sequel 3.7.0 → 3.8.0

data/spec/adapters/mysql_spec.rb

@@ -62,6 +62,17 @@ context "MySQL", '#create_table' do
     @db.create_table(:dolls){File :name, :default=>'blah'}
     @db.sqls.should == ["CREATE TABLE dolls (name blob)"]
   end
+  
+  specify "should respect the size option for File type" do
+    @db.create_table(:dolls) do
+      File :n1
+      File :n2, :size=>:tiny
+      File :n3, :size=>:medium
+      File :n4, :size=>:long
+      File :n5, :size=>255
+    end
+    @db.schema(:dolls).map{|k, v| v[:db_type]}.should == %w"blob tinyblob mediumblob longblob blob"
+  end
 end
 
 context "A MySQL database" do
@@ -942,6 +953,17 @@ if MYSQL_DB.class.adapter_scheme == :mysql
       @ds.all.should == [{:a=>10}, {:a=>15}, {:b=>20}, {:b=>25}]
     end
     
+    specify "should work with Database#run" do
+      proc{MYSQL_DB.run('SELECT * FROM a; SELECT * FROM b')}.should_not raise_error
+      proc{MYSQL_DB.run('SELECT * FROM a; SELECT * FROM b')}.should_not raise_error
+    end
+    
+    specify "should work with Database#run and other statements" do
+      proc{MYSQL_DB.run('UPDATE a SET a = 1; SELECT * FROM a; DELETE FROM b')}.should_not raise_error
+      MYSQL_DB[:a].select_order_map(:a).should == [1, 1]
+      MYSQL_DB[:b].all.should == []
+    end
+    
     specify "should split results returned into arrays if split_multiple_result_sets is used" do
       @ds.split_multiple_result_sets.all.should == [[{:a=>10}, {:a=>15}], [{:b=>20}, {:b=>25}]]
     end

data/spec/core/connection_pool_spec.rb

@@ -86,7 +86,7 @@ context "A connection pool handling connections" do
 
   specify "#make_new should not make more than max_size connections" do
     50.times{Thread.new{@cpool.hold{sleep 0.001}}}
-    @cpool.created_count.should == @max_size
+    @cpool.created_count.should <= @max_size
   end
 
   specify ":disconnection_proc option should set the disconnection proc to use" do
@@ -383,7 +383,7 @@ context "ConnectionPool#disconnect" do
     @pool.size.should == 0
   end
 
-  specify "should not touch connections in use" do
+  specify "should disconnect connections in use as soon as they are no longer in use" do
     threads = []
     stop = nil
     5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.01;end}}; sleep 0.01}
@@ -402,8 +402,9 @@ context "ConnectionPool#disconnect" do
       conns = []
       @pool.disconnect {|c| conns << c}
       conns.size.should == 4
+      @pool.size.should == 1
     end
-    @pool.size.should == 1
+    @pool.size.should == 0
   end
 end
 
@@ -413,6 +414,10 @@ context "A connection pool with multiple servers" do
     @pool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:servers=>{:read_only=>{}})){|server| "#{server}#{@invoked_counts[server] += 1}"}
   end
   
+  specify "#servers should return symbols for all servers" do
+    @pool.servers.sort_by{|s| s.to_s}.should == [:default, :read_only]
+  end
+
   specify "should use the :default server by default" do
     @pool.size.should == 0
     @pool.hold do |c|
@@ -423,6 +428,18 @@ context "A connection pool with multiple servers" do
     @pool.size.should == 1
     @invoked_counts.should == {:default=>1}
   end
+  
+  specify "should use the :default server an invalid server is used" do
+    @pool.hold do |c1|
+      c1.should == "default1"
+      @pool.hold(:blah) do |c2|
+        c2.should == c1
+        @pool.hold(:blah2) do |c3|
+          c2.should == c3
+        end
+      end
+    end
+  end
 
   specify "should use the requested server if server is given" do
     @pool.size(:read_only).should == 0
