Class | Sequel::SQL::ComplexExpression
In: | lib/sequel/sql.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

### 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 + BITWISE_OPERATORS + IS_OPERATORS + IN_OPERATORS |  | Operator symbols that take exactly two arguments
N_ARITY_OPERATORS | = | [:AND, :OR, :'||'] + MATHEMATICAL_OPERATORS |  | Operator symbols that take one or more arguments
ONE_ARITY_OPERATORS | = | [:NOT, :NOOP, :'B~'] |  | Operator symbols that take only a single argument

### 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 166
    166:       def initialize(op, *args)
    167:         orig_args = args
    168:         args = args.map{|a| Sequel.condition_specifier?(a) ? SQL::BooleanExpression.from_value_pairs(a) : a}
    169:         case op
    170:         when *N_ARITY_OPERATORS
    171:           raise(Error, "The #{op} operator requires at least 1 argument") unless args.length >= 1
    172:           old_args = args
    173:           args = []
    174:           old_args.each{|a| a.is_a?(self.class) && a.op == op ? args.concat(a.args) : args.push(a)}
    175:         when *TWO_ARITY_OPERATORS
    176:           raise(Error, "The #{op} operator requires precisely 2 arguments") unless args.length == 2
    177:           # With IN/NOT IN, even if the second argument is an array of two element arrays,
    178:           # don't convert it into a boolean expression, since it's definitely being used
    179:           # as a value list.
    180:           args[1] = orig_args[1] if IN_OPERATORS.include?(op)
    181:         when *ONE_ARITY_OPERATORS
    182:           raise(Error, "The #{op} operator requires a single argument") unless args.length == 1
    183:         else
    184:           raise(Error, "Invalid operator #{op}")
    185:         end
    186:         @op = op
    187:         @args = args
    188:       end

[Validate]