refactor project entirely

Signed-off-by: oppiliappan <[e-mail]>

delete.go

···
+package norm
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+)
+
+type delete_ struct {
+	from  string
+	where *Expr
+}
+
+func Delete() delete_ {
+	return delete_{}
+}
+
+type DeleteOpt func(s *delete_)
+
+func (s delete_) From(table string) delete_ {
+	s.from = table
+	return s
+}
+
+func (s delete_) Where(expr Expr) delete_ {
+	s.where = &expr
+	return s
+}
+
+func (s delete_) Compile() (string, []any, error) {
+	var sql strings.Builder
+	var args []any
+
+	sql.WriteString("DELETE ")
+
+	if s.from == "" {
+		return "", nil, fmt.Errorf("FROM clause is required")
+	}
+	sql.WriteString(" FROM ")
+	sql.WriteString(s.from)
+
+	if s.where != nil {
+		sql.WriteString(" WHERE ")
+		sql.WriteString(s.where.String())
+
+		args = s.where.Binds()
+	}
+
+	return sql.String(), args, nil
+}
+
+func (s delete_) Build(p Database) (*sql.Stmt, []any, error) {
+	return Build(s, p)
+}
+
+func (s delete_) MustBuild(p Database) (*sql.Stmt, []any) {
+	return MustBuild(s, p)
+}
+
+func (s delete_) Exec(p Database) (sql.Result, error) {
+	return Exec(s, p)
+}
+
+func (s delete_) ExecContext(ctx context.Context, p Database) (sql.Result, error) {
+	return ExecContext(ctx, s, p)
+}
+
+func (s delete_) Query(p Database) (*sql.Rows, error) {
+	return Query(s, p)
+}
+
+func (s delete_) QueryContext(ctx context.Context, p Database) (*sql.Rows, error) {
+	return QueryContext(ctx, s, p)
+}
+
+func (s delete_) QueryRow(p Database) (*sql.Row, error) {
+	return QueryRow(s, p)
+}
+
+func (s delete_) QueryRowContext(ctx context.Context, p Database) (*sql.Row, error) {
+	return QueryRowContext(ctx, s, p)
+}

delete_test.go

···
+package norm
+
+import (
+	_ "github.com/mattn/go-sqlite3"
+	"testing"
+)
+
+func TestDeleteIntegration_BasicQueries(t *testing.T) {
+	tests := []struct {
+		name         string
+		stmt         Execer
+		expectedRows int64
+	}{
+		{
+			name:         "Delete all users",
+			stmt:         Delete().From("users"),
+			expectedRows: 6,
+		},
+		{
+			name: "Delete active users only",
+			stmt: Delete().
+				From("users").
+				Where(Eq("active", true)),
+			expectedRows: 4,
+		},
+		{
+			name: "Select users in Engineering",
+			stmt: Delete().
+				From("users").
+				Where(Eq("department", "Engineering")),
+			expectedRows: 3,
+		},
+		{
+			name: "Delete users with age > 30",
+			stmt: Delete().
+				From("users").
+				Where(Gt("age", 30)),
+			expectedRows: 2,
+		},
+		{
+			name: "Delete users with salary between 70000 and 80000",
+			stmt: Delete().
+				From("users").
+				Where(Gte("salary", 70000.0).And(Lte("salary", 80000.0))),
+			expectedRows: 3,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			db := setupTestDB(t)
+			defer db.Close()
+
+			res, err := test.stmt.Exec(db)
+			if err != nil {
+				t.Fatalf("Failed to execute query: %v", err)
+			}
+
+			count, err := res.RowsAffected()
+			if err != nil {
+				t.Fatalf("Failed to execute query: %v", err)
+			}
+
+			if count != test.expectedRows {
+				t.Errorf("Expected %d rows, got %d", test.expectedRows, count)
+			}
+		})
+	}
+}

expr.go

