class Jennifer::QueryBuilder::ExpressionBuilder

• Jennifer::QueryBuilder::ExpressionBuilder
• Reference
• Object

Overview

Stands for creating criteria for the query.

This class provides straight forward way to define criteria and a bit (pretty huge one) of metaprogramming.

You can use standard method #c to create criteria for current table or for any other (passing it's name as a 2nd argument):

Jennifer::Query["contacts"].join("addresses") { c("contact_id") == c("id", "contacts") }

Also you can use "magic" underscored methods to specify current table fields putting "_" before a name:

Jennifer::Query["contacts"].join("addresses") { _contact_id == c("id", "contacts") }

Obviously, you also can specify same way table name for the field. Just put "__" (double underscore) between table name and field name as well.

Jennifer::Query["contacts"].join("addresses") { _contact_id == _contacts__id }

Because of double underscore between symbols between field and table you can safely reference tables with "_".

Jennifer::Query["facebook_profiles"].join("addresses") { _profile_id == _facebook_profiles__id }

Defined in:

Constructors

• .new(table, relation = nil, query = nil)

Instance Method Summary

• #abs(arg0)

  Create "AbsFunction" function.

• #all(query : Query)

  Creates ALL SQL statement.

• #and(first_condition, second_condition, *conditions)

  Combines given first_condition, second_condition and all other conditions by AND operator.

• #and(conditions : Array)

  Combines given array of conditions by AND operator.

• #any(query : Query)

  Creates ANY SQL statement.

• #avg(arg0)

  Create "AvgFunction" function.

• #c(name : String, table_name : String = @table, relation : String? = nil)

  Creates criterion for current table by given name name.

• #c_with_relation(name : String, relation : String)

  Creates criterion by given name name for the relation.

• #cast(expression, type : String)

  Cases expression to the given type.

• #ceil(arg0)

  Create "CeilFunction" function.

• #clone

  Returns a copy of self with all instance variables cloned.

• #coalesce(*args)

  Create :CoalesceFunction function.

• #concat(*args)

  Create "ConcatFunction" function.

• #concat_ws(*args)

  Create "ConcatWsFunction" function.

• #count(*args)

  Create "CountFunction" function.

• #current_date

  Create "CurrentDateFunction" function.

• #current_time

  Create "CurrentTimeFunction" function.

• #current_timestamp

  Create "CurrentTimestampFunction" function.

• #floor(arg0)

  Create "FloorFunction" function.

• #g(condition)

  Creates grouping for the given condition.

• #group(condition)

  Alias for #g.

• #lower(arg0)

  Create "LowerFunction" function.

• #max(arg0)

  Create "MaxFunction" function.

• #min(arg0)

  Create "MinFunction" function.

• #now

  Create "NowFunction" function.

• #or(first_condition, second_condition, *conditions)

  Combines given first_condition, second_condition and all other conditions by OR operator.

• #or(conditions : Array)

  Combines given array of conditions by OR operator.

• #primary

  Query's model primary field criterion.

• #query : Query?
• #query=(query : Query?)
• #relation : String?
• #round(*args)

  Create "RoundFunction" function.

• #sql(query : String, args : Array(DBAny) = [] of DBAny, use_brackets : Bool = true)

  Adds plain query query.

• #sql(query : String, use_brackets : Bool = true)

  Adds plain query query.

• #star(table : String = @table)

  Creates select star for table.

• #sum(arg0)

  Create "SumFunction" function.

• #table : String
• #upper(arg0)

  Create "UpperFunction" function.

• #values(field : Symbol)

  Returns reference to the field in upsert operation.

• #xor(first_condition, second_condition, *conditions)

  Combines given first_condition, second_condition and all other conditions by XOR operator.

• #xor(conditions : Array)

  Combines given array of conditions by XOR operator.

Macro Summary

• method_missing(call)

Constructor Detail

Instance Method Detail

nested_query = Jennifer::Query["contacts"].select(:age).where { _tag == "phone" }
Jennifer::Query["contacts"].where { _age > all(nested_query) }

User.all.where { and(_name.like("%on"), _age > 3) }
# WHERE (users.name LIKE '%on' AND users.age > 3)

User.all.where { and([_name.like("%on"), _age > 3]) }
# WHERE (users.name LIKE '%on' AND users.age > 3)

nested_query = Jennifer::Query["addresses"].where { _main }.select(:contact_id)
Jennifer::Query["contacts"].where { _id == any(nested_query) }

Jennifer::Query["users"].where { c("id") } # => "users"."id"

Jennifer::Query[""].select { [cast(sql("'100'", false), "integer").alias("field")] }
# => SELECT CAST('100' AS INTEGER) AS field

Jennifer::Query["users"].where { c1 & g(c2 | c3) }

User.all.where { or(_name.like("%on"), _age > 3) }
# => WHERE (users.name LIKE '%on' OR users.age > 3)

User.all.where { or([_name.like("%on"), _age > 3]) }
# WHERE (users.name LIKE '%on' OR users.age > 3)

Jennifer::Query[""].select { [sql("1", false)] } # => SELECT 1
Jennifer::Query[""].select { [sql("1")] }        # => SELECT (1)
Jennifer::Query[""].select { [sql("TIMESTAMP %s AT TIME ZONE %s", ["2001-02-16 20:38:40", "MST"], false)] }
# => SELECT TIMESTAMP '2001-02-16 20:38:40' AT TIME ZONE 'MST';

Jennifer::Query[""].select { [sql("1", false)] } # => SELECT 1
Jennifer::Query[""].select { [sql("1")] }        # => SELECT (1)
Jennifer::Query[""].select { [sql("TIMESTAMP %s AT TIME ZONE %s", ["2001-02-16 20:38:40", "MST"], false)] }
# => SELECT TIMESTAMP '2001-02-16 20:38:40' AT TIME ZONE 'MST';

Jennifer::Query["users"].select { [star("contacts")] } # => SELECT contacts.* FROM users

Jennifer::Query["orders"].upsert(%w(name uid price), [["Order 1", 123, 3]], %w(uid)) do
  {:price => values(:price) + _price}
end

User.all.where { xor(_name.like("%on"), _age > 3) }
# => WHERE (users.name LIKE '%on' XOR users.age > 3)

User.all.where { xor([_name.like("%on"), _age > 3]) }
# WHERE (users.name LIKE '%on' XOR users.age > 3)

Macro Detail