class Lustra::Model::CollectionBase(T)

• Lustra::Model::CollectionBase(T)
• Reference
• Object

Overview

CollectionBase(T) is the base class for collection of model. Collection of model are a SQL SELECT query mapping & building system. They are Enumerable and are `Lustra::SQL::SelectBuilder` behavior; therefore, they can be used array-like and are working with low-level SQL Building.

The CollectionBase(T) is extended by each model. For example, generating the model MyModel will generate the class MyModel::Collection which inherits from CollectionBase(MyModel)

Collection are instantiated using Model.query method.

Included Modules

• Enumerable(T)
• Lustra::SQL::SelectBuilder

Direct Known Subclasses

• Lustra::Reflection::Column::Collection
• Lustra::Reflection::Table::Collection

Defined in:

Instance Method Summary

• #<<(item : T)

  Add an item to the current collection.

• #[](range : Range(Number, Number), fetch_columns = false) : Array(T)

  Get a range of models

• #[](off, fetch_columns = false) : T

  Basically a fancy way to write OFFSET x LIMIT 1

• #[]?(off, fetch_columns = false) : T | Nil

  Basically a fancy way to write OFFSET x LIMIT 1

• #add(item : T)

  Alias for Collection#<<

• #any?

  Check whether the query return any row.

• #association_name : String | Nil
• #association_name=(association_name : String | Nil)
• #autosave=(autosave : Bool)
• #autosave? : Bool
• #build(x : NamedTuple, &block : T -> Nil) : T

  Build a new collection; if the collection comes from a has_many relation (e.g.

• #build(**tuple, & : T -> Nil) : T

  Build a new collection; if the collection comes from a has_many relation (e.g.

• #build(x : NamedTuple) : T

  Build a new collection; if the collection comes from a has_many relation (e.g.

• #build(**tuple) : T

  Build a new collection; if the collection comes from a has_many relation (e.g.

• #count(type : X.class = Int64) forall X

  Use SQL COUNT over your query, and return this number as a Int64

• #create(x : NamedTuple, &block : T -> Nil) : T

  Build a new object and setup the fields like setup in the condition tuple.

• #create(**tuple, & : T -> Nil) : T

  Build a new object and setup the fields like setup in the condition tuple.

• #create(x : NamedTuple) : T

  Build a new object and setup the fields like setup in the condition tuple.

• #create(**tuple) : T

  Build a new object and setup the fields like setup in the condition tuple.

• #create!(x : NamedTuple, &block : T -> Nil) : T

  Build a new object and setup the fields like setup in the condition tuple.

• #create!(**tuple, & : T -> Nil) : T

  Build a new object and setup the fields like setup in the condition tuple.

• #create!(x : NamedTuple) : T

  Build a new object and setup the fields like setup in the condition tuple.

• #create!(**tuple) : T

  Build a new object and setup the fields like setup in the condition tuple.

• #delete_all : self

  Delete all the rows which would have been returned by this collection.

• #dup

  Duplicate the query

• #each(fetch_columns = false, & : T -> ) : Nil

  Build the SQL, send the query then iterate through each models gathered by the request.

• #each_with_cursor(batch = 1000, fetch_columns = false, &block : T -> )

  Build the SQL, send the query then iterate through each models gathered by the request.

• #empty?

  Inverse of #any?, return true if the request return no rows.

• #find(fetch_columns = false, &) : T | Nil

  A convenient way to write where { condition }.first(fetch_columns)

• #find(tuple : NamedTuple, fetch_columns = false) : T | Nil

  A convenient way to write where({any_column: "any_value"}).first(fetch_columns)

• #find(**tuple) : T | Nil

  A convenient way to write where({any_column: "any_value"}).first

• #find!(fetch_columns = false, &) : T

  A convenient way to write where { condition }.first!(fetch_columns)

• #find!(tuple : NamedTuple, fetch_columns = false) : T

  A convenient way to write where({any_column: "any_value"}).first!(fetch_columns)

• #find!(**tuple) : T

  A convenient way to write where({any_column: "any_value"}).first!

• #find_or_build(x : NamedTuple, &block : T -> Nil) : T
• #find_or_build(**tuple, & : T -> Nil) : T

  Try to fetch a row.

• #find_or_build(x : NamedTuple) : T
• #find_or_build(**tuple) : T
• #find_or_create(x : NamedTuple, &block : T -> Nil) : T

  Try to fetch a row.

• #find_or_create(**tuple, & : T -> Nil) : T

  Try to fetch a row.

• #find_or_create(x : NamedTuple) : T

  Try to fetch a row.

• #find_or_create(**tuple) : T

  Try to fetch a row.

• #first(fetch_columns = false) : T | Nil

  Get the first row from the collection query.

• #first!(fetch_columns = false) : T

  Get the first row from the collection query.

• #full_outer_join(association : Lustra::SQL::Symbolic, lateral = false)

  FULL_OUTER JOIN using association name (auto-detects join conditions)

• #inner_join(association : Lustra::SQL::Symbolic, lateral = false)

  INNER JOIN using association name (auto-detects join conditions)

• #item_class

  Return the model class for this collection

• #join(association : Lustra::SQL::Symbolic, type = :inner, lateral = false)

  Join a relation using association name (auto-detects join conditions) Overrides the parent join to handle association names without blocks

• #last(fetch_columns = false) : T | Nil

  Get the last row from the collection query.

• #last!(fetch_columns = false) : T

  Get the last row from the collection query.

• #left_join(association : Lustra::SQL::Symbolic, lateral = false)

  LEFT JOIN using association name (auto-detects join conditions)

• #map(fetch_columns = false, &block : T -> X) : Array(X) forall X

  Build the SQL, send the query then build and array by applying the block transformation over it.

• #parent_model : Lustra::Model | Nil

  Parent model context for autosave functionality

• #parent_model=(parent_model : Lustra::Model | Nil)

  Parent model context for autosave functionality

• #right_join(association : Lustra::SQL::Symbolic, lateral = false)

  RIGHT JOIN using association name (auto-detects join conditions)

• #save!(item : T)

  Save a model and handle append_operation for has_many through relationships This allows the build + save pattern to work

• #tags
• #to_a(fetch_columns = false) : Array(T)

  Create an array from the query.

• #unlink(item : T)

  Unlink the model currently referenced through a relation has_many through

Instance Method Detail