+83

delete.go

··· 1 1 + package norm 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "database/sql" 6 6 + "fmt" 7 7 + "strings" 8 8 + ) 9 9 + 10 10 + type delete_ struct { 11 11 + from string 12 12 + where *Expr 13 13 + } 14 14 + 15 15 + func Delete() delete_ { 16 16 + return delete_{} 17 17 + } 18 18 + 19 19 + type DeleteOpt func(s *delete_) 20 20 + 21 21 + func (s delete_) From(table string) delete_ { 22 22 + s.from = table 23 23 + return s 24 24 + } 25 25 + 26 26 + func (s delete_) Where(expr Expr) delete_ { 27 27 + s.where = &expr 28 28 + return s 29 29 + } 30 30 + 31 31 + func (s delete_) Compile() (string, []any, error) { 32 32 + var sql strings.Builder 33 33 + var args []any 34 34 + 35 35 + sql.WriteString("DELETE ") 36 36 + 37 37 + if s.from == "" { 38 38 + return "", nil, fmt.Errorf("FROM clause is required") 39 39 + } 40 40 + sql.WriteString(" FROM ") 41 41 + sql.WriteString(s.from) 42 42 + 43 43 + if s.where != nil { 44 44 + sql.WriteString(" WHERE ") 45 45 + sql.WriteString(s.where.String()) 46 46 + 47 47 + args = s.where.Binds() 48 48 + } 49 49 + 50 50 + return sql.String(), args, nil 51 51 + } 52 52 + 53 53 + func (s delete_) Build(p Database) (*sql.Stmt, []any, error) { 54 54 + return Build(s, p) 55 55 + } 56 56 + 57 57 + func (s delete_) MustBuild(p Database) (*sql.Stmt, []any) { 58 58 + return MustBuild(s, p) 59 59 + } 60 60 + 61 61 + func (s delete_) Exec(p Database) (sql.Result, error) { 62 62 + return Exec(s, p) 63 63 + } 64 64 + 65 65 + func (s delete_) ExecContext(ctx context.Context, p Database) (sql.Result, error) { 66 66 + return ExecContext(ctx, s, p) 67 67 + } 68 68 + 69 69 + func (s delete_) Query(p Database) (*sql.Rows, error) { 70 70 + return Query(s, p) 71 71 + } 72 72 + 73 73 + func (s delete_) QueryContext(ctx context.Context, p Database) (*sql.Rows, error) { 74 74 + return QueryContext(ctx, s, p) 75 75 + } 76 76 + 77 77 + func (s delete_) QueryRow(p Database) (*sql.Row, error) { 78 78 + return QueryRow(s, p) 79 79 + } 80 80 + 81 81 + func (s delete_) QueryRowContext(ctx context.Context, p Database) (*sql.Row, error) { 82 82 + return QueryRowContext(ctx, s, p) 83 83 + }

+69

delete_test.go

··· 1 1 + package norm 2 2 + 3 3 + import ( 4 4 + _ "github.com/mattn/go-sqlite3" 5 5 + "testing" 6 6 + ) 7 7 + 8 8 + func TestDeleteIntegration_BasicQueries(t *testing.T) { 9 9 + tests := []struct { 10 10 + name string 11 11 + stmt Execer 12 12 + expectedRows int64 13 13 + }{ 14 14 + { 15 15 + name: "Delete all users", 16 16 + stmt: Delete().From("users"), 17 17 + expectedRows: 6, 18 18 + }, 19 19 + { 20 20 + name: "Delete active users only", 21 21 + stmt: Delete(). 22 22 + From("users"). 23 23 + Where(Eq("active", true)), 24 24 + expectedRows: 4, 25 25 + }, 26 26 + { 27 27 + name: "Select users in Engineering", 28 28 + stmt: Delete(). 29 29 + From("users"). 30 30 + Where(Eq("department", "Engineering")), 31 31 + expectedRows: 3, 32 32 + }, 33 33 + { 34 34 + name: "Delete users with age > 30", 35 35 + stmt: Delete(). 36 36 + From("users"). 37 37 + Where(Gt("age", 30)), 38 38 + expectedRows: 2, 39 39 + }, 40 40 + { 41 41 + name: "Delete users with salary between 70000 and 80000", 42 42 + stmt: Delete(). 43 43 + From("users"). 44 44 + Where(Gte("salary", 70000.0).And(Lte("salary", 80000.0))), 45 45 + expectedRows: 3, 46 46 + }, 47 47 + } 48 48 + 49 49 + for _, test := range tests { 50 50 + t.Run(test.name, func(t *testing.T) { 51 51 + db := setupTestDB(t) 52 52 + defer db.Close() 53 53 + 54 54 + res, err := test.stmt.Exec(db) 55 55 + if err != nil { 56 56 + t.Fatalf("Failed to execute query: %v", err) 57 57 + } 58 58 + 59 59 + count, err := res.RowsAffected() 60 60 + if err != nil { 61 61 + t.Fatalf("Failed to execute query: %v", err) 62 62 + } 63 63 + 64 64 + if count != test.expectedRows { 65 65 + t.Errorf("Expected %d rows, got %d", test.expectedRows, count) 66 66 + } 67 67 + }) 68 68 + } 69 69 + }

+120

expr.go

