sequel 3.21.0 → 3.28.0

data/spec/adapters/db2_spec.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+#Author: Roy L Zuo (roylzuo at gmail dot com)
+#Description: 
+
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+
+require ENV['SEQUEL_DB2_SPEC_REQUIRE'] if ENV['SEQUEL_DB2_SPEC_REQUIRE']
+
+unless defined?(DB2_DB)
+  DB2_DB = Sequel.connect(ENV['SEQUEL_DB2_SPEC_DB']||DB2_URL)
+end
+
+if DB2_DB.table_exists?(:test)
+  DB2_DB.drop_table :test
+end
+INTEGRATION_DB = DB2_DB unless defined?(INTEGRATION_DB)
+
+describe Sequel::Database do
+  before do
+    @db = DB2_DB
+    @db.create_table(:test){String :a}
+    @ds = @db[:test]
+  end
+
+  after do
+    @db.drop_table(:test)
+  end
+  
+  specify "should provide disconnect functionality after preparing a connection" do
+    @ds.prepare(:first, :a).call
+    @db.disconnect
+    @db.pool.size.should == 0
+  end
+
+  specify "should return version correctly" do
+    @db.db2_version.should match(/DB2 v/i)
+  end
+end
+
+describe "Simple Dataset operations" do
+  before do
+    DB2_DB.create_table!(:items) do
+      Integer :id, :primary_key => true
+      Integer :number
+    end
+    @ds = DB2_DB[:items]
+    @ds.insert(:number=>10, :id => 1 )
+  end
+  after do
+    DB2_DB.drop_table(:items)
+  end
+  cspecify "should insert with a primary key specified", :mssql do
+    @ds.insert(:id=>100, :number=>20)
+    @ds.count.should == 2
+    @ds.order(:id).all.should == [{:id=>1, :number=>10}, {:id=>100, :number=>20}]
+  end
+end
+
+describe Sequel::Database do
+  before do
+    @db = DB2_DB
+  end
+  after do
+    @db.drop_table(:items)
+  end
+  specify "should parse primary keys from the schema properly" do
+    @db.create_table!(:items){Integer :number}
+    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == []
+    @db.create_table!(:items){primary_key :number}
+    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number]
+    @db.create_table!(:items){Integer :number1, :null => false; Integer :number2, :null => false; primary_key [:number1, :number2]}
+    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number1, :number2]
+  end
+end
+
+describe "Sequel::IBMDB.convert_smallint_to_bool" do
+  before do
+    @db = DB2_DB
+    @db.create_table!(:booltest){column :b, 'smallint'; column :i, 'integer'}
+    @ds = @db[:booltest]
+  end
+  after do
+    Sequel::IBMDB.convert_smallint_to_bool = true
+    @db.drop_table(:booltest)
+  end
+  
+  specify "should consider smallint datatypes as boolean if set, but not larger smallints" do
+    @db.schema(:booltest, :reload=>true).first.last[:type].should == :boolean
+    @db.schema(:booltest, :reload=>true).first.last[:db_type].should match /smallint/i
+    Sequel::IBMDB.convert_smallint_to_bool = false
+    @db.schema(:booltest, :reload=>true).first.last[:type].should == :integer
+    @db.schema(:booltest, :reload=>true).first.last[:db_type].should match /smallint/i
+  end
+  
+  specify "should return smallints as bools and integers as integers when set" do
+    Sequel::IBMDB.convert_smallint_to_bool = true
+    @ds.delete
+    @ds << {:b=>true, :i=>10}
+    @ds.all.should == [{:b=>true, :i=>10}]
+    @ds.delete
+    @ds << {:b=>false, :i=>0}
+    @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 smallints as integers when unset" do
+    Sequel::IBMDB.convert_smallint_to_bool = false
+    @ds.delete
+    @ds << {:b=>true, :i=>10}
+    @ds.all.should == [{:b=>1, :i=>10}]
+    @ds.delete
+    @ds << {:b=>false, :i=>0}
+    @ds.all.should == [{:b=>0, :i=>0}]
+    
+    @ds.delete
+    @ds << {:b=>1, :i=>10}
+    @ds.all.should == [{:b=>1, :i=>10}]
+    @ds.delete
+    @ds << {:b=>0, :i=>0}
+    @ds.all.should == [{:b=>0, :i=>0}]
+  end
+end if DB2_DB.adapter_scheme == :ibmdb
+
+describe "Simple Dataset operations in transactions" do
+  before do
+    DB2_DB.create_table!(:items_insert_in_transaction) do
+      Integer :id, :primary_key => true
+      integer :number
+    end
+    @ds = DB2_DB[:items_insert_in_transaction]
+  end
+  after do
+    DB2_DB.drop_table(:items_insert_in_transaction)
+  end
+
+  specify "should insert correctly with a primary key specified inside a transaction" do
+    DB2_DB.transaction do
+      @ds.insert(:id=>100, :number=>20)
+      @ds.count.should == 1
+      @ds.order(:id).all.should == [{:id=>100, :number=>20}]
+    end
+  end
+end

