rebuild sql builder

Author: free1139

sqlbuilder.go

@@ -1,227 +1,73 @@
 package qsql
 
 import (
-	"strconv"
 	"strings"
 )
 
 type SqlBuilder struct {
-	table   []string
-	initArg []interface{}
-
-	whereStr   []string
-	whereArg   []interface{}
-	whereInStr []string
-	whereInArg [][]interface{}
-
-	// TODO: how to treat or
-	whereOrStr   []string
-	whereOrArg   []interface{}
-	whereOrInStr []string
-	whereOrInArg [][]interface{}
-
-	groupByStr  []string
-	havingStr   []string
-	havingArg   []interface{}
-	havingOrStr []string
-	havingOrArg []interface{}
-	orderByStr  []string
-	offset      int
-	limit       int
+	drvName string
+	buff    strings.Builder
+	args    []interface{}
 }
 
-func NewSqlBuilder(table string, args ...interface{}) *SqlBuilder {
-	return &SqlBuilder{
-		table:   []string{table},
-		initArg: args,
+func NewSqlBuilder(drvName ...string) *SqlBuilder {
+	b := &SqlBuilder{}
+	if len(drvName) > 0 {
+		b.drvName = drvName[0]
+	} else {
+		b.drvName = DRV_NAME_SQLITE3
 	}
+	return b
 }
 
-func (b *SqlBuilder) Copy() *SqlBuilder {
-	n := &SqlBuilder{
-		table:       make([]string, len(b.table)),
-		whereStr:    make([]string, len(b.whereStr)),
-		whereArg:    make([]interface{}, len(b.whereArg)),
-		whereOrStr:  make([]string, len(b.whereOrStr)),
-		whereOrArg:  make([]interface{}, len(b.whereOrArg)),
-		groupByStr:  make([]string, len(b.groupByStr)),
-		havingStr:   make([]string, len(b.havingStr)),
-		havingArg:   make([]interface{}, len(b.havingArg)),
-		havingOrStr: make([]string, len(b.havingOrStr)),
-		havingOrArg: make([]interface{}, len(b.havingOrArg)),
-		orderByStr:  make([]string, len(b.orderByStr)),
-		offset:      b.offset,
-		limit:       b.limit,
-	}
-	copy(n.table, b.table)
-	copy(n.whereStr, b.whereStr)
-	copy(n.whereArg, b.whereArg)
-	copy(n.whereOrStr, b.whereOrStr)
-	copy(n.whereOrArg, b.whereOrArg)
-	copy(n.groupByStr, b.groupByStr)
-	copy(n.havingStr, b.havingStr)
-	copy(n.havingArg, b.havingArg)
-	copy(n.havingOrStr, b.havingOrStr)
-	copy(n.havingOrArg, b.havingOrArg)
-	n.orderByStr = b.orderByStr
-	n.offset = b.offset
-	n.limit = b.limit
-	return n
+func (b *SqlBuilder) String() string {
+	return b.buff.String()
 }
-
-func (b *SqlBuilder) Joins(table string) *SqlBuilder {
-	b.table = append(b.table, table)
-	return b
+func (b *SqlBuilder) Args() []interface{} {
+	return b.args
 }
 
-func (b *SqlBuilder) Where(cond string, args ...interface{}) *SqlBuilder {
-	b.whereStr = append(b.whereStr, cond)
-	b.whereArg = append(b.whereArg, args...)
-	return b
-}
-func (b *SqlBuilder) WhereIn(column string, args []interface{}) *SqlBuilder {
-	if len(args) == 0 {
-		return b
+func (b *SqlBuilder) Add(key string, args ...interface{}) *SqlBuilder {
+	if len(key) > 0 {
+		b.buff.WriteString(key)
 	}
-	b.whereInStr = append(b.whereInStr, column)
-	b.whereInArg = append(b.whereInArg, args)
+	if len(args) > 0 {
+		b.args = append(b.args, args...)
+	}
+	b.buff.WriteString("\n")
 	return b
 }
 
-func (b *SqlBuilder) WhereOr(cond string, args ...interface{}) *SqlBuilder {
-	b.whereOrStr = append(b.whereOrStr, cond)
-	b.whereOrArg = append(b.whereOrArg, args...)
-	return b
+func (b *SqlBuilder) AddTab(key string, args ...interface{}) *SqlBuilder {
+	b.buff.WriteString("  ")
+	return b.Add(key, args)
 }
-
-func (b *SqlBuilder) WhereOrIn(cond string, args []interface{}) *SqlBuilder {
-	if len(args) == 0 {
+func (b *SqlBuilder) AddTabOk(ok bool, key string, args ...interface{}) *SqlBuilder {
+	if !ok {
 		return b
 	}
-	b.whereOrInStr = append(b.whereOrInStr, cond)
-	b.whereOrInArg = append(b.whereOrInArg, args)
-	return b
-}
-
-func (b *SqlBuilder) GroupBy(cond ...string) *SqlBuilder {
-	b.groupByStr = append(b.groupByStr, cond...)
-	return b
-}
-func (b *SqlBuilder) Having(cond string, args ...interface{}) *SqlBuilder {
-	b.havingStr = append(b.havingStr, cond)
-	b.havingArg = append(b.havingArg, args...)
-	return b
-}
-func (b *SqlBuilder) HavingOr(cond string, args ...interface{}) *SqlBuilder {
-	b.havingOrStr = append(b.havingOrStr, cond)
-	b.havingOrArg = append(b.havingOrArg, args...)
-	return b
+	return b.AddTab(key, args...)
 }
 
-func (b *SqlBuilder) OrderBy(cond string) *SqlBuilder {
-	b.orderByStr = append(b.orderByStr, cond)
-	return b
-}
-func (b *SqlBuilder) Offset(offset int) *SqlBuilder {
-	b.offset = offset
-	return b
-}
-func (b *SqlBuilder) Limit(limit int) *SqlBuilder {
-	b.limit = limit
-	return b
-}
-func (b *SqlBuilder) buildWhere() (string, []interface{}) {
-	args := []interface{}{}
-	if len(b.whereStr) == 0 && len(b.whereOrStr) == 0 {
-		return "", args
-	}
-
-	query := "WHERE "
-	if len(b.whereStr) > 0 {
-		query += "(" + strings.Join(b.whereStr, " AND ") + ") "
-		args = append(args, b.whereArg...)
-	}
-	if len(b.whereOrStr) > 0 {
-		if len(b.whereStr) > 0 {
-			query += "OR "
-		}
-		query += "(" + strings.Join(b.whereOrStr, " OR ") + ") "
-		args = append(args, b.whereOrArg...)
-	}
-	return query, args
-}
-func (b *SqlBuilder) buildGroupBy() string {
-	if len(b.groupByStr) == 0 {
-		return ""
-	}
-	return "GROUP BY " + strings.Join(b.groupByStr, ", ") + " "
-}
-func (b *SqlBuilder) buildHaving() (string, []interface{}) {
-	args := []interface{}{}
-	if len(b.havingStr) == 0 && len(b.havingOrStr) == 0 {
-		return "", args
-	}
-	query := "HAVING "
-	if len(b.havingStr) > 0 {
-		query += "(" + strings.Join(b.havingStr, " AND ") + ") "
-		args = append(args, b.havingArg...)
-	}
-	if len(b.havingOrStr) > 0 {
-		if len(b.havingStr) > 0 {
-			query += "OR "
-		}
-		query += "(" + strings.Join(b.havingOrStr, " OR ") + ") "
-		args = append(args, b.havingOrArg...)
-	}
-	return query, args
-}
-func (b *SqlBuilder) buildOrderBy() string {
-	if len(b.orderByStr) == 0 {
-		return ""
-	}
-	return "ORDER BY " + strings.Join(b.orderByStr, ", ") + " "
-}
-func (b *SqlBuilder) buildOffset() string {
-	if b.offset == 0 {
-		return ""
+func (b *SqlBuilder) In(in []interface{}) string {
+	if len(in) == 0 {
+		panic("need condition")
 	}
-	return "OFFSET " + strconv.Itoa(b.offset) + " "
-}
-func (b *SqlBuilder) buildLimit() string {
-	if b.limit == 0 {
-		return ""
-	}
-	return "LIMIT " + strconv.Itoa(b.limit) + " "
+	b.args = append(b.args, in...)
+	return stmtIn(len(b.args)-1, len(in), b.drvName)
 }
 
-func (b *SqlBuilder) Select(column ...string) (string, []interface{}) {
-	if len(b.table) == 0 {
-		panic("table not set")
-	}
-	selectStr := "*"
+func (b *SqlBuilder) Select(column ...string) string {
 	if len(column) > 0 {
-		selectStr = strings.Join(column, ", ")
+		return strings.Join(column, ", ")
+	} else {
+		return "*"
 	}
-	args := b.initArg
-	query := "SELECT " + selectStr + " "
-	query += "FROM " + strings.Join(b.table, " ") + " "
-
-	whereStr, whereArg := b.buildWhere()
-	if len(whereStr) > 0 {
-		query += whereStr
-		args = append(args, whereArg...)
-	}
-
-	query += b.buildGroupBy()
-
-	havingStr, havingArg := b.buildHaving()
-	if len(havingStr) > 0 {
-		query += havingStr
-		args = append(args, havingArg...)
+}
+func (b *SqlBuilder) SelectStruct(obj interface{}) string {
+	fields, err := reflectInsertStruct(obj, b.drvName)
+	if err != nil {
+		panic(err)
 	}
-
-	query += b.buildOrderBy()
-	query += b.buildOffset()
-	query += b.buildLimit()
-	return query, args
+	return fields.Names
 }

sqlbuilder_test.go

@@ -6,37 +6,24 @@ import (
 )
 
 func TestSqlBuilder(t *testing.T) {
-	sb := NewSqlBuilder("tmp tb1")
-	fmt.Println(sb.Select("*"))
-
-	sb.Joins("INNER JOIN tmp1 tb2 ON tb2.id=tb2.tmp_id")
-	fmt.Println(sb.Select("*"))
-
-	sb.Where("1=?", 0)
-	fmt.Println(sb.Select("*"))
-
-	sb.WhereOr("1=1")
-	fmt.Println(sb.Select("*"))
-
-	sb.GroupBy("tb1.id")
-	fmt.Println(sb.Select("*"))
-
-	sb.GroupBy("tb2.id")
-	fmt.Println(sb.Select("*"))
-
-	sb.Having("count(tb1.id)>?", 2)
-	fmt.Println(sb.Select("*"))
-
-	sb.Offset(0)
-	fmt.Println(sb.Select("*"))
-	sb.Offset(1)
-	fmt.Println(sb.Select("*"))
-
-	sb.Limit(0)
-	fmt.Println(sb.Select("*"))
-	sb.Limit(1)
-	fmt.Println(sb.Select("*"))
-
-	mTable, args := sb.Select("id")
-	fmt.Println(NewSqlBuilder("("+mTable+") tmp", args...).Select("*"))
+	sb := NewSqlBuilder(DRV_NAME_POSTGRES)
+	sb.Add("SELECT")
+	sb.AddTab(sb.Select("tb1.id", "count(*)"))
+	sb.Add("FROM")
+	sb.AddTab("tmp tb1")
+	sb.AddTab("INNER JOIN tmp1 tb2 ON tb2.id=tb2.tmp_id")
+	sb.Add("WHERE")
+	sb.AddTab("1=1")
+	sb.AddTabOk(false, "AND (1=?)", 0)
+	sb.AddTab("OR (tb1 IN (" + sb.In([]interface{}{1, 2}) + "))")
+	sb.Add("GROUP BY tb1.id")
+	sb.Add("HAVING count(*)>?", 1)
+	sb.Add("ORDER BY tb1.id DESC")
+	sb.Add("OFFSET ?", 1)
+	sb.Add("LIMIT ?", 1)
+	fmt.Println(sb)
+
+	sb1 := NewSqlBuilder(DRV_NAME_POSTGRES)
+	sb1.Add("SELECT * FROM ("+sb.String()+") tmp", sb1.Args())
+	fmt.Println(sb1)
 }