🥮 mooncakes.io
README

jaredzhou/foxql/builder does not have a README file

#
AnyColumn

source
pub trait AnyColumn {
  fn name(Self) -> String
  fn table_name(Self) -> String
  fn sql_type(Self) -> String
}

Trait that erases T — exposes column identity for heterogeneous column lists.

#
Comparable

source
pub trait Comparable {
  fn compare(Self) -> Unit
}

Trait for types that support comparison operators (gt, gte, lt, lte, between).
impl Comparable for Int

#
StringMatchable

source
pub trait StringMatchable {
  fn str_match(Self) -> Unit
}

Trait for types that support string operators (like, not_like).

#
Column

source
pub(all) struct Column[T] {
  name : String
  table : String
  sql_type : String
  _marker : T?
} derive(Eq, 
Debug)

A typed column reference in a specific table.
impl AnyColumn for Column[T]

#
Column::asc

source

Sort ascending.

#
Column::between

source

#
Column::desc

source

Sort descending.

#
Column::eq

source

#
Column::eq_col

source
fn[T] Column::eq_col(self : Column[T], other : Column[T]) -> 
Expr

Compare two columns for equality (for JOIN ON).

#
Column::eq_select

source

Compare column with a scalar subquery.

#
Column::gt

source

#
Column::gt_select

source

#
Column::gte

source

#
Column::gte_select

source

#
Column::in_

source

#
Column::in_select

source

#
Column::is_not_null

source
fn[T] Column::is_not_null(self : Column[T]) -> 
Expr

#
Column::is_null

source
fn[T] Column::is_null(self : Column[T]) -> 
Expr

#
Column::like

source
fn[T : StringMatchable] Column::like(self : Column[T], pattern : String) -> 
Expr

#
Column::lt

source

#
Column::lt_select

source

#
Column::lte

source

#
Column::lte_select

source

#
Column::neq

source

#
Column::neq_select

source

#
Column::new

source
fn[T] Column::new(name : String, table : String, sql_type : String) -> Column[T]

Create a new column reference.

#
Column::not_like

source
fn[T : StringMatchable] Column::not_like(self : Column[T], pattern : String) -> 
Expr

#
Column::to_ref

source

Produce a type-erased ColumnRef.

#
DeleteBuilder

source
pub(all) struct DeleteBuilder {
  table : Table
} derive(Eq, 
Debug)

A pending DELETE builder. Must call .where_() before .to_sql().

#
DeleteBuilder::new

source
fn DeleteBuilder::new(table : Table) -> DeleteBuilder

Create a new DeleteBuilder. Internal — users call table.delete().

#
DeleteBuilder::where_

source

Attach a WHERE clause. Promotes to DeleteReady.

#
DeleteReady

source
pub(all) struct DeleteReady {
  table : Table
  where_clause : 
Expr
  returning : Array[
ColumnRef]?
}

A complete DELETE builder with a WHERE clause. Terminal: .to_sql().

#
DeleteReady::returning

source
fn DeleteReady::returning(self : DeleteReady, cols : Array[&AnyColumn]) -> DeleteReady

Attach a RETURNING clause.

#
DeleteReady::to_sql

source

Render the query to a parameterised SQL string + args array.

#
DeleteReady::where_

source

Attach another WHERE condition, AND-ed with the existing one.

#
InsertBuilder

source

A fluent builder for an INSERT query. Terminal: .to_sql().

#
InsertBuilder::do_nothing

source
fn InsertBuilder::do_nothing(self : InsertBuilder) -> InsertBuilder

ON CONFLICT DO NOTHING.

#
InsertBuilder::do_update

source

ON CONFLICT DO UPDATE SET column = value.

#
InsertBuilder::new

source
fn InsertBuilder::new(table : Table, columns : Array[&AnyColumn]) -> InsertBuilder

Create a new InsertBuilder. Internal — users call table.insert(..) instead.

#
InsertBuilder::on_conflict

source
fn InsertBuilder::on_conflict(self : InsertBuilder, cols : Array[&AnyColumn]) -> InsertBuilder

Set the ON CONFLICT target column(s).

#
InsertBuilder::returning

source
fn InsertBuilder::returning(self : InsertBuilder, cols : Array[&AnyColumn]) -> InsertBuilder

Attach a RETURNING clause.

#
InsertBuilder::rows

source

Add a multi-row VALUES clause.