data/spec/adapters/mssql_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 require ENV['SEQUEL_MSSQL_SPEC_REQUIRE'] if ENV['SEQUEL_MSSQL_SPEC_REQUIRE']
@@ -440,3 +441,38 @@ describe "MSSQL::Dataset#count" do
     MSSQL_DB[:items].select(:name, :value).group(:name, :value).order(:name).count.should == 1
   end
 end
+
+describe "MSSQL::Database#create_table" do
+  specify "should support collate with various other column options" do
+    MSSQL_DB.create_table!(:items){ String :name, :size => 128, :collate => :sql_latin1_general_cp1_ci_as, :default => 'foo', :null => false, :unique => true}
+    MSSQL_DB[:items].insert
+    MSSQL_DB[:items].select_map(:name).should == ["foo"]
+  end
+end
+
+describe "MSSQL::Database#mssql_unicode_strings = false" do
+  before do
+    MSSQL_DB.mssql_unicode_strings = false
+  end
+  after do
+    MSSQL_DB.drop_table(:items)
+    MSSQL_DB.mssql_unicode_strings = true
+  end
+
+  specify "should work correctly" do
+    MSSQL_DB.create_table!(:items){String :name}
+    MSSQL_DB[:items].mssql_unicode_strings.should == false
+    MSSQL_DB[:items].insert(:name=>'foo')
+    MSSQL_DB[:items].select_map(:name).should == ['foo']
+  end
+
+  specify "should be overridable at the dataset level" do
+    MSSQL_DB.create_table!(:items){String :name}
+    ds = MSSQL_DB[:items]
+    ds.mssql_unicode_strings.should == false
+    ds.mssql_unicode_strings = true
+    ds.mssql_unicode_strings.should == true
+    ds.insert(:name=>'foo')
+    ds.select_map(:name).should == ['foo']
+  end
+end

data/spec/adapters/mysql_spec.rb

@@ -82,6 +82,12 @@ describe "MySQL", '#create_table' do
     end
     @db.schema(:dolls).map{|k, v| v[:auto_increment]}.should == [nil, nil, true]
   end
+
+  specify "should support collate with various other column options" do
+    @db.create_table!(:dolls){ String :name, :size=>128, :collate=>:utf8_bin, :default=>'foo', :null=>false, :unique=>true}
+    @db[:dolls].insert
+    @db[:dolls].select_map(:name).should == ["foo"]
+  end
 end
 
 describe "A MySQL database" do
@@ -950,7 +956,7 @@ describe "MySQL::Dataset#calc_found_rows" do
   end
 end
 
-if MYSQL_DB.adapter_scheme == :mysql or MYSQL_DB.adapter_scheme == :jdbc
+if MYSQL_DB.adapter_scheme == :mysql or MYSQL_DB.adapter_scheme == :jdbc or MYSQL_DB.adapter_scheme == :mysql2
   describe "MySQL Stored Procedures" do
     before do
       MYSQL_DB.create_table(:items){Integer :id; Integer :value}
