module Clear::SQL

Overview

Clear::SQL

Clear is made like an onion:

+------------------------------------+
|           THE ORM STACK            +
+------------------------------------+
|  Model | DB Views | Migrations     | < High Level Tools
+---------------+--------------------+
|  Columns | Validation | Converters | < Mapping system
+---------------+--------------------+
|  Clear::SQL   | Clear::Expression  | < Low Level SQL Builder
+------------------------------------+
|  Crystal DB   | Crystal PG         | < Low Level connection
+------------------------------------+

On the bottom stack, Clear offer SQL query building. Theses features are then used by top level parts of the engine.

The SQL module provide a simple API to generate #delete, #insert, #select and #update methods.

Each requests can be duplicated then modified and executed.

Note: Each request object is mutable. Therefore, to update and store a request, you must use manually the dup method.

Included Modules

• Clear::SQL::Logger

Extended Modules

• Clear::SQL

Defined in:

Class Method Summary

• .lock(table : String | Symbol, mode = "ACCESS EXCLUSIVE", connection = "default", &)

  Tablewise locking

• .truncate(tablename : T.class | String, restart_sequence = false, cascade = false, truncate_inherited = true, connection_name : String | Nil = nil) forall T

  Truncate a table or a model

Instance Method Summary

• #add_connection(name : String, url : String, connection_pool_size = 5)
• #delete(table : Symbolic)

  Start a DELETE table query

• #escape(x : String | Symbol)

  Escape the expression, double quoting it.

• #execute(connection_name : String, sql)

  Execute a SQL statement on a specific connection.

• #execute(sql)

  Execute a SQL statement.

• #init(name : String, url : String, connection_pool_size = 5)
• #init(url : String, connection_pool_size = 5)
• #init(connections : Hash(Symbolic, String), connection_pool_size = 5)
• #insert(table, args : NamedTuple)
• #insert(table, *args)

  Alias of #insert_into, for hurry developers

• #insert

  Create a new INSERT query

• #insert_into(table)

  Start an INSERT INTO table query

• #insert_into(table, *args)

  Start an INSERT INTO table query

• #raw(x, *params)

  This provide a fast way to create SQL fragment while escaping items, both with ? and :key system:

• #raw(__template, **params)
• #raw_enum(x, params : Enumerable(T)) forall T

  See self.raw Can pass an array to this version

• #rollback

  Raise a rollback, in case of transaction

• #sanitize(x)

  Sanitize string and convert some literals (e.g.

• #select(*args)

  Start a SELECT FROM table query

• #transaction(connection = "default", &)

  Create an unstackable transaction

• #unsafe(x)
• #update(table)

  Start a UPDATE table query

• #with_savepoint(connection_name = "default", &)

  Create a transaction, but this one is stackable using savepoints.

Class Method Detail

User.query.count          # => 200
Clear::SQL.truncate(User) # equivalent to Clear::SQL.truncate(User.table, connection_name: User.connection)
User.query.count          # => 0

Instance Method Detail

Clear::SQL.insert_into("table", id: 1, name: "hello")

query = Mode.query.select(Clear::SQL.raw("CASE WHEN x=:x THEN 1 ELSE 0 END as check", x: "blabla"))
query = Mode.query.select(Clear::SQL.raw("CASE WHEN x=? THEN 1 ELSE 0 END as check", "blabla"))

Clear::SQL.transaction do
  # do something
  Clear::SQL.transaction do # Technically, this block do nothing, since we already are in transaction
    rollback                # < Rollback the up-most `transaction` block.
  end
end

Clear::SQL.with_savepoint do
  # do something
  Clear::SQL.with_savepoint do
    rollback # < Rollback only the last `with_savepoint` block
  end
end