··· 1 1 + package norm 2 2 + 3 3 + import "fmt" 4 4 + 5 5 + type op string 6 6 + 7 7 + type Expr struct { 8 8 + kind ExprKind 9 9 + 10 10 + ident *IdentExpr 11 11 + binary *BinExpr 12 12 + value *ValueExpr 13 13 + } 14 14 + 15 15 + func (e Expr) String() string { 16 16 + switch e.kind { 17 17 + case exprKindIdent: 18 18 + return e.ident.String() 19 19 + case exprKindBinary: 20 20 + return e.binary.String() 21 21 + case exprKindValue: 22 22 + return e.value.String() 23 23 + } 24 24 + 25 25 + // unreachable 26 26 + return "" 27 27 + } 28 28 + 29 29 + func (e Expr) Binds() []any { 30 30 + switch e.kind { 31 31 + case exprKindIdent: 32 32 + return e.ident.Binds() 33 33 + case exprKindBinary: 34 34 + return e.binary.Binds() 35 35 + case exprKindValue: 36 36 + return e.value.Binds() 37 37 + } 38 38 + 39 39 + return nil 40 40 + } 41 41 + 42 42 + type ExprKind int 43 43 + 44 44 + const ( 45 45 + exprKindIdent ExprKind = iota 46 46 + exprKindBinary 47 47 + exprKindValue 48 48 + ) 49 49 + 50 50 + type IdentExpr string 51 51 + 52 52 + func (i IdentExpr) String() string { 53 53 + return string(i) 54 54 + } 55 55 + 56 56 + func (i IdentExpr) Binds() []any { 57 57 + return nil 58 58 + } 59 59 + 60 60 + func (i IdentExpr) AsExpr() Expr { 61 61 + return Expr{ 62 62 + kind: exprKindIdent, 63 63 + ident: &i, 64 64 + } 65 65 + } 66 66 + 67 67 + type ValueExpr struct { 68 68 + inner any 69 69 + } 70 70 + 71 71 + func (v ValueExpr) String() string { 72 72 + return "?" 73 73 + } 74 74 + 75 75 + func (v ValueExpr) Binds() []any { 76 76 + return []any{v.inner} 77 77 + } 78 78 + 79 79 + func (v ValueExpr) AsExpr() Expr { 80 80 + return Expr{ 81 81 + kind: exprKindValue, 82 82 + value: &v, 83 83 + } 84 84 + } 85 85 + 86 86 + type BinExpr struct { 87 87 + left Expr 88 88 + op op 89 89 + right Expr 90 90 + } 91 91 + 92 92 + func (b BinExpr) String() string { 93 93 + return fmt.Sprintf("(%s) %s (%s)", b.left.String(), b.op, b.right.String()) 94 94 + } 95 95 + 96 96 + func (b BinExpr) Binds() []any { 97 97 + binds := b.left.Binds() 98 98 + binds = append(binds, b.right.Binds()...) 99 99 + return binds 100 100 + } 101 101 + 102 102 + func (b BinExpr) AsExpr() Expr { 103 103 + return Expr{ 104 104 + kind: exprKindBinary, 105 105 + binary: &b, 106 106 + } 107 107 + } 108 108 + 109 109 + func buildBinExpr(left IdentExpr, op op, right any) Expr { 110 110 + return BinExpr{left.AsExpr(), op, ValueExpr{right}.AsExpr()}.AsExpr() 111 111 + } 112 112 + func Eq(left string, right any) Expr { return buildBinExpr(IdentExpr(left), "=", right) } 113 113 + func Neq(left string, right any) Expr { return buildBinExpr(IdentExpr(left), "<>", right) } 114 114 + func Gt(left string, right any) Expr { return buildBinExpr(IdentExpr(left), ">", right) } 115 115 + func Gte(left string, right any) Expr { return buildBinExpr(IdentExpr(left), ">=", right) } 116 116 + func Lt(left string, right any) Expr { return buildBinExpr(IdentExpr(left), "<", right) } 117 117 + func Lte(left string, right any) Expr { return buildBinExpr(IdentExpr(left), "<=", right) } 118 118 + 119 119 + func (l Expr) And(r Expr) Expr { return BinExpr{l, "and", r}.AsExpr() } 120 120 + func (l Expr) Or(r Expr) Expr { return BinExpr{l, "or", r}.AsExpr() }

+102

expr_test.go

··· 1 1 + package norm 2 2 + 3 3 + import ( 4 4 + "testing" 5 5 + ) 6 6 + 7 7 + func TestIdentExpr(t *testing.T) { 8 8 + ident := IdentExpr("username") 9 9 + 10 10 + if ident.String() != "username" { 11 11 + t.Errorf("Expected 'username', got '%s'", ident.String()) 12 12 + } 13 13 + 14 14 + if ident.Binds() != nil { 15 15 + t.Errorf("Expected nil binds, got %v", ident.Binds()) 16 16 + } 17 17 + 18 18 + expr := ident.AsExpr() 19 19 + if expr.kind != exprKindIdent { 20 20 + t.Errorf("Expected exprKindIdent, got %d", expr.kind) 21 21 + } 22 22 + 23 23 + if expr.String() != "username" { 24 24 + t.Errorf("Expected 'username', got '%s'", expr.String()) 25 25 + } 26 26 + } 27 27 + 28 28 + func TestValueExpr(t *testing.T) { 29 29 + value := ValueExpr{inner: "test"} 30 30 + 31 31 + if value.String() != "?" { 32 32 + t.Errorf("Expected '?', got '%s'", value.String()) 33 33 + } 34 34 + 35 35 + if value.Binds()[0] != "test" { 36 36 + t.Errorf("Expected %q, got %v", []any{"test"}, value.Binds()) 37 37 + } 38 38 + 39 39 + expr := value.AsExpr() 40 40 + if expr.kind != exprKindValue { 41 41 + t.Errorf("Expected exprKindValue, got %d", expr.kind) 42 42 + } 43 43 + } 44 44 + 45 45 + func TestBinaryExpressions(t *testing.T) { 46 46 + tests := []struct { 47 47 + name string 48 48 + expr Expr 49 49 + expected string 50 50 + }{ 51 51 + {"Eq", Eq("age", 25), "(age) = (?)"}, 52 52 + {"Neq", Neq("status", "active"), "(status) <> (?)"}, 53 53 + {"Gt", Gt("score", 100), "(score) > (?)"}, 54 54 + {"Gte", Gte("rating", 4.5), "(rating) >= (?)"}, 55 55 + {"Lt", Lt("count", 10), "(count) < (?)"}, 56 56 + {"Lte", Lte("price", 99.99), "(price) <= (?)"}, 57 57 + } 58 58 + 59 59 + for _, test := range tests { 60 60 + t.Run(test.name, func(t *testing.T) { 61 61 + if test.expr.String() != test.expected { 62 62 + t.Errorf("Expected '%s', got '%s'", test.expected, test.expr.String()) 63 63 + } 64 64 + 65 65 + if test.expr.kind != exprKindBinary { 66 66 + t.Errorf("Expected exprKindBinary, got %d", test.expr.kind) 67 67 + } 68 68 + }) 69 69 + } 70 70 + } 71 71 + 72 72 + func TestLogicalOperators(t *testing.T) { 73 73 + left := Eq("age", 25) 74 74 + right := Eq("status", "active") 75 75 + 76 76 + andExpr := left.And(right) 77 77 + expectedAnd := "((age) = (?)) and ((status) = (?))" 78 78 + if andExpr.String() != expectedAnd { 79 79 + t.Errorf("Expected '%s', got '%s'", expectedAnd, andExpr.String()) 80 80 + } 81 81 + 82 82 + orExpr := left.Or(right) 83 83 + expectedOr := "((age) = (?)) or ((status) = (?))" 84 84 + if orExpr.String() != expectedOr { 85 85 + t.Errorf("Expected '%s', got '%s'", expectedOr, orExpr.String()) 86 86 + } 87 87 + } 88 88 + 89 89 + func TestComplexExpressions(t *testing.T) { 90 90 + age := Eq("age", 25) 91 91 + status := Eq("status", "active") 92 92 + score := Gt("score", 100) 93 93 + 94 94 + complex := age. 95 95 + And(status). 96 96 + Or(score) 97 97 + expected := "(((age) = (?)) and ((status) = (?))) or ((score) > (?))" 98 98 + 99 99 + if complex.String() != expected { 100 100 + t.Errorf("Expected '%s', got '%s'", expected, complex.String()) 101 101 + } 102 102 + }

+143

insert.go

··· 1 1 + package norm 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "database/sql" 6 6 + "fmt" 7 7 + "strings" 8 8 + ) 9 9 + 10 10 + type insert struct { 11 11 + into string 12 12 + or InsertOr 13 13 + values []struct { 14 14 + col string 15 15 + val any 16 16 + } 17 17 + } 18 18 + 19 19 + type InsertOr int 20 20 + 21 21 + const ( 22 22 + None InsertOr = iota 23 23 + Abort 24 24 + Fail 25 25 + Ignore 26 26 + Replace 27 27 + Rollback 28 28 + ) 29 29 + 30 30 + func (i InsertOr) String() string { 31 31 + switch i { 32 32 + case Abort: 33 33 + return "ABORT" 34 34 + case Fail: 35 35 + return "FAIL" 36 36 + case Ignore: 37 37 + return "IGNORE" 38 38 + case Replace: 39 39 + return "REPLACE" 40 40 + case Rollback: 41 41 + return "ROLLBACK" 42 42 + default: 43 43 + return "" 44 44 + } 45 45 + } 46 46 + 47 47 + func Insert() insert { 48 48 + return insert{} 49 49 + } 50 50 + 51 51 + type InsertOpt func(s *insert) 52 52 + 53 53 + func (s insert) Into(table string) insert { 54 54 + s.into = table 55 55 + return s 56 56 + } 57 57 + 58 58 + func (s insert) Or(option InsertOr) insert { 59 59 + s.or = option 60 60 + return s 61 61 + } 62 62 + 63 63 + func (s insert) Value(column string, arg any) insert { 64 64 + s.values = append(s.values, struct { 65 65 + col string 66 66 + val any 67 67 + }{ 68 68 + column, arg, 69 69 + }) 70 70 + return s 71 71 + } 72 72 + 73 73 + func (s insert) Compile() (string, []any, error) { 74 74 + var sql strings.Builder 75 75 + var args []any 76 76 + 77 77 + sql.WriteString("INSERT ") 78 78 + 79 79 + if s.or != None { 80 80 + sql.WriteString("OR ") 81 81 + sql.WriteString(s.or.String()) 82 82 + sql.WriteString(" ") 83 83 + } 84 84 + 85 85 + if s.into == "" { 86 86 + return "", nil, fmt.Errorf("INTO clause is required") 87 87 + } 88 88 + sql.WriteString("INTO ") 89 89 + sql.WriteString(s.into) 90 90 + 91 91 + if len(s.values) == 0 { 92 92 + return "", nil, fmt.Errorf("no values supplied") 93 93 + } 94 94 + 95 95 + sql.WriteString(" (") 96 96 + 97 97 + for i, v := range s.values { 98 98 + if i != 0 { 99 99 + sql.WriteString(", ") 100 100 + } 101 101 + 102 102 + sql.WriteString(v.col) 103 103 + args = append(args, v.val) 104 104 + } 105 105 + 106 106 + sql.WriteString(") VALUES (") 107 107 + sql.WriteString(strings.TrimSuffix(strings.Repeat("?, ", len(s.values)), ", ")) 108 108 + sql.WriteString(")") 109 109 + 110 110 + return sql.String(), args, nil 111 111 + } 112 112 + 113 113 + func (s insert) Build(p Database) (*sql.Stmt, []any, error) { 114 114 + return Build(s, p) 115 115 + } 116 116 + 117 117 + func (s insert) MustBuild(p Database) (*sql.Stmt, []any) { 118 118 + return MustBuild(s, p) 119 119 + } 120 120 + 121 121 + func (s insert) Exec(p Database) (sql.Result, error) { 122 122 + return Exec(s, p) 123 123 + } 124 124 + 125 125 + func (s insert) ExecContext(ctx context.Context, p Database) (sql.Result, error) { 126 126 + return ExecContext(ctx, s, p) 127 127 + } 128 128 + 129 129 + func (s insert) Query(p Database) (*sql.Rows, error) { 130 130 + return Query(s, p) 131 131 + } 132 132 + 133 133 + func (s insert) QueryContext(ctx context.Context, p Database) (*sql.Rows, error) { 134 134 + return QueryContext(ctx, s, p) 135 135 + } 136 136 + 137 137 + func (s insert) QueryRow(p Database) (*sql.Row, error) { 138 138 + return QueryRow(s, p) 139 139 + } 140 140 + 141 141 + func (s insert) QueryRowContext(ctx context.Context, p Database) (*sql.Row, error) { 142 142 + return QueryRowContext(ctx, s, p) 143 143 + }

