galchemy - v3.1.0

galchemy/orm/query

Types

ModelRef

</> 
pub type ModelRef {
  ModelRef(metadata: metadata.ModelMetadata, table: schema.Table)
}

Constructors

QueryError

</> 
pub type QueryError {
  DeclarativeError(declarative.DeclarativeError)
  UnknownColumn(table: relation.TableRef, column: String)
  UnknownRelation(
    table: relation.TableRef,
    relation_name: String,
  )
  RelatedTableMismatch(
    relation_name: String,
    expected: relation.TableRef,
    actual: relation.TableRef,
  )
}

Constructors

Selection

</> 
pub type Selection {
  Selection(column: String, alias: option.Option(String))
}

Constructors

Values

as_

</> 
pub fn as_(model_ref: ModelRef, alias: String) -> ModelRef

asc

</> 
pub fn asc(
  model_ref: ModelRef,
  column_name: String,
) -> Result(expression.Order, QueryError)

col

</> 
pub fn col(
  model_ref: ModelRef,
  column_name: String,
) -> Result(expression.Expression, QueryError)

desc

</> 
pub fn desc(
  model_ref: ModelRef,
  column_name: String,
) -> Result(expression.Order, QueryError)

distinct

</> 
pub fn distinct(
  query: expression.SelectQuery,
) -> expression.SelectQuery

eq

</> 
pub fn eq(
  model_ref: ModelRef,
  column_name: String,
  value: expression.Expression,
) -> Result(expression.Predicate, QueryError)

field

</> 
pub fn field(column: String) -> Selection

field_as

</> 
pub fn field_as(column: String, alias: String) -> Selection

from_metadata

</> 
pub fn from_metadata(
  next_metadata: metadata.ModelMetadata,
) -> ModelRef

from_model

</> 
pub fn from_model(
  next_model: declarative.Model,
) -> Result(ModelRef, QueryError)

gt

</> 
pub fn gt(
  model_ref: ModelRef,
  column_name: String,
  value: expression.Expression,
) -> Result(expression.Predicate, QueryError)

gte

</> 
pub fn gte(
  model_ref: ModelRef,
  column_name: String,
  value: expression.Expression,
) -> Result(expression.Predicate, QueryError)

ilike

</> 
pub fn ilike(
  model_ref: ModelRef,
  column_name: String,
  value: expression.Expression,
) -> Result(expression.Predicate, QueryError)

in_list

</> 
pub fn in_list(
  model_ref: ModelRef,
  column_name: String,
  values: List(expression.Expression),
) -> Result(expression.Predicate, QueryError)

inner_join_relation

</> 
pub fn inner_join_relation(
  query: expression.SelectQuery,
  model_ref: ModelRef,
  relation_name: String,
  related_model: ModelRef,
) -> Result(expression.SelectQuery, QueryError)

is_not_null

</> 
pub fn is_not_null(
  model_ref: ModelRef,
  column_name: String,
) -> Result(expression.Predicate, QueryError)

is_null

</> 
pub fn is_null(
  model_ref: ModelRef,
  column_name: String,
) -> Result(expression.Predicate, QueryError)

item

</> 
pub fn item(
  model_ref: ModelRef,
  column_name: String,
) -> Result(expression.SelectItem, QueryError)

item_as

</> 
pub fn item_as(
  model_ref: ModelRef,
  column_name: String,
  alias: String,
) -> Result(expression.SelectItem, QueryError)

left_join_relation

</> 
pub fn left_join_relation(
  query: expression.SelectQuery,
  model_ref: ModelRef,
  relation_name: String,
  related_model: ModelRef,
) -> Result(expression.SelectQuery, QueryError)

like

</> 
pub fn like(
  model_ref: ModelRef,
  column_name: String,
  value: expression.Expression,
) -> Result(expression.Predicate, QueryError)

limit

</> 
pub fn limit(
  query: expression.SelectQuery,
  value: Int,
) -> expression.SelectQuery

lt

</> 
pub fn lt(
  model_ref: ModelRef,
  column_name: String,
  value: expression.Expression,
) -> Result(expression.Predicate, QueryError)

lte

</> 
pub fn lte(
  model_ref: ModelRef,
  column_name: String,
  value: expression.Expression,
) -> Result(expression.Predicate, QueryError)

neq

</> 
pub fn neq(
  model_ref: ModelRef,
  column_name: String,
  value: expression.Expression,
) -> Result(expression.Predicate, QueryError)

offset

</> 
pub fn offset(
  query: expression.SelectQuery,
  value: Int,
) -> expression.SelectQuery

order_by

</> 
pub fn order_by(
  query: expression.SelectQuery,
  next_order: expression.Order,
) -> expression.SelectQuery

select_all

</> 
pub fn select_all(model_ref: ModelRef) -> expression.SelectQuery

select_fields

</> 
pub fn select_fields(
  model_ref: ModelRef,
  selections: List(Selection),
) -> Result(expression.SelectQuery, QueryError)

where_

</> 
pub fn where_(
  query: expression.SelectQuery,
  next_predicate: expression.Predicate,
) -> expression.SelectQuery
✨ Search Document