sql_tree 0.0.1

data/lib/sql_tree/node/select_expression.rb

@@ -0,0 +1,45 @@
+module SQLTree::Node
+  
+  class SelectExpression < Base
+    
+    attr_accessor :expression, :variable
+    
+    def initialize(expression, variable = nil)
+      @expression = expression
+      @variable   = variable
+    end
+    
+    def to_sql
+      sql = @expression.to_sql
+      sql << " AS " << quote_var(@variable) if @variable
+      return sql
+    end
+    
+    def self.parse(tokens)
+      if tokens.peek == SQLTree::Token::MULTIPLY
+        tokens.consume(SQLTree::Token::MULTIPLY)
+        return SQLTree::Node::ALL_FIELDS
+      else
+        expression = SQLTree::Node::Expression.parse(tokens)
+        expr = SQLTree::Node::SelectExpression.new(expression)
+        if tokens.peek == SQLTree::Token::AS
+          tokens.consume(SQLTree::Token::AS)
+          expr.variable = SQLTree::Node::Variable.parse(tokens).name
+        end
+        return expr
+      end
+    end
+    
+    def ==(other)
+      other.expression == self.expression && other.variable == self.variable
+    end    
+  end
+  
+  class AllFieldsExpression < Expression
+    def to_sql
+      '*'
+    end
+  end
+  
+  ALL_FIELDS = AllFieldsExpression.new
+end

data/lib/sql_tree/node/select_query.rb

@@ -0,0 +1,78 @@
+module SQLTree::Node
+  
+  class SelectQuery < Base
+  
+    attr_accessor :distinct, :select, :from, :where, :group_by, :having, :order_by, :limit
+  
+    def initialize
+      @distinct = false
+      @select   = []
+    end
+  
+    def to_sql
+      raise "At least one SELECT expression is required" if self.select.empty?
+      sql = (self.distinct) ? "SELECT DISTINCT " : "SELECT "
+      sql << select.map { |s| s.to_sql }.join(', ')
+      sql << " FROM " << from.map { |f| f.to_sql }.join(', ')
+      sql << " WHERE " << where.to_sql if where
+      return sql
+    end
+  
+    # Uses the provided initialized parser to parse a SELECT query.
+    def self.parse(tokens)
+      select_node = self.new
+      tokens.consume(SQLTree::Token::SELECT)
+
+      if tokens.peek == SQLTree::Token::DISTINCT
+        tokens.consume(SQLTree::Token::DISTINCT)
+        select_node.distinct = true
+      end
+
+      select_node.select = self.parse_select_clause(tokens)
+      select_node.from   = self.parse_from_clause(tokens)   if tokens.peek == SQLTree::Token::FROM
+      select_node.where  = self.parse_where_clause(tokens)  if tokens.peek == SQLTree::Token::WHERE
+
+      return select_node
+    end
+    
+    def self.parse_select_clause(tokens)
+      expressions = [SQLTree::Node::SelectExpression.parse(tokens)]
+      while tokens.peek == SQLTree::Token::COMMA
+        tokens.consume(SQLTree::Token::COMMA)
+        expressions << SQLTree::Node::SelectExpression.parse(tokens)
+      end
+      return expressions
+    end
+    
+    def self.parse_from_clause(tokens)
+      tokens.consume(SQLTree::Token::FROM)
+      sources = [SQLTree::Node::Source.parse(tokens)]
+      while tokens.peek == SQLTree::Token::COMMA
+        tokens.consume(SQLTree::Token::COMMA)
+        sources << SQLTree::Node::Source.parse(tokens)
+      end
+      return sources
+    end
+    
+    def self.parse_where_clause(tokens)
+      tokens.consume(SQLTree::Token::WHERE)
+      Expression.parse(tokens)
+    end
+
+    def self.parse_group_clause(tokens)
+      # TODO: implement me
+    end
+
+    def self.parse_having_clause(tokens)
+      # TODO: implement me
+    end
+    
+    def self.parse_order_clause(tokens)
+      # TODO: implement me
+    end
+
+    def self.parse_limit_clause(tokens)
+      # TODO: implement me
+    end
+  end
+end