···
+package norm
+
+import "fmt"
+
+type op string
+
+type Expr struct {
+	kind ExprKind
+
+	ident  *IdentExpr
+	binary *BinExpr
+	value  *ValueExpr
+}
+
+func (e Expr) String() string {
+	switch e.kind {
+	case exprKindIdent:
+		return e.ident.String()
+	case exprKindBinary:
+		return e.binary.String()
+	case exprKindValue:
+		return e.value.String()
+	}
+
+	// unreachable
+	return ""
+}
+
+func (e Expr) Binds() []any {
+	switch e.kind {
+	case exprKindIdent:
+		return e.ident.Binds()
+	case exprKindBinary:
+		return e.binary.Binds()
+	case exprKindValue:
+		return e.value.Binds()
+	}
+
+	return nil
+}
+
+type ExprKind int
+
+const (
+	exprKindIdent ExprKind = iota
+	exprKindBinary
+	exprKindValue
+)
+
+type IdentExpr string
+
+func (i IdentExpr) String() string {
+	return string(i)
+}
+
+func (i IdentExpr) Binds() []any {
+	return nil
+}
+
+func (i IdentExpr) AsExpr() Expr {
+	return Expr{
+		kind:  exprKindIdent,
+		ident: &i,
+	}
+}
+
+type ValueExpr struct {
+	inner any
+}
+
+func (v ValueExpr) String() string {
+	return "?"
+}
+
+func (v ValueExpr) Binds() []any {
+	return []any{v.inner}
+}
+
+func (v ValueExpr) AsExpr() Expr {
+	return Expr{
+		kind:  exprKindValue,
+		value: &v,
+	}
+}
+
+type BinExpr struct {
+	left  Expr
+	op    op
+	right Expr
+}
+
+func (b BinExpr) String() string {
+	return fmt.Sprintf("(%s) %s (%s)", b.left.String(), b.op, b.right.String())
+}
+
+func (b BinExpr) Binds() []any {
+	binds := b.left.Binds()
+	binds = append(binds, b.right.Binds()...)
+	return binds
+}
+
+func (b BinExpr) AsExpr() Expr {
+	return Expr{
+		kind:   exprKindBinary,
+		binary: &b,
+	}
+}
+
+func buildBinExpr(left IdentExpr, op op, right any) Expr {
+	return BinExpr{left.AsExpr(), op, ValueExpr{right}.AsExpr()}.AsExpr()
+}
+func Eq(left string, right any) Expr  { return buildBinExpr(IdentExpr(left), "=", right) }
+func Neq(left string, right any) Expr { return buildBinExpr(IdentExpr(left), "<>", right) }
+func Gt(left string, right any) Expr  { return buildBinExpr(IdentExpr(left), ">", right) }
+func Gte(left string, right any) Expr { return buildBinExpr(IdentExpr(left), ">=", right) }
+func Lt(left string, right any) Expr  { return buildBinExpr(IdentExpr(left), "<", right) }
+func Lte(left string, right any) Expr { return buildBinExpr(IdentExpr(left), "<=", right) }
+
+func (l Expr) And(r Expr) Expr { return BinExpr{l, "and", r}.AsExpr() }
+func (l Expr) Or(r Expr) Expr  { return BinExpr{l, "or", r}.AsExpr() }

expr_test.go

···
+package norm
+
+import (
+	"testing"
+)
+
+func TestIdentExpr(t *testing.T) {
+	ident := IdentExpr("username")
+
+	if ident.String() != "username" {
+		t.Errorf("Expected 'username', got '%s'", ident.String())
+	}
+
+	if ident.Binds() != nil {
+		t.Errorf("Expected nil binds, got %v", ident.Binds())
+	}
+
+	expr := ident.AsExpr()
+	if expr.kind != exprKindIdent {
+		t.Errorf("Expected exprKindIdent, got %d", expr.kind)
+	}
+
+	if expr.String() != "username" {
+		t.Errorf("Expected 'username', got '%s'", expr.String())
+	}
+}
+
+func TestValueExpr(t *testing.T) {
+	value := ValueExpr{inner: "test"}
+
+	if value.String() != "?" {
+		t.Errorf("Expected '?', got '%s'", value.String())
+	}
+
+	if value.Binds()[0] != "test" {
+		t.Errorf("Expected %q, got %v", []any{"test"}, value.Binds())
+	}
+
+	expr := value.AsExpr()
+	if expr.kind != exprKindValue {
+		t.Errorf("Expected exprKindValue, got %d", expr.kind)
+	}
+}
+
+func TestBinaryExpressions(t *testing.T) {
+	tests := []struct {
+		name     string
+		expr     Expr
+		expected string
+	}{
+		{"Eq", Eq("age", 25), "(age) = (?)"},
+		{"Neq", Neq("status", "active"), "(status) <> (?)"},
+		{"Gt", Gt("score", 100), "(score) > (?)"},
+		{"Gte", Gte("rating", 4.5), "(rating) >= (?)"},
+		{"Lt", Lt("count", 10), "(count) < (?)"},
+		{"Lte", Lte("price", 99.99), "(price) <= (?)"},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			if test.expr.String() != test.expected {
+				t.Errorf("Expected '%s', got '%s'", test.expected, test.expr.String())
+			}
+
+			if test.expr.kind != exprKindBinary {
+				t.Errorf("Expected exprKindBinary, got %d", test.expr.kind)
+			}
+		})
+	}
+}
+
+func TestLogicalOperators(t *testing.T) {
+	left := Eq("age", 25)
+	right := Eq("status", "active")
+
+	andExpr := left.And(right)
+	expectedAnd := "((age) = (?)) and ((status) = (?))"
+	if andExpr.String() != expectedAnd {
+		t.Errorf("Expected '%s', got '%s'", expectedAnd, andExpr.String())
+	}
+
+	orExpr := left.Or(right)
+	expectedOr := "((age) = (?)) or ((status) = (?))"
+	if orExpr.String() != expectedOr {
+		t.Errorf("Expected '%s', got '%s'", expectedOr, orExpr.String())
+	}
+}
+
+func TestComplexExpressions(t *testing.T) {
+	age := Eq("age", 25)
+	status := Eq("status", "active")
+	score := Gt("score", 100)
+
+	complex := age.
+		And(status).
+		Or(score)
+	expected := "(((age) = (?)) and ((status) = (?))) or ((score) > (?))"
+
+	if complex.String() != expected {
+		t.Errorf("Expected '%s', got '%s'", expected, complex.String())
+	}
+}

insert.go