@@ -464,6 +481,144 @@ context "A connection pool with multiple servers" do
     @pool.hold(:read_only){|c| c.should == 'read_only2'}
     @pool.hold{|c| c.should == 'default2'}
   end
+  
+  specify "#add_servers should add new servers to the pool" do
+    pool = Sequel::ConnectionPool.new(:servers=>{:server1=>{}}){|s| s}
+    
+    pool.hold{}
+    pool.hold(:server2){}
+    pool.hold(:server3){}
+    pool.hold(:server1) do
+      pool.allocated.length.should == 0
+      pool.allocated(:server1).length.should == 1
+      pool.allocated(:server2).should == nil
+      pool.allocated(:server3).should == nil
+      pool.available_connections.length.should == 1
+      pool.available_connections(:server1).length.should == 0
+      pool.available_connections(:server2).should == nil
+      pool.available_connections(:server3).should == nil
+
+      pool.add_servers([:server2, :server3])
+      pool.hold(:server2){}
+      pool.hold(:server3) do 
+        pool.allocated.length.should == 0
+        pool.allocated(:server1).length.should == 1
+        pool.allocated(:server2).length.should == 0
+        pool.allocated(:server3).length.should == 1
+        pool.available_connections.length.should == 1
+        pool.available_connections(:server1).length.should == 0
+        pool.available_connections(:server2).length.should == 1
+        pool.available_connections(:server3).length.should == 0
+      end
+    end
+  end
+
+  specify "#add_servers should ignore existing keys" do
+    pool = Sequel::ConnectionPool.new(:servers=>{:server1=>{}}){|s| s}
+    
+    pool.allocated.length.should == 0
+    pool.allocated(:server1).length.should == 0
+    pool.available_connections.length.should == 0
+    pool.available_connections(:server1).length.should == 0
+    pool.hold do |c1| 
+      c1.should == :default
+      pool.allocated.length.should == 1
+      pool.allocated(:server1).length.should == 0
+      pool.available_connections.length.should == 0
+      pool.available_connections(:server1).length.should == 0
+      pool.hold(:server1) do |c2| 
+        c2.should == :server1
+        pool.allocated.length.should == 1
+        pool.allocated(:server1).length.should == 1
+        pool.available_connections.length.should == 0
+        pool.available_connections(:server1).length.should == 0
+        pool.add_servers([:default, :server1])
+        pool.allocated.length.should == 1
+        pool.allocated(:server1).length.should == 1
+        pool.available_connections.length.should == 0
+        pool.available_connections(:server1).length.should == 0
+      end
+      pool.allocated.length.should == 1
+      pool.allocated(:server1).length.should == 0
+      pool.available_connections.length.should == 0
+      pool.available_connections(:server1).length.should == 1
+      pool.add_servers([:default, :server1])
+      pool.allocated.length.should == 1
+      pool.allocated(:server1).length.should == 0
+      pool.available_connections.length.should == 0
+      pool.available_connections(:server1).length.should == 1
+    end
+    pool.allocated.length.should == 0
+    pool.allocated(:server1).length.should == 0
+    pool.available_connections.length.should == 1
+    pool.available_connections(:server1).length.should == 1
+    pool.add_servers([:default, :server1])
+    pool.allocated.length.should == 0
+    pool.allocated(:server1).length.should == 0
+    pool.available_connections.length.should == 1
+    pool.available_connections(:server1).length.should == 1
+  end
+  
+  specify "#remove_servers should disconnect available connections immediately" do
+    pool = Sequel::ConnectionPool.new(:max_connections=>5, :servers=>{:server1=>{}}){|s| s}
+    threads = []
+    stop = nil
+    5.times {|i| threads << Thread.new{pool.hold(:server1){|c| sleep 0.05}}}
+    sleep 0.1
+    threads.each {|t| t.join}
+    
+    pool.size(:server1).should == 5
+    pool.remove_servers([:server1])
+    pool.size(:server1).should == 0
+  end
+  
+  specify "#remove_servers should disconnect connections in use as soon as they are returned to the pool" do
+    dc = []
+    pool = Sequel::ConnectionPool.new(:servers=>{:server1=>{}}, :disconnection_proc=>proc{|c| dc << c}){|s| s}
+    c1 = nil
+    pool.hold(:server1) do |c|
+      pool.size(:server1).should == 1
+      dc.should == []
+      pool.remove_servers([:server1])
+      pool.size(:server1).should == 0
+      dc.should == []
+      c1 = c
+    end
+    pool.size(:server1).should == 0
+    dc.should == [c1]
+  end
+  
+  specify "#remove_servers should remove server related data structures immediately" do
+    pool = Sequel::ConnectionPool.new(:servers=>{:server1=>{}}){|s| s}
+    pool.available_connections(:server1).should == []
+    pool.allocated(:server1).should == {}
+    pool.remove_servers([:server1])
+    pool.available_connections(:server1).should == nil
+    pool.allocated(:server1).should == nil
+  end
+  
+  specify "#remove_servers should not allow the removal of the default server" do
+    pool = Sequel::ConnectionPool.new(:servers=>{:server1=>{}}){|s| s}
+    proc{pool.remove_servers([:server1])}.should_not raise_error
+    proc{pool.remove_servers([:default])}.should raise_error(Sequel::Error)
+  end
+  
+  specify "#remove_servers should ignore servers that have already been removed" do
+    dc = []
+    pool = Sequel::ConnectionPool.new(:servers=>{:server1=>{}}, :disconnection_proc=>proc{|c| dc << c}){|s| s}
+    c1 = nil
+    pool.hold(:server1) do |c|
+      pool.size(:server1).should == 1
+      dc.should == []
+      pool.remove_servers([:server1])
+      pool.remove_servers([:server1])
+      pool.size(:server1).should == 0
+      dc.should == []
+      c1 = c
+    end
+    pool.size(:server1).should == 0
+    dc.should == [c1]
+  end
 end
 
 context "SingleThreadedPool" do
