class Clear::Reflection::Table

• Clear::Reflection::Table
• Reference
• Object

Overview

Reflection of the tables using information_schema in postgreSQL.

TODO Usage of view instead of model

Included Modules

• Clear::Model

Extended Modules

• Clear::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: true, converter: "String", db_column_name: "table_name", crystal_variable_name: table_name, presence: true, mass_assign: true}, "table_type" => {type: String, primary: false, converter: "String", db_column_name: "table_type", crystal_variable_name: table_type, 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 : Clear::Model::QueryCache | Nil = nil, persisted = false, fetch_columns = false)
• .new(json : JSON::Any, cache : Clear::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(x)

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

• .find!(x)

  Returns a model using primary key equality.

• .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 : Clear::SQL::InsertQuery -> | Nil = nil)

  Import a bulk of models in one SQL insert query.

• .polymorphic? : Bool
• .public
• .query

  Return a new empty query SELECT * FROM [my_model_table].

• .read_only=(read_only : Bool)
• .read_only? : Bool
• .schema : Clear::SQL::Symbolic | Nil

  Define the current schema used in PostgreSQL.

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

  Define the current schema used in PostgreSQL.

• .table : Clear::SQL::Symbolic

  Return the table name setup for this model.

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

  Return the table name setup for this model.

• .tables_only
• .views_only

Instance Method Summary

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

  Attributes, used when fetch_columns is true

• #cache : Clear::Model::QueryCache | Nil
• #changed?

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

• #clear_change_flags

  Reset the #changed? flag on all columns

• #columns : Clear::Reflection::Column::Collection

  The method columns is a has_many relation to Clear::Reflection::Column

• #indexes : Hash(String, Array(String))

  List all the indexes related to the current table.

• #invalidate_caching : self

  Force to clean-up the caches for the relations connected to this model.

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

• #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_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 : Clear::Model::Column(String, Clear::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 : Clear::Model::Column(String, Clear::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 : Clear::Model::Column(String, Clear::Model::Converter::StringConverter)

  Returns the column object used to manage #table_schema field

• #table_type : String

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

• #table_type=(x : String)

  Setter for #table_type column.

• #table_type_column : Clear::Model::Column(String, Clear::Model::Converter::StringConverter)

  Returns the column object used to manage #table_type field

• #to_h(full = false) : Hash(String, Clear::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, Clear::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

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

class ModelA
  include Clear::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 Clear::Model

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

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

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

class ModelA
  include Clear::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 Clear::Model

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

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

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

class MyModel
  include Clear::Model

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

class MyModel
  include Clear::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 Clear::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 Clear::Model

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

Instance Method Detail

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