sql_tree 0.1.0 → 0.1.1

data/spec/unit/insert_query_spec.rb

@@ -4,21 +4,21 @@ describe SQLTree::Node::InsertQuery do
   
   it "should parse an insert query without field list correctly" do
     insert = SQLTree::Node::InsertQuery["INSERT INTO table VALUES (1, 'two', 3+4, MD5('$ecret'))"]
-    insert.table.should == 'table'
+    insert.table.should == SQLTree::Node::TableReference.new('table')
     insert.fields.should be_nil
     insert.values.should have(4).items
-    insert.values[0].should == SQLTree::Node::Value.new(1)
-    insert.values[1].should == SQLTree::Node::Value.new('two')
-    insert.values[2].should be_kind_of(SQLTree::Node::ArithmeticExpression)
-    insert.values[3].should be_kind_of(SQLTree::Node::FunctionExpression)
+    insert.values[0].should == SQLTree::Node::Expression::Value.new(1)
+    insert.values[1].should == SQLTree::Node::Expression::Value.new('two')
+    insert.values[2].should be_kind_of(SQLTree::Node::Expression::BinaryOperator)
+    insert.values[3].should be_kind_of(SQLTree::Node::Expression::FunctionCall)
   end
   
   it "should parse an insert query with field list" do
     insert = SQLTree::Node::InsertQuery['INSERT INTO table ("field1", "field2") VALUES (1, 2)']
-    insert.table.should == 'table'
+    insert.table.should == SQLTree::Node::TableReference.new('table')
     insert.fields.should have(2).items
-    insert.fields[0].should == SQLTree::Node::Variable.new('field1')
-    insert.fields[1].should == SQLTree::Node::Variable.new('field2')
     insert.values.should have(2).items
+    insert.fields[0].should == SQLTree::Node::Expression::Field.new('field1')
+    insert.fields[1].should == SQLTree::Node::Expression::Field.new('field2')
   end
 end

data/spec/unit/leaf_node_spec.rb

@@ -1,82 +1,82 @@
 require "#{File.dirname(__FILE__)}/../spec_helper"
 
-describe SQLTree::Node::Value do
+describe SQLTree::Node::Expression::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)
+      lambda { SQLTree::Node::Expression::Value['field_name'] }.should raise_error(SQLTree::Parser::UnexpectedToken)
     end
 
     it "should parse an integer value correctly" do
-      SQLTree::Node::Value['123'].value.should == 123
+      SQLTree::Node::Expression::Value['123'].value.should == 123
     end
 
     it "should parse a string correctly" do
-      SQLTree::Node::Value["'123'"].value.should == '123'
+      SQLTree::Node::Expression::Value["'123'"].value.should == '123'
     end
 
     it "should parse a NULL value correctly" do
-      SQLTree::Node::Value['NULL'].value.should == nil
+      SQLTree::Node::Expression::Value['NULL'].value.should == nil
     end
 
   end
 end
 
-describe SQLTree::Node::Variable do
+describe SQLTree::Node::Expression::Variable do
 
   describe '.parse' do
     it "should parse a variable name correctly" do
-      SQLTree::Node::Field['variable'].name.should == 'variable'
+      SQLTree::Node::Expression::Variable['variable'].name.should == 'variable'
     end
 
     it "should parse a quoted variable name correctly" do
-      SQLTree::Node::Field['"variable"'].name.should == 'variable'
+      SQLTree::Node::Expression::Variable['"variable"'].name.should == 'variable'
     end
 
     it "should raise an error when parsing a reserved keyword as variable" do
-      lambda { SQLTree::Node::Field['select'] }.should raise_error(SQLTree::Parser::UnexpectedToken)
+      lambda { SQLTree::Node::Expression::Variable['select'] }.should raise_error(SQLTree::Parser::UnexpectedToken)
     end
 
     it "should parse a quoted reserved keyword as variable name correctly" do
-      SQLTree::Node::Field['"select"'].name.should == 'select'
+      SQLTree::Node::Expression::Variable['"select"'].name.should == 'select'
     end
   end
 end
 
-describe SQLTree::Node::Field do
+describe SQLTree::Node::Expression::Field do
   describe '.parse' do
     it "should parse a field name with table name correclty" do
