sequel 2.6.0 → 2.7.0

data/spec/adapters/spec_helper.rb

@@ -4,4 +4,7 @@ unless Object.const_defined?('Sequel')
   require 'sequel_core'
   Sequel.quote_identifiers = false
 end
-require File.join(File.dirname(__FILE__), '../spec_config.rb')
+begin
+  require File.join(File.dirname(__FILE__), '../spec_config.rb')
+rescue LoadError
+end

data/spec/integration/eager_loader_test.rb

@@ -228,7 +228,6 @@ describe "has_many :through has_many and has_one :through belongs_to" do
           firms.each{|firm| firm.associations[:invoices] = []}
           Invoice.eager_graph(:client).filter(:client__firm_id=>id_map.keys).all do |inv|
             id_map[inv.client.firm_id].each do |firm|
-              inv.client.associations[:firm] = inv.associations[:firm] = firm
               firm.associations[:invoices] << inv
             end
           end
@@ -255,20 +254,22 @@ describe "has_many :through has_many and has_one :through belongs_to" do
         :after_load=>(proc do |inv, firm|
           # Delete the cached associations from firm, because it only has the
           # client with this invoice, instead of all clients of the firm
-          inv.associations[:client] = firm.associations.delete(:clients).first
+          if c = firm.associations.delete(:clients)
+            firm.associations[:invoice_client] = c.first
+          end
+          inv.associations[:client] ||= firm.associations[:invoice_client]
         end), \
         :eager_loader=>(proc do |key_hash, invoices, associations|
           id_map = {}
           invoices.each do |inv|
             inv.associations[:firm] = nil
-            inv.associations[:client] = nil
             (id_map[inv.client_id] ||= []) << inv
           end
           Firm.eager_graph(:clients).filter(:clients__id=>id_map.keys).all do |firm|
             # Delete the cached associations from firm, because it only has the
             # clients related the invoices being eagerly loaded, instead of all
             # clients of the firm.
-            firm.associations.delete(:clients).each do |client|
+            firm.associations[:clients].each do |client|
               id_map[client.pk].each do |inv|
                 inv.associations[:firm] = firm
                 inv.associations[:client] = client

data/spec/integration/spec_helper.rb

@@ -3,7 +3,10 @@ unless Object.const_defined?('Sequel')
   $:.unshift(File.join(File.dirname(__FILE__), "../../lib/"))
   require 'sequel'
 end
-require File.join(File.dirname(__FILE__), '../spec_config.rb')
+begin
+  require File.join(File.dirname(__FILE__), '../spec_config.rb')
+rescue LoadError
+end
 
 $sqls = []
 def clear_sqls

data/spec/sequel_core/connection_pool_spec.rb

@@ -137,13 +137,13 @@ context "A connection pool with a max size of 1" do
   specify "should let only one thread access the connection at any time" do
     cc,c1, c2 = nil
     
-    t1 = Thread.new {@pool.hold {|c| cc = c; c1 = c.dup; while c == 'herro';sleep 0.1;end}}
-    sleep 0.2
+    t1 = Thread.new {@pool.hold {|c| cc = c; c1 = c.dup; while c == 'herro';sleep 0.01;end}}
+    sleep 0.02
     cc.should == 'herro'
     c1.should == 'herro'
     
-    t2 = Thread.new {@pool.hold {|c| c2 = c.dup; while c == 'hello';sleep 0.1;end}}
-    sleep 0.2
+    t2 = Thread.new {@pool.hold {|c| c2 = c.dup; while c == 'hello';sleep 0.01;end}}
+    sleep 0.02
     
     # connection held by t1
     t1.should be_alive
@@ -157,7 +157,7 @@ context "A connection pool with a max size of 1" do
     @pool.allocated.should == {t1=>cc}
     
     cc.gsub!('rr', 'll')
-    sleep 0.5
+    sleep 0.05
     
     # connection held by t2
     t1.should_not be_alive
@@ -169,7 +169,7 @@ context "A connection pool with a max size of 1" do
     @pool.allocated.should == {t2=>cc}
     
     cc.gsub!('ll', 'rr')
-    sleep 0.5
+    sleep 0.05
     
     #connection released
     t2.should_not be_alive
@@ -215,8 +215,8 @@ context "A connection pool with a max size of 5" do
     threads = []
     stop = nil
     
-    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.1;end}}; sleep 0.1}
-    sleep 0.2
+    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.01;end}}; sleep 0.01}
+    sleep 0.02
     threads.each {|t| t.should be_alive}
     cc.size.should == 5
     @invoked_count.should == 5
