Class Sequel::SQL::ComplexExpression
In: lib/sequel/extensions/eval_inspect.rb
lib/sequel/sql.rb
Parent: Object

Represents a 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

Included Modules

AliasMethods CastMethods OrderMethods PatternMatchMethods SubscriptMethods

Constants

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}.freeze   A hash of the opposite for each operator symbol, used for inverting objects.
MATHEMATICAL_OPERATORS = [:+, :-, :/, :*, :**].freeze   Standard mathematical operators used in NumericMethods
BITWISE_OPERATORS = [:&, :|, :^, :<<, :>>, :%].freeze   Bitwise mathematical operators used in BitwiseMethods
EQUALITY_OPERATORS = [:'=', :'!='].freeze   Operators that check for equality
INEQUALITY_OPERATORS = [:<, :>, :<=, :>=].freeze   Inequality operators used in InequalityMethods
BOOLEAN_OPERATOR_METHODS = {:& => :AND, :| =>:OR}.freeze   Hash of ruby operator symbols to SQL operators, used in BooleanMethods
IN_OPERATORS = [:IN, :'NOT IN'].freeze   Operators that use IN/NOT IN for inclusion/exclusion
IS_OPERATORS = [:IS, :'IS NOT'].freeze   Operators that use IS, used for special casing to override literal true/false values
REGEXP_OPERATORS = [:~, :'!~', :'~*', :'!~*'].freeze   Operators that do pattern matching via regular expressions
LIKE_OPERATORS = [:LIKE, :'NOT LIKE', :ILIKE, :'NOT ILIKE'].freeze   Operators that do pattern matching via LIKE
TWO_ARITY_OPERATORS = (EQUALITY_OPERATORS + INEQUALITY_OPERATORS + IS_OPERATORS + IN_OPERATORS + REGEXP_OPERATORS + LIKE_OPERATORS + [:**]).freeze   Operator symbols that take exactly two arguments
N_ARITY_OPERATORS = ([:AND, :OR, :'||'] + MATHEMATICAL_OPERATORS + BITWISE_OPERATORS - [:**]).freeze   Operator symbols that take one or more arguments
ASSOCIATIVE_OPERATORS = [:AND, :OR, :'||', :+, :*, :&, :|].freeze   Operator symbols that are associative
ONE_ARITY_OPERATORS = [:NOT, :NOOP, :'B~'].freeze   Operator symbols that take only a single argument
CUSTOM_EXPRESSIONS = [:extract].freeze   Custom expressions that may have different syntax on different databases
CONSTANT_INVERSIONS = {Constants::TRUE=>Constants::FALSE, Constants::FALSE=>Constants::TRUE, Constants::NULL=>Constants::NOTNULL, Constants::NOTNULL=>Constants::NULL}.freeze   A hash of the opposite for each constant, used for inverting constants.

Attributes

args  [R]  An array of args for this object
op  [R]  The operator symbol for this object

Public Class methods

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.

[Source]

     # File lib/sequel/sql.rb, line 200
200:       def initialize(op, *args)
201:         orig_args = args
202:         args = args.map{|a| Sequel.condition_specifier?(a) ? SQL::BooleanExpression.from_value_pairs(a) : a}
203:         case op
204:         when *N_ARITY_OPERATORS
205:           raise(Error, "The #{op} operator requires at least 1 argument") unless args.length >= 1
206:           args.map!{|a| a.is_a?(self.class) && a.op == :NOOP ? a.args.first : a}
207:           if ASSOCIATIVE_OPERATORS.include?(op)
208:             old_args = args
209:             args = []
210:             old_args.each{|a| a.is_a?(self.class) && a.op == op ? args.concat(a.args) : args.push(a)}
211:           end
212:         when *TWO_ARITY_OPERATORS
213:           raise(Error, "The #{op} operator requires precisely 2 arguments") unless args.length == 2
214:           # With IN/NOT IN, even if the second argument is an array of two element arrays,
215:           # don't convert it into a boolean expression, since it's definitely being used
216:           # as a value list.
217:           args[1] = orig_args[1] if IN_OPERATORS.include?(op)
218:         when *ONE_ARITY_OPERATORS
219:           raise(Error, "The #{op} operator requires a single argument") unless args.length == 1
220:         when *CUSTOM_EXPRESSIONS
221:           # nothing
222:         else
223:           raise(Error, "Invalid operator #{op}")
224:         end
225:         @op = op
226:         @args = args.freeze
227:         freeze
228:       end

Public Instance methods

Return a BooleanExpression with the same op and args.

[Source]

      # File lib/sequel/sql.rb, line 1210
1210:       def sql_boolean
1211:         BooleanExpression.new(op, *args)
1212:       end

Return a NumericExpression with the same op and args.

[Source]

      # File lib/sequel/sql.rb, line 1215
1215:       def sql_number
1216:         NumericExpression.new(op, *args)
1217:       end

Return a StringExpression with the same op and args.

[Source]

      # File lib/sequel/sql.rb, line 1220
1220:       def sql_string
1221:         StringExpression.new(op, *args)
1222:       end

[Validate]