sql_tree 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+/pkg
+/tmp

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Willem van Bergen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,25 @@
+= SQLTree
+
+SQLTree is a pure Ruby library to represent SQL queries with a syntax tree
+for inspection and modification.
+
+The library can parse an SQL query (a string) to represent the query using
+a syntax tree, and it can generate an SQL query from a syntax tree. The syntax
+tree ca be used to inspect to query, or to modify it.
+
+This library is currently under heavy development. This means that not all
+SQL constructs are supported yet. For now, only SQL <tt>SELECT</tt> queries
+are supported.
+
+== Installation
+
+The SQLTree library is distributed as a gem on Gemcutter.org. To install:
+
+  gem install sql_tree --source http://gemcutter.org
+
+== 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 
+  LICENSE file).

data/Rakefile

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

data/lib/sql_tree.rb

@@ -0,0 +1,42 @@
+# 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 
+# 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)
+    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 (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>
+  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>request_log_analyzer/controller</tt>) to camelcase
+  # (<tt>RequestLogAnalyzer::Controller</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

data/lib/sql_tree/node.rb

@@ -0,0 +1,37 @@
+module SQLTree::Node
+
+  def self.const_missing(const)
+    SQLTree.load_default_class_file(SQLTree::Node, const)
+  end
+
+  class Base
+
+    # Pretty prints this instance for inspection
+    def inspect
+      "#{self.class.name}[#{self.to_sql}]"
+    end
+  
+    # 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 = {})
+      parser = SQLTree::Parser.new(sql, options)
+      self.parse(parser)
+    end
+  end
+end

data/lib/sql_tree/node/expression.rb

@@ -0,0 +1,240 @@
+module SQLTree::Node
+
+  # Base class for all SQL expressions.
+  #
+  # 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
+    # * an SQL variable
+    # * an SQL function
+    # * a literal SQL value (numeric or string)
+    def self.parse_atomic(tokens)
+      case tokens.peek
+      when SQLTree::Token::LPAREN
+        tokens.consume(SQLTree::Token::LPAREN)
+        expr = SQLTree::Node::Expression.parse(tokens)
+        tokens.consume(SQLTree::Token::RPAREN)        
+        expr
+      when SQLTree::Token::NOT
+        SQLTree::Node::LogicalNotExpression.parse(tokens)
+      when SQLTree::Token::Variable
+        if tokens.peek(2) == SQLTree::Token::LPAREN
+          SQLTree::Node::FunctionExpression.parse(tokens)
+        else
+          SQLTree::Node::Variable.parse(tokens)
+        end
+      else
+        SQLTree::Node::Value.parse(tokens)
+      end
+    end
+  end
+  
+  class LogicalNotExpression < Expression
+    
+    attr_accessor :expression
+    
+    def initialize(expression)
+      @expression = expression
+    end
+    
+    def to_sql
+      "NOT(#{@expression.to_sql})"
+    end
+    
+    def to_tree
+      [:not, expression.to_tree]
+    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))
+    end
+  end
+
+  class LogicalExpression < Expression
+    attr_accessor :operator, :expressions
+
+    def initialize(operator, expressions)
+      @expressions = expressions
+      @operator    = operator.to_s.downcase.to_sym
+    end
+
+    def to_sql
+      "(" + @expressions.map { |e| e.to_sql }.join(" #{@operator.to_s.upcase} ") + ")"
+    end
+
+    def to_tree
+      [@operator] + @expressions.map { |e| e.to_tree }
+    end
+    
+    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 
+      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 to_tree
+      [SQLTree::Token::OPERATORS_HASH[@operator], @lhs.to_tree, @rhs.to_tree]
+    end
+    
+    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
+    
+    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
+  end
+  
+  class SetExpression < Expression
+    attr_accessor :items
+    
+    def initialize(items = [])
+      @items = items
+    end
+
+    def to_tree
+      items.map { |i| i.to_tree }
+    end
+    
+    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)]
+      while tokens.peek == SQLTree::Token::COMMA
+        tokens.consume(SQLTree::Token::COMMA)
+        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 to_tree
+      [@function.to_sym] + @arguments.map { |e| e.to_tree }
+    end
+    
+    def self.parse(tokens)
+      expr = self.new(tokens.next.literal)
+      tokens.consume(SQLTree::Token::LPAREN)
+      until tokens.peek == SQLTree::Token::RPAREN
+        expr.arguments << SQLTree::Node::Expression.parse(tokens)
+        tokens.consume(SQLTree::Token::COMMA) if tokens.peek == SQLTree::Token::COMMA
+      end
+      tokens.consume(SQLTree::Token::RPAREN)
+      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 to_tree
+      [SQLTree::Token::OPERATORS_HASH[@operator], @lhs.to_tree, @rhs.to_tree]
+    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)
+        expr = self.new(tokens.next.literal, expr, self.parse_secondary(tokens))
+      end
+      return expr
+    end
+    
+    def self.parse_secondary(tokens)
+      expr = Expression.parse_atomic(tokens)
+      while [SQLTree::Token::PLUS, SQLTree::Token::MINUS].include?(tokens.peek)
+        expr = self.new(tokens.next.literal, expr, SQLTree::Node::Expression.parse_atomic(tokens))
+      end
+      return expr
+    end
+  end
+end

data/lib/sql_tree/node/field.rb

@@ -0,0 +1,50 @@
+module SQLTree::Node
+  
+  class Field < Base
+
+    attr_accessor :name, :table
+
+    def initialize(name, table = nil)
+      @name = name
+      @table = table
+    end
+
+    def quote_var(name)
+      return '*' if name == :all
+      super(name)
+    end
+
+    def to_sql
+      @table.nil? ? quote_var(@name) : quote_var(@table) + '.' + quote_var(@name)
+    end
+
+    def to_tree
+      to_sql.to_sym
+    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
+        when SQLTree::Token::Variable then tokens.current.literal
+        else raise SQLTree::Parser::UnexpectedToken.new(tokens.current)
+      end
+
+      if tokens.peek == SQLTree::Token::DOT
+        table = field_or_table
+        tokens.consume(SQLTree::Token::DOT)
+        field = case tokens.next
+          when SQLTree::Token::MULTIPLY then :all
+          when SQLTree::Token::Variable then tokens.current.literal
+          else raise SQLTree::Parser::UnexpectedToken.new(tokens.current)
+        end
+        self.new(field, table)
+      else
+        self.new(field_or_table)
+      end
+    end
+  end
+end

data/lib/sql_tree/node/join.rb

@@ -0,0 +1,50 @@
+module SQLTree::Node
+
+  class Join < Base
+
+    attr_accessor :join_type, :table_reference, :join_expression
+
+    def initialize(values = {})
+      values.each { |key, value| self.send(:"#{key}=", value) }
+    end
+
+    def to_sql
+      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
+    end
+
+    def table 
+      table_reference.table
+    end
+
+    def table_alias
+      table_reference.table_alias
+    end
+
+    def self.parse(tokens)
+      join = self.new
+
+      if tokens.peek == SQLTree::Token::FULL
+        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)
+        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)
+      join.join_expression = SQLTree::Node::Expression.parse(tokens)
+
+      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