add update stmt

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

expr.go

···
 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() }
+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

···
 	right := Eq("status", "active")
 
 	andExpr := left.And(right)
-	expectedAnd := "((age) = (?)) and ((status) = (?))"
+	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) = (?))"
+	expectedOr := "((age) = (?)) OR ((status) = (?))"
 	if orExpr.String() != expectedOr {
 		t.Errorf("Expected '%s', got '%s'", expectedOr, orExpr.String())
 	}
···
 	complex := age.
 		And(status).
 		Or(score)
-	expected := "(((age) = (?)) and ((status) = (?))) or ((score) > (?))"
+	expected := "(((age) = (?)) AND ((status) = (?))) OR ((score) > (?))"
 
 	if complex.String() != expected {
 		t.Errorf("Expected '%s', got '%s'", expected, complex.String())

select_test.go

···
 				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",
+			expectedSql:  "SELECT name, age, department FROM users WHERE ((active) = (?)) AND ((age) > (?)) GROUP BY department ORDER BY name asc LIMIT 10",
 			expectedArgs: []any{true, 18},
 		},
 	}
···
 			expectedRows: 2,
 		},
 		{
-			name: "Select users with salary between 70000 and 80000",
+			name: "Select users with salary between 70000 AND 80000",
 			stmt: Select("name", "salary").
 				From("users").
 				Where(Gte("salary", 70000.0).And(Lte("salary", 80000.0))),

update.go

···
+package norm
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+)
+
+type update struct {
+	table string
+	or    UpdateOr
+	sets  []struct {
+		col string
+		val any
+	}
+	where *Expr
+}
+
+type UpdateOr int
+
+const (
+	UpdateNone UpdateOr = iota
+	UpdateAbort
+	UpdateFail
+	UpdateIgnore
+	UpdateReplace
+	UpdateRollback
+)
+
+func (u UpdateOr) String() string {
+	switch u {
+	case UpdateAbort:
+		return "ABORT"
+	case UpdateFail:
+		return "FAIL"
+	case UpdateIgnore:
+		return "IGNORE"
+	case UpdateReplace:
+		return "REPLACE"
+	case UpdateRollback:
+		return "ROLLBACK"
+	default:
+		return ""
+	}
+}
+
+func Update(table string) update {
+	return update{table: table}
+}
+
+type UpdateOpt func(s *update)
+
+func (u update) Or(option UpdateOr) update {
+	u.or = option
+	return u
+}
+
+func (u update) Set(column string, value any) update {
+	u.sets = append(u.sets, struct {
+		col string
+		val any
+	}{
+		column, value,
+	})
+	return u
+}
+
+func (u update) Sets(values map[string]any) update {
+	for column, value := range values {
+		u = u.Set(column, value)
+	}
+	return u
+}
+
+func (u update) Where(expr Expr) update {
+	u.where = &expr
+	return u
+}
+
+func (u update) Compile() (string, []any, error) {
+	var sql strings.Builder
+	var args []any
+
+	sql.WriteString("UPDATE ")
+
+	orKw := u.or.String()
+	if orKw != "" {
+		sql.WriteString("OR ")
+		sql.WriteString(u.or.String())
+		sql.WriteString(" ")
+	}
+
+	if u.table == "" {
+		return "", nil, fmt.Errorf("table name is required")
+	}
+	sql.WriteString(u.table)
+
+	if len(u.sets) == 0 {
+		return "", nil, fmt.Errorf("no SET clauses supplied")
+	}
+
+	sql.WriteString(" SET ")
+
+	for i, set := range u.sets {
+		if i != 0 {
+			sql.WriteString(", ")
+		}
+		sql.WriteString(set.col)
+		sql.WriteString(" = ?")
+		args = append(args, set.val)
+	}
+
+	if u.where != nil {
+		sql.WriteString(" WHERE ")
+		sql.WriteString(u.where.String())
+
+		args = append(args, u.where.Binds()...)
+	}
+
+	return sql.String(), args, nil
+}
+
+func (u update) MustCompile() (string, []any) {
+	sql, args, err := u.Compile()
+	if err != nil {
+		panic(err)
+	}
+
+	return sql, args
+}
+
+func (u update) Build(p Database) (*sql.Stmt, []any, error) { return Build(u, p) }
+func (u update) MustBuild(p Database) (*sql.Stmt, []any)    { return MustBuild(u, p) }
+
+func (u update) Exec(p Database) (sql.Result, error) { return Exec(u, p) }
+func (u update) ExecContext(ctx context.Context, p Database) (sql.Result, error) {
+	return ExecContext(ctx, u, p)
+}
+func (u update) MustExec(p Database) sql.Result { return MustExec(u, p) }
+func (u update) MustExecContext(ctx context.Context, p Database) sql.Result {
+	return MustExecContext(ctx, u, p)
+}

