sql_tree 0.1.0 → 0.1.1

data/lib/sql_tree/node/insert_query.rb

@@ -2,26 +2,26 @@ module SQLTree::Node
 
   class InsertQuery < Base
 
-    attr_accessor :table, :fields, :values
+    child :table
+    
+    child :fields
+    
+    child :values
 
     def initialize(table, fields = nil, values = [])
       @table, @fields, @values  = table, fields, values
     end
 
-    def to_sql
-      sql = "INSERT INTO #{self.quote_var(table)} "
-      sql << '(' + fields.map { |f| f.to_sql }.join(', ') + ') ' if fields
-      sql << 'VALUES (' + values.map { |v| v.to_sql }.join(', ') + ')'
+    def to_sql(options = {})
+      sql = "INSERT INTO #{table.to_sql(options)} "
+      sql << '(' + fields.map { |f| f.to_sql(options) }.join(', ') + ') ' if fields
+      sql << 'VALUES (' + values.map { |v| v.to_sql(options) }.join(', ') + ')'
       sql
     end
     
     def self.parse_field_list(tokens)
       tokens.consume(SQLTree::Token::LPAREN)
-      fields = [SQLTree::Node::Variable.parse(tokens)]
-      while tokens.peek == SQLTree::Token::COMMA
-        tokens.consume(SQLTree::Token::COMMA)
-        fields << SQLTree::Node::Variable.parse(tokens)
-      end
+      fields = parse_list(tokens, SQLTree::Node::Expression::Field)
       tokens.consume(SQLTree::Token::RPAREN)
       return fields
     end
@@ -29,11 +29,7 @@ module SQLTree::Node
     def self.parse_value_list(tokens)
       tokens.consume(SQLTree::Token::VALUES)
       tokens.consume(SQLTree::Token::LPAREN)
-      values = [SQLTree::Node::Expression.parse(tokens)]
-      while tokens.peek == SQLTree::Token::COMMA
-        tokens.consume(SQLTree::Token::COMMA)
-        values << SQLTree::Node::Expression.parse(tokens)
-      end
+      values = parse_list(tokens)
       tokens.consume(SQLTree::Token::RPAREN)
       return values
     end
@@ -41,9 +37,9 @@ module SQLTree::Node
     def self.parse(tokens)
       tokens.consume(SQLTree::Token::INSERT)
       tokens.consume(SQLTree::Token::INTO)
-      insert_query = self.new(SQLTree::Node::Variable.parse(tokens).name)
+      insert_query = self.new(SQLTree::Node::TableReference.parse(tokens))
 
-      insert_query.fields = self.parse_field_list(tokens) if tokens.peek == SQLTree::Token::LPAREN
+      insert_query.fields = self.parse_field_list(tokens) if SQLTree::Token::LPAREN === tokens.peek
       insert_query.values = self.parse_value_list(tokens)
       return insert_query
     end

data/lib/sql_tree/node/join.rb

@@ -2,16 +2,18 @@ module SQLTree::Node
 
   class Join < Base
 
-    attr_accessor :join_type, :table_reference, :join_expression
+    leaf :join_type
+    child :table_reference
+    child :join_expression
 
     def initialize(values = {})
       values.each { |key, value| self.send(:"#{key}=", value) }
     end
 
-    def to_sql
+    def to_sql(options = {})
       join_sql = join_type ? "#{join_type.to_s.upcase} " : ""
-      join_sql << "JOIN #{table_reference.to_sql} "
-      join_sql << "ON #{join_expression.to_sql}"
+      join_sql << "JOIN #{table_reference.to_sql(options)} "
+      join_sql << "ON #{join_expression.to_sql(options)}"
       join_sql
     end
 
@@ -26,14 +28,13 @@ module SQLTree::Node
     def self.parse(tokens)
       join = self.new
 
-      if tokens.peek == SQLTree::Token::FULL
+      if SQLTree::Token::FULL === tokens.peek
         join.join_type = :outer
         tokens.consume(SQLTree::Token::FULL, SQLTree::Token::OUTER)
-      elsif [SQLTree::Token::OUTER, SQLTree::Token::INNER, SQLTree::Token::LEFT, SQLTree::Token::RIGHT].include?(tokens.peek)
+      elsif [SQLTree::Token::OUTER, SQLTree::Token::INNER, SQLTree::Token::LEFT, SQLTree::Token::RIGHT].include?(tokens.peek.class)
         join.join_type = tokens.next.literal.downcase.to_sym
       end
 
