From e7bb45c26f97f8c44ded4678cf85ea9bc1033008 Mon Sep 17 00:00:00 2001 From: Vasily Rodionov Date: Wed, 30 Oct 2024 20:39:31 +0500 Subject: [PATCH 1/2] new: flavor getters --- createtable.go | 4 ++++ createtable_test.go | 17 +++++++++++++++++ cte.go | 4 ++++ cte_test.go | 28 ++++++++++++++++++++++++++++ ctequery.go | 4 ++++ delete.go | 4 ++++ delete_test.go | 17 +++++++++++++++++ insert.go | 4 ++++ insert_test.go | 17 +++++++++++++++++ select.go | 4 ++++ select_test.go | 14 ++++++++++++++ union.go | 4 ++++ union_test.go | 14 ++++++++++++++ update.go | 4 ++++ update_test.go | 14 ++++++++++++++ whereclause.go | 4 ++++ whereclause_test.go | 21 +++++++++++++++++++++ 17 files changed, 178 insertions(+) diff --git a/createtable.go b/createtable.go index 168ee3f..a42d6c6 100644 --- a/createtable.go +++ b/createtable.go @@ -158,6 +158,10 @@ func (ctb *CreateTableBuilder) SetFlavor(flavor Flavor) (old Flavor) { return } +func (ctb *CreateTableBuilder) GetFlavor() 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..45e25f1 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,17 @@ func ExampleCreateTableBuilder_NumDefine() { // Output: // 5 } + +func TestCreateTableGetFlavor(t *testing.T) { + a := assert.New(t) + ctb := newCreateTableBuilder() + postgresFlavor := PostgreSQL + clickhouseFlavor := ClickHouse + ctb.SetFlavor(postgresFlavor) + flavor := ctb.GetFlavor() + a.Equal(postgresFlavor, flavor) + + ctbClick := clickhouseFlavor.NewCreateTableBuilder() + flavor = ctbClick.GetFlavor() + a.Equal(clickhouseFlavor, flavor) +} diff --git a/cte.go b/cte.go index 4611f56..7f89ada 100644 --- a/cte.go +++ b/cte.go @@ -112,6 +112,10 @@ func (cteb *CTEBuilder) SetFlavor(flavor Flavor) (old Flavor) { return } +func (cteb *CTEBuilder) GetFlavor() 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..1ae41c3 100644 --- a/cte_test.go +++ b/cte_test.go @@ -130,3 +130,31 @@ 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() + postgresFlavor := PostgreSQL + clickhouseFlavor := ClickHouse + cteb.SetFlavor(postgresFlavor) + flavor := cteb.GetFlavor() + a.Equal(postgresFlavor, flavor) + + ctebClick := clickhouseFlavor.NewCTEBuilder() + flavor = ctebClick.GetFlavor() + a.Equal(clickhouseFlavor, flavor) +} + +func TestCTEQueryBuilderGetFlavor(t *testing.T) { + a := assert.New(t) + ctetb := newCTEQueryBuilder() + postgresFlavor := PostgreSQL + clickhouseFlavor := ClickHouse + ctetb.SetFlavor(postgresFlavor) + flavor := ctetb.GetFlavor() + a.Equal(postgresFlavor, flavor) + + ctetbClick := clickhouseFlavor.NewCTEQueryBuilder() + flavor = ctetbClick.GetFlavor() + a.Equal(clickhouseFlavor, flavor) +} diff --git a/ctequery.go b/ctequery.go index 15bcfc2..f61792c 100644 --- a/ctequery.go +++ b/ctequery.go @@ -124,6 +124,10 @@ func (ctetb *CTEQueryBuilder) SetFlavor(flavor Flavor) (old Flavor) { return } +func (ctetb *CTEQueryBuilder) GetFlavor() 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..ced6cfb 100644 --- a/delete.go +++ b/delete.go @@ -200,6 +200,10 @@ func (db *DeleteBuilder) SetFlavor(flavor Flavor) (old Flavor) { return } +func (db *DeleteBuilder) GetFlavor() 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..a69ef62 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,17 @@ 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() + postgresFlavor := PostgreSQL + clickhouseFlavor := ClickHouse + db.SetFlavor(postgresFlavor) + flavor := db.GetFlavor() + a.Equal(postgresFlavor, flavor) + + dbClick := clickhouseFlavor.NewDeleteBuilder() + flavor = dbClick.GetFlavor() + a.Equal(clickhouseFlavor, flavor) +} diff --git a/insert.go b/insert.go index 9f3cd3f..b22bbe0 100644 --- a/insert.go +++ b/insert.go @@ -213,6 +213,10 @@ func (ib *InsertBuilder) SetFlavor(flavor Flavor) (old Flavor) { return } +func (ib *InsertBuilder) GetFlavor() 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..784f5e4 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,17 @@ func ExampleInsertBuilder_NumValue() { // Output: // 2 } + +func TestInsertBuilderGetFlavor(t *testing.T) { + a := assert.New(t) + ib := newInsertBuilder() + postgresFlavor := PostgreSQL + clickhouseFlavor := ClickHouse + ib.SetFlavor(postgresFlavor) + flavor := ib.GetFlavor() + a.Equal(postgresFlavor, flavor) + + ibClick := clickhouseFlavor.NewInsertBuilder() + flavor = ibClick.GetFlavor() + a.Equal(clickhouseFlavor, flavor) +} diff --git a/select.go b/select.go index 00e633b..d60359a 100644 --- a/select.go +++ b/select.go @@ -537,6 +537,10 @@ func (sb *SelectBuilder) SetFlavor(flavor Flavor) (old Flavor) { return } +func (sb *SelectBuilder) GetFlavor() 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..298692e 100644 --- a/select_test.go +++ b/select_test.go @@ -375,3 +375,17 @@ 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() + postgresFlavor := PostgreSQL + clickhouseFlavor := ClickHouse + sb.SetFlavor(postgresFlavor) + flavor := sb.GetFlavor() + a.Equal(postgresFlavor, flavor) + + sbClick := clickhouseFlavor.NewSelectBuilder() + flavor = sbClick.GetFlavor() + a.Equal(clickhouseFlavor, flavor) +} diff --git a/union.go b/union.go index fe559c4..4c445ee 100644 --- a/union.go +++ b/union.go @@ -204,6 +204,10 @@ func (ub *UnionBuilder) SetFlavor(flavor Flavor) (old Flavor) { return } +func (ub *UnionBuilder) GetFlavor() 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..966d3b8 100644 --- a/union_test.go +++ b/union_test.go @@ -91,3 +91,17 @@ 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() + postgresFlavor := PostgreSQL + clickhouseFlavor := ClickHouse + ub.SetFlavor(postgresFlavor) + flavor := ub.GetFlavor() + a.Equal(postgresFlavor, flavor) + + ubClick := clickhouseFlavor.NewUnionBuilder() + flavor = ubClick.GetFlavor() + a.Equal(clickhouseFlavor, flavor) +} diff --git a/update.go b/update.go index 56389ad..c9773b7 100644 --- a/update.go +++ b/update.go @@ -269,6 +269,10 @@ func (ub *UpdateBuilder) SetFlavor(flavor Flavor) (old Flavor) { return } +func (ub *UpdateBuilder) GetFlavor() 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..02628ad 100644 --- a/update_test.go +++ b/update_test.go @@ -149,3 +149,17 @@ 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() + postgresFlavor := PostgreSQL + clickhouseFlavor := ClickHouse + ub.SetFlavor(postgresFlavor) + flavor := ub.GetFlavor() + a.Equal(postgresFlavor, flavor) + + ubClick := clickhouseFlavor.NewUpdateBuilder() + flavor = ubClick.GetFlavor() + a.Equal(clickhouseFlavor, flavor) +} diff --git a/whereclause.go b/whereclause.go index a93c802..13d0a4b 100644 --- a/whereclause.go +++ b/whereclause.go @@ -86,6 +86,10 @@ func (wc *WhereClause) SetFlavor(flavor Flavor) (old Flavor) { return } +func (wc *WhereClause) GetFlavor() 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..bf52f14 100644 --- a/whereclause_test.go +++ b/whereclause_test.go @@ -311,3 +311,24 @@ 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() + postgresFlavor := PostgreSQL + wc.SetFlavor(postgresFlavor) + flavor := wc.GetFlavor() + a.Equal(postgresFlavor, flavor) +} + +func TestWhereClauseCopyGetFlavor(t *testing.T) { + a := assert.New(t) + + wc := NewWhereClause() + postgresFlavor := PostgreSQL + wc.SetFlavor(postgresFlavor) + + wcCopy := CopyWhereClause(wc) + flavor := wcCopy.GetFlavor() + a.Equal(postgresFlavor, flavor) +} From 4b59c4acd52a58258249bd45463cd3451a102910 Mon Sep 17 00:00:00 2001 From: Vasily Rodionov Date: Thu, 31 Oct 2024 15:23:25 +0500 Subject: [PATCH 2/2] new: Added Flavor method to Builder interface --- builder.go | 12 ++++++++++++ builder_test.go | 19 +++++++++++++++++++ createtable.go | 3 ++- createtable_test.go | 17 ++++++++--------- cte.go | 3 ++- cte_test.go | 34 ++++++++++++++++------------------ ctequery.go | 3 ++- delete.go | 3 ++- delete_test.go | 17 ++++++++--------- insert.go | 3 ++- insert_test.go | 17 ++++++++--------- select.go | 3 ++- select_test.go | 17 ++++++++--------- union.go | 3 ++- union_test.go | 17 ++++++++--------- update.go | 3 ++- update_test.go | 17 ++++++++--------- whereclause.go | 3 ++- whereclause_test.go | 14 ++++++-------- 19 files changed, 119 insertions(+), 89 deletions(-) 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 a42d6c6..b628349 100644 --- a/createtable.go +++ b/createtable.go @@ -158,7 +158,8 @@ func (ctb *CreateTableBuilder) SetFlavor(flavor Flavor) (old Flavor) { return } -func (ctb *CreateTableBuilder) GetFlavor() Flavor { +// Flavor returns flavor of builder +func (ctb *CreateTableBuilder) Flavor() Flavor { return ctb.args.Flavor } diff --git a/createtable_test.go b/createtable_test.go index 45e25f1..7006090 100644 --- a/createtable_test.go +++ b/createtable_test.go @@ -93,13 +93,12 @@ func ExampleCreateTableBuilder_NumDefine() { func TestCreateTableGetFlavor(t *testing.T) { a := assert.New(t) ctb := newCreateTableBuilder() - postgresFlavor := PostgreSQL - clickhouseFlavor := ClickHouse - ctb.SetFlavor(postgresFlavor) - flavor := ctb.GetFlavor() - a.Equal(postgresFlavor, flavor) - - ctbClick := clickhouseFlavor.NewCreateTableBuilder() - flavor = ctbClick.GetFlavor() - a.Equal(clickhouseFlavor, flavor) + + 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 7f89ada..9200d87 100644 --- a/cte.go +++ b/cte.go @@ -112,7 +112,8 @@ func (cteb *CTEBuilder) SetFlavor(flavor Flavor) (old Flavor) { return } -func (cteb *CTEBuilder) GetFlavor() Flavor { +// Flavor returns flavor of builder +func (cteb *CTEBuilder) Flavor() Flavor { return cteb.args.Flavor } diff --git a/cte_test.go b/cte_test.go index 1ae41c3..3940bb7 100644 --- a/cte_test.go +++ b/cte_test.go @@ -134,27 +134,25 @@ func TestRecursiveCTEBuilder(t *testing.T) { func TestCTEGetFlavor(t *testing.T) { a := assert.New(t) cteb := newCTEBuilder() - postgresFlavor := PostgreSQL - clickhouseFlavor := ClickHouse - cteb.SetFlavor(postgresFlavor) - flavor := cteb.GetFlavor() - a.Equal(postgresFlavor, flavor) - - ctebClick := clickhouseFlavor.NewCTEBuilder() - flavor = ctebClick.GetFlavor() - a.Equal(clickhouseFlavor, flavor) + + 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() - postgresFlavor := PostgreSQL - clickhouseFlavor := ClickHouse - ctetb.SetFlavor(postgresFlavor) - flavor := ctetb.GetFlavor() - a.Equal(postgresFlavor, flavor) - - ctetbClick := clickhouseFlavor.NewCTEQueryBuilder() - flavor = ctetbClick.GetFlavor() - a.Equal(clickhouseFlavor, flavor) + + 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 f61792c..0f5b396 100644 --- a/ctequery.go +++ b/ctequery.go @@ -124,7 +124,8 @@ func (ctetb *CTEQueryBuilder) SetFlavor(flavor Flavor) (old Flavor) { return } -func (ctetb *CTEQueryBuilder) GetFlavor() Flavor { +// Flavor returns flavor of builder +func (ctetb *CTEQueryBuilder) Flavor() Flavor { return ctetb.args.Flavor } diff --git a/delete.go b/delete.go index ced6cfb..a196403 100644 --- a/delete.go +++ b/delete.go @@ -200,7 +200,8 @@ func (db *DeleteBuilder) SetFlavor(flavor Flavor) (old Flavor) { return } -func (db *DeleteBuilder) GetFlavor() Flavor { +// Flavor returns flavor of builder +func (db *DeleteBuilder) Flavor() Flavor { return db.args.Flavor } diff --git a/delete_test.go b/delete_test.go index a69ef62..992d292 100644 --- a/delete_test.go +++ b/delete_test.go @@ -87,13 +87,12 @@ func ExampleDeleteBuilder_With() { func TestDeleteBuilderGetFlavor(t *testing.T) { a := assert.New(t) db := newDeleteBuilder() - postgresFlavor := PostgreSQL - clickhouseFlavor := ClickHouse - db.SetFlavor(postgresFlavor) - flavor := db.GetFlavor() - a.Equal(postgresFlavor, flavor) - - dbClick := clickhouseFlavor.NewDeleteBuilder() - flavor = dbClick.GetFlavor() - a.Equal(clickhouseFlavor, flavor) + + 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 b22bbe0..1aaf085 100644 --- a/insert.go +++ b/insert.go @@ -213,7 +213,8 @@ func (ib *InsertBuilder) SetFlavor(flavor Flavor) (old Flavor) { return } -func (ib *InsertBuilder) GetFlavor() Flavor { +// Flavor returns flavor of builder +func (ib *InsertBuilder) Flavor() Flavor { return ib.args.Flavor } diff --git a/insert_test.go b/insert_test.go index 784f5e4..ec60bf5 100644 --- a/insert_test.go +++ b/insert_test.go @@ -248,13 +248,12 @@ func ExampleInsertBuilder_NumValue() { func TestInsertBuilderGetFlavor(t *testing.T) { a := assert.New(t) ib := newInsertBuilder() - postgresFlavor := PostgreSQL - clickhouseFlavor := ClickHouse - ib.SetFlavor(postgresFlavor) - flavor := ib.GetFlavor() - a.Equal(postgresFlavor, flavor) - - ibClick := clickhouseFlavor.NewInsertBuilder() - flavor = ibClick.GetFlavor() - a.Equal(clickhouseFlavor, flavor) + + 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 d60359a..88cf2b1 100644 --- a/select.go +++ b/select.go @@ -537,7 +537,8 @@ func (sb *SelectBuilder) SetFlavor(flavor Flavor) (old Flavor) { return } -func (sb *SelectBuilder) GetFlavor() Flavor { +// Flavor returns flavor of builder +func (sb *SelectBuilder) Flavor() Flavor { return sb.args.Flavor } diff --git a/select_test.go b/select_test.go index 298692e..c31064d 100644 --- a/select_test.go +++ b/select_test.go @@ -379,13 +379,12 @@ func TestSelectBuilderSelectMore(t *testing.T) { func TestSelectBuilderGetFlavor(t *testing.T) { a := assert.New(t) sb := newSelectBuilder() - postgresFlavor := PostgreSQL - clickhouseFlavor := ClickHouse - sb.SetFlavor(postgresFlavor) - flavor := sb.GetFlavor() - a.Equal(postgresFlavor, flavor) - - sbClick := clickhouseFlavor.NewSelectBuilder() - flavor = sbClick.GetFlavor() - a.Equal(clickhouseFlavor, flavor) + + 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 4c445ee..7e5567b 100644 --- a/union.go +++ b/union.go @@ -204,7 +204,8 @@ func (ub *UnionBuilder) SetFlavor(flavor Flavor) (old Flavor) { return } -func (ub *UnionBuilder) GetFlavor() Flavor { +// Flavor returns flavor of builder +func (ub *UnionBuilder) Flavor() Flavor { return ub.args.Flavor } diff --git a/union_test.go b/union_test.go index 966d3b8..e12031a 100644 --- a/union_test.go +++ b/union_test.go @@ -95,13 +95,12 @@ func TestUnionForSQLite(t *testing.T) { func TestUnionBuilderGetFlavor(t *testing.T) { a := assert.New(t) ub := newUnionBuilder() - postgresFlavor := PostgreSQL - clickhouseFlavor := ClickHouse - ub.SetFlavor(postgresFlavor) - flavor := ub.GetFlavor() - a.Equal(postgresFlavor, flavor) - - ubClick := clickhouseFlavor.NewUnionBuilder() - flavor = ubClick.GetFlavor() - a.Equal(clickhouseFlavor, flavor) + + 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 c9773b7..0cec4cc 100644 --- a/update.go +++ b/update.go @@ -269,7 +269,8 @@ func (ub *UpdateBuilder) SetFlavor(flavor Flavor) (old Flavor) { return } -func (ub *UpdateBuilder) GetFlavor() Flavor { +// Flavor returns flavor of builder +func (ub *UpdateBuilder) Flavor() Flavor { return ub.args.Flavor } diff --git a/update_test.go b/update_test.go index 02628ad..2c7719e 100644 --- a/update_test.go +++ b/update_test.go @@ -153,13 +153,12 @@ func ExampleUpdateBuilder_With() { func TestUpdateBuilderGetFlavor(t *testing.T) { a := assert.New(t) ub := newUpdateBuilder() - postgresFlavor := PostgreSQL - clickhouseFlavor := ClickHouse - ub.SetFlavor(postgresFlavor) - flavor := ub.GetFlavor() - a.Equal(postgresFlavor, flavor) - - ubClick := clickhouseFlavor.NewUpdateBuilder() - flavor = ubClick.GetFlavor() - a.Equal(clickhouseFlavor, flavor) + + 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 13d0a4b..f06ff90 100644 --- a/whereclause.go +++ b/whereclause.go @@ -86,7 +86,8 @@ func (wc *WhereClause) SetFlavor(flavor Flavor) (old Flavor) { return } -func (wc *WhereClause) GetFlavor() Flavor { +// Flavor returns flavor of clause +func (wc *WhereClause) Flavor() Flavor { return wc.flavor } diff --git a/whereclause_test.go b/whereclause_test.go index bf52f14..cc2478c 100644 --- a/whereclause_test.go +++ b/whereclause_test.go @@ -315,20 +315,18 @@ func TestEmptyStringsWhereAddWhereExpr(t *testing.T) { func TestWhereClauseGetFlavor(t *testing.T) { a := assert.New(t) wc := NewWhereClause() - postgresFlavor := PostgreSQL - wc.SetFlavor(postgresFlavor) - flavor := wc.GetFlavor() - a.Equal(postgresFlavor, flavor) + wc.SetFlavor(PostgreSQL) + flavor := wc.Flavor() + a.Equal(PostgreSQL, flavor) } func TestWhereClauseCopyGetFlavor(t *testing.T) { a := assert.New(t) wc := NewWhereClause() - postgresFlavor := PostgreSQL - wc.SetFlavor(postgresFlavor) + wc.SetFlavor(PostgreSQL) wcCopy := CopyWhereClause(wc) - flavor := wcCopy.GetFlavor() - a.Equal(postgresFlavor, flavor) + flavor := wcCopy.Flavor() + a.Equal(PostgreSQL, flavor) }