Class: Sequel::SQL::ComplexExpression

Inherits:
Expression show all
Defined in:
lib/sequel_core/sql.rb

Overview

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 the blockless filter support in Sequel.

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.

Constant Summary collapse

OPERTATOR_INVERSIONS =

A hash of the opposite for each operator symbol, used for inverting objects.

{: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}
MATHEMATICAL_OPERATORS =

Mathematical Operators used in NumericMethods

[:+, :-, :/, :*]
INEQUALITY_OPERATORS =

Inequality Operators used in InequalityMethods

[:<, :>, :<=, :>=]
BOOLEAN_OPERATOR_METHODS =

Hash of ruby operator symbols to SQL operators, used in BooleanMethods

{:& => :AND, :| =>:OR}
TWO_ARITY_OPERATORS =

Operator symbols that take exactly two arguments

[:'=', :'!=', :IS, :'IS NOT', :LIKE, :'NOT LIKE', \
:~, :'!~', :'~*', :'!~*', :IN, :'NOT IN', :ILIKE, :'NOT ILIKE'] + INEQUALITY_OPERATORS
N_ARITY_OPERATORS =

Operator symbols that take one or more arguments

[:AND, :OR, :'||'] + MATHEMATICAL_OPERATORS
ONE_ARITY_OPERATORS =

Operator symbols that take one argument

[:NOT, :NOOP]

Constants included from ColumnMethods

Sequel::SQL::ColumnMethods::AS, Sequel::SQL::ColumnMethods::ASC, Sequel::SQL::ColumnMethods::DESC

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods inherited from Expression

#lit

Methods included from ColumnMethods

#as, #asc, #cast_as, #desc

Constructor Details

#initialize(op, *args) ⇒ ComplexExpression

Set the operator symbol and arguments for this object to the ones given. Convert all args that are hashes or arrays with all two pairs to ComplexExpressions. 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.



139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/sequel_core/sql.rb', line 139

def initialize(op, *args)
  args.collect! do |a|
    case a
    when Hash
      a.sql_expr
    when Array
      a.all_two_pairs? ? a.sql_expr : a
    else
      a
    end
  end
  case op
  when *N_ARITY_OPERATORS
    raise(Error, "The #{op} operator requires at least 1 argument") unless args.length >= 1
  when *TWO_ARITY_OPERATORS
    raise(Error, "The #{op} operator requires precisely 2 arguments") unless args.length == 2
  when *ONE_ARITY_OPERATORS
    raise(Error, "The #{op} operator requires a single argument") unless args.length == 1
  else
    raise(Error, "Invalid operator #{op}")
  end
  @op = op
  @args = args
end

Instance Attribute Details

#args ⇒ Object (readonly)

An array of args for this object



130
131
132
 
# File 'lib/sequel_core/sql.rb', line 130

def args
  @args
end

#op ⇒ Object (readonly)

The operator symbol for this object



133
134
135
 
# File 'lib/sequel_core/sql.rb', line 133

def op
  @op
end

Instance Method Details

#to_s(ds) ⇒ Object

Delegate the creation of the resulting SQL to the given dataset, since it may be database dependent.



166
167
168
 
# File 'lib/sequel_core/sql.rb', line 166

def to_s(ds)
  ds.complex_expression_sql(@op, @args)
end