From f3c3aa70bea4a272db8249713a603eab6637ba18 Mon Sep 17 00:00:00 2001 From: Mesut GENEZ Date: Fri, 20 Dec 2024 10:15:47 +0300 Subject: [PATCH] preapare and sql options --- builder.go | 78 +++++++++++++----- builder_test.go | 210 +++++++++++++++++++++++++++++++++++++++--------- example/main.go | 86 ++++++++++++-------- 3 files changed, 286 insertions(+), 88 deletions(-) diff --git a/builder.go b/builder.go index 851a422..003e39e 100644 --- a/builder.go +++ b/builder.go @@ -36,15 +36,18 @@ type GoBuilder struct { paramsClause []any counterClause int holderClause SQLDialect + holderCode string } // NewGoBuilder initializes a new instance of GoBuilder func NewGoBuilder(holderClause SQLDialect) *GoBuilder { - return &GoBuilder{ + gb := &GoBuilder{ paramsClause: []any{}, counterClause: 1, holderClause: holderClause, } + gb.holderCode = gb.getPlaceholderCode() + return gb } // Table specifies the table name for the query @@ -219,8 +222,33 @@ func (gb *GoBuilder) Union(sql string) *GoBuilder { return gb } -// ToSql returns the final SQL query and the associated bind parameters -func (gb *GoBuilder) ToSql() (string, []any) { +// Sql returns the final SQL query +func (gb *GoBuilder) Sql() string { + clauses := []string{ + gb.selectClause, + gb.joinClause, + gb.whereClause, + gb.groupByClause, + gb.havingClause, + gb.orderByClause, + gb.limitClause, + gb.unionClause, + } + query := strings.Join(clauses, " ") + re := regexp.MustCompile(`\s+`) + query = strings.TrimSpace(re.ReplaceAllString(query, " ")) + + params := gb.paramsClause + for i, param := range params { + placeholder := fmt.Sprintf("%s%d", gb.holderCode, i+1) + query = strings.Replace(query, placeholder, gb.cleanValue(param), 1) + } + gb.reset() + return query +} + +// Prepare returns the final SQL query and the associated bind parameters +func (gb *GoBuilder) Prepare() (string, []any) { clauses := []string{ gb.selectClause, gb.joinClause, @@ -241,27 +269,13 @@ func (gb *GoBuilder) ToSql() (string, []any) { // Private method to RESET builder func (gb *GoBuilder) reset() { - *gb = GoBuilder{ - paramsClause: []any{}, - counterClause: 1, - holderClause: gb.holderClause, - } + *gb = *NewGoBuilder(Postgres) } // Private method to add parameters func (gb *GoBuilder) addParam(value any) string { gb.paramsClause = append(gb.paramsClause, value) - var placeholder string - switch gb.holderClause { - case Postgres: - placeholder = fmt.Sprintf("$%d", gb.counterClause) - case SQLServer: - placeholder = fmt.Sprintf("@%d", gb.counterClause) - case Oracle: - placeholder = fmt.Sprintf(":%d", gb.counterClause) - default: // mysql and sqlite - placeholder = fmt.Sprintf("?%d", gb.counterClause) - } + placeholder := fmt.Sprintf("%s%d", gb.holderCode, gb.counterClause) gb.counterClause++ return placeholder } @@ -296,3 +310,29 @@ func (gb *GoBuilder) between(OP, column string, args ...any) *GoBuilder { } return gb } + +// cleanValue trims and escapes potentially harmful characters from the value +func (gb *GoBuilder) cleanValue(value any) string { + switch v := value.(type) { + case string: + cleaned := strings.ReplaceAll(v, "'", "''") + return "'" + cleaned + "'" + default: + return fmt.Sprintf("%v", v) + } +} + +func (gb *GoBuilder) getPlaceholderCode() string { + var code string + switch gb.holderClause { + case Postgres: + code = "$" + case SQLServer: + code = "@" + case Oracle: + code = ":" + default: // mysql and sqlite + code = "?" + } + return code +} diff --git a/builder_test.go b/builder_test.go index 5f6c136..2c1eb1d 100644 --- a/builder_test.go +++ b/builder_test.go @@ -10,339 +10,475 @@ var ( params []any queryExpected string paramsExpected []any - s = NewGoBuilder(Postgres) + gb = NewGoBuilder(Postgres) ) func TestSql_Select(t *testing.T) { queryExpected = "SELECT * FROM users" paramsExpected = []any{} - query, params = s.Table("users").Select().ToSql() + query, params = gb.Table("users").Select().Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "SELECT * FROM users" + query = gb.Table("users").Select().Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_Select_With_Columns(t *testing.T) { queryExpected = "SELECT firstname, lastname FROM users" paramsExpected = []any{} - query, params = s.Table("users").Select("firstname", "lastname").ToSql() + query, params = gb.Table("users").Select("firstname", "lastname").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "SELECT firstname, lastname FROM users" + query = gb.Table("users").Select("firstname", "lastname").Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_Distinct(t *testing.T) { queryExpected = "SELECT DISTINCT name, age FROM users" paramsExpected := []any{} - query, params = s.Table("users").SelectDistinct("name", "age").ToSql() + query, params = gb.Table("users").SelectDistinct("name", "age").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "SELECT DISTINCT name, age FROM users" + query = gb.Table("users").SelectDistinct("name", "age").Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_Insert(t *testing.T) { queryExpected = "INSERT INTO users (firstname, lastname) VALUES ($1, $2)" paramsExpected := []any{"Mesut", "GENEZ"} args := map[string]any{"firstname": "Mesut", "lastname": "GENEZ"} - query, params = s.Table("users").Insert(args).ToSql() + query, params = gb.Table("users").Insert(args).Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "INSERT INTO users (firstname, lastname) VALUES ('Mesut', 'GENEZ')" + query = gb.Table("users").Insert(args).Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_Update(t *testing.T) { // sometimes it may not pass the test because the map is unordered + args := map[string]any{"firstname": "Mesut", "lastname": "GENEZ"} queryExpected = "UPDATE users SET firstname = $1, lastname = $2" paramsExpected := []any{"Mesut", "GENEZ"} - query, params = s.Table("users").Update(map[string]any{"firstname": "Mesut", "lastname": "GENEZ"}).ToSql() + query, params = gb.Table("users").Update(args).Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "UPDATE users SET firstname = 'Mesut', lastname = 'GENEZ'" + query = gb.Table("users").Update(args).Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_Delete(t *testing.T) { queryExpected = "DELETE FROM users" paramsExpected := []any{} - query, params = s.Table("users").Delete().ToSql() + query, params = gb.Table("users").Delete().Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "DELETE FROM users" + query = gb.Table("users").Delete().Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_Where(t *testing.T) { queryExpected = "WHERE firstname = $1" paramsExpected := []any{"Mesut"} - query, params = s.Where("firstname", "=", "Mesut").ToSql() + query, params = gb.Where("firstname", "=", "Mesut").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "WHERE firstname = 'Mesut'" + query = gb.Where("firstname", "=", "Mesut").Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_WhereWithInt(t *testing.T) { queryExpected = "WHERE id = $1" paramsExpected := []any{55} - query, params = s.Where("id", "=", 55).ToSql() + query, params = gb.Where("id", "=", 55).Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "WHERE id = 55" + query = gb.Where("id", "=", 55).Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_WhereWithFloat(t *testing.T) { queryExpected = "WHERE amount = $1" paramsExpected := []any{55.5} - query, params = s.Where("amount", "=", 55.5).ToSql() + query, params = gb.Where("amount", "=", 55.5).Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "WHERE amount = 55.5" + query = gb.Where("amount", "=", 55.5).Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_Where_With_And(t *testing.T) { queryExpected = "WHERE firstname = $1 AND lastname = $2" paramsExpected := []any{"Mesut", "GENEZ"} - query, params = s.Where("firstname", "=", "Mesut").Where("lastname", "=", "GENEZ").ToSql() + query, params = gb.Where("firstname", "=", "Mesut").Where("lastname", "=", "GENEZ").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "WHERE firstname = 'Mesut' AND lastname = 'GENEZ'" + query = gb.Where("firstname", "=", "Mesut").Where("lastname", "=", "GENEZ").Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_OrWhere(t *testing.T) { queryExpected = "WHERE firstname = $1" paramsExpected := []any{"Mesut"} - query, params = s.OrWhere("firstname", "=", "Mesut").ToSql() + query, params = gb.OrWhere("firstname", "=", "Mesut").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "WHERE firstname = 'Mesut'" + query = gb.OrWhere("firstname", "=", "Mesut").Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_OrWhere_With_And(t *testing.T) { queryExpected = "WHERE firstname = $1 OR lastname = $2" paramsExpected := []any{"Mesut", "GENEZ"} - query, params = s.OrWhere("firstname", "=", "Mesut").OrWhere("lastname", "=", "GENEZ").ToSql() + query, params = gb.OrWhere("firstname", "=", "Mesut").OrWhere("lastname", "=", "GENEZ").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "WHERE firstname = 'Mesut' OR lastname = 'GENEZ'" + query = gb.OrWhere("firstname", "=", "Mesut").OrWhere("lastname", "=", "GENEZ").Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_In(t *testing.T) { queryExpected = "WHERE firstname IN ($1, $2)" paramsExpected := []any{"Mesut", 33} - query, params = s.In("firstname", "Mesut", 33).ToSql() + query, params = gb.In("firstname", "Mesut", 33).Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "WHERE firstname IN ('Mesut', 33)" + query = gb.In("firstname", "Mesut", 33).Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_InWithInt(t *testing.T) { queryExpected = "WHERE id IN ($1, $2, $3)" paramsExpected := []any{12, 34, 55} - query, params = s.In("id", 12, 34, 55).ToSql() + query, params = gb.In("id", 12, 34, 55).Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "WHERE id IN (12, 34, 55)" + query = gb.In("id", 12, 34, 55).Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_InAnd(t *testing.T) { queryExpected = "WHERE firstname IN ($1) AND lastname IN ($2)" paramsExpected := []any{"Mesut", "GENEZ"} - query, params = s.In("firstname", "Mesut").In("lastname", "GENEZ").ToSql() + query, params = gb.In("firstname", "Mesut").In("lastname", "GENEZ").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "WHERE firstname IN ('Mesut') AND lastname IN ('GENEZ')" + query = gb.In("firstname", "Mesut").In("lastname", "GENEZ").Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_OrIn(t *testing.T) { queryExpected = "WHERE firstname IN ($1)" paramsExpected := []any{"Mesut"} - query, params = s.OrIn("firstname", "Mesut").ToSql() + query, params = gb.OrIn("firstname", "Mesut").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "WHERE firstname IN ('Mesut')" + query = gb.OrIn("firstname", "Mesut").Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_OrInAnd(t *testing.T) { queryExpected = "WHERE firstname IN ($1, $2) OR lastname IN ($3)" paramsExpected := []any{"Mesut", "GENEZ", "GENEZ"} - query, params = s.OrIn("firstname", "Mesut", "GENEZ").OrIn("lastname", "GENEZ").ToSql() + query, params = gb.OrIn("firstname", "Mesut", "GENEZ").OrIn("lastname", "GENEZ").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "WHERE firstname IN ('Mesut', 'GENEZ') OR lastname IN ('GENEZ')" + query = gb.OrIn("firstname", "Mesut", "GENEZ").OrIn("lastname", "GENEZ").Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_Between(t *testing.T) { queryExpected = "WHERE firstname BETWEEN $1 AND $2" paramsExpected := []any{"Mesut", "GENEZ"} - query, params = s.Between("firstname", "Mesut", "GENEZ").ToSql() + query, params = gb.Between("firstname", "Mesut", "GENEZ").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "WHERE firstname BETWEEN 'Mesut' AND 'GENEZ'" + query = gb.Between("firstname", "Mesut", "GENEZ").Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_BetweenWithInt(t *testing.T) { queryExpected = "WHERE id BETWEEN $1 AND $2" paramsExpected := []any{12, 55} - query, params = s.Between("id", 12, 55).ToSql() + query, params = gb.Between("id", 12, 55).Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "WHERE id BETWEEN 12 AND 55" + query = gb.Between("id", 12, 55).Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_BetweenWithWhere(t *testing.T) { queryExpected = "WHERE firstname BETWEEN $1 AND $2 AND lastname BETWEEN $3 AND $4" paramsExpected := []any{"Mesut", "GENEZ", "Mesut", "GENEZ"} - query, params = s.Between("firstname", "Mesut", "GENEZ").Between("lastname", "Mesut", "GENEZ").ToSql() + query, params = gb.Between("firstname", "Mesut", "GENEZ").Between("lastname", "Mesut", "GENEZ").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "WHERE firstname BETWEEN 'Mesut' AND 'GENEZ' AND lastname BETWEEN 'Mesut' AND 'GENEZ'" + query = gb.Between("firstname", "Mesut", "GENEZ").Between("lastname", "Mesut", "GENEZ").Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_OrBetween(t *testing.T) { queryExpected = "WHERE firstname BETWEEN $1 AND $2" paramsExpected := []any{"Mesut", "GENEZ"} - query, params = s.OrBetween("firstname", "Mesut", "GENEZ").ToSql() + query, params = gb.OrBetween("firstname", "Mesut", "GENEZ").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "WHERE firstname BETWEEN 'Mesut' AND 'GENEZ'" + query = gb.OrBetween("firstname", "Mesut", "GENEZ").Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_OrBetweenWithWhere(t *testing.T) { queryExpected = "WHERE firstname BETWEEN $1 AND $2 OR lastname BETWEEN $3 AND $4" paramsExpected := []any{"Mesut", "GENEZ", "Mesut", "GENEZ"} - query, params = s.OrBetween("firstname", "Mesut", "GENEZ").OrBetween("lastname", "Mesut", "GENEZ").ToSql() + query, params = gb.OrBetween("firstname", "Mesut", "GENEZ").OrBetween("lastname", "Mesut", "GENEZ").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "WHERE firstname BETWEEN 'Mesut' AND 'GENEZ' OR lastname BETWEEN 'Mesut' AND 'GENEZ'" + query = gb.OrBetween("firstname", "Mesut", "GENEZ").OrBetween("lastname", "Mesut", "GENEZ").Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_IsNull(t *testing.T) { queryExpected = "SELECT * FROM users WHERE age = $1 AND name IS NULL" paramsExpected := []any{30} - query, params = s.Table("users").Select().Where("age", "=", 30).IsNull("name").ToSql() + query, params = gb.Table("users").Select().Where("age", "=", 30).IsNull("name").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "SELECT * FROM users WHERE age = 30 AND name IS NULL" + query = gb.Table("users").Select().Where("age", "=", 30).IsNull("name").Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_IsNotNull(t *testing.T) { queryExpected = "SELECT * FROM users WHERE age = $1 AND name IS NOT NULL" paramsExpected := []any{30} - query, params = s.Table("users").Select().Where("age", "=", 30).IsNotNull("name").ToSql() + query, params = gb.Table("users").Select().Where("age", "=", 30).IsNotNull("name").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "SELECT * FROM users WHERE age = 30 AND name IS NOT NULL" + query = gb.Table("users").Select().Where("age", "=", 30).IsNotNull("name").Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_Having(t *testing.T) { queryExpected = "SELECT * FROM orders GROUP BY user_id HAVING COUNT(*) > 1" paramsExpected := []any{} - query, params = s.Table("orders").Select().GroupBy("user_id").Having("COUNT(*) > 1").ToSql() + query, params = gb.Table("orders").Select().GroupBy("user_id").Having("COUNT(*) > 1").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "SELECT * FROM orders GROUP BY user_id HAVING COUNT(*) > 1" + query = gb.Table("orders").Select().GroupBy("user_id").Having("COUNT(*) > 1").Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_Join(t *testing.T) { queryExpected = "INNER JOIN users ON roles" paramsExpected := []any{} - query, params = s.Join("INNER", "users", "roles").ToSql() + query, params = gb.Join("INNER", "users", "roles").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "INNER JOIN users ON roles" + query = gb.Join("INNER", "users", "roles").Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_Limit(t *testing.T) { queryExpected = "LIMIT 1, 5" paramsExpected := []any{} - query, params = s.Limit(1, 5).ToSql() + query, params = gb.Limit(1, 5).Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } if !reflect.DeepEqual(paramsExpected, params) { t.Errorf("paramsExpected = %v, params %v", paramsExpected, params) } + queryExpected = "LIMIT 1, 5" + query = gb.Limit(1, 5).Sql() + if !reflect.DeepEqual(queryExpected, query) { + t.Errorf("queryExpected = %v, query %v", queryExpected, query) + } } func TestSql_Group(t *testing.T) { queryExpected = "GROUP BY firstname" paramsExpected := []any{} - query, params = s.GroupBy("firstname").ToSql() + query, params = gb.GroupBy("firstname").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } @@ -354,7 +490,7 @@ func TestSql_Group(t *testing.T) { func TestSql_GroupMultiple(t *testing.T) { queryExpected = "GROUP BY firstname, lastname, email" paramsExpected := []any{} - query, params = s.GroupBy("firstname", "lastname", "email").ToSql() + query, params = gb.GroupBy("firstname", "lastname", "email").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } @@ -366,7 +502,7 @@ func TestSql_GroupMultiple(t *testing.T) { func TestSql_OrderBy(t *testing.T) { queryExpected = "ORDER BY firstname ASC" paramsExpected := []any{} - query, params = s.OrderBy("firstname").ToSql() + query, params = gb.OrderBy("firstname").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } @@ -378,7 +514,7 @@ func TestSql_OrderBy(t *testing.T) { func TestSql_OrderByMultiple(t *testing.T) { queryExpected = "ORDER BY firstname, lastname ASC" paramsExpected := []any{} - query, params = s.OrderBy("firstname", "lastname").ToSql() + query, params = gb.OrderBy("firstname", "lastname").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } @@ -390,7 +526,7 @@ func TestSql_OrderByMultiple(t *testing.T) { func TestSql_OrderByDesc(t *testing.T) { queryExpected = "ORDER BY firstname DESC" paramsExpected := []any{} - query, params = s.OrderByDesc("firstname").ToSql() + query, params = gb.OrderByDesc("firstname").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } @@ -402,7 +538,7 @@ func TestSql_OrderByDesc(t *testing.T) { func TestSql_OrderByDescMultiple(t *testing.T) { queryExpected = "ORDER BY firstname, lastname DESC" paramsExpected := []any{} - query, params = s.OrderByDesc("firstname", "lastname").ToSql() + query, params = gb.OrderByDesc("firstname", "lastname").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } @@ -414,7 +550,7 @@ func TestSql_OrderByDescMultiple(t *testing.T) { func TestSql_Union(t *testing.T) { queryExpected = "UNION select * from companies" paramsExpected := []any{} - query, params = s.Union("select * from companies").ToSql() + query, params = gb.Union("select * from companies").Prepare() if !reflect.DeepEqual(queryExpected, query) { t.Errorf("queryExpected = %v, query %v", queryExpected, query) } @@ -428,8 +564,8 @@ func TestSql_SubQuery(t *testing.T) { mainBuilder := NewGoBuilder(Postgres) subBuilder := NewGoBuilder(Postgres) - query, params = subBuilder.Table("users").Select("id").Where("age", ">", 30).ToSql() - query, params = mainBuilder.Table("orders").Select("order_id", "user_id").In("user_id", query).ToSql() + query, params = subBuilder.Table("users").Select("id").Where("age", ">", 30).Prepare() + query, params = mainBuilder.Table("orders").Select("order_id", "user_id").In("user_id", query).Prepare() queryExpected = "SELECT order_id, user_id FROM orders WHERE user_id IN ($1)" diff --git a/example/main.go b/example/main.go index 5818e4e..104cbee 100644 --- a/example/main.go +++ b/example/main.go @@ -14,67 +14,89 @@ var ( func main() { - query, params = gb.Table("users").Select().Where("id", "=", "1").ToSql() - fmt.Printf("All Columns: \n%s\n%v\n\n", query, params) + query, params = gb.Table("users").Select().Where("id", "=", "1").Prepare() + fmt.Printf("All Columns Prepare: \n%s\t%v\n", query, params) + query = gb.Table("users").Select().Where("id", "=", "1").Sql() + fmt.Printf("All Columns Sql: \n%s\n\n", query) - query, params = gb.Table("users").Select("firstname", "lastname", "created_at"). - Where("id", "=", 1). - ToSql() - fmt.Printf("Filter Columns: \n%s\n%v\n\n", query, params) + query, params = gb.Table("users").Select("firstname", "lastname", "created_at").Where("id", "=", 1).Prepare() + fmt.Printf("Filter Columns Prepare: \n%s\t%v\n", query, params) + query = gb.Table("users").Select("firstname", "lastname", "created_at").Where("id", "=", 1).Sql() + fmt.Printf("Filter Columns Sql: \n%s\n\n", query) - query, params = gb.Table("users").Select(). - Where("id", "=", "1"). - OrWhere("email", "=", "loremipsum@lrmpsm.com"). - ToSql() - fmt.Printf("Where Or Where: \n%s\n%v\n\n", query, params) + query, params = gb.Table("users").Select().Where("id", "=", "1").OrWhere("email", "=", "loremipsum@lrmpsm.com").Prepare() + fmt.Printf("Where Or Where Prepare: \n%s\t%v\n\n", query, params) + query = gb.Table("users").Select().Where("id", "=", "1").OrWhere("email", "=", "loremipsum@lrmpsm.com").Sql() + fmt.Printf("Where Or Where Sql: \n%s\n\n", query) query, params = gb.Table("users as u").Select("u.firstname", "u.lastname", "a.address"). Join("INNER", "address as a", "a.user_id=u.id"). - Where("u.email", "=", "loremipsum@lrmpsm.com"). - ToSql() - fmt.Printf("Join: \n%s\n%v\n\n", query, params) + Where("u.email", "=", "loremipsum@lrmpsm.com").Prepare() + fmt.Printf("Join Prepare: \n%s\t%v\n", query, params) + query = gb.Table("users as u").Select("u.firstname", "u.lastname", "a.address"). + Join("INNER", "address as a", "a.user_id=u.id"). + Where("u.email", "=", "loremipsum@lrmpsm.com").Sql() + fmt.Printf("Join Sql: \n%s\n\n", query) query, params = gb.Table("users").Select(). Where("id", "=", "1"). - Between("created_at", "2021-01-01", "2021-03-16"). - ToSql() - fmt.Printf("Between: \n%s\n%v\n\n", query, params) + Between("created_at", "2021-01-01", "2021-03-16").Prepare() + fmt.Printf("Between Prepare: \n%s\t%v\n", query, params) + query = gb.Table("users").Select(). + Where("id", "=", "1"). + Between("created_at", "2021-01-01", "2021-03-16").Sql() + fmt.Printf("Between Sql: \n%s\n\n", query) query, params = gb.Table("users").Select(). Where("id", "=", "1"). Between("created_at", "2021-01-01", "2021-03-16"). - Limit(1, 5). - ToSql() - fmt.Printf("Limit: \n%s\n%v\n\n", query, params) + Limit(1, 5).Prepare() + fmt.Printf("Limit Prepare: \n%s\t%v\n", query, params) + query = gb.Table("users").Select(). + Where("id", "=", "1"). + Between("created_at", "2021-01-01", "2021-03-16"). + Limit(1, 5).Sql() + fmt.Printf("Limit Sql: \n%s\n\n", query) query, params = gb.Table("users").Select(). Where("id", "=", "1"). Between("created_at", "2021-01-01", "2021-03-16"). - GroupBy("lastname"). - ToSql() - fmt.Printf("Group By: \n%s\n%v\n\n", query, params) + GroupBy("lastname").Prepare() + fmt.Printf("Group By Prepare: \n%s\t%v\n", query, params) + query = gb.Table("users").Select(). + Where("id", "=", "1"). + Between("created_at", "2021-01-01", "2021-03-16"). + GroupBy("lastname").Sql() + fmt.Printf("Group By Sql: \n%s\n\n", query) query, params = gb.Table("users").Select(). Where("id", "=", "1"). Between("created_at", "2021-01-01", "2021-03-16"). GroupBy("lastname"). - OrderBy("id"). - ToSql() - fmt.Printf("Order By: \n%s\n%v\n\n", query, params) + OrderBy("id").Prepare() + fmt.Printf("Order By Prepare: \n%s\t%v\n", query, params) + query = gb.Table("users").Select(). + Where("id", "=", "1"). + Between("created_at", "2021-01-01", "2021-03-16"). + GroupBy("lastname"). + OrderBy("id").Sql() + fmt.Printf("Order By Sql: \n%s\n\n", query) - query, params = gb.Table("users").Delete().Where("email", "=", "loremipsum@lrmpsm.com").ToSql() - fmt.Printf("Delete: \n%s\n%v\n\n", query, params) + query, params = gb.Table("users").Delete().Where("email", "=", "loremipsum@lrmpsm.com").Prepare() + fmt.Printf("Delete Prepare: \n%s\t%v\n", query, params) + query = gb.Table("users").Delete().Where("email", "=", "loremipsum@lrmpsm.com").Sql() + fmt.Printf("Delete Sql: \n%s\n\n", query) - query, params = gb.Table("users").Select().Where("lastname", "=", "lorem").ToSql() - query, params = gb.Table("users").Select().Where("lastname", "=", "ipsum").Union(query).ToSql() + query, params = gb.Table("users").Select().Where("lastname", "=", "lorem").Prepare() + query, params = gb.Table("users").Select().Where("lastname", "=", "ipsum").Union(query).Prepare() fmt.Printf("Union: \n%s\n%v\n\n", query, params) // example subquery mainBuilder := gobuilder.NewGoBuilder(gobuilder.Postgres) subBuilder := gobuilder.NewGoBuilder(gobuilder.Postgres) - query, params = subBuilder.Table("users").Select("id").Where("age", ">", 30).ToSql() - query, params = mainBuilder.Table("orders").Select("order_id", "user_id").Where("user_id", "IN", query).ToSql() + query, params = subBuilder.Table("users").Select("id").Where("age", ">", 30).Prepare() + query, params = mainBuilder.Table("orders").Select("order_id", "user_id").Where("user_id", "IN", query).Prepare() fmt.Printf("SubQuery: \n%s\n%v\n\n", query, params) }