···
+package norm
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+)
+
+type insert struct {
+	into   string
+	or     InsertOr
+	values []struct {
+		col string
+		val any
+	}
+}
+
+type InsertOr int
+
+const (
+	None InsertOr = iota
+	Abort
+	Fail
+	Ignore
+	Replace
+	Rollback
+)
+
+func (i InsertOr) String() string {
+	switch i {
+	case Abort:
+		return "ABORT"
+	case Fail:
+		return "FAIL"
+	case Ignore:
+		return "IGNORE"
+	case Replace:
+		return "REPLACE"
+	case Rollback:
+		return "ROLLBACK"
+	default:
+		return ""
+	}
+}
+
+func Insert() insert {
+	return insert{}
+}
+
+type InsertOpt func(s *insert)
+
+func (s insert) Into(table string) insert {
+	s.into = table
+	return s
+}
+
+func (s insert) Or(option InsertOr) insert {
+	s.or = option
+	return s
+}
+
+func (s insert) Value(column string, arg any) insert {
+	s.values = append(s.values, struct {
+		col string
+		val any
+	}{
+		column, arg,
+	})
+	return s
+}
+
+func (s insert) Compile() (string, []any, error) {
+	var sql strings.Builder
+	var args []any
+
+	sql.WriteString("INSERT ")
+
+	if s.or != None {
+		sql.WriteString("OR ")
+		sql.WriteString(s.or.String())
+		sql.WriteString(" ")
+	}
+
+	if s.into == "" {
+		return "", nil, fmt.Errorf("INTO clause is required")
+	}
+	sql.WriteString("INTO ")
+	sql.WriteString(s.into)
+
+	if len(s.values) == 0 {
+		return "", nil, fmt.Errorf("no values supplied")
+	}
+
+	sql.WriteString(" (")
+
+	for i, v := range s.values {
+		if i != 0 {
+			sql.WriteString(", ")
+		}
+
+		sql.WriteString(v.col)
+		args = append(args, v.val)
+	}
+
+	sql.WriteString(") VALUES (")
+	sql.WriteString(strings.TrimSuffix(strings.Repeat("?, ", len(s.values)), ", "))
+	sql.WriteString(")")
+
+	return sql.String(), args, nil
+}
+
+func (s insert) Build(p Database) (*sql.Stmt, []any, error) {
+	return Build(s, p)
+}
+
+func (s insert) MustBuild(p Database) (*sql.Stmt, []any) {
+	return MustBuild(s, p)
+}
+
+func (s insert) Exec(p Database) (sql.Result, error) {
+	return Exec(s, p)
+}
+
+func (s insert) ExecContext(ctx context.Context, p Database) (sql.Result, error) {
+	return ExecContext(ctx, s, p)
+}
+
+func (s insert) Query(p Database) (*sql.Rows, error) {
+	return Query(s, p)
+}
+
+func (s insert) QueryContext(ctx context.Context, p Database) (*sql.Rows, error) {
+	return QueryContext(ctx, s, p)
+}
+
+func (s insert) QueryRow(p Database) (*sql.Row, error) {
+	return QueryRow(s, p)
+}
+
+func (s insert) QueryRowContext(ctx context.Context, p Database) (*sql.Row, error) {
+	return QueryRowContext(ctx, s, p)
+}

insert_test.go

···
+package norm
+
+import (
+	_ "github.com/mattn/go-sqlite3"
+	"testing"
+)
+
+func TestInsertBuild_Success(t *testing.T) {
+	tests := []struct {
+		name         string
+		stmt         Compiler
+		expectedSql  string
+		expectedArgs []any
+	}{
+		{
+			name:         "Simple insert",
+			stmt:         Insert().Into("users").Value("name", "John"),
+			expectedSql:  "INSERT INTO users (name) VALUES (?)",
+			expectedArgs: []any{"John"},
+		},
+		{
+			name:         "Replace clause",
+			stmt:         Insert().Or(Replace).Into("users").Value("name", "John"),
+			expectedSql:  "INSERT OR REPLACE INTO users (name) VALUES (?)",
+			expectedArgs: []any{"John"},
+		},
+		{
+			name:         "More values",
+			stmt:         Insert().Into("users").Value("name", "John").Value("age", 35),
+			expectedSql:  "INSERT INTO users (name, age) VALUES (?, ?)",
+			expectedArgs: []any{"John", 35},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			sql, args, err := test.stmt.Compile()
+
+			if err != nil {
+				t.Errorf("Expected no error, got %v", err)
+			}
+
+			if sql != test.expectedSql {
+				t.Errorf("Expected '%s', got '%s'", test.expectedSql, sql)
+			}
+
+			if len(args) != len(test.expectedArgs) {
+				t.Errorf("Expected '%d' args, got '%d' args", len(test.expectedArgs), len(args))
+			}
+
+			for i := range len(args) {
+				if args[i] != test.expectedArgs[i] {
+					t.Errorf("Expected '%v', got '%v' at index %d", test.expectedArgs[i], args[i], i)
+				}
+			}
+		})
+	}
+}

query.go