data/lib/sql_tree/node/source.rb

@@ -0,0 +1,37 @@
+module SQLTree::Node
+  
+  class Source < Base
+    
+    attr_accessor :table_reference, :joins
+    
+    def initialize(table_reference, joins = [])
+      @table_reference, @joins = table_reference, joins
+    end
+    
+    def table
+      table_reference.table
+    end
+
+    def table_alias
+      table_reference.table_alias
+    end
+  
+    def to_sql
+      sql = table_reference.to_sql
+      sql << ' ' << joins.map { |j| j.to_sql }.join(' ') if joins.any?
+      return sql
+    end
+
+    def ==(other)
+      other.table_reference = self.table_reference && other.joins == self.joins
+    end
+
+    def self.parse(tokens)
+      source = self.new(SQLTree::Node::TableReference.parse(tokens))
+      while tokens.peek && tokens.peek.join?
+        source.joins << Join.parse(tokens)
+      end
+      return source
+    end
+  end 
+end

data/lib/sql_tree/node/table_reference.rb

@@ -0,0 +1,34 @@
+module SQLTree::Node
+
+  class TableReference < Base
+
+    attr_accessor :table, :table_alias
+
+    def initialize(table, table_alias = nil)
+      @table, @table_alias = table, table_alias
+    end
+
+    def to_sql
+      sql = quote_var(table)
+      sql << " AS " << quote_var(table_alias) if table_alias
+      return sql
+    end
+
+    def ==(other)
+      other.table = self.table && other.table_alias == self.table_alias
+    end
+    
+    def self.parse(tokens)
+      if SQLTree::Token::Variable === tokens.next
+        table_reference = self.new(tokens.current.literal)
+        if tokens.peek == SQLTree::Token::AS || SQLTree::Token::Variable === tokens.peek
+          tokens.consume(SQLTree::Token::AS) if tokens.peek == SQLTree::Token::AS
+          table_reference.table_alias = SQLTree::Node::Variable.parse(tokens).name
+        end
+        return table_reference
+      else 
+        raise SQLTree::Parser::UnexpectedToken.new(tokens.current)
+      end
+    end
+  end
+end

data/lib/sql_tree/node/value.rb

@@ -0,0 +1,37 @@
+module SQLTree::Node
+  
+  class Value < Base
+    attr_accessor :value
+
+    def initialize(value)
+      @value = value
+    end
+  
+    def to_sql
+      case value
+      when nil    then 'NULL'
+      when String then quote_str(@value)
+      else             @value.to_s
+      end
+    end
+    
+    def to_tree
+      @value
+    end
+    
+    def ==(other)
+      other.kind_of?(self.class) && other.value == self.value
+    end
+    
+    def self.parse(tokens)
+      case tokens.next
+      when SQLTree::Token::String, SQLTree::Token::Number
+        SQLTree::Node::Value.new(tokens.current.literal)
+      when SQLTree::Token::NULL
+        SQLTree::Node::Value.new(nil)
+      else
+        raise SQLTree::Parser::UnexpectedToken.new(tokens.current, :literal)
+      end      
+    end
+  end
+end

data/lib/sql_tree/node/variable.rb

@@ -0,0 +1,35 @@
+module SQLTree::Node
+  
+  class Variable < Base
+
+    attr_accessor :name
+
+    def initialize(name)
+      @name = name
+    end
+  
+    def to_sql
+      quote_var(@name)
+    end
+    
+    def to_tree
+      @name.to_sym
+    end
+    
+    def ==(other)
+      other.name == self.name
+    end
+
+    def self.parse(tokens)
+      if SQLTree::Token::Variable === tokens.peek
+        if tokens.peek(2) == SQLTree::Token::DOT
+          SQLTree::Node::Field.parse(tokens)
+        else
+          self.new(tokens.next.literal)
+        end
+      else
+        raise SQLTree::Parser::UnexpectedToken.new(tokens.peek, :variable)
+      end
+    end
+  end
+end