update_test.go

···
+package norm
+
+import (
+	"slices"
+	"testing"
+
+	_ "github.com/mattn/go-sqlite3"
+)
+
+func TestUpdateBuild_Success(t *testing.T) {
+	tests := []struct {
+		name         string
+		stmt         Compiler
+		expectedSql  string
+		expectedArgs []any
+	}{
+		{
+			name:         "Simple update",
+			stmt:         Update("users").Set("name", "John"),
+			expectedSql:  "UPDATE users SET name = ?",
+			expectedArgs: []any{"John"},
+		},
+		{
+			name:         "Update with WHERE",
+			stmt:         Update("users").Set("name", "John").Where(Eq("id", 1)),
+			expectedSql:  "UPDATE users SET name = ? WHERE (id) = (?)",
+			expectedArgs: []any{"John", 1},
+		},
+		{
+			name:         "Abort clause",
+			stmt:         Update("users").Or(UpdateAbort).Set("name", "John"),
+			expectedSql:  "UPDATE OR ABORT users SET name = ?",
+			expectedArgs: []any{"John"},
+		},
+		{
+			name:         "Ignore clause",
+			stmt:         Update("users").Or(UpdateIgnore).Set("name", "John"),
+			expectedSql:  "UPDATE OR IGNORE users SET name = ?",
+			expectedArgs: []any{"John"},
+		},
+		{
+			name:         "Fail clause",
+			stmt:         Update("users").Or(UpdateFail).Set("name", "John"),
+			expectedSql:  "UPDATE OR FAIL users SET name = ?",
+			expectedArgs: []any{"John"},
+		},
+		{
+			name:         "Replace clause",
+			stmt:         Update("users").Or(UpdateReplace).Set("name", "John"),
+			expectedSql:  "UPDATE OR REPLACE users SET name = ?",
+			expectedArgs: []any{"John"},
+		},
+		{
+			name:         "Rollback clause",
+			stmt:         Update("users").Or(UpdateRollback).Set("name", "John"),
+			expectedSql:  "UPDATE OR ROLLBACK users SET name = ?",
+			expectedArgs: []any{"John"},
+		},
+		{
+			name:         "Default clause",
+			stmt:         Update("users").Or(UpdateOr(10)).Set("name", "John"),
+			expectedSql:  "UPDATE users SET name = ?",
+			expectedArgs: []any{"John"},
+		},
+		{
+			name:         "Multiple sets",
+			stmt:         Update("users").Set("name", "John").Set("age", 35),
+			expectedSql:  "UPDATE users SET name = ?, age = ?",
+			expectedArgs: []any{"John", 35},
+		},
+		{
+			name:         "Multiple WHERE conditions",
+			stmt:         Update("users").Set("salary", 90000.0).Where(Eq("department", "Engineering").And(Eq("active", true))),
+			expectedSql:  "UPDATE users SET salary = ? WHERE ((department) = (?)) AND ((active) = (?))",
+			expectedArgs: []any{90000.0, "Engineering", true},
+		},
+		{
+			name:         "Complex update",
+			stmt:         Update("users").Or(UpdateIgnore).Set("name", "Updated").Set("salary", 100000.0).Where(Gt("age", 30).And(Eq("active", true))),
+			expectedSql:  "UPDATE OR IGNORE users SET name = ?, salary = ? WHERE ((age) > (?)) AND ((active) = (?))",
+			expectedArgs: []any{"Updated", 100000.0, 30, true},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			sql, args := test.stmt.MustCompile()
+
+			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)
+				}
+			}
+		})
+	}
+}
+
+func TestUpdateSetMap_Build(t *testing.T) {
+	tests := []struct {
+		name           string
+		stmt           Compiler
+		expectedConfig []struct {
+			sql  string
+			args []any
+		}
+	}{
+		{
+			name: "Sets with map",
+			stmt: Update("users").Sets(map[string]any{
+				"name": "John",
+				"age":  25,
+			}).Where(Eq("id", 1)),
+			expectedConfig: []struct {
+				sql  string
+				args []any
+			}{
+				{
+					sql:  "UPDATE users SET name = ?, age = ? WHERE (id) = (?)",
+					args: []any{"John", 25, 1},
+				},
+				{
+					sql:  "UPDATE users SET age = ?, name = ? WHERE (id) = (?)",
+					args: []any{25, "John", 1},
+				},
+			},
+		},
+		{
+			name: "Mixed individual and map sets",
+			stmt: Update("users").Set("active", false).Sets(map[string]any{
+				"name":   "Updated User",
+				"salary": 95000.0,
+			}),
+			expectedConfig: []struct {
+				sql  string
+				args []any
+			}{
+				{
+					sql:  "UPDATE users SET active = ?, name = ?, salary = ?",
+					args: []any{false, "Updated User", 95000.0},
+				},
+				{
+					sql:  "UPDATE users SET active = ?, salary = ?, name = ?",
+					args: []any{false, 95000.0, "Updated User"},
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			sql, args := test.stmt.MustCompile()
+
+			any := false
+			idx := 0
+			for i, config := range test.expectedConfig {
+				idx = i
+				equalSql := config.sql == sql
+				equalArgs := slices.Equal(config.args, args)
+				if equalSql && equalArgs {
+					any = true
+				}
+			}
+
+			if !any {
+				t.Errorf("Config did not match: %d: %q; got %q, %q", idx, test.expectedConfig[idx], sql, args)
+			}
+
+		})
+	}
+}
+
+func TestUpdateCompileFail(t *testing.T) {
+	tests := []struct {
+		name          string
+		stmt          Compiler
+		expectedError string
+	}{
+		{
+			name:          "No SET clauses",
+			stmt:          Update("users"),
+			expectedError: "no SET clauses supplied",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			sql, args, err := test.stmt.Compile()
+			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 TestUpdateIntegration(t *testing.T) {
+	tests := []struct {
+		name         string
+		stmt         Execer
+		expectedRows int64
+	}{
+		{
+			name:         "Update all users salary",
+			stmt:         Update("users").Set("salary", 100000.0),
+			expectedRows: 6,
+		},
+		{
+			name: "Update active users only",
+			stmt: Update("users").
+				Set("department", "Updated Department").
+				Where(Eq("active", true)),
+			expectedRows: 4,
+		},
+		{
+			name: "Update users in Engineering",
+			stmt: Update("users").
+				Set("salary", 95000.0).
+				Where(Eq("department", "Engineering")),
+			expectedRows: 3,
+		},
+		{
+			name: "Update users with age > 30",
+			stmt: Update("users").
+				Set("active", false).
+				Where(Gt("age", 30)),
+			expectedRows: 2,
+		},
+		{
+			name: "Update users with multiple conditions",
+			stmt: Update("users").
+				Set("salary", 120000.0).
+				Where(Eq("department", "Engineering").And(Eq("active", true))),
+			expectedRows: 2,
+		},
+		{
+			name: "Update with OR IGNORE (no conflict expected)",
+			stmt: Update("users").
+				Or(UpdateIgnore).
+				Set("name", "Updated Name").
+				Where(Eq("id", 1)),
+			expectedRows: 1,
+		},
+		{
+			name: "Update multiple fields",
+			stmt: Update("users").
+				Sets(map[string]any{
+					"active": true,
+					"salary": 110000.0,
+				}).
+				Where(Eq("department", "Marketing")),
+			expectedRows: 2,
+		},
+		{
+			name: "Update with no matching rows",
+			stmt: Update("users").
+				Set("name", "Non-existent").
+				Where(Eq("id", 999)),
+			expectedRows: 0,
+		},
+	}
+
+	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 get rows affected: %v", err)
+			}
+
+			if count != test.expectedRows {
+				t.Errorf("Expected %d rows, got %d", test.expectedRows, count)
+			}
+		})
+	}
+}