class Lustra::Reflection::Column

• Lustra::Reflection::Column
• Reference
• Object

Overview

Reflection of the columns using information_schema in postgreSQL.

TODO Usage of view instead of model

Included Modules

• Lustra::Model

Extended Modules

• Lustra::Model::HasHooks::ClassMethods

Defined in:

Constant Summary

COLUMNS = {"table_catalog" => {type: String, primary: false, converter: "String", db_column_name: "table_catalog", crystal_variable_name: table_catalog, presence: true, mass_assign: true}, "table_schema" => {type: String, primary: false, converter: "String", db_column_name: "table_schema", crystal_variable_name: table_schema, presence: true, mass_assign: true}, "table_name" => {type: String, primary: false, converter: "String", db_column_name: "table_name", crystal_variable_name: table_name, presence: false, mass_assign: true}, "column_name" => {type: String, primary: true, converter: "String", db_column_name: "column_name", crystal_variable_name: column_name, presence: true, mass_assign: true}} of Nil => Nil

POLYMORPHISM_SETTINGS = {} of Nil => Nil

Constructors

• .build(x : NamedTuple) : self

  Build a new empty model and fill the columns using the NamedTuple in argument.

• .build(x : NamedTuple, &block : self -> Nil) : self

  Build a new empty model and fill the columns using the NamedTuple in argument.

• .create(x : NamedTuple, &block : self -> Nil) : self

  Build and new model and save it.

• .create(**tuple, &block : self -> Nil) : self

  Build and new model and save it.

• .create(x : NamedTuple) : self

  Build and new model and save it.

• .create(**tuple) : self

  Build and new model and save it.

• .create!(x : NamedTuple, &block : self -> Nil) : self

  Build and new model and save it.

• .create!(**tuple, &block : self -> Nil) : self

  Build and new model and save it.

• .create!(x : NamedTuple) : self

  Build and new model and save it.

• .create!(**tuple) : self

  Build and new model and save it.

• .new(h : Hash(String, _), cache : Lustra::Model::QueryCache | Nil = nil, persisted = false, fetch_columns = false)
• .new(json : JSON::Any, cache : Lustra::Model::QueryCache | Nil = nil, persisted = false)
• .new(t : NamedTuple, persisted = false)
• .new

Class Method Summary

• .build(**tuple : **T) forall T

  Build a new empty model and fill the columns using the NamedTuple in argument.

• .build(**tuple)

  Build a new empty model and fill the columns using the NamedTuple in argument.

• .build(**tuple, &)

  Build a new empty model and fill the columns using the NamedTuple in argument.

• .columns
• .connection : String

  Define on which connection the model is living.

• .connection=(connection : String)

  Define on which connection the model is living.

• .create_from_json(string_or_io : String | IO, trusted : Bool = false)

  Create a new model from json and save it.

• .create_from_json!(string_or_io : String | IO, trusted : Bool = false)

  Create a new model from json and save it.

• .find(ids : Array)

  Find multiple models by an array of primary keys.

• .find(x)

  Returns a model using primary key equality Returns nil if not found.

• .find!(ids : Array)

  Find multiple models by an array of primary keys.

• .find!(x)

  Returns a model using primary key equality.

• .find_by(tuple : NamedTuple)

  Find a model by column values.

• .find_by(**tuple)

  Find a model by column values.

• .find_by!(tuple : NamedTuple)

  Find a model by column values.

• .find_by!(**tuple)

  Find a model by column values.

• .from_json(string_or_io : String | IO, trusted : Bool = false)

  Create a new empty model and fill the columns from json.

• .full_table_name

  returns the fully qualified and escaped name for this table.

• .import(array : Enumerable(self), on_conflict : Lustra::SQL::InsertQuery -> | Nil = nil)

  Import a bulk of models in one SQL insert query.

• .polymorphic? : Bool
• .query

  Return a new query SELECT * FROM [my_model_table].

• .read_only=(read_only : Bool)
• .read_only? : Bool
• .register_counter_cache(association_model : Class, counter_column : String, foreign_key : String)

  Register a counter cache for this model using model class

• .reset_counters(id, *counter_models)

  Reset counter cache columns to their correct values.

• .schema : Lustra::SQL::Symbolic | Nil

  Define the current schema used in PostgreSQL.

• .schema=(schema : Lustra::SQL::Symbolic | Nil)

  Define the current schema used in PostgreSQL.

• .table : Lustra::SQL::Symbolic

  Return the table name setup for this model.

• .table=(table : Lustra::SQL::Symbolic)

  Return the table name setup for this model.

Instance Method Summary

• #_cached_table : Lustra::Reflection::Table | Nil
• #add_built_association(association_name : String, model : Lustra::Model)

  Add a built association to track for autosave

• #attributes : Hash(String, Lustra::SQL::Any)

  Attributes, used when fetch_columns is true

• #built_associations : Hash(String, Array(Lustra::Model))

  Track built associations for autosave functionality

• #built_associations=(built_associations : Hash(String, Array(Lustra::Model)))

  Track built associations for autosave functionality

• #cache : Lustra::Model::QueryCache | Nil
• #changed : Array(String)

  Returns an array of names of all changed attributes.