#
InsertBuilder::to_sql

source

Render the query to a parameterised SQL string + args array.

#
InsertBuilder::values

source

Add a single-row VALUES clause.

#
SelectBuilder

source

A fluent builder for a SELECT query. Terminal: .to_sql() or .build().

#
SelectBuilder::agg

source

Add an aggregate expression to the SELECT list.

#
SelectBuilder::build

source

Produce the AST node without rendering.

#
SelectBuilder::distinct

source
fn SelectBuilder::distinct(self : SelectBuilder) -> SelectBuilder

Add SELECT DISTINCT.

#
SelectBuilder::distinct_on

source
fn SelectBuilder::distinct_on(self : SelectBuilder, cols : Array[&AnyColumn]) -> SelectBuilder

Add SELECT DISTINCT ON (columns).

#
SelectBuilder::group_by

source
fn SelectBuilder::group_by(self : SelectBuilder, cols : Array[&AnyColumn]) -> SelectBuilder

Add a GROUP BY clause.

#
SelectBuilder::having

source

Attach a HAVING clause (must be after GROUP BY).

#
SelectBuilder::join

source

Add an INNER JOIN clause.

#
SelectBuilder::limit

source
fn SelectBuilder::limit(self : SelectBuilder, n : Int) -> SelectBuilder

Attach a LIMIT clause.

#
SelectBuilder::new

source

Create a new SelectBuilder. Internal — users call table.select(..) instead.

#
SelectBuilder::offset

source
fn SelectBuilder::offset(self : SelectBuilder, n : Int) -> SelectBuilder

Attach an OFFSET clause.

#
SelectBuilder::order_by

source

Add an ORDER BY clause. Chain multiple times for multiple columns.

#
SelectBuilder::to_sql

source

Render the query to a parameterised SQL string + args array.

#
SelectBuilder::where_

source

Attach a WHERE condition, AND-ed with any existing conditions. Call multiple times to build up filters from different layers.

#
Table

source
pub(all) struct Table {
  name : String
  schema_name : String?
} derive(Eq, 
Debug)

Table identity — name and optional schema.

#
Table::delete

source
fn Table::delete(self : Table) -> DeleteBuilder

Start building a DELETE query on this table. Requires .where_() before .to_sql().

#
Table::insert

source
fn Table::insert(self : Table, columns : Array[&AnyColumn]) -> InsertBuilder

Start building an INSERT query on this table.

#
Table::new

source
fn Table::new(name : String, schema? : String) -> Table

Create a table, optionally qualified with a schema.

#
Table::qualified_name

source
fn Table::qualified_name(self : Table) -> String

Return the fully-qualified table name for use in SQL (schema.name or name).

#
Table::select

source
fn Table::select(self : Table, columns? : Array[&AnyColumn]) -> SelectBuilder

Start building a SELECT query on this table. Omit columns for SELECT *.

#
Table::update

source
fn Table::update(self : Table) -> UpdateBuilder

Start building an UPDATE query on this table. Requires .where_() before .to_sql().

#
UpdateBuilder

source
pub(all) struct UpdateBuilder {
  table : Table
  set_clauses : Array[
SetClause]
}

A pending UPDATE builder. Must call .where_() before .to_sql().

#
UpdateBuilder::new

source
fn UpdateBuilder::new(table : Table) -> UpdateBuilder

Create a new UpdateBuilder. Internal — users call table.update().

#
UpdateBuilder::set

source

Add a SET clause. Column as &AnyColumn, value as &@moonpg.ToValue.

#
UpdateBuilder::where_

source

Attach a WHERE clause. Promotes to UpdateReady.

#
UpdateReady

source
pub(all) struct UpdateReady {
  table : Table
  set_clauses : Array[
SetClause]
  where_clause : 
Expr
  returning : Array[
ColumnRef]?
}

A complete UPDATE builder with a WHERE clause. Terminal: .to_sql().

#
UpdateReady::returning

source
fn UpdateReady::returning(self : UpdateReady, cols : Array[&AnyColumn]) -> UpdateReady

Attach a RETURNING clause.

#
UpdateReady::to_sql

source

Render the query to a parameterised SQL string + args array.

#
UpdateReady::where_

source

Attach another WHERE condition, AND-ed with the existing one.

#
avg

source

#
count

source

#
count_star

source

COUNT(*) — count all rows.

#
max

source

#
min

source

#
sum

source

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io