Conditions

A condition is a value of type ant.Condtype Cond struct{ … }Cond is a query condition.. You build one from a field probe and pass it to Wherefunc (t *Table[T]) Where(c ...Cond) *Query[T]Where starts a query with conditions., and the compiler checks that the value fits the column.

Comparing values

users, err := db.Users.
	Where(ant.Gte(&U.Age, 18)).
	All(ctx)

Several conditions in one Where all have to match, and calling Where again adds more.

users, err := db.Users.
	Where(ant.Gte(&U.Age, 18), ant.Lt(&U.Age, 65)).
	Where(ant.Ne(&U.Name, "Bob")).
	All(ctx)

Condition	Means
ant.Eq(&U.Age, 18)func Eq[V comparable](field *V, v V) CondEq matches rows where field equals v.	equal
ant.Ne(&U.Age, 18)func Ne[V comparable](field *V, v V) CondNe matches rows where field does not equal v.	not equal
ant.Gtfunc Gt[V Ordered](field *V, v V) CondGt matches rows where field is greater than v., ant.Gtefunc Gte[V Ordered](field *V, v V) CondGte matches rows where field is greater than or equal to v.	greater than, or equal too
ant.Ltfunc Lt[V Ordered](field *V, v V) CondLt matches rows where field is less than v., ant.Ltefunc Lte[V Ordered](field *V, v V) CondLte matches rows where field is less than or equal to v.	less than, or equal too
ant.Between(&U.Age, 18, 65)func Between[V Ordered](field *V, low, high V) CondBetween matches rows where field is within low and high, inclusive.	in a range, ends included
ant.In(&U.Age, 18, 21)func In[V comparable](field *V, values ...V) CondIn matches rows where field equals one of values.	one of these
ant.NotIn(&U.Age, 18, 21)func NotIn[V comparable](field *V, values ...V) CondNotIn matches rows where field equals none of values.	none of these
ant.Like(&U.Name, "A%")func Like[V ~string](field *V, pattern V) CondLike matches rows where field matches a SQL LIKE pattern, in which % matches any text and _ matches one character.	matches a pattern
ant.ILike(&U.Name, "a%")func ILike[V ~string]( field *V, pattern V, ) CondILike is Like ignoring case.	the same, ignoring case
ant.IsNull(&U.Bio)func IsNull[V any](field *V) CondIsNull matches rows where field is NULL., ant.IsNotNullfunc IsNotNull[V any](field *V) CondIsNotNull matches rows where field is not NULL.	empty or not

Gt and the other orderings work on numbers, strings, and time.Time. A zero value is a real value here too: ant.Eq(&U.Age, 0) matches age zero.

Lists

In is variadic, so a slice spreads into it.

names := []string{"Alice", "Bob"}

users, err := db.Users.Where(ant.In(&U.Name, names...)).All(ctx)

An empty list

ant.In with no values matches nothing, and ant.NotIn with no values matches everything. Both are correct, and the second is exactly why a bulk write refuses a condition that can't exclude a row.

And, Or, Not

cond := ant.Or(
	ant.Lt(&U.Age, 18),
	ant.And(ant.Gt(&U.Age, 65), ant.Like(&U.Name, "A%")),
)

users, err := db.Users.Where(cond, ant.Not(ant.Eq(&U.Name, "Bob"))).All(ctx)

Grouping follows the nesting. An empty ant.And()func And(conds ...Cond) CondAnd matches rows where every condition matches. matches everything, and an empty ant.Or()func Or(conds ...Cond) CondOr matches rows where any condition matches. matches nothing.

Comparing two columns

EqCol compares columns, which is also how subqueries refer to the outer row. Both must have the same Go type.

sameDay, err := db.Users.Where(ant.EqCol(&U.CreatedAt, &U.UpdatedAt)).All(ctx)

One value, several columns

either := ant.AnyOf("Bob", &U.Name, &U.Email)   // Bob in any of them
both := ant.AllOf("Bob", &U.Name, &U.Email)     // Bob in all of them
neither := ant.NoneOf("Bob", &U.Name, &U.Email) // Bob in none of them

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

Several columns as one

InTuples matches pairs of values together, where In on each column separately would mix them up.

columns := []ant.FieldRef{ant.F(&U.Name), ant.F(&U.Age)}

users, err := db.Users.
	Where(ant.InTuples(columns, []any{"Alice", 30}, []any{"Bob", 17})).
	All(ctx)

Dates

These compare against the database's clock, so the results don't depend on your server's.

past := ant.Past(&U.CreatedAt)
future := ant.Future(&U.CreatedAt)
today := ant.Today(&U.CreatedAt)

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

ant.DatePart(&U.CreatedAt, "year")func DatePart(field *time.Time, part string) Expr[float64]DatePart extracts part of a date column, such as "year" or "month". reads part of a date as an expression, on PostgreSQL.

Conditions as values

A condition is an ordinary value, so you can give it a name and reuse it.

adults := ant.Gte(&U.Age, 18)

count, err := db.Users.Where(adults).Count(ctx)
users, err := db.Users.Where(adults).OrderBy(&U.Name).All(ctx)

See it tested: tests/features/querying