···
-package norm
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-)
-
-// use with prepared statements
-func Placeholder[T any]() T {
-	var zero T
-	return zero
-}
-
-type op string
-
-type Expr struct {
-	kind ExprKind
-
-	ident  *IdentExpr
-	binary *BinExpr
-	value  *ValueExpr
-}
-
-func (e Expr) String() string {
-	switch e.kind {
-	case exprKindIdent:
-		return e.ident.String()
-	case exprKindBinary:
-		return e.binary.String()
-	case exprKindValue:
-		return e.value.String()
-	}
-
-	// unreachable
-	return ""
-}
-
-func (e Expr) Binds() []any {
-	switch e.kind {
-	case exprKindIdent:
-		return e.ident.Binds()
-	case exprKindBinary:
-		return e.binary.Binds()
-	case exprKindValue:
-		return e.value.Binds()
-	}
-
-	return nil
-}
-
-type ExprKind int
-
-const (
-	exprKindIdent ExprKind = iota
-	exprKindBinary
-	exprKindValue
-)
-
-type IdentExpr string
-
-func (i IdentExpr) String() string {
-	return string(i)
-}
-
-func (i IdentExpr) Binds() []any {
-	return nil
-}
-
-func (i IdentExpr) AsExpr() Expr {
-	return Expr{
-		kind:  exprKindIdent,
-		ident: &i,
-	}
-}
-
-type ValueExpr struct {
-	inner any
-}
-
-func (v ValueExpr) String() string {
-	return "?"
-}
-
-func (v ValueExpr) Binds() []any {
-	return []any{v.inner}
-}
-
-func (v ValueExpr) AsExpr() Expr {
-	return Expr{
-		kind:  exprKindValue,
-		value: &v,
-	}
-}
-
-type BinExpr struct {
-	left  Expr
-	op    op
-	right Expr
-}
-
-func (b BinExpr) String() string {
-	return fmt.Sprintf("(%s) %s (%s)", b.left.String(), b.op, b.right.String())
-}
-
-func (b BinExpr) Binds() []any {
-	binds := b.left.Binds()
-	binds = append(binds, b.right.Binds()...)
-	return binds
-}
-
-func (b BinExpr) AsExpr() Expr {
-	return Expr{
-		kind:   exprKindBinary,
-		binary: &b,
-	}
-}
-
-func buildBinExpr(left IdentExpr, op op, right any) Expr {
-	return BinExpr{left.AsExpr(), op, ValueExpr{right}.AsExpr()}.AsExpr()
-}
-func Eq(left string, right any) Expr  { return buildBinExpr(IdentExpr(left), "=", right) }
-func Neq(left string, right any) Expr { return buildBinExpr(IdentExpr(left), "<>", right) }
-func Gt(left string, right any) Expr  { return buildBinExpr(IdentExpr(left), ">", right) }
-func Gte(left string, right any) Expr { return buildBinExpr(IdentExpr(left), ">=", right) }
-func Lt(left string, right any) Expr  { return buildBinExpr(IdentExpr(left), "<", right) }
-func Lte(left string, right any) Expr { return buildBinExpr(IdentExpr(left), "<=", right) }
-
-func (l Expr) And(r Expr) Expr { return BinExpr{l, "and", r}.AsExpr() }
-func (l Expr) Or(r Expr) Expr  { return BinExpr{l, "or", r}.AsExpr() }
-
-type select_ struct {
-	resultColumns []string // TODO: strongly type result columns
-	from          string   // table-or-subquery expr
-	where         *Expr
-	orderBy       []orderBy
-	groupBy       []groupBy
-	limit         *limit
-}
-
-type orderBy struct {
-	field     string
-	direction Direction
-}
-
-type groupBy struct {
-	field string
-}
-
-type limit struct {
-	limit int
-}
-
-func Select(cols ...string) select_ {
-	return select_{
-		resultColumns: cols,
-	}
-}
-
-type SelectOpt func(s *select_)
-
-func (s select_) From(table string) select_ {
-	s.from = table
-	return s
-}
-
-func (s select_) Where(expr Expr) select_ {
-	s.where = &expr
-	return s
-}
-
-type Direction string
-
-const (
-	Ascending  Direction = "asc"
-	Descending Direction = "desc"
-)
-
-func (s select_) OrderBy(field string, direction Direction) select_ {
-	s.orderBy = append(s.orderBy, orderBy{
-		field:     field,
-		direction: direction,
-	})
-	return s
-}
-
-func (s select_) GroupBy(field string) select_ {
-	s.groupBy = append(s.groupBy, groupBy{
-		field: field,
-	})
-	return s
-}
-
-func (s select_) Limit(i int) select_ {
-	s.limit = &limit{
-		limit: i,
-	}
-	return s
-}
-
-func (s select_) Build() (string, []any, error) {
-	var sql strings.Builder
-	var args []any
-
-	sql.WriteString("SELECT ")
-	if len(s.resultColumns) == 0 {
-		return "", nil, fmt.Errorf("result columns empty")
-	} else {
-		for i, col := range s.resultColumns {
-			if i > 0 {
-				sql.WriteString(", ")
-			}
-			sql.WriteString(col)
-		}
-	}
-
-	if s.from == "" {
-		return "", nil, fmt.Errorf("FROM clause is required")
-	}
-	sql.WriteString(" FROM ")
-	sql.WriteString(s.from)
-
-	if s.where != nil {
-		sql.WriteString(" WHERE ")
-		sql.WriteString(s.where.String())
-
-		args = s.where.Binds()
-	}
-
-	// GROUP BY clause
-	if len(s.groupBy) > 0 {
-		sql.WriteString(" GROUP BY ")
-		for i, gb := range s.groupBy {
-			if i > 0 {
-				sql.WriteString(", ")
-			}
-			sql.WriteString(gb.field)
-		}
-	}
-
-	// ORDER BY clause
-	if len(s.orderBy) > 0 {
-		sql.WriteString(" ORDER BY ")
-		for i, ob := range s.orderBy {
-			if i > 0 {
-				sql.WriteString(", ")
-			}
-			sql.WriteString(ob.field)
-			sql.WriteString(" ")
-			sql.WriteString(string(ob.direction))
-		}
-	}
-
-	// LIMIT clause
-	if s.limit != nil {
-		if s.limit.limit <= 0 {
-			return "", nil, fmt.Errorf("LIMIT must be positive, got %d", s.limit.limit)
-		}
-		sql.WriteString(" LIMIT ")
-		sql.WriteString(strconv.Itoa(s.limit.limit))
-	}
-
-	return sql.String(), args, nil
-}
-
-func (s select_) MustBuild() (string, []any) {
-	sql, args, err := s.Build()
-	if err != nil {
-		panic(err)
-	}
-	return sql, args
-}
-
-type delete_ struct {
-	from  string
-	where *Expr
-}
-
-func Delete() delete_ {
-	return delete_{}
-}
-
-type DeleteOpt func(s *delete_)
-
-func (s delete_) From(table string) delete_ {
-	s.from = table
-	return s
-}
-
-func (s delete_) Where(expr Expr) delete_ {
-	s.where = &expr
-	return s
-}
-
-func (s delete_) Build() (string, []any, error) {
-	var sql strings.Builder
-	var args []any
-
-	sql.WriteString("DELETE ")
-
-	if s.from == "" {
-		return "", nil, fmt.Errorf("FROM clause is required")
-	}
-	sql.WriteString(" FROM ")
-	sql.WriteString(s.from)
-
-	if s.where != nil {
-		sql.WriteString(" WHERE ")
-		sql.WriteString(s.where.String())
-
-		args = s.where.Binds()
-	}
-
-	return sql.String(), args, nil
-}
-
-func (s delete_) MustBuild() (string, []any) {
-	sql, args, err := s.Build()
-	if err != nil {
-		panic(err)
-	}
-	return sql, args
-}
-
-type insert struct {
-	into   string
-	or     InsertOr
-	values []struct {
-		col string
-		val any
-	}
-}
-
-type InsertOr int
-
-const (
-	None InsertOr = iota
-	Abort
-	Fail
-	Ignore
-	Replace
-	Rollback
-)
-
-func (i InsertOr) String() string {
-	switch i {
-	case Abort:
-		return "ABORT"
-	case Fail:
-		return "FAIL"
-	case Ignore:
-		return "IGNORE"
-	case Replace:
-		return "REPLACE"
-	case Rollback:
-		return "ROLLBACK"
-	default:
-		return ""
-	}
-}
-
-func Insert() insert {
-	return insert{}
-}
-
-type InsertOpt func(s *insert)
-
-func (s insert) Into(table string) insert {
-	s.into = table
-	return s
-}
-
-func (s insert) Or(option InsertOr) insert {
-	s.or = option
-	return s
-}
-
-func (s insert) Value(column string, arg any) insert {
-	s.values = append(s.values, struct {
-		col string
-		val any
-	}{
-		column, arg,
-	})
-	return s
-}
-
-func (s insert) Build() (string, []any, error) {
-	var sql strings.Builder
-	var args []any
-
-	sql.WriteString("INSERT ")
-
-	if s.or != None {
-		sql.WriteString("OR ")
-		sql.WriteString(s.or.String())
-		sql.WriteString(" ")
-	}
-
-	if s.into == "" {
-		return "", nil, fmt.Errorf("INTO clause is required")
-	}
-	sql.WriteString("INTO ")
-	sql.WriteString(s.into)
-
-	if len(s.values) == 0 {
-		return "", nil, fmt.Errorf("no values supplied")
-	}
-
-	sql.WriteString(" (")
-
-	for i, v := range s.values {
-		if i != 0 {
-			sql.WriteString(", ")
-		}
-
-		sql.WriteString(v.col)
-		args = append(args, v.val)
-	}
-
-	sql.WriteString(") VALUES (")
-	sql.WriteString(strings.TrimSuffix(strings.Repeat("?, ", len(s.values)), ", "))
-	sql.WriteString(")")
-
-	return sql.String(), args, nil
-}
-
-func (s insert) MustBuild() (string, []any) {
-	sql, args, err := s.Build()
-	if err != nil {
-		panic(err)
-	}
-	return sql, args
-}

