Class: SQLTree::Node::ComparisonExpression

Inherits:
Expression show all
Defined in:
lib/sql_tree/node/expression.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Expression

parse_atomic

Methods inherited from Base

[], #inspect, #quote_str, #quote_var

Constructor Details

#initialize(operator, lhs, rhs) ⇒ ComparisonExpression

Returns a new instance of ComparisonExpression.



90
91
92
93
94
 
# File 'lib/sql_tree/node/expression.rb', line 90

def initialize(operator, lhs, rhs)
  @lhs = lhs
  @rhs = rhs
  @operator = operator
end

Instance Attribute Details

#lhs ⇒ Object

Returns the value of attribute lhs.



88
89
90
 
# File 'lib/sql_tree/node/expression.rb', line 88

def lhs
  @lhs
end

#operator ⇒ Object

Returns the value of attribute operator.



88
89
90
 
# File 'lib/sql_tree/node/expression.rb', line 88

def operator
  @operator
end

#rhs ⇒ Object

Returns the value of attribute rhs.



88
89
90
 
# File 'lib/sql_tree/node/expression.rb', line 88

def rhs
  @rhs
end

Class Method Details

.parse(tokens) ⇒ Object 



121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/sql_tree/node/expression.rb', line 121

def self.parse(tokens)
  lhs = SQLTree::Node::ArithmeticExpression.parse(tokens)
  while SQLTree::Token::COMPARISON_OPERATORS.include?(tokens.peek)
    comparison_operator = parse_comparison_operator(tokens)
    rhs = ['IN', 'NOT IN'].include?(comparison_operator) ?
            SQLTree::Node::SetExpression.parse(tokens)   :
            SQLTree::Node::ArithmeticExpression.parse(tokens)

    lhs = self.new(comparison_operator, lhs, rhs)
  end
  return lhs
end

.parse_comparison_operator(tokens) ⇒ Object 



100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/sql_tree/node/expression.rb', line 100

def self.parse_comparison_operator(tokens)
  operator_token = tokens.next
  if SQLTree::Token::IS === operator_token
    if SQLTree::Token::NOT === tokens.peek
      tokens.consume(SQLTree::Token::NOT)
      'IS NOT'
    else
      'IS'
    end
  elsif SQLTree::Token::NOT === operator_token
    case tokens.peek
    when SQLTree::Token::LIKE, SQLTree::Token::ILIKE, SQLTree::Token::BETWEEN, SQLTree::Token::IN
      "NOT #{tokens.next.literal.upcase}"
    else
      raise SQLTree::Parser::UnexpectedToken.new(tokens.peek)
    end
  else
    operator_token.literal
  end
end

Instance Method Details

#to_sql ⇒ Object 



96
97
98
 
# File 'lib/sql_tree/node/expression.rb', line 96

def to_sql
  "(#{@lhs.to_sql} #{@operator} #{@rhs.to_sql})"
end