-
       tokens.consume(SQLTree::Token::JOIN)
       join.table_reference = SQLTree::Node::TableReference.parse(tokens)
       tokens.consume(SQLTree::Token::ON)
@@ -41,10 +42,5 @@ module SQLTree::Node
 
       return join
     end
-
-    def ==(other)
-      other.table = self.table && other.table_alias == self.table_alias &&
-        other.join_type == self.join_type && other.join_expression == self.join_expression
-    end
   end
 end

data/lib/sql_tree/node/ordering.rb

@@ -2,14 +2,15 @@ module SQLTree::Node
 
   class Ordering < Base
 
-    attr_accessor :expression, :direction
+    child :expression
+    leaf :direction
 
     def initialize(expression, direction = nil)
       @expression, @direction = expression, direction
     end
 
-    def to_sql
-      sql = expression.to_sql
+    def to_sql(options = {})
+      sql = expression.to_sql(options)
       sql << " #{direction.to_s.upcase}" if direction
       sql
     end

data/lib/sql_tree/node/select_declaration.rb

@@ -0,0 +1,62 @@
+module SQLTree::Node
+
+  class SelectDeclaration < Base
+
+    child :expression
+    leaf :variable
+
+    def to_sql(options = {})
+      sql = @expression.to_sql(options)
+      sql << " AS " << quote_var(@variable) if @variable
+      return sql
+    end
+
+    def self.parse(tokens)
+      
+      if SQLTree::Token::MULTIPLY === tokens.peek
+        
+        # "SELECT * FROM ..."
+        tokens.consume(SQLTree::Token::MULTIPLY)
+        return SQLTree::Node::ALL_FIELDS
+        
+      elsif SQLTree::Token::Identifier === tokens.peek(1) &&
+            SQLTree::Token::DOT        === tokens.peek(2) &&
+            SQLTree::Token::MULTIPLY   === tokens.peek(3)
+            
+        # "SELECT table.* FROM ..."
+        table = tokens.next.literal
+        tokens.consume(SQLTree::Token::DOT, SQLTree::Token::MULTIPLY)
+        return SQLTree::Node::AllFieldsDeclaration.new(table)
+        
+      else
+        
+        expression = SQLTree::Node::Expression.parse(tokens)
+        expr = self.new(:expression => expression)
+        if SQLTree::Token::AS === tokens.peek
+          tokens.consume(SQLTree::Token::AS)
+          if SQLTree::Token::Identifier === tokens.peek
+            expr.variable = tokens.next.literal
+          else
+            raise SQLTree::Parser::UnexpectedToken.new(tokens.peek)
+          end
+        end
+        return expr
+      end
+    end
+  end
+
+  class AllFieldsDeclaration < Base
+    
+    leaf :table
+    
+    def initialize(table = nil)
+      @table = table
+    end
+    
+    def to_sql(options = {})
+      table ? "#{quote_var(table)}.*" : '*'
+    end
+  end
+
+  ALL_FIELDS = AllFieldsDeclaration.new
+end

data/lib/sql_tree/node/select_query.rb

@@ -2,22 +2,29 @@ module SQLTree::Node
 
   class SelectQuery < Base
 
-    attr_accessor :distinct, :select, :from, :where, :group_by, :having, :order_by, :limit
+    leaf :distinct
+    child :select
+    child :from
+    child :where
+    child :group_by
+    child :having
+    child :order_by
+    child :limit
 
     def initialize
       @distinct = false
       @select   = []
     end
 
-    def to_sql
+    def to_sql(options = {})
       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(', ') if from
-      sql << " WHERE "    << where.to_sql if where
-      sql << " GROUP BY " << group_by.map { |g| g.to_sql }.join(', ') if group_by
-      sql << " ORDER BY " << order_by.map { |o| o.to_sql }.join(', ') if order_by
-      sql << " HAVING "   << having.to_sql if having
+      sql << select.map { |s| s.to_sql(options) }.join(', ')
+      sql << " FROM "     << from.map { |f| f.to_sql(options) }.join(', ') if from
+      sql << " WHERE "    << where.to_sql(options) if where
+      sql << " GROUP BY " << group_by.map { |g| g.to_sql(options) }.join(', ') if group_by
+      sql << " ORDER BY " << order_by.map { |o| o.to_sql(options) }.join(', ') if order_by
+      sql << " HAVING "   << having.to_sql(options) if having
       return sql
     end
 
