sql_tree 0.0.1 → 0.0.2

data/lib/sql_tree/node/expression.rb

@@ -49,10 +49,6 @@ module SQLTree::Node
       "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
@@ -75,10 +71,6 @@ module SQLTree::Node
       "(" + @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
@@ -105,10 +97,6 @@ module SQLTree::Node
       "(#{@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
@@ -151,10 +139,6 @@ module SQLTree::Node
       @items = items
     end
 
-    def to_tree
-      items.map { |i| i.to_tree }
-    end
-    
     def to_sql
       "(#{items.map {|i| i.to_sql}.join(', ')})"
     end
@@ -184,10 +168,6 @@ module SQLTree::Node
       "#{@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)
@@ -213,10 +193,6 @@ module SQLTree::Node
       "(#{@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

data/lib/sql_tree/node/field.rb

@@ -4,6 +4,9 @@ module SQLTree::Node
 
     attr_accessor :name, :table
 
+    alias :field :name
+    alias :field= :name=
+
     def initialize(name, table = nil)
       @name = name
       @table = table
@@ -17,10 +20,6 @@ module SQLTree::Node
     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

data/lib/sql_tree/node/ordering.rb

@@ -0,0 +1,25 @@
+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?
+        ordering.direction = tokens.next.literal.downcase.to_sym
+      end
+      return ordering
+    end
+  end
+end

data/lib/sql_tree/node/select_query.rb

@@ -14,7 +14,8 @@ module SQLTree::Node
       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 << " WHERE " << where.to_sql       if where
+      sql << " ORDER BY " << order_by.map { |o| o.to_sql }.join(', ') if order_by
       return sql
     end
   
@@ -28,10 +29,10 @@ module SQLTree::Node
         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
-
+      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
+      select_node.order_by = self.parse_order_clause(tokens)  if tokens.peek == SQLTree::Token::ORDER
       return select_node
     end
     
@@ -68,7 +69,14 @@ module SQLTree::Node
     end
     
     def self.parse_order_clause(tokens)
-      # TODO: implement me
+      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
     end
 
     def self.parse_limit_clause(tokens)

data/lib/sql_tree/node/source.rb

@@ -29,7 +29,7 @@ module SQLTree::Node
     def self.parse(tokens)
       source = self.new(SQLTree::Node::TableReference.parse(tokens))
       while tokens.peek && tokens.peek.join?
-        source.joins << Join.parse(tokens)
+        source.joins << SQLTree::Node::Join.parse(tokens)
       end
       return source
     end

data/lib/sql_tree/node/value.rb

@@ -15,10 +15,6 @@ module SQLTree::Node
       end
     end
     
-    def to_tree
-      @value
-    end
-    
     def ==(other)
       other.kind_of?(self.class) && other.value == self.value
     end

data/lib/sql_tree/node/variable.rb

@@ -12,10 +12,6 @@ module SQLTree::Node
       quote_var(@name)
     end
     
-    def to_tree
-      @name.to_sym
-    end
-    
     def ==(other)
       other.name == self.name
     end

data/lib/sql_tree/token.rb

@@ -36,6 +36,10 @@ class SQLTree::Token
       SQLTree::Token::FULL].include?(self)
   end
   
+  def direction?
+    [SQLTree::Token::ASC, SQLTree::Token::DESC].include?(self)
+  end
+  
   ###################################################################
   # DYNAMIC TOKEN TYPES
   ###################################################################
@@ -107,8 +111,8 @@ class SQLTree::Token
   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}
+  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
   KEYWORDS.each { |kw| const_set(kw, Class.new(SQLTree::Token::Keyword).new(kw)) }

data/spec/integration/full_queries_spec.rb

@@ -14,8 +14,23 @@ describe SQLTree, 'parsing and generating SQL' do
     SQLTree["SELECT a.* FROM table AS a"].to_sql.should == 'SELECT "a".* FROM "table" AS "a"'
   end
   
-  it "parse and generate a complex SQL query" do
-    SQLTree['SELECT a.*,   MD5( a.name )   AS checksum   FROM  table  AS  a , other   WHERE   other.timestamp    >  a.timestamp'].to_sql.should ==
-                  'SELECT "a".*, MD5("a"."name") AS "checksum" FROM "table" AS "a", "other" WHERE ("other"."timestamp" > "a"."timestamp")'
+  it "should parse and generate an ORDER BY clause" do
+    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
 end

