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

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

new sql_boolean sql_number sql_string

### Included Modules

AliasMethods CastMethods OrderMethods 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} |  | A hash of the opposite for each operator symbol, used for inverting objects.
MATHEMATICAL_OPERATORS | = | [:+, :-, :/, :*] |  | Standard mathematical operators used in `NumericMethods`
BITWISE_OPERATORS | = | [:&, :|, :^, :<<, :>>, :%] |  | Bitwise mathematical operators used in `NumericMethods`
INEQUALITY_OPERATORS | = | [:<, :>, :<=, :>=] |  | Inequality operators used in `InequalityMethods`
BOOLEAN_OPERATOR_METHODS | = | {:& => :AND, :| =>:OR} |  | Hash of ruby operator symbols to SQL operators, used in `BooleanMethods`
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
TWO_ARITY_OPERATORS | = | [:'=', :'!=', :LIKE, :'NOT LIKE', \ :~, :'!~', :'~*', :'!~*', :ILIKE, :'NOT ILIKE'] + \ INEQUALITY_OPERATORS + IS_OPERATORS + IN_OPERATORS |  | Operator symbols that take exactly two arguments
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
CUSTOM_EXPRESSIONS | = | [:extract] |  | 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} |  | 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

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.

[Source]

         # File lib/sequel/sql.rb, line 180
    180:       def initialize(op, *args)
    181:         orig_args = args
    182:         args = args.map{|a| Sequel.condition_specifier?(a) ? SQL::BooleanExpression.from_value_pairs(a) : a}
    183:         case op
    184:         when *N_ARITY_OPERATORS
    185:           raise(Error, "The #{op} operator requires at least 1 argument") unless args.length >= 1
    186:           old_args = args
    187:           args = []
    188:           old_args.each{|a| a.is_a?(self.class) && a.op == op ? args.concat(a.args) : args.push(a)}
    189:         when *TWO_ARITY_OPERATORS
    190:           raise(Error, "The #{op} operator requires precisely 2 arguments") unless args.length == 2
    191:           # With IN/NOT IN, even if the second argument is an array of two element arrays,
    192:           # don't convert it into a boolean expression, since it's definitely being used
    193:           # as a value list.
    194:           args[1] = orig_args[1] if IN_OPERATORS.include?(op)
    195:         when *ONE_ARITY_OPERATORS
    196:           raise(Error, "The #{op} operator requires a single argument") unless args.length == 1
    197:         when *CUSTOM_EXPRESSIONS
    198:           # nothing
    199:         else
    200:           raise(Error, "Invalid operator #{op}")
    201:         end
    202:         @op = op
    203:         @args = args
    204:       end

### Public Instance methods

sql_boolean()

Return a BooleanExpression with the same op and args.

[Source]

          # File lib/sequel/sql.rb, line 1042
    1042:       def sql_boolean
    1043:         BooleanExpression.new(self.op, *self.args)
    1044:       end

sql_number()

Return a NumericExpression with the same op and args.

[Source]

          # File lib/sequel/sql.rb, line 1047
    1047:       def sql_number
    1048:         NumericExpression.new(self.op, *self.args)
    1049:       end

sql_string()

Return a StringExpression with the same op and args.

[Source]

          # File lib/sequel/sql.rb, line 1052
    1052:       def sql_string
    1053:         StringExpression.new(self.op, *self.args)
    1054:       end

[Validate]