sql_tree 0.0.2 → 0.0.3

data/README.rdoc

@@ -16,10 +16,21 @@ are supported.
 The SQLTree library is distributed as a gem on Gemcutter.org. To install:
 
   gem install sql_tree --source http://gemcutter.org
+  
+== Usage
+
+Consider the following example:
+
+  require 'sql_tree'
+  tree  = SQLTree["SELECT * FROM table WHERE field = 'value'"]
+  where = SQLTree::Node::Expression["username = 'user' AND password = MD5('$secret')"]
+  tree.where = where # replace WHERE expression
+  puts tree.to_sql
+  # "SELECT * FROM "table" WHERE (("username" = 'user') AND ("password" = MD5('$secret')))"
 
 == Additional information
 
 * See the project wiki at http://wiki.github.com/wvanbergen/sql_tree for more
   information about using this library.
-* This plugin is written by Willem van Bergen and is MIT licensed (see the 
+* This plugin is written by Willem van Bergen and is MIT licensed (see the
   LICENSE file).

data/Rakefile

@@ -1,5 +1,5 @@
 Dir['tasks/*.rake'].each { |file| load(file) }
 
 GithubGem::RakeTasks.new(:gem)
-   
+
 task :default => [:spec]

data/lib/sql_tree/node/expression.rb

@@ -5,11 +5,11 @@ module SQLTree::Node
   # This is an asbtract class and should not be used directly. Use
   # one of the subclasses instead.
   class Expression < Base
-  
+
     def self.parse(tokens)
       SQLTree::Node::LogicalExpression.parse(tokens)
     end
-    
+
     # Parses a single, atomic SQL expression. This can be either:
     # * a full expression (or set of expressions) within parentheses.
     # * a logical NOT expression
@@ -21,7 +21,7 @@ module SQLTree::Node
       when SQLTree::Token::LPAREN
         tokens.consume(SQLTree::Token::LPAREN)
         expr = SQLTree::Node::Expression.parse(tokens)
-        tokens.consume(SQLTree::Token::RPAREN)        
+        tokens.consume(SQLTree::Token::RPAREN)
         expr
       when SQLTree::Token::NOT
         SQLTree::Node::LogicalNotExpression.parse(tokens)
@@ -36,23 +36,23 @@ module SQLTree::Node
       end
     end
   end
-  
+
   class LogicalNotExpression < Expression
-    
+
     attr_accessor :expression
-    
+
     def initialize(expression)
       @expression = expression
     end
-    
+
     def to_sql
       "NOT(#{@expression.to_sql})"
     end
-    
+
     def ==(other)
       other.kind_of?(self.class) && other.expression == self.expression
     end
-    
+
     def self.parse(tokens)
       tokens.consume(SQLTree::Token::NOT)
       self.new(SQLTree::Node::Expression.parse(tokens))
@@ -74,29 +74,29 @@ module SQLTree::Node
     def ==(other)
       self.operator == other.operator && self.expressions == other.expressions
     end
-    
+
     def self.parse(tokens)
       expr = ComparisonExpression.parse(tokens)
       while [SQLTree::Token::AND, SQLTree::Token::OR].include?(tokens.peek)
         expr = SQLTree::Node::LogicalExpression.new(tokens.next.literal, [expr, ComparisonExpression.parse(tokens)])
-      end 
+      end
       return expr
     end
   end
 
   class ComparisonExpression < Expression
     attr_accessor :lhs, :rhs, :operator
-    
+
     def initialize(operator, lhs, rhs)
       @lhs = lhs
       @rhs = rhs
       @operator = operator
     end
-    
+
     def to_sql
       "(#{@lhs.to_sql} #{@operator} #{@rhs.to_sql})"
     end
-    
+
     def self.parse_comparison_operator(tokens)
       operator_token = tokens.next
       if SQLTree::Token::IS === operator_token
@@ -117,7 +117,7 @@ module SQLTree::Node
         operator_token.literal
       end
     end
-    
+
     def self.parse(tokens)
       lhs = SQLTree::Node::ArithmeticExpression.parse(tokens)
       while SQLTree::Token::COMPARISON_OPERATORS.include?(tokens.peek)
@@ -125,16 +125,16 @@ module SQLTree::Node
         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
   end
-  
+
   class SetExpression < Expression
     attr_accessor :items
-    
+
     def initialize(items = [])
       @items = items
     end
@@ -142,7 +142,7 @@ module SQLTree::Node
     def to_sql
       "(#{items.map {|i| i.to_sql}.join(', ')})"
     end
-    
+
     def self.parse(tokens)
       tokens.consume(SQLTree::Token::LPAREN)
       items = [SQLTree::Node::Expression.parse(tokens)]
@@ -151,23 +151,23 @@ module SQLTree::Node
         items << SQLTree::Node::Expression.parse(tokens)
       end
       tokens.consume(SQLTree::Token::RPAREN)
-      
+
       self.new(items)
     end
   end
-  
+
   class FunctionExpression < Expression
     attr_accessor :function, :arguments
-    
+
     def initialize(function, arguments = [])
       @function = function
       @arguments = arguments
     end
-    
+
     def to_sql
       "#{@function}(" + @arguments.map { |e| e.to_sql }.join(', ') + ")"
     end
-    
+
     def self.parse(tokens)
       expr = self.new(tokens.next.literal)
       tokens.consume(SQLTree::Token::LPAREN)
@@ -176,27 +176,27 @@ module SQLTree::Node
         tokens.consume(SQLTree::Token::COMMA) if tokens.peek == SQLTree::Token::COMMA
       end
       tokens.consume(SQLTree::Token::RPAREN)
-      return expr      
+      return expr
     end
   end
-  
+
   class ArithmeticExpression < Expression
     attr_accessor :lhs, :rhs, :operator
-    
+
     def initialize(operator, lhs, rhs)
       @lhs = lhs
       @rhs = rhs
       @operator = operator
     end
-    
+
     def to_sql
       "(#{@lhs.to_sql} #{@operator} #{@rhs.to_sql})"
     end
-    
+
     def self.parse(tokens)
       self.parse_primary(tokens)
     end
-    
+
     def self.parse_primary(tokens)
       expr = self.parse_secondary(tokens)
       while [SQLTree::Token::PLUS, SQLTree::Token::MINUS].include?(tokens.peek)
@@ -204,7 +204,7 @@ module SQLTree::Node
       end
       return expr
     end
-    
+
     def self.parse_secondary(tokens)
       expr = Expression.parse_atomic(tokens)
       while [SQLTree::Token::PLUS, SQLTree::Token::MINUS].include?(tokens.peek)

data/lib/sql_tree/node/field.rb

@@ -1,5 +1,5 @@
 module SQLTree::Node
-  
+
   class Field < Base
 
     attr_accessor :name, :table
@@ -20,11 +20,11 @@ module SQLTree::Node
     def to_sql
       @table.nil? ? quote_var(@name) : quote_var(@table) + '.' + quote_var(@name)
     end
-    
+
     def ==(other)
       other.name == self.name && other.table == self.table
     end
-    
+
     def self.parse(tokens)
       field_or_table = case tokens.next
         when SQLTree::Token::MULTIPLY then :all

data/lib/sql_tree/node/join.rb

@@ -15,7 +15,7 @@ module SQLTree::Node
       join_sql
     end
 
-    def table 
+    def table
       table_reference.table
     end
 
@@ -43,7 +43,7 @@ module SQLTree::Node
     end
 
     def ==(other)
-      other.table = self.table && other.table_alias == self.table_alias && 
+      other.table = self.table && other.table_alias == self.table_alias &&
         other.join_type == self.join_type && other.join_expression == self.join_expression
     end
   end

data/lib/sql_tree/node/ordering.rb

@@ -1,19 +1,19 @@
 module SQLTree::Node
-  
+
   class Ordering < Base
-    
+
     attr_accessor :expression, :direction
-    
+
     def initialize(expression, direction = nil)
       @expression, @direction = expression, direction
     end
-    
+
     def to_sql
       sql = expression.to_sql
       sql << " #{direction.to_s.upcase}" if direction
       sql
     end
-    
+
     def self.parse(tokens)
       ordering = self.new(SQLTree::Node::Expression.parse(tokens))
       if tokens.peek && tokens.peek.direction?

data/lib/sql_tree/node/select_expression.rb

@@ -1,20 +1,20 @@
 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)