@@ -228,16 +228,16 @@ context "A connection pool with a max size of 5" do
     @pool.allocated.should == h
     
     threads[0].raise "your'e dead"
-    sleep 0.1
+    sleep 0.01
     threads[3].raise "your'e dead too"
     
-    sleep 0.1
+    sleep 0.01
     
     @pool.available_connections.should == [1, 4]
     @pool.allocated.should == {threads[1]=>2, threads[2]=>3, threads[4]=>5}
     
     stop = true
-    sleep 0.2
+    sleep 0.02
     
     @pool.available_connections.size.should == 5
     @pool.allocated.should be_empty
@@ -248,14 +248,14 @@ context "A connection pool with a max size of 5" do
     threads = []
     stop = nil
     
-    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.1;end}}; sleep 0.1}
-    sleep 0.2
+    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.01;end}}; sleep 0.01}
+    sleep 0.02
     threads.each {|t| t.should be_alive}
     @pool.available_connections.should be_empty
 
     3.times {|i| threads << Thread.new {@pool.hold {|c| cc[i + 5] = c}}}
     
-    sleep 0.2
+    sleep 0.02
     threads[5].should be_alive
     threads[6].should be_alive
     threads[7].should be_alive
@@ -265,7 +265,7 @@ context "A connection pool with a max size of 5" do
     cc[7].should be_nil
     
     stop = true
-    sleep 0.3
+    sleep 0.05
     
     threads.each {|t| t.should_not be_alive}
     
@@ -285,12 +285,12 @@ context "ConnectionPool#disconnect" do
   specify "should invoke the given block for each available connection" do
     threads = []
     stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
+    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.01;end}}; sleep 0.01}
     while @pool.size < 5
-      sleep 0.2
+      sleep 0.02
     end
     stop = true
-    sleep 1
+    sleep 0.1
     threads.each {|t| t.join}
     
     @pool.size.should == 5
@@ -304,12 +304,12 @@ context "ConnectionPool#disconnect" do
   specify "should remove all available connections" do
     threads = []
     stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
+    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.01;end}}; sleep 0.01}
     while @pool.size < 5
-      sleep 0.2
+      sleep 0.02
     end
     stop = true
-    sleep 1
+    sleep 0.1
     threads.each {|t| t.join}
     
     @pool.size.should == 5
@@ -320,12 +320,12 @@ context "ConnectionPool#disconnect" do
   specify "should not touch connections in use" do
     threads = []
     stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.1;end}}; sleep 0.1}
+    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.01;end}}; sleep 0.01}
     while @pool.size < 5
-      sleep 0.2
+      sleep 0.02
     end
     stop = true
-    sleep 1
+    sleep 0.1
     threads.each {|t| t.join}
     
     @pool.size.should == 5

data/spec/sequel_core/core_sql_spec.rb

@@ -51,6 +51,18 @@ context "Array#case and Hash#case" do
   end
 end
 
