sequel 3.33.0 → 3.34.0

data/spec/integration/prepared_statement_test.rb

@@ -13,7 +13,7 @@ describe "Prepared Statements and Bound Arguments" do
     @pr = @ds.requires_placeholder_type_specifiers? ? proc{|i| :"#{i}__integer"} : proc{|i| i}
   end
   after do
-    @db.drop_table(:items)
+    @db.drop_table?(:items)
   end
   
   specify "should support bound variables when selecting" do
@@ -22,6 +22,7 @@ describe "Prepared Statements and Bound Arguments" do
     @ds.filter(:numb=>:$n).call(:first, :n=>10).should == {:id=>1, :numb=>10}
     @ds.filter(:numb=>:$n).call([:map, :numb], :n=>10).should == [10]
     @ds.filter(:numb=>:$n).call([:to_hash, :id, :numb], :n=>10).should == {1=>10}
+    @ds.filter(:numb=>:$n).call([:to_hash_groups, :id, :numb], :n=>10).should == {1=>[10]}
   end
     
   specify "should support blocks for select, all, and map " do
@@ -252,16 +253,16 @@ describe "Bound Argument Types" do
     end
     @ds = @db[:items]
     @vs = {:d=>Date.civil(2010, 10, 11), :dt=>DateTime.civil(2010, 10, 12, 13, 14, 15), :f=>1.0, :s=>'str', :t=>Time.at(20101010), :file=>Sequel::SQL::Blob.new('blob'), :b=>true}
+  end
+  before do
+    @ds.delete
     @ds.insert(@vs)
-    @ds.meta_def(:ba) do |sym, type|
-      prepared_arg_placeholder == '$' ? :"#{sym}__#{type}" : sym
-    end
   end
   after do
     Sequel.datetime_class = Time
   end
   after(:all) do
-    @db.drop_table(:items)
+    @db.drop_table?(:items)
   end
 
   cspecify "should handle date type", [:do, :sqlite], :mssql, [:jdbc, :sqlite], :oracle do 
@@ -273,14 +274,33 @@ describe "Bound Argument Types" do
     @ds.filter(:dt=>:$x).prepare(:first, :ps_datetime).call(:x=>@vs[:dt])[:dt].should == @vs[:dt]
   end
 
-  cspecify "should handle time type", [:do], [:jdbc, :sqlite], [:oracle] do
+  cspecify "should handle datetime type with fractional seconds", [:do], [:mysql2], [:swift], [:jdbc, :sqlite], [:tinytds], [:oracle] do
+    Sequel.datetime_class = DateTime
+    fract_time = DateTime.parse('2010-10-12 13:14:15.500000')
+    @ds.prepare(:update, :ps_datetime_up, :dt=>:$x).call(:x=>fract_time)
+    @ds.literal(@ds.filter(:dt=>:$x).prepare(:first, :ps_datetime).call(:x=>fract_time)[:dt]).should == @ds.literal(fract_time)
+  end
+
+  cspecify "should handle time type", [:do], [:jdbc, :sqlite], [:swift], [:oracle] do
     @ds.filter(:t=>:$x).prepare(:first, :ps_time).call(:x=>@vs[:t])[:t].should == @vs[:t]
   end
 
+  cspecify "should handle time type with fractional seconds", [:do], [:jdbc, :sqlite], [:oracle] do
+    fract_time = @vs[:t] + 0.5
+    @ds.prepare(:update, :ps_time_up, :t=>:$x).call(:x=>fract_time)
+    @ds.literal(@ds.filter(:t=>:$x).prepare(:first, :ps_time).call(:x=>fract_time)[:t]).should == @ds.literal(fract_time)
+  end
+
   cspecify "should handle blob type", [:swift], [:odbc], [:jdbc, :db2], :oracle, :derby do
     @ds.filter(:file=>:$x).prepare(:first, :ps_blob).call(:x=>@vs[:file])[:file].should == @vs[:file]
   end
 
+  cspecify "should handle blob type with embedded zeros", [:swift], [:odbc], [:jdbc, :db2], :oracle, :derby do
+    zero_blob = Sequel::SQL::Blob.new("a\0"*100)
+    @ds.prepare(:update, :ps_blob_up, :file=>:$x).call(:x=>zero_blob)
+    @ds.filter(:file=>:$x).prepare(:first, :ps_blob).call(:x=>zero_blob)[:file].should == zero_blob
+  end
+
   cspecify "should handle float type", [:swift, :sqlite] do
     @ds.filter(:f=>:$x).prepare(:first, :ps_float).call(:x=>@vs[:f])[:f].should == @vs[:f]
   end
