Merge pull request #23 from twharmon/transactions

Fix transaction approach

count_query.go

@@ -1,13 +1,20 @@
 package gosql
 
 import (
+	"database/sql"
 	"fmt"
 	"strings"
 )
 
+// QueryRower .
+type QueryRower interface {
+	QueryRow(query string, args ...interface{}) *sql.Row
+}
+
 // CountQuery is a query for counting rows in a table.
 type CountQuery struct {
 	db         *DB
+	queryRower QueryRower
 	count      string
 	table      string
 	joins      []string
@@ -55,7 +62,7 @@ func (cq *CountQuery) LeftJoin(join string) *CountQuery {
 // Exec executes the query.
 func (cq *CountQuery) Exec() (int64, error) {
 	var count int64
-	row := cq.db.db.QueryRow(cq.String(), cq.whereArgs...)
+	row := cq.queryRower.QueryRow(cq.String(), cq.whereArgs...)
 	err := row.Scan(&count)
 	return count, err
 }

db.go

@@ -139,6 +139,7 @@ func (db *DB) QueryRow(query string, args ...interface{}) *sql.Row {
 func (db *DB) Select(fields ...string) *SelectQuery {
 	sq := new(SelectQuery)
 	sq.db = db
+	sq.querier = db.db
 	sq.fields = fields
 	return sq
 }
@@ -147,6 +148,7 @@ func (db *DB) Select(fields ...string) *SelectQuery {
 func (db *DB) ManualUpdate(table string) *UpdateQuery {
 	uq := new(UpdateQuery)
 	uq.db = db
+	uq.execer = db.db
 	uq.table = table
 	return uq
 }
@@ -155,6 +157,7 @@ func (db *DB) ManualUpdate(table string) *UpdateQuery {
 func (db *DB) Count(table string, count string) *CountQuery {
 	cq := new(CountQuery)
 	cq.db = db
+	cq.queryRower = db.db
 	cq.table = table
 	cq.count = count
 	return cq
@@ -164,6 +167,7 @@ func (db *DB) Count(table string, count string) *CountQuery {
 func (db *DB) ManualDelete(table string) *DeleteQuery {
 	dq := new(DeleteQuery)
 	dq.db = db
+	dq.execer = db.db
 	dq.table = table
 	return dq
 }

db_test.go

@@ -79,6 +79,21 @@ func TestInsertWithPrimary(t *testing.T) {
 	check(t, mock.ExpectationsWereMet())
 }
 
+func TestInsertWithAllFieldsPrimary(t *testing.T) {
+	db, mock, err := getMockDB()
+	check(t, err)
+	type T struct {
+		ID   int    `gosql:"primary"`
+		Name string `gosql:"primary"`
+	}
+	check(t, db.Register(T{}))
+	model := T{5, "foo"}
+	mock.ExpectExec(`^insert into t \(id, name\) values \(\?, \?\)$`).WithArgs(model.ID, model.Name).WillReturnResult(sqlmock.NewResult(0, 1))
+	_, err = db.Insert(&model)
+	check(t, err)
+	check(t, mock.ExpectationsWereMet())
+}
+
 func ExampleDB_Insert() {
 	os.Remove("/tmp/foo.db")
 	sqliteDB, _ := sql.Open("sqlite3", "/tmp/foo.db")

delete_query.go

@@ -9,6 +9,7 @@ import (
 // DeleteQuery is a query for deleting rows from a table.
 type DeleteQuery struct {
 	db        *DB
+	execer    Execer
 	table     string
 	joins     []string
 	wheres    []*where
@@ -51,7 +52,7 @@ func (dq *DeleteQuery) LeftJoin(join string) *DeleteQuery {
 
 // Exec executes the query.
 func (dq *DeleteQuery) Exec() (sql.Result, error) {
-	return dq.db.db.Exec(dq.String(), dq.whereArgs...)
+	return dq.execer.Exec(dq.String(), dq.whereArgs...)
 }
 
 // String returns the string representation of DeleteQuery.

model.go

@@ -41,7 +41,7 @@ func (m *model) getInsertQuery(v reflect.Value) string {
 		if i == len(m.fields)-1 {
 			query.WriteString(") ")
 			values.WriteString(")")
-		} else if !isIntIn(i+1, m.primaryFieldIndecies) || !isIntIn(len(m.fields)-1, m.primaryFieldIndecies) {
+		} else if !isIntIn(i+1, m.primaryFieldIndecies) || !isIntIn(len(m.fields)-1, m.primaryFieldIndecies) || !v.Field(i).IsZero() {
 			query.WriteString(", ")
 			values.WriteString(", ")
 		}

select_query.go

@@ -1,6 +1,7 @@
 package gosql
 
 import (
+	"database/sql"
 	"errors"
 	"fmt"
 	"reflect"
@@ -18,9 +19,15 @@ type having struct {
 	condition   string
 }
 
+// Querier .
+type Querier interface {
+	Query(query string, args ...interface{}) (*sql.Rows, error)
+}
+
 // SelectQuery holds information for a select query.
 type SelectQuery struct {
 	db         *DB
+	querier    Querier
 	model      *model
 	fields     []string
 	joins      []string
@@ -168,7 +175,7 @@ func (sq *SelectQuery) toOne(out interface{}) error {
 	}
 	args := sq.whereArgs
 	args = append(args, sq.havingArgs...)
-	rows, err := sq.db.db.Query(sq.String(), args...)
+	rows, err := sq.querier.Query(sq.String(), args...)
 	if err != nil {
 		return err
 	}
@@ -196,7 +203,7 @@ func (sq *SelectQuery) toMany(sliceType reflect.Type, outs interface{}) error {
 	sq.many = true
 	args := sq.whereArgs
 	args = append(args, sq.havingArgs...)
-	rows, err := sq.db.db.Query(sq.String(), args...)
+	rows, err := sq.querier.Query(sq.String(), args...)
 	if err != nil {
 		return err
 	}
@@ -231,7 +238,7 @@ func (sq *SelectQuery) toManyValues(sliceType reflect.Type, outs interface{}) er
 	sq.many = true
 	args := sq.whereArgs
 	args = append(args, sq.havingArgs...)
-	rows, err := sq.db.db.Query(sq.String(), args...)
+	rows, err := sq.querier.Query(sq.String(), args...)
 	if err != nil {
 		return err
 	}

tx.go

@@ -0,0 +1,108 @@
+package gosql
+
+import (
+	"database/sql"
+	"reflect"
+)
+
+// Tx .
+type Tx struct {
+	tx *sql.Tx
+	db *DB
+}
+
+// Commit .
+func (t *Tx) Commit() error {
+	return t.tx.Commit()
+}
+
+// Rollback .
+func (t *Tx) Rollback() error {
+	return t.tx.Rollback()
+}
+
+// Insert insterts a row in the database.
+func (t *Tx) Insert(obj interface{}) (sql.Result, error) {
+	m, err := t.db.getModelOf(obj)
+	if err != nil {
+		return nil, err
+	}
+	v := reflect.ValueOf(obj).Elem()
+	return t.tx.Exec(m.getInsertQuery(v), m.getArgs(v)...)
+}
+
+// Update updates a row in the database.
+func (t *Tx) Update(obj interface{}) (sql.Result, error) {
+	m, err := t.db.getModelOf(obj)
+	if err != nil {
+		return nil, err
+	}
+	v := reflect.ValueOf(obj).Elem()
+	return t.tx.Exec(m.getUpdateQuery(), m.getArgsPrimaryLast(v)...)
+}
+
+// Delete deletes a row from the database.
+func (t *Tx) Delete(obj interface{}) (sql.Result, error) {
+	m, err := t.db.getModelOf(obj)
+	if err != nil {
+		return nil, err
+	}
+	v := reflect.ValueOf(obj).Elem()
+	var inserts []interface{}
+	for _, i := range m.primaryFieldIndecies {
+		inserts = append(inserts, v.Field(i).Interface())
+	}
+	return t.tx.Exec(m.getDeleteQuery(), inserts...)
+}
+
+// Exec is a wrapper around sql.DB.Exec().
+func (t *Tx) Exec(query string, args ...interface{}) (sql.Result, error) {
+	return t.tx.Exec(query, args...)
+}
+
+// Query is a wrapper around sql.DB.Query().
+func (t *Tx) Query(query string, args ...interface{}) (*sql.Rows, error) {
+	return t.tx.Query(query, args...)
+}
+
+// QueryRow is a wrapper around sql.DB.QueryRow().
+func (t *Tx) QueryRow(query string, args ...interface{}) *sql.Row {
+	return t.tx.QueryRow(query, args...)
+}
+
+// Select selects columns of a table.
+func (t *Tx) Select(fields ...string) *SelectQuery {
+	sq := new(SelectQuery)
+	sq.db = t.db
+	sq.querier = t.tx
+	sq.fields = fields
+	return sq
+}
+
+// ManualUpdate starts a query for manually updating rows in a table.
+func (t *Tx) ManualUpdate(table string) *UpdateQuery {
+	uq := new(UpdateQuery)
+	uq.db = t.db
+	uq.execer = t.tx
+	uq.table = table
+	return uq
+}
+
+// Count starts a query for counting rows in a table.
+func (t *Tx) Count(table string, count string) *CountQuery {
+	cq := new(CountQuery)
+	cq.db = t.db
+	cq.queryRower = t.tx
+	cq.table = table
+	cq.count = count
+	return cq
+}
+
+// ManualDelete starts a query for manually deleting rows in a table.
+func (t *Tx) ManualDelete(table string) *DeleteQuery {
+	dq := new(DeleteQuery)
+	dq.db = t.db
+	dq.execer = t.tx
+	dq.table = table
+	return dq
+}

update_query.go

@@ -9,6 +9,7 @@ import (
 // UpdateQuery holds information for an update query.
 type UpdateQuery struct {
 	db        *DB
+	execer    Execer
 	table     string
 	joins     []string
 	wheres    []*where
@@ -17,6 +18,11 @@ type UpdateQuery struct {
 	setArgs   []interface{}
 }
 
+// Execer .
+type Execer interface {
+	Exec(query string, args ...interface{}) (sql.Result, error)
+}
+
 // Where specifies which rows will be returned.
 func (uq *UpdateQuery) Where(condition string, args ...interface{}) *UpdateQuery {
 	w := &where{
@@ -62,7 +68,7 @@ func (uq *UpdateQuery) LeftJoin(join string) *UpdateQuery {
 func (uq *UpdateQuery) Exec() (sql.Result, error) {
 	args := uq.setArgs
 	args = append(args, uq.whereArgs...)
-	return uq.db.db.Exec(uq.String(), args...)
+	return uq.execer.Exec(uq.String(), args...)
 }
 
 // String returns the string representation of UpdateQuery.