fix tx support and only keep the optimized api

Author: free1139

README.md

@@ -63,16 +63,13 @@ mdb := db.GetCache("master")
 mdb := db.GetCache("master") 
 // or mdb = <sql.Tx>
 
-// row := mdb.QueryRow("SELECT * ...")
-row := qsql.QueryRow(mdb, "SELECT * ...")
+row := mdb.QueryRow("SELECT * ...")
 // ...
 
-// rows, err := mdb.Query("SELECT * ...")
-rows, err := qsql.Query(mdb, "SELECT * ...")
+rows, err := mdb.Query("SELECT * ...")
 // ...
 
-// result, err := mdb.Exec("UPDATE ...")
-result, err := qsql.Exec(mdb, "UPDATE ...")
+result, err := mdb.Exec("UPDATE ...")
 // ...
 ```
 
@@ -209,30 +206,21 @@ if err != nil {
 }
 ```
 
-## Make a MultiTx
+## Make a lazy tx commit
 ``` text
-multiTx := []*qsql.MultiTx{}
-multiTx = append(multiTx, qsql.NewMultiTx(
-    "UPDATE testing SET name = ? WHERE id = ?",
-    id,
-))
-multiTx = append(multiTx, qsql.NewMultiTx(
-    "UPDATE testing SET name = ? WHERE id = ?",
-    id,
-))
-
-// do exec multi tx
+// commit the tx
 mdb := db.GetCache("master") 
 tx, err := mdb.Begin()
 if err != nil{
     // ...
 }
-if err := qsql.ExecMutlTx(tx, multiTx); err != nil {
-    qsql.Rollback(tx)
-    // ...
+fn := func() error {
+  if err := tx.Exec("UPDATE testing SET name = ? WHERE id = ?", id); err != nil{
+    return err
+  }
+  return nil
 }
-if err := tx.Commit(); err != nil {
-    qsql.Rollback(tx)
+if err := qsql.Commit(tx, fn); err != nil {
     // ...
 }
 ```

api.go