-      field = SQLTree::Node::Field['table.field']
+      field = SQLTree::Node::Expression::Field['table.field']
       field.table.should == 'table'
       field.name.should  == 'field'
     end
 
     it "should parse a field name without table name correclty" do
-      field = SQLTree::Node::Field['field']
+      field = SQLTree::Node::Expression::Field['field']
       field.table.should be_nil
       field.name.should == 'field'
     end
 
     it "should parse a quoted field name without table name correclty" do
-      field = SQLTree::Node::Field['"field"']
+      field = SQLTree::Node::Expression::Field['"field"']
       field.table.should be_nil
       field.name.should == 'field'
     end
 
     it "should parse a quoted field name with quoted table name correclty" do
-      field = SQLTree::Node::Field['"table"."field"']
+      field = SQLTree::Node::Expression::Field['"table"."field"']
       field.table.should == 'table'
       field.name.should  == 'field'
     end
 
     it "should parse a quoted field name with non-quoted table name correclty" do
-      field = SQLTree::Node::Field['table."field"']
+      field = SQLTree::Node::Expression::Field['table."field"']
       field.table.should == 'table'
       field.name.should  == 'field'
     end
 
     it "should parse a non-quoted field name with quoted table name correclty" do
-      field = SQLTree::Node::Field['"table".field']
+      field = SQLTree::Node::Expression::Field['"table".field']
       field.table.should == 'table'
       field.name.should  == 'field'
     end

data/spec/unit/select_query_spec.rb

@@ -18,9 +18,9 @@ describe SQLTree::Node::SelectQuery do
 
     tree.select.length.should == 2
     tree.from.length.should   == 2
-    tree.where.should be_kind_of(SQLTree::Node::ComparisonExpression)
-    tree.group_by.first.should be_kind_of(SQLTree::Node::Field)
-    tree.having.should be_kind_of(SQLTree::Node::ComparisonExpression)
+    tree.where.should be_kind_of(SQLTree::Node::Expression::BinaryOperator)
+    tree.group_by.first.should be_kind_of(SQLTree::Node::Expression::Field)
+    tree.having.should be_kind_of(SQLTree::Node::Expression::BinaryOperator)
   end
 end
 
@@ -92,7 +92,7 @@ describe SQLTree::Node::Ordering do
 
   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.expression.should be_kind_of(SQLTree::Node::Expression::FunctionCall)
     ordering.direction.should == :desc
   end
 

data/spec/unit/tokenizer_spec.rb

@@ -2,65 +2,61 @@ 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)
+      SQLTree::Tokenizer.tokenize('WHERE').should tokenize_to(:where)
     end
 
     it "should tokenize expression keywords" do
-      @tokenizer.tokenize('and').should tokenize_to(:and)
+      SQLTree::Tokenizer.tokenize('and').should tokenize_to(:and)
     end
 
     it "should tokenize muliple separate keywords" do
-      @tokenizer.tokenize('SELECT DISTINCT').should tokenize_to(:select, :distinct)
+      SQLTree::Tokenizer.tokenize('SELECT DISTINCT').should tokenize_to(:select, :distinct)
     end
 
     it "should ignore excessive whitespace" do
-      @tokenizer.tokenize("\tSELECT      DISTINCT \r\r").should tokenize_to(:select, :distinct)
+      SQLTree::Tokenizer.tokenize("\tSELECT      DISTINCT \r\r").should tokenize_to(:select, :distinct)
     end
 
     it "should tokenize variables" do
-      @tokenizer.tokenize("var").should tokenize_to(sql_var('var'))
+      SQLTree::Tokenizer.tokenize("var").should tokenize_to(sql_var('var'))
     end
 
     it "should tokenize quoted variables" do
-      @tokenizer.tokenize('"var"').should tokenize_to(sql_var('var'))
+      SQLTree::Tokenizer.tokenize('"var"').should tokenize_to(sql_var('var'))
     end
 
     it "should tokenize quoted variables even when they are a reserved keyword" do
-      @tokenizer.tokenize('"where"').should tokenize_to(sql_var('where'))
+      SQLTree::Tokenizer.tokenize('"where"').should tokenize_to(sql_var('where'))
     end
 
     it "should tokenize strings" do