@@ -493,10 +648,63 @@ context "A single threaded pool with multiple servers" do
     @pool = Sequel::SingleThreadedPool.new(CONNECTION_POOL_DEFAULTS.merge(:disconnection_proc=>proc{|c| @max_size=3}, :servers=>{:read_only=>{}})){|server| server}
   end
   
+  specify "#servers should return symbols for all servers" do
+    @pool.servers.sort_by{|s| s.to_s}.should == [:default, :read_only]
+  end
+  
+  specify "#add_servers should add new servers to the pool" do
+    @pool.hold(:blah){|c| c.should == :default}
+    @pool.add_servers([:blah])
+    @pool.hold(:blah){|c| c.should == :blah}
+  end
+  
+  specify "#add_servers should ignore keys already existing" do
+    @pool.hold{|c| c.should == :default}
+    @pool.hold(:read_only){|c| c.should == :read_only}
+    @pool.add_servers([:default, :read_only])
+    @pool.conn.should == :default
+    @pool.conn(:read_only).should == :read_only
+  end
+  
+  specify "#remove_servers should remove servers from the pool" do
+    @pool.hold(:read_only){|c| c.should == :read_only}
+    @pool.remove_servers([:read_only])
+    @pool.hold(:read_only){|c| c.should == :default}
+  end
+  
+  specify "#remove_servers should not allow the removal of the default server" do
+    proc{@pool.remove_servers([:default])}.should raise_error(Sequel::Error)
+  end
+  
+  specify "#remove_servers should disconnect connection immediately" do
+    @pool.hold(:read_only){|c| c.should == :read_only}
+    @pool.conn(:read_only).should == :read_only
+    @pool.remove_servers([:read_only])
+    @pool.conn(:read_only).should == nil
+    @pool.hold{}
+    @pool.conn(:read_only).should == :default
+  end
+  
+  specify "#remove_servers should ignore keys that do not exist" do
+    proc{@pool.remove_servers([:blah])}.should_not raise_error
+  end
+  
   specify "should use the :default server by default" do
     @pool.hold{|c| c.should == :default}
     @pool.conn.should == :default
   end