@@ -306,7 +326,7 @@ describe "Dataset#unbind" do
     @u = proc{|ds| ds, bv = ds.unbind; ds.call(:first, bv)}
   end
   after do
-    INTEGRATION_DB.drop_table(:items) rescue nil
+    INTEGRATION_DB.drop_table?(:items)
   end
   
   specify "should unbind values assigned to equality and inequality statements" do
@@ -334,7 +354,7 @@ describe "Dataset#unbind" do
     @u[@ds.filter{c > 0}].should == {:c=>BigDecimal.new('1.1')}
   end
 
-  cspecify "should handle dates and times", [:do], [:jdbc, :mssql], [:jdbc, :sqlite], [:tinytds], :oracle do
+  cspecify "should handle dates and times", [:do], [:jdbc, :mssql], [:jdbc, :sqlite], [:swift], [:tinytds], :oracle do
     @ct[Date, Date.today]
     @u[@ds.filter(:c=>Date.today)].should == {:c=>Date.today}
     t = Time.now

data/spec/integration/schema_test.rb

@@ -12,7 +12,7 @@ describe "Database schema parser" do
     INTEGRATION_DB.identifier_input_method = @iim
     INTEGRATION_DB.default_schema = @defsch
     INTEGRATION_DB.quote_identifiers = @qi
-    INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
+    INTEGRATION_DB.drop_table?(:items)
   end
 
   specify "should handle a database with a identifier methods" do
@@ -139,7 +139,7 @@ describe "Database schema parser" do
 end if INTEGRATION_DB.respond_to?(:schema_parse_table, true)
 
 test_indexes = begin
-  INTEGRATION_DB.drop_table(:blah) rescue nil
+  INTEGRATION_DB.drop_table?(:blah)
   INTEGRATION_DB.indexes(:blah)
   true
 rescue Sequel::NotImplemented
@@ -149,7 +149,7 @@ rescue
 end
 describe "Database index parsing" do
   after do
-    INTEGRATION_DB.drop_table(:items)
+    INTEGRATION_DB.drop_table?(:items)
   end
 
   specify "should parse indexes into a hash" do
@@ -177,13 +177,69 @@ describe "Database index parsing" do
   end
 end if test_indexes
 
+test_foreign_key_list = begin
+  INTEGRATION_DB.drop_table?(:blah)
+  INTEGRATION_DB.foreign_key_list(:blah)
+  true
+rescue Sequel::NotImplemented
+  false
+rescue
+  true
+end
+describe "Database foreign key parsing" do
+  before do
+    @db = INTEGRATION_DB
+    @pr = lambda do |table, *expected|
+      actual = @db.foreign_key_list(table).sort_by{|c| c[:columns].map{|s| s.to_s}.join << (c[:key]||[]).map{|s| s.to_s}.join}.map{|v| v.values_at(:columns, :table, :key)}
+      actual.zip(expected).each do |a, e|
+        if e.last.first == :pk
+          if a.last == nil
+            a.pop
+            e.pop
+          else
+           e.last.shift
+          end
+        end
+        a.should == e
+      end
+      actual.length.should == expected.length
+    end
+  end
+  after do
+    @db.drop_table?(:b, :a)
+  end
+
+  specify "should parse foreign key information into an array of hashes" do
+    @db.create_table!(:a, :engine=>:InnoDB){primary_key :c; Integer :d; index :d, :unique=>true}
+    @db.create_table!(:b, :engine=>:InnoDB){foreign_key :e, :a}
+    @pr[:a]
+    @pr[:b, [[:e], :a, [:pk, :c]]]
+
+    @db.alter_table(:b){add_foreign_key :f, :a, :key=>[:d]}
+    @pr[:b, [[:e], :a, [:pk, :c]], [[:f], :a, [:d]]]
+
+    @db.alter_table(:b){add_foreign_key [:f], :a, :key=>[:c]}
+    @pr[:b, [[:e], :a, [:pk, :c]], [[:f], :a, [:c]], [[:f], :a, [:d]]]
+
+    @db.alter_table(:a){add_index [:d, :c], :unique=>true}
+    @db.alter_table(:b){add_foreign_key [:f, :e], :a, :key=>[:d, :c]}
+    @pr[:b, [[:e], :a, [:pk, :c]], [[:f], :a, [:c]], [[:f], :a, [:d]], [[:f, :e], :a, [:d, :c]]]
+  end
+
+  specify "should handle composite foreign and primary keys" do
+    @db.create_table!(:a, :engine=>:InnoDB){Integer :b; Integer :c; primary_key [:b, :c]; index [:c, :b], :unique=>true}
+    @db.create_table!(:b, :engine=>:InnoDB){Integer :e; Integer :f; foreign_key [:e, :f], :a; foreign_key [:f, :e], :a, :key=>[:c, :b]}
+    @pr[:b, [[:e, :f], :a, [:pk, :b, :c]], [[:f, :e], :a, [:c, :b]]]
+  end
+end if test_foreign_key_list
+
 describe "Database schema modifiers" do
   before do
     @db = INTEGRATION_DB
     @ds = @db[:items]
   end
   after do