data/spec/lib/matchers.rb

@@ -1,31 +1,3 @@
-class ParseAs
-  
-  def initialize(expected_tree)
-    @expected_tree = expected_tree
-  end 
-  
-  def matches?(found_tree)
-    @found_tree = found_tree.to_tree
-    return @found_tree == @expected_tree
-  end
-  
-  def description
-    "expected to parse to #{@expected_tree.inspect}"
-  end
-  
-  def failure_message
-    " #{@expected_tree.inspect} expected, but found #{@found_tree.inspect}"
-  end
-  
-  def negative_failure_message
-    " expected not to be tokenized to #{@expected_tree.inspect}"
-  end  
-end
-
-def parse_as(tree)
-  ParseAs.new(tree)
-end
-
 class TokenizeTo
   
   def initialize(expected_tokens)

data/spec/unit/select_query_spec.rb

@@ -50,3 +50,32 @@ describe SQLTree::Node::Join do
     SQLTree::Node::Join['LEFT JOIN table t ON other.field = table.field'].table_alias.should == 't'
   end
 end
+
+describe SQLTree::Node::Ordering do
+  it "should parse an ordering with direction" do
+    ordering = SQLTree::Node::Ordering["table.field ASC"]
+    ordering.expression.table.should == 'table'
+    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
+    tree.order_by[0].direction.should == :asc
+    tree.order_by[1].direction.should == :desc
+  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.1'
+  s.version = "0.0.2"
   s.date    = "2009-10-09"
 
   s.summary = "A pure Ruby library to represent SQL queries with a syntax tree for inspection and modification."
@@ -22,6 +22,6 @@ Gem::Specification.new do |s|
 
   # Do not modify the files and test_files values by hand, because this will
   # automatically by them gem release script.
-  s.files = %w(spec/unit/select_query_spec.rb spec/spec_helper.rb lib/sql_tree/tokenizer.rb lib/sql_tree/node/variable.rb lib/sql_tree/node/join.rb .gitignore LICENSE spec/lib/matchers.rb spec/integration/full_queries_spec.rb lib/sql_tree/parser.rb sql_tree.gemspec spec/unit/tokenizer_spec.rb spec/unit/expression_node_spec.rb lib/sql_tree/node/select_expression.rb spec/unit/leaf_node_spec.rb lib/sql_tree/token.rb lib/sql_tree/node/table_reference.rb lib/sql_tree/node/source.rb lib/sql_tree/node/field.rb Rakefile tasks/github-gem.rake lib/sql_tree/node/select_query.rb lib/sql_tree/node.rb README.rdoc spec/integration/api_spec.rb lib/sql_tree/node/value.rb lib/sql_tree/node/expression.rb lib/sql_tree.rb)
+  s.files = %w(spec/unit/select_query_spec.rb spec/spec_helper.rb lib/sql_tree/tokenizer.rb lib/sql_tree/node/variable.rb lib/sql_tree/node/join.rb .gitignore lib/sql_tree/node/ordering.rb LICENSE spec/lib/matchers.rb spec/integration/full_queries_spec.rb lib/sql_tree/parser.rb sql_tree.gemspec spec/unit/tokenizer_spec.rb spec/unit/expression_node_spec.rb lib/sql_tree/node/select_expression.rb spec/unit/leaf_node_spec.rb lib/sql_tree/token.rb lib/sql_tree/node/table_reference.rb lib/sql_tree/node/source.rb lib/sql_tree/node/field.rb Rakefile tasks/github-gem.rake lib/sql_tree/node/select_query.rb lib/sql_tree/node.rb README.rdoc spec/integration/api_spec.rb lib/sql_tree/node/value.rb lib/sql_tree/node/expression.rb lib/sql_tree.rb)
   s.test_files = %w(spec/unit/select_query_spec.rb spec/integration/full_queries_spec.rb spec/unit/tokenizer_spec.rb spec/unit/expression_node_spec.rb spec/unit/leaf_node_spec.rb spec/integration/api_spec.rb)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sql_tree
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -28,6 +28,7 @@ files:
 - lib/sql_tree/node/variable.rb
 - lib/sql_tree/node/join.rb
 - .gitignore
+- lib/sql_tree/node/ordering.rb
 - LICENSE
 - spec/lib/matchers.rb
 - spec/integration/full_queries_spec.rb