Merge pull request #2 from gwaylib/shu.dev

Remove unused code and rebuild page sql

Author: free1139

api.go

@@ -81,7 +81,7 @@ type QuickSql interface {
 	// fmt.Sprintf("select * from table_name where id=? in (%s)", qsql.StmtWhereIn(1,len(args))
 	//
 	// Return "?,?,?,?..." for default, or "@p1,@p2,@p3..." for mssql, or ":1,:2,:3..." for pgsql when paramStartIdx is 0.
-	MakeStmtIn(paramStartIdx, paramLen int) string
+	StmtIn(paramStartIdx, paramLen int) string
 
 	// auto commit when the func is return nil, or auto rollback when the func is error
 	Commit(tx *sql.Tx, fn func() error) error

api_page.go

@@ -1,132 +1,69 @@
-//
 // Example:
 //
-// qSql = &qsql.Page{
-//      CountSql:`SELECT count(1) FROM user_info WHERE create_time >= ? AND create_time <= ?`,
-//      DataSql:`SELECT mobile, balance FROM user_info WHERE create_time >= ? AND create_time <= ?`
-// }
-// count, titles, result, err := qSql.QueryPageArray(db, true, condition, 0, 10)
+// mdb := db.GetCache("main")
+//
+// // count sql
+// cbd := NewSqlBuilder(mdb.DriverName())
+// cbd.Select("COUNT(*)")
+// cbd.Add("FROM tmp")
+// cbd.Add("WHERE")
+// cbd.AddTab("create_at BETWEEN ? AND ?", time.Now().AddDate(-1,0,0), time.Now())
+//
+// // copy condition
+// qbd := cbd.Copy()
+// qbd.Select("id", "created_at", "name")
+// qbd.Add("OFFSET ?", 0)
+// qbd.Add("LIMIT ?", 20)
+//
+// pSql := NewPageSql(cbd, qbd)
+// count, err := pSql.QueryCount(db)
 // ...
 // Or
-// count, titles, result, err := qSql.QueryPageMap(db, true, condtion, 0, 10)
+// titles, result, err := pSql.QueryPageArray(db)
 // ...
-// if err != nil {
+// Or
+// titles, result, err := pSql.QueryPageMap(db)
 // ...
-// }
-//
 package qsql
 
 import (
 	"context"
-	"fmt"
 
 	"github.com/gwaylib/errors"
 )
 
-type PageArgs struct {
-	args   []interface{}
-	offset int64
-	limit  int64
-}
-
-func NewPageArgs(args ...interface{}) *PageArgs {
-	return &PageArgs{
-		args: args,
-	}
-}
-
-// using offset and limit when limit is set.
-func (p *PageArgs) Limit(offset, limit int64) *PageArgs {
-	p.offset = offset
-	p.limit = limit
-	return p
-}
-
 type PageSql struct {
-	countSql string
-	dataSql  string
+	countBD *SqlBuilder
+	queryBD *SqlBuilder
 }
 
-func NewPageSql(countSql, dataSql string) *PageSql {
-	if len(countSql) == 0 {
-		panic("countSql not set")
-	}
-	if len(dataSql) == 0 {
-		panic("dataSql not set")
-	}
+func NewPageSql(countBD, queryBD *SqlBuilder) *PageSql {
 	return &PageSql{
-		countSql: countSql,
-		dataSql:  dataSql,
+		countBD: countBD,
+		queryBD: queryBD,
 	}
 }
 
-func (p PageSql) CountSql() string {
-	return p.countSql
-}
-func (p PageSql) DataSql() string {
-	return p.dataSql
-}
-
-// fill the page sql with fmt arg, and return a new page
-// Typically used for table name formatting
-func (p PageSql) FmtPage(args ...interface{}) PageSql {
-	countSql := p.countSql
-	if len(countSql) > 0 {
-		countSql = fmt.Sprintf(p.countSql, args...)
-	}
-	dataSql := p.dataSql
-	if len(dataSql) > 0 {
-		dataSql = fmt.Sprintf(p.dataSql, args...)
-	}
-
-	return PageSql{
-		countSql: countSql,
-		dataSql:  dataSql,
-	}
-}
-
-func (p *PageSql) QueryCount(db *DB, args ...interface{}) (int64, error) {
+func (p *PageSql) QueryCount(db *DB) (int64, error) {
 	count := int64(0)
-	if err := queryElem(db, context.TODO(), &count, p.countSql, args...); err != nil {
+	if err := queryElem(db, context.TODO(), &count, p.countBD.String(), p.countBD.Args()...); err != nil {
 		return 0, errors.As(err)
 	}
 	return count, nil
 }
 
-func (p *PageSql) QueryPageArr(db *DB, doCount bool, args *PageArgs) (int64, []string, [][]interface{}, error) {
-	total := int64(0)
-	dataArgs := args.args
-	if args.limit > 0 {
-		dataArgs = append(dataArgs, []interface{}{args.offset, args.limit}...)
-	}
-	titles, data, err := queryPageArr(db, context.TODO(), p.dataSql, dataArgs...)
+func (p *PageSql) QueryPageArr(db *DB) ([]string, [][]interface{}, error) {
+	titles, data, err := queryPageArr(db, context.TODO(), p.queryBD.String(), p.queryBD.Args()...)
 	if err != nil {
-		return total, nil, nil, errors.As(err)
-	} else if doCount {
-		count, err := p.QueryCount(db, args.args...)
-		if err != nil {
-			return total, nil, nil, errors.As(err)
-		}
-		total = count
+		return nil, nil, errors.As(err)
 	}
-	return total, titles, data, nil
+	return titles, data, nil
 }
 
-func (p *PageSql) QueryPageMap(db *DB, doCount bool, args *PageArgs) (int64, []string, []map[string]interface{}, error) {
-	total := int64(0)
-	dataArgs := args.args
-	if args.limit > 0 {
-		dataArgs = append(dataArgs, []interface{}{args.offset, args.limit}...)
-	}
-	title, data, err := queryPageMap(db, context.TODO(), p.dataSql, dataArgs...)
+func (p *PageSql) QueryPageMap(db *DB) ([]string, []map[string]interface{}, error) {
+	titles, data, err := queryPageMap(db, context.TODO(), p.queryBD.String(), p.queryBD.Args()...)
 	if err != nil {
-		return total, nil, nil, errors.As(err)
-	} else if doCount {
-		count, err := p.QueryCount(db, args.args...)
-		if err != nil {
-			return total, nil, nil, errors.As(err)
-		}
-		total = count
+		return nil, nil, errors.As(err)
 	}
-	return total, title, data, nil
+	return titles, data, nil
 }

db.go

@@ -112,7 +112,7 @@ func (db *DB) QueryPageMapContext(ctx context.Context, querySql string, args ...
 
 // Return "?,?,?,?..." for default, or "@p1,@p2,@p3..." for mssql, or ":1,:2,:3..." for pgsql.
 // paramStartIdx default is 0, but you need count it when the driver is mssq, pgsql etc. .
-func (db *DB) MakeStmtIn(paramStartIdx, paramsLen int) string {
+func (db *DB) StmtIn(paramStartIdx, paramsLen int) string {
 	return stmtIn(paramStartIdx, paramsLen, db.DriverName())
 }
 

stmt_in.go

@@ -2,7 +2,6 @@ package qsql
 
 import (
 	"fmt"
-	"reflect"
 )
 
 func stmtIn(paramIdx, paramsLen int, driverNames ...string) string {
@@ -46,20 +45,3 @@ func stmtIn(paramIdx, paramsLen int, driverNames ...string) string {
 		return string(result)
 	}
 }
-
-func StmtSliceArgs(args ...interface{}) []interface{} {
-	result := []interface{}{}
-	for _, arg := range args {
-		val := reflect.ValueOf(arg)
-		switch val.Kind() {
-		case reflect.Array, reflect.Slice:
-			arrLen := val.Len()
-			for i := 0; i < arrLen; i++ {
-				result = append(result, val.Index(i).Interface())
-			}
-		default:
-			result = append(result, arg)
-		}
-	}
-	return result
-}

stmt_in_test.go

@@ -24,18 +24,3 @@ func TestStmtIn(t *testing.T) {
 		t.Fatalf("expect '@p1,@p2,@p3', but@ %s", msOutput1)
 	}
 }
-
-func TestStmtSliceArgs(t *testing.T) {
-	in := []string{"a", "b", "c"}
-	out := StmtSliceArgs(in)
-	if len(out) != 3 {
-		t.Fatalf("expect 3, but:%d", len(out))
-	}
-	arg1, ok := out[0].(string)
-	if !ok {
-		t.Fatal("expect string, but not")
-	}
-	if arg1 != "a" {
-		t.Fatalf("expect 'a' , but: %s ", arg1)
-	}
-}

type.go

@@ -1,76 +1,11 @@
 package qsql
 
 import (
-	"database/sql"
-	"database/sql/driver"
 	"fmt"
 	"strconv"
 	"time"
 )
 
-// Bool type
-type Bool bool
-
-func (v *Bool) Scan(i interface{}) error {
-	b := sql.NullBool{}
-	if err := b.Scan(i); err != nil {
-		return err
-	}
-	*v = Bool(b.Bool)
-	return nil
-}
-func (v *Bool) Value() (driver.Value, error) {
-	return v, nil
-}
-
-// Int64 type
-type Int64 int64
-
-func (v *Int64) Scan(i interface{}) error {
-	b := sql.NullInt64{}
-	if err := b.Scan(i); err != nil {
-		return err
-	}
-	*v = Int64(b.Int64)
-	return nil
-}
-func (v Int64) Value() (driver.Value, error) {
-	return int64(v), nil
-}
-
-// Float64 type
-type Float64 float64
-
-func (v *Float64) Scan(i interface{}) error {
-	b := sql.NullFloat64{}
-	if err := b.Scan(i); err != nil {
-		return err
-	}
-	*v = Float64(b.Float64)
-	return nil
-}
-func (v Float64) Value() (driver.Value, error) {
-	return float64(v), nil
-}
-
-// String type
-type String string
-
-func (v *String) Scan(i interface{}) error {
-	b := sql.NullString{}
-	if err := b.Scan(i); err != nil {
-		return err
-	}
-	*v = String(b.String)
-	return nil
-}
-func (v String) Value() (driver.Value, error) {
-	return string(v), nil
-}
-func (v *String) String() string {
-	return string(*v)
-}
-
 // 通用的字符串查询
 type DBData string