galchemy - v3.1.0

galchemy/orm/declarative

Types

Column

</> 
pub type Column {
  Column(
    name: String,
    data_type: model.ColumnType,
    nullable: Bool,
    default: option.Option(String),
    primary_key: Bool,
    unique: Bool,
  )
}

Constructors

DeclarativeError

</> 
pub type DeclarativeError {
  DuplicateColumn(table: relation.TableRef, column: String)
  DuplicateRelation(
    table: relation.TableRef,
    relation_name: String,
  )
  MissingIdentity(table: relation.TableRef)
  UnknownIdentityColumn(table: relation.TableRef, column: String)
  UnknownLocalColumn(table: relation.TableRef, column: String)
}

Constructors

Model

</> 
pub type Model {
  Model(
    table: relation.TableRef,
    columns: List(Column),
    identity_columns: option.Option(List(String)),
    relations: List(RelationDefinition),
  )
}

Constructors

RelationDefinition

</> 
pub type RelationDefinition {
  RelationDefinition(
    name: String,
    foreign_key_name: String,
    kind: RelationKind,
    related_table: relation.TableRef,
    column_pairs: List(relation.ColumnPair),
  )
}

Constructors

RelationKind

</> 
pub type RelationKind {
  BelongsTo
  HasMany
}

Constructors 

  • BelongsTo
  • HasMany

Values

array

</> 
pub fn array(name: String, item_type: model.ColumnType) -> Column

belongs_to

</> 
pub fn belongs_to(
  name: String,
  foreign_key_name: String,
  related_schema: String,
  related_table: String,
  column_pairs: List(relation.ColumnPair),
) -> RelationDefinition

big_int

</> 
pub fn big_int(name: String) -> Column

bool

</> 
pub fn bool(name: String) -> Column

bytea

</> 
pub fn bytea(name: String) -> Column

custom

</> 
pub fn custom(name: String, type_name: String) -> Column

custom_with

</> 
pub fn custom_with(
  name: String,
  next_type: codec.CustomCodec(a),
) -> Column

date

</> 
pub fn date(name: String) -> Column

default

</> 
pub fn default(next_column: Column, sql: String) -> Column

float

</> 
pub fn float(name: String) -> Column

has_many

</> 
pub fn has_many(
  name: String,
  foreign_key_name: String,
  related_schema: String,
  related_table: String,
  column_pairs: List(relation.ColumnPair),
) -> RelationDefinition

identity

</> 
pub fn identity(
  next_model: Model,
  columns: List(String),
) -> Model

int

</> 
pub fn int(name: String) -> Column

json

</> 
pub fn json(name: String) -> Column

jsonb

</> 
pub fn jsonb(name: String) -> Column

model_

</> 
pub fn model_(
  schema_name: String,
  table_name: String,
  columns: List(Column),
  relations: List(RelationDefinition),
) -> Model

nullable

</> 
pub fn nullable(next_column: Column) -> Column

numeric

</> 
pub fn numeric(
  name: String,
  precision: option.Option(Int),
  scale: option.Option(Int),
) -> Column

pair

</> 
pub fn pair(
  local_column: String,
  related_column: String,
) -> relation.ColumnPair

primary_key

</> 
pub fn primary_key(next_column: Column) -> Column

real

</> 
pub fn real(name: String) -> Column

small_int

</> 
pub fn small_int(name: String) -> Column

text

</> 
pub fn text(name: String) -> Column

time_of_day

</> 
pub fn time_of_day(name: String) -> Column

timestamp

</> 
pub fn timestamp(name: String) -> Column

timestamptz

</> 
pub fn timestamptz(name: String) -> Column

timetz

</> 
pub fn timetz(name: String) -> Column

to_metadata

</> 
pub fn to_metadata(
  next_model: Model,
) -> Result(metadata.ModelMetadata, DeclarativeError)

to_snapshot

</> 
pub fn to_snapshot(
  models: List(Model),
) -> Result(model.SchemaSnapshot, DeclarativeError)

to_table_schema

</> 
pub fn to_table_schema(
  next_model: Model,
) -> Result(model.TableSchema, DeclarativeError)

unique

</> 
pub fn unique(next_column: Column) -> Column

uuid

</> 
pub fn uuid(name: String) -> Column

varchar

</> 
pub fn varchar(
  name: String,
  length: option.Option(Int),
) -> Column
✨ Search Document