data/lib/sql_tree/parser.rb

@@ -0,0 +1,63 @@
+class SQLTree::Parser
+  
+  class UnexpectedToken < StandardError
+    
+    attr_reader :expected_token, :actual_token
+    
+    def initialize(actual_token, expected_token = nil)
+      @expected_token, @actual_token = expected_token, actual_token
+      message =  "Unexpected token: found #{actual_token.inspect}"
+      message << ", but expected #{expected_token.inspect}" if expected_token
+      message << '!'
+      super(message)
+    end
+  end  
+
+  def self.parse(sql_string, options = {})
+    self.new(sql_string, options).parse!
+  end
+
+  attr_reader :options
+
+  def initialize(tokens, options)
+    if tokens.kind_of?(String)
+      @tokens = SQLTree::Tokenizer.new.tokenize(tokens)
+    else
+      @tokens = tokens
+    end
+    @options = options
+  end
+
+  def current
+    @current_token
+  end
+  
+  def next
+    @current_token = @tokens.shift
+  end
+  
+  def consume(*checks)
+    checks.each do |check|
+      raise UnexpectedToken.new(self.current, check) unless check == self.next
+    end
+  end
+  
+  def peek(distance = 1)
+    @tokens[distance - 1]
+  end
+  
+  def peek_tokens(amount)
+    @tokens[0, amount]
+  end
+
+  def debug
+    puts @tokens.inspect
+  end
+  
+  def parse!
+    case self.peek
+    when SQLTree::Token::SELECT then SQLTree::Node::SelectQuery.parse(self)
+    else raise UnexpectedToken.new(self.peek)
+    end
+  end
+end

data/lib/sql_tree/token.rb