+58

insert_test.go

··· 1 1 + package norm 2 2 + 3 3 + import ( 4 4 + _ "github.com/mattn/go-sqlite3" 5 5 + "testing" 6 6 + ) 7 7 + 8 8 + func TestInsertBuild_Success(t *testing.T) { 9 9 + tests := []struct { 10 10 + name string 11 11 + stmt Compiler 12 12 + expectedSql string 13 13 + expectedArgs []any 14 14 + }{ 15 15 + { 16 16 + name: "Simple insert", 17 17 + stmt: Insert().Into("users").Value("name", "John"), 18 18 + expectedSql: "INSERT INTO users (name) VALUES (?)", 19 19 + expectedArgs: []any{"John"}, 20 20 + }, 21 21 + { 22 22 + name: "Replace clause", 23 23 + stmt: Insert().Or(Replace).Into("users").Value("name", "John"), 24 24 + expectedSql: "INSERT OR REPLACE INTO users (name) VALUES (?)", 25 25 + expectedArgs: []any{"John"}, 26 26 + }, 27 27 + { 28 28 + name: "More values", 29 29 + stmt: Insert().Into("users").Value("name", "John").Value("age", 35), 30 30 + expectedSql: "INSERT INTO users (name, age) VALUES (?, ?)", 31 31 + expectedArgs: []any{"John", 35}, 32 32 + }, 33 33 + } 34 34 + 35 35 + for _, test := range tests { 36 36 + t.Run(test.name, func(t *testing.T) { 37 37 + sql, args, err := test.stmt.Compile() 38 38 + 39 39 + if err != nil { 40 40 + t.Errorf("Expected no error, got %v", err) 41 41 + } 42 42 + 43 43 + if sql != test.expectedSql { 44 44 + t.Errorf("Expected '%s', got '%s'", test.expectedSql, sql) 45 45 + } 46 46 + 47 47 + if len(args) != len(test.expectedArgs) { 48 48 + t.Errorf("Expected '%d' args, got '%d' args", len(test.expectedArgs), len(args)) 49 49 + } 50 50 + 51 51 + for i := range len(args) { 52 52 + if args[i] != test.expectedArgs[i] { 53 53 + t.Errorf("Expected '%v', got '%v' at index %d", test.expectedArgs[i], args[i], i) 54 54 + } 55 55 + } 56 56 + }) 57 57 + } 58 58 + }

-434

query.go