+context "Array#sql_array" do
+  setup do
+    @d = Sequel::Dataset.new(nil)
+  end
+
+  specify "should treat the array as an SQL array instead of conditions" do
+    @d.literal([[:x, 1], [:y, 2]]).should == '((x = 1) AND (y = 2))'
+    @d.literal([[:x, 1], [:y, 2]].sql_array).should == '((x, 1), (y, 2))'
+    @d.filter([:a, :b]=>[[:x, 1], [:y, 2]].sql_array).sql.should == 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
+  end
+end
+
 context "Array#to_sql" do
   specify "should concatenate multiple lines into a single string" do
     "SELECT * \r\nFROM items\r\n WHERE a = 1".split.to_sql. \

data/spec/sequel_core/dataset_spec.rb

@@ -725,6 +725,15 @@ context "Dataset#from" do
     @dataset.from(:a[:i]).select_sql.should ==
       "SELECT * FROM a(i)"
   end
+
+  specify "should accept :schema__table___alias symbol format" do
+    @dataset.from(:abc__def).select_sql.should ==
+      "SELECT * FROM abc.def"
+    @dataset.from(:abc__def___d).select_sql.should ==
+      "SELECT * FROM abc.def AS d"
+    @dataset.from(:abc___def).select_sql.should ==
+      "SELECT * FROM abc AS def"
+  end
 end
 
 context "Dataset#select" do
@@ -1111,8 +1120,9 @@ context "Dataset#count" do
       end
       
       def fetch_rows(sql)
+        @columns = [sql =~ /SELECT COUNT/i ? :count : :a]
         @@sql = sql
-        yield({1 => 1})
+        yield({@columns.first=>1})
       end
     end
     @dataset = @c.new(nil).from(:test)
@@ -1148,6 +1158,14 @@ context "Dataset#count" do
     @dataset.graph(@dataset, [:a], :table_alias=>:test2).count.should == 1
     @c.sql.should == 'SELECT COUNT(*) FROM test LEFT OUTER JOIN test AS test2 USING (a) LIMIT 1'
   end
+
+  specify "should not cache the columns value" do
+    ds = @dataset.from(:blah)
+    ds.columns.should == [:a]
+    ds.count.should == 1
+    @c.sql.should == 'SELECT COUNT(*) FROM blah LIMIT 1'
+    ds.columns.should == [:a]
+  end
 end
 
 
@@ -1274,16 +1292,28 @@ context "Dataset#join_table" do
       'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
   end
   
-  specify "should support aliased tables" do
+  specify "should support aliased tables using the deprecated argument" do
     @d.from('stats').join('players', {:id => :player_id}, 'p').sql.should ==
       'SELECT * FROM "stats" INNER JOIN "players" AS "p" ON ("p"."id" = "stats"."player_id")'
+  end
 
+  specify "should support aliased tables using the :table_alias option" do
+    @d.from('stats').join('players', {:id => :player_id}, :table_alias=>:p).sql.should ==
+      'SELECT * FROM "stats" INNER JOIN "players" AS "p" ON ("p"."id" = "stats"."player_id")'
+  end
+  
+  specify "should support using an alias for the FROM when doing the first join with unqualified condition columns" do
     ds = MockDataset.new(nil).from(:foo => :f)
     ds.quote_identifiers = true
     ds.join_table(:inner, :bar, :id => :bar_id).sql.should ==
       'SELECT * FROM "foo" AS "f" INNER JOIN "bar" ON ("bar"."id" = "f"."bar_id")'
   end
   
+  specify "should support the :implicit_qualifier option" do
+    @d.from('stats').join('players', {:id => :player_id}, :implicit_qualifier=>:p).sql.should ==
+      'SELECT * FROM "stats" INNER JOIN "players" ON ("players"."id" = "p"."player_id")'
+  end
+  
   specify "should allow for arbitrary conditions in the JOIN clause" do
     @d.join_table(:left_outer, :categories, :status => 0).sql.should ==
       'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."status" = 0)'
@@ -2953,6 +2983,11 @@ context "Dataset#grep" do
     @ds.grep(:title, [/^ruby/, 'ruby']).sql.should ==
       "SELECT * FROM posts WHERE (((title ~ '^ruby') OR (title LIKE 'ruby')))"
   end
