sequel 3.10.0 → 3.11.0

data/lib/sequel/version.rb

@@ -1,6 +1,6 @@
 module Sequel
   MAJOR = 3
-  MINOR = 10
+  MINOR = 11
   TINY  = 0
   
   VERSION = [MAJOR, MINOR, TINY].join('.')

data/spec/adapters/mssql_spec.rb

@@ -375,3 +375,29 @@ context "MSSSQL::Dataset#into" do
     @db.drop_table(:new)
   end
 end
+
+context "A MSSQL database" do
+  before do
+    @db = MSSQL_DB
+  end
+  after do
+    @db.drop_table(:a)
+  end
+  
+  specify "should handle many existing types for set_column_allow_null" do
+    @db.create_table!(:a){column :a, 'integer'}
+    @db.alter_table(:a){set_column_allow_null :a, false}
+    @db.create_table!(:a){column :a, 'decimal(24, 2)'}
+    @db.alter_table(:a){set_column_allow_null :a, false}
+    @db.schema(:a).first.last[:column_size].should == 24
+    @db.schema(:a).first.last[:scale].should == 2
+    @db.create_table!(:a){column :a, 'decimal(10)'}
+    @db.schema(:a).first.last[:column_size].should == 10
+    @db.schema(:a).first.last[:scale].should == 0
+    @db.alter_table(:a){set_column_allow_null :a, false}
+    @db.create_table!(:a){column :a, 'nchar(2)'}
+    @db.alter_table(:a){set_column_allow_null :a, false}
+    s = @db.schema(:a).first.last
+    (s[:max_chars] || s[:column_size]).should == 2
+  end
+end

data/spec/adapters/mysql_spec.rb

@@ -107,14 +107,20 @@ if MYSQL_DB.class.adapter_scheme == :mysql
       @db.schema(:booltest, :reload=>true).should == [[:b, {:type=>:integer, :allow_null=>true, :primary_key=>false, :default=>nil, :ruby_default=>nil, :db_type=>"tinyint(1)"}, ], [:i, {:type=>:integer, :allow_null=>true, :primary_key=>false, :default=>nil, :ruby_default=>nil, :db_type=>"tinyint(4)"}, ]]
     end
     
-    specify "should return tinyints as bools when set" do
+    specify "should return tinyint(1)s as bools and tinyint(4)s as integers when set" do
+      Sequel::MySQL.convert_tinyint_to_bool = true
       @ds.delete
       @ds << {:b=>true, :i=>10}
-      @ds.all.should == [{:b=>true, :i=>true}]
+      @ds.all.should == [{:b=>true, :i=>10}]
       @ds.delete
       @ds << {:b=>false, :i=>0}
-      @ds.all.should == [{:b=>false, :i=>false}]
-      
+      @ds.all.should == [{:b=>false, :i=>0}]
+      @ds.delete
+      @ds << {:b=>true, :i=>1}
+      @ds.all.should == [{:b=>true, :i=>1}]
+    end
+
+    specify "should return all tinyints as integers when unset" do
       Sequel::MySQL.convert_tinyint_to_bool = false
       @ds.delete
       @ds << {:b=>true, :i=>10}
@@ -244,6 +250,29 @@ context "MySQL datasets" do
   end
 end
 
+describe "Dataset#distinct" do
+  before do
+    @db = MYSQL_DB
+    @db.create_table!(:a) do
+      Integer :a
+      Integer :b
+    end
+    @ds = @db[:a]
+  end
+  after do
+    @db.drop_table(:a)
+  end
+  
+  it "#distinct with arguments should return results distinct on those arguments" do
+    @ds.insert(20, 10)
+    @ds.insert(30, 10)
+    @ds.order(:b, :a).distinct.map(:a).should == [20, 30]
+    @ds.order(:b, :a.desc).distinct.map(:a).should == [30, 20]
+    # MySQL doesn't respect orders when using the nonstandard GROUP BY
+    [[20], [30]].should include(@ds.order(:b, :a).distinct(:b).map(:a))
+  end
+end
+
 context "MySQL join expressions" do
   before do
     @ds = MYSQL_DB[:nodes]

data/spec/adapters/postgres_spec.rb

@@ -148,6 +148,29 @@ context "A PostgreSQL dataset" do
   end
 end
 
+describe "Dataset#distinct" do
+  before do
+    @db = POSTGRES_DB
+    @db.create_table!(:a) do
+      Integer :a
+      Integer :b
+    end
+    @ds = @db[:a]
+  end
+  after do
+    @db.drop_table(:a)
+  end
+  
+  it "#distinct with arguments should return results distinct on those arguments" do
+    @ds.insert(20, 10)
+    @ds.insert(30, 10)
+    @ds.order(:b, :a).distinct.map(:a).should == [20, 30]
+    @ds.order(:b, :a.desc).distinct.map(:a).should == [30, 20]
+    @ds.order(:b, :a).distinct(:b).map(:a).should == [20]
+    @ds.order(:b, :a.desc).distinct(:b).map(:a).should == [30]
+  end
+end
+
 if POSTGRES_DB.pool.respond_to?(:max_size) and POSTGRES_DB.pool.max_size > 1
   describe "Dataset#for_update support" do
     before do
