+3

go.mod

reviewed

··· 1 1 + module tangled.sh/oppi.li/norm 2 2 + 3 3 + go 1.24.1

+258

query.go

reviewed

··· 1 1 + package norm 2 2 + 3 3 + import ( 4 4 + "fmt" 5 5 + "strconv" 6 6 + "strings" 7 7 + ) 8 8 + 9 9 + type op string 10 10 + 11 11 + type Expr struct { 12 12 + kind ExprKind 13 13 + 14 14 + ident *IdentExpr 15 15 + binary *BinExpr 16 16 + value *ValueExpr 17 17 + } 18 18 + 19 19 + func (e Expr) String() string { 20 20 + switch e.kind { 21 21 + case exprKindIdent: 22 22 + return e.ident.String() 23 23 + case exprKindBinary: 24 24 + return e.binary.String() 25 25 + case exprKindValue: 26 26 + return e.value.String() 27 27 + } 28 28 + 29 29 + // unreachable 30 30 + return "" 31 31 + } 32 32 + 33 33 + func (e Expr) Binds() []any { 34 34 + switch e.kind { 35 35 + case exprKindIdent: 36 36 + return e.ident.Binds() 37 37 + case exprKindBinary: 38 38 + return e.binary.Binds() 39 39 + case exprKindValue: 40 40 + return e.value.Binds() 41 41 + } 42 42 + 43 43 + return nil 44 44 + } 45 45 + 46 46 + type ExprKind int 47 47 + 48 48 + const ( 49 49 + exprKindIdent ExprKind = iota 50 50 + exprKindBinary 51 51 + exprKindValue 52 52 + ) 53 53 + 54 54 + type IdentExpr string 55 55 + 56 56 + func (i IdentExpr) String() string { 57 57 + return string(i) 58 58 + } 59 59 + 60 60 + func (i IdentExpr) Binds() []any { 61 61 + return nil 62 62 + } 63 63 + 64 64 + func (i IdentExpr) AsExpr() Expr { 65 65 + return Expr{ 66 66 + kind: exprKindIdent, 67 67 + ident: &i, 68 68 + } 69 69 + } 70 70 + 71 71 + type ValueExpr struct { 72 72 + inner any 73 73 + } 74 74 + 75 75 + func (v ValueExpr) String() string { 76 76 + return "?" 77 77 + } 78 78 + 79 79 + func (v ValueExpr) Binds() []any { 80 80 + return []any{v.inner} 81 81 + } 82 82 + 83 83 + func (v ValueExpr) AsExpr() Expr { 84 84 + return Expr{ 85 85 + kind: exprKindValue, 86 86 + value: &v, 87 87 + } 88 88 + } 89 89 + 90 90 + type BinExpr struct { 91 91 + left Expr 92 92 + op op 93 93 + right Expr 94 94 + } 95 95 + 96 96 + func (b BinExpr) String() string { 97 97 + return fmt.Sprintf("(%s) %s (%s)", b.left.String(), b.op, b.right.String()) 98 98 + } 99 99 + 100 100 + func (b BinExpr) Binds() []any { 101 101 + binds := b.left.Binds() 102 102 + binds = append(binds, b.right.Binds()...) 103 103 + return binds 104 104 + } 105 105 + 106 106 + func (b BinExpr) AsExpr() Expr { 107 107 + return Expr{ 108 108 + kind: exprKindBinary, 109 109 + binary: &b, 110 110 + } 111 111 + } 112 112 + 113 113 + func buildBinExpr(left IdentExpr, op op, right any) Expr { 114 114 + return BinExpr{left.AsExpr(), op, ValueExpr{right}.AsExpr()}.AsExpr() 115 115 + } 116 116 + func Eq(left string, right any) Expr { return buildBinExpr(IdentExpr(left), "=", right) } 117 117 + func Neq(left string, right any) Expr { return buildBinExpr(IdentExpr(left), "<>", right) } 118 118 + func Gt(left string, right any) Expr { return buildBinExpr(IdentExpr(left), ">", right) } 119 119 + func Gte(left string, right any) Expr { return buildBinExpr(IdentExpr(left), ">=", right) } 120 120 + func Lt(left string, right any) Expr { return buildBinExpr(IdentExpr(left), "<", right) } 121 121 + func Lte(left string, right any) Expr { return buildBinExpr(IdentExpr(left), "<=", right) } 122 122 + 123 123 + func (l Expr) And(r Expr) Expr { return BinExpr{l, "and", r}.AsExpr() } 124 124 + func (l Expr) Or(r Expr) Expr { return BinExpr{l, "or", r}.AsExpr() } 125 125 + 126 126 + type select_ struct { 127 127 + resultColumns []string // TODO: strongly type result columns 128 128 + from string // table-or-subquery expr 129 129 + where *Expr 130 130 + orderBy []orderBy 131 131 + groupBy []groupBy 132 132 + limit *limit 133 133 + } 134 134 + 135 135 + type orderBy struct { 136 136 + field string 137 137 + direction Direction 138 138 + } 139 139 + 140 140 + type groupBy struct { 141 141 + field string 142 142 + } 143 143 + 144 144 + type limit struct { 145 145 + limit int 146 146 + } 147 147 + 148 148 + func Select(cols ...string) select_ { 149 149 + return select_{ 150 150 + resultColumns: cols, 151 151 + } 152 152 + } 153 153 + 154 154 + type SelectOpt func(s *select_) 155 155 + 156 156 + func (s select_) From(table string) select_ { 157 157 + s.from = table 158 158 + return s 159 159 + } 160 160 + 161 161 + func (s select_) Where(expr Expr) select_ { 162 162 + s.where = &expr 163 163 + return s 164 164 + } 165 165 + 166 166 + type Direction string 167 167 + 168 168 + const ( 169 169 + Ascending Direction = "asc" 170 170 + Descending Direction = "desc" 171 171 + ) 172 172 + 173 173 + func (s select_) OrderBy(field string, direction Direction) select_ { 174 174 + s.orderBy = append(s.orderBy, orderBy{ 175 175 + field: field, 176 176 + direction: direction, 177 177 + }) 178 178 + return s 179 179 + } 180 180 + 181 181 + func (s select_) GroupBy(field string) select_ { 182 182 + s.groupBy = append(s.groupBy, groupBy{ 183 183 + field: field, 184 184 + }) 185 185 + return s 186 186 + } 187 187 + 188 188 + func (s select_) Limit(i int) select_ { 189 189 + s.limit = &limit{ 190 190 + limit: i, 191 191 + } 192 192 + return s 193 193 + } 194 194 + 195 195 + func (s select_) Build() (string, []any, error) { 196 196 + var sql strings.Builder 197 197 + var args []any 198 198 + 199 199 + sql.WriteString("SELECT ") 200 200 + if len(s.resultColumns) == 0 { 201 201 + return "", nil, fmt.Errorf("result columns empty") 202 202 + } else { 203 203 + for i, col := range s.resultColumns { 204 204 + if i > 0 { 205 205 + sql.WriteString(", ") 206 206 + } 207 207 + sql.WriteString(col) 208 208 + } 209 209 + } 210 210 + 211 211 + if s.from == "" { 212 212 + return "", nil, fmt.Errorf("FROM clause is required") 213 213 + } 214 214 + sql.WriteString(" FROM ") 215 215 + sql.WriteString(s.from) 216 216 + 217 217 + if s.where != nil { 218 218 + sql.WriteString(" WHERE ") 219 219 + sql.WriteString(s.where.String()) 220 220 + 221 221 + args = s.where.Binds() 222 222 + } 223 223 + 224 224 + // GROUP BY clause 225 225 + if len(s.groupBy) > 0 { 226 226 + sql.WriteString(" GROUP BY ") 227 227 + for i, gb := range s.groupBy { 228 228 + if i > 0 { 229 229 + sql.WriteString(", ") 230 230 + } 231 231 + sql.WriteString(gb.field) 232 232 + } 233 233 + } 234 234 + 235 235 + // ORDER BY clause 236 236 + if len(s.orderBy) > 0 { 237 237 + sql.WriteString(" ORDER BY ") 238 238 + for i, ob := range s.orderBy { 239 239 + if i > 0 { 240 240 + sql.WriteString(", ") 241 241 + } 242 242 + sql.WriteString(ob.field) 243 243 + sql.WriteString(" ") 244 244 + sql.WriteString(string(ob.direction)) 245 245 + } 246 246 + } 247 247 + 248 248 + // LIMIT clause 249 249 + if s.limit != nil { 250 250 + if s.limit.limit <= 0 { 251 251 + return "", nil, fmt.Errorf("LIMIT must be positive, got %d", s.limit.limit) 252 252 + } 253 253 + sql.WriteString(" LIMIT ") 254 254 + sql.WriteString(strconv.Itoa(s.limit.limit)) 255 255 + } 256 256 + 257 257 + return sql.String(), args, nil 258 258 + }

+381

query_test.go

reviewed

··· 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 + // Test chained logical operations 91 91 + age := Eq("age", 25) 92 92 + status := Eq("status", "active") 93 93 + score := Gt("score", 100) 94 94 + 95 95 + complex := age. 96 96 + And(status). 97 97 + Or(score) 98 98 + expected := "(((age) = (?)) and ((status) = (?))) or ((score) > (?))" 99 99 + 100 100 + if complex.String() != expected { 101 101 + t.Errorf("Expected '%s', got '%s'", expected, complex.String()) 102 102 + } 103 103 + } 104 104 + 105 105 + func TestSelectBasic(t *testing.T) { 106 106 + s := Select("name", "age") 107 107 + 108 108 + if len(s.resultColumns) != 2 { 109 109 + t.Errorf("Expected 2 columns, got %d", len(s.resultColumns)) 110 110 + } 111 111 + 112 112 + if s.resultColumns[0] != "name" || s.resultColumns[1] != "age" { 113 113 + t.Errorf("Expected columns [name, age], got %v", s.resultColumns) 114 114 + } 115 115 + } 116 116 + 117 117 + func TestSelectAPI(t *testing.T) { 118 118 + // Test fluent API chaining 119 119 + s := Select("*"). 120 120 + From("users"). 121 121 + Where(Eq("id", 1)). 122 122 + OrderBy("name", Ascending). 123 123 + GroupBy("department"). 124 124 + Limit(10) 125 125 + 126 126 + if s.from != "users" { 127 127 + t.Errorf("Expected from to be 'users', got '%s'", s.from) 128 128 + } 129 129 + 130 130 + if s.where == nil { 131 131 + t.Error("Expected where clause to be set") 132 132 + } 133 133 + 134 134 + if len(s.orderBy) != 1 { 135 135 + t.Errorf("Expected 1 order by clause, got %d", len(s.orderBy)) 136 136 + } 137 137 + 138 138 + if s.orderBy[0].field != "name" || s.orderBy[0].direction != Ascending { 139 139 + t.Errorf("Expected order by name ASC, got %v", s.orderBy[0]) 140 140 + } 141 141 + 142 142 + if len(s.groupBy) != 1 { 143 143 + t.Errorf("Expected 1 group by clause, got %d", len(s.groupBy)) 144 144 + } 145 145 + 146 146 + if s.groupBy[0].field != "department" { 147 147 + t.Errorf("Expected group by department, got %s", s.groupBy[0].field) 148 148 + } 149 149 + 150 150 + if s.limit == nil { 151 151 + t.Error("Expected limit to be set") 152 152 + } 153 153 + 154 154 + if s.limit.limit != 10 { 155 155 + t.Errorf("Expected limit 10, got %d", s.limit.limit) 156 156 + } 157 157 + } 158 158 + 159 159 + func TestSelectBuild_Success(t *testing.T) { 160 160 + tests := []struct { 161 161 + name string 162 162 + builder func() select_ 163 163 + expectedSql string 164 164 + expectedArgs []any 165 165 + }{ 166 166 + { 167 167 + name: "Simple select", 168 168 + builder: func() select_ { 169 169 + return Select("name", "age").From("users") 170 170 + }, 171 171 + expectedSql: "SELECT name, age FROM users", 172 172 + expectedArgs: nil, 173 173 + }, 174 174 + { 175 175 + name: "Select with where", 176 176 + builder: func() select_ { 177 177 + return Select("*"). 178 178 + From("users"). 179 179 + Where(Eq("active", true)) 180 180 + }, 181 181 + expectedSql: "SELECT * FROM users WHERE (active) = (?)", 182 182 + expectedArgs: []any{true}, 183 183 + }, 184 184 + { 185 185 + name: "Select with order by", 186 186 + builder: func() select_ { 187 187 + return Select("name"). 188 188 + From("users"). 189 189 + OrderBy("name", Ascending) 190 190 + }, 191 191 + expectedSql: "SELECT name FROM users ORDER BY name asc", 192 192 + expectedArgs: nil, 193 193 + }, 194 194 + { 195 195 + name: "Select with multiple order by", 196 196 + builder: func() select_ { 197 197 + return Select("name", "age"). 198 198 + From("users"). 199 199 + OrderBy("name", Ascending). 200 200 + OrderBy("age", Descending) 201 201 + }, 202 202 + expectedSql: "SELECT name, age FROM users ORDER BY name asc, age desc", 203 203 + expectedArgs: nil, 204 204 + }, 205 205 + { 206 206 + name: "Select with group by", 207 207 + builder: func() select_ { 208 208 + return Select("department", "COUNT(*)"). 209 209 + From("users"). 210 210 + GroupBy("department") 211 211 + }, 212 212 + expectedSql: "SELECT department, COUNT(*) FROM users GROUP BY department", 213 213 + expectedArgs: nil, 214 214 + }, 215 215 + { 216 216 + name: "Select with limit", 217 217 + builder: func() select_ { 218 218 + return Select("*"). 219 219 + From("users"). 220 220 + Limit(5) 221 221 + }, 222 222 + expectedSql: "SELECT * FROM users LIMIT 5", 223 223 + expectedArgs: nil, 224 224 + }, 225 225 + { 226 226 + name: "Complex select", 227 227 + builder: func() select_ { 228 228 + return Select("name", "age", "department"). 229 229 + From("users"). 230 230 + Where(Eq("active", true).And(Gt("age", 18))). 231 231 + GroupBy("department"). 232 232 + OrderBy("name", Ascending). 233 233 + Limit(10) 234 234 + }, 235 235 + expectedSql: "SELECT name, age, department FROM users WHERE ((active) = (?)) and ((age) > (?)) GROUP BY department ORDER BY name asc LIMIT 10", 236 236 + expectedArgs: []any{true, 18}, 237 237 + }, 238 238 + } 239 239 + 240 240 + for _, test := range tests { 241 241 + t.Run(test.name, func(t *testing.T) { 242 242 + s := test.builder() 243 243 + sql, args, err := s.Build() 244 244 + 245 245 + if err != nil { 246 246 + t.Errorf("Expected no error, got %v", err) 247 247 + } 248 248 + 249 249 + if sql != test.expectedSql { 250 250 + t.Errorf("Expected '%s', got '%s'", test.expectedSql, sql) 251 251 + } 252 252 + 253 253 + if len(args) != len(test.expectedArgs) { 254 254 + t.Errorf("Expected '%d' args, got '%d' args", len(test.expectedArgs), len(args)) 255 255 + } 256 256 + 257 257 + for i := range len(args) { 258 258 + if args[i] != test.expectedArgs[i] { 259 259 + t.Errorf("Expected '%s', got '%s' at index %d", test.expectedArgs[i], args[i], i) 260 260 + } 261 261 + } 262 262 + }) 263 263 + } 264 264 + } 265 265 + 266 266 + func TestSelectBuild_Errors(t *testing.T) { 267 267 + tests := []struct { 268 268 + name string 269 269 + builder func() select_ 270 270 + expectedError string 271 271 + }{ 272 272 + { 273 273 + name: "No columns", 274 274 + builder: func() select_ { 275 275 + return Select() 276 276 + }, 277 277 + expectedError: "result columns empty", 278 278 + }, 279 279 + { 280 280 + name: "No from clause", 281 281 + builder: func() select_ { 282 282 + return Select("name") 283 283 + }, 284 284 + expectedError: "FROM clause is required", 285 285 + }, 286 286 + { 287 287 + name: "Invalid limit", 288 288 + builder: func() select_ { 289 289 + return Select("name"). 290 290 + From("users"). 291 291 + Limit(0) 292 292 + }, 293 293 + expectedError: "LIMIT must be positive, got 0", 294 294 + }, 295 295 + { 296 296 + name: "Negative limit", 297 297 + builder: func() select_ { 298 298 + return Select("name"). 299 299 + From("users"). 300 300 + Limit(-5) 301 301 + }, 302 302 + expectedError: "LIMIT must be positive, got -5", 303 303 + }, 304 304 + } 305 305 + 306 306 + for _, test := range tests { 307 307 + t.Run(test.name, func(t *testing.T) { 308 308 + s := test.builder() 309 309 + sql, args, err := s.Build() 310 310 + 311 311 + if err == nil { 312 312 + t.Error("Expected error, got nil") 313 313 + } 314 314 + 315 315 + if err.Error() != test.expectedError { 316 316 + t.Errorf("Expected error '%s', got '%s'", test.expectedError, err.Error()) 317 317 + } 318 318 + 319 319 + if sql != "" { 320 320 + t.Errorf("Expected empty SQL on error, got '%s'", sql) 321 321 + } 322 322 + 323 323 + if args != nil { 324 324 + t.Errorf("Expected empty args on error, got '%q'", args) 325 325 + } 326 326 + }) 327 327 + } 328 328 + } 329 329 + 330 330 + func TestDirections(t *testing.T) { 331 331 + if Ascending != "asc" { 332 332 + t.Errorf("Expected ASC to be 'asc', got '%s'", Ascending) 333 333 + } 334 334 + 335 335 + if Descending != "desc" { 336 336 + t.Errorf("Expected DESC to be 'desc', got '%s'", Descending) 337 337 + } 338 338 + } 339 339 + 340 340 + func TestMultipleOrderBy(t *testing.T) { 341 341 + s := Select("name", "age"). 342 342 + From("users"). 343 343 + OrderBy("name", Ascending). 344 344 + OrderBy("age", Descending). 345 345 + OrderBy("created_at", Descending) 346 346 + 347 347 + if len(s.orderBy) != 3 { 348 348 + t.Errorf("Expected 3 order by clauses, got %d", len(s.orderBy)) 349 349 + } 350 350 + 351 351 + expected := []orderBy{ 352 352 + {"name", Ascending}, 353 353 + {"age", Descending}, 354 354 + {"created_at", Descending}, 355 355 + } 356 356 + 357 357 + for i, ob := range s.orderBy { 358 358 + if ob.field != expected[i].field || ob.direction != expected[i].direction { 359 359 + t.Errorf("Expected order by %v, got %v", expected[i], ob) 360 360 + } 361 361 + } 362 362 + } 363 363 + 364 364 + func TestMultipleGroupBy(t *testing.T) { 365 365 + s := Select("department", "status", "COUNT(*)"). 366 366 + From("users"). 367 367 + GroupBy("department"). 368 368 + GroupBy("status") 369 369 + 370 370 + if len(s.groupBy) != 2 { 371 371 + t.Errorf("Expected 2 group by clauses, got %d", len(s.groupBy)) 372 372 + } 373 373 + 374 374 + expected := []string{"department", "status"} 375 375 + 376 376 + for i, gb := range s.groupBy { 377 377 + if gb.field != expected[i] { 378 378 + t.Errorf("Expected group by %s, got %s", expected[i], gb.field) 379 379 + } 380 380 + } 381 381 + }