+
+  specify "should support searching against other columns" do
+    @ds.grep(:title, :body).sql.should ==
+      "SELECT * FROM posts WHERE ((title LIKE body))"
+  end
 end
 
 context "Sequel.use_parse_tree" do
@@ -3158,3 +3193,43 @@ context "Sequel::Dataset #set_overrides" do
     @ds.set_overrides(:x=>2).update_sql.should == "UPDATE items SET x = 1"
   end
 end
+
+context "Sequel::Dataset#each" do
+  before do
+    @ds = Sequel::Dataset.new(nil).from(:items)
+    def @ds.fetch_rows(sql)
+      @columns = /count/i.match(sql) ? [:count] : [:a]
+      yield({@columns.first=>sql})
+    end
+  end
+
+  specify "should not set the columns if passing an option that modifies them" do
+    @ds.each(:select=>[:count]){}
+    @ds.columns.should == [:a]
+    @ds.each(:from=>[:count]){} 
+    @ds.columns.should == [:a]
+    @ds.each(:join=>[Sequel::SQL::JoinClause.new(:natural, :count)]){}
+    @ds.columns.should == [:a]
+    @ds.each(:sql=>'SELECT COUNT'){}
+    @ds.columns.should == [:a]
+  end
+
+  specify "should have the correct columns inside the block regardless" do
+    @ds.each(:select=>[:count]) do |x|
+      x[:count].should == 'SELECT count FROM items'
+      @ds.columns.should == [:count]
+    end
+    @ds.each(:from=>[:count]) do |x|
+      x[:count].should == 'SELECT * FROM count'
+      @ds.columns.should == [:count]
+    end
+    @ds.each(:join=>[Sequel::SQL::JoinClause.new(:natural, :count)]) do |x|
+      x[:count].should == 'SELECT * FROM items NATURAL JOIN count'
+      @ds.columns.should == [:count]
+    end
+    @ds.each(:sql=>'SELECT COUNT') do |x|
+      x[:count].should == 'SELECT COUNT'
+      @ds.columns.should == [:count]
+    end
+  end
+end

data/spec/sequel_core/expression_filters_spec.rb

@@ -343,4 +343,10 @@ context "Blockless Ruby Filters" do
     ce.instance_variable_set(:@op, :BANG)
     proc{@d.lit(ce)}.should raise_error(Sequel::Error)
   end
+
+  it "should support equality comparison of two expressions" do
+    e1 = ~:comment.like('%:hidden:%')
+    e2 = ~:comment.like('%:hidden:%')
+    e1.should == e2
+  end
 end

data/spec/sequel_core/object_graph_spec.rb

@@ -55,6 +55,11 @@ describe Sequel::Dataset, " graphing" do
     ds.sql.should == 'SELECT points.id, points.x, points.y, planes.id AS planes_id, planes.x AS planes_x, planes.y AS planes_y, planes.graph_id FROM points LEFT OUTER JOIN lines AS planes ON (planes.x = points.id)'
   end
 
+  it "#graph should accept a :implicit_qualifier option" do
+    ds = @ds1.graph(:lines, {:x=>:id}, :implicit_qualifier=>:planes)
+    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 = planes.id)'
+  end
+
   it "#graph should accept a :join_type option" do
     ds = @ds1.graph(:lines, {:x=>:id}, :join_type=>:inner)
     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 INNER JOIN lines ON (lines.x = points.id)'
@@ -104,13 +109,19 @@ describe Sequel::Dataset, " graphing" do
     proc{@ds1.graph(@ds2, :x=>:id).graph(@ds2, {:x=>:id}, :table_alias=>:blah)}.should_not raise_error
   end
 
-  it "#set_graph_aliases should not modify the current dataset's opts" do
+  it "#set_graph_aliases and #add_graph_aliases should not modify the current dataset's opts" do
     o1 = @ds1.opts
     o2 = o1.dup
     ds1 = @ds1.set_graph_aliases(:x=>[:graphs,:id])
     @ds1.opts.should == o1
     @ds1.opts.should == o2
     ds1.opts.should_not == o1