@@ -971,26 +977,37 @@ if MYSQL_DB.adapter_scheme == :mysql or MYSQL_DB.adapter_scheme == :jdbc
       MYSQL_DB[:items].count.should == 0
     end
     
-    specify "should be callable on the dataset object" do
-      MYSQL_DB.execute_ddl('CREATE PROCEDURE test_sproc(a INTEGER) BEGIN SELECT *, a AS b FROM items; END')
-      MYSQL_DB[:items].delete
-      @d = MYSQL_DB[:items]
-      @d.call_sproc(:select, :test_sproc, 3).should == []
-      @d.insert(:value=>1)
-      @d.call_sproc(:select, :test_sproc, 4).should == [{:id=>nil, :value=>1, :b=>4}]
-      @d.row_proc = proc{|r| r.keys.each{|k| r[k] *= 2 if r[k].is_a?(Integer)}; r}
-      @d.call_sproc(:select, :test_sproc, 3).should == [{:id=>nil, :value=>2, :b=>6}]
+    # Mysql2 doesn't support stored procedures that return result sets, probably because
+    # CLIENT_MULTI_RESULTS is not set.
+    unless MYSQL_DB.adapter_scheme == :mysql2
+      specify "should be callable on the dataset object" do
+        MYSQL_DB.execute_ddl('CREATE PROCEDURE test_sproc(a INTEGER) BEGIN SELECT *, a AS b FROM items; END')
+        MYSQL_DB[:items].delete
+        @d = MYSQL_DB[:items]
+        @d.call_sproc(:select, :test_sproc, 3).should == []
+        @d.insert(:value=>1)
+        @d.call_sproc(:select, :test_sproc, 4).should == [{:id=>nil, :value=>1, :b=>4}]
+        @d.row_proc = proc{|r| r.keys.each{|k| r[k] *= 2 if r[k].is_a?(Integer)}; r}
+        @d.call_sproc(:select, :test_sproc, 3).should == [{:id=>nil, :value=>2, :b=>6}]
+      end
+      
+      specify "should be callable on the dataset object with multiple arguments" do
+        MYSQL_DB.execute_ddl('CREATE PROCEDURE test_sproc(a INTEGER, c INTEGER) BEGIN SELECT *, a AS b, c AS d FROM items; END')
+        MYSQL_DB[:items].delete
+        @d = MYSQL_DB[:items]
+        @d.call_sproc(:select, :test_sproc, 3, 4).should == []
+        @d.insert(:value=>1)
+        @d.call_sproc(:select, :test_sproc, 4, 5).should == [{:id=>nil, :value=>1, :b=>4, :d=>5}]
+        @d.row_proc = proc{|r| r.keys.each{|k| r[k] *= 2 if r[k].is_a?(Integer)}; r}
+        @d.call_sproc(:select, :test_sproc, 3, 4).should == [{:id=>nil, :value=>2, :b=>6, :d => 8}]
+      end
     end
-    
-    specify "should be callable on the dataset object with multiple arguments" do
-      MYSQL_DB.execute_ddl('CREATE PROCEDURE test_sproc(a INTEGER, c INTEGER) BEGIN SELECT *, a AS b, c AS d FROM items; END')
+
+    specify "should deal with nil values" do
+      MYSQL_DB.execute_ddl('CREATE PROCEDURE test_sproc(i INTEGER, v INTEGER) BEGIN INSERT INTO items VALUES (i, v); END')
       MYSQL_DB[:items].delete
