norm: init

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

go.mod

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

query.go

···
+package norm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+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
+}

query_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) {
+	// Test chained logical operations
+	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")
+
+	if len(s.resultColumns) != 2 {
+		t.Errorf("Expected 2 columns, got %d", len(s.resultColumns))
+	}
+
+	if s.resultColumns[0] != "name" || s.resultColumns[1] != "age" {
+		t.Errorf("Expected columns [name, age], got %v", s.resultColumns)
+	}
+}
+
+func TestSelectAPI(t *testing.T) {
+	// Test fluent API chaining
+	s := Select("*").
+		From("users").
+		Where(Eq("id", 1)).
+		OrderBy("name", Ascending).
+		GroupBy("department").
+		Limit(10)
+
+	if s.from != "users" {
+		t.Errorf("Expected from to be 'users', got '%s'", s.from)
+	}
+
+	if s.where == nil {
+		t.Error("Expected where clause to be set")
+	}
+
+	if len(s.orderBy) != 1 {
+		t.Errorf("Expected 1 order by clause, got %d", len(s.orderBy))
+	}
+
+	if s.orderBy[0].field != "name" || s.orderBy[0].direction != Ascending {
+		t.Errorf("Expected order by name ASC, got %v", s.orderBy[0])
+	}
+
+	if len(s.groupBy) != 1 {
+		t.Errorf("Expected 1 group by clause, got %d", len(s.groupBy))
+	}
+
+	if s.groupBy[0].field != "department" {
+		t.Errorf("Expected group by department, got %s", s.groupBy[0].field)
+	}
+
+	if s.limit == nil {
+		t.Error("Expected limit to be set")
+	}
+
+	if s.limit.limit != 10 {
+		t.Errorf("Expected limit 10, got %d", s.limit.limit)
+	}
+}
+
+func TestSelectBuild_Success(t *testing.T) {
+	tests := []struct {
+		name         string
+		builder      func() select_
+		expectedSql  string
+		expectedArgs []any
+	}{
+		{
+			name: "Simple select",
+			builder: func() select_ {
+				return Select("name", "age").From("users")
+			},
+			expectedSql:  "SELECT name, age FROM users",
+			expectedArgs: nil,
+		},
+		{
+			name: "Select with where",
+			builder: func() select_ {
+				return Select("*").
+					From("users").
+					Where(Eq("active", true))
+			},
+			expectedSql:  "SELECT * FROM users WHERE (active) = (?)",
+			expectedArgs: []any{true},
+		},
+		{
+			name: "Select with order by",
+			builder: func() select_ {
+				return Select("name").
+					From("users").
+					OrderBy("name", Ascending)
+			},
+			expectedSql:  "SELECT name FROM users ORDER BY name asc",
+			expectedArgs: nil,
+		},
+		{
+			name: "Select with multiple order by",
+			builder: func() select_ {
+				return Select("name", "age").
+					From("users").
+					OrderBy("name", Ascending).
+					OrderBy("age", Descending)
+			},
+			expectedSql:  "SELECT name, age FROM users ORDER BY name asc, age desc",
+			expectedArgs: nil,
+		},
+		{
+			name: "Select with group by",
+			builder: func() select_ {
+				return Select("department", "COUNT(*)").
+					From("users").
+					GroupBy("department")
+			},
+			expectedSql:  "SELECT department, COUNT(*) FROM users GROUP BY department",
+			expectedArgs: nil,
+		},
+		{
+			name: "Select with limit",
+			builder: func() select_ {
+				return Select("*").
+					From("users").
+					Limit(5)
+			},
+			expectedSql:  "SELECT * FROM users LIMIT 5",
+			expectedArgs: nil,
+		},
+		{
+			name: "Complex select",
+			builder: func() select_ {
+				return Select("name", "age", "department").
+					From("users").
+					Where(Eq("active", true).And(Gt("age", 18))).
+					GroupBy("department").
+					OrderBy("name", Ascending).
+					Limit(10)
+			},
+			expectedSql:  "SELECT name, age, department FROM users WHERE ((active) = (?)) and ((age) > (?)) GROUP BY department ORDER BY name asc LIMIT 10",
+			expectedArgs: []any{true, 18},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			s := test.builder()
+			sql, args, err := s.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 '%s', got '%s' at index %d", test.expectedArgs[i], args[i], i)
+				}
+			}
+		})
+	}
+}
+
+func TestSelectBuild_Errors(t *testing.T) {
+	tests := []struct {
+		name          string
+		builder       func() select_
+		expectedError string
+	}{
+		{
+			name: "No columns",
+			builder: func() select_ {
+				return Select()
+			},
+			expectedError: "result columns empty",
+		},
+		{
+			name: "No from clause",
+			builder: func() select_ {
+				return Select("name")
+			},
+			expectedError: "FROM clause is required",
+		},
+		{
+			name: "Invalid limit",
+			builder: func() select_ {
+				return Select("name").
+					From("users").
+					Limit(0)
+			},
+			expectedError: "LIMIT must be positive, got 0",
+		},
+		{
+			name: "Negative limit",
+			builder: func() select_ {
+				return Select("name").
+					From("users").
+					Limit(-5)
+			},
+			expectedError: "LIMIT must be positive, got -5",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			s := test.builder()
+			sql, args, err := s.Build()
+
+			if err == nil {
+				t.Error("Expected error, got nil")
+			}
+
+			if err.Error() != test.expectedError {
+				t.Errorf("Expected error '%s', got '%s'", test.expectedError, err.Error())
+			}
+
+			if sql != "" {
+				t.Errorf("Expected empty SQL on error, got '%s'", sql)
+			}
+
+			if args != 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)
+	}
+}
+
+func TestMultipleOrderBy(t *testing.T) {
+	s := Select("name", "age").
+		From("users").
+		OrderBy("name", Ascending).
+		OrderBy("age", Descending).
+		OrderBy("created_at", Descending)
+
+	if len(s.orderBy) != 3 {
+		t.Errorf("Expected 3 order by clauses, got %d", len(s.orderBy))
+	}
+
+	expected := []orderBy{
+		{"name", Ascending},
+		{"age", Descending},
+		{"created_at", Descending},
+	}
+
+	for i, ob := range s.orderBy {
+		if ob.field != expected[i].field || ob.direction != expected[i].direction {
+			t.Errorf("Expected order by %v, got %v", expected[i], ob)
+		}
+	}
+}
+
+func TestMultipleGroupBy(t *testing.T) {
+	s := Select("department", "status", "COUNT(*)").
+		From("users").
+		GroupBy("department").
+		GroupBy("status")
+
+	if len(s.groupBy) != 2 {
+		t.Errorf("Expected 2 group by clauses, got %d", len(s.groupBy))
+	}
+
+	expected := []string{"department", "status"}
+
+	for i, gb := range s.groupBy {
+		if gb.field != expected[i] {
+			t.Errorf("Expected group by %s, got %s", expected[i], gb.field)
+		}
+	}
+}