sequel_core 2.1.0 → 2.2.0

data/spec/{blockless_filters_spec.rb → expression_filters_spec.rb}

@@ -6,20 +6,12 @@ context "Blockless Ruby Filters" do
     db.quote_identifiers = false
     @d = db[:items]
     def @d.l(*args, &block)
-      if block_given?
-        literal(filter_expr(Proc.new(&block)))
-      else
-        literal(filter_expr(*args))
-      end
+      literal(filter_expr(*args, &block))
     end
     def @d.lit(*args)
       literal(*args)
     end
   end
-
-  after do
-    Sequel.use_parse_tree = true
-  end
   
   it "should support boolean columns directly" do
     @d.l(:x).should == 'x'
@@ -300,7 +292,7 @@ context "Blockless Ruby Filters" do
     @d.lit([:x, :z].sql_string_join(' ') + :y).should == "((x || ' ' || z) || y)"
   end
 
-  it "should be supported inside blocks if Sequel.use_parse_tree = false" do
+  it "should be supported inside blocks" do
     @d.l{[[:x, nil], [:y, [1,2,3]]].sql_or}.should == '((x IS NULL) OR (y IN (1, 2, 3)))'
     @d.l{~[[:x, nil], [:y, [1,2,3]]]}.should == '((x IS NOT NULL) OR (y NOT IN (1, 2, 3)))'
     @d.l{~(((('x'.lit - :y)/(:x + :y))*:z) <= 100)}.should == '((((x - y) / (x + y)) * z) > 100)'

data/spec/object_graph_spec.rb

@@ -71,6 +71,11 @@ describe Sequel::Dataset, " graphing" do
     ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON ((lines.x = points.id) AND (lines.y = points.id))'
   end
 
+  it "#graph should accept a block instead of conditions and pass it to join_table" do
+    ds = @ds1.graph(@ds2){|ja, lja, js| [[:x.qualify(ja), :id.qualify(lja)], [:y.qualify(ja), :id.qualify(lja)]]}
+    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON ((lines.x = points.id) AND (lines.y = points.id))'
+  end
+
   it "#graph should not add columns if graph is called after set_graph_aliases" do
     ds = @ds1.set_graph_aliases([[:x,[:points, :x]], [:y,[:lines, :y]]])
     ds.sql.should == 'SELECT points.x, lines.y FROM points'

data/spec/schema_spec.rb

@@ -278,10 +278,10 @@ context "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE UNIQUE INDEX cats_id_name_index ON cats (id, name)"]
   end
   
-  pt_specify "should accept unnamed constraint definitions with blocks" do
+  specify "should accept unnamed constraint definitions with blocks" do
     @db.create_table(:cats) do
       integer :score
-      check {:x > 0 && :y < 1}
+      check {(:x > 0) & (:y < 1)}
     end
     @db.sqls.should == ["CREATE TABLE cats (score integer, CHECK ((x > 0) AND (y < 1)))"]
   end
@@ -301,9 +301,9 @@ context "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (score integer, CONSTRAINT valid_score CHECK (score <= 100))"]
   end
 
-  pt_specify "should accept named constraint definitions with block" do
+  specify "should accept named constraint definitions with block" do
     @db.create_table(:cats) do
-      constraint(:blah_blah) {:x > 0 && :y < 1}
+      constraint(:blah_blah) {(:x > 0) & (:y < 1)}
     end
     @db.sqls.should == ["CREATE TABLE cats (CONSTRAINT blah_blah CHECK ((x > 0) AND (y < 1)))"]
   end
@@ -350,9 +350,9 @@ context "DB#alter_table" do
     @db.sqls.should == ["ALTER TABLE cats ADD CONSTRAINT valid_score CHECK (score <= 100)"]
   end
 
-  pt_specify "should support add_constraint with block" do
+  specify "should support add_constraint with block" do
     @db.alter_table(:cats) do
-      add_constraint(:blah_blah) {:x > 0 && :y < 1}
+      add_constraint(:blah_blah) {(:x > 0) & (:y < 1)}
     end
     @db.sqls.should == ["ALTER TABLE cats ADD CONSTRAINT blah_blah CHECK ((x > 0) AND (y < 1))"]
   end

data/spec/spec_config.rb.example

@@ -1,6 +1,7 @@
 # database objects for running adapter specs
 # INFORMIX_DB = Sequel.connect('informix://localhost/mydb')
-# MYSQL_DB = Sequel.connect('mysql://root@localhost/sandbox')
+# MYSQL_USER = 'root'
+# MYSQL_DB = Sequel.connect("mysql://#{MYSQL_USER}@localhost/sandbox")
 # MYSQL_SOCKET_FILE = '/tmp/mysql.sock'
 # ORACLE_DB = Sequel.connect('oracle://hr:hr@localhost/XE')
 # POSTGRES_DB = Sequel.connect('postgres://postgres:postgres@localhost:5432/reality_spec')

