diff --git a/builder.go b/builder.go index b6067f5..692cb14 100644 --- a/builder.go +++ b/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{ diff --git a/builder_test.go b/builder_test.go index 5648e32..c27a0ba 100644 --- a/builder_test.go +++ b/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()) + +} diff --git a/createtable.go b/createtable.go index 168ee3f..b628349 100644 --- a/createtable.go +++ b/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) diff --git a/createtable_test.go b/createtable_test.go index bec0ff9..7006090 100644 --- a/createtable_test.go +++ b/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) +} diff --git a/cte.go b/cte.go index 4611f56..9200d87 100644 --- a/cte.go +++ b/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) diff --git a/cte_test.go b/cte_test.go index c22d23f..3940bb7 100644 --- a/cte_test.go +++ b/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) +} diff --git a/ctequery.go b/ctequery.go index 15bcfc2..0f5b396 100644 --- a/ctequery.go +++ b/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) diff --git a/delete.go b/delete.go index 352f8e4..a196403 100644 --- a/delete.go +++ b/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) diff --git a/delete_test.go b/delete_test.go index 3fd6c4f..992d292 100644 --- a/delete_test.go +++ b/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) +} diff --git a/insert.go b/insert.go index 9f3cd3f..1aaf085 100644 --- a/insert.go +++ b/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) diff --git a/insert_test.go b/insert_test.go index 28224c4..ec60bf5 100644 --- a/insert_test.go +++ b/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) +} diff --git a/select.go b/select.go index 00e633b..88cf2b1 100644 --- a/select.go +++ b/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) diff --git a/select_test.go b/select_test.go index c0c1112..c31064d 100644 --- a/select_test.go +++ b/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) +} diff --git a/union.go b/union.go index fe559c4..7e5567b 100644 --- a/union.go +++ b/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) diff --git a/union_test.go b/union_test.go index 5109991..e12031a 100644 --- a/union_test.go +++ b/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) +} diff --git a/update.go b/update.go index 56389ad..0cec4cc 100644 --- a/update.go +++ b/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) diff --git a/update_test.go b/update_test.go index 9d2323d..2c7719e 100644 --- a/update_test.go +++ b/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) +} diff --git a/whereclause.go b/whereclause.go index a93c802..f06ff90 100644 --- a/whereclause.go +++ b/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 { diff --git a/whereclause_test.go b/whereclause_test.go index 17b7d05..cc2478c 100644 --- a/whereclause_test.go +++ b/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) +}