query_test.go select_test.go

···
 package norm
 
 import (
+	_ "github.com/mattn/go-sqlite3"
 	"testing"
-
-	_ "github.com/mattn/go-sqlite3"
 )
 
-func TestIdentExpr(t *testing.T) {
-	ident := IdentExpr("username")
-
-	if ident.String() != "username" {
-		t.Errorf("Expected 'username', got '%s'", ident.String())
-	}
-
-	if ident.Binds() != nil {
-		t.Errorf("Expected nil binds, got %v", ident.Binds())
-	}
-
-	expr := ident.AsExpr()
-	if expr.kind != exprKindIdent {
-		t.Errorf("Expected exprKindIdent, got %d", expr.kind)
-	}
-
-	if expr.String() != "username" {
-		t.Errorf("Expected 'username', got '%s'", expr.String())
-	}
-}
-
-func TestValueExpr(t *testing.T) {
-	value := ValueExpr{inner: "test"}
-
-	if value.String() != "?" {
-		t.Errorf("Expected '?', got '%s'", value.String())
-	}
-
-	if value.Binds()[0] != "test" {
-		t.Errorf("Expected %q, got %v", []any{"test"}, value.Binds())
-	}
-
-	expr := value.AsExpr()
-	if expr.kind != exprKindValue {
-		t.Errorf("Expected exprKindValue, got %d", expr.kind)
-	}
-}
-
-func TestBinaryExpressions(t *testing.T) {
-	tests := []struct {
-		name     string
-		expr     Expr
-		expected string
-	}{
-		{"Eq", Eq("age", 25), "(age) = (?)"},
-		{"Neq", Neq("status", "active"), "(status) <> (?)"},
-		{"Gt", Gt("score", 100), "(score) > (?)"},
-		{"Gte", Gte("rating", 4.5), "(rating) >= (?)"},
-		{"Lt", Lt("count", 10), "(count) < (?)"},
-		{"Lte", Lte("price", 99.99), "(price) <= (?)"},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			if test.expr.String() != test.expected {
-				t.Errorf("Expected '%s', got '%s'", test.expected, test.expr.String())
-			}
-
-			if test.expr.kind != exprKindBinary {
-				t.Errorf("Expected exprKindBinary, got %d", test.expr.kind)
-			}
-		})
-	}
-}
-
-func TestLogicalOperators(t *testing.T) {
-	left := Eq("age", 25)
-	right := Eq("status", "active")
-
-	andExpr := left.And(right)
-	expectedAnd := "((age) = (?)) and ((status) = (?))"
-	if andExpr.String() != expectedAnd {
-		t.Errorf("Expected '%s', got '%s'", expectedAnd, andExpr.String())
-	}
-
-	orExpr := left.Or(right)
-	expectedOr := "((age) = (?)) or ((status) = (?))"
-	if orExpr.String() != expectedOr {
-		t.Errorf("Expected '%s', got '%s'", expectedOr, orExpr.String())
-	}
-}
-
-func TestComplexExpressions(t *testing.T) {
-	age := Eq("age", 25)
-	status := Eq("status", "active")
-	score := Gt("score", 100)
-
-	complex := age.
-		And(status).
-		Or(score)
-	expected := "(((age) = (?)) and ((status) = (?))) or ((score) > (?))"
-
-	if complex.String() != expected {
-		t.Errorf("Expected '%s', got '%s'", expected, complex.String())
-	}
-}
-
 func TestSelectBasic(t *testing.T) {
 	s := Select("name", "age")
 
···
 func TestSelectBuild_Success(t *testing.T) {
 	tests := []struct {
 		name         string
-		stmt         select_
+		stmt         Compiler
 		expectedSql  string
 		expectedArgs []any
 	}{
···
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			sql, args, err := test.stmt.Build()
+			sql, args, err := test.stmt.Compile()
 
 			if err != nil {
 				t.Errorf("Expected no error, got %v", err)
···
 func TestSelectBuild_Errors(t *testing.T) {
 	tests := []struct {
 		name          string
-		stmt          select_
+		stmt          Compiler
 		expectedError string
 	}{
 		{
···
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			sql, args, err := test.stmt.Build()
+			sql, args, err := test.stmt.Compile()
 
 			if err == nil {
 				t.Error("Expected error, got nil")
···
 				t.Errorf("Expected empty args on error, got '%q'", args)
 			}
 		})
-	}
-}
-
-func TestDirections(t *testing.T) {
-	if Ascending != "asc" {
-		t.Errorf("Expected ASC to be 'asc', got '%s'", Ascending)
-	}
-
-	if Descending != "desc" {
-		t.Errorf("Expected DESC to be 'desc', got '%s'", Descending)
 	}
 }
 
···
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			sql, args, err := test.stmt.Build()
+			rows, err := test.stmt.Query(db)
 			if err != nil {
 				t.Fatalf("Failed to build query: %v", err)
 			}
 
-			rows, err := db.Query(sql, args...)
-			if err != nil {
-				t.Fatalf("Failed to execute query: %v", err)
-			}
-			defer rows.Close()
-
 			count := 0
 			for rows.Next() {
 				count++
···
 					Or(Eq("department", "Marketing").And(Lt("age", 30))),
 			)
 
-		sql, args := s.MustBuild()
-
-		rows, err := db.Query(sql, args...)
+		rows, err := s.Query(db)
 		if err != nil {
 			t.Fatalf("Failed to execute query: %v", err)
 		}
···
 			OrderBy("department", Ascending).
 			OrderBy("age", Descending)
 
-		sql, args := s.MustBuild()
-
-		rows, err := db.Query(sql, args...)
+		rows, err := s.Query(db)
 		if err != nil {
 			t.Fatalf("Failed to execute query: %v", err)
 		}
···
 			GroupBy("department").
 			OrderBy("user_count", Descending)
 
-		sql, args := s.MustBuild()
-
-		rows, err := db.Query(sql, args...)
+		rows, err := s.Query(db)
 		if err != nil {
 			t.Fatalf("Failed to execute query: %v", err)
 		}
···
 			OrderBy("salary", Descending).
 			Limit(2)
 
-		sql, args := s.MustBuild()
-
-		rows, err := db.Query(sql, args...)
+		rows, err := s.Query(db)
 		if err != nil {
 			t.Fatalf("Failed to execute query: %v", err)
 		}
···
 			From("users").
 			Where(Eq("name", "John Doe"))
 
-		sql, args := s.MustBuild()
-
-		rows, err := db.Query(sql, args...)
+		rows, err := s.Query(db)
 		if err != nil {
 			t.Fatalf("Failed to execute query: %v", err)
 		}
···
 			From("users").
 			Where(Eq("active", false))
 
-		sql, args := s.MustBuild()
-
-		rows, err := db.Query(sql, args...)
+		rows, err := s.Query(db)
 		if err != nil {
 			t.Fatalf("Failed to execute query: %v", err)
 		}
···
 			From("users").
 			Where(Gte("salary", 80000.0))
 
-		sql, args := s.MustBuild()
-
-		rows, err := db.Query(sql, args...)
+		rows, err := s.Query(db)
 		if err != nil {
 			t.Fatalf("Failed to execute query: %v", err)
 		}
···
 		}
 	})
 }
