Flavor getters

builder.go

@@ -13,6 +13,7 @@ import (
 type Builder interface {
 	Build() (sql string, args []interface{})
 	BuildWithFlavor(flavor Flavor, initialArg ...interface{}) (sql string, args []interface{})
+	Flavor() Flavor
 }
 
 type compiledBuilder struct {
@@ -30,6 +31,12 @@ func (cb *compiledBuilder) BuildWithFlavor(flavor Flavor, initialArg ...interfac
 	return cb.args.CompileWithFlavor(cb.format, flavor, initialArg...)
 }
 
+// Flavor returns flavor of builder
+// Always returns DefaultFlavor
+func (cb *compiledBuilder) Flavor() Flavor {
+	return cb.args.Flavor
+}
+
 type flavoredBuilder struct {
 	builder Builder
 	flavor  Flavor
@@ -43,6 +50,11 @@ func (fb *flavoredBuilder) BuildWithFlavor(flavor Flavor, initialArg ...interfac
 	return fb.builder.BuildWithFlavor(flavor, initialArg...)
 }
 
+// Flavor returns flavor of builder
+func (fb *flavoredBuilder) Flavor() Flavor {
+	return fb.flavor
+}
+
 // WithFlavor creates a new Builder based on builder with a default flavor.
 func WithFlavor(builder Builder, flavor Flavor) Builder {
 	return &flavoredBuilder{

builder_test.go

@@ -132,3 +132,22 @@ func TestBuildWithCQL(t *testing.T) {
 	a.Equal(sql, "BEGIN BATCH USING TIMESTAMP ? INSERT INTO t1 (col1, col2) VALUES (?, ?); INSERT INTO t2 (col3, col4) VALUES (?, ?); APPLY BATCH;")
 	a.Equal(args, []interface{}{1481124356754405, 1, 2, 3, 4})
 }
+
+func TestBuilderGetFlavor(t *testing.T) {
+	a := assert.New(t)
+
+	defaultBuilder := Build("SELECT * FROM foo WHERE id = $0", 1234)
+	a.Equal(DefaultFlavor, defaultBuilder.Flavor())
+
+	buildfBuilder := Buildf("SELECT * FROM foo WHERE id = %v", 1234)
+	a.Equal(DefaultFlavor, buildfBuilder.Flavor())
+
+	namedBuilder := Buildf("SELECT * FROM ${table} WHERE id = 1234", map[string]interface{}{
+		"table": "foo",
+	})
+	a.Equal(DefaultFlavor, namedBuilder.Flavor())
+
+	flavoredBuilder := WithFlavor(Build("SELECT * FROM foo WHERE id = $0", 1234), PostgreSQL)
+	a.Equal(PostgreSQL, flavoredBuilder.Flavor())
+
+}

createtable.go

@@ -158,6 +158,11 @@ func (ctb *CreateTableBuilder) SetFlavor(flavor Flavor) (old Flavor) {
 	return
 }
 
+// Flavor returns flavor of builder
+func (ctb *CreateTableBuilder) Flavor() Flavor {
+	return ctb.args.Flavor
+}
+
 // Var returns a placeholder for value.
 func (ctb *CreateTableBuilder) Var(arg interface{}) string {
 	return ctb.args.Add(arg)

createtable_test.go

@@ -5,6 +5,9 @@ package sqlbuilder
 
 import (
 	"fmt"
+	"testing"
+
+	"github.com/huandu/go-assert"
 )
 
 func ExampleCreateTable() {
@@ -86,3 +89,16 @@ func ExampleCreateTableBuilder_NumDefine() {
 	// Output:
 	// 5
 }
+
+func TestCreateTableGetFlavor(t *testing.T) {
+	a := assert.New(t)
+	ctb := newCreateTableBuilder()
+
+	ctb.SetFlavor(PostgreSQL)
+	flavor := ctb.Flavor()
+	a.Equal(PostgreSQL, flavor)
+
+	ctbClick := ClickHouse.NewCreateTableBuilder()
+	flavor = ctbClick.Flavor()
+	a.Equal(ClickHouse, flavor)
+}

cte.go

@@ -112,6 +112,11 @@ func (cteb *CTEBuilder) SetFlavor(flavor Flavor) (old Flavor) {
 	return
 }
 
+// Flavor returns flavor of builder
+func (cteb *CTEBuilder) Flavor() Flavor {
+	return cteb.args.Flavor
+}
+
 // SQL adds an arbitrary sql to current position.
 func (cteb *CTEBuilder) SQL(sql string) *CTEBuilder {
 	cteb.injection.SQL(cteb.marker, sql)

cte_test.go

@@ -130,3 +130,29 @@ func TestRecursiveCTEBuilder(t *testing.T) {
 	sql = ctetb.String()
 	a.Equal(sql, "/* table init */ t (a, b) /* after table */ AS (SELECT a, b FROM t) /* after table as */")
 }
+
+func TestCTEGetFlavor(t *testing.T) {
+	a := assert.New(t)
+	cteb := newCTEBuilder()
+
+	cteb.SetFlavor(PostgreSQL)
+	flavor := cteb.Flavor()
+	a.Equal(PostgreSQL, flavor)
+
+	ctebClick := ClickHouse.NewCTEBuilder()
+	flavor = ctebClick.Flavor()
+	a.Equal(ClickHouse, flavor)
+}
+
+func TestCTEQueryBuilderGetFlavor(t *testing.T) {
+	a := assert.New(t)
+	ctetb := newCTEQueryBuilder()
+
+	ctetb.SetFlavor(PostgreSQL)
+	flavor := ctetb.Flavor()
+	a.Equal(PostgreSQL, flavor)
+
+	ctetbClick := ClickHouse.NewCTEQueryBuilder()
+	flavor = ctetbClick.Flavor()
+	a.Equal(ClickHouse, flavor)
+}

ctequery.go

@@ -124,6 +124,11 @@ func (ctetb *CTEQueryBuilder) SetFlavor(flavor Flavor) (old Flavor) {
 	return
 }
 
+// Flavor returns flavor of builder
+func (ctetb *CTEQueryBuilder) Flavor() Flavor {
+	return ctetb.args.Flavor
+}
+
 // SQL adds an arbitrary sql to current position.
 func (ctetb *CTEQueryBuilder) SQL(sql string) *CTEQueryBuilder {
 	ctetb.injection.SQL(ctetb.marker, sql)

delete.go

@@ -200,6 +200,11 @@ func (db *DeleteBuilder) SetFlavor(flavor Flavor) (old Flavor) {
 	return
 }
 
+// Flavor returns flavor of builder
+func (db *DeleteBuilder) Flavor() Flavor {
+	return db.args.Flavor
+}
+
 // SQL adds an arbitrary sql to current position.
 func (db *DeleteBuilder) SQL(sql string) *DeleteBuilder {
 	db.injection.SQL(db.marker, sql)

delete_test.go

@@ -5,6 +5,9 @@ package sqlbuilder
 
 import (
 	"fmt"
+	"testing"
+
+	"github.com/huandu/go-assert"
 )
 
 func ExampleDeleteFrom() {
@@ -80,3 +83,16 @@ func ExampleDeleteBuilder_With() {
 	// Output:
 	// WITH users AS (SELECT id, name FROM users WHERE name IS NULL) DELETE FROM orders WHERE users.id = orders.user_id
 }
+
+func TestDeleteBuilderGetFlavor(t *testing.T) {
+	a := assert.New(t)
+	db := newDeleteBuilder()
+
+	db.SetFlavor(PostgreSQL)
+	flavor := db.Flavor()
+	a.Equal(PostgreSQL, flavor)
+
+	dbClick := ClickHouse.NewDeleteBuilder()
+	flavor = dbClick.Flavor()
+	a.Equal(ClickHouse, flavor)
+}

insert.go

@@ -213,6 +213,11 @@ func (ib *InsertBuilder) SetFlavor(flavor Flavor) (old Flavor) {
 	return
 }
 
+// Flavor returns flavor of builder
+func (ib *InsertBuilder) Flavor() Flavor {
+	return ib.args.Flavor
+}
+
 // Var returns a placeholder for value.
 func (ib *InsertBuilder) Var(arg interface{}) string {
 	return ib.args.Add(arg)

insert_test.go

@@ -5,6 +5,9 @@ package sqlbuilder
 
 import (
 	"fmt"
+	"testing"
+
+	"github.com/huandu/go-assert"
 )
 
 func ExampleInsertInto() {
@@ -241,3 +244,16 @@ func ExampleInsertBuilder_NumValue() {
 	// Output:
 	// 2
 }
+
+func TestInsertBuilderGetFlavor(t *testing.T) {
+	a := assert.New(t)
+	ib := newInsertBuilder()
+
+	ib.SetFlavor(PostgreSQL)
+	flavor := ib.Flavor()
+	a.Equal(PostgreSQL, flavor)
+
+	ibClick := ClickHouse.NewInsertBuilder()
+	flavor = ibClick.Flavor()
+	a.Equal(ClickHouse, flavor)
+}

select.go

@@ -537,6 +537,11 @@ func (sb *SelectBuilder) SetFlavor(flavor Flavor) (old Flavor) {
 	return
 }
 
+// Flavor returns flavor of builder
+func (sb *SelectBuilder) Flavor() Flavor {
+	return sb.args.Flavor
+}
+
 // SQL adds an arbitrary sql to current position.
 func (sb *SelectBuilder) SQL(sql string) *SelectBuilder {
 	sb.injection.SQL(sb.marker, sql)

select_test.go

@@ -375,3 +375,16 @@ func TestSelectBuilderSelectMore(t *testing.T) {
 	).SQL("/* second */").SelectMore("name").SQL("/* third */")
 	a.Equal(sb.String(), "SELECT id, name /* first */ /* third */ WHERE name IS NOT NULL /* second */")
 }
+
+func TestSelectBuilderGetFlavor(t *testing.T) {
+	a := assert.New(t)
+	sb := newSelectBuilder()
+
+	sb.SetFlavor(PostgreSQL)
+	flavor := sb.Flavor()
+	a.Equal(PostgreSQL, flavor)
+
+	sbClick := ClickHouse.NewSelectBuilder()
+	flavor = sbClick.Flavor()
+	a.Equal(ClickHouse, flavor)
+}

union.go

@@ -204,6 +204,11 @@ func (ub *UnionBuilder) SetFlavor(flavor Flavor) (old Flavor) {
 	return
 }
 
+// Flavor returns flavor of builder
+func (ub *UnionBuilder) Flavor() Flavor {
+	return ub.args.Flavor
+}
+
 // Var returns a placeholder for value.
 func (ub *UnionBuilder) Var(arg interface{}) string {
 	return ub.args.Add(arg)

union_test.go

@@ -91,3 +91,16 @@ func TestUnionForSQLite(t *testing.T) {
 
 	a.Equal(sql, "SELECT id, name FROM users WHERE created_at > DATE('now', '-15 days') UNION ALL SELECT id, nick_name FROM user_extras WHERE status IN (1, 2, 3) ORDER BY id")
 }
+
+func TestUnionBuilderGetFlavor(t *testing.T) {
+	a := assert.New(t)
+	ub := newUnionBuilder()
+
+	ub.SetFlavor(PostgreSQL)
+	flavor := ub.Flavor()
+	a.Equal(PostgreSQL, flavor)
+
+	ubClick := ClickHouse.NewUnionBuilder()
+	flavor = ubClick.Flavor()
+	a.Equal(ClickHouse, flavor)
+}

update.go

@@ -269,6 +269,11 @@ func (ub *UpdateBuilder) SetFlavor(flavor Flavor) (old Flavor) {
 	return
 }
 
+// Flavor returns flavor of builder
+func (ub *UpdateBuilder) Flavor() Flavor {
+	return ub.args.Flavor
+}
+
 // SQL adds an arbitrary sql to current position.
 func (ub *UpdateBuilder) SQL(sql string) *UpdateBuilder {
 	ub.injection.SQL(ub.marker, sql)

update_test.go

@@ -149,3 +149,16 @@ func ExampleUpdateBuilder_With() {
 	// Output:
 	// WITH users AS (SELECT id, name FROM users WHERE prime IS NOT NULL) UPDATE orders SET orders.transport_fee = 0 WHERE users.id = orders.user_id
 }
+
+func TestUpdateBuilderGetFlavor(t *testing.T) {
+	a := assert.New(t)
+	ub := newUpdateBuilder()
+
+	ub.SetFlavor(PostgreSQL)
+	flavor := ub.Flavor()
+	a.Equal(PostgreSQL, flavor)
+
+	ubClick := ClickHouse.NewUpdateBuilder()
+	flavor = ubClick.Flavor()
+	a.Equal(ClickHouse, flavor)
+}

whereclause.go

@@ -86,6 +86,11 @@ func (wc *WhereClause) SetFlavor(flavor Flavor) (old Flavor) {
 	return
 }
 
+// Flavor returns flavor of clause
+func (wc *WhereClause) Flavor() Flavor {
+	return wc.flavor
+}
+
 // AddWhereExpr adds an AND expression to WHERE clause with the specified arguments.
 func (wc *WhereClause) AddWhereExpr(args *Args, andExpr ...string) *WhereClause {
 	if len(andExpr) == 0 {

whereclause_test.go

@@ -311,3 +311,22 @@ func TestEmptyStringsWhereAddWhereExpr(t *testing.T) {
 	a.Equal(ub.String(), "UPDATE t SET foo = 1 ")
 	a.Equal(db.String(), "DELETE FROM t ")
 }
+
+func TestWhereClauseGetFlavor(t *testing.T) {
+	a := assert.New(t)
+	wc := NewWhereClause()
+	wc.SetFlavor(PostgreSQL)
+	flavor := wc.Flavor()
+	a.Equal(PostgreSQL, flavor)
+}
+
+func TestWhereClauseCopyGetFlavor(t *testing.T) {
+	a := assert.New(t)
+
+	wc := NewWhereClause()
+	wc.SetFlavor(PostgreSQL)
+
+	wcCopy := CopyWhereClause(wc)
+	flavor := wcCopy.Flavor()
+	a.Equal(PostgreSQL, flavor)
+}