Include CASE WHEN expression starter

dialect/mysql/select_test.go

@@ -30,6 +30,34 @@ func TestSelect(t *testing.T) {
 				sm.Where(mysql.Quote("id").In(mysql.Arg(100, 200, 300))),
 			),
 		},
+		"case with else": {
+			ExpectedSQL: "SELECT id, name, (CASE WHEN (`id` = '1') THEN 'A' ELSE 'B' END) AS `C` FROM users",
+			Query: mysql.Select(
+				sm.Columns(
+					"id",
+					"name",
+					mysql.Case().
+						When(mysql.Quote("id").EQ(mysql.S("1")), mysql.S("A")).
+						Else(mysql.S("B")).
+						As("C"),
+				),
+				sm.From("users"),
+			),
+		},
+		"case without else": {
+			ExpectedSQL: "SELECT id, name, (CASE WHEN (`id` = '1') THEN 'A' END) AS `C` FROM users",
+			Query: mysql.Select(
+				sm.Columns(
+					"id",
+					"name",
+					mysql.Case().
+						When(mysql.Quote("id").EQ(mysql.S("1")), mysql.S("A")).
+						End().
+						As("C"),
+				),
+				sm.From("users"),
+			),
+		},
 		"select distinct": {
 			ExpectedSQL:  "SELECT DISTINCT id, name FROM users WHERE (`id` IN (?, ?, ?))",
 			ExpectedArgs: []any{100, 200, 300},

dialect/mysql/starters.go

@@ -100,3 +100,9 @@ func Raw(query string, args ...any) Expression {
 func Cast(exp bob.Expression, typname string) Expression {
 	return bmod.Cast(exp, typname)
 }
+
+// SQL: CASE WHEN a THEN b ELSE c END
+// Go: mysql.Case().When("a", "b").Else("c")
+func Case() expr.CaseChain[Expression, Expression] {
+	return expr.NewCase[Expression, Expression]()
+}

dialect/psql/select_test.go

@@ -29,6 +29,34 @@ func TestSelect(t *testing.T) {
 				sm.Where(psql.Quote("id").In(psql.Arg(100, 200, 300))),
 			),
 		},
+		"case with else": {
+			ExpectedSQL: `SELECT id, name, (CASE WHEN (id = '1') THEN 'A' ELSE 'B' END) AS "C" FROM users`,
+			Query: psql.Select(
+				sm.Columns(
+					"id",
+					"name",
+					psql.Case().
+						When(psql.Quote("id").EQ(psql.S("1")), psql.S("A")).
+						Else(psql.S("B")).
+						As("C"),
+				),
+				sm.From("users"),
+			),
+		},
+		"case without else": {
+			ExpectedSQL: `SELECT id, name, (CASE WHEN (id = '1') THEN 'A' END) AS "C" FROM users`,
+			Query: psql.Select(
+				sm.Columns(
+					"id",
+					"name",
+					psql.Case().
+						When(psql.Quote("id").EQ(psql.S("1")), psql.S("A")).
+						End().
+						As("C"),
+				),
+				sm.From("users"),
+			),
+		},
 		"select distinct": {
 			ExpectedSQL:  "SELECT DISTINCT id, name FROM users WHERE (id IN ($1, $2, $3))",
 			ExpectedArgs: []any{100, 200, 300},

dialect/psql/starters.go

@@ -100,3 +100,9 @@ func Raw(query string, args ...any) Expression {
 func Cast(exp bob.Expression, typname string) Expression {
 	return bmod.Cast(exp, typname)
 }
+
+// SQL: CASE WHEN a THEN b ELSE c END
+// Go: psql.Case().When("a", "b").Else("c")
+func Case() expr.CaseChain[Expression, Expression] {
+	return expr.NewCase[Expression, Expression]()
+}

dialect/sqlite/select_test.go

@@ -30,6 +30,34 @@ func TestSelect(t *testing.T) {
 				sm.Where(sqlite.Quote("id").In(sqlite.Arg(100, 200, 300))),
 			),
 		},
+		"case with else": {
+			ExpectedSQL: `SELECT id, name, (CASE WHEN ("id" = '1') THEN 'A' ELSE 'B' END) AS "C" FROM users`,
+			Query: sqlite.Select(
+				sm.Columns(
+					"id",
+					"name",
+					sqlite.Case().
+						When(sqlite.Quote("id").EQ(sqlite.S("1")), sqlite.S("A")).
+						Else(sqlite.S("B")).
+						As("C"),
+				),
+				sm.From("users"),
+			),
+		},
+		"case without else": {
+			ExpectedSQL: `SELECT id, name, (CASE WHEN ("id" = '1') THEN 'A' END) AS "C" FROM users`,
+			Query: sqlite.Select(
+				sm.Columns(
+					"id",
+					"name",
+					sqlite.Case().
+						When(sqlite.Quote("id").EQ(sqlite.S("1")), sqlite.S("A")).
+						End().
+						As("C"),
+				),
+				sm.From("users"),
+			),
+		},
 		"select distinct": {
 			ExpectedSQL:  `SELECT DISTINCT id, name FROM users WHERE ("id" IN (?1, ?2, ?3))`,
 			ExpectedArgs: []any{100, 200, 300},

dialect/sqlite/starters.go

@@ -100,3 +100,9 @@ func Raw(query string, args ...any) Expression {
 func Cast(exp bob.Expression, typname string) Expression {
 	return bmod.Cast(exp, typname)
 }
+
+// SQL: CASE WHEN a THEN b ELSE c END
+// Go: sqlite.Case().When("a", "b").Else("c")
+func Case() expr.CaseChain[Expression, Expression] {
+	return expr.NewCase[Expression, Expression]()
+}

expr/case.go

@@ -0,0 +1,83 @@
+package expr
+
+import (
+	"context"
+	"errors"
+	"io"
+
+	"github.com/stephenafamo/bob"
+)
+
+type (
+	caseExpr struct {
+		whens    []when
+		elseExpr bob.Expression
+	}
+	when struct {
+		condition bob.Expression
+		then      bob.Expression
+	}
+)
+
+func (c caseExpr) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error) {
+	var args []any
+
+	if len(c.whens) == 0 {
+		return nil, errors.New("case must have at least one when expression")
+	}
+
+	w.Write([]byte("CASE"))
+	for _, when := range c.whens {
+		w.Write([]byte(" WHEN "))
+		whenArgs, err := when.condition.WriteSQL(ctx, w, d, start+len(args))
+		if err != nil {
+			return nil, err
+		}
+		args = append(args, whenArgs...)
+
+		w.Write([]byte(" THEN "))
+		thenArgs, err := when.then.WriteSQL(ctx, w, d, start+len(args))
+		if err != nil {
+			return nil, err
+		}
+		args = append(args, thenArgs...)
+	}
+
+	if c.elseExpr != nil {
+		w.Write([]byte(" ELSE "))
+		elseArgs, err := c.elseExpr.WriteSQL(ctx, w, d, start+len(args))
+		if err != nil {
+			return nil, err
+		}
+		args = append(args, elseArgs...)
+	}
+	w.Write([]byte(" END"))
+
+	return args, nil
+}
+
+type CaseChain[T bob.Expression, B builder[T]] func() caseExpr
+
+func NewCase[T bob.Expression, B builder[T]]() CaseChain[T, B] {
+	return CaseChain[T, B](func() caseExpr { return caseExpr{} })
+}
+
+func (cc CaseChain[T, B]) WriteSQL(ctx context.Context, w io.Writer, d bob.Dialect, start int) ([]any, error) {
+	return cc().WriteSQL(ctx, w, d, start)
+}
+
+func (cc CaseChain[T, B]) When(condition, then bob.Expression) CaseChain[T, B] {
+	c := cc()
+	c.whens = append(c.whens, when{condition: condition, then: then})
+	return CaseChain[T, B](func() caseExpr { return c })
+}
+
+func (cc CaseChain[T, B]) Else(then bob.Expression) T {
+	c := cc()
+	c.elseExpr = then
+	return X[T, B](c)
+}
+
+func (cc CaseChain[T, B]) End() T {
+	return X[T, B](cc())
+}