Class/Module Index [+]

Quicksearch

Sequel::SQL::ComplexExpression

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.

Constants

BITWISE_OPERATORS

Bitwise mathematical operators used in NumericMethods

BOOLEAN_OPERATOR_METHODS

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

CONSTANT_INVERSIONS

A hash of the opposite for each constant, used for inverting constants.

CUSTOM_EXPRESSIONS

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

Operators that use IN/NOT IN for inclusion/exclusion

IS_OPERATORS

Operators that use IS, used for special casing to override literal true/false values

LIKE_OPERATORS

Operators that do pattern matching via LIKE

MATHEMATICAL_OPERATORS

Standard mathematical operators used in NumericMethods

N_ARITY_OPERATORS

Operator symbols that take one or more arguments

ONE_ARITY_OPERATORS

Operator symbols that take only a single argument

OPERTATOR_INVERSIONS

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

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) click to toggle source

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.

# File lib/sequel/sql.rb, line 211
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() click to toggle source

Return a BooleanExpression with the same op and args.

# File lib/sequel/sql.rb, line 1126
def sql_boolean
  BooleanExpression.new(self.op, *self.args)
end
sql_number() click to toggle source

Return a NumericExpression with the same op and args.

# File lib/sequel/sql.rb, line 1131
def sql_number
  NumericExpression.new(self.op, *self.args)
end
sql_string() click to toggle source

Return a StringExpression with the same op and args.

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

[Validate]

Generated with the Darkfish Rdoc Generator 2.