@@ -194,7 +217,7 @@ if POSTGRES_DB.pool.respond_to?(:max_size) and POSTGRES_DB.pool.max_size > 1
             c = @ds.for_share.filter(:id=>1).first
           end
         end
-        sleep 0.05
+        sleep 0.1
         @ds.filter(:id=>1).update(:name=>'Jim')
         c.should == {:id=>1, :number=>20, :name=>nil}
       end

data/spec/adapters/spec_helper.rb

@@ -10,6 +10,12 @@ begin
 rescue LoadError
 end
 
+class Sequel::Database
+  def log_duration(duration, message)
+    log_info(message)
+  end
+end
+
 class Spec::Example::ExampleGroup
   def log 
     begin

data/spec/adapters/sqlite_spec.rb

@@ -36,6 +36,34 @@ context "An SQLite database" do
     end
   end
   
+  specify "should provide the SQLite version as an integer" do
+    @db.sqlite_version.should be_a_kind_of(Integer)
+  end
+  
+  specify "should support setting and getting the foreign_keys pragma" do
+    (@db.sqlite_version >= 30619 ? [true, false] : [nil]).should include(@db.foreign_keys)
+    @db.foreign_keys = true
+    @db.foreign_keys = false
+  end
+  
+  if SQLITE_DB.sqlite_version >= 30619
+    specify "should enforce foreign key integrity if foreign_keys pragma is set" do
+      @db.foreign_keys = true
+      @db.create_table!(:fk){primary_key :id; foreign_key :parent_id, :fk}
+      @db[:fk].insert(1, nil)
+      @db[:fk].insert(2, 1)
+      @db[:fk].insert(3, 3)
+      proc{@db[:fk].insert(4, 5)}.should raise_error(Sequel::Error)
+    end
+  end
+  
+  specify "should not enforce foreign key integrity if foreign_keys pragma is unset" do
+    @db.foreign_keys = false
+    @db.create_table!(:fk){primary_key :id; foreign_key :parent_id, :fk}
+    @db[:fk].insert(1, 2)
+    @db[:fk].all.should == [{:id=>1, :parent_id=>2}]
+  end
+  
   specify "should provide a list of existing tables" do
     @db.drop_table(:testing) rescue nil
     @db.tables.should be_a_kind_of(Array)

data/spec/core/connection_pool_spec.rb

@@ -240,8 +240,8 @@ shared_examples_for "A threaded connection pool" do
     threads = []
     stop = nil
     
-    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.01;end}}; sleep 0.01}
-    sleep 0.02
+    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.02;end}}; sleep 0.02}
+    sleep 0.04
     threads.each {|t| t.should be_alive}
     cc.size.should == 5
     @invoked_count.should == 5
@@ -253,16 +253,16 @@ shared_examples_for "A threaded connection pool" do
     @pool.allocated.should == h
     
     threads[0].raise "your'e dead"
-    sleep 0.01
+    sleep 0.02
     threads[3].raise "your'e dead too"
     
-    sleep 0.01
+    sleep 0.02
     
     @pool.available_connections.should == [1, 4]
     @pool.allocated.should == {threads[1]=>2, threads[2]=>3, threads[4]=>5}
     
     stop = true
-    sleep 0.02
+    sleep 0.04
     
     @pool.available_connections.size.should == 5
     @pool.allocated.should be_empty
@@ -734,6 +734,12 @@ context "A single threaded pool with multiple servers" do
 end
 
 shared_examples_for "All connection pools classes" do
+  specify "should not raise an error when disconnecting twice" do
+    c = @class.new({}){123}
+    proc{c.disconnect}.should_not raise_error
+    proc{c.disconnect}.should_not raise_error
+  end
+  
   specify "should yield a connection created by the initialize block to hold" do
     x = nil
     @class.new({}){123}.hold{|c| x = c}
@@ -746,6 +752,12 @@ shared_examples_for "All connection pools classes" do
     x.should == [:default, :default]
   end
   
+  specify "should have respect an :after_connect proc that is called with each newly created connection" do
+    x = nil
+    @class.new(:after_connect=>proc{|c| x = [c, c]}){|c| 123}.hold{}
+    x.should == [123, 123]
+  end
+  
   specify "should raise a DatabaseConnectionError if the connection raises an exception" do
     proc{@class.new({}){|c| raise Exception}.hold{}}.should raise_error(Sequel::DatabaseConnectionError)
   end

data/spec/core/database_spec.rb

