class Jennifer::QueryBuilder::Query

• Jennifer::QueryBuilder::Query
• Reference
• Object

Included Modules

• Jennifer::QueryBuilder::Aggregations
• Jennifer::QueryBuilder::Executables
• Jennifer::QueryBuilder::Joining
• Jennifer::QueryBuilder::Ordering
• Jennifer::QueryBuilder::Statement

Direct Known Subclasses

• Jennifer::QueryBuilder::IModelQuery

Defined in:

Constructors

• .new(table, adapter = Adapter.default_adapter)
• .new

Class Method Summary

• .[](*args)

  Alias for .build.

• .build(*args)

  Builds query with related expression builder.

• .null(table = "")

  Alias for new(table).none.

Instance Method Summary

• #_select_fields : Array(Criteria)

  Returns array of Criteria for SELECT query statement.

• #adapter : Adapter::Base
• #as_sql(generator)

  Converts node to SQL using sql_generator SQLGenerator.

• #as_sql
• #clone

  Creates a clone of the query.

• #distinct

  Specifies whether the records should be unique or not.

• #do_nothing? : Bool

  Returns whether query should be executed.

• #empty?
• #eql?(other : Query)

  Compare current object with given comparing generated SQL query and parameters.

• #eql?(other : Statement | LogicOperator)
• #except(parts : Array(String))

  Creates a clone of the query without specified parts.

• #exec(&)

  Allows executing a block in the query context.

• #expression_builder : Jennifer::QueryBuilder::ExpressionBuilder

  Returns current query expression builder.

• #filterable?

  Returns whether node has an argument to be added to SQL statement arguments.

• #from(from : String | Query)

  Specifies table from which the records will be fetched.

• #group(column : String)

  Groups by given column realizes it as is.

• #group(column : Symbol)

  Groups by given column realizing it as a current table's field.

• #group(column : Criteria)
• #group(*columns : String)

  Groups by given columns realizes them as are

• #group(*columns : Symbol)

  Groups by given columns realizes them as current table's ones

• #group(&)
• #having(&)

  Allows to specify a HAVING clause.

• #limit(count : Int32)

  Specifies a limit for the number of records to retrieve.

• #lock(type : String | Bool = true)

  Specifies locking settings.

• #merge(other : self)

  Merges other query into current one.

• #none

  Returns a chainable query with zero records.

• #offset(count : Int32)

  Specifies the number of rows to skip before returning rows.

• #select(raw_sql : String)

  Specifies raw SELECT clause value.

• #select(field : Criteria)

  Specifies criterion to be used in SELECT clause.

• #select(fields : Array(Criteria))
• #select(*fields : Symbol)

  Specifies column names to be used in SELECT clause.

• #select(&)
• #set_tree(other : LogicOperator | Condition)

  Joins given other condition statement to the main condition tree.

• #set_tree(other : Query)

  Joins given other condition statement to the main condition tree.

• #set_tree(other : SQLNode)

  Joins given other condition statement to the main condition tree.

• #set_tree(other : Nil)

  Joins given other condition statement to the main condition tree.

• #sql_args : Array(DBAny)

  Returns array of SQL query arguments.

• #table : String

  Table name to be specified in FROM clause.

• #to_json(only : Array(String)? = nil, except : Array(String)? = nil, &)

  Returns a JSON string representing collection of retrieved entities.

• #to_json(json : JSON::Builder)
• #to_json(json : JSON::Builder, only : Array(String)? = nil, except : Array(String)? = nil, &)
• #to_json(only : Array(String)? = nil, except : Array(String)? = nil)
• #to_s(io : IO)

  Appends a short String representation of this object which includes its class name and its object address.

• #tree : Condition | LogicOperator | Nil

  Query filter to be rendered in WHERE clause.

• #tree=(tree : Condition | LogicOperator | Nil)

  Query filter to be rendered in WHERE clause.

• #union(query, all : Bool = false)

  Adds query to UNION.

• #where(&)

  Mutates query applying all modification returned from the block.

• #where(conditions : Hash(Symbol, _))

  Mutates query by given conditions.

• #with(name : String | Symbol, query : Query, recursive : Bool = false)

  Adds CTE (common table expression) to the query.

Constructor Detail

Class Method Detail

Jennifer::Query["contacts"].where { _name == "Jack London" }

Jennifer::Query.build("contacts").where { _name == "Jack London" }

Instance Method Detail

query = Jennifer::Query["contacts"].where { _city == "Kyiv" }
query.clone.where { _name.like("John%") }
query.clone.where { _name.like("Peter%") }

Jennifer::Query["contacts"].where { _city == "Paris" }.except(["where"])

Jennifer::Query["contacts"].exec { where { _name == "Jack London" } }

# FROM contacts
Jennifer::Query[""].from("contacts") # FROM contacts
# FROM (SELECT users.* WHERE users.active)
Jennifer::Query["contacts"].from(Jennifer::Query["users"].where { _active })

Jennifer::Query["contacts"].group("first_name || last_name")

Jennifer::Query["contacts"].group(:name)

Jennifer::Query["contacts"].limit(10)

Queue.all.where do
  _id == g(Queue.all.limit(1).lock("FOR UPDATE SKIP LOCKED"))
end.delete

# returns contacts that have main address
addresses_condition = Jennifer::Query["addresses"].where { _main }
Jennifer::Query["contacts"].join("addresses") { _contact_id == _contacts__id }
  .merge(addresses_condition)

Contacts.all.relation(:addresses).merge(Address.all.main)

Jennifer::Query["contacts"].where { _name == "Jack London" }.none

Jennifer::Query["contacts"].offset(10)

Jennifer::Query["contacts"].select("name as first_name, age as count").results

Jennifer::Query["contacts"].exec { select(expression._name.alias("first_name")) }.results

Jennifer::Query["user"].to_json
# => [{"id": 1, "name": "John Smith"}]

class Person
  def initialize(@name : String, @age : Int32)
  end
end

Person.new("John", 32).to_s # => #<Person:0x10a199f20>

Jennifer::Query["contacts"].union(Jennifer::Query["users"])
Jennifer::Query["contacts"].union(Jennifer::Query["users"], true)

User.where { _email == "example@test.com" }

Jennifer::Query["contacts"].where({:name => "test", :age => 23})
# SELECT contacts.* FROM contacts WHERE (contacts.name = 'test' AND contacts.age = 23)

# WITH RECURSIVE test AS (SELECT users.* FROM users )
Jennifer::Query["contacts"].with("test", Jennifer::Query["users"])

# WITH RECURSIVE test AS (SELECT users.* FROM users )
Jennifer::Query["contacts"].with("test", Jennifer::Query["users"], true)