@@ -29,17 +29,17 @@ module SQLTree::Node
         return expr
       end
     end
-    
+
     def ==(other)
       other.expression == self.expression && other.variable == self.variable
-    end    
+    end
   end
-  
+
   class AllFieldsExpression < Expression
     def to_sql
       '*'
     end
   end
-  
+
   ALL_FIELDS = AllFieldsExpression.new
 end

data/lib/sql_tree/node/select_query.rb

@@ -1,24 +1,26 @@
 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
+      sql << " FROM "     << from.map { |f| f.to_sql }.join(', ')
+      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
       return sql
     end
-  
+
     # Uses the provided initialized parser to parse a SELECT query.
     def self.parse(tokens)
       select_node = self.new
@@ -32,10 +34,14 @@ module SQLTree::Node
       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.group_by = self.parse_group_clause(tokens)
+        select_node.having   = self.parse_having_clause(tokens) if tokens.peek == SQLTree::Token::HAVING
+      end
       select_node.order_by = self.parse_order_clause(tokens)  if tokens.peek == SQLTree::Token::ORDER
       return select_node
     end
-    
+
     def self.parse_select_clause(tokens)
       expressions = [SQLTree::Node::SelectExpression.parse(tokens)]
       while tokens.peek == SQLTree::Token::COMMA