-
-func TestDeleteIntegration_BasicQueries(t *testing.T) {
-	tests := []struct {
-		name         string
-		stmt         delete_
-		expectedRows int64
-	}{
-		{
-			name:         "Delete all users",
-			stmt:         Delete().From("users"),
-			expectedRows: 6,
-		},
-		{
-			name: "Delete active users only",
-			stmt: Delete().
-				From("users").
-				Where(Eq("active", true)),
-			expectedRows: 4,
-		},
-		{
-			name: "Select users in Engineering",
-			stmt: Delete().
-				From("users").
-				Where(Eq("department", "Engineering")),
-			expectedRows: 3,
-		},
-		{
-			name: "Delete users with age > 30",
-			stmt: Delete().
-				From("users").
-				Where(Gt("age", 30)),
-			expectedRows: 2,
-		},
-		{
-			name: "Delete users with salary between 70000 and 80000",
-			stmt: Delete().
-				From("users").
-				Where(Gte("salary", 70000.0).And(Lte("salary", 80000.0))),
-			expectedRows: 3,
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			db := setupTestDB(t)
-			defer db.Close()
-
-			sql, args, err := test.stmt.Build()
-			if err != nil {
-				t.Fatalf("Failed to build query: %v", err)
-			}
-
-			res, err := db.Exec(sql, args...)
-			if err != nil {
-				t.Fatalf("Failed to execute query: %v", err)
-			}
-
-			count, err := res.RowsAffected()
-			if err != nil {
-				t.Fatalf("Failed to execute query: %v", err)
-			}
-
-			if count != test.expectedRows {
-				t.Errorf("Expected %d rows, got %d", test.expectedRows, count)
-			}
-		})
-	}
-}
-
-func TestInsertBuild_Success(t *testing.T) {
-	tests := []struct {
-		name         string
-		stmt         insert
-		expectedSql  string
-		expectedArgs []any
-	}{
-		{
-			name:         "Simple insert",
-			stmt:         Insert().Into("users").Value("name", "John"),
-			expectedSql:  "INSERT INTO users (name) VALUES (?)",
-			expectedArgs: []any{"John"},
-		},
-		{
-			name:         "Replace clause",
-			stmt:         Insert().Or(Replace).Into("users").Value("name", "John"),
-			expectedSql:  "INSERT OR REPLACE INTO users (name) VALUES (?)",
-			expectedArgs: []any{"John"},
-		},
-		{
-			name:         "More values",
-			stmt:         Insert().Into("users").Value("name", "John").Value("age", 35),
-			expectedSql:  "INSERT INTO users (name, age) VALUES (?, ?)",
-			expectedArgs: []any{"John", 35},
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			sql, args, err := test.stmt.Build()
-
-			if err != nil {
-				t.Errorf("Expected no error, got %v", err)
-			}
-
-			if sql != test.expectedSql {
-				t.Errorf("Expected '%s', got '%s'", test.expectedSql, sql)
-			}
-
-			if len(args) != len(test.expectedArgs) {
-				t.Errorf("Expected '%d' args, got '%d' args", len(test.expectedArgs), len(args))
-			}
-
-			for i := range len(args) {
-				if args[i] != test.expectedArgs[i] {
-					t.Errorf("Expected '%v', got '%v' at index %d", test.expectedArgs[i], args[i], i)
-				}
-			}
-		})
-	}
-}