+  
+  specify "should use the :default server an invalid server is used" do
+    @pool.hold do |c1|
+      c1.should == :default
+      @pool.hold(:blah) do |c2|
+        c2.should == c1
+        @pool.hold(:blah2) do |c3|
+          c2.should == c3
+        end
+      end
+    end
+  end
 
   specify "should use the requested server if server is given" do
     @pool.hold(:read_only){|c| c.should == :read_only}

data/spec/core/core_sql_spec.rb

@@ -408,3 +408,10 @@ context "Sequel::SQL::OrderedExpression" do
     @oe.invert.invert.descending.should == true
   end
 end
+
+context "Expression" do
+  specify "should ==" do
+    :column.qualify(:table).cast(:type).*(:numeric_column).asc.should == :column.qualify(:table).cast(:type).*(:numeric_column).asc
+    :other_column.qualify(:table).cast(:type).*(:numeric_column).asc.should_not == :column.qualify(:table).cast(:type).*(:numeric_column).asc
+  end
+end

data/spec/core/database_spec.rb

@@ -191,7 +191,7 @@ context "Database#disconnect" do
   specify "should call pool.disconnect" do
     d = Sequel::Database.new
     p = d.pool
-    p.should_receive(:disconnect).once.and_return(2)
+    p.should_receive(:disconnect).once.with({}).and_return(2)
     d.disconnect.should == 2
   end
 end
@@ -951,12 +951,30 @@ context "A single threaded database" do
     @db.pool.hold {|c| c.should == 1234568}
   end
   
-  specify "should convert an Exception into a RuntimeError" do
-    db = Sequel::Database.new(:single_threaded => true) do
-      raise Exception
-    end
-    
-    proc {db.pool.hold {|c|}}.should raise_error(RuntimeError)
+  specify "should disconnect correctly" do
+    def @db.disconnect_connection(c); @dc = c end
+    def @db.dc; @dc end
+    x = nil
+    @db.pool.hold{|c| x = c}
+    @db.pool.conn.should == x
+    proc{@db.disconnect}.should_not raise_error
+    @db.pool.conn.should == nil
+    @db.dc.should == x
+  end
+  
+  specify "should convert an Exception on connection into a DatabaseConnectionError" do
+    db = Sequel::Database.new(:single_threaded => true){raise Exception}
+    proc {db.pool.hold {|c|}}.should raise_error(Sequel::DatabaseConnectionError)
+  end
+  
+  specify "should raise a DatabaseConnectionError if the connection proc returns nil" do
+    db = Sequel::Database.new(:single_threaded => true){nil}
+    proc {db.pool.hold {|c|}}.should raise_error(Sequel::DatabaseConnectionError)
+  end
+  
+  specify "should convert an Exceptions during use into RuntimeErrors" do
+    db = Sequel::Database.new(:single_threaded => true){Object.new}
+    proc {db.synchronize{raise Exception}}.should raise_error(RuntimeError)
   end
 end
 
@@ -1232,6 +1250,140 @@ context "Database#server_opts" do
   end
 end
 