··· 1 1 - package norm 2 2 - 3 3 - import ( 4 4 - "fmt" 5 5 - "strconv" 6 6 - "strings" 7 7 - ) 8 8 - 9 9 - // use with prepared statements 10 10 - func Placeholder[T any]() T { 11 11 - var zero T 12 12 - return zero 13 13 - } 14 14 - 15 15 - type op string 16 16 - 17 17 - type Expr struct { 18 18 - kind ExprKind 19 19 - 20 20 - ident *IdentExpr 21 21 - binary *BinExpr 22 22 - value *ValueExpr 23 23 - } 24 24 - 25 25 - func (e Expr) String() string { 26 26 - switch e.kind { 27 27 - case exprKindIdent: 28 28 - return e.ident.String() 29 29 - case exprKindBinary: 30 30 - return e.binary.String() 31 31 - case exprKindValue: 32 32 - return e.value.String() 33 33 - } 34 34 - 35 35 - // unreachable 36 36 - return "" 37 37 - } 38 38 - 39 39 - func (e Expr) Binds() []any { 40 40 - switch e.kind { 41 41 - case exprKindIdent: 42 42 - return e.ident.Binds() 43 43 - case exprKindBinary: 44 44 - return e.binary.Binds() 45 45 - case exprKindValue: 46 46 - return e.value.Binds() 47 47 - } 48 48 - 49 49 - return nil 50 50 - } 51 51 - 52 52 - type ExprKind int 53 53 - 54 54 - const ( 55 55 - exprKindIdent ExprKind = iota 56 56 - exprKindBinary 57 57 - exprKindValue 58 58 - ) 59 59 - 60 60 - type IdentExpr string 61 61 - 62 62 - func (i IdentExpr) String() string { 63 63 - return string(i) 64 64 - } 65 65 - 66 66 - func (i IdentExpr) Binds() []any { 67 67 - return nil 68 68 - } 69 69 - 70 70 - func (i IdentExpr) AsExpr() Expr { 71 71 - return Expr{ 72 72 - kind: exprKindIdent, 73 73 - ident: &i, 74 74 - } 75 75 - } 76 76 - 77 77 - type ValueExpr struct { 78 78 - inner any 79 79 - } 80 80 - 81 81 - func (v ValueExpr) String() string { 82 82 - return "?" 83 83 - } 84 84 - 85 85 - func (v ValueExpr) Binds() []any { 86 86 - return []any{v.inner} 87 87 - } 88 88 - 89 89 - func (v ValueExpr) AsExpr() Expr { 90 90 - return Expr{ 91 91 - kind: exprKindValue, 92 92 - value: &v, 93 93 - } 94 94 - } 95 95 - 96 96 - type BinExpr struct { 97 97 - left Expr 98 98 - op op 99 99 - right Expr 100 100 - } 101 101 - 102 102 - func (b BinExpr) String() string { 103 103 - return fmt.Sprintf("(%s) %s (%s)", b.left.String(), b.op, b.right.String()) 104 104 - } 105 105 - 106 106 - func (b BinExpr) Binds() []any { 107 107 - binds := b.left.Binds() 108 108 - binds = append(binds, b.right.Binds()...) 109 109 - return binds 110 110 - } 111 111 - 112 112 - func (b BinExpr) AsExpr() Expr { 113 113 - return Expr{ 114 114 - kind: exprKindBinary, 115 115 - binary: &b, 116 116 - } 117 117 - } 118 118 - 119 119 - func buildBinExpr(left IdentExpr, op op, right any) Expr { 120 120 - return BinExpr{left.AsExpr(), op, ValueExpr{right}.AsExpr()}.AsExpr() 121 121 - } 122 122 - func Eq(left string, right any) Expr { return buildBinExpr(IdentExpr(left), "=", right) } 123 123 - func Neq(left string, right any) Expr { return buildBinExpr(IdentExpr(left), "<>", right) } 124 124 - func Gt(left string, right any) Expr { return buildBinExpr(IdentExpr(left), ">", right) } 125 125 - func Gte(left string, right any) Expr { return buildBinExpr(IdentExpr(left), ">=", right) } 126 126 - func Lt(left string, right any) Expr { return buildBinExpr(IdentExpr(left), "<", right) } 127 127 - func Lte(left string, right any) Expr { return buildBinExpr(IdentExpr(left), "<=", right) } 128 128 - 129 129 - func (l Expr) And(r Expr) Expr { return BinExpr{l, "and", r}.AsExpr() } 130 130 - func (l Expr) Or(r Expr) Expr { return BinExpr{l, "or", r}.AsExpr() } 131 131 - 132 132 - type select_ struct { 133 133 - resultColumns []string // TODO: strongly type result columns 134 134 - from string // table-or-subquery expr 135 135 - where *Expr 136 136 - orderBy []orderBy 137 137 - groupBy []groupBy 138 138 - limit *limit 139 139 - } 140 140 - 141 141 - type orderBy struct { 142 142 - field string 143 143 - direction Direction 144 144 - } 145 145 - 146 146 - type groupBy struct { 147 147 - field string 148 148 - } 149 149 - 150 150 - type limit struct { 151 151 - limit int 152 152 - } 153 153 - 154 154 - func Select(cols ...string) select_ { 155 155 - return select_{ 156 156 - resultColumns: cols, 157 157 - } 158 158 - } 159 159 - 160 160 - type SelectOpt func(s *select_) 161 161 - 162 162 - func (s select_) From(table string) select_ { 163 163 - s.from = table 164 164 - return s 165 165 - } 166 166 - 167 167 - func (s select_) Where(expr Expr) select_ { 168 168 - s.where = &expr 169 169 - return s 170 170 - } 171 171 - 172 172 - type Direction string 173 173 - 174 174 - const ( 175 175 - Ascending Direction = "asc" 176 176 - Descending Direction = "desc" 177 177 - ) 178 178 - 179 179 - func (s select_) OrderBy(field string, direction Direction) select_ { 180 180 - s.orderBy = append(s.orderBy, orderBy{ 181 181 - field: field, 182 182 - direction: direction, 183 183 - }) 184 184 - return s 185 185 - } 186 186 - 187 187 - func (s select_) GroupBy(field string) select_ { 188 188 - s.groupBy = append(s.groupBy, groupBy{ 189 189 - field: field, 190 190 - }) 191 191 - return s 192 192 - } 193 193 - 194 194 - func (s select_) Limit(i int) select_ { 195 195 - s.limit = &limit{ 196 196 - limit: i, 197 197 - } 198 198 - return s 199 199 - } 200 200 - 201 201 - func (s select_) Build() (string, []any, error) { 202 202 - var sql strings.Builder 203 203 - var args []any 204 204 - 205 205 - sql.WriteString("SELECT ") 206 206 - if len(s.resultColumns) == 0 { 207 207 - return "", nil, fmt.Errorf("result columns empty") 208 208 - } else { 209 209 - for i, col := range s.resultColumns { 210 210 - if i > 0 { 211 211 - sql.WriteString(", ") 212 212 - } 213 213 - sql.WriteString(col) 214 214 - } 215 215 - } 216 216 - 217 217 - if s.from == "" { 218 218 - return "", nil, fmt.Errorf("FROM clause is required") 219 219 - } 220 220 - sql.WriteString(" FROM ") 221 221 - sql.WriteString(s.from) 222 222 - 223 223 - if s.where != nil { 224 224 - sql.WriteString(" WHERE ") 225 225 - sql.WriteString(s.where.String()) 226 226 - 227 227 - args = s.where.Binds() 228 228 - } 229 229 - 230 230 - // GROUP BY clause 231 231 - if len(s.groupBy) > 0 { 232 232 - sql.WriteString(" GROUP BY ") 233 233 - for i, gb := range s.groupBy { 234 234 - if i > 0 { 235 235 - sql.WriteString(", ") 236 236 - } 237 237 - sql.WriteString(gb.field) 238 238 - } 239 239 - } 240 240 - 241 241 - // ORDER BY clause 242 242 - if len(s.orderBy) > 0 { 243 243 - sql.WriteString(" ORDER BY ") 244 244 - for i, ob := range s.orderBy { 245 245 - if i > 0 { 246 246 - sql.WriteString(", ") 247 247 - } 248 248 - sql.WriteString(ob.field) 249 249 - sql.WriteString(" ") 250 250 - sql.WriteString(string(ob.direction)) 251 251 - } 252 252 - } 253 253 - 254 254 - // LIMIT clause 255 255 - if s.limit != nil { 256 256 - if s.limit.limit <= 0 { 257 257 - return "", nil, fmt.Errorf("LIMIT must be positive, got %d", s.limit.limit) 258 258 - } 259 259 - sql.WriteString(" LIMIT ") 260 260 - sql.WriteString(strconv.Itoa(s.limit.limit)) 261 261 - } 262 262 - 263 263 - return sql.String(), args, nil 264 264 - } 265 265 - 266 266 - func (s select_) MustBuild() (string, []any) { 267 267 - sql, args, err := s.Build() 268 268 - if err != nil { 269 269 - panic(err) 270 270 - } 271 271 - return sql, args 272 272 - } 273 273 - 274 274 - type delete_ struct { 275 275 - from string 276 276 - where *Expr 277 277 - } 278 278 - 279 279 - func Delete() delete_ { 280 280 - return delete_{} 281 281 - } 282 282 - 283 283 - type DeleteOpt func(s *delete_) 284 284 - 285 285 - func (s delete_) From(table string) delete_ { 286 286 - s.from = table 287 287 - return s 288 288 - } 289 289 - 290 290 - func (s delete_) Where(expr Expr) delete_ { 291 291 - s.where = &expr 292 292 - return s 293 293 - } 294 294 - 295 295 - func (s delete_) Build() (string, []any, error) { 296 296 - var sql strings.Builder 297 297 - var args []any 298 298 - 299 299 - sql.WriteString("DELETE ") 300 300 - 301 301 - if s.from == "" { 302 302 - return "", nil, fmt.Errorf("FROM clause is required") 303 303 - } 304 304 - sql.WriteString(" FROM ") 305 305 - sql.WriteString(s.from) 306 306 - 307 307 - if s.where != nil { 308 308 - sql.WriteString(" WHERE ") 309 309 - sql.WriteString(s.where.String()) 310 310 - 311 311 - args = s.where.Binds() 312 312 - } 313 313 - 314 314 - return sql.String(), args, nil 315 315 - } 316 316 - 317 317 - func (s delete_) MustBuild() (string, []any) { 318 318 - sql, args, err := s.Build() 319 319 - if err != nil { 320 320 - panic(err) 321 321 - } 322 322 - return sql, args 323 323 - } 324 324 - 325 325 - type insert struct { 326 326 - into string 327 327 - or InsertOr 328 328 - values []struct { 329 329 - col string 330 330 - val any 331 331 - } 332 332 - } 333 333 - 334 334 - type InsertOr int 335 335 - 336 336 - const ( 337 337 - None InsertOr = iota 338 338 - Abort 339 339 - Fail 340 340 - Ignore 341 341 - Replace 342 342 - Rollback 343 343 - ) 344 344 - 345 345 - func (i InsertOr) String() string { 346 346 - switch i { 347 347 - case Abort: 348 348 - return "ABORT" 349 349 - case Fail: 350 350 - return "FAIL" 351 351 - case Ignore: 352 352 - return "IGNORE" 353 353 - case Replace: 354 354 - return "REPLACE" 355 355 - case Rollback: 356 356 - return "ROLLBACK" 357 357 - default: 358 358 - return "" 359 359 - } 360 360 - } 361 361 - 362 362 - func Insert() insert { 363 363 - return insert{} 364 364 - } 365 365 - 366 366 - type InsertOpt func(s *insert) 367 367 - 368 368 - func (s insert) Into(table string) insert { 369 369 - s.into = table 370 370 - return s 371 371 - } 372 372 - 373 373 - func (s insert) Or(option InsertOr) insert { 374 374 - s.or = option 375 375 - return s 376 376 - } 377 377 - 378 378 - func (s insert) Value(column string, arg any) insert { 379 379 - s.values = append(s.values, struct { 380 380 - col string 381 381 - val any 382 382 - }{ 383 383 - column, arg, 384 384 - }) 385 385 - return s 386 386 - } 387 387 - 388 388 - func (s insert) Build() (string, []any, error) { 389 389 - var sql strings.Builder 390 390 - var args []any 391 391 - 392 392 - sql.WriteString("INSERT ") 393 393 - 394 394 - if s.or != None { 395 395 - sql.WriteString("OR ") 396 396 - sql.WriteString(s.or.String()) 397 397 - sql.WriteString(" ") 398 398 - } 399 399 - 400 400 - if s.into == "" { 401 401 - return "", nil, fmt.Errorf("INTO clause is required") 402 402 - } 403 403 - sql.WriteString("INTO ") 404 404 - sql.WriteString(s.into) 405 405 - 406 406 - if len(s.values) == 0 { 407 407 - return "", nil, fmt.Errorf("no values supplied") 408 408 - } 409 409 - 410 410 - sql.WriteString(" (") 411 411 - 412 412 - for i, v := range s.values { 413 413 - if i != 0 { 414 414 - sql.WriteString(", ") 415 415 - } 416 416 - 417 417 - sql.WriteString(v.col) 418 418 - args = append(args, v.val) 419 419 - } 420 420 - 421 421 - sql.WriteString(") VALUES (") 422 422 - sql.WriteString(strings.TrimSuffix(strings.Repeat("?, ", len(s.values)), ", ")) 423 423 - sql.WriteString(")") 424 424 - 425 425 - return sql.String(), args, nil 426 426 - } 427 427 - 428 428 - func (s insert) MustBuild() (string, []any) { 429 429 - sql, args, err := s.Build() 430 430 - if err != nil { 431 431 - panic(err) 432 432 - } 433 433 - return sql, args 434 434 - }