-      @d = MYSQL_DB[:items]
-      @d.call_sproc(:select, :test_sproc, 3, 4).should == []
-      @d.insert(:value=>1)
-      @d.call_sproc(:select, :test_sproc, 4, 5).should == [{:id=>nil, :value=>1, :b=>4, :d=>5}]
-      @d.row_proc = proc{|r| r.keys.each{|k| r[k] *= 2 if r[k].is_a?(Integer)}; r}
-      @d.call_sproc(:select, :test_sproc, 3, 4).should == [{:id=>nil, :value=>2, :b=>6, :d => 8}]
+      MYSQL_DB.call_sproc(:test_sproc, :args=>[1, nil])
+      MYSQL_DB[:items].all.should == [{:id=>1, :value=>nil}]
     end
   end
 end

data/spec/adapters/postgres_spec.rb

@@ -514,11 +514,6 @@ describe "Postgres::Dataset#insert" do
     @db.sqls.last.should == 'INSERT INTO test5 (value) VALUES (10) RETURNING xid'
   end
 
-  specify "should have insert_returning_sql use the RETURNING keyword" do
-    @ds.insert_returning_sql(:xid, :value=>10).should == "INSERT INTO test5 (value) VALUES (10) RETURNING xid"
-    @ds.insert_returning_sql('*'.lit, :value=>10).should == "INSERT INTO test5 (value) VALUES (10) RETURNING *"
-  end
-
   specify "should have insert_select return nil if server_version < 80200" do
     @ds.meta_def(:server_version){80100}
     @ds.insert_select(:value=>10).should == nil
@@ -606,12 +601,6 @@ describe "Postgres::Database schema qualified tables" do
     POSTGRES_DB.drop_table(:domains)
   end
   
-  specify "#table_exists? should not include tables from the default non-public schemas" do
-    POSTGRES_DB.create_table(:schema_test__schema_test){integer :i}
-    POSTGRES_DB.table_exists?(:schema_test).should == true
-    POSTGRES_DB.table_exists?(:domain_udt_usage).should == false
-  end
-  
   specify "#table_exists? should see if the table is in a given schema" do
     POSTGRES_DB.create_table(:schema_test__schema_test){integer :i}
     POSTGRES_DB.table_exists?(:schema_test__schema_test).should == true
@@ -909,7 +898,7 @@ describe "Postgres::Database functions, languages, and triggers" do
   after do
     @d.drop_function('tf', :if_exists=>true, :cascade=>true)
     @d.drop_function('tf', :if_exists=>true, :cascade=>true, :args=>%w'integer integer')
-    @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true)
+    @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true) if @d.server_version < 90000
     @d.drop_table(:test) rescue nil
   end
 
@@ -940,19 +929,19 @@ describe "Postgres::Database functions, languages, and triggers" do
   
   specify "#create_language and #drop_language should create and drop languages" do
     @d.send(:create_language_sql, :plpgsql).should == 'CREATE LANGUAGE plpgsql'
-    @d.create_language(:plpgsql, :replace=>true)
+    @d.create_language(:plpgsql, :replace=>true) if @d.server_version < 90000
     proc{@d.create_language(:plpgsql)}.should raise_error(Sequel::DatabaseError)
     @d.send(:drop_language_sql, :plpgsql).should == 'DROP LANGUAGE plpgsql'
-    @d.drop_language(:plpgsql)
-    proc{@d.drop_language(:plpgsql)}.should raise_error(Sequel::DatabaseError)
+    @d.drop_language(:plpgsql) if @d.server_version < 90000
+    proc{@d.drop_language(:plpgsql)}.should raise_error(Sequel::DatabaseError) if @d.server_version < 90000
     @d.send(:create_language_sql, :plpgsql, :replace=>true, :trusted=>true, :handler=>:a, :validator=>:b).should == (@d.server_version >= 90000 ? 'CREATE OR REPLACE TRUSTED LANGUAGE plpgsql HANDLER a VALIDATOR b' : 'CREATE TRUSTED LANGUAGE plpgsql HANDLER a VALIDATOR b')
     @d.send(:drop_language_sql, :plpgsql, :if_exists=>true, :cascade=>true).should == 'DROP LANGUAGE IF EXISTS plpgsql CASCADE'
     # Make sure if exists works