@@ -85,28 +85,23 @@ func Close(closer io.Closer) {
 
 // A lazy function to rollback the *sql.Tx
 func Rollback(tx *sql.Tx) {
-	err := tx.Rollback()
-
-	// roll back error is a serious error
-	if err != nil {
+	if err := tx.Rollback(); err != nil {
+		// roll back error is a serious error
 		log.Error(errors.As(err))
 	}
 }
 
-// A way implement the sql.Exec
-func Exec(db Execer, querySql string, args ...interface{}) (sql.Result, error) {
-	return db.Exec(querySql, args...)
-}
-func ExecContext(db Execer, ctx context.Context, querySql string, args ...interface{}) (sql.Result, error) {
-	return db.ExecContext(ctx, querySql, args...)
-}
-
-// A way to ran multiply tx
-func ExecMultiTx(tx *sql.Tx, mTx []*MultiTx) error {
-	return execMultiTx(tx, context.TODO(), mTx)
-}
-func ExecMultiTxContext(tx *sql.Tx, ctx context.Context, mTx []*MultiTx) error {
-	return execMultiTx(tx, ctx, mTx)
+// A lazy function to commit the *sql.Tx
+// if will auto commit when the function is nil error, or do a rollback and return the function error.
+func Commit(tx *sql.Tx, fn func() error) error {
+	if err := fn(); err != nil {
+		Rollback(tx)
+		return err
+	}
+	if err := tx.Commit(); err != nil {
+		return err
+	}
+	return nil
 }
 
 // Reflect one db data to the struct. the struct tag format like `db:"field_title"`, reference to: http://github.com/jmoiron/sqlx
@@ -118,22 +113,6 @@ func InsertStructContext(exec Execer, ctx context.Context, obj interface{}, tbNa
 	return insertStruct(exec, ctx, obj, tbName, drvName...)
 }
 
-// A sql.Query implements
-func Query(db Queryer, querySql string, args ...interface{}) (*sql.Rows, error) {
-	return db.Query(querySql, args...)
-}
-func QueryContext(db Queryer, ctx context.Context, querySql string, args ...interface{}) (*sql.Rows, error) {
-	return db.QueryContext(ctx, querySql, args...)
-}
-
-// A sql.QueryRow implements
-func QueryRow(db Queryer, querySql string, args ...interface{}) *sql.Row {
-	return db.QueryRow(querySql, args...)
-}
-func QueryRowContext(db Queryer, ctx context.Context, querySql string, args ...interface{}) *sql.Row {
-	return db.QueryRowContext(ctx, querySql, args...)
-}
-
 // Relect the sql.Rows to a struct.
 func ScanStruct(rows Rows, obj interface{}) error {
 	return scanStruct(rows, obj)

example/qsql.go

@@ -19,7 +19,7 @@ func main() {
 	defer qsql.Close(mdb)
 
 	// create table
-	if _, err := qsql.Exec(mdb,
+	if _, err := mdb.Exec(
 		`CREATE TABLE user (
 		  "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
 		  "created_at" datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
@@ -30,7 +30,7 @@ func main() {
 	}
 
 	// std insert
-	if _, err := qsql.Exec(mdb, "INSERT INTO user(username,passwd)VALUES(?,?)", "t1", "t1"); err != nil {
+	if _, err := mdb.Exec("INSERT INTO user(username,passwd)VALUES(?,?)", "t1", "t1"); err != nil {
 		panic(err)
 	}
 
@@ -46,7 +46,7 @@ func main() {
 	// std query
 	var id int64
 	var username, passwd string
-	if err := qsql.QueryRow(mdb, "SELECT id, username, passwd FROM user WHERE username=?", "t1").Scan(&id, &username, &passwd); err != nil {
+	if err := mdb.QueryRow("SELECT id, username, passwd FROM user WHERE username=?", "t1").Scan(&id, &username, &passwd); err != nil {
 		panic(err)
 	}
 	if username != "t1" && passwd != "t1" {
@@ -124,24 +124,23 @@ func main() {
 	if err != nil {
 		panic(err)
 	}
-	txUsers := []TestingUser{
-		{UserName: "t3", Passwd: "t3"},
-		{UserName: "t4", Passwd: "t4"},
-	}
-	for _, u := range txUsers {
-		if _, err := qsql.InsertStruct(tx, &u, "user"); err != nil {
-			println(errors.As(err))
-			qsql.Rollback(tx)
-			return
+	if err := qsql.Commit(tx, func() error {
+		txUsers := []TestingUser{
+			{UserName: "t3", Passwd: "t3"},
+			{UserName: "t4", Passwd: "t4"},
 		}
-	}
-	if err := tx.Commit(); err != nil {
-		println(errors.As(err))
-		qsql.Rollback(tx)
-		return
+		for _, u := range txUsers {
+			if _, err := qsql.InsertStruct(tx, &u, "user"); err != nil {
+				return errors.As(err)
+			}
+		}
+		return nil
+	}); err != nil {
+		panic(err)
 	}
 
 	// excute for stmt
+	// TODO: more stmt optimization
 	stmt, err := mdb.Prepare("SELECT COUNT(*) FROM user WHERE username=?")
 	count := 0
 	if err := stmt.QueryRow("t3").Scan(&count); err != nil {

qsql.go

@@ -10,15 +10,6 @@ import (
 	"github.com/jmoiron/sqlx/reflectx"
 )
 
-type MultiTx struct {
-	Query string
-	Args  []interface{}
-}
-
-func NewMultiTx(query string, args ...interface{}) *MultiTx {
-	return &MultiTx{query, args}
-}
-
 const (
 	addObjSql = "INSERT INTO %s (%s) VALUES (%s);"
 )
@@ -73,15 +64,6 @@ func insertStruct(exec Execer, ctx context.Context, obj interface{}, tbName stri
 	return result, nil
 }
 
-func execMultiTx(tx *sql.Tx, ctx context.Context, mTx []*MultiTx) error {
-	for _, mt := range mTx {
-		if _, err := tx.ExecContext(ctx, mt.Query, mt.Args...); err != nil {
-			return errors.As(err)
-		}
-	}
-	return nil
-}
-
 // fieldsByName fills a values interface with fields from the passed value based
 // on the traversals in int.  If ptrs is true, return addresses instead of values.
 // We write this instead of using FieldsByName to save allocations and map lookups