@@ -209,6 +209,88 @@ context "Database#connect" do
   end
 end
 
+context "Database#log_info" do
+  before do
+    @o = Object.new
+    def @o.logs; @logs || []; end
+    def @o.method_missing(*args); (@logs ||= []) << args; end
+    @db = Sequel::Database.new(:logger=>@o)
+  end
+
+  specify "should log message at info level to all loggers" do
+    @db.log_info('blah')
+    @o.logs.should == [[:info, 'blah']]
+  end
+
+  specify "should log message with args at info level to all loggers" do
+    @db.log_info('blah', [1, 2])
+    @o.logs.should == [[:info, 'blah; [1, 2]']]
+  end
+end
+
+context "Database#log_yield" do
+  before do
+    @o = Object.new
+    def @o.logs; @logs || []; end
+    def @o.warn(*args); (@logs ||= []) << [:warn] + args; end
+    def @o.method_missing(*args); (@logs ||= []) << args; end
+    @db = Sequel::Database.new(:logger=>@o)
+  end
+
+  specify "should yield to the passed block" do
+    a = nil
+    @db.log_yield('blah'){a = 1}
+    a.should == 1
+  end
+
+  specify "should raise an exception if a block is not passed" do
+    proc{@db.log_yield('blah')}.should raise_error
+  end
+
+  specify "should log message with duration at info level to all loggers" do
+    @db.log_yield('blah'){}
+    @o.logs.length.should == 1
+    @o.logs.first.length.should == 2
+    @o.logs.first.first.should == :info
+    @o.logs.first.last.should =~ /\A\(\d\.\d{6}s\) blah\z/ 
+  end
+
+  specify "should log message with duration at warn level if duration greater than log_warn_duration" do
+    @db.log_warn_duration = 0
+    @db.log_yield('blah'){}
+    @o.logs.length.should == 1
+    @o.logs.first.length.should == 2
+    @o.logs.first.first.should == :warn
+    @o.logs.first.last.should =~ /\A\(\d\.\d{6}s\) blah\z/ 
+  end
+
+  specify "should log message with duration at info level if duration less than log_warn_duration" do
+    @db.log_warn_duration = 1000
+    @db.log_yield('blah'){}
+    @o.logs.length.should == 1
+    @o.logs.first.length.should == 2
+    @o.logs.first.first.should == :info
+    @o.logs.first.last.should =~ /\A\(\d\.\d{6}s\) blah\z/ 
+  end
+
+  specify "should log message at error level if block raises an error" do
+    @db.log_warn_duration = 0
+    proc{@db.log_yield('blah'){raise Sequel::Error, 'adsf'}}.should raise_error
+    @o.logs.length.should == 1
+    @o.logs.first.length.should == 2
+    @o.logs.first.first.should == :error
+    @o.logs.first.last.should =~ /\ASequel::Error: adsf: blah\z/ 
+  end
+
+  specify "should include args with message if args passed" do
+    @db.log_yield('blah', [1, 2]){}
+    @o.logs.length.should == 1
+    @o.logs.first.length.should == 2
+    @o.logs.first.first.should == :info
+    @o.logs.first.last.should =~ /\A\(\d\.\d{6}s\) blah; \[1, 2\]\z/ 
+  end
+end
+
 context "Database#uri" do
   before do
     @c = Class.new(Sequel::Database) do
@@ -342,7 +424,7 @@ context "Database#test_connection" do
     @db = Sequel::Database.new{@test = rand(100)}
   end
   
-  specify "should call pool#hold" do
+  specify "should pool#hold" do
     @db.test_connection
     @test.should_not be_nil
   end
@@ -350,6 +432,10 @@ context "Database#test_connection" do
   specify "should return true if successful" do
     @db.test_connection.should be_true
   end
+
+  specify "should raise an error if the attempting to connect raises an error" do
+    proc{Sequel::Database.new{raise Sequel::Error, 'blah'}.test_connection}.should raise_error(Sequel::Error)
+  end
 end
 
 class DummyDataset < Sequel::Dataset
@@ -875,6 +961,20 @@ context "A Database adapter with a scheme" do
     c.opts[:database].should == 'd[b]'
     c.opts[:host].should == 'domain\\instance'
   end
+
+  specify "should test the connection if test parameter is truthy" do
+    proc{Sequel.connect 'ccc:///d%5bb%5d?test=t'}.should raise_error(Sequel::DatabaseConnectionError)
+    proc{Sequel.connect 'ccc:///d%5bb%5d?test=1'}.should raise_error(Sequel::DatabaseConnectionError)
+    proc{Sequel.connect 'ccc:///d%5bb%5d', :test=>true}.should raise_error(Sequel::DatabaseConnectionError)
+    proc{Sequel.connect 'ccc:///d%5bb%5d', :test=>'t'}.should raise_error(Sequel::DatabaseConnectionError)
+  end
+
+  specify "should not test the connection if test parameter is not truthy" do
+    proc{Sequel.connect 'ccc:///d%5bb%5d?test=f'}.should_not raise_error
+    proc{Sequel.connect 'ccc:///d%5bb%5d?test=0'}.should_not raise_error
+    proc{Sequel.connect 'ccc:///d%5bb%5d', :test=>false}.should_not raise_error
+    proc{Sequel.connect 'ccc:///d%5bb%5d', :test=>'f'}.should_not raise_error
+  end
 end
 
 context "Sequel::Database.connect" do