-    @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true)
+    @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true) if @d.server_version < 90000
   end
   
   specify "#create_trigger and #drop_trigger should create and drop triggers" do
-    @d.create_language(:plpgsql)
+    @d.create_language(:plpgsql) if @d.server_version < 90000
     @d.create_function(:tf, 'BEGIN IF NEW.value IS NULL THEN RAISE EXCEPTION \'Blah\'; END IF; RETURN NEW; END;', :language=>:plpgsql, :returns=>:trigger)
     @d.send(:create_trigger_sql, :test, :identity, :tf, :each_row=>true).should == 'CREATE TRIGGER identity BEFORE INSERT OR UPDATE OR DELETE ON test FOR EACH ROW EXECUTE PROCEDURE tf()'
     @d.create_table(:test){String :name; Integer :value}
@@ -973,17 +962,17 @@ describe "Postgres::Database functions, languages, and triggers" do
 end
 
 if POSTGRES_DB.adapter_scheme == :postgres
-describe "Postgres::Dataset #use_cursor" do
-  before(:all) do
-    @db = POSTGRES_DB
-    @db.create_table!(:test_cursor){Integer :x}
-    @db.sqls.clear
-    @ds = @db[:test_cursor]
-    @db.transaction{1001.times{|i| @ds.insert(i)}}
-  end
-  after(:all) do
-    @db.drop_table(:test) rescue nil
-  end
+  describe "Postgres::Dataset #use_cursor" do
+    before(:all) do
+      @db = POSTGRES_DB
+      @db.create_table!(:test_cursor){Integer :x}
+      @db.sqls.clear
+      @ds = @db[:test_cursor]
+      @db.transaction{1001.times{|i| @ds.insert(i)}}
+    end
+    after(:all) do
+      @db.drop_table(:test_cursor) rescue nil
+    end
   
     specify "should return the same results as the non-cursor use" do
       @ds.all.should == @ds.use_cursor.all
@@ -1005,5 +994,103 @@ describe "Postgres::Dataset #use_cursor" do
       @ds.check_return
       @ds.all.should == @ds.use_cursor.all
     end
+  end
+
+  describe "Postgres::PG_NAMED_TYPES" do
+    before do
+      @db = POSTGRES_DB
+      Sequel::Postgres::PG_NAMED_TYPES[:interval] = lambda{|v| v.reverse}
+      @db.instance_eval do
+        disconnect
+        @conversion_procs = nil
+      end 
+    end
+    after do
+      Sequel::Postgres::PG_NAMED_TYPES.delete(:interval)
+      @db.instance_eval do
+        disconnect
+        @conversion_procs = nil
+      end
+      @db.drop_table(:foo)
+    end
+
+    specify "should look up conversion procs by name" do
+      @db.create_table!(:foo){interval :bar}
+      @db[:foo].insert('21 days')
+      @db[:foo].get(:bar).should == 'syad 12'
+    end
+  end
 end
