Shorten Execute to Exec

batch.go

@@ -7,18 +7,18 @@ import (
 
 // Batch is a batch of queries.
 type Batch interface {
- // Execute executes each query in order.
- Execute() error
+ // Exec executes each query in order.
+ Exec() error
 
- // ExecuteTx executes each query in order. It puts the first
- // result row in results. If successful, it returns true and an Iterator
- // that ranges over the conditional statement results.
- ExecuteTx(results ...interface{}) (bool, Iterator, error)
+ // ExecTx executes each query in order. It puts the first result row in results.
+ // If successful, it returns true and an Iterator that ranges over the
+ // conditional statement results.
+ ExecTx(results ...interface{}) (bool, Iterator, error)
 
- // ExecuteTxMap executes each query in order. It puts the first
- // result row in results. If successful, it returns true and an Iterator
- // that ranges over the conditional statement results.
- ExecuteTxMap(results map[string]interface{}) (bool, Iterator, error)
+ // ExecTxMap executes each query in order. It puts the first result row in
+ // results. If successful, it returns true and an Iterator that ranges over the
+ // conditional statement results.
+ ExecTxMap(results map[string]interface{}) (bool, Iterator, error)
 
  // Query adds the query for statement and arguments.
  Query(statement string, arguments ...interface{})
@@ -44,20 +44,20 @@ type BatchMock struct {
  mock.Mock
 }
 
-// Execute implements Batch.
-func (m BatchMock) Execute() error {
+// Exec implements Batch.
+func (m BatchMock) Exec() error {
  return m.Called().Error(0)
 }
 
-// ExecuteTx implements Batch.
-func (m BatchMock) ExecuteTx(results ...interface{}) (bool, Iterator, error) {
+// ExecTx implements Batch.
+func (m BatchMock) ExecTx(results ...interface{}) (bool, Iterator, error) {
  var r = m.Called(results)
 
  return r.Bool(0), r.Get(1).(Iterator), r.Error(2)
 }
 
-// ExecuteTxMap implements Batch.
-func (m BatchMock) ExecuteTxMap(results map[string]interface{}) (bool, Iterator, error) {
+// ExecTxMap implements Batch.
+func (m BatchMock) ExecTxMap(results map[string]interface{}) (bool, Iterator, error) {
  var r = m.Called(results)
 
  return r.Bool(0), r.Get(1).(Iterator), r.Error(2)
@@ -74,11 +74,11 @@ type batch struct {
  s *gocql.Session
 }
 
-func (b batch) Execute() error {
+func (b batch) Exec() error {
  return b.s.ExecuteBatch(b.b)
 }
 
-func (b batch) ExecuteTx(results ...interface{}) (bool, Iterator, error) {
+func (b batch) ExecTx(results ...interface{}) (bool, Iterator, error) {
  var a, i, err = b.s.ExecuteBatchCAS(b.b, results...)
 
  if err != nil {
@@ -88,7 +88,7 @@ func (b batch) ExecuteTx(results ...interface{}) (bool, Iterator, error) {
  return a, iterator{i: i}, nil
 }
 
-func (b batch) ExecuteTxMap(results map[string]interface{}) (bool, Iterator, error) {
+func (b batch) ExecTxMap(results map[string]interface{}) (bool, Iterator, error) {
  var a, i, err = b.s.MapExecuteBatchCAS(b.b, results)
 
  if err != nil {

batch_test.go

@@ -9,7 +9,7 @@ func TestBatch(t *testing.T) {
  var s = newSession(t)
 
  var exec = func(q string) {
- if err := s.QueryExecute(q); err != nil {
+ if err := s.QueryExec(q); err != nil {
  t.Errorf("Actual error %v, expected no error", err)
  }
  }
@@ -19,7 +19,7 @@ func TestBatch(t *testing.T) {
  exec(tabCreate)
  exec(rowInsert)
 
- // Execute
+ // Exec
  var b = s.QueryBatch(BatchKind(0))
 
  if b == nil {
@@ -28,17 +28,17 @@ func TestBatch(t *testing.T) {
 
  b.Query("update gockle_test.test set n = 3 where id = 1 if n = 2")
 
- if err := b.Execute(); err != nil {
+ if err := b.Exec(); err != nil {
  t.Errorf("Actual error %v, expected no error", err)
  }
 
- // ExecuteTx
+ // ExecTx
  b = s.QueryBatch(BatchKind(0))
  b.Query("update gockle_test.test set n = 4 where id = 1 if n = 3")
 
  var id, n int
 
- if b, i, err := b.ExecuteTx(&id, &n); err == nil {
+ if b, i, err := b.ExecTx(&id, &n); err == nil {
  if id != 0 {
  t.Errorf("Actual id %v, expected 0", id)
  }
@@ -62,13 +62,13 @@ func TestBatch(t *testing.T) {
  t.Errorf("Actual error %v, expected no error", err)
  }
 
- // ExecuteTxMap
+ // ExecTxMap
  b = s.QueryBatch(BatchKind(0))
  b.Query("update gockle_test.test set n = 5 where id = 1 if n = 4")
 
  var m = map[string]interface{}{}
 
- if b, i, err := b.ExecuteTxMap(m); err == nil {
+ if b, i, err := b.ExecTxMap(m); err == nil {
  if l := len(m); l > 0 {
  t.Errorf("Actual length %v, expected 0", l)
  }
@@ -102,11 +102,11 @@ func TestBatchMock(t *testing.T) {
  arguments []interface{}
  results []interface{}
  }{
- {"Execute", nil, []interface{}{nil}},
- {"Execute", nil, []interface{}{e}},
- {"ExecuteTx", []interface{}{[]interface{}(nil)}, []interface{}{false, (*iterator)(nil), nil}},
- {"ExecuteTx", []interface{}{[]interface{}{1}}, []interface{}{true, &iterator{}, e}},
- {"ExecuteTxMap", []interface{}{map[string]interface{}(nil)}, []interface{}{false, (*iterator)(nil), nil}},
- {"ExecuteTxMap", []interface{}{map[string]interface{}{"a": 1}}, []interface{}{true, &iterator{}, e}},
+ {"Exec", nil, []interface{}{nil}},
+ {"Exec", nil, []interface{}{e}},
+ {"ExecTx", []interface{}{[]interface{}(nil)}, []interface{}{false, (*iterator)(nil), nil}},
+ {"ExecTx", []interface{}{[]interface{}{1}}, []interface{}{true, &iterator{}, e}},
+ {"ExecTxMap", []interface{}{map[string]interface{}(nil)}, []interface{}{false, (*iterator)(nil), nil}},
+ {"ExecTxMap", []interface{}{map[string]interface{}{"a": 1}}, []interface{}{true, &iterator{}, e}},
  })
 }

readme.md

@@ -25,9 +25,9 @@ A `gocql.Batch` method has a counterpart in `Batch`:
 
 Some `gocql.Session` methods have counterparts in `Batch`:
 
-- `gocql.Session.ExecuteBatch`: `Batch.Execute`
-- `gocql.Session.ExecuteBatchCAS`: `Batch.ExecuteTx`
-- `gocql.Session.MapExecuteBatchCAS`: `Batch.ExecuteTxMap`
+- `gocql.Session.ExecuteBatch`: `Batch.Exec`
+- `gocql.Session.ExecuteBatchCAS`: `Batch.ExecTx`
+- `gocql.Session.MapExecuteBatchCAS`: `Batch.ExecTxMap`
 
 Some `gocql.Session` methods have counterparts in `Session`:
 
@@ -36,7 +36,7 @@ Some `gocql.Session` methods have counterparts in `Session`:
 
 Some `gocql.Query` methods have counterparts in `Session`:
 
-- `gocql.Query.Exec`: `Session.QueryExecute`
+- `gocql.Query.Exec`: `Session.QueryExec`
 - `gocql.Query.MapScan`: `Session.QueryScanMap`
 - `gocql.Query.MapScanCAS`: `Session.QueryScanMapTx`
 - `gocql.Query.Scan`: `Session.QueryScan`
@@ -59,7 +59,7 @@ Insert a row:
 
  var s = NewSession(...)
 
- if err := s.QueryExecute("insert into users (id, name) values (123, 'me')"); err != nil {
+ if err := s.QueryExec("insert into users (id, name) values (123, 'me')"); err != nil {
   return err
  }
 

session.go

@@ -19,8 +19,8 @@ type Session interface {
  // QueryBatch returns a Batch with type kind for batched queries.
  QueryBatch(kind BatchKind) Batch
 
- // QueryExecute runs statement with arguments.
- QueryExecute(statement string, arguments ...interface{}) error
+ // QueryExec runs statement with arguments.
+ QueryExec(statement string, arguments ...interface{}) error
 
  // QueryIterate runs statement with arguments and returns an Iterator for
  // the results.
@@ -33,9 +33,9 @@ type Session interface {
  // in results.
  QueryScanMap(statement string, arguments []interface{}, results map[string]interface{}) error
 
- // QueryScanMapTx runs statement with arguments as a lightweight
- // transaction and puts the first result row in results. It returns whether
- // the transaction succeeded. If not, it puts the old values in results.
+ // QueryScanMapTx runs statement with arguments as a lightweight transaction and
+ // puts the first result row in results. It returns whether the transaction
+ // succeeded. If not, it puts the old values in results.
  QueryScanMapTx(statement string, arguments []interface{}, results map[string]interface{}) (bool, error)
 
  // QuerySliceMap runs statement with arguments and returns all result rows.
@@ -75,8 +75,8 @@ func (m SessionMock) QueryBatch(kind BatchKind) Batch {
  return m.Called(kind).Get(0).(Batch)
 }
 
-// QueryExecute implements Session.
-func (m SessionMock) QueryExecute(statement string, arguments ...interface{}) error {
+// QueryExec implements Session.
+func (m SessionMock) QueryExec(statement string, arguments ...interface{}) error {
  return m.Called(statement, arguments).Error(0)
 }
 
@@ -150,7 +150,7 @@ func (s session) QueryBatch(kind BatchKind) Batch {
  return batch{b: s.s.NewBatch(gocql.BatchType(kind)), s: s.s}
 }
 
-func (s session) QueryExecute(statement string, arguments ...interface{}) error {
+func (s session) QueryExec(statement string, arguments ...interface{}) error {
  return s.s.Query(statement, arguments...).Exec()
 }
 

session_test.go

@@ -48,7 +48,7 @@ func TestNewSession(t *testing.T) {
 
 func TestSessionMetadata(t *testing.T) {
  var exec = func(s Session, q string) {
- if err := s.QueryExecute(q); err != nil {
+ if err := s.QueryExec(q); err != nil {
  t.Errorf("Actual error %v, expected no error", err)
  }
  }
@@ -108,8 +108,8 @@ func TestSessionMock(t *testing.T) {
  {"Columns", []interface{}{"a", "b"}, []interface{}{map[string]gocql.TypeInfo{"c": gocql.NativeType{}}, e}},
  {"QueryBatch", []interface{}{BatchKind(0)}, []interface{}{(*batch)(nil)}},
  {"QueryBatch", []interface{}{BatchKind(1)}, []interface{}{&batch{}}},
- {"QueryExecute", []interface{}{"", []interface{}(nil)}, []interface{}{nil}},
- {"QueryExecute", []interface{}{"a", []interface{}{1}}, []interface{}{e}},
+ {"QueryExec", []interface{}{"", []interface{}(nil)}, []interface{}{nil}},
+ {"QueryExec", []interface{}{"a", []interface{}{1}}, []interface{}{e}},
  {"QueryIterate", []interface{}{"", []interface{}(nil)}, []interface{}{(*iterator)(nil)}},
  {"QueryIterate", []interface{}{"a", []interface{}{1}}, []interface{}{iterator{}}},
  {"QueryScan", []interface{}{"", []interface{}(nil), []interface{}(nil)}, []interface{}{nil}},
@@ -129,7 +129,7 @@ func TestSessionQuery(t *testing.T) {
  var s = newSession(t)
 
  var exec = func(q string) {
- if err := s.QueryExecute(q); err != nil {
+ if err := s.QueryExec(q); err != nil {
  t.Errorf("Actual error %v, expected no error", err)
  }
  }