sql_tree 0.1.1 → 0.2.0

data/.gitignore

@@ -1,3 +1,6 @@
 /pkg
 /tmp
 /doc
+.bundle
+Gemfile.lock
+*.rbc

data/.infinity_test

@@ -0,0 +1,8 @@
+infinity_test do
+  
+  use :rubies => %w(1.8.7 1.9.2 ree jruby rbx), :test_framework => :rspec
+  
+  before(:each_ruby) do |environment|
+    environment.system('bundle install')
+  end
+end

data/Gemfile

@@ -0,0 +1,2 @@
+source :gemcutter
+gemspec

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Willem van Bergen
+Copyright (c) 2009-2010 Willem van Bergen and contributors
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -12,9 +12,11 @@ yet stable and not all SQL constructs are implemented yet.
 
 == Installation
 
-The SQLTree library is distributed as a gem on Gemcutter.org. To install:
+The SQLTree library is distributed as a gem. To install:
 
-  gem install sql_tree --source http://gemcutter.org
+  gem install sql_tree
+  
+Or, add <tt>gem 'sql_tree'</tt> to your project's Gemfile and run <tt>bundle install</tt>.  
   
 == Usage
 
@@ -33,5 +35,5 @@ This library is written by Willem van Bergen and is MIT licensed (see the
 LICENSE file).
 
 * Full RDoc API documentation can be found at http://rdoc.info/projects/wvanbergen/sql_tree
-* See the project wiki at http://wiki.github.com/wvanbergen/sql_tree for more
+* See the project wiki at http://github.com/wvanbergen/sql_tree/wiki for more
   information about using this library.

data/Rakefile

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

data/lib/sql_tree.rb

@@ -5,6 +5,8 @@
 # necessary files for the gem to function properly.
 module SQLTree
 
+  VERSION = "0.2.0"
+
   class << self
     # The character to quote variable names with.
     attr_accessor :identifier_quote_char
@@ -13,38 +15,14 @@ module SQLTree
   # Set default quote characters
   self.identifier_quote_char = '"'
     
-  # 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)
-    load_default_class_file(SQLTree, const)
-  end
-
-  # Loads constants that reside in the SQLTree tree using the constant name
-  # and its base constant to determine the filename.
-  # <tt>base</tt>:: The base constant to load the constant from. This should be Foo when the constant Foo::Bar is being loaded.
-  # <tt>const</tt>:: The constant to load from the base constant as a string or symbol. This should be 'Bar' or :Bar when the constant Foo::Bar is being loaded.
-  def self.load_default_class_file(base, const)
-    require "#{to_underscore("#{base.name}::#{const}")}"
-    base.const_get(const) if base.const_defined?(const)
-  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 (SQLTree::Parser) to underscores (sql_tree/parser)
-  # 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>
-  def self.to_underscore(str)
-    str.to_s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
-  end
-
-  # Convert a string/symbol in underscores (<tt>sql_tree/parser</tt>) to camelcase
-  # (<tt>SqlTree::Parser</tt>). This can be used to find the class that is defined in a given filename.
-  # <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
+
+require 'sql_tree/token'
+require 'sql_tree/tokenizer'
+require 'sql_tree/node'
+require 'sql_tree/parser'

data/lib/sql_tree/node.rb

@@ -1,11 +1,5 @@
 module SQLTree::Node
 
-  # Auto-loades files for Node subclasses that reside in the
-  # node directory, based on the classname.
-  def self.const_missing(const)
-    SQLTree.load_default_class_file(SQLTree::Node, const)
-  end
-
   # The SQLTree::Node::Base class is the superclass for all node
   # types that are used to represent SQL queries.
   #
@@ -105,4 +99,22 @@ module SQLTree::Node
       self.parse(parser)
     end
   end