@@ -44,7 +50,7 @@ module SQLTree::Node
       end
       return expressions
     end
-    
+
     def self.parse_from_clause(tokens)
       tokens.consume(SQLTree::Token::FROM)
       sources = [SQLTree::Node::Source.parse(tokens)]
@@ -54,20 +60,28 @@ module SQLTree::Node
       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
+      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
     end
 
     def self.parse_having_clause(tokens)
-      # TODO: implement me
+      tokens.consume(SQLTree::Token::HAVING)
+      SQLTree::Node::Expression.parse(tokens)
     end
-    
+
     def self.parse_order_clause(tokens)
       tokens.consume(SQLTree::Token::ORDER)
       tokens.consume(SQLTree::Token::BY)

data/lib/sql_tree/node/source.rb

@@ -1,13 +1,13 @@
 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
@@ -15,7 +15,7 @@ module SQLTree::Node
     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?
@@ -33,5 +33,5 @@ module SQLTree::Node
       end
       return source
     end
-  end 
+  end
 end

data/lib/sql_tree/node/table_reference.rb

@@ -17,7 +17,7 @@ module SQLTree::Node
     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)
@@ -26,7 +26,7 @@ module SQLTree::Node
           table_reference.table_alias = SQLTree::Node::Variable.parse(tokens).name
         end
         return table_reference
-      else 
+      else
         raise SQLTree::Parser::UnexpectedToken.new(tokens.current)
       end
     end

data/lib/sql_tree/node/value.rb

@@ -1,12 +1,12 @@
 module SQLTree::Node
-  
+
   class Value < Base
     attr_accessor :value
 
     def initialize(value)
       @value = value
     end
-  
+
     def to_sql
       case value
       when nil    then 'NULL'
@@ -14,11 +14,11 @@ module SQLTree::Node
       else             @value.to_s
       end
     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
@@ -27,7 +27,7 @@ module SQLTree::Node
         SQLTree::Node::Value.new(nil)
       else
         raise SQLTree::Parser::UnexpectedToken.new(tokens.current, :literal)
-      end      
+      end
     end
   end
 end

data/lib/sql_tree/node/variable.rb

@@ -1,5 +1,5 @@
 module SQLTree::Node
-  
+
   class Variable < Base
 
     attr_accessor :name
@@ -7,11 +7,11 @@ module SQLTree::Node
     def initialize(name)
       @name = name
     end
-  
+
     def to_sql
       quote_var(@name)
     end
-    
+
     def ==(other)
       other.name == self.name
     end

data/lib/sql_tree/node.rb

@@ -10,23 +10,23 @@ module SQLTree::Node
     def inspect
       "#{self.class.name}[#{self.to_sql}]"
     end
-  
-    # Quotes a variable name so that it can be safely used within 
+
+    # Quotes a variable name so that it can be safely used within
     # SQL queries.
     def quote_var(name)
       "\"#{name}\""
     end
-  
+
     # Quotes a string so that it can be used within an SQL query.
     def quote_str(str)
       "'#{str.gsub(/\'/, "''")}'"
     end