@@ -0,0 +1,131 @@
+# The <tt>SQLTree::Token</tt> class is the base class for every token
+# in the SQL language. Actual tokens are represented by a subclass.
+#
+# Tokens are produced by the <tt>SQLTree::Tokenizer</tt> from a string
+# and are consumed by the <tt>SQLTree::Parser</tt> to construct an
+# abstract syntax tree for the query that is being parsed.
+class SQLTree::Token
+
+  # For some tokens, the encountered literal value is important
+  # during the parsing phase (e.g. strings and variable names).
+  # Therefore, the literal value encountered that represented the 
+  # token in the original SQL query string is stored.
+  attr_accessor :literal
+
+  # Creates a token instance with a given literal representation.
+  #
+  # <tt>literal<tt>:: The literal string value that was encountered 
+  #                   while tokenizing.
+  def initialize(literal)
+    @literal = literal
+  end
+  
+  # Compares two tokens. Tokens are considered equal when they are
+  # instances of the same class, i.e. do literal is not used.
+  def ==(other)
+    other.class == self.class
+  end
+  
+  def inspect # :nodoc:
+    literal
+  end
+  
+  def join?
+    [SQLTree::Token::JOIN, SQLTree::Token::LEFT, SQLTree::Token::RIGHT, 
+      SQLTree::Token::INNER, SQLTree::Token::OUTER, SQLTree::Token::NATURAL, 
+      SQLTree::Token::FULL].include?(self)
+  end
+  
+  ###################################################################
+  # DYNAMIC TOKEN TYPES
+  ###################################################################
+
+  # The <tt>SQLTree::Token::Value</tt> class is the base class for
+  # every dynamic token. A dynamic token is a token for which the 
+  # literal value used remains impoirtant during parsing.
+  class Value < SQLTree::Token
+    
+    def inspect # :nodoc:
+      "#<#{self.class.name.split('::').last}:#{literal.inspect}>"
+    end
+    
+    # Compares two tokens. For values, the literal encountered value 
+    # of the token is also taken into account besides the class.
+    def ==(other)
+      other.class == self.class && @literal == other.literal
+    end
+  end
+  
+  # The <tt>SQLTree::Token::Variable</tt> class represents SQL
+  # variables. The variable name is stored in the literal as string, 
+  # without quotes if they were present.
+  class Variable < SQLTree::Token::Value
+  end
+
+  # The <tt>SQLTree::Token::String</tt> class represents strings.
+  # The actual string is stored in the literal as string without quotes.
+  class String < SQLTree::Token::Value
+  end
+
+  # The <tt>SQLTree::Token::Keyword</tt> class represents numbers.
+  # The actual number is stored as an integer or float in the token's
+  # literal.
+  class Number < SQLTree::Token::Value
+  end
+  
+  ###################################################################
+  # STATIC TOKEN TYPES
+  ###################################################################
+
+  # The <tt>SQLTree::Token::Keyword</tt> class represents reserved SQL
+  # keywords. These keywords are used to structure the query. Keywords
+  # are static, i.e. the literal value is not important during the
+  # parsing process.
+  class Keyword < SQLTree::Token
+    def inspect # :nodoc:
+      ":#{literal.gsub(/ /, '_').downcase}"
+    end
+  end
+
+  # The <tt>SQLTree::Token::Operator</tt> class represents logical and
+  # arithmetic operators in SQL. These tokens are static, i.e. the literal
+  # value is not important during the parsing process.
+  class Operator < SQLTree::Token
+    def inspect # :nodoc:
+      OPERATORS_HASH[literal].inspect
+    end
+  end
+
+  ###################################################################
+  # STATIC TOKEN CONSTANTS
+  ###################################################################
+
+  # Create some static token classes and a single instance of them
+  LPAREN = Class.new(SQLTree::Token).new('(')
+  RPAREN = Class.new(SQLTree::Token).new(')')
+  DOT    = Class.new(SQLTree::Token).new('.')
+  COMMA  = Class.new(SQLTree::Token).new(',')
+
+  # A list of all the SQL reserverd keywords.
+  KEYWORDS = %w{SELECT FROM WHERE GOUP HAVING ORDER DISTINCT LEFT RIGHT INNER FULL OUTER NATURAL JOIN USING 
+                AND OR NOT AS ON IS NULL BY LIKE ILIKE BETWEEN IN}
+
+  # Create a token for all the reserved keywords in SQL
+  KEYWORDS.each { |kw| const_set(kw, Class.new(SQLTree::Token::Keyword).new(kw)) }
+
+  # A list of keywords that aways occur in fixed combinations. Register these as separate keywords.
+  KEYWORD_COMBINATIONS = [%w{IS NOT}, %w{NOT LIKE}, %w{NOT BETWEEN}, %w{NOT ILIKE}]
+  KEYWORD_COMBINATIONS.each { |kw| const_set(kw.join('_'), Class.new(SQLTree::Token::Keyword).new(kw.join(' '))) }
+
+  ARITHMETHIC_OPERATORS_HASH = { '+' => :plus, '-' => :minus, '*' => :multiply, '/' => :divide, '%' => :modulo }
+  COMPARISON_OPERATORS_HASH  = { '=' => :eq, '!=' => :ne, '<>' => :ne, '>' => :gt, '<' => :lt, '>=' => :gte, '<=' => :lte }
+
+  # Register a token class and single instance for every token.
+  OPERATORS_HASH = ARITHMETHIC_OPERATORS_HASH.merge(COMPARISON_OPERATORS_HASH)
+  OPERATORS_HASH.each_pair do |literal, symbol|
+    self.const_set(symbol.to_s.upcase, Class.new(SQLTree::Token::Operator).new(literal)) unless self.const_defined?(symbol.to_s.upcase)
+  end
+  
+  COMPARISON_OPERATORS = COMPARISON_OPERATORS_HASH.map { |(literal, symbol)| const_get(symbol.to_s.upcase) } +
+    [SQLTree::Token::IN, SQLTree::Token::IS, SQLTree::Token::BETWEEN, SQLTree::Token::LIKE, SQLTree::Token::ILIKE, SQLTree::Token::NOT]
+end