-      @tokenizer.tokenize("'hello' '  world  '").should tokenize_to('hello', '  world  ')
+      SQLTree::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)
+      SQLTree::Tokenizer.tokenize("1 -2 3.14 -4.0").should tokenize_to(1, -2, 3.14, -4.0)
     end
 
     it "should tokenize logical operators" do
-      @tokenizer.tokenize("< = <> >=").should tokenize_to(:lt, :eq, :ne, :gte)
+      SQLTree::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)
+      SQLTree::Tokenizer.tokenize("+ - / * % || &").should tokenize_to(:plus, :minus, :divide, :multiply, :modulo, :concat, :binary_and)
     end
 
     it "should tokenize parentheses" do
-      @tokenizer.tokenize("(a)").should tokenize_to(lparen, sql_var('a'), rparen)
+      SQLTree::Tokenizer.tokenize("(a)").should tokenize_to(lparen, sql_var('a'), rparen)
     end
 
     it "should tokenize dots" do
-      @tokenizer.tokenize('a."b"').should tokenize_to(sql_var('a'), dot, sql_var('b'))
+      SQLTree::Tokenizer.tokenize('a."b"').should tokenize_to(sql_var('a'), dot, sql_var('b'))
     end
 
     it "should tokenize commas" do
-      @tokenizer.tokenize('a , "b"').should tokenize_to(sql_var('a'), comma, sql_var('b'))
+      SQLTree::Tokenizer.tokenize('a , "b"').should tokenize_to(sql_var('a'), comma, sql_var('b'))
     end
   end
 
@@ -68,18 +64,18 @@ describe SQLTree::Tokenizer do
   # # 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)
+  #     SQLTree::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(
+      SQLTree::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)
+      SQLTree::Tokenizer.tokenize("MD5('test')").should tokenize_to(sql_var('MD5'), lparen, 'test', rparen)
     end
   end
 

data/spec/unit/update_query_spec.rb

@@ -4,18 +4,18 @@ describe SQLTree::Node::UpdateQuery do
 
   it "should parse a delete query without WHERE clause correctly" do
     update = SQLTree::Node::UpdateQuery["UPDATE table SET field1 = 1, field2 = 5 - 3"]
-    update.table.should == 'table'
+    update.table.should == SQLTree::Node::TableReference.new("table")
     update.updates.should have(2).items
-    update.updates[0].field.should == 'field1'
-    update.updates[0].expression.should == SQLTree::Node::Value.new(1)
-    update.updates[1].field.should == 'field2'
-    update.updates[1].expression.should be_kind_of(SQLTree::Node::ArithmeticExpression)
+    update.updates[0].field.should == SQLTree::Node::Expression::Field.new("field1")
+    update.updates[0].expression.should == SQLTree::Node::Expression::Value.new(1)
+    update.updates[1].field.should == SQLTree::Node::Expression::Field.new("field2")
+    update.updates[1].expression.should be_kind_of(SQLTree::Node::Expression)
     update.where.should be_nil
   end
 
   it "should parse a delete query without WHERE clause correctly" do
     update = SQLTree::Node::UpdateQuery["UPDATE table SET field = 1 WHERE id = 17"]
-    update.table.should == 'table'
+    update.table.should == SQLTree::Node::TableReference.new("table")
     update.updates.should have(1).item
     update.where.should be_kind_of(SQLTree::Node::Expression)
   end

data/sql_tree.gemspec

@@ -3,8 +3,8 @@ 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.1.0"
-  s.date    = "2009-10-09"
+  s.version = "0.1.1"
+  s.date    = "2009-10-17"
 
   s.summary = "A pure Ruby library to represent SQL queries with a syntax tree for inspection and modification."
   s.description = <<-EOS
