class Tag

Included Modules

Extended Modules

Defined in:

models/tag.cr

Constant Summary

COLUMNS = {"id" => {type: Int64, primary: true, converter: "Int64", db_column_name: "id", crystal_variable_name: id, presence: false}, "name" => {type: String, primary: false, converter: "String", db_column_name: "name", crystal_variable_name: name, presence: true}} of Nil => Nil
POLYMORPHISM_SETTINGS = {} of Nil => Nil

Constructors

Class Method Summary

Instance Method Summary

Constructor Detail

def self.create(x : Hash) : self #

[View source]
def self.create(x : NamedTuple) : self #

[View source]
def self.create(**args) : self #

Build and new model and save it. Returns the model.

The model may not be saved due to validation failure; check the returned model errors? and persisted? flags.


[View source]
def self.create!(a : Hash) : self #

[View source]
def self.create!(x : NamedTuple) : self #

[View source]
def self.create!(**args) : self #

Build and new model and save it. Returns the model.

Returns the newly inserted model Raises an exception if validation failed during the saving process.


[View source]
def self.new(h : Hash(String, _), cache : Clear::Model::QueryCache | Nil = nil, persisted = false, fetch_columns = false) #

[View source]
def self.new(json : JSON::Any, cache : Clear::Model::QueryCache | Nil = nil, persisted = false) #

[View source]
def self.new(t : NamedTuple, persisted = false) #

[View source]
def self.new #

[View source]

Class Method Detail

def self.build(**x : **T) forall T #

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

Returns the new model


[View source]
def self.columns #

[View source]
def self.connection : String #

Define on which connection the model is living. Useful in case of models living in different databases.

Is set to "default" by default.

See Clear::SQL#init(URI, *opts) for more information about multi-connections.

Example:

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

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

def self.connection=(connection : String) #

Define on which connection the model is living. Useful in case of models living in different databases.

Is set to "default" by default.

See Clear::SQL#init(URI, *opts) for more information about multi-connections.

Example:

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

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

def self.create(x : Array(NamedTuple)) : Array(self) #

Multi-models creation. See Collection#create(**args)

Returns the list of newly created model.

Each model will call an INSERT query. You may want to use Collection#import to insert multiple model more efficiently in one query.


[View source]
def self.create!(x : Array(NamedTuple)) : Array(self) #

Multi-models creation. See Collection#create!(**args)

Returns the list of newly created model. Raises exception if any of the model has validation error.


[View source]
def self.find(x) #

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


[View source]
def self.find!(x) #

Returns a model using primary key equality. Raises error if the model is not found.


[View source]
def self.import(array : Enumerable(self), on_conflict : Clear::SQL::InsertQuery -> | Nil = nil) #

Import a bulk of models in one SQL insert query. Each model must be non-persisted.

on_conflict callback can be optionnaly turned on to manage constraints of the database.

Note: Old models are not modified. This method return a copy of the models as saved in the database.

Example:


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

[View source]
def self.polymorphic? : Bool #

def self.query #

Return a new empty query SELECT * FROM [my_model_table]. Can be refined after that.


[View source]
def self.read_only=(read_only : Bool) #

def self.read_only? : Bool #

def self.schema : Clear::SQL::Symbolic | Nil #

Define the current schema used in PostgreSQL. The value is nil by default, which lead to non-specified schema during the querying, and usage of "public" by PostgreSQL.

This property can be redefined on initialization. Example:

  class MyModel
    include Clear::Model

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

def self.schema=(schema : Clear::SQL::Symbolic | Nil) #

Define the current schema used in PostgreSQL. The value is nil by default, which lead to non-specified schema during the querying, and usage of "public" by PostgreSQL.

This property can be redefined on initialization. Example:

  class MyModel
    include Clear::Model

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

def self.table : Clear::SQL::Symbolic #

Return the table name setup for this model. By convention, the class name is by default equals to the pluralized underscored string form of the model name. Example:

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

The property can be updated at initialization to a custom table name:

  class MyModel
    include Clear::Model

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

def self.table=(table : Clear::SQL::Symbolic) #

Return the table name setup for this model. By convention, the class name is by default equals to the pluralized underscored string form of the model name. Example:

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

The property can be updated at initialization to a custom table name:

  class MyModel
    include Clear::Model

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

Instance Method Detail

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

Attributes, used when fetch_columns is true


def cache : Clear::Model::QueryCache | Nil #

def changed? #

Return true if the model is dirty (e.g. one or more fields have been changed.). Return false otherwise.


def clear_change_flags #

Reset the #changed? flag on all columns

The model behave like its not dirty anymore and call to save would apply no changes.

Returns self


def id : Int64 #

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


def id=(x : Int64) #

Setter for #id column.


def id_column : Clear::Model::Column(Int64, Clear::Model::Converter::Int64Converter) #

Returns the column object used to manage #id field

See Clear::Model::Column


def invalidate_caching : self #

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


[View source]
def name : String #

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


def name=(x : String) #

Setter for #name column.


def name_column : Clear::Model::Column(String, Clear::Model::Converter::StringConverter) #

Returns the column object used to manage #name field

See Clear::Model::Column


def repositories : Repository::Collection #

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

Set the columns from hash


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

Set the model fields from hash


def reset(t : NamedTuple) #

def reset(from_json : JSON::Any) #

def reset(**t : **T) forall T #

reset flavors


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

Set the columns from hash


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

Set the model fields from hash


def set(t : NamedTuple) #

def set(from_json : JSON::Any) #

def set(**t : **T) forall T #
Description copied from module Clear::Model::HasColumns

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

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

def to_h(full = false) : Hash(String, Clear::SQL::Any) #

Return a hash version of the columns of this model.


def to_json(emit_nulls : Bool = false) #

def to_json(json, emit_nulls = false) #

def update_h : Hash(String, Clear::SQL::Any) #

Generate the hash for update request (like during save)


def validate_fields_presence #

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

This method is called on validation.