• #changed?

  Return true if the model is dirty (e.g.

• #changes : Hash(String, Tuple(Lustra::SQL::Any, Lustra::SQL::Any))

  Returns a hash of all changed attributes with their [old_value, new_value].

• #clear_built_associations

  Clear all built associations (called after successful save)

• #clear_change_flags

  Reset the #changed? flag on all columns

• #column_name : String

  Returns the value of #column_name column or throw an exception if the column is not defined.

• #column_name=(x : String)

  Setter for #column_name column.

• #column_name_column : Lustra::Model::Column(String, Lustra::Model::Converter::StringConverter)

  Returns the column object used to manage #column_name field

• #has_built_associations? : Bool

  Check if there are any pending built associations

• #reset(h : Hash(Symbol, _))

  Set the columns from hash

• #reset(h : Hash(String, _))

  Set the model fields from hash

• #reset(t : NamedTuple)
• #reset(from_json : JSON::Any)
• #reset(**t : **T) forall T

  reset flavors

• #reset_counters(*counter_models)

  Reset counter cache columns

• #set(h : Hash(Symbol, _))

  Set the columns from hash

• #set(h : Hash(String, _))

  Set the model fields from hash

• #set(t : NamedTuple)
• #set(from_json : JSON::Any)
• #set(**t : **T) forall T

  Set one or multiple columns to a specific value This two are equivalents:

• #set_from_json(string_or_io : String | IO, trusted : Bool = false)

  Set the fields from json passed as argument Trusted flag set to true will allow mass assignment without protection, FALSE by default

• #table : Lustra::Reflection::Table

  The method table is a belongs_to relation to Lustra::Reflection::Table

• #table=(model : Lustra::Reflection::Table)
• #table_catalog : String

  Returns the value of #table_catalog column or throw an exception if the column is not defined.

• #table_catalog=(x : String)

  Setter for #table_catalog column.

• #table_catalog_column : Lustra::Model::Column(String, Lustra::Model::Converter::StringConverter)

  Returns the column object used to manage #table_catalog field

• #table_name : String

  Returns the value of #table_name column or throw an exception if the column is not defined.

• #table_name=(x : String)

  Setter for #table_name column.

• #table_name_column : Lustra::Model::Column(String, Lustra::Model::Converter::StringConverter)

  Returns the column object used to manage #table_name field

• #table_schema : String

  Returns the value of #table_schema column or throw an exception if the column is not defined.

• #table_schema=(x : String)

  Setter for #table_schema column.

• #table_schema_column : Lustra::Model::Column(String, Lustra::Model::Converter::StringConverter)

  Returns the column object used to manage #table_schema field

• #to_h(full = false) : Hash(String, Lustra::SQL::Any)

  Return a hash version of the columns of this model.

• #to_json(emit_nulls : Bool = false)
• #to_json(json, emit_nulls = false)
• #update_from_json(string_or_io : String | IO, trusted : Bool = false)

  Set the fields from json passed as argument and call save on the object Trusted flag set to true will allow mass assignment without protection, FALSE by default

• #update_from_json!(string_or_io : String | IO, trusted : Bool = false)

  Set the fields from json passed as argument and call save! on the object Trusted flag set to true will allow mass assignment without protection, FALSE by default

• #update_h : Hash(String, Lustra::SQL::Any)

  Generate the hash for update request (like during save)

• #validate_fields_presence

  For each column, ensure than when needed the column has present information into it.

Constructor Detail

Class Method Detail

Lustra::SQL.init("postgres://postgres@localhost/database_1")
Lustra::SQL.init("secondary", "postgres://postgres@localhost/database_2")

class ModelA
  include Lustra::Model

  # Performs all the queries on `database_1`
  # self.connection = "default"
  column id : Int32, primary: true, presence: false
  column title : String
end

class ModelB
  include Lustra::Model

  # Performs all the queries on `database_2`
  self.connection = "secondary"

  column id : Int32, primary: true, presence: false
end

Lustra::SQL.init("postgres://postgres@localhost/database_1")
Lustra::SQL.init("secondary", "postgres://postgres@localhost/database_2")

class ModelA
  include Lustra::Model

  # Performs all the queries on `database_1`
  # self.connection = "default"
  column id : Int32, primary: true, presence: false
  column title : String
end

class ModelB
  include Lustra::Model

  # Performs all the queries on `database_2`
  self.connection = "secondary"

  column id : Int32, primary: true, presence: false
end

users = User.find([1, 2, 3])
users.size # => 0..3 depending on how many were found

users = User.find!([1, 2, 3]) # Raises if any ID is not found

user = User.find_by(email: "test@example.com")
user = User.find_by(first_name: "John", last_name: "Doe")

user = User.find_by(email: "test@example.com")
user = User.find_by(first_name: "John", last_name: "Doe")

user = User.find_by!(email: "test@example.com")

user = User.find_by!(email: "test@example.com")

users = [User.new(id: 1), User.new(id: 2), User.new(id: 3)]
users = User.import(users)

User.reset_counters(user.id, Post)
User.reset_counters(user.id, Post, Comment)

class MyModel
  include Lustra::Model

  self.schema = "my_schema"
end
MyModel.query.to_sql # SELECT * FROM "my_schema"."my_models"

class MyModel
  include Lustra::Model

  self.schema = "my_schema"
end
MyModel.query.to_sql # SELECT * FROM "my_schema"."my_models"

MyModel => "my_models"
Person => "people"
Project::Info => "project_infos"

class MyModel
  include Lustra::Model

  self.table = "another_table_name"
end
MyModel.query.to_sql # SELECT * FROM "another_table_name"

MyModel => "my_models"
Person => "people"
Project::Info => "project_infos"

class MyModel
  include Lustra::Model

  self.table = "another_table_name"
end
MyModel.query.to_sql # SELECT * FROM "another_table_name"

Instance Method Detail

user.email = "new@test.com"
user.first_name = "John"
user.changed  # => ["email", "first_name"]

user.email = "new@test.com"
user.first_name = "John"
user.changes  # => {"email" => ["old@test.com", "new@test.com"], "first_name" => [nil, "John"]}

user = User.find(1)
user.reset_counters(Post)
user.reset_counters(Post, Comment)

model.set(a: 1)
model.a = 1