+    o3 = ds1.opts
+    o4 = o3.dup
+    ds2 = ds1.add_graph_aliases(:y=>[:blah,:id])
+    ds1.opts.should == o3
+    ds1.opts.should == o3
+    ds2.opts.should_not == o2
   end
 
   it "#set_graph_aliases should specify the graph mapping" do
@@ -122,6 +133,17 @@ describe Sequel::Dataset, " graphing" do
     ].should(include(ds.sql))
   end
 
+  it "#add_graph_aliases should add columns to the graph mapping" do
+    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :q]).add_graph_aliases(:y=>[:lines, :r]).sql.should == 'SELECT points.q AS x, lines.r AS y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+  end
+
+  it "#set_graph_aliases should allow a third entry to specify an expression to use other than the default" do
+    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x, 1], :y=>[:lines, :y, :random[]])
+    ['SELECT 1 AS x, random() AS y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)',
+    'SELECT random() AS y, 1 AS x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    ].should(include(ds.sql))
+  end
+
   it "#set_graph_aliases should only alias columns if necessary" do
     ds = @ds1.set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y])
     ['SELECT points.x, lines.y FROM points',
@@ -194,7 +216,7 @@ describe Sequel::Dataset, " graphing" do
     results.first.should == {:points=>{:id=>1, :x=>2, :y=>3}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}
   end
 
-  it "#graph_each should only include the columns selected with #set_graph_aliases, if called" do
+  it "#graph_each should only include the columns selected with #set_graph_aliases and #add_graph_aliases, if called" do
     ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y])
     def ds.fetch_rows(sql, &block)
       yield({:x=>2,:y=>3})
@@ -210,6 +232,22 @@ describe Sequel::Dataset, " graphing" do
     results = ds.all
     results.length.should == 1
     results.first.should == {:points=>{:x=>2}, :lines=>nil}
+
+    ds = ds.add_graph_aliases(:q=>[:points, :r, 18])
+    def ds.fetch_rows(sql, &block)
+      yield({:x=>2, :q=>18})
+    end
+    ds.all.should == [{:points=>{:x=>2, :r=>18}, :lines=>nil}]
+  end
+
+  it "#graph_each should correctly map values when #set_graph_aliases is used with a third argument for each entry" do
+    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :z1, 2], :y=>[:lines, :z2, :random[]])
+    def ds.fetch_rows(sql, &block)
+      yield({:x=>2,:y=>3})
+    end
+    results = ds.all
+    results.length.should == 1
+    results.first.should == {:points=>{:z1=>2}, :lines=>{:z2=>3}}
   end
 
   it "#graph_each should run the row_proc and transform for graphed datasets" do

data/spec/sequel_core/schema_spec.rb

@@ -10,6 +10,19 @@ context "DB#create_table" do
     @db.sqls.should == ['CREATE TABLE cats ()']
   end
 
+  specify "should accept the table name in multiple formats" do
+    @db.create_table(:cats__cats) {}
+    @db.create_table("cats__cats1") {}
+    @db.create_table(:cats__cats2.identifier) {}
+    @db.create_table(:cats.qualify(:cats3)) {}
+    @db.sqls.should == ['CREATE TABLE cats.cats ()', 'CREATE TABLE cats__cats1 ()', 'CREATE TABLE cats__cats2 ()', 'CREATE TABLE cats3.cats ()']
+  end
+
+  specify "should raise an error if the table name argument is not valid" do
+    proc{@db.create_table(1) {}}.should raise_error(Sequel::Error)
+    proc{@db.create_table(:cats.as(:c)) {}}.should raise_error(Sequel::Error)
+  end
+
   specify "should accept multiple columns" do
     @db.create_table(:cats) do
       column :id, :integer