data/spec/spec_helper.rb

@@ -50,12 +50,6 @@ class SchemaDummyDatabase < Sequel::Database
   end
 end
 
-class Spec::Example::ExampleGroup
-  def self.pt_specify(*args, &block)
-    specify(*args, &block) if defined?(::ParseTree)
-  end
-end
-
 if File.exists?(File.join(File.dirname(__FILE__), 'spec_config.rb'))
   require File.join(File.dirname(__FILE__), 'spec_config.rb')
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_core
 version: !ruby/object:Gem::Version 
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors: 
 - Jeremy Evans
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-17 00:00:00 -07:00
+date: 2008-07-05 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -48,14 +48,13 @@ files:
 - spec/rcov.opts
 - spec/schema_generator_spec.rb
 - spec/spec_helper.rb
-- spec/sequelizer_spec.rb
 - spec/spec.opts
 - spec/spec_config.rb.example
 - spec/spec_config.rb
 - spec/worker_spec.rb
 - spec/connection_pool_spec.rb
 - spec/object_graph_spec.rb
-- spec/blockless_filters_spec.rb
+- spec/expression_filters_spec.rb
 - lib/sequel_core.rb
 - lib/sequel_core
 - lib/sequel_core/adapters
@@ -80,10 +79,8 @@ files:
 - lib/sequel_core/dataset
 - lib/sequel_core/dataset/callback.rb
 - lib/sequel_core/dataset/convenience.rb
-- lib/sequel_core/dataset/sequelizer.rb
 - lib/sequel_core/dataset/sql.rb
 - lib/sequel_core/dataset/pagination.rb
-- lib/sequel_core/dataset/parse_tree_sequelizer.rb
 - lib/sequel_core/dataset/query.rb
 - lib/sequel_core/dataset/schema.rb
 - lib/sequel_core/object_graph.rb

data/lib/sequel_core/dataset/parse_tree_sequelizer.rb

