cquill/typed/raw · cquill

add

pub fn add(left: RawExpr, right: RawExpr) -> RawExpr

Add two raw expressions.

age_from_now

</>

pub fn age_from_now(column: table.Column(t, a)) -> RawExpr

AGE - Calculate age between timestamps.

Example

age_from_now(birth_date)  // AGE(birth_date)

and_raw

</>

pub fn and_raw(conditions: List(RawExpr)) -> RawExpr

AND multiple raw conditions.

avg

</>

pub fn avg(column: table.Column(t, a)) -> RawExpr

AVG(column) - Average values in a column.

case_when

</>

pub fn case_when(
  conditions: List(#(RawExpr, RawExpr)),
  else_expr: RawExpr,
) -> RawExpr

Generate a CASE expression.

Example

case_when([
  #(raw("status = 'active'"), raw("'Active'")),
  #(raw("status = 'pending'"), raw("'Pending'")),
], raw("'Unknown'"))

cast

</>

pub fn cast(expr: RawExpr, to_type: String) -> RawExpr

CAST - Cast an expression to a different type.

Example

cast(raw("'123'"), "INTEGER")  // CAST('123' AS INTEGER)
cast(raw("created_at"), "DATE")  // CAST(created_at AS DATE)

cast_column

</>

pub fn cast_column(
  column: table.Column(t, a),
  to_type: String,
) -> RawExpr

CAST a column to a different type.

coalesce_column

</>

pub fn coalesce_column(
  column: table.Column(t, option.Option(String)),
  default: String,
) -> RawExpr

COALESCE - Return first non-null value. Uses column name for type safety reference.

Example

coalesce_column(user_nickname, "Anonymous")
// COALESCE(nickname, 'Anonymous')

coalesce_int_column

</>

pub fn coalesce_int_column(
  column: table.Column(t, option.Option(Int)),
  default: Int,
) -> RawExpr

COALESCE for integer columns.

coalesce_raw

</>

pub fn coalesce_raw(expressions: List(RawExpr)) -> RawExpr

COALESCE with raw expressions.

Example

coalesce_raw([raw("nickname"), raw("'Anonymous'")])

column_expr

</>

pub fn column_expr(column: table.Column(t, a)) -> RawExpr

Create a raw expression from a column name.

column_raw_between

</>

pub fn column_raw_between(
  column: table.Column(t, a),
  low: RawExpr,
  high: RawExpr,
) -> RawExpr

Column between two raw expressions.

column_raw_eq

</>

pub fn column_raw_eq(
  column: table.Column(t, a),
  expr: RawExpr,
) -> RawExpr

Create a raw comparison between a column and a raw expression.

Example

column_raw_eq(created_at, now())
// created_at = NOW()

column_raw_gt

</>

pub fn column_raw_gt(
  column: table.Column(t, a),
  expr: RawExpr,
) -> RawExpr

Column greater than raw expression.

column_raw_gte

</>

pub fn column_raw_gte(
  column: table.Column(t, a),
  expr: RawExpr,
) -> RawExpr

Column greater than or equal to raw expression.

column_raw_lt

</>

pub fn column_raw_lt(
  column: table.Column(t, a),
  expr: RawExpr,
) -> RawExpr

Column less than raw expression.

column_raw_lte

</>

pub fn column_raw_lte(
  column: table.Column(t, a),
  expr: RawExpr,
) -> RawExpr

Column less than or equal to raw expression.

concat

</>

pub fn concat(expressions: List(RawExpr)) -> RawExpr

CONCAT - Concatenate multiple expressions.

Example

concat([raw("first_name"), raw("' '"), raw("last_name")])

concat_columns_with_separator

</>

pub fn concat_columns_with_separator(
  columns: List(table.Column(t, String)),
  separator: String,
) -> RawExpr

Concatenate columns with a separator.

Example

concat_columns_with_separator([first_name, last_name], " ")
// first_name || ' ' || last_name

count_all

</>

pub fn count_all() -> RawExpr

COUNT(*) - Count all rows.

count_column

</>

pub fn count_column(column: table.Column(t, a)) -> RawExpr

COUNT(column) - Count non-null values in a column.

count_distinct

</>

pub fn count_distinct(column: table.Column(t, a)) -> RawExpr

COUNT(DISTINCT column) - Count distinct non-null values.

count_over

</>

pub fn count_over() -> RawExpr

COUNT(*) OVER () - Window function for total count. Useful for pagination to get total count alongside results.

Example

select_raw(query, [count_over_with_alias("total_count")])

count_over_with_alias

</>

pub fn count_over_with_alias(alias: String) -> RawExpr

COUNT(*) OVER () with an alias.

current_date

</>

pub fn current_date() -> RawExpr

CURRENT_DATE - Current date without time

current_time

</>

pub fn current_time() -> RawExpr

CURRENT_TIME - Current time without date

current_timestamp

</>

pub fn current_timestamp() -> RawExpr

CURRENT_TIMESTAMP - Current timestamp (alternative to NOW())

date_trunc

</>

pub fn date_trunc(
  precision: String,
  column: table.Column(t, a),
) -> RawExpr

DATE_TRUNC - Truncate timestamp to specified precision.

Example

date_trunc("month", created_at)  // DATE_TRUNC('month', created_at)

divide

</>

pub fn divide(left: RawExpr, right: RawExpr) -> RawExpr

Divide left by right.

exists

</>

pub fn exists(subquery: RawExpr) -> RawExpr

EXISTS subquery check.

Example

exists(raw("SELECT 1 FROM orders WHERE orders.user_id = users.id"))

extract

</>

pub fn extract(
  field: String,
  column: table.Column(t, a),
) -> RawExpr

EXTRACT(field FROM column) - Extract part of a timestamp.

Example

extract("year", created_at)   // EXTRACT(year FROM created_at)
extract("month", created_at)  // EXTRACT(month FROM created_at)

false_literal

</>

pub fn false_literal() -> RawExpr

Create a raw expression for boolean FALSE.

float_literal

</>

pub fn float_literal(value: Float) -> RawExpr

Create a raw expression from a literal float.

in_subquery

</>

pub fn in_subquery(
  column: table.Column(t, a),
  subquery: RawExpr,
) -> RawExpr

IN with a subquery.

Example

in_subquery(user_id, raw("SELECT id FROM active_users"))

int_literal

</>

pub fn int_literal(value: Int) -> RawExpr

Create a raw expression from a literal integer.

interval

</>

pub fn interval(amount: Int, unit: String) -> RawExpr

Generate an INTERVAL expression.

Example

interval(7, "days")   // INTERVAL '7 days'
interval(1, "hour")   // INTERVAL '1 hour'
interval(30, "minutes")  // INTERVAL '30 minutes'

length

</>

pub fn length(column: table.Column(t, String)) -> RawExpr

LENGTH(column) - String length.

lower

</>

pub fn lower(column: table.Column(t, String)) -> RawExpr

LOWER(column) - Lowercase string.

max

</>

pub fn max(column: table.Column(t, a)) -> RawExpr

MAX(column) - Maximum value in a column.

min

</>

pub fn min(column: table.Column(t, a)) -> RawExpr

MIN(column) - Minimum value in a column.

modulo

</>

pub fn modulo(left: RawExpr, right: RawExpr) -> RawExpr

Modulo operation.

multiply

</>

pub fn multiply(left: RawExpr, right: RawExpr) -> RawExpr

Multiply two expressions.

not_exists

</>

pub fn not_exists(subquery: RawExpr) -> RawExpr

NOT EXISTS subquery check.

not_in_subquery

</>

pub fn not_in_subquery(
  column: table.Column(t, a),
  subquery: RawExpr,
) -> RawExpr

NOT IN with a subquery.

not_raw

</>

pub fn not_raw(condition: RawExpr) -> RawExpr

NOT a raw condition.

now

</>

pub fn now() -> RawExpr

NOW() - Current timestamp

Example

select_raw(query, [now()])
where_raw(query, raw_with_params("created_at > $1 - $2", [
  now_as_value(),
  interval(7, "days"),
]))

null_literal

</>

pub fn null_literal() -> RawExpr

Create a raw expression for NULL.

nullif_column

</>

pub fn nullif_column(
  column: table.Column(t, String),
  value: String,
) -> RawExpr

NULLIF - Return NULL if two expressions are equal.

Example

nullif_column(status, "deleted")
// NULLIF(status, 'deleted')

or_raw

</>

pub fn or_raw(conditions: List(RawExpr)) -> RawExpr

OR multiple raw conditions.

random

</>

pub fn random() -> RawExpr

RANDOM() - Generate a random value (useful for random ordering).

Example

order_by_raw(query, random(), Asc)  // Random order

raw

</>

pub fn raw(sql: String) -> RawExpr

Create a raw SQL expression without parameters.

WARNING: This bypasses type safety. Use for database functions and expressions that don’t accept user input.

Example

raw("NOW()")
raw("RANDOM()")

raw_params

</>

pub fn raw_params(expr: RawExpr) -> List(ast.Value)

Extract the parameters from a RawExpr.

raw_sql

</>

pub fn raw_sql(expr: RawExpr) -> String

Extract the SQL string from a RawExpr.

raw_to_condition

</>

pub fn raw_to_condition(expr: RawExpr) -> ast.Condition

Convert a RawExpr to an AST Condition for use in WHERE clauses.

raw_to_order_by

</>

pub fn raw_to_order_by(
  expr: RawExpr,
  direction: ast.Direction,
) -> ast.OrderBy

Convert a RawExpr to an AST OrderBy for use in ORDER BY clauses.

raw_to_select_expr

</>

pub fn raw_to_select_expr(
  expr: RawExpr,
  alias: option.Option(String),
) -> ast.SelectExpression

Convert a RawExpr to an AST SelectExpression for use in SELECT clauses.

raw_with_params

</>

pub fn raw_with_params(
  sql: String,
  params: List(ast.Value),
) -> RawExpr

Create a raw SQL expression with parameters. Always prefer this over string concatenation to prevent SQL injection.

Example

raw_with_params("email = $1", [StringValue(user_input)])
raw_with_params("created_at > $1 AND status = $2", [
  StringValue("2024-01-01"),
  StringValue("active"),
])

row_number_over

</>

pub fn row_number_over(
  column: table.Column(t, a),
  direction: ast.Direction,
) -> RawExpr

ROW_NUMBER() OVER (ORDER BY column).

string_literal

</>

pub fn string_literal(value: String) -> RawExpr

Create a raw expression from a literal string. The string is properly escaped and quoted.

subtract

</>

pub fn subtract(left: RawExpr, right: RawExpr) -> RawExpr

Subtract right from left.

sum

</>

pub fn sum(column: table.Column(t, a)) -> RawExpr

SUM(column) - Sum values in a column.

trim

</>

pub fn trim(column: table.Column(t, String)) -> RawExpr

TRIM(column) - Remove leading/trailing whitespace.

true_literal

</>

pub fn true_literal() -> RawExpr

Create a raw expression for boolean TRUE.

upper

</>

pub fn upper(column: table.Column(t, String)) -> RawExpr

UPPER(column) - Uppercase string.