select.go

···
+package norm
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type select_ struct {
+	resultColumns []string // TODO: strongly type result columns
+	from          string   // table-or-subquery expr
+	where         *Expr
+	orderBy       []orderBy
+	groupBy       []groupBy
+	limit         *limit
+}
+
+type orderBy struct {
+	field     string
+	direction Direction
+}
+
+type groupBy struct {
+	field string
+}
+
+type limit struct {
+	limit int
+}
+
+func Select(cols ...string) select_ {
+	return select_{
+		resultColumns: cols,
+	}
+}
+
+type SelectOpt func(s *select_)
+
+func (s select_) From(table string) select_ {
+	s.from = table
+	return s
+}
+
+func (s select_) Where(expr Expr) select_ {
+	s.where = &expr
+	return s
+}
+
+func (s select_) OrderBy(field string, direction Direction) select_ {
+	s.orderBy = append(s.orderBy, orderBy{
+		field:     field,
+		direction: direction,
+	})
+	return s
+}
+
+func (s select_) GroupBy(field string) select_ {
+	s.groupBy = append(s.groupBy, groupBy{
+		field: field,
+	})
+	return s
+}
+
+func (s select_) Limit(i int) select_ {
+	s.limit = &limit{
+		limit: i,
+	}
+	return s
+}
+
+func (s select_) Compile() (string, []any, error) {
+	var sql strings.Builder
+	var args []any
+
+	sql.WriteString("SELECT ")
+	if len(s.resultColumns) == 0 {
+		return "", nil, fmt.Errorf("result columns empty")
+	} else {
+		for i, col := range s.resultColumns {
+			if i > 0 {
+				sql.WriteString(", ")
+			}
+			sql.WriteString(col)
+		}
+	}
+
+	if s.from == "" {
+		return "", nil, fmt.Errorf("FROM clause is required")
+	}
+	sql.WriteString(" FROM ")
+	sql.WriteString(s.from)
+
+	if s.where != nil {
+		sql.WriteString(" WHERE ")
+		sql.WriteString(s.where.String())
+
+		args = s.where.Binds()
+	}
+
+	// GROUP BY clause
+	if len(s.groupBy) > 0 {
+		sql.WriteString(" GROUP BY ")
+		for i, gb := range s.groupBy {
+			if i > 0 {
+				sql.WriteString(", ")
+			}
+			sql.WriteString(gb.field)
+		}
+	}
+
+	// ORDER BY clause
+	if len(s.orderBy) > 0 {
+		sql.WriteString(" ORDER BY ")
+		for i, ob := range s.orderBy {
+			if i > 0 {
+				sql.WriteString(", ")
+			}
+			sql.WriteString(ob.field)
+			sql.WriteString(" ")
+			sql.WriteString(string(ob.direction))
+		}
+	}
+
+	// LIMIT clause
+	if s.limit != nil {
+		if s.limit.limit <= 0 {
+			return "", nil, fmt.Errorf("LIMIT must be positive, got %d", s.limit.limit)
+		}
+		sql.WriteString(" LIMIT ")
+		sql.WriteString(strconv.Itoa(s.limit.limit))
+	}
+
+	return sql.String(), args, nil
+}
+
+func (s select_) Build(p Database) (*sql.Stmt, []any, error) {
+	return Build(s, p)
+}
+
+func (s select_) MustBuild(p Database) (*sql.Stmt, []any) {
+	return MustBuild(s, p)
+}
+
+func (s select_) Exec(p Database) (sql.Result, error) {
+	return Exec(s, p)
+}
+
+func (s select_) ExecContext(ctx context.Context, p Database) (sql.Result, error) {
+	return ExecContext(ctx, s, p)
+}
+
+func (s select_) Query(p Database) (*sql.Rows, error) {
+	return Query(s, p)
+}
+
+func (s select_) QueryContext(ctx context.Context, p Database) (*sql.Rows, error) {
+	return QueryContext(ctx, s, p)
+}
+
+func (s select_) QueryRow(p Database) (*sql.Row, error) {
+	return QueryRow(s, p)
+}
+
+func (s select_) QueryRowContext(ctx context.Context, p Database) (*sql.Row, error) {
+	return QueryRowContext(ctx, s, p)
+}

