🥮 mooncakes.io
    Sign in

    jaredzhou/foxql/ast does not have a README file

    ToValue

    source
    pub trait ToValue {
      fn to_value(Self) -> Value
    }

    Convert a MoonBit native type into a parameterised Value.
    impl ToValue for Bool
    impl ToValue for Int
    impl ToValue for Double
    impl ToValue for String

    Aggregation

    source
    pub(all) enum Aggregation {
      Count(ColumnRef?)
      Sum(ColumnRef)
      Avg(ColumnRef)
      Min(ColumnRef)
      Max(ColumnRef)
    } derive(Eq, 
    Debug    )

    An aggregation function call.

    Aggregation::eq

    source
    fn[T : ToValue] Aggregation::eq(self : Aggregation, value : T) -> Expr

    Aggregation::gt

    source
    fn[T : ToValue] Aggregation::gt(self : Aggregation, value : T) -> Expr

    Aggregation::gte

    source
    fn[T : ToValue] Aggregation::gte(self : Aggregation, value : T) -> Expr

    Aggregation::lt

    source
    fn[T : ToValue] Aggregation::lt(self : Aggregation, value : T) -> Expr

    Aggregation::lte

    source
    fn[T : ToValue] Aggregation::lte(self : Aggregation, value : T) -> Expr

    Aggregation::neq

    source
    fn[T : ToValue] Aggregation::neq(self : Aggregation, value : T) -> Expr

    ColumnRef

    source
    pub(all) struct ColumnRef {
      name : String
      table : String
    } derive(Eq, 
    Debug    )

    Identifies a column by (table, name).

    ColumnRef::eq

    source
    fn ColumnRef::eq(self : ColumnRef, value : &ToValue) -> Expr

    Compare with a value (for dynamic ColumnRefs).

    ColumnRef::gt

    source
    fn ColumnRef::gt(self : ColumnRef, value : &ToValue) -> Expr

    ColumnRef::gte

    source
    fn ColumnRef::gte(self : ColumnRef, value : &ToValue) -> Expr

    ColumnRef::lt

    source
    fn ColumnRef::lt(self : ColumnRef, value : &ToValue) -> Expr

    ColumnRef::lte

    source
    fn ColumnRef::lte(self : ColumnRef, value : &ToValue) -> Expr

    ColumnRef::neq

    source
    fn ColumnRef::neq(self : ColumnRef, value : &ToValue) -> Expr

    DeleteStmt

    source
    pub(all) struct DeleteStmt {
      table : String
      where_clause : Expr
      returning : Array[ColumnRef]?
    } derive(Eq, 
    Debug    )

    A DELETE statement. where_clause is non-optional.

    Expr

    source
    pub(all) enum Expr {
      Compare(ColumnRef, Operator, Value)
      CompareCols(ColumnRef, Operator, ColumnRef)
      And(Array[Expr])
      Or(Array[Expr])
      Not(Expr)
      InList(ColumnRef, Array[Value])
      InSelect(ColumnRef, SelectStmt)
      Between(ColumnRef, Value, Value)
      IsNull(ColumnRef)
      IsNotNull(ColumnRef)
      AggCompare(Aggregation, Operator, Value)
      CompareSelect(ColumnRef, Operator, SelectStmt)
    } derive(Eq, 
    Debug    )

    A WHERE clause expression — a tree of comparisons joined by AND / OR / NOT.

    Expr::and_

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

    Combine two expressions with AND. Flattens nested And for cleaner SQL.

    Expr::or_

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

    Combine two expressions with OR. Flattens nested Or for cleaner SQL.

    InsertStmt

    source
    pub(all) struct InsertStmt {
      table : String
      columns : Array[ColumnRef]
      values : Array[Array[Value]]
      on_conflict : OnConflict?
      returning : Array[ColumnRef]?
    } derive(Eq, 
    Debug    )

    An INSERT statement (placeholder — wired in a later ticket).

    JoinClause

    source
    pub(all) struct JoinClause {
      table : String
      on : Expr
    } derive(Eq, 
    Debug    )

    An INNER JOIN clause.

    OnConflict

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

    Operator

    source
    pub(all) enum Operator {
      Eq
      Neq
      Gt
      Gte
      Lt
      Lte
      Like
      NotLike
      In
      Between
      IsNull
      IsNotNull
    } derive(Eq, 
    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, 
    Debug    )

    OrderDirection

    source
    pub(all) enum OrderDirection {
      Asc
      Desc
    } derive(Eq, 
    Debug    )

    ORDER BY direction.

    SelectExpr

    source
    pub(all) enum SelectExpr {
      Col(ColumnRef)
      Agg(Aggregation)
    } derive(Eq, 
    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]
    } derive(Eq, 
    Debug    )

    A SELECT statement.

    SetClause

    source
    pub(all) struct SetClause {
      column : ColumnRef
      value : Value
    } derive(Eq, 
    Debug    )

    SqlType

    source
    pub(all) enum SqlType {
      Integer
      BigInt
      Text
      Boolean
      DoublePrecision
      Bytea
      TimestampTz
      Numeric
      Jsonb
    } derive(Eq, 
    Debug    )

    PostgreSQL column types.

    UpdateStmt

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

    An UPDATE statement. where_clause is non-optional.

    Value

    source
    pub(all) enum Value {
      Null
      Bool(Bool)
      Int(Int)
      Float(Double)
      String(String)
    } derive(Eq, 
    Debug    )

    A runtime parameterised value — each variant maps to a PG type.
    impl ToValue for Value

    not_

    source
    fn not_(expr : Expr) -> Expr

    Wrap an expression with NOT.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io