Extract the underlying AST condition.

Create a simple join condition comparing columns from two different tables. This is a convenience wrapper around typed_eq_columns for join conditions.

Example

typed_from(users)
|> typed_join(posts, on: on(user_id, post_user_id))

Create a join condition with an additional condition. The primary comparison is ANDed with the additional condition.

Example

typed_from(users)
|> typed_join(posts, on: on_and(
    user_id, post_user_id,
    typed_eq(in_join2_right(post_published), True)
  ))

Create a join condition with multiple additional conditions.

Example

on_and_all(user_id, post_user_id, [
  typed_eq(in_join2_right(post_published), True),
  typed_gt(in_join2_right(post_views), 100),
])

Extract the underlying AST query for adapter use. This is used when passing the query to the adapter layer.

Combine conditions with AND

Create a BETWEEN condition: column BETWEEN low AND high

Create a condition comparing two columns. Both columns must belong to the same table scope. Useful for join conditions.

Example

typed_column_eq(in_join2_right(user_id), in_join2_left(id))

Create a condition comparing two columns with greater-than.

Create a condition comparing two columns with greater-than-or-equal.

Create a condition comparing two columns with less-than.

Create a condition comparing two columns with less-than-or-equal.

Create a condition comparing two columns for inequality.

Create a contains condition: column LIKE ‘%substring%’ Convenience wrapper that generates the LIKE pattern automatically. Only works with String columns.

Example

typed_contains(description, "important")  // LIKE '%important%'

Add a CROSS JOIN to the query. Cross joins produce a Cartesian product and don’t require a condition.

Example

typed_from(sizes)
|> typed_cross_join(colors)
// Produces all size/color combinations

Add a CROSS JOIN with an aliased table.

Add DISTINCT to the query.

Create an ends_with condition: column LIKE ‘%suffix’ Convenience wrapper that generates the LIKE pattern automatically. Only works with String columns.

Example

typed_ends_with(email, "@example.com")  // LIKE '%@example.com'

Create an equality condition: column = value The column’s value type must match the value being compared.

Example

typed_eq(email, "test@example.com")  // Column(UserTable, String) = String
typed_eq(id, 42)                      // Column(UserTable, Int) = Int

Create an equality condition comparing columns from two different tables. Returns a condition with Join2 scope, suitable for join conditions. Both columns must have the same value type.

Example

// In a join between users and posts tables:
typed_eq_columns(posts_user_id, users_id)
// Returns: TypedCondition(Join2(PostTable, UserTable))

Create a new typed query from a Table. This is the primary entry point for building type-safe queries.

Example

let query = typed_from(users)

Add a FULL JOIN to the query.

Get the LIMIT value.

Get the OFFSET value.

Add a GROUP BY column.

Add a raw SQL GROUP BY expression. WARNING: Raw SQL bypasses compile-time type checking.

Example

typed_from(orders)
|> typed_group_by_raw(raw.date_trunc("month", created_at))

Create a greater-than condition: column > value

Create a greater-than condition comparing columns from two different tables. Returns a condition with Join2 scope.

Create a greater-than-or-equal condition: column >= value

Create a greater-than-or-equal condition comparing columns from two different tables. Returns a condition with Join2 scope.

Check if the query has any WHERE conditions.

Check if the query has any ORDER BY clauses.

Check if the query has pagination.

Add a HAVING condition.

Add a raw SQL HAVING condition. WARNING: Raw SQL bypasses compile-time type checking.

Example

typed_from(orders)
|> typed_group_by(user_id)
|> typed_having_raw(raw.raw("COUNT(*) > 5"))

Create a case-insensitive LIKE condition: column ILIKE pattern Only works with String columns.

Example

typed_ilike(email, "%@EXAMPLE.COM")  // Matches case-insensitively

Create an IN condition: column IN (values…)

Check if the query is DISTINCT.

Create an IS NOT NULL condition. Only works with Option columns.

Create an IS NULL condition. Only works with Option columns.

Add an INNER JOIN to the query, returning a query with joined table types. The resulting query can use columns from both tables.

Example

typed_from(users)
|> typed_join(posts, on: typed_column_eq(user_id, id))
// Now the query type is TypedQuery(Join2(UserTable, PostTable))

Add a third table to a joined query.

Add an INNER JOIN with an aliased table. Useful for self-joins where the same table needs different aliases.

Example

let managers = alias_table(employees, "m")

typed_from(employees)
|> typed_join_aliased(managers, on: join_condition)

Add a LEFT JOIN to the query.

Add a LEFT JOIN with an aliased table.

Create a LIKE condition: column LIKE pattern Only works with String columns.

Set the LIMIT for the query.

Create a less-than condition: column < value

Create a less-than condition comparing columns from two different tables. Returns a condition with Join2 scope.

Create a less-than-or-equal condition: column <= value

Create a less-than-or-equal condition comparing columns from two different tables. Returns a condition with Join2 scope.

Remove LIMIT and OFFSET.

Negate a condition

Create a not-equal condition: column != value

Create a not-equal condition comparing columns from two different tables. Returns a condition with Join2 scope.

Create a NOT ILIKE condition: column NOT ILIKE pattern

Create a NOT IN condition: column NOT IN (values…)

Create a NOT LIKE condition: column NOT LIKE pattern

Set the OFFSET for the query.

Combine conditions with OR

Add an OR condition to the query.

Add an ORDER BY clause with explicit direction and null ordering.

Add an ORDER BY ASC clause.

Clear all ORDER BY clauses.

Add an ORDER BY DESC clause.

Add a raw SQL ORDER BY clause. WARNING: Raw SQL bypasses compile-time type checking.

Example

typed_from(users)
|> typed_order_by_raw(raw.random(), ast.Asc)  // Random order

Set both LIMIT and OFFSET for pagination.

Create a raw typed condition for use in typed_where. This allows mixing typed and raw conditions.

Example

typed_from(users)
|> typed_where(typed_eq(active, True))
|> typed_where(typed_raw_condition(raw("created_at > NOW() - INTERVAL '7 days'")))

Add a RIGHT JOIN to the query.

Add a RIGHT JOIN with an aliased table.

Select specific columns. The columns must belong to the query’s table type.

Example

typed_from(users)
|> typed_select([id, email, name])

Select all columns (SELECT *).

Select columns by name. Use this when you need to select columns with different value types.

Example

typed_from(users)
|> typed_select_by_names(["id", "email", "name"])

Add raw SQL expressions to the SELECT clause. WARNING: Raw SQL bypasses compile-time type checking.

Example

typed_from(users)
|> typed_select_raw([
    raw.count_over_with_alias("total"),
    raw.raw("EXTRACT(year FROM created_at) AS year"),
  ])

Add raw SQL expressions to the SELECT clause with aliases. WARNING: Raw SQL bypasses compile-time type checking.

Example

typed_from(users)
|> typed_select_raw_aliased([
    #(raw.count_all(), "total_count"),
    #(raw.now(), "query_time"),
  ])

Create a starts_with condition: column LIKE ‘prefix%’ Convenience wrapper that generates the LIKE pattern automatically. Only works with String columns.

Example

typed_starts_with(name, "John")  // LIKE 'John%'

Add a WHERE condition to the query. The condition must be for the same table type as the query.

Example

typed_from(users)
|> typed_where(typed_eq(email, "test@example.com"))

Clear all WHERE conditions.

Add a raw SQL WHERE condition to the query. WARNING: Raw SQL bypasses compile-time type checking.

Example

typed_from(users)
|> typed_where_raw(raw("created_at > NOW() - INTERVAL '7 days'"))