class Clear::Model::CollectionBase(T)

• Clear::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 `Clear::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

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

Direct Known Subclasses

• Clear::Reflection::Column::Collection
• Clear::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.

• #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, &block : T -> )

  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.

• #item_class

  Return the model class for this collection

• #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.

• #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.

• #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