-  
+
     # This method should be implemented by a subclass.
     def self.parse(tokens)
       raise 'Only implemented in subclasses!'
     end
-  
+
     # Parses a string, expecting it to be parsable to an instance of
     # the current class.
     def self.[](sql, options = {})

data/lib/sql_tree/parser.rb

@@ -1,9 +1,9 @@
 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}"
@@ -11,7 +11,7 @@ class SQLTree::Parser
       message << '!'
       super(message)
     end
-  end  
+  end
 
   def self.parse(sql_string, options = {})
     self.new(sql_string, options).parse!
@@ -31,21 +31,21 @@ class SQLTree::Parser
   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
@@ -53,7 +53,7 @@ class SQLTree::Parser
   def debug
     puts @tokens.inspect
   end
-  
+
   def parse!
     case self.peek
     when SQLTree::Token::SELECT then SQLTree::Node::SelectQuery.parse(self)

data/lib/sql_tree/token.rb

@@ -8,60 +8,60 @@ 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 
+  # 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 
+  # <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::JOIN, SQLTree::Token::LEFT, SQLTree::Token::RIGHT,
+      SQLTree::Token::INNER, SQLTree::Token::OUTER, SQLTree::Token::NATURAL,
       SQLTree::Token::FULL].include?(self)
   end
-  
+
   def direction?
     [SQLTree::Token::ASC, SQLTree::Token::DESC].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 
+  # 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 
+
+    # 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, 
+  # variables. The variable name is stored in the literal as string,
   # without quotes if they were present.
   class Variable < SQLTree::Token::Value
   end
@@ -76,7 +76,7 @@ class SQLTree::Token
   # literal.
   class Number < SQLTree::Token::Value
   end
-  
+
   ###################################################################
   # STATIC TOKEN TYPES
   ###################################################################
@@ -111,7 +111,7 @@ class SQLTree::Token
   COMMA  = Class.new(SQLTree::Token).new(',')
 
   # A list of all the SQL reserverd keywords.