-    @db.drop_table(:items) if @db.table_exists?(:items)
+    @db.drop_table?(:items)
   end
 
   specify "should create tables correctly" do
@@ -194,6 +250,21 @@ describe "Database schema modifiers" do
     @ds.columns!.should == [:number]
   end
   
+  describe "join tables" do
+    after do
+      @db.drop_join_table(:cat_id=>:cats, :dog_id=>:dogs) if @db.table_exists?(:cats_dogs)
+      @db.drop_table(:cats, :dogs)
+      @db.table_exists?(:cats_dogs).should == false
+    end
+
+    specify "should create join tables correctly" do
+      @db.create_table!(:cats){primary_key :id}
+      @db.create_table!(:dogs){primary_key :id}
+      @db.create_join_table(:cat_id=>:cats, :dog_id=>:dogs)
+      @db.table_exists?(:cats_dogs).should == true
+    end
+  end
+
   specify "should create temporary tables without raising an exception" do
     @db.create_table!(:items, :temp=>true){Integer :number}
   end
@@ -202,7 +273,7 @@ describe "Database schema modifiers" do
     @db.create_table!(:items){String :a}
     @db.create_table?(:items){String :b}
     @db[:items].columns.should == [:a]
-    @db.drop_table(:items) rescue nil
+    @db.drop_table?(:items)
     @db.create_table?(:items){String :b}
     @db[:items].columns.should == [:b]
   end
@@ -211,13 +282,13 @@ describe "Database schema modifiers" do
     @db.create_table!(:items){String :a, :index=>true}
     @db.create_table?(:items){String :b, :index=>true}
     @db[:items].columns.should == [:a]
-    @db.drop_table(:items) rescue nil
+    @db.drop_table?(:items)
     @db.create_table?(:items){String :b, :index=>true}
     @db[:items].columns.should == [:b]
   end
 
   specify "should rename tables correctly" do
-    @db.drop_table(:items) rescue nil
+    @db.drop_table?(:items)
     @db.create_table!(:items2){Integer :number}
     @db.rename_table(:items2, :items)
     @db.table_exists?(:items).should == true

data/spec/integration/spec_helper.rb

@@ -15,6 +15,7 @@ if ENV['SEQUEL_COLUMNS_INTROSPECTION']
 end
 
 Sequel::Model.use_transactions = false
+Sequel::Model.cache_anonymous_models = false
 
 unless defined?(RSpec)
   module Spec::Matchers

data/spec/integration/timezone_test.rb

@@ -66,7 +66,7 @@ describe "Sequel timezone support" do
     test_timezone
   end
 
-  cspecify "should support using local time for both database storage and for application", [:do, :mysql], [:do, :postgres], [:oracle] do
+  cspecify "should support using local time for both database storage and for application", [:do, :mysql], [:do, :postgres], [:oracle], [:swift, :postgres], [:swift, :mysql] do
     Sequel.default_timezone = :local
     test_timezone
     Sequel.database_timezone = :utc

data/spec/integration/transaction_test.rb

@@ -3,15 +3,14 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 describe "Database transactions" do
   before(:all) do
     @db = INTEGRATION_DB
-    @db.drop_table(:items) if @db.table_exists?(:items)
-    @db.create_table(:items, :engine=>'InnoDB'){String :name; Integer :value}
+    @db.create_table!(:items, :engine=>'InnoDB'){String :name; Integer :value}
     @d = @db[:items]
   end
   before do
     @d.delete
   end
   after(:all) do
-    @db.drop_table(:items) if @db.table_exists?(:items)
+    @db.drop_table?(:items)
   end
 
   specify "should support transactions" do
