Expressions

An ant.Expr[V]type Expr[] struct{ … }Expr is a typed SQL expression: a column, an aggregate, or a raw fragment. computes a value in SQL and knows its Go type. You can compare it, order by it, select it, or write it to a column.

Using an expression

lower := ant.Lower(&U.Name)

users, err := db.Users.
	Where(lower.Eq("bob")).
	Order(lower.Desc()).
	All(ctx)

Columns and arithmetic

ant.Colfunc Col[V any](field *V) Expr[V]Col returns the expression for a column. turns a probe into an expression, and arithmetic stays typed.

nextYear := ant.Col(&U.Age).Plus(1)

users, err := db.Users.Where(nextYear.Eq(18)).All(ctx)

Method	Does
.Plus, .Minus, .Times, .Div	arithmetic with a value
.Eq, .Ne, .Gt, .Gte, .Lt, .Lte	compare with a value, giving a Cond
.EqExpr, .GtExpr, .LtExpr	compare with another expression
.IsNull, .IsNotNull	check for NULL
.Asc, .Desc	an ordering term
.Filter(conds...)	narrow an aggregate
.Over(window)	run as a window function

Built-in functions

lower := ant.Lower(&U.Name)
upper := ant.Upper(&U.Name)
length := ant.Length(&U.Name)
fallback := ant.Coalesce(&U.Bio, new("none"))
sorted := ant.Collate(&U.Name, "C")

users, err := db.Users.Where(length.Gte(5)).Order(sorted.Asc()).All(ctx)

CASE

kind := ant.Case[string]().
	When(ant.Lt(&U.Age, 18), "minor").
	When(ant.Gt(&U.Age, 65), "senior").
	Else("adult")

Elsefunc (c CaseExpr[V]) Else(value V) Expr[V]Else finishes the expression with a value for when no branch matches. returns the finished Expr[string]. Endfunc (c CaseExpr[V]) End() Expr[sql.Null[V]]End finishes the expression, which is NULL when no branch matches. leaves it open, as Expr[sql.Null[string]], since a row that matches nothing is NULL. WhenExprfunc (c CaseExpr[V]) WhenExpr(cond Cond, then Expr[V]) CaseExpr[V]WhenExpr adds a branch whose result is an expression, such as another column. and ElseExprfunc (c CaseExpr[V]) ElseExpr(value Expr[V]) Expr[V]ElseExpr finishes the expression, with an expression for rows no branch matched. take columns or other expressions as results.

Any database function

ant.Funcfunc Func[R any](name string, args ...any) Expr[R]Func calls a database function by name. calls a function by name, with the result type you state. Columns go in as expressions, and other values are bound.

fixed := ant.Func[string]("REPLACE", ant.Col(&U.Name), "o", "0")

A SQL fragment

ant.SQLfunc SQL[V any](text string, args ...any) Expr[V]SQL returns an expression from raw SQL. lets you write the expression yourself. Each ? takes a column or a bound value, so a value never becomes part of the statement text.

label := ant.SQL[string]("? || ?", ant.Col(&U.Name), "/x")
even := ant.SQLCond("? % ? = 0", ant.Col(&U.Age), 2)

users, err := db.Users.Where(even).All(ctx)

ant.SQLCondfunc SQLCond(text string, args ...any) CondSQLCond returns a condition from raw SQL. is the same thing, as a condition. The wrong number of arguments is an error.

Never build the text from input

The string is SQL, by design. Pass values as arguments, and keep the text a constant.

See it tested: tests/features/querying/expressions_test.go