@@ -26,39 +33,25 @@ module SQLTree::Node
       select_node = self.new
       tokens.consume(SQLTree::Token::SELECT)
 
-      if tokens.peek == SQLTree::Token::DISTINCT
+      if SQLTree::Token::DISTINCT === tokens.peek
         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
-      if tokens.peek == SQLTree::Token::GROUP
+      select_node.select   = parse_list(tokens, SQLTree::Node::SelectDeclaration)
+      select_node.from     = self.parse_from_clause(tokens)   if SQLTree::Token::FROM === tokens.peek
+      select_node.where    = self.parse_where_clause(tokens)  if SQLTree::Token::WHERE === tokens.peek
+      if SQLTree::Token::GROUP === tokens.peek
         select_node.group_by = self.parse_group_clause(tokens)
-        select_node.having   = self.parse_having_clause(tokens) if tokens.peek == SQLTree::Token::HAVING
+        select_node.having   = self.parse_having_clause(tokens) if SQLTree::Token::HAVING === tokens.peek
       end
-      select_node.order_by = self.parse_order_clause(tokens)  if tokens.peek == SQLTree::Token::ORDER
+      select_node.order_by = self.parse_order_clause(tokens) if SQLTree::Token::ORDER === tokens.peek
       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
+      parse_list(tokens, SQLTree::Node::Source)
     end
 
     def self.parse_where_clause(tokens)
@@ -67,14 +60,8 @@ module SQLTree::Node
     end
 
     def self.parse_group_clause(tokens)
-      tokens.consume(SQLTree::Token::GROUP)
-      tokens.consume(SQLTree::Token::BY)
-      exprs = [SQLTree::Node::Expression.parse(tokens)]
-      while tokens.peek == SQLTree::Token::COMMA
-        tokens.consume(SQLTree::Token::COMMA)
-        exprs << SQLTree::Node::Expression.parse(tokens)
-      end
-      return exprs
+      tokens.consume(SQLTree::Token::GROUP, SQLTree::Token::BY)
+      parse_list(tokens)
     end
 
     def self.parse_having_clause(tokens)
@@ -83,14 +70,8 @@ module SQLTree::Node
     end
 
     def self.parse_order_clause(tokens)
-      tokens.consume(SQLTree::Token::ORDER)
-      tokens.consume(SQLTree::Token::BY)
-      exprs = [SQLTree::Node::Ordering.parse(tokens)]
-      while tokens.peek == SQLTree::Token::COMMA
-        tokens.consume(SQLTree::Token::COMMA)
-        exprs << SQLTree::Node::Ordering.parse(tokens)
-      end
-      return exprs
+      tokens.consume(SQLTree::Token::ORDER, SQLTree::Token::BY)
+      parse_list(tokens, SQLTree::Node::Ordering)
     end
 
     def self.parse_limit_clause(tokens)

data/lib/sql_tree/node/source.rb

@@ -2,7 +2,8 @@ module SQLTree::Node
 
   class Source < Base
 
-    attr_accessor :table_reference, :joins
+    child :table_reference
+    child :joins
 
     def initialize(table_reference, joins = [])
       @table_reference, @joins = table_reference, joins
@@ -16,16 +17,12 @@ module SQLTree::Node
       table_reference.table_alias
     end
 
-    def to_sql
-      sql = table_reference.to_sql
-      sql << ' ' << joins.map { |j| j.to_sql }.join(' ') if joins.any?
+    def to_sql(options = {})
+      sql = table_reference.to_sql(options)
+      sql << ' ' << joins.map { |j| j.to_sql(options) }.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?

data/lib/sql_tree/node/table_reference.rb

@@ -2,28 +2,25 @@ module SQLTree::Node
 
   class TableReference < Base
 
-    attr_accessor :table, :table_alias
+    leaf :table
+    leaf :table_alias
 
     def initialize(table, table_alias = nil)
       @table, @table_alias = table, table_alias
     end
 
-    def to_sql
+    def to_sql(options = {})
       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
+      if SQLTree::Token::Identifier === 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
+        if SQLTree::Token::AS === tokens.peek || SQLTree::Token::Identifier === tokens.peek
+          tokens.consume(SQLTree::Token::AS) if SQLTree::Token::AS === tokens.peek
+          table_reference.table_alias = tokens.next.literal
         end
         return table_reference
       else

data/lib/sql_tree/node/update_query.rb