-  KEYWORDS = %w{SELECT FROM WHERE GROUP HAVING ORDER DISTINCT LEFT RIGHT INNER FULL OUTER NATURAL JOIN USING 
+  KEYWORDS = %w{SELECT FROM WHERE GROUP HAVING ORDER DISTINCT LEFT RIGHT INNER FULL OUTER NATURAL JOIN USING
                 AND OR NOT AS ON IS NULL BY LIKE ILIKE BETWEEN IN ASC DESC}
 
   # Create a token for all the reserved keywords in SQL
@@ -129,7 +129,7 @@ class SQLTree::Token
   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

data/lib/sql_tree/tokenizer.rb

@@ -11,17 +11,17 @@
 # the <tt>each_token</tt> (aliased to <tt>each</tt>) will yield every
 # token one by one.
 class SQLTree::Tokenizer
-  
+
   include Enumerable
-  
+
   # The keyword queue, on which kywords are placed before they are yielded
   # to the parser, to enable keyword combining (e.g. NOT LIKE)
   attr_reader :keyword_queue
-  
+
   def initialize # :nodoc:
     @keyword_queue = []
   end
-  
+
   # Returns an array of tokens for the given string.
   # <tt>string</tt>:: the string to tokenize
   def tokenize(string)
@@ -29,7 +29,7 @@ class SQLTree::Tokenizer
     @current_char_pos = -1
     self.entries
   end
-  
+
   # Returns the current character that is being tokenized
   def current_char
     @current_char
@@ -51,7 +51,7 @@ class SQLTree::Tokenizer
 
   # Combines several tokens to a single token if possible, and
   # yields teh result, or yields every single token if they cannot
-  # be combined. 
+  # be combined.
   # <tt>token</tt>:: the token to yield or combine
   # <tt>block</tt>:: the block to yield tokens and combined tokens to.
   def handle_token(token, &block) # :yields: SQLTree::Token
@@ -62,7 +62,7 @@ class SQLTree::Tokenizer
       block.call(token)
     end
   end
-  
+
   # This method ensures that every keyword currently in the queue is
   # yielded. This method get called by <tt>handle_token</tt> when it
   # knows for sure that the keywords on the queue cannot be combined
@@ -73,10 +73,10 @@ class SQLTree::Tokenizer
   end
 
   # Iterator method that yields each token that is encountered in the
-  # SQL stream. These tokens are passed to the SQL parser to construct 
+  # SQL stream. These tokens are passed to the SQL parser to construct
   # a syntax tree for the SQL query.
   #
-  # This method is aliased to <tt>:each</tt> to make the Enumerable 
+  # This method is aliased to <tt>:each</tt> to make the Enumerable
   # methods work on this method.
   def each_token(&block) # :yields: SQLTree::Token
     while next_char
@@ -93,13 +93,13 @@ class SQLTree::Tokenizer
       when '"';            tokenize_quoted_variable(&block)     # TODO: allow MySQL quoting mode
       end
     end
-    
+
     # Make sure to yield any tokens that are still stashed on the queue.
     empty_keyword_queue!(&block)
   end
-  
+
   alias :each :each_token
-  
+
   # Tokenizes a eyword in the code. This can either be a reserved SQL keyword
   # or a variable. This method will yield variables directly. Keywords will be
   # yielded with a delay, because they may need to be combined with other
@@ -107,7 +107,7 @@ class SQLTree::Tokenizer
   def tokenize_keyword(&block) # :yields: SQLTree::Token
     literal = current_char
     literal << next_char while /[\w]/ =~ peek_char
-      
+
     if SQLTree::Token::KEYWORDS.include?(literal.upcase)
       handle_token(SQLTree::Token.const_get(literal.upcase), &block)
     else
@@ -125,7 +125,7 @@ class SQLTree::Tokenizer
       dot_encountered = true if peek_char == '.'
       number << next_char
     end
-    
+
     if dot_encountered
       handle_token(SQLTree::Token::Number.new(number.to_f), &block)
     else
@@ -160,7 +160,7 @@ class SQLTree::Tokenizer
   # A regular expression that matches all operator characters.
   OPERATOR_CHARS = /\=|<|>|!|\-|\+|\/|\*|\%/
 
-  # Tokenizes an operator in the SQL stream. This method will yield the 
+  # Tokenizes an operator in the SQL stream. This method will yield the
   # operator token when the last character of the token is encountered.
   def tokenize_operator(&block) # :yields: SQLTree::Token
     operator = current_char

data/lib/sql_tree.rb

@@ -1,10 +1,10 @@
 # The SQLTree module is the basic namespace for the sql_tree gem.
 #
 # It contains the shorthand parse method (i.e. <tt>SQLTree[sql_query]</tt>)
-# and some helper methods that are used by the gem. It also requires the 
+# and some helper methods that are used by the gem. It also requires the
 # necessary files for the gem to function properly.
 module SQLTree
-  
+
   # Loads constants in the SQLTree namespace using self.load_default_class_file(base, const)
   # <tt>const</tt>:: The constant that is not yet loaded in the SQLTree namespace. This should be passed as a string or symbol.
   def self.const_missing(const)
@@ -18,14 +18,14 @@ module SQLTree
   def self.load_default_class_file(base, const)
     require "#{to_underscore("#{base.name}::#{const}")}"
     base.const_get(const) if base.const_defined?(const)
-  end  
-  
+  end
+
   # The <tt>[]</tt> method is a shorthand for the <tt>SQLTree::Parser.parse</tt>
   # method to parse an SQL query and return a SQL syntax tree.
   def self.[](query, options = {})
     SQLTree::Parser.parse(query)
   end
-  
+
   # Convert a string/symbol in camelcase (RequestLogAnalyzer::Controller) to underscores (request_log_analyzer/controller)
   # This function can be used to load the file (using require) in which the given constant is defined.
   # <tt>str</tt>:: The string to convert in the following format: <tt>ModuleName::ClassName</tt>
@@ -38,5 +38,5 @@ module SQLTree
   # <tt>str</tt>:: The string to convert in the following format: <tt>module_name/class_name</tt>
   def self.to_camelcase(str)
     str.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
-  end  
+  end
 end

data/spec/integration/api_spec.rb

@@ -1,5 +1,5 @@
 require "#{File.dirname(__FILE__)}/../spec_helper"
 
 describe SQLTree, :API do
-  
+
 end

data/spec/integration/full_queries_spec.rb

@@ -5,32 +5,37 @@ describe SQLTree, 'parsing and generating SQL' do
   it "should parse and generate SQL fo a simple list query" do
     SQLTree["SELECT * FROM table"].to_sql.should == 'SELECT * FROM "table"'
   end
-  
+
   it "should parse and generate the DISTINCT keyword" do
     SQLTree["SELECT DISTINCT * FROM table"].to_sql.should == 'SELECT DISTINCT * FROM "table"'
   end
-  
+
   it 'should parse and generate table aliases' do
     SQLTree["SELECT a.* FROM table AS a"].to_sql.should == 'SELECT "a".* FROM "table" AS "a"'
   end
-  
+
   it "should parse and generate an ORDER BY clause" do
-    SQLTree["SELECT * FROM table ORDER BY field1, field2"].to_sql.should == 
+    SQLTree["SELECT * FROM table ORDER BY field1, field2"].to_sql.should ==
             'SELECT * FROM "table" ORDER BY "field1", "field2"'
   end
-  
+
   it "should parse and generate an expression in the SELECT clause" do
     SQLTree['SELECT MD5( a)  AS  a,    b  > 0  AS  test  FROM  table'].to_sql.should ==
             'SELECT MD5("a") AS "a", ("b" > 0) AS "test" FROM "table"'
   end
-  
+
   it "should parse and generate a complex FROM clause" do
     SQLTree['SELECT * FROM  a  LEFT JOIN  b  ON ( a.id    = b.a_id),      c  AS  d'].to_sql.should ==
             'SELECT * FROM "a" LEFT JOIN "b" ON ("a"."id" = "b"."a_id"), "c" AS "d"'
   end
-  
+
   it "should parse and generate a WHERE clause" do
     SQLTree['SELECT * FROM  t  WHERE (   field  > 4  OR  NOW() >  timestamp)   AND   other_field  IS NOT NULL'].to_sql.should ==
             'SELECT * FROM "t" WHERE ((("field" > 4) OR (NOW() > "timestamp")) AND ("other_field" IS NOT NULL))'
   end
+
+  it "should parse and generate a GROUP BY and HAVING clause" do
+    SQLTree['SELECT SUM( field1 ) FROM  t  GROUP BY  field1,  MD5( field2 ) HAVING  SUM( field1 ) > 10'].to_sql.should ==
+            'SELECT SUM("field1") FROM "t" GROUP BY "field1", MD5("field2") HAVING (SUM("field1") > 10)'
+  end
 end

data/spec/lib/matchers.rb

@@ -1,5 +1,5 @@
 class TokenizeTo
-  
+
   def initialize(expected_tokens)
     @expected_tokens = expected_tokens.map do |t|
       case t
@@ -11,24 +11,24 @@ class TokenizeTo
       end
     end
   end
-  
+
   def matches?(found_tokens)
     @found_tokens = found_tokens
     return @found_tokens == @expected_tokens
   end
-  
+
   def description
     "expected to tokenized to #{@expected_tokens.inspect}"
   end
-  
+
   def failure_message
     " #{@expected_tokens.inspect} expected, but found #{@found_tokens.inspect}"
   end
-  
+
   def negative_failure_message
     " expected not to be tokenized to #{@expected_tokens.inspect}"
-  end  
-  
+  end
+
 end
 
 def tokenize_to(*expected_tokens)

data/spec/spec_helper.rb

@@ -11,16 +11,16 @@ module SQLTree::Spec
       SQLTree::Node.const_get(const)
     end
   end
-  
+
   module TokenLoader
     def self.const_missing(const)
       SQLTree::Token.const_get(const)
     end
-  end  
+  end
 end
 
 Spec::Runner.configure do |config|
-  
+
 end
 
 require "#{File.dirname(__FILE__)}/lib/matchers"

data/spec/unit/expression_node_spec.rb

@@ -35,12 +35,12 @@ describe SQLTree::Node::Expression do
       logical = SQLTree::Node::Expression['1 AND 2 AND 3']
       logical.should == SQLTree::Node::Expression['(1 AND 2) AND 3']
     end
-  
+
     it "should nest expressions correctly when parentheses are used" do
       logical = SQLTree::Node::Expression['1 AND (2 AND 3)']
       logical.should_not == SQLTree::Node::Expression['(1 AND 2) AND 3']
     end
-    
+
     it "should parse a NOT expression without parenteheses correctly" do
       SQLTree::Node::Expression['NOT 1'].should == SQLTree::Node::LogicalNotExpression.new(SQLTree::Node::Value.new(1))
     end
@@ -55,21 +55,21 @@ describe SQLTree::Node::Expression do
       comparison.lhs.should      == SQLTree::Node::Value.new(1)
       comparison.rhs.should      == SQLTree::Node::Value.new(2)
     end
-    
+
     it "should parse an IS NULL expression corectly" do
       comparison = SQLTree::Node::Expression['field IS NULL']
       comparison.operator.should == 'IS'
       comparison.lhs.should == SQLTree::Node::Variable.new('field')
       comparison.rhs.should == SQLTree::Node::Value.new(nil)
     end
-    
+
     it "should parse an IS NOT NULL expression corectly" do
       comparison = SQLTree::Node::Expression['field IS NOT NULL']
       comparison.operator.should == 'IS NOT'
       comparison.lhs.should == SQLTree::Node::Variable.new('field')
       comparison.rhs.should == SQLTree::Node::Value.new(nil)
     end
-    
+
     it "should parse a LIKE expression corectly" do
       comparison = SQLTree::Node::Expression["field LIKE '%search%"]
       comparison.operator.should == 'LIKE'
@@ -83,20 +83,20 @@ describe SQLTree::Node::Expression do
       comparison.lhs.should == SQLTree::Node::Variable.new('field')
       comparison.rhs.should == SQLTree::Node::Value.new('%search%')
     end
-    
+
     it "should parse an IN expression correctly" do
       comparison = SQLTree::Node::Expression["field IN (1,2,3,4)"]
       comparison.operator.should == 'IN'
       comparison.lhs.should == SQLTree::Node::Variable.new('field')
       comparison.rhs.should be_kind_of(SQLTree::Node::SetExpression)
     end
-    
+
     it "should parse a NOT IN expression correctly" do
       comparison = SQLTree::Node::Expression["field NOT IN (1>2, 3+6, 99)"]
       comparison.operator.should == 'NOT IN'
       comparison.lhs.should == SQLTree::Node::Variable.new('field')
       comparison.rhs.should be_kind_of(SQLTree::Node::SetExpression)
     end
-    
+
   end
 end

data/spec/unit/leaf_node_spec.rb

@@ -1,7 +1,7 @@
 require "#{File.dirname(__FILE__)}/../spec_helper"
 
 describe SQLTree::Node::Value do
-  
+
   describe '.parse' do
     it "should not parse a field name" do
       lambda { SQLTree::Node::Value['field_name'] }.should raise_error(SQLTree::Parser::UnexpectedToken)
@@ -14,11 +14,11 @@ describe SQLTree::Node::Value do
     it "should parse a string correctly" do
       SQLTree::Node::Value["'123'"].value.should == '123'
     end
-    
+
     it "should parse a NULL value correctly" do
       SQLTree::Node::Value['NULL'].value.should == nil
     end
-    
+
   end
 end
 

data/spec/unit/select_query_spec.rb

@@ -29,23 +29,23 @@ describe SQLTree::Node::Join do
   it "should parse a join table" do
     SQLTree::Node::Join['LEFT JOIN table ON other.field = table.field'].table.should == 'table'
   end
-  
+
   it "should parse the join type" do
     SQLTree::Node::Join['LEFT JOIN table ON other.field = table.field'].join_type.should == :left
   end
-  
+
   it "should parse the join expression" do
     SQLTree::Node::Join['LEFT JOIN table ON other.field = table.field'].join_expression.should be_kind_of(SQLTree::Node::Expression)
   end
-  
+
   it "should not parse a table alias" do
     SQLTree::Node::Join['LEFT JOIN table ON other.field = table.field'].table_alias.should be_nil
-  end  
-  
+  end
+
   it "should parse a table alias with AS" do
     SQLTree::Node::Join['LEFT JOIN table AS t ON other.field = table.field'].table_alias.should == 't'
   end
-  
+
   it "should parse a table alias without AS" do
     SQLTree::Node::Join['LEFT JOIN table t ON other.field = table.field'].table_alias.should == 't'
   end
@@ -58,20 +58,20 @@ describe SQLTree::Node::Ordering do
     ordering.expression.name.should  == 'field'
     ordering.direction.should == :asc
   end
-  
+
   it "should parse an ordering without direction" do
     ordering = SQLTree::Node::Ordering["table.field"]
     ordering.expression.table.should == 'table'
     ordering.expression.name.should  == 'field'
     ordering.direction.should be_nil
   end
-  
+
   it "should parse an ordering without direction" do
     ordering = SQLTree::Node::Ordering["MD5(3 + 6) DESC"]
     ordering.expression.should be_kind_of(SQLTree::Node::FunctionExpression)
     ordering.direction.should == :desc
   end
-  
+
   it "shoulde parse multiple orderings" do
     tree = SQLTree['SELECT * FROM table ORDER BY field1 ASC, field2 DESC']
     tree.order_by.should have(2).items

data/spec/unit/tokenizer_spec.rb

@@ -1,11 +1,11 @@
 require "#{File.dirname(__FILE__)}/../spec_helper"
 
 describe SQLTree::Tokenizer do
-  
+
   before(:all) do
     @tokenizer = SQLTree::Tokenizer.new
   end
-  
+
   context "recognizing single tokens" do
     it "should tokenize SQL query keywords" do
       @tokenizer.tokenize('WHERE').should tokenize_to(:where)
@@ -14,7 +14,7 @@ describe SQLTree::Tokenizer do
     it "should tokenize expression keywords" do
       @tokenizer.tokenize('and').should tokenize_to(:and)
     end
-    
+
     it "should tokenize muliple separate keywords" do
       @tokenizer.tokenize('SELECT DISTINCT').should tokenize_to(:select, :distinct)
     end
@@ -38,49 +38,49 @@ describe SQLTree::Tokenizer do
     it "should tokenize strings" do
       @tokenizer.tokenize("'hello' '  world  '").should tokenize_to('hello', '  world  ')
     end
-  
+
     it "should tokenize numbers" do
       @tokenizer.tokenize("1 -2 3.14 -4.0").should tokenize_to(1, -2, 3.14, -4.0)
-    end  
+    end
 
     it "should tokenize logical operators" do
       @tokenizer.tokenize("< = <> >=").should tokenize_to(:lt, :eq, :ne, :gte)
     end
-    
+
     it "should tokenize arithmetic operators" do
       @tokenizer.tokenize("+ - / * %").should tokenize_to(:plus, :minus, :divide, :multiply, :modulo)
-    end    
-    
+    end
+
     it "should tokenize parentheses" do
       @tokenizer.tokenize("(a)").should tokenize_to(lparen, sql_var('a'), rparen)
-    end  
-    
+    end
+
     it "should tokenize dots" do
       @tokenizer.tokenize('a."b"').should tokenize_to(sql_var('a'), dot, sql_var('b'))
-    end  
-    
+    end
+
     it "should tokenize commas" do
       @tokenizer.tokenize('a , "b"').should tokenize_to(sql_var('a'), comma, sql_var('b'))
     end
   end
-  
-  # # Combined tokens are disabled for now; 
+
+  # # Combined tokens are disabled for now;
   # # Combination is currently done in the parsing phase.
   # context "combining double keywords" do
   #   it "should tokenize double keywords" do
   #     @tokenizer.tokenize('NOT LIKE').should tokenize_to(:not_like)
   #   end
   # end
-  
+
   context "when tokenizing full queries or query fragments" do
     it "should tokenize a full SQL query" do
       @tokenizer.tokenize("SELECT a.* FROM a_table AS a WHERE a.id > 1").should tokenize_to(
         :select,  sql_var('a'), dot, :multiply, :from, sql_var('a_table'), :as, sql_var('a'), :where, sql_var('a'), dot, sql_var('id'), :gt, 1)
     end
-    
+
     it "should tokenize a function call" do
       @tokenizer.tokenize("MD5('test')").should tokenize_to(sql_var('MD5'), lparen, 'test', rparen)
     end
   end
-  
+
 end

data/sql_tree.gemspec

@@ -3,7 +3,7 @@ Gem::Specification.new do |s|
 
   # Do not modify the version and date values by hand, because this will
   # automatically by them gem release script.
-  s.version = "0.0.2"
+  s.version = "0.0.3"
   s.date    = "2009-10-09"
 
   s.summary = "A pure Ruby library to represent SQL queries with a syntax tree for inspection and modification."

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sql_tree
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Willem van Bergen