-end
+end
+
+require 'sql_tree/node/expression'
+
+require 'sql_tree/node/select_query'
+require 'sql_tree/node/select_declaration'
+require 'sql_tree/node/table_reference'
+require 'sql_tree/node/source'
+require 'sql_tree/node/join'
+require 'sql_tree/node/ordering'
+
+require 'sql_tree/node/insert_query'
+require 'sql_tree/node/update_query'
+require 'sql_tree/node/delete_query'
+require 'sql_tree/node/set_query'
+
+require 'sql_tree/node/begin_statement'
+require 'sql_tree/node/commit_statement'
+require 'sql_tree/node/rollback_statement'

data/lib/sql_tree/node/begin_statement.rb

@@ -0,0 +1,12 @@
+module SQLTree::Node
+  class BeginStatement < Base
+    def to_sql(options = {})
+      "BEGIN"
+    end
+
+    def self.parse(tokens)
+      tokens.consume(SQLTree::Token::BEGIN)
+      return self.new
+    end
+  end
+end

data/lib/sql_tree/node/commit_statement.rb

@@ -0,0 +1,12 @@
+module SQLTree::Node
+  class CommitStatement < Base
+    def to_sql(options = {})
+      "COMMIT"
+    end
+
+    def self.parse(tokens)
+      tokens.consume(SQLTree::Token::COMMIT)
+      return self.new
+    end
+  end
+end

data/lib/sql_tree/node/expression.rb

@@ -49,6 +49,11 @@ module SQLTree::Node
         else
           Variable.parse(tokens)
         end
+      elsif SQLTree::Token::STRING_ESCAPE == tokens.peek
+        tokens.consume(SQLTree::Token::STRING_ESCAPE)
+        Value.parse(tokens)
+      elsif SQLTree::Token::INTERVAL === tokens.peek
+        IntervalValue.parse(tokens)
       else
         Value.parse(tokens)
       end
@@ -333,7 +338,35 @@ module SQLTree::Node
         return function_call
       end
     end
-    
+
+
+    # Represents a postgresql INTERVAL value. Example: interval '2 days'.
+    #
+    # The value is the literal text of the interval (e.g. "2 days").
+    class IntervalValue < SQLTree::Node::Expression
+      # The actual value this node represents.
+      leaf :value
+
+      def initialize(value) # :nodoc:
+        @value = value
+      end
+
+      # Generates an SQL representation for this value.
+      def to_sql(options = {})
+        "interval " + quote_str(@value)
+      end
+
+      def self.parse(tokens)
+        tokens.consume(SQLTree::Token::INTERVAL)
+        if SQLTree::Token::String === tokens.peek
+          self.new(tokens.next.literal)
+        else
+          raise SQLTree::Parser::UnexpectedToken.new(tokens.current, :literal)
+        end
+      end
+    end
+
+
     # Represents alitreal value in an SQL expression. This node is a leaf node
     # and thus has no child nodes.
     #
@@ -345,14 +378,14 @@ module SQLTree::Node
     # * an integer or decimal value, which is represented by an appropriate 
     #   <tt>Numeric</tt> instance.
     class Value  < SQLTree::Node::Expression
-      
+
       # The actual value this node represents.
       leaf :value
 
       def initialize(value) # :nodoc:
         @value = value
       end
-      
+
       # Generates an SQL representation for this value.
       #
       # This method supports nil, string, numeric, date and time values.
@@ -361,11 +394,11 @@ module SQLTree::Node
       # within an SQL query
       def to_sql(options = {})
         case value
-        when nil            then 'NULL'
-        when String         then quote_str(@value)
-        when Numeric        then @value.to_s
-        when Date           then @value.strftime("'%Y-%m-%d'")
-        when DateTime, Time then @value.strftime("'%Y-%m-%d %H:%M:%S'")
+        when nil;            'NULL'
+        when String;         quote_str(@value)
+        when Numeric;        @value.to_s
+        when Date;           @value.strftime("'%Y-%m-%d'")
+        when DateTime, Time; @value.strftime("'%Y-%m-%d %H:%M:%S'")
         else raise "Don't know how te represent this value in SQL!"
         end
       end