+
+if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRES_DB.server_version >= 90000
+  describe "Postgres::Database#copy_table" do
+    before(:all) do
+      @db = POSTGRES_DB
+      @db.create_table!(:test_copy){Integer :x; Integer :y}
+      ds = @db[:test_copy]
+      ds.insert(1, 2)
+      ds.insert(3, 4)
+    end
+    after(:all) do
+      @db.drop_table(:test_copy) rescue nil
+    end
+  
+    specify "without a block or options should return a text version of the table as a single string" do
+      @db.copy_table(:test_copy).should == "1\t2\n3\t4\n"
+    end
+
+    specify "without a block and with :format=>:csv should return a csv version of the table as a single string" do
+      @db.copy_table(:test_copy, :format=>:csv).should == "1,2\n3,4\n"
+    end
+  
+    specify "should treat string as SQL code" do
+      @db.copy_table('COPY "test_copy" TO STDOUT').should == "1\t2\n3\t4\n"
+    end
+  
+    specify "should respect given :options options" do
+      @db.copy_table(:test_copy, :options=>"FORMAT csv, HEADER TRUE").should == "x,y\n1,2\n3,4\n"
+    end
+  
+    specify "should respect given :options options when :format is used" do
+      @db.copy_table(:test_copy, :format=>:csv, :options=>"QUOTE '''', FORCE_QUOTE *").should == "'1','2'\n'3','4'\n"
+    end
+  
+    specify "should accept dataset as first argument" do
+      @db.copy_table(@db[:test_copy].cross_join(:test_copy___tc).order(1, 2, 3, 4)).should == "1\t2\t1\t2\n1\t2\t3\t4\n3\t4\t1\t2\n3\t4\t3\t4\n"
+    end
+  
+    specify "with a block and no options should yield each row as a string in text format" do
+      buf = []
+      @db.copy_table(:test_copy){|b| buf << b}
+      buf.should == ["1\t2\n", "3\t4\n"]
+    end
+  
+    specify "with a block and :format=>:csv should yield each row as a string in csv format" do
+      buf = []
+      @db.copy_table(:test_copy, :format=>:csv){|b| buf << b}
+      buf.should == ["1,2\n", "3,4\n"]
+    end
+  
+    specify "should work fine when using a block that is terminated early with a following copy_table" do
+      buf = []
+      proc{@db.copy_table(:test_copy, :format=>:csv){|b| buf << b; break}}.should raise_error(Sequel::DatabaseDisconnectError)
+      buf.should == ["1,2\n"]
+      buf.clear
+      proc{@db.copy_table(:test_copy, :format=>:csv){|b| buf << b; raise ArgumentError}}.should raise_error(Sequel::DatabaseDisconnectError)
+      buf.should == ["1,2\n"]
+      buf.clear
+      @db.copy_table(:test_copy){|b| buf << b}
+      buf.should == ["1\t2\n", "3\t4\n"]
+    end
+  
+    specify "should work fine when using a block that is terminated early with a following regular query" do
+      buf = []
+      proc{@db.copy_table(:test_copy, :format=>:csv){|b| buf << b; break}}.should raise_error(Sequel::DatabaseDisconnectError)
+      buf.should == ["1,2\n"]
+      buf.clear
+      proc{@db.copy_table(:test_copy, :format=>:csv){|b| buf << b; raise ArgumentError}}.should raise_error(Sequel::DatabaseDisconnectError)
+      buf.should == ["1,2\n"]
+      @db[:test_copy].select_order_map(:x).should == [1, 3]
+    end
+  end  
 end

data/spec/adapters/spec_helper.rb

@@ -10,6 +10,11 @@ begin
 rescue LoadError
 end
 
+if ENV['SEQUEL_COLUMNS_INTROSPECTION']
+  Sequel.extension :columns_introspection
+  Sequel::Dataset.introspect_all_columns
+end
+
 class Sequel::Database
   def log_duration(duration, message)
     log_info(message)
@@ -31,6 +36,7 @@ end
   end
 
   def self.cspecify(message, *checked, &block)
+    return specify(message, &block) if ENV['SEQUEL_NO_PENDING']
     pending = false
     checked.each do |c|
       case c

data/spec/adapters/sqlite_spec.rb

@@ -66,6 +66,17 @@ describe "An SQLite database" do
     @db[:fk].all.should == [{:id=>1, :parent_id=>2}]
   end
   
+  specify "should support a use_timestamp_timezones setting" do
+    @db.create_table!(:time){Time :time}
+    @db[:time].insert(Time.now)
+    @db[:time].get(:time.cast_string).should =~ /[-+]\d\d\d\d\z/
+    @db.use_timestamp_timezones = false
+    @db[:time].delete
+    @db[:time].insert(Time.now)
+    @db[:time].get(:time.cast_string).should_not =~ /[-+]\d\d\d\d\z/
+    @db.use_timestamp_timezones = true
+  end
+  
   specify "should provide a list of existing tables" do
     @db.drop_table(:testing) rescue nil
     @db.tables.should be_a_kind_of(Array)