+13 -261

query_test.go select_test.go

··· 1 1 package norm 2 2 3 3 import ( 4 4 + _ "github.com/mattn/go-sqlite3" 4 5 "testing" 5 5 - 6 6 - _ "github.com/mattn/go-sqlite3" 7 6 ) 8 7 9 9 - func TestIdentExpr(t *testing.T) { 10 10 - ident := IdentExpr("username") 11 11 - 12 12 - if ident.String() != "username" { 13 13 - t.Errorf("Expected 'username', got '%s'", ident.String()) 14 14 - } 15 15 - 16 16 - if ident.Binds() != nil { 17 17 - t.Errorf("Expected nil binds, got %v", ident.Binds()) 18 18 - } 19 19 - 20 20 - expr := ident.AsExpr() 21 21 - if expr.kind != exprKindIdent { 22 22 - t.Errorf("Expected exprKindIdent, got %d", expr.kind) 23 23 - } 24 24 - 25 25 - if expr.String() != "username" { 26 26 - t.Errorf("Expected 'username', got '%s'", expr.String()) 27 27 - } 28 28 - } 29 29 - 30 30 - func TestValueExpr(t *testing.T) { 31 31 - value := ValueExpr{inner: "test"} 32 32 - 33 33 - if value.String() != "?" { 34 34 - t.Errorf("Expected '?', got '%s'", value.String()) 35 35 - } 36 36 - 37 37 - if value.Binds()[0] != "test" { 38 38 - t.Errorf("Expected %q, got %v", []any{"test"}, value.Binds()) 39 39 - } 40 40 - 41 41 - expr := value.AsExpr() 42 42 - if expr.kind != exprKindValue { 43 43 - t.Errorf("Expected exprKindValue, got %d", expr.kind) 44 44 - } 45 45 - } 46 46 - 47 47 - func TestBinaryExpressions(t *testing.T) { 48 48 - tests := []struct { 49 49 - name string 50 50 - expr Expr 51 51 - expected string 52 52 - }{ 53 53 - {"Eq", Eq("age", 25), "(age) = (?)"}, 54 54 - {"Neq", Neq("status", "active"), "(status) <> (?)"}, 55 55 - {"Gt", Gt("score", 100), "(score) > (?)"}, 56 56 - {"Gte", Gte("rating", 4.5), "(rating) >= (?)"}, 57 57 - {"Lt", Lt("count", 10), "(count) < (?)"}, 58 58 - {"Lte", Lte("price", 99.99), "(price) <= (?)"}, 59 59 - } 60 60 - 61 61 - for _, test := range tests { 62 62 - t.Run(test.name, func(t *testing.T) { 63 63 - if test.expr.String() != test.expected { 64 64 - t.Errorf("Expected '%s', got '%s'", test.expected, test.expr.String()) 65 65 - } 66 66 - 67 67 - if test.expr.kind != exprKindBinary { 68 68 - t.Errorf("Expected exprKindBinary, got %d", test.expr.kind) 69 69 - } 70 70 - }) 71 71 - } 72 72 - } 73 73 - 74 74 - func TestLogicalOperators(t *testing.T) { 75 75 - left := Eq("age", 25) 76 76 - right := Eq("status", "active") 77 77 - 78 78 - andExpr := left.And(right) 79 79 - expectedAnd := "((age) = (?)) and ((status) = (?))" 80 80 - if andExpr.String() != expectedAnd { 81 81 - t.Errorf("Expected '%s', got '%s'", expectedAnd, andExpr.String()) 82 82 - } 83 83 - 84 84 - orExpr := left.Or(right) 85 85 - expectedOr := "((age) = (?)) or ((status) = (?))" 86 86 - if orExpr.String() != expectedOr { 87 87 - t.Errorf("Expected '%s', got '%s'", expectedOr, orExpr.String()) 88 88 - } 89 89 - } 90 90 - 91 91 - func TestComplexExpressions(t *testing.T) { 92 92 - age := Eq("age", 25) 93 93 - status := Eq("status", "active") 94 94 - score := Gt("score", 100) 95 95 - 96 96 - complex := age. 97 97 - And(status). 98 98 - Or(score) 99 99 - expected := "(((age) = (?)) and ((status) = (?))) or ((score) > (?))" 100 100 - 101 101 - if complex.String() != expected { 102 102 - t.Errorf("Expected '%s', got '%s'", expected, complex.String()) 103 103 - } 104 104 - } 105 105 - 106 8 func TestSelectBasic(t *testing.T) { 107 9 s := Select("name", "age") 108 10 ··· 159 61 func TestSelectBuild_Success(t *testing.T) { 160 62 tests := []struct { 161 63 name string 162 162 - stmt select_ 64 64 + stmt Compiler 163 65 expectedSql string 164 66 expectedArgs []any 165 67 }{ ··· 225 127 226 128 for _, test := range tests { 227 129 t.Run(test.name, func(t *testing.T) { 228 228 - sql, args, err := test.stmt.Build() 130 130 + sql, args, err := test.stmt.Compile() 229 131 230 132 if err != nil { 231 133 t.Errorf("Expected no error, got %v", err) ··· 251 153 func TestSelectBuild_Errors(t *testing.T) { 252 154 tests := []struct { 253 155 name string 254 254 - stmt select_ 156 156 + stmt Compiler 255 157 expectedError string 256 158 }{ 257 159 { ··· 282 184 283 185 for _, test := range tests { 284 186 t.Run(test.name, func(t *testing.T) { 285 285 - sql, args, err := test.stmt.Build() 187 187 + sql, args, err := test.stmt.Compile() 286 188 287 189 if err == nil { 288 190 t.Error("Expected error, got nil") ··· 300 202 t.Errorf("Expected empty args on error, got '%q'", args) 301 203 } 302 204 }) 303 303 - } 304 304 - } 305 305 - 306 306 - func TestDirections(t *testing.T) { 307 307 - if Ascending != "asc" { 308 308 - t.Errorf("Expected ASC to be 'asc', got '%s'", Ascending) 309 309 - } 310 310 - 311 311 - if Descending != "desc" { 312 312 - t.Errorf("Expected DESC to be 'desc', got '%s'", Descending) 313 205 } 314 206 } 315 207 ··· 402 294 403 295 for _, test := range tests { 404 296 t.Run(test.name, func(t *testing.T) { 405 405 - sql, args, err := test.stmt.Build() 297 297 + rows, err := test.stmt.Query(db) 406 298 if err != nil { 407 299 t.Fatalf("Failed to build query: %v", err) 408 300 } 409 301 410 410 - rows, err := db.Query(sql, args...) 411 411 - if err != nil { 412 412 - t.Fatalf("Failed to execute query: %v", err) 413 413 - } 414 414 - defer rows.Close() 415 415 - 416 302 count := 0 417 303 for rows.Next() { 418 304 count++ ··· 438 324 Or(Eq("department", "Marketing").And(Lt("age", 30))), 439 325 ) 440 326 441 441 - sql, args := s.MustBuild() 442 442 - 443 443 - rows, err := db.Query(sql, args...) 327 327 + rows, err := s.Query(db) 444 328 if err != nil { 445 329 t.Fatalf("Failed to execute query: %v", err) 446 330 } ··· 479 363 OrderBy("department", Ascending). 480 364 OrderBy("age", Descending) 481 365 482 482 - sql, args := s.MustBuild() 483 483 - 484 484 - rows, err := db.Query(sql, args...) 366 366 + rows, err := s.Query(db) 485 367 if err != nil { 486 368 t.Fatalf("Failed to execute query: %v", err) 487 369 } ··· 522 404 GroupBy("department"). 523 405 OrderBy("user_count", Descending) 524 406 525 525 - sql, args := s.MustBuild() 526 526 - 527 527 - rows, err := db.Query(sql, args...) 407 407 + rows, err := s.Query(db) 528 408 if err != nil { 529 409 t.Fatalf("Failed to execute query: %v", err) 530 410 } ··· 563 443 OrderBy("salary", Descending). 564 444 Limit(2) 565 445 566 566 - sql, args := s.MustBuild() 567 567 - 568 568 - rows, err := db.Query(sql, args...) 446 446 + rows, err := s.Query(db) 569 447 if err != nil { 570 448 t.Fatalf("Failed to execute query: %v", err) 571 449 } ··· 610 488 From("users"). 611 489 Where(Eq("name", "John Doe")) 612 490 613 613 - sql, args := s.MustBuild() 614 614 - 615 615 - rows, err := db.Query(sql, args...) 491 491 + rows, err := s.Query(db) 616 492 if err != nil { 617 493 t.Fatalf("Failed to execute query: %v", err) 618 494 } ··· 633 509 From("users"). 634 510 Where(Eq("active", false)) 635 511 636 636 - sql, args := s.MustBuild() 637 637 - 638 638 - rows, err := db.Query(sql, args...) 512 512 + rows, err := s.Query(db) 639 513 if err != nil { 640 514 t.Fatalf("Failed to execute query: %v", err) 641 515 } ··· 656 530 From("users"). 657 531 Where(Gte("salary", 80000.0)) 658 532 659 659 - sql, args := s.MustBuild() 660 660 - 661 661 - rows, err := db.Query(sql, args...) 533 533 + rows, err := s.Query(db) 662 534 if err != nil { 663 535 t.Fatalf("Failed to execute query: %v", err) 664 536 } ··· 674 546 } 675 547 }) 676 548 } 677 677 - 678 678 - func TestDeleteIntegration_BasicQueries(t *testing.T) { 679 679 - tests := []struct { 680 680 - name string 681 681 - stmt delete_ 682 682 - expectedRows int64 683 683 - }{ 684 684 - { 685 685 - name: "Delete all users", 686 686 - stmt: Delete().From("users"), 687 687 - expectedRows: 6, 688 688 - }, 689 689 - { 690 690 - name: "Delete active users only", 691 691 - stmt: Delete(). 692 692 - From("users"). 693 693 - Where(Eq("active", true)), 694 694 - expectedRows: 4, 695 695 - }, 696 696 - { 697 697 - name: "Select users in Engineering", 698 698 - stmt: Delete(). 699 699 - From("users"). 700 700 - Where(Eq("department", "Engineering")), 701 701 - expectedRows: 3, 702 702 - }, 703 703 - { 704 704 - name: "Delete users with age > 30", 705 705 - stmt: Delete(). 706 706 - From("users"). 707 707 - Where(Gt("age", 30)), 708 708 - expectedRows: 2, 709 709 - }, 710 710 - { 711 711 - name: "Delete users with salary between 70000 and 80000", 712 712 - stmt: Delete(). 713 713 - From("users"). 714 714 - Where(Gte("salary", 70000.0).And(Lte("salary", 80000.0))), 715 715 - expectedRows: 3, 716 716 - }, 717 717 - } 718 718 - 719 719 - for _, test := range tests { 720 720 - t.Run(test.name, func(t *testing.T) { 721 721 - db := setupTestDB(t) 722 722 - defer db.Close() 723 723 - 724 724 - sql, args, err := test.stmt.Build() 725 725 - if err != nil { 726 726 - t.Fatalf("Failed to build query: %v", err) 727 727 - } 728 728 - 729 729 - res, err := db.Exec(sql, args...) 730 730 - if err != nil { 731 731 - t.Fatalf("Failed to execute query: %v", err) 732 732 - } 733 733 - 734 734 - count, err := res.RowsAffected() 735 735 - if err != nil { 736 736 - t.Fatalf("Failed to execute query: %v", err) 737 737 - } 738 738 - 739 739 - if count != test.expectedRows { 740 740 - t.Errorf("Expected %d rows, got %d", test.expectedRows, count) 741 741 - } 742 742 - }) 743 743 - } 744 744 - } 745 745 - 746 746 - func TestInsertBuild_Success(t *testing.T) { 747 747 - tests := []struct { 748 748 - name string 749 749 - stmt insert 750 750 - expectedSql string 751 751 - expectedArgs []any 752 752 - }{ 753 753 - { 754 754 - name: "Simple insert", 755 755 - stmt: Insert().Into("users").Value("name", "John"), 756 756 - expectedSql: "INSERT INTO users (name) VALUES (?)", 757 757 - expectedArgs: []any{"John"}, 758 758 - }, 759 759 - { 760 760 - name: "Replace clause", 761 761 - stmt: Insert().Or(Replace).Into("users").Value("name", "John"), 762 762 - expectedSql: "INSERT OR REPLACE INTO users (name) VALUES (?)", 763 763 - expectedArgs: []any{"John"}, 764 764 - }, 765 765 - { 766 766 - name: "More values", 767 767 - stmt: Insert().Into("users").Value("name", "John").Value("age", 35), 768 768 - expectedSql: "INSERT INTO users (name, age) VALUES (?, ?)", 769 769 - expectedArgs: []any{"John", 35}, 770 770 - }, 771 771 - } 772 772 - 773 773 - for _, test := range tests { 774 774 - t.Run(test.name, func(t *testing.T) { 775 775 - sql, args, err := test.stmt.Build() 776 776 - 777 777 - if err != nil { 778 778 - t.Errorf("Expected no error, got %v", err) 779 779 - } 780 780 - 781 781 - if sql != test.expectedSql { 782 782 - t.Errorf("Expected '%s', got '%s'", test.expectedSql, sql) 783 783 - } 784 784 - 785 785 - if len(args) != len(test.expectedArgs) { 786 786 - t.Errorf("Expected '%d' args, got '%d' args", len(test.expectedArgs), len(args)) 787 787 - } 788 788 - 789 789 - for i := range len(args) { 790 790 - if args[i] != test.expectedArgs[i] { 791 791 - t.Errorf("Expected '%v', got '%v' at index %d", test.expectedArgs[i], args[i], i) 792 792 - } 793 793 - } 794 794 - }) 795 795 - } 796 796 - }

+168

select.go

··· 1 1 + package norm 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "database/sql" 6 6 + "fmt" 7 7 + "strconv" 8 8 + "strings" 9 9 + ) 10 10 + 11 11 + type select_ struct { 12 12 + resultColumns []string // TODO: strongly type result columns 13 13 + from string // table-or-subquery expr 14 14 + where *Expr 15 15 + orderBy []orderBy 16 16 + groupBy []groupBy 17 17 + limit *limit 18 18 + } 19 19 + 20 20 + type orderBy struct { 21 21 + field string 22 22 + direction Direction 23 23 + } 24 24 + 25 25 + type groupBy struct { 26 26 + field string 27 27 + } 28 28 + 29 29 + type limit struct { 30 30 + limit int 31 31 + } 32 32 + 33 33 + func Select(cols ...string) select_ { 34 34 + return select_{ 35 35 + resultColumns: cols, 36 36 + } 37 37 + } 38 38 + 39 39 + type SelectOpt func(s *select_) 40 40 + 41 41 + func (s select_) From(table string) select_ { 42 42 + s.from = table 43 43 + return s 44 44 + } 45 45 + 46 46 + func (s select_) Where(expr Expr) select_ { 47 47 + s.where = &expr 48 48 + return s 49 49 + } 50 50 + 51 51 + func (s select_) OrderBy(field string, direction Direction) select_ { 52 52 + s.orderBy = append(s.orderBy, orderBy{ 53 53 + field: field, 54 54 + direction: direction, 55 55 + }) 56 56 + return s 57 57 + } 58 58 + 59 59 + func (s select_) GroupBy(field string) select_ { 60 60 + s.groupBy = append(s.groupBy, groupBy{ 61 61 + field: field, 62 62 + }) 63 63 + return s 64 64 + } 65 65 + 66 66 + func (s select_) Limit(i int) select_ { 67 67 + s.limit = &limit{ 68 68 + limit: i, 69 69 + } 70 70 + return s 71 71 + } 72 72 + 73 73 + func (s select_) Compile() (string, []any, error) { 74 74 + var sql strings.Builder 75 75 + var args []any 76 76 + 77 77 + sql.WriteString("SELECT ") 78 78 + if len(s.resultColumns) == 0 { 79 79 + return "", nil, fmt.Errorf("result columns empty") 80 80 + } else { 81 81 + for i, col := range s.resultColumns { 82 82 + if i > 0 { 83 83 + sql.WriteString(", ") 84 84 + } 85 85 + sql.WriteString(col) 86 86 + } 87 87 + } 88 88 + 89 89 + if s.from == "" { 90 90 + return "", nil, fmt.Errorf("FROM clause is required") 91 91 + } 92 92 + sql.WriteString(" FROM ") 93 93 + sql.WriteString(s.from) 94 94 + 95 95 + if s.where != nil { 96 96 + sql.WriteString(" WHERE ") 97 97 + sql.WriteString(s.where.String()) 98 98 + 99 99 + args = s.where.Binds() 100 100 + } 101 101 + 102 102 + // GROUP BY clause 103 103 + if len(s.groupBy) > 0 { 104 104 + sql.WriteString(" GROUP BY ") 105 105 + for i, gb := range s.groupBy { 106 106 + if i > 0 { 107 107 + sql.WriteString(", ") 108 108 + } 109 109 + sql.WriteString(gb.field) 110 110 + } 111 111 + } 112 112 + 113 113 + // ORDER BY clause 114 114 + if len(s.orderBy) > 0 { 115 115 + sql.WriteString(" ORDER BY ") 116 116 + for i, ob := range s.orderBy { 117 117 + if i > 0 { 118 118 + sql.WriteString(", ") 119 119 + } 120 120 + sql.WriteString(ob.field) 121 121 + sql.WriteString(" ") 122 122 + sql.WriteString(string(ob.direction)) 123 123 + } 124 124 + } 125 125 + 126 126 + // LIMIT clause 127 127 + if s.limit != nil { 128 128 + if s.limit.limit <= 0 { 129 129 + return "", nil, fmt.Errorf("LIMIT must be positive, got %d", s.limit.limit) 130 130 + } 131 131 + sql.WriteString(" LIMIT ") 132 132 + sql.WriteString(strconv.Itoa(s.limit.limit)) 133 133 + } 134 134 + 135 135 + return sql.String(), args, nil 136 136 + } 137 137 + 138 138 + func (s select_) Build(p Database) (*sql.Stmt, []any, error) { 139 139 + return Build(s, p) 140 140 + } 141 141 + 142 142 + func (s select_) MustBuild(p Database) (*sql.Stmt, []any) { 143 143 + return MustBuild(s, p) 144 144 + } 145 145 + 146 146 + func (s select_) Exec(p Database) (sql.Result, error) { 147 147 + return Exec(s, p) 148 148 + } 149 149 + 150 150 + func (s select_) ExecContext(ctx context.Context, p Database) (sql.Result, error) { 151 151 + return ExecContext(ctx, s, p) 152 152 + } 153 153 + 154 154 + func (s select_) Query(p Database) (*sql.Rows, error) { 155 155 + return Query(s, p) 156 156 + } 157 157 + 158 158 + func (s select_) QueryContext(ctx context.Context, p Database) (*sql.Rows, error) { 159 159 + return QueryContext(ctx, s, p) 160 160 + } 161 161 + 162 162 + func (s select_) QueryRow(p Database) (*sql.Row, error) { 163 163 + return QueryRow(s, p) 164 164 + } 165 165 + 166 166 + func (s select_) QueryRowContext(ctx context.Context, p Database) (*sql.Row, error) { 167 167 + return QueryRowContext(ctx, s, p) 168 168 + }

+112

types.go

··· 1 1 + package norm 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "database/sql" 6 6 + "fmt" 7 7 + ) 8 8 + 9 9 + type Database interface { 10 10 + Prepare(sql string) (*sql.Stmt, error) 11 11 + PrepareContext(ctx context.Context, query string) (*sql.Stmt, error) 12 12 + 13 13 + Exec(query string, args ...any) (sql.Result, error) 14 14 + ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error) 15 15 + } 16 16 + 17 17 + type Compiler interface { 18 18 + Compile() (string, []any, error) 19 19 + } 20 20 + 21 21 + type Builder interface { 22 22 + Build(db Database) (*sql.Stmt, []any, error) 23 23 + MustBuild(db Database) (*sql.Stmt, []any) 24 24 + } 25 25 + 26 26 + // anything that is a Compiler, can also be Builder: 27 27 + func Build(c Compiler, p Database) (*sql.Stmt, []any, error) { 28 28 + query, args, err := c.Compile() 29 29 + if err != nil { 30 30 + return nil, nil, err 31 31 + } 32 32 + 33 33 + stmt, err := p.Prepare(query) 34 34 + if err != nil { 35 35 + return nil, nil, fmt.Errorf("failed to prepare statement: `%s` : %w", query, err) 36 36 + } 37 37 + 38 38 + return stmt, args, nil 39 39 + } 40 40 + 41 41 + func MustBuild(c Compiler, p Database) (*sql.Stmt, []any) { 42 42 + stmt, args, err := Build(c, p) 43 43 + if err != nil { 44 44 + panic(err) 45 45 + } 46 46 + return stmt, args 47 47 + } 48 48 + 49 49 + type Execer interface { 50 50 + Exec(db Database) (sql.Result, error) 51 51 + ExecContext(ctx context.Context, db Database) (sql.Result, error) 52 52 + } 53 53 + 54 54 + // anything that is a Builder can also be an Execer 55 55 + func Exec(b Builder, p Database) (sql.Result, error) { 56 56 + return ExecContext(context.Background(), b, p) 57 57 + } 58 58 + 59 59 + func ExecContext(ctx context.Context, b Builder, p Database) (sql.Result, error) { 60 60 + stmt, args, err := b.Build(p) 61 61 + if err != nil { 62 62 + return nil, err 63 63 + } 64 64 + 65 65 + return stmt.ExecContext(ctx, args...) 66 66 + } 67 67 + 68 68 + type Querier interface { 69 69 + Query(db Database) (*sql.Rows, error) 70 70 + QueryContext(ctx context.Context, db Database) (*sql.Rows, error) 71 71 + QueryRow(db Database) (*sql.Row, error) 72 72 + QueryRowContext(ctx context.Context, db Database) (*sql.Row, error) 73 73 + } 74 74 + 75 75 + // anything that is a Builder can also be an Querier 76 76 + func Query(b Builder, p Database) (*sql.Rows, error) { 77 77 + return QueryContext(context.Background(), b, p) 78 78 + } 79 79 + 80 80 + func QueryContext(ctx context.Context, b Builder, p Database) (*sql.Rows, error) { 81 81 + stmt, args, err := b.Build(p) 82 82 + if err != nil { 83 83 + return nil, err 84 84 + } 85 85 + 86 86 + return stmt.QueryContext(ctx, args...) 87 87 + } 88 88 + 89 89 + func QueryRow(b Builder, p Database) (*sql.Row, error) { 90 90 + return QueryRowContext(context.Background(), b, p) 91 91 + } 92 92 + 93 93 + func QueryRowContext(ctx context.Context, b Builder, p Database) (*sql.Row, error) { 94 94 + stmt, args, err := b.Build(p) 95 95 + if err != nil { 96 96 + return nil, err 97 97 + } 98 98 + 99 99 + return stmt.QueryRowContext(ctx, args...), nil 100 100 + } 101 101 + 102 102 + type Direction string 103 103 + 104 104 + const ( 105 105 + Ascending Direction = "asc" 106 106 + Descending Direction = "desc" 107 107 + ) 108 108 + 109 109 + func Placeholder[T any]() T { 110 110 + var zero T 111 111 + return zero 112 112 + }