@@ -1,310 +0,0 @@
-module Sequel
-  class Dataset
-   private
-    # Formats an comparison expression involving a left value and a right
-    # value. Comparison expressions differ according to the class of the right
-    # value. The stock implementation supports Range (inclusive and exclusive),
-    # Array (as a list of values to compare against), Dataset (as a subquery to
-    # compare against), or a regular value.
-    #
-    #   dataset.compare_expr('id', 1..20) #=>
-    #     "(id >= 1 AND id <= 20)"
-    #   dataset.compare_expr('id', [3,6,10]) #=>
-    #     "(id IN (3, 6, 10))"
-    #   dataset.compare_expr('id', DB[:items].select(:id)) #=>
-    #     "(id IN (SELECT id FROM items))"
-    #   dataset.compare_expr('id', nil) #=>
-    #     "(id IS NULL)"
-    #   dataset.compare_expr('id', 3) #=>
-    #     "(id = 3)"
-    def compare_expr(l, r)
-      case r
-      when Range
-        "(#{literal(l)} >= #{literal(r.begin)} AND #{literal(l)} <#{'=' unless r.exclude_end?} #{literal(r.end)})"
-      when Array, Sequel::Dataset
-        "(#{literal(l)} IN #{literal(r)})"
-      when NilClass
-        "(#{literal(l)} IS NULL)"
-      when Regexp
-        collate_match_expr(l, r)
-      else
-        "(#{literal(l)} = #{literal(r)})"
-      end
-    end
-
-    # Formats a string matching expression with support for multiple choices.
-    # For more information see #match_expr.
-    def collate_match_expr(l, r)
-      if r.is_a?(Array)
-        "(#{r.map {|i| match_expr(l, i)}.join(' OR ')})"
-      else
-        match_expr(l, r)
-      end
-    end
-
-    # Formats a string matching expression. The stock implementation supports
-    # matching against strings only using the LIKE operator. Specific adapters
-    # can override this method to provide support for regular expressions.
-    def match_expr(l, r)
-      case r
-      when String
-        "(#{literal(l)} LIKE #{literal(r)})"
-      else
-        raise Sequel::Error, "Unsupported match pattern class (#{r.class})."
-      end
-    end
-
-    # Translates a method call parse-tree to SQL expression. The following 
-    # operators are recognized and translated to SQL expressions: >, <, >=, <=,
-    # ==, =~, +, -, *, /, %:
-    #
-    #   :x == 1 #=> "(x = 1)"
-    #   (:x + 100) < 200 #=> "((x + 100) < 200)"
-    #
-    # The in, in?, nil and nil? method calls are intercepted and passed to 
-    # #compare_expr.
-    #
-    #   :x.in [1, 2, 3] #=> "(x IN (1, 2, 3))"
-    #   :x.in?(DB[:y].select(:z)) #=> "(x IN (SELECT z FROM y))"
-    #   :x.nil? #=> "(x IS NULL)"
-    #
-    # The like and like? method calls are intercepted and passed to #match_expr.
-    #
-    #   :x.like? 'ABC%' #=> "(x LIKE 'ABC%')"
-    #
-    # The method also supports SQL functions by invoking Symbol#[]:
-    #
-    #   :avg[:x] #=> "avg(x)"
-    #   :substring[:x, 5] #=> "substring(x, 5)"
-    #
-    # All other method calls are evaulated as normal Ruby code.
-    def call_expr(e, b, opts)
-      case op = e[2]
-      when :>, :<, :>=, :<=
-        l = eval_expr(e[1], b, opts)
-        r = eval_expr(e[3][1], b, opts)
-        if l.is_one_of?(Symbol, Sequel::LiteralString, Sequel::SQL::Expression) || \
-          r.is_one_of?(Symbol, Sequel::LiteralString, Sequel::SQL::Expression)
-          "(#{literal(l)} #{op} #{literal(r)})"
-        else
-          ext_expr(e, b, opts)
-        end
-      when :==
-        l = eval_expr(e[1], b, opts)
-        r = eval_expr(e[3][1], b, opts)
-        compare_expr(l, r)
-      when :=~
-        l = eval_expr(e[1], b, opts)
-        r = eval_expr(e[3][1], b, opts)
-        collate_match_expr(l, r)
-      when :+, :-, :*, :%, :/
-        l = eval_expr(e[1], b, opts)
-        r = eval_expr(e[3][1], b, opts)
-        if l.is_one_of?(Symbol, Sequel::LiteralString, Sequel::SQL::Expression) || \
-          r.is_one_of?(Symbol, Sequel::LiteralString, Sequel::SQL::Expression)
-          "(#{literal(l)} #{op} #{literal(r)})".lit
-        else
-          ext_expr(e, b, opts)
-        end
-      when :<<
-        l = eval_expr(e[1], b, opts)
-        r = eval_expr(e[3][1], b, opts)
-        "#{literal(l)} = #{literal(r)}".lit
-      when :|
-        l = eval_expr(e[1], b, opts)
-        r = eval_expr(e[3][1], b, opts)
-        if l.is_one_of?(Symbol, Sequel::SQL::Subscript)
-          l|r
-        else
-          ext_expr(e, b, opts)
-        end
-      when :in, :in?
-        # in/in? operators are supported using two forms:
-        #   :x.in([1, 2, 3])
-        #   :x.in(1, 2, 3) # variable arity
-        l = eval_expr(e[1], b, opts)
-        r = eval_expr((e[3].size == 2) ? e[3][1] : e[3], b, opts)
-        compare_expr(l, r)
-      when :nil, :nil?
-        l = eval_expr(e[1], b, opts)
-        compare_expr(l, nil)
-      when :like, :like?
-        l = eval_expr(e[1], b, opts)
-        r = eval_expr(e[3][1], b, opts)
-        collate_match_expr(l, r)
-      else
-        if (op == :[]) && (e[1][0] == :lit) && (Symbol === e[1][1])
-          # SQL Functions, e.g.: :sum[:x]
-          if e[3]
-            e[1][1][*eval_expr(e[3], b, opts)]
-          else
-            e[1][1][]
-          end
-        else
-          # external code
-          ext_expr(e, b, opts)
-        end
-      end
-    end
-    
-    def fcall_expr(e, b, opts) #:nodoc:
-      ext_expr(e, b, opts)
-    end
-    
-    def vcall_expr(e, b, opts) #:nodoc:
-      eval(e[1].to_s, b)
-    end
-    
-    def iter_expr(e, b, opts) #:nodoc:
-      if e[1][0] == :call && e[1][2] == :each
-        unfold_each_expr(e, b, opts)
-      elsif e[1] == [:fcall, :proc]
-        eval_expr(e[3], b, opts) # inline proc
-      else
-        ext_expr(e, b, opts) # method call with inline proc
-      end
-    end
-    
-    def replace_dvars(a, values)
-      a.map do |i|
-        if i.is_a?(Array) && (i[0] == :dvar)
-          if v = values[i[1]]
-            value_to_parse_tree(v)
-          else
-            i
-          end
-        elsif Array === i
-          replace_dvars(i, values)
-        else
-          i
-        end
-      end
-    end
-    
-    def value_to_parse_tree(value)
-      c = Class.new
-      c.class_eval("def m; #{value.inspect}; end")
-      ParseTree.translate(c, :m)[2][1][2]
-    end
-    
-    def unfold_each_expr(e, b, opts) #:nodoc:
-      source = eval_expr(e[1][1], b, opts)
-      block_dvars = []
-      if e[2][0] == :dasgn_curr
-        block_dvars << e[2][1]
-      elsif e[2][0] == :masgn
-        e[2][1].each do |i|
-          if i.is_a?(Array) && i[0] == :dasgn_curr
-            block_dvars << i[1]
-          end
-        end
-      end
-      new_block = [:block]
-      
-      source.each do |*dvars|
-        iter_values = (Array === dvars[0]) ? dvars[0] : dvars
-        values = block_dvars.inject({}) {|m, i| m[i] = iter_values.shift; m}
-        iter = replace_dvars(e[3], values)
-        new_block << iter
-      end
-      
-      pt_expr(new_block, b, opts)
-    end
-    
-    # Evaluates a parse-tree into an SQL expression.
-    def eval_expr(e, b, opts)
-      case e[0]
-      when :call # method call
-        call_expr(e, b, opts)
-      when :fcall
-        fcall_expr(e, b, opts)
-      when :vcall
-        vcall_expr(e, b, opts)
-      when :ivar, :cvar, :dvar, :const, :gvar # local ref
-        eval(e[1].to_s, b)
-      when :nth_ref
-        eval("$#{e[1]}", b)
-      when :lvar # local context
-        if e[1] == :block
-          sub_proc = eval(e[1].to_s, b)
-          sub_proc.to_sql(self)
-        else
-          eval(e[1].to_s, b)
-        end
-      when :lit, :str # literal
-         e[1]
-      when :dot2 # inclusive range
-        eval_expr(e[1], b, opts)..eval_expr(e[2], b, opts)
-      when :dot3 # exclusive range
-        eval_expr(e[1], b, opts)...eval_expr(e[2], b, opts)
-      when :colon2 # qualified constant ref
-        eval_expr(e[1], b, opts).const_get(e[2])
-      when :false
-        false
-      when :true
-        true
-      when :nil
-        nil
-      when :array
-        # array
-        e[1..-1].map {|i| eval_expr(i, b, opts)}
-      when :match3
-        # =~/!~ operator
-        l = eval_expr(e[2], b, opts)
-        r = eval_expr(e[1], b, opts)
-        compare_expr(l, r)
-      when :iter
-        iter_expr(e, b, opts)
-      when :dasgn, :dasgn_curr
-        # assignment
-        l = e[1]
-        r = eval_expr(e[2], b, opts)
-        raise Sequel::Error::InvalidExpression, "#{l} = #{r}. Did you mean :#{l} == #{r}?"
-      when :if
-        op, c, br1, br2 = *e
-        if ext_expr(c, b, opts)
-          eval_expr(br1, b, opts)
-        elsif br2
-          eval_expr(br2, b, opts)
-        end
-      when :dstr
-        ext_expr(e, b, opts)
-      else
-        raise Sequel::Error::InvalidExpression, "Invalid expression tree: #{e.inspect}"
-      end
-    end
-    
-    JOIN_AND = " AND ".freeze
-    JOIN_COMMA = ", ".freeze
-  
-    def pt_expr(e, b, opts = {}) #:nodoc:
-      case e[0]
-      when :not # negation: !x, (x != y), (x !~ y)
-        if (e[1][0] == :lit) && (Symbol === e[1][1])
-          # translate (!:x) into (x = 'f')
-          compare_expr(e[1][1], false)
-        else
-          "(NOT #{pt_expr(e[1], b, opts)})"
-        end
-      when :and # x && y
-        "(#{e[1..-1].map {|i| pt_expr(i, b, opts)}.join(JOIN_AND)})"
-      when :or # x || y
-        "(#{pt_expr(e[1], b, opts)} OR #{pt_expr(e[2], b, opts)})"
-      when :call, :vcall, :iter, :match3, :if # method calls, blocks
-        eval_expr(e, b, opts)
-      when :block # block of statements
-        if opts[:comma_separated]
-          "#{e[1..-1].map {|i| pt_expr(i, b, opts)}.join(JOIN_COMMA)}"
-        else
-          "(#{e[1..-1].map {|i| pt_expr(i, b, opts)}.join(JOIN_AND)})"
-        end
-      else # literals
-        if e == [:lvar, :block]
-          eval_expr(e, b, opts)
-        else
-          literal(eval_expr(e, b, opts))
-        end
-      end
-    end
-  end
-end