@@ -265,12 +264,11 @@ if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or (RUBY_ENGINE == 'rbx' &&
   describe "Database transactions and Thread#kill" do
     before do
       @db = INTEGRATION_DB
-      @db.drop_table(:items) if @db.table_exists?(:items)
-      @db.create_table(:items, :engine=>'InnoDB'){String :name; Integer :value}
+      @db.create_table!(:items, :engine=>'InnoDB'){String :name; Integer :value}
       @d = @db[:items]
     end
     after do
-      @db.drop_table(:items) if @db.table_exists?(:items)
+      @db.drop_table?(:items)
     end
 
     specify "should handle transactions inside threads" do

data/spec/integration/type_test.rb

@@ -33,7 +33,7 @@ describe "Supported types" do
     ds.all.should == [{:number=>2}]
   end
   
-  specify "should support generic bignum type" do
+  cspecify "should support generic bignum type", [:swift, :sqlite] do
     ds = create_items_table_with_column(:number, Bignum)
     ds.insert(:number => 2**34)
     ds.all.should == [{:number=>2**34}]
@@ -68,7 +68,7 @@ describe "Supported types" do
     ds.first[:dat].to_s.should == d.to_s
   end
   
-  cspecify "should support generic time type", [:do], [:swift], [:odbc], [:jdbc, :mssql], [:jdbc, :postgres], [:jdbc, :sqlite], [:mysql2], [:tinytds], :oracle do
+  cspecify "should support generic time type", [:do], [:swift], [:odbc], [:jdbc, :mssql], [:jdbc, :sqlite], [:mysql2], [:tinytds], :oracle do
     ds = create_items_table_with_column(:tim, Time, :only_time=>true)
     t = Sequel::SQLTime.now
     ds.insert(:tim => t)

data/spec/model/associations_spec.rb

@@ -653,7 +653,7 @@ describe Sequel::Model, "one_to_one" do
   it "should add a setter method" do
     @c2.one_to_one :attribute, :class => @c1
     attrib = @c1.new(:id=>3)
-    @c1.dataset._fetch = {:id=>3}
+    @c1.dataset._fetch = @c1.instance_dataset._fetch = {:id=>3}
     @c2.new(:id => 1234).attribute = attrib
     sqls = MODEL_DB.sqls
     ['INSERT INTO attributes (node_id, id) VALUES (1234, 3)',
@@ -692,7 +692,7 @@ describe Sequel::Model, "one_to_one" do
   it "should have the setter method respect the :primary_key option" do
     @c2.one_to_one :attribute, :class => @c1, :primary_key=>:xxx
     attrib = @c1.new(:id=>3)
-    @c1.dataset._fetch = {:id=>3}
+    @c1.dataset._fetch = @c1.instance_dataset._fetch = {:id=>3}
     @c2.new(:id => 1234, :xxx=>5).attribute = attrib
     sqls = MODEL_DB.sqls
     ['INSERT INTO attributes (node_id, id) VALUES (5, 3)',
@@ -836,7 +836,7 @@ describe Sequel::Model, "one_to_one" do
 
     d = @c2.new(:id => 1)
     f = @c2.new(:id => 3, :node_id=> 4321)
-    @c2.dataset._fetch = {:id => 3, :node_id=>1}
+    @c2.dataset._fetch = @c2.instance_dataset._fetch = {:id => 3, :node_id=>1}
     d.parent = f
     f.values.should == {:id => 3, :node_id=>1}
     d.parent.should == f
@@ -854,7 +854,7 @@ describe Sequel::Model, "one_to_one" do
     @c2.one_to_one :parent, :class => @c2, :primary_key=>:blah
     d = @c2.new(:id => 1, :blah => 3)
     e = @c2.new(:id => 4321, :node_id=>444)
-    @c2.dataset._fetch = {:id => 4321, :node_id => 3}
+    @c2.dataset._fetch = @c2.instance_dataset._fetch = {:id => 4321, :node_id => 3}
     d.parent = e
     e.values.should == {:id => 4321, :node_id => 3}
     sqls = MODEL_DB.sqls
@@ -867,7 +867,7 @@ describe Sequel::Model, "one_to_one" do
     @c2.one_to_one :parent, :class => @c2, :key=>:blah
     d = @c2.new(:id => 3)
     e = @c2.new(:id => 4321, :blah=>444)
-    @c2.dataset._fetch = {:id => 4321, :blah => 3}
+    @c2.dataset._fetch = @c2.instance_dataset._fetch = {:id => 4321, :blah => 3}
     d.parent = e
     e.values.should == {:id => 4321, :blah => 3}
     sqls = MODEL_DB.sqls
@@ -1181,7 +1181,7 @@ describe Sequel::Model, "one_to_many" do
     
     n = @c2.load(:id => 1234)
     a = @c1.new(:id => 234)
-    @c1.dataset._fetch = {:node_id => 1234, :id => 234}
+    @c1.dataset._fetch = @c1.instance_dataset._fetch = {:node_id => 1234, :id => 234}
     a.should == n.add_attribute(a)
     sqls = MODEL_DB.sqls
     sqls.shift.should =~ /INSERT INTO attributes \((node_)?id, (node_)?id\) VALUES \(1?234, 1?234\)/
@@ -1213,7 +1213,7 @@ describe Sequel::Model, "one_to_many" do
     @c2.one_to_many :attributes, :class => @c1
     n = @c2.new(:id => 1234)
     MODEL_DB.reset
-    @c1.dataset._fetch = {:node_id => 1234, :id => 234}
+    @c1.dataset._fetch = @c1.instance_dataset._fetch = {:node_id => 1234, :id => 234}
     n.add_attribute(:id => 234).should == @c1.load(:node_id => 1234, :id => 234)
     sqls = MODEL_DB.sqls
     sqls.shift.should =~ /INSERT INTO attributes \((node_)?id, (node_)?id\) VALUES \(1?234, 1?234\)/
@@ -1969,7 +1969,7 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1
     
     n = @c2.load(:id => 1234)
-    @c1.dataset._fetch = {:id=>1}
+    @c1.dataset._fetch = @c1.instance_dataset._fetch = {:id=>1}
     n.add_attribute(:id => 1).should == @c1.load(:id => 1)
     sqls = MODEL_DB.sqls
     ['INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 1)',
@@ -3017,3 +3017,89 @@ describe "Sequel::Model Associations with clashing column names" do
     @bar.mtmfoos.should == []
   end
 end 
+
+describe "Model#pk_or_nil" do
+  before do
+    @m = Class.new(Sequel::Model)
+    @m.columns :id, :x, :y
+  end
+  
+  it "should be default return the value of the :id column" do
+    m = @m.load(:id => 111, :x => 2, :y => 3)
+    m.pk_or_nil.should == 111
+  end
+
+  it "should be return the primary key value for custom primary key" do
+    @m.set_primary_key :x
+    m = @m.load(:id => 111, :x => 2, :y => 3)
+    m.pk_or_nil.should == 2
+  end
+
+  it "should be return the primary key value for composite primary key" do
+    @m.set_primary_key [:y, :x]
+    m = @m.load(:id => 111, :x => 2, :y => 3)
+    m.pk_or_nil.should == [3, 2]
+  end
+
+  it "should raise if no primary key" do
+    @m.set_primary_key nil
+    m = @m.new(:id => 111, :x => 2, :y => 3)
+    m.pk_or_nil.should be_nil
+
+    @m.no_primary_key
+    m = @m.new(:id => 111, :x => 2, :y => 3)
+    m.pk_or_nil.should be_nil
+  end
+end
+
+describe Sequel::Model, "#refresh" do
+  before do
+    @c = Class.new(Sequel::Model(:items)) do
+      unrestrict_primary_key
+      columns :id, :x
+    end
+    MODEL_DB.reset
+  end
+
+  specify "should remove cached associations" do
+    @c.many_to_one :node, :class=>@c
+    @m = @c.new(:id => 555)
+    @m.associations[:node] = 15
+    @m.reload
+    @m.associations.should == {}
+  end
+end
+
+describe "Model#freeze" do
+  before do
+    class ::Album < Sequel::Model
+      columns :id
+      class B < Sequel::Model
+        columns :id, :album_id
+        many_to_one :album, :class=>Album
+      end
+      one_to_one :b, :key=>:album_id, :class=>B
+    end
+    @o = Album.load(:id=>1).freeze
+    MODEL_DB.sqls
+  end
+  after do
+    Object.send(:remove_const, :Album)
+  end
+
+  it "should freeze the object's associations" do
+    @o.associations.frozen?.should be_true
+  end
+
+  it "should not break associations getters" do
+    Album::B.dataset._fetch = {:album_id=>1, :id=>2}
+    @o.b.should == Album::B.load(:id=>2, :album_id=>1)
+    @o.associations[:b].should be_nil
+  end
+
+  it "should not break reciprocal associations" do
+    b = Album::B.load(:id=>2, :album_id=>nil)
+    b.album = @o
+    @o.associations[:b].should be_nil
+  end
+end