types.go

···
+package norm
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+)
+
+type Database interface {
+	Prepare(sql string) (*sql.Stmt, error)
+	PrepareContext(ctx context.Context, query string) (*sql.Stmt, error)
+
+	Exec(query string, args ...any) (sql.Result, error)
+	ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)
+}
+
+type Compiler interface {
+	Compile() (string, []any, error)
+}
+
+type Builder interface {
+	Build(db Database) (*sql.Stmt, []any, error)
+	MustBuild(db Database) (*sql.Stmt, []any)
+}
+
+// anything that is a Compiler, can also be Builder:
+func Build(c Compiler, p Database) (*sql.Stmt, []any, error) {
+	query, args, err := c.Compile()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	stmt, err := p.Prepare(query)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to prepare statement: `%s` : %w", query, err)
+	}
+
+	return stmt, args, nil
+}
+
+func MustBuild(c Compiler, p Database) (*sql.Stmt, []any) {
+	stmt, args, err := Build(c, p)
+	if err != nil {
+		panic(err)
+	}
+	return stmt, args
+}
+
+type Execer interface {
+	Exec(db Database) (sql.Result, error)
+	ExecContext(ctx context.Context, db Database) (sql.Result, error)
+}
+
+// anything that is a Builder can also be an Execer
+func Exec(b Builder, p Database) (sql.Result, error) {
+	return ExecContext(context.Background(), b, p)
+}
+
+func ExecContext(ctx context.Context, b Builder, p Database) (sql.Result, error) {
+	stmt, args, err := b.Build(p)
+	if err != nil {
+		return nil, err
+	}
+
+	return stmt.ExecContext(ctx, args...)
+}
+
+type Querier interface {
+	Query(db Database) (*sql.Rows, error)
+	QueryContext(ctx context.Context, db Database) (*sql.Rows, error)
+	QueryRow(db Database) (*sql.Row, error)
+	QueryRowContext(ctx context.Context, db Database) (*sql.Row, error)
+}
+
+// anything that is a Builder can also be an Querier
+func Query(b Builder, p Database) (*sql.Rows, error) {
+	return QueryContext(context.Background(), b, p)
+}
+
+func QueryContext(ctx context.Context, b Builder, p Database) (*sql.Rows, error) {
+	stmt, args, err := b.Build(p)
+	if err != nil {
+		return nil, err
+	}
+
+	return stmt.QueryContext(ctx, args...)
+}
+
+func QueryRow(b Builder, p Database) (*sql.Row, error) {
+	return QueryRowContext(context.Background(), b, p)
+}
+
+func QueryRowContext(ctx context.Context, b Builder, p Database) (*sql.Row, error) {
+	stmt, args, err := b.Build(p)
+	if err != nil {
+		return nil, err
+	}
+
+	return stmt.QueryRowContext(ctx, args...), nil
+}
+
+type Direction string
+
+const (
+	Ascending  Direction = "asc"
+	Descending Direction = "desc"
+)
+
+func Placeholder[T any]() T {
+	var zero T
+	return zero
+}