data/spec/core/dataset_spec.rb

@@ -322,6 +322,16 @@ context "Dataset#where" do
     @d3 = @dataset.where("a = 1")
   end
   
+  specify "should just clone if given an empty argument" do
+    @dataset.where({}).sql.should == @dataset.sql
+    @dataset.where([]).sql.should == @dataset.sql
+    @dataset.where('').sql.should == @dataset.sql
+
+    @dataset.filter({}).sql.should == @dataset.sql
+    @dataset.filter([]).sql.should == @dataset.sql
+    @dataset.filter('').sql.should == @dataset.sql
+  end
+  
   specify "should work with hashes" do
     @dataset.where(:name => 'xyz', :price => 342).select_sql.
       should match(/WHERE \(\(name = 'xyz'\) AND \(price = 342\)\)|WHERE \(\(price = 342\) AND \(name = 'xyz'\)\)/)
@@ -735,6 +745,12 @@ context "Dataset#having" do
     @columns = "region, sum(population), avg(gdp)"
   end
 
+  specify "should just clone if given an empty argument" do
+    @dataset.having({}).sql.should == @dataset.sql
+    @dataset.having([]).sql.should == @dataset.sql
+    @dataset.having('').sql.should == @dataset.sql
+  end
+  
   specify "should affect select statements" do
     @d1.select_sql.should ==
       "SELECT #{@columns} FROM test GROUP BY region HAVING (sum(population) > 10)"
@@ -1151,6 +1167,28 @@ context "Dataset#select_more" do
   end
 end
 
+context "Dataset#select_append" do
+  before do
+    @d = Sequel::Dataset.new(nil).from(:test)
+  end
+  
+  specify "should select * in addition to columns if no columns selected" do
+    @d.select_append(:a, :b).sql.should == 'SELECT *, a, b FROM test'
+    @d.select_all.select_append(:a, :b).sql.should == 'SELECT *, a, b FROM test'
+    @d.select(:blah).select_all.select_append(:a, :b).sql.should == 'SELECT *, a, b FROM test'
+  end
+
+  specify "should add to the currently selected columns" do
+    @d.select(:a).select_append(:b).sql.should == 'SELECT a, b FROM test'
+    @d.select(:a.*).select_append(:b.*).sql.should == 'SELECT a.*, b.* FROM test'
+  end
+
+  specify "should accept a block that yields a virtual row" do
+    @d.select(:a).select_append{|o| o.b}.sql.should == 'SELECT a, b FROM test'
+    @d.select(:a.*).select_append(:b.*){b(1)}.sql.should == 'SELECT a.*, b.*, b(1) FROM test'
+  end
+end
+
 context "Dataset#order" do
   before do
     @dataset = Sequel::Dataset.new(nil).from(:test)
@@ -1484,13 +1522,13 @@ context "Dataset#distinct" do
     @dataset.distinct.sql.should == 'SELECT DISTINCT name FROM test'
   end
   
-  specify "should raise an error if columns given and distinct on not supported" do
-    @dataset.meta_def(:supports_distinct_on?){false}
+  specify "should raise an error if columns given and DISTINCT ON is not supported" do
     proc{@dataset.distinct}.should_not raise_error
     proc{@dataset.distinct(:a)}.should raise_error(Sequel::InvalidOperation)
   end
   
-  specify "should accept an expression list" do
+  specify "should use DISTINCT ON if columns are given and DISTINCT ON is supported" do
+    @dataset.meta_def(:supports_distinct_on?){true}
     @dataset.distinct(:a, :b).sql.should == 'SELECT DISTINCT ON (a, b) name FROM test'
     @dataset.distinct(:stamp.cast(:integer), :node_id=>nil).sql.should == 'SELECT DISTINCT ON (CAST(stamp AS integer), (node_id IS NULL)) name FROM test'
   end
@@ -2541,7 +2579,7 @@ context "Dataset#columns" do
   end
   
   specify "should ignore any filters, orders, or DISTINCT clauses" do
-    @dataset.filter!(:b=>100).order!(:b).distinct!(:b)
+    @dataset.filter!(:b=>100).order!(:b).distinct!
     @dataset.columns = nil
     @dataset.columns.should == 'SELECT * FROM items LIMIT 1a'
   end