@@ -389,7 +422,7 @@ module SQLTree::Node
         end
       end
     end
-    
+
     # Represents a variable within an SQL expression. This is a leaf node, so it
     # does not have any child nodes. A variale can point to a field of a table or 
     # to another expression that was declared elsewhere.

data/lib/sql_tree/node/join.rb

@@ -3,15 +3,18 @@ module SQLTree::Node
   class Join < Base
 
     leaf :join_type
+    leaf :is_outer
     child :table_reference
     child :join_expression
 
     def initialize(values = {})
+      self.is_outer = false
       values.each { |key, value| self.send(:"#{key}=", value) }
     end
 
     def to_sql(options = {})
       join_sql = join_type ? "#{join_type.to_s.upcase} " : ""
+      join_sql << "OUTER " if is_outer
       join_sql << "JOIN #{table_reference.to_sql(options)} "
       join_sql << "ON #{join_expression.to_sql(options)}"
       join_sql
@@ -35,6 +38,11 @@ module SQLTree::Node
         join.join_type = tokens.next.literal.downcase.to_sym
       end
 
+      if [:right, :left].include?(join.join_type) && tokens.peek.class == SQLTree::Token::OUTER
+        join.is_outer = true
+        tokens.consume(SQLTree::Token::OUTER)
+      end
+
       tokens.consume(SQLTree::Token::JOIN)
       join.table_reference = SQLTree::Node::TableReference.parse(tokens)
       tokens.consume(SQLTree::Token::ON)

data/lib/sql_tree/node/rollback_statement.rb

@@ -0,0 +1,12 @@
+module SQLTree::Node
+  class RollbackStatement < Base
+    def to_sql(options = {})
+      "ROLLBACK"
+    end
+
+    def self.parse(tokens)
+      tokens.consume(SQLTree::Token::ROLLBACK)
+      return self.new
+    end
+  end
+end

data/lib/sql_tree/node/select_declaration.rb

@@ -1,5 +1,17 @@
 module SQLTree::Node
 
+  class SelectExpression < Base
+    
+    def self.parse(tokens)
+      case tokens.peek
+      when SQLTree::Token::COUNT
+        SQLTree::Node::CountAggregrate.parse(tokens)
+      else
+        SQLTree::Node::Expression.parse(tokens)
+      end
+    end
+  end
+
   class SelectDeclaration < Base
 
     child :expression
@@ -30,8 +42,7 @@ module SQLTree::Node
         
       else
         
-        expression = SQLTree::Node::Expression.parse(tokens)
-        expr = self.new(:expression => expression)
+        expr = self.new(:expression => SQLTree::Node::SelectExpression.parse(tokens))
         if SQLTree::Token::AS === tokens.peek
           tokens.consume(SQLTree::Token::AS)
           if SQLTree::Token::Identifier === tokens.peek
@@ -44,6 +55,61 @@ module SQLTree::Node
       end
     end
   end