@@ -1,36 +1,97 @@
 module SQLTree::Node
 
+  # The UpdateQuery class represents an SQL +UPDATE+ query.
+  #
+  # This root node has three children: +table+, +updates+ and +where+.
   class UpdateQuery < Base
     
-    attr_accessor :table, :updates, :where
+    # The table ({SQLTree::Node::TableReference}) to update.
+    child :table
+    
+    # The updates to do in the table. This is an array of 
+    # {SQLTree::Node::UpdateQuery::Assignment} instances.
+    child :updates
+    
+    # The {SQLTree::Node::Expression} instance that restricts the records that
+    # should be updated.
+    child :where
     
     def initialize(table, updates = [], where = nil)
       @table, @updates, @where = table, updates, where
     end
     
-    def to_sql
-      sql = "UPDATE #{self.quote_var(table)} SET "
-      sql << updates.map { |u| u.to_sql }.join(', ')
-      sql << " WHERE " << where.to_sql if self.where
+    # Generates the SQL UPDATE query.
+    # @return [String] The SQL update query
+    def to_sql(options = {})
+      sql = "UPDATE #{table.to_sql(options)} SET "
+      sql << updates.map { |u| u.to_sql(options) }.join(', ')
+      sql << " WHERE " << where.to_sql(options) if self.where
       sql
     end
     
+    # Parses an SQL UPDATE query. Syntax:
+    #
+    #   UpdateQuery -> UPDATE TableReference 
+    #                     SET Assignment (COMMA Assignment)*
+    #                     (WHERE Expression)?
+    #
+    # @param [SQLTree::Parser] tokens The token stream to parse from.
+    # @return [SQLTree::Node::UpdateQuery] The parsed UpdateQuery instance.
+    # @raise [SQLTree::Parser::UnexpectedToken] if an unexpected token is
+    #    encountered during parsing.
     def self.parse(tokens)
       tokens.consume(SQLTree::Token::UPDATE)
-      update_query = self.new(SQLTree::Node::Variable.parse(tokens).name)
+      update_query = self.new(SQLTree::Node::TableReference.parse(tokens))
       tokens.consume(SQLTree::Token::SET)
-      update_query.updates = [SQLTree::Node::Assignment.parse(tokens)]
-      while tokens.peek == SQLTree::Token::COMMA
-        tokens.consume(SQLTree::Token::COMMA)
-        update_query.updates << SQLTree::Node::Assignment.parse(tokens)
-      end
+      update_query.updates = parse_list(tokens, SQLTree::Node::UpdateQuery::Assignment)
       
-      if tokens.peek == SQLTree::Token::WHERE
+      if SQLTree::Token::WHERE === tokens.peek
         tokens.consume(SQLTree::Token::WHERE)
         update_query.where = SQLTree::Node::Expression.parse(tokens)
       end
       
       update_query
     end
+
+    # The Assignment node is used to represent the assignment of a new
+    # value to a field in an +UPDATE+ query.
+    #
+    # This node has two children: <tt>field</tt> and <tt>expression</tt>.
+    class Assignment < Base
+    
+      # The field ({SQLTree::Node::Expression::Field}) to update.
+      child :field
+    
+      # A {SQLTree::Node::Expression} instance that is used to 
+      # update the field with.
+      child :expression
+    
+      # Initializes a new assignment node.
+      def initialize(field, expression = nil)
+        @field, @expression = field, expression
+      end
+    
+      # Generates an SQL fragment for this node.
+      # @return [String] An SQL fragment that can be embedded in the SET
+      #    clause of on SQL UPDATE query.
+      def to_sql(options = {})
+        "#{field.to_sql(options)} = #{expression.to_sql(options)}"
+      end
+    
+      # Parses an Assignment node from a stream of tokens. Syntax:
+      #
+      #   Assignment -> <identifier> EQ Expression
+      #
+      # @param [SQLTree::Parser] tokens The token stream to parse from.
+      # @return [SQLTree::Node::Assignment] The parsed assignment instance.
+      # @raise [SQLTree::Parser::UnexpectedToken] if an unexpected token is
+      #    encountered during parsing.
+      def self.parse(tokens)
+        assignment = self.new(SQLTree::Node::Expression::Field.parse(tokens))
+        tokens.consume(SQLTree::Token::EQ)
+        assignment.expression = SQLTree::Node::Expression.parse(tokens)
+        assignment
+      end
+    end
   end
 end