mooncakes.io

ast
→
builder
→
tosql
→
types
→
README
U
Aggregation
U
Column
U
ColumnRef
U
DeleteBuilder
U
DeleteReady
U
DeleteStmt
U
Expr
U
Filter
U
InsertBuilder
U
InsertStmt
U
OrderByClause
U
OrderDirection
U
SelectBuilder
U
SelectStmt
U
SqlType
U
Table
U
UpdateBuilder
U
UpdateReady
U
UpdateStmt
Tr
FieldResolver
Tr
ToSql
T
Schema
- ::loadSchema::load
- ::tableSchema::table
T
SchemaColumn
T
SchemaTable
- ::colSchemaTable::col
- ::deleteSchemaTable::delete
- ::has_columnSchemaTable::has_column
- ::insertSchemaTable::insert
- ::selectSchemaTable::select
- ::updateSchemaTable::update
V
avg
V
count
V
count_star
V
empty
V
max
V
min
V
not_
V
raw
V
sum

README

jaredzhou/foxql/ast does not have a README file

#
Aggregation

pub(all) enum Aggregation {
  Count(ColumnRef?)
  Sum(ColumnRef)
  Avg(ColumnRef)
  Min(ColumnRef)
  Max(ColumnRef)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

An aggregation function call.

#
Aggregation::eq

source

fn[T : @jaredzhou/moonpg.ToValue
ToValue + @moonbitlang/core/debug.Debug
Debug] Aggregation::eq(self : Aggregation, value : T) -> Expr

#
Aggregation::gt

source

fn[T : @jaredzhou/moonpg.ToValue
ToValue + @moonbitlang/core/debug.Debug
Debug] Aggregation::gt(self : Aggregation, value : T) -> Expr

#
Aggregation::gte

source

fn[T : @jaredzhou/moonpg.ToValue
ToValue + @moonbitlang/core/debug.Debug
Debug] Aggregation::gte(self : Aggregation, value : T) -> Expr

#
Aggregation::lt

source

fn[T : @jaredzhou/moonpg.ToValue
ToValue + @moonbitlang/core/debug.Debug
Debug] Aggregation::lt(self : Aggregation, value : T) -> Expr

#
Aggregation::lte

source

fn[T : @jaredzhou/moonpg.ToValue
ToValue + @moonbitlang/core/debug.Debug
Debug] Aggregation::lte(self : Aggregation, value : T) -> Expr

#
Aggregation::neq

source

fn[T : @jaredzhou/moonpg.ToValue
ToValue + @moonbitlang/core/debug.Debug
Debug] Aggregation::neq(self : Aggregation, value : T) -> Expr

#
ColumnRef

source

pub(all) struct ColumnRef {
  name : String
  table : String
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Identifies a column by (table, name).

#
ColumnRef::eq

source

fn ColumnRef::eq(self : ColumnRef, value : &@jaredzhou/moonpg.ToValue
ToValue) -> Expr

Compare with a value (for dynamic ColumnRefs).

#
ColumnRef::gt

source

fn ColumnRef::gt(self : ColumnRef, value : &@jaredzhou/moonpg.ToValue
ToValue) -> Expr

#
ColumnRef::gte

source

fn ColumnRef::gte(self : ColumnRef, value : &@jaredzhou/moonpg.ToValue
ToValue) -> Expr

#
ColumnRef::lt

source

fn ColumnRef::lt(self : ColumnRef, value : &@jaredzhou/moonpg.ToValue
ToValue) -> Expr

#
ColumnRef::lte

source

fn ColumnRef::lte(self : ColumnRef, value : &@jaredzhou/moonpg.ToValue
ToValue) -> Expr

#
ColumnRef::neq

source

fn ColumnRef::neq(self : ColumnRef, value : &@jaredzhou/moonpg.ToValue
ToValue) -> Expr

#
DeleteStmt

source

pub(all) struct DeleteStmt {
  table : String
  where_clause : Expr
  returning : Array[ColumnRef]?
}

A DELETE statement. where_clause is non-optional.

#
Expr

source

#alias(Filter)
pub(all) enum Expr {
  Empty
  Compare(ColumnRef, Operator, &@jaredzhou/moonpg.ToValue
ToValue)
  CompareCols(ColumnRef, Operator, ColumnRef)
  And(Array[Expr])
  Or(Array[Expr])
  Not(Expr)
  InList(ColumnRef, Array[&@jaredzhou/moonpg.ToValue
ToValue])
  InSelect(ColumnRef, SelectStmt)
  Between(ColumnRef, &@jaredzhou/moonpg.ToValue
ToValue, &@jaredzhou/moonpg.ToValue
ToValue)
  IsNull(ColumnRef)
  IsNotNull(ColumnRef)
  AggCompare(Aggregation, Operator, &@jaredzhou/moonpg.ToValue
ToValue)
  CompareSelect(ColumnRef, Operator, SelectStmt)
  Raw(String, Array[&@jaredzhou/moonpg.ToValue
ToValue])
}

A WHERE clause expression — a tree of comparisons joined by AND / OR / NOT. Values are stored as &@moonpg.ToValue trait objects, allowing any moonpg-compatible type to be bound as a parameter without going through a foxql Value enum.

#
Expr::and_

source

fn Expr::and_(self : Expr, other : Expr) -> Expr

Combine two expressions with AND. Flattens nested And for cleaner SQL. Empty is the identity: Empty.and_(x) → x, x.and_(Empty) → x.

#
Expr::or_

source

fn Expr::or_(self : Expr, other : Expr) -> Expr

Combine two expressions with OR. Flattens nested Or for cleaner SQL. Empty is the identity: Empty.or_(x) → x, x.or_(Empty) → x.

#
InsertStmt

source

pub(all) struct InsertStmt {
  table : String
  columns : Array[ColumnRef]
  values : Array[Array[&@jaredzhou/moonpg.ToValue
ToValue]]
  on_conflict : OnConflict?
  returning : Array[ColumnRef]?
}

An INSERT statement.

#
JoinClause

source

pub(all) struct JoinClause {
  table : String
  on : Expr
}

An INNER JOIN clause.

#
OnConflict

source

pub(all) enum OnConflict {
  DoNothing(String)
  DoUpdate(String, Array[SetClause])
}

#
Operator

source

pub(all) enum Operator {
  Eq
  Neq
  Gt
  Gte
  Lt
  Lte
  Like
  NotLike
  In
  Between
  IsNull
  IsNotNull
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

#
Operator::to_sql_op

source

fn Operator::to_sql_op(self : Operator) -> String

Render the operator as its SQL keyword / symbol.

#
OrderByClause

source

pub(all) struct OrderByClause {
  column : ColumnRef
  direction : OrderDirection
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

#
OrderDirection

source

pub(all) enum OrderDirection {
  Asc
  Desc
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ORDER BY direction.

#
SelectExpr

source

pub(all) enum SelectExpr {
  Col(ColumnRef)
  Agg(Aggregation)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

An item in the SELECT list — either a column reference or an aggregate call.

#
SelectStmt

source

pub(all) struct SelectStmt {
  table : String
  columns : Array[SelectExpr]
  where_clause : Expr?
  joins : Array[JoinClause]
  group_by : Array[ColumnRef]
  having : Expr?
  order_by : Array[OrderByClause]
  limit : Int?
  offset : Int?
  distinct : Bool
  distinct_on : Array[ColumnRef]
}

A SELECT statement.

#
SetClause

source

pub(all) struct SetClause {
  column : ColumnRef
  value : &@jaredzhou/moonpg.ToValue
ToValue
}

#
UpdateStmt

source

pub(all) struct UpdateStmt {
  table : String
  set_clauses : Array[SetClause]
  where_clause : Expr
  returning : Array[ColumnRef]?
}

An UPDATE statement. where_clause is non-optional.

#
empty

source

fn empty() -> Expr

The empty filter — identity element for AND/OR. Use as a starting point when building filters from many optional conditions.

#
not_

source

fn not_(expr : Expr) -> Expr

Wrap an expression with NOT. not_(Empty) → Empty.

Source Files

Site source Report issue Packages Build queue Skills Statistics

#Aggregation

#Aggregation::eq

#Aggregation::gt

#Aggregation::gte

#Aggregation::lt

#Aggregation::lte

#Aggregation::neq

#ColumnRef

#ColumnRef::eq

#ColumnRef::gt

#ColumnRef::gte

#ColumnRef::lt

#ColumnRef::lte

#ColumnRef::neq

#DeleteStmt

#Expr

#Expr::and_

#Expr::or_

#InsertStmt

#JoinClause

#OnConflict

#Operator

#Operator::to_sql_op

#OrderByClause

#OrderDirection

#SelectExpr

#SelectStmt

#SetClause

#UpdateStmt

#empty

#not_

Source Files

#
Aggregation

#
Aggregation::eq

#
Aggregation::gt

#
Aggregation::gte

#
Aggregation::lt

#
Aggregation::lte

#
Aggregation::neq

#
ColumnRef

#
ColumnRef::eq

#
ColumnRef::gt

#
ColumnRef::gte

#
ColumnRef::lt

#
ColumnRef::lte

#
ColumnRef::neq

#
DeleteStmt

#
Expr

#
Expr::and_

#
Expr::or_

#
InsertStmt

#
JoinClause

#
OnConflict

#
Operator

#
Operator::to_sql_op

#
OrderByClause

#
OrderDirection

#
SelectExpr

#
SelectStmt

#
SetClause

#
UpdateStmt

#
empty

#
not_