@@ -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/unit/insert_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 lib/sql_tree/parser.rb sql_tree.gemspec spec/unit/tokenizer_spec.rb spec/unit/expression_node_spec.rb spec/unit/delete_query_spec.rb lib/sql_tree/node/select_expression.rb lib/sql_tree/node/assignment.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/insert_query.rb lib/sql_tree/node/field.rb Rakefile tasks/github-gem.rake spec/unit/update_query_spec.rb spec/integration/parse_and_generate_spec.rb 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/node/delete_query.rb lib/sql_tree.rb lib/sql_tree/node/update_query.rb)
+  s.files = %w(spec/unit/select_query_spec.rb spec/unit/insert_query_spec.rb spec/spec_helper.rb lib/sql_tree/tokenizer.rb lib/sql_tree/node/join.rb .gitignore lib/sql_tree/node/ordering.rb LICENSE spec/lib/matchers.rb lib/sql_tree/parser.rb sql_tree.gemspec spec/unit/tokenizer_spec.rb spec/unit/expression_node_spec.rb spec/unit/delete_query_spec.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/insert_query.rb Rakefile tasks/github-gem.rake spec/unit/update_query_spec.rb spec/integration/parse_and_generate_spec.rb lib/sql_tree/node/select_query.rb lib/sql_tree/node.rb README.rdoc spec/integration/api_spec.rb lib/sql_tree/node/expression.rb lib/sql_tree/node/delete_query.rb lib/sql_tree/node/select_declaration.rb lib/sql_tree.rb lib/sql_tree/node/update_query.rb)
   s.test_files = %w(spec/unit/select_query_spec.rb spec/unit/insert_query_spec.rb spec/unit/tokenizer_spec.rb spec/unit/expression_node_spec.rb spec/unit/delete_query_spec.rb spec/unit/leaf_node_spec.rb spec/unit/update_query_spec.rb spec/integration/parse_and_generate_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.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-09 00:00:00 +02:00
+date: 2009-10-17 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -26,7 +26,6 @@ files:
 - spec/unit/insert_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
@@ -37,14 +36,11 @@ files:
 - spec/unit/tokenizer_spec.rb
 - spec/unit/expression_node_spec.rb
 - spec/unit/delete_query_spec.rb
-- lib/sql_tree/node/select_expression.rb
-- lib/sql_tree/node/assignment.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/insert_query.rb
-- lib/sql_tree/node/field.rb
 - Rakefile
 - tasks/github-gem.rake
 - spec/unit/update_query_spec.rb
@@ -53,9 +49,9 @@ files:
 - 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/node/delete_query.rb
+- lib/sql_tree/node/select_declaration.rb
 - lib/sql_tree.rb
 - lib/sql_tree/node/update_query.rb
 has_rdoc: true
@@ -87,7 +83,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.4
 signing_key: 
 specification_version: 3
 summary: A pure Ruby library to represent SQL queries with a syntax tree for inspection and modification.

data/lib/sql_tree/node/assignment.rb

@@ -1,22 +0,0 @@
-module SQLTree::Node
-
-  class Assignment < Base
-    
-    attr_accessor :field, :expression
-    
-    def initialize(field, expression = nil)
-      @field, @expression = field, expression
-    end
-    
-    def to_sql
-      "#{quote_var(field)} = #{expression.to_sql}"
-    end
-    
-    def self.parse(tokens)
-      assignment = self.new(SQLTree::Node::Variable.parse(tokens).name)
-      tokens.consume(SQLTree::Token::EQ)
-      assignment.expression = SQLTree::Node::Expression.parse(tokens)
-      assignment
-    end
-  end
-end

data/lib/sql_tree/node/field.rb

@@ -1,49 +0,0 @@
-module SQLTree::Node
-
-  class Field < Base
-
-    attr_accessor :name, :table
-
-    alias :field :name
-    alias :field= :name=
-
-    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 ==(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/select_expression.rb

@@ -1,45 +0,0 @@
-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)
-        return SQLTree::Node::ALL_FIELDS
-      else
-        expression = SQLTree::Node::Expression.parse(tokens)
-        expr = SQLTree::Node::SelectExpression.new(expression)
-        if tokens.peek == SQLTree::Token::AS
-          tokens.consume(SQLTree::Token::AS)
-          expr.variable = SQLTree::Node::Variable.parse(tokens).name
-        end
-        return expr
-      end
-    end
-
-    def ==(other)
-      other.expression == self.expression && other.variable == self.variable
-    end
-  end
-
-  class AllFieldsExpression < Expression
-    def to_sql
-      '*'
-    end
-  end
-
-  ALL_FIELDS = AllFieldsExpression.new
-end