+context "Database#add_servers" do
+  before do
+    @db = MockDatabase.new(:host=>1, :database=>2, :servers=>{:server1=>{:host=>3}})
+    def @db.connect(server)
+      server_opts(server)
+    end
+    def @db.disconnect_connection(c)
+    end
+  end
+
+  specify "should add new servers to the connection pool" do
+    @db.synchronize{|c| c[:host].should == 1}
+    @db.synchronize(:server1){|c| c[:host].should == 3}
+    @db.synchronize(:server2){|c| c[:host].should == 1}
+
+    @db.add_servers(:server2=>{:host=>6})
+    @db.synchronize{|c| c[:host].should == 1}
+    @db.synchronize(:server1){|c| c[:host].should == 3}
+    @db.synchronize(:server2){|c| c[:host].should == 6}
+
+    @db.disconnect
+    @db.synchronize{|c| c[:host].should == 1}
+    @db.synchronize(:server1){|c| c[:host].should == 3}
+    @db.synchronize(:server2){|c| c[:host].should == 6}
+  end
+
+  specify "should replace options for future connections to existing servers" do
+    @db.synchronize{|c| c[:host].should == 1}
+    @db.synchronize(:server1){|c| c[:host].should == 3}
+    @db.synchronize(:server2){|c| c[:host].should == 1}
+
+    @db.add_servers(:default=>proc{{:host=>4}}, :server1=>{:host=>8})
+    @db.synchronize{|c| c[:host].should == 1}
+    @db.synchronize(:server1){|c| c[:host].should == 3}
+    @db.synchronize(:server2){|c| c[:host].should == 1}
+
+    @db.disconnect
+    @db.synchronize{|c| c[:host].should == 4}
+    @db.synchronize(:server1){|c| c[:host].should == 8}
+    @db.synchronize(:server2){|c| c[:host].should == 4}
+  end
+end
+
+context "Database#remove_servers" do
+  before do
+    @db = MockDatabase.new(:host=>1, :database=>2, :servers=>{:server1=>{:host=>3}, :server2=>{:host=>4}})
+    def @db.connect(server)
+      server_opts(server)
+    end
+    def @db.disconnect_connection(c)
+    end
+  end
+
+  specify "should remove servers from the connection pool" do
+    @db.synchronize{|c| c[:host].should == 1}
+    @db.synchronize(:server1){|c| c[:host].should == 3}
+    @db.synchronize(:server2){|c| c[:host].should == 4}
+
+    @db.remove_servers(:server1, :server2)
+    @db.synchronize{|c| c[:host].should == 1}
+    @db.synchronize(:server1){|c| c[:host].should == 1}
+    @db.synchronize(:server2){|c| c[:host].should == 1}
+  end
+  
+  specify "should accept arrays of symbols" do
+    @db.remove_servers([:server1, :server2])
+    @db.synchronize{|c| c[:host].should == 1}
+    @db.synchronize(:server1){|c| c[:host].should == 1}
+    @db.synchronize(:server2){|c| c[:host].should == 1}
+  end
+
+  specify "should allow removal while connections are still open" do
+    @db.synchronize do |c1|
+      c1[:host].should == 1
+      @db.synchronize(:server1) do |c2|
+        c2[:host].should == 3
+        @db.synchronize(:server2) do |c3|
+          c3[:host].should == 4
+          @db.remove_servers(:server1, :server2)
+            @db.synchronize(:server1) do |c4|
+              c4.should_not == c2
+              c4.should == c1
+              c4[:host].should == 1
+              @db.synchronize(:server2) do |c5|
+                c5.should_not == c3
+                c5.should == c1
+                c5[:host].should == 1
+              end
+            end
+          c3[:host].should == 4
+         end
+        c2[:host].should == 3
+      end
+      c1[:host].should == 1
+    end
+  end
+end
+
+context "Database#each_server" do
+  before do
+    @db = Sequel.connect(:adapter=>:mock, :host=>1, :database=>2, :servers=>{:server1=>{:host=>3}, :server2=>{:host=>4}})
+    def @db.connect(server)
+      server_opts(server)
+    end
+    def @db.disconnect_connection(c)
+    end
+  end
+
+  specify "should yield a separate database object for each server" do
+    hosts = []
+    @db.each_server do |db|
+      db.should be_a_kind_of(Sequel::Database)
+      db.should_not == @db
+      db.opts[:database].should == 2
+      hosts << db.opts[:host]
+    end
+    hosts.sort.should == [1, 3, 4]
+  end
+
+  specify "should disconnect and remove entry from Sequel::DATABASES after use" do
+    dbs = []
+    dcs = []
+    @db.each_server do |db|
+      dbs << db
+      Sequel::DATABASES.should include(db)
+      db.meta_def(:disconnect){dcs << db}
+    end
+    dbs.each do |db|
+      Sequel::DATABASES.should_not include(db)
+    end
+    dbs.should == dcs
+  end
+end
+  
 context "Database#raise_error" do
   specify "should reraise if the exception class is not in opts[:classes]" do
     e = Class.new(StandardError)