class Sequel::SQL::ComplexExpression

  1. lib/sequel/sql.rb
Parent: SQL

Represents a complex SQL expression, with a given operator and one or more attributes (which may also be ComplexExpressions, forming a tree). This class is the backbone of Sequel’s ruby expression DSL.

This is an abstract class that is not that useful by itself. The subclasses BooleanExpression, NumericExpression, and StringExpression define the behavior of the DSL via operators.

Methods

Public Class

  1. new

Public Instance

  1. args
  2. op
  3. sql_boolean
  4. sql_number
  5. sql_string

Constants

BITWISE_OPERATORS = [:&, :|, :^, :<<, :>>, :%]  

Bitwise mathematical operators used in NumericMethods
BOOLEAN_OPERATOR_METHODS = {:& => :AND, :| =>:OR}  

Hash of ruby operator symbols to SQL operators, used in BooleanMethods
CONSTANT_INVERSIONS = {Constants::TRUE=>Constants::FALSE, Constants::FALSE=>Constants::TRUE, Constants::NULL=>Constants::NOTNULL, Constants::NOTNULL=>Constants::NULL}  

A hash of the opposite for each constant, used for inverting constants.
CUSTOM_EXPRESSIONS = [:extract]  

Custom expressions that may have different syntax on different databases
EQUALITY_OPERATORS = [:'=', :'!=']  

Operators that check for equality
INEQUALITY_OPERATORS = [:<, :>, :<=, :>=]  

Inequality operators used in InequalityMethods
IN_OPERATORS = [:IN, :'NOT IN']  

Operators that use IN/NOT IN for inclusion/exclusion
IS_OPERATORS = [:IS, :'IS NOT']  

Operators that use IS, used for special casing to override literal true/false values
LIKE_OPERATORS = [:LIKE, :'NOT LIKE', :ILIKE, :'NOT ILIKE']  

Operators that do pattern matching via LIKE
MATHEMATICAL_OPERATORS = [:+, :-, :/, :*]  

Standard mathematical operators used in NumericMethods
N_ARITY_OPERATORS = [:AND, :OR, :'||'] + MATHEMATICAL_OPERATORS + BITWISE_OPERATORS  

Operator symbols that take one or more arguments
ONE_ARITY_OPERATORS = [:NOT, :NOOP, :'B~']  

Operator symbols that take only a single argument
OPERTATOR_INVERSIONS = {:AND => :OR, :OR => :AND, :< => :>=, :> => :<=, :<= => :>, :>= => :<, :'=' => :'!=' , :'!=' => :'=', :LIKE => :'NOT LIKE', :'NOT LIKE' => :LIKE, :~ => :'!~', :'!~' => :~, :IN => :'NOT IN', :'NOT IN' => :IN, :IS => :'IS NOT', :'IS NOT' => :IS, :'~*' => :'!~*', :'!~*' => :'~*', :NOT => :NOOP, :NOOP => :NOT, :ILIKE => :'NOT ILIKE', :'NOT ILIKE'=>:ILIKE}  

A hash of the opposite for each operator symbol, used for inverting objects.
REGEXP_OPERATORS = [:~, :'!~', :'~*', :'!~*']  

Operators that do pattern matching via regular expressions
TWO_ARITY_OPERATORS = EQUALITY_OPERATORS + INEQUALITY_OPERATORS + IS_OPERATORS + IN_OPERATORS + REGEXP_OPERATORS + LIKE_OPERATORS  

Operator symbols that take exactly two arguments

Attributes

args [R]

An array of args for this object
op [R]

The operator symbol for this object

Public Class methods

new (op, *args)

Set the operator symbol and arguments for this object to the ones given. Convert all args that are hashes or arrays of two element arrays to BooleanExpressions, other than the second arg for an IN/NOT IN operator. Raise an Error if the operator doesn’t allow boolean input and a boolean argument is given. Raise an Error if the wrong number of arguments for a given operator is used.

[show source] 
# File lib/sequel/sql.rb, line 202
def initialize(op, *args)
  orig_args = args
  args = args.map{|a| Sequel.condition_specifier?(a) ? SQL::BooleanExpression.from_value_pairs(a) : a}
  case op
  when *N_ARITY_OPERATORS
    raise(Error, "The #{op} operator requires at least 1 argument") unless args.length >= 1
    old_args = args
    args = []
    old_args.each{|a| a.is_a?(self.class) && a.op == op ? args.concat(a.args) : args.push(a)}
  when *TWO_ARITY_OPERATORS
    raise(Error, "The #{op} operator requires precisely 2 arguments") unless args.length == 2
    # With IN/NOT IN, even if the second argument is an array of two element arrays,
    # don't convert it into a boolean expression, since it's definitely being used
    # as a value list.
    args[1] = orig_args[1] if IN_OPERATORS.include?(op)
  when *ONE_ARITY_OPERATORS
    raise(Error, "The #{op} operator requires a single argument") unless args.length == 1
  when *CUSTOM_EXPRESSIONS
    # nothing
  else
    raise(Error, "Invalid operator #{op}")
  end
  @op = op
  @args = args
end

Public Instance methods

sql_boolean ()

Return a BooleanExpression with the same op and args.

[show source] 
# File lib/sequel/sql.rb, line 1127
def sql_boolean
  BooleanExpression.new(self.op, *self.args)
end
sql_number ()

Return a NumericExpression with the same op and args.

[show source] 
# File lib/sequel/sql.rb, line 1132
def sql_number
  NumericExpression.new(self.op, *self.args)
end
sql_string ()

Return a StringExpression with the same op and args.

[show source] 
# File lib/sequel/sql.rb, line 1137
def sql_string
  StringExpression.new(self.op, *self.args)
end