Allianaab2m/aya/gen - mooncakes.io

README
U
Row
Tr
Driver
Tr
Executor
Tr
SqlDecode
Tr
SqlEncode
Tr
SqlNum
Tr
SqlOrd
E
DbError
E
DecodeError
E
StatementError
T
BinOp
- ::contramapBinding::contramap
- ::newBinding::new
- ::withoutBinding::without
- ::ascColumn::asc
- ::descColumn::desc
- ::eqColumn::eq
- ::eq_colColumn::eq_col
- ::exprColumn::expr
- ::gtColumn::gt
- ::gteColumn::gte
- ::in_Column::in_
- ::is_noneColumn::is_none
- ::is_someColumn::is_some
- ::ltColumn::lt
- ::lteColumn::lte
- ::neColumn::ne
- ::newColumn::new
- ::nullableColumn::nullable
- ::rawColumn::raw
- ::filterDelete::filter
- ::runDelete::run
- ::to_sqlDelete::to_sql
T
Dialect
T
Dir
- ::exprEmitter::expr
- ::newEmitter::new
- ::ascExpr::asc
- ::descExpr::desc
- ::eqExpr::eq
- ::eq_colExpr::eq_col
- ::gtExpr::gt
- ::gteExpr::gte
- ::in_Expr::in_
- ::is_noneExpr::is_none
- ::is_someExpr::is_some
- ::ltExpr::lt
- ::lteExpr::lte
- ::neExpr::ne
- ::rawExpr::raw
- ::runInsert::run
- ::to_sqlInsert::to_sql
T
Join
T
JoinKind
- ::colNullable::col
- ::rowNullable::row
T
OrderKey
- ::filterQuery::filter
- ::firstQuery::first
- ::group_byQuery::group_by
- ::joinQuery::join
- ::left_joinQuery::left_join
- ::limitQuery::limit
- ::mapQuery::map
- ::map_colsQuery::map_cols
- ::oneQuery::one
- ::order_byQuery::order_by
- ::reduceQuery::reduce
- ::runQuery::run
- ::to_sqlQuery::to_sql
T
RawExpr
- ::mapReducer::map
- ::zipReducer::zip
- ::into2Selection::into2
- ::into3Selection::into3
- ::mapSelection::map
- ::newSelection::new
- ::optionalSelection::optional
- ::optional_onSelection::optional_on
- ::zipSelection::zip
T
SqlValue
- ::newTable::new
- ::driverTx::driver
- ::is_openTx::is_open
- ::newTx::new
- ::filterUpdate::filter
- ::runUpdate::run
- ::setUpdate::set
- ::to_sqlUpdate::to_sql
V
avg
V
count
V
count_of
V
delete
V
delete_all
V
from
V
insert
V
insert_except
V
insert_many
V
max
V
min
V
sel
V
sel2
V
sel3
V
split2
V
sum
V
transaction
V
update
V
update_all

Allianaab2m/aya/gen does not have a README file

AttrError

pub(all) suberror AttrError {
  Malformed(raw~ : String, reason~ : String)
} derive(@moonbitlang/core/debug.Debug
Debug)

EntityError

source

pub(all) suberror EntityError {
  NotARecord(type_name~ : String)
  MissingTable(type_name~ : String)
  DuplicatePrimaryKey(type_name~ : String)
  InvalidArg(type_name~ : String, key~ : String, value~ : String)
  UnknownIndexColumn(type_name~ : String, column~ : String)
  EmptyIndex(type_name~ : String)
  ReservedArg(type_name~ : String, key~ : String, use_instead~ : String)
} derive(@moonbitlang/core/debug.Debug
Debug)

impl Show for EntityError

GenError

source

pub(all) suberror GenError {
  ParseFailed(name~ : String, diagnostics~ : Int)
} derive(@moonbitlang/core/debug.Debug
Debug)

Attr

source

pub struct Attr {
  name : String
  args : Map[String, String]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A #aya.* attribute recovered from source text.

moonbitlang/parser hands us attributes with raw filled in but parsed left as None for user-defined namespaces, so we read raw ourselves. Attribute::name() drops the namespace (#aya.id and #morm.id both report "id"), which is not good enough to tell our attributes apart.

Attr::arg

source

fn Attr::arg(self : Attr, key : String) -> String?

Look up an optional string argument.

EntitySpec

source

pub struct EntitySpec {
  type_name : String
  table : String
  tbl : String
  cols_name : String
  fields : Array[FieldSpec]
  indexes : Array[IndexSpec]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A struct carrying #aya.table, lowered into everything the emitter needs.

This describes the row type: the flat shape of one database row. A domain type is a separate thing that the programmer maps to and from.

FieldSpec

source

pub struct FieldSpec {
  name : String
  ty : String
  column : String
  is_primary : Bool
  nullable : Bool
  sql_type : String?
  default_sql : String?
  unique : Bool
  autoincrement : Bool
  references : RefSpec?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

One column of an entity, in the order it was declared.

Declaration order is load-bearing: it fixes both the projection order and the positional decoder, which is exactly the pairing a hand-written Selection can get wrong.

IndexSpec

source

pub struct IndexSpec {
  name : String
  columns : Array[String]
  unique : Bool
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A secondary index declared on the entity with #aya.index(...).

RefSpec

source

pub struct RefSpec {
  table : String
  column : String
  on_delete : String?
  on_update : String?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A foreign key declared on a column, e.g. #aya.column(references="accounts.id", on_delete="cascade").

collect_entities

source

fn collect_entities(impls : @moonbitlang/core/list.List
List[@moonbitlang/parser/syntax.Impl
Impl]) -> Array[EntitySpec] raise

Collect every #aya.table declaration in a parsed file.

Declarations without the attribute are skipped, so an entity file may hold ordinary MoonBit code alongside entities.

emit_entity

source

fn emit_entity(spec : EntitySpec) -> String

Emit the four declarations that make one entity usable as a table.

emit_file

source

fn emit_file(specs : Array[EntitySpec]) -> String

Emit a complete generated file for a set of entities.

entities_of

source

fn entities_of(source : String, name? : String) -> Array[EntitySpec] raise

Parse a source file and lower every #aya.table in it.

The shared front half of both generators: the column-handle emitter and the DDL emitter must see the same entities, or the code and the schema drift.

generate

source

fn generate(source : String, name? : String) -> String raise

Parse an entity source file and produce its generated companion.

String in, string out: file IO stays in the CLI so the whole pipeline is testable without touching the filesystem.

parse_attr

source

fn parse_attr(raw : String) -> Attr? raise AttrError

Parse one raw attribute such as #aya.entity(table="users", alias="u").

Returns None when the attribute belongs to another namespace, so callers can ignore #deprecated, #morm.entity, and friends without special cases.

render_type

source

fn render_type(t : @moonbitlang/parser/syntax.Type
Type) -> String

Render a parsed type back to MoonBit source text.

The emitter needs the type twice, once inside Column[_] and once as the entity field type, so the round trip has to be faithful for the types aya can actually store.