+  
+  class CountAggregrate < Base
+    leaf :distinct
+    child :expression
+  
+    def to_sql(options = {})
+      sql = "COUNT("
+      sql << "DISTINCT " if distinct
+      sql << expression.to_sql(options)
+      sql << ')'
+    end
+  
+    def self.parse(tokens)
+      count_aggregate = self.new(:distinct => false)
+      
+      tokens.consume(SQLTree::Token::COUNT)
+      tokens.consume(SQLTree::Token::LPAREN)
+      
+      # Handle DISTINCT
+      distinct_parens = false
+      if SQLTree::Token::DISTINCT === tokens.peek
+        tokens.consume(SQLTree::Token::DISTINCT)
+        count_aggregate.distinct = true
+        if SQLTree::Token::LPAREN === tokens.peek
+          tokens.consume(SQLTree::Token::LPAREN)
+          distinct_parens = true
+        end
+      end
+      
+      if SQLTree::Token::MULTIPLY === tokens.peek
+        
+        # "COUNT(*)"
+        tokens.consume(SQLTree::Token::MULTIPLY)
+        count_aggregate.expression = SQLTree::Node::ALL_FIELDS
+        
+      elsif SQLTree::Token::Identifier === tokens.peek(1) &&
+            SQLTree::Token::DOT        === tokens.peek(2) &&
+            SQLTree::Token::MULTIPLY   === tokens.peek(3)
+            
+        # "COUNT(table.*)"
+        table = tokens.next.literal
+        tokens.consume(SQLTree::Token::DOT, SQLTree::Token::MULTIPLY)
+        count_aggregate.expression =  SQLTree::Node::AllFieldsDeclaration.new(table)
+
+      else
+      
+        count_aggregate.expression = SQLTree::Node::Expression.parse(tokens)
+      end
+      
+      tokens.consume(SQLTree::Token::RPAREN) if distinct_parens
+      tokens.consume(SQLTree::Token::RPAREN)
+    
+      return count_aggregate
+    end
+  end
 
   class AllFieldsDeclaration < Base
     

data/lib/sql_tree/node/set_query.rb

@@ -0,0 +1,38 @@
+module SQLTree::Node
+
+  # The <tt>DeleteQuery</tt> node represents an SQL DELETE query.
+  #
+  # This node has two children: <tt>table</tt> and <tt>where</tt>.
+  class SetQuery < Base
+
+    # The variable (<tt>SQLTree::Node::Field</tt>) that is being set.
+    child :variable
+    
+    # The <tt>SQLTree::Node::Expression</tt> value that the variable is being
+    # set to.
+    child :value
+
+    # Initializes a new DeleteQuery instance.
+    def initialize(variable, value)
+      @variable, @value = variable, value
+    end
+
+    # Generates an SQL DELETE query from this node.
+    def to_sql(options = {})
+      sql = "SET #{variable.to_sql(options)}"
+      sql << " TO #{value.to_sql(options)}"
+      sql
+    end
+    
+    # Parses a SET query from a stream of tokens.
+    # <tt>tokens</tt>:: The token stream to parse from, which is an instance
+    #                   of <tt> SQLTree::Parser</tt>.
+    def self.parse(tokens)
+      tokens.consume(SQLTree::Token::SET)
+      variable = SQLTree::Node::Expression::Field.parse(tokens)
+      tokens.consume(SQLTree::Token::TO)
+      value = SQLTree::Node::Expression::Value.parse(tokens)
+      return self.new(variable, value)
+    end
+  end
+end

data/lib/sql_tree/parser.rb

@@ -112,10 +112,14 @@ class SQLTree::Parser
   #
   def parse!
     case self.peek
-    when SQLTree::Token::SELECT then SQLTree::Node::SelectQuery.parse(self)
-    when SQLTree::Token::INSERT then SQLTree::Node::InsertQuery.parse(self)
-    when SQLTree::Token::DELETE then SQLTree::Node::DeleteQuery.parse(self)
-    when SQLTree::Token::UPDATE then SQLTree::Node::UpdateQuery.parse(self)
+    when SQLTree::Token::SELECT;   SQLTree::Node::SelectQuery.parse(self)
+    when SQLTree::Token::INSERT;   SQLTree::Node::InsertQuery.parse(self)
+    when SQLTree::Token::DELETE;   SQLTree::Node::DeleteQuery.parse(self)
+    when SQLTree::Token::UPDATE;   SQLTree::Node::UpdateQuery.parse(self)
+    when SQLTree::Token::BEGIN;    SQLTree::Node::BeginStatement.parse(self)
+    when SQLTree::Token::COMMIT;   SQLTree::Node::CommitStatement.parse(self)
+    when SQLTree::Token::ROLLBACK; SQLTree::Node::RollbackStatement.parse(self)
+    when SQLTree::Token::SET;      SQLTree::Node::SetQuery.parse(self)
     else raise UnexpectedToken.new(self.peek)
     end
   end