sequel 3.37.0 → 3.38.0

data/spec/integration/eager_loader_test.rb

@@ -333,7 +333,7 @@ describe "Polymorphic Associations" do
       many_to_one :attachable, :reciprocal=>:assets, \
         :dataset=>(proc do
           klass = m.call(attachable_type)
-          klass.filter(klass.primary_key=>attachable_id)
+          klass.where(klass.primary_key=>attachable_id)
         end), \
         :eager_loader=>(proc do |eo|
           id_map = {}
@@ -343,7 +343,7 @@ describe "Polymorphic Associations" do
           end 
           id_map.each do |klass_name, id_map|
             klass = m.call(klass_name)
-            klass.filter(klass.primary_key=>id_map.keys).all do |attach|
+            klass.where(klass.primary_key=>id_map.keys).all do |attach|
               id_map[attach.pk].each do |asset|
                 asset.associations[:attachable] = attach
               end 
@@ -363,25 +363,18 @@ describe "Polymorphic Associations" do
       primary_key :id
     end
     class ::Post < Sequel::Model
-      one_to_many :assets, :key=>:attachable_id, :reciprocal=>:attachable do |ds|
-        ds.filter(:attachable_type=>'Post')
-      end 
+      one_to_many :assets, :key=>:attachable_id, :reciprocal=>:attachable, :conditions=>{:attachable_type=>'Post'}
       
       private
 
       def _add_asset(asset)
-        asset.attachable_id = pk
-        asset.attachable_type = 'Post'
-        asset.save
+        asset.update(:attachable_id=>pk, :attachable_type=>'Post')
       end
       def _remove_asset(asset)
-        asset.attachable_id = nil
-        asset.attachable_type = nil
-        asset.save
+        asset.update(:attachable_id=>nil, :attachable_type=>nil)
       end
       def _remove_all_assets
-        Asset.filter(:attachable_id=>pk, :attachable_type=>'Post')\
-          .update(:attachable_id=>nil, :attachable_type=>nil)
+        assets_dataset.update(:attachable_id=>nil, :attachable_type=>nil)
       end
     end 
   
@@ -389,25 +382,18 @@ describe "Polymorphic Associations" do
       primary_key :id
     end
     class ::Note < Sequel::Model
-      one_to_many :assets, :key=>:attachable_id, :reciprocal=>:attachable do |ds|
-        ds.filter(:attachable_type=>'Note')
-      end 
-      
+      one_to_many :assets, :key=>:attachable_id, :reciprocal=>:attachable, :conditions=>{:attachable_type=>'Note'}     
+
       private
 
       def _add_asset(asset)
-        asset.attachable_id = pk
-        asset.attachable_type = 'Note'
-        asset.save
+        asset.update(:attachable_id=>pk, :attachable_type=>'Note')
       end
       def _remove_asset(asset)
-        asset.attachable_id = nil
-        asset.attachable_type = nil
-        asset.save
+        asset.update(:attachable_id=>nil, :attachable_type=>nil)
       end
       def _remove_all_assets
-        Asset.filter(:attachable_id=>pk, :attachable_type=>'Note')\
-          .update(:attachable_id=>nil, :attachable_type=>nil)
+        assets_dataset.update(:attachable_id=>nil, :attachable_type=>nil)
       end
     end
   end
@@ -630,8 +616,8 @@ describe "statistics associations" do
        :eager_loader=>(proc do |eo|
         eo[:rows].each{|p| p.associations[:ticket_hours] = nil}
         Ticket.filter(:project_id=>eo[:id_map].keys).
-         group(:project_id).
-         select{[project_id.as(project_id), sum(hours).as(hours)]}.
+         select_group(:project_id).
+         select_append{sum(hours).as(hours)}.
          all do |t|
           p = eo[:id_map][t.values.delete(:project_id)].first
           p.associations[:ticket_hours] = t

data/spec/integration/plugin_test.rb

@@ -199,7 +199,7 @@ describe "Many Through Many Plugin" do
   end
   
   def self_join(c)
-    c.join(c.table_name.as(:b), Array(c.primary_key).zip(Array(c.primary_key))).select_all(c.table_name)
+    c.join(Sequel.as(c.table_name, :b), Array(c.primary_key).zip(Array(c.primary_key))).select_all(c.table_name)
   end
 
   specify "should handle super simple case with 1 join table" do
@@ -1265,7 +1265,7 @@ describe "List plugin with a scope" do
     @db.drop_table?(:pages)
   end
 
-  it "should return rows in order of position" do
+  specify "should return rows in order of position" do
     @c.map(:name).should == %w[ Hm Ps Au P1 P2 P3 ]
   end
 
@@ -1286,7 +1286,7 @@ describe "List plugin with a scope" do
     @c[:name => "P3"].next.should == nil
   end
 
-  it "should define move_to" do
+  specify "should define move_to" do
     @c[:name => "P2"].move_to(1)
     @c.map(:name).should == %w[ Hm Ps Au P2 P1 P3 ]
 
@@ -1297,7 +1297,7 @@ describe "List plugin with a scope" do
     proc { @c[:name => "P2"].move_to(10) }.should raise_error(Sequel::Error)
   end
 
-  it "should define move_to_top and move_to_bottom" do
+  specify "should define move_to_top and move_to_bottom" do
     @c[:name => "Au"].move_to_top
     @c.map(:name).should == %w[ Hm Au Ps P1 P2 P3 ]
 
@@ -1305,7 +1305,7 @@ describe "List plugin with a scope" do
     @c.map(:name).should == %w[ Hm Ps Au P1 P2 P3 ]
   end
 
-  it "should define move_up and move_down" do
+  specify "should define move_up and move_down" do
     @c[:name => "P2"].move_up
     @c.map(:name).should == %w[ Hm Ps Au P2 P1 P3 ]
 

data/spec/integration/prepared_statement_test.rb

@@ -123,7 +123,7 @@ describe "Prepared Statements and Bound Arguments" do
   end
 
   specify "should support bound variables with update" do
-    @ds.filter(:numb=>:$n).call(:update, {:n=>10, :nn=>20}, :numb=>:numb+:$nn).should == 1
+    @ds.filter(:numb=>:$n).call(:update, {:n=>10, :nn=>20}, :numb=>Sequel.+(:numb, :$nn)).should == 1
     @ds.all.should == [{:id=>1, :numb=>30}]
   end
   
@@ -235,7 +235,7 @@ describe "Prepared Statements and Bound Arguments" do
   end
 
   specify "should support prepared statements with update" do
-    @ds.filter(:numb=>:$n).prepare(:update, :update_n, :numb=>:numb+:$nn)
+    @ds.filter(:numb=>:$n).prepare(:update, :update_n, :numb=>Sequel.+(:numb, :$nn))
     @db.call(:update_n, :n=>10, :nn=>20).should == 1
     @ds.all.should == [{:id=>1, :numb=>30}]
   end
@@ -287,12 +287,12 @@ describe "Bound Argument Types" do
     @ds.filter(:d=>:$x).prepare(:first, :ps_date).call(:x=>@vs[:d])[:d].should == @vs[:d]
   end
 
-  cspecify "should handle datetime type", [:do], [:mysql2], [:swift], [:jdbc, :sqlite], [:tinytds], [:oracle] do
+  cspecify "should handle datetime type", [:do], [:mysql2], [:jdbc, :sqlite], [:tinytds], [:oracle] do
     Sequel.datetime_class = DateTime
     @ds.filter(:dt=>:$x).prepare(:first, :ps_datetime).call(:x=>@vs[:dt])[:dt].should == @vs[:dt]
   end
 
-  cspecify "should handle datetime type with fractional seconds", [:do], [:mysql2], [:swift], [:jdbc, :sqlite], [:tinytds], [:oracle] do
+  cspecify "should handle datetime type with fractional seconds", [:do], [:mysql2], [: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)
@@ -303,20 +303,29 @@ describe "Bound Argument Types" 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
+  cspecify "should handle time type with fractional seconds", [:do], [:jdbc, :sqlite], [:oracle], [:swift, :postgres] 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]
+  cspecify "should handle blob type", [:odbc], [:oracle] do
+    @ds.delete
+    @ds.prepare(:insert, :ps_blob, {:file=>:$x}).call(:x=>@vs[:file])
+    @ds.get(:file).should == @vs[:file]
+  end
+
+  cspecify "should handle blob type with nil values", [:oracle], [:tinytds], [:jdbc, proc{|db| defined?(Sequel::JDBC::SQLServer::DatabaseMethods) && db.is_a?(Sequel::JDBC::SQLServer::DatabaseMethods)}] do
+    @ds.delete
+    @ds.prepare(:insert, :ps_blob, {:file=>:$x}).call(:x=>nil)
+    @ds.get(:file).should == nil
   end
 
-  cspecify "should handle blob type with embedded zeros", [:swift], [:odbc], [:jdbc, :db2], :oracle, :derby do
+  cspecify "should handle blob type with embedded zeros", [:odbc], [:oracle] 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
+    @ds.delete
+    @ds.prepare(:insert, :ps_blob, {:file=>:$x}).call(:x=>zero_blob)
+    @ds.get(:file).should == zero_blob
   end
 
   cspecify "should handle float type", [:swift, :sqlite] do
@@ -330,7 +339,7 @@ describe "Bound Argument Types" do
   cspecify "should handle boolean type", [:do, :sqlite], [:odbc, :mssql], [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
     @ds.filter(:b=>:$x).prepare(:first, :ps_string).call(:x=>@vs[:b])[:b].should == @vs[:b]
   end
-end unless Sequel.guarded?([:swift, :postgres])
+end
 
 describe "Dataset#unbind" do
   before do
@@ -393,8 +402,8 @@ describe "Dataset#unbind" do
       Integer :d
     end
     @ds.insert(:a=>2, :b=>0, :c=>3, :d=>5)
-    @u[@ds.filter{a > 1}.and{b < 2}.or(:c=>3).and({~{:d=>4}=>1}.case(0) => 1)].should == {:a=>2, :b=>0, :c=>3, :d=>5}
-    @u[@ds.filter{a > 1}.and{b < 2}.or(:c=>3).and({~{:d=>5}=>1}.case(0) => 1)].should == nil
+    @u[@ds.filter{a > 1}.and{b < 2}.or(:c=>3).and(Sequel.case({~Sequel.expr(:d=>4)=>1}, 0) => 1)].should == {:a=>2, :b=>0, :c=>3, :d=>5}
+    @u[@ds.filter{a > 1}.and{b < 2}.or(:c=>3).and(Sequel.case({~Sequel.expr(:d=>5)=>1}, 0) => 1)].should == nil
   end
 
   specify "should handle case where the same variable has the same value in multiple places " do

data/spec/integration/schema_test.rb

@@ -239,7 +239,9 @@ describe "Database schema modifiers" do
     @ds = @db[:items]
   end
   after do
-    @db.drop_table?(:items, :items2)
+    # Use instead of drop_table? to work around issues on jdbc/db2
+    @db.drop_table(:items) rescue nil
+    @db.drop_table(:items2) rescue nil
   end
 
   specify "should create tables correctly" do
@@ -526,30 +528,40 @@ describe "Database schema modifiers" do
     proc{@ds.insert(1, 2)}.should_not raise_error
   end
 
-  cspecify "should remove columns from tables correctly", :h2, :mssql, [:jdbc, :db2], :hsqldb do
+  specify "should remove columns from tables correctly" do
+    @db.create_table!(:items) do
+      primary_key :id
+      Integer :i
+    end
+    @ds.insert(:i=>10)
+    @db.drop_column(:items, :i)
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id]
+  end
+
+  specify "should remove columns with defaults from tables correctly" do
+    @db.create_table!(:items) do
+      primary_key :id
+      Integer :i, :default=>20
+    end
+    @ds.insert(:i=>10)
+    @db.drop_column(:items, :i)
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id]
+  end
+
+  cspecify "should remove foreign key columns from tables correctly", :h2, :mssql, :hsqldb do
     # MySQL with InnoDB cannot drop foreign key columns unless you know the
     # name of the constraint, see Bug #14347
     @db.create_table!(:items, :engine=>:MyISAM) do
       primary_key :id
-      String :name
-      Integer :number
+      Integer :i
       foreign_key :item_id, :items
     end
-    @ds.insert(:number=>10)
-    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :name, :number, :item_id]
-    @ds.columns!.should == [:id, :name, :number, :item_id]
-    @db.drop_column(:items, :number)
-    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :name, :item_id]
-    @ds.columns!.should == [:id, :name, :item_id]
-    @db.drop_column(:items, :name)
-    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
-    @ds.columns!.should == [:id, :item_id]
+    @ds.insert(:i=>10)
     @db.drop_column(:items, :item_id)
-    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id]
-    @ds.columns!.should == [:id]
+    @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :i]
   end
 
-  cspecify "should remove multiple columns in a single alter_table block", [:jdbc, :db2] do
+  specify "should remove multiple columns in a single alter_table block" do
     @db.create_table!(:items) do
       primary_key :id
       String :name
@@ -557,13 +569,11 @@ describe "Database schema modifiers" do
     end
     @ds.insert(:number=>10)
     @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :name, :number]
-    @ds.columns!.should == [:id, :name, :number]
     @db.alter_table(:items) do
       drop_column :name
       drop_column :number
     end
     @db.schema(:items, :reload=>true).map{|x| x.first}.should == [:id]
-    @ds.columns!.should == [:id]
   end
 end
 

data/spec/integration/spec_helper.rb

@@ -2,7 +2,7 @@ require 'rubygems'
 require 'logger'
 unless Object.const_defined?('Sequel')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-  require 'sequel'
+  require 'sequel/no_core_ext'
 end
 begin
   require File.join(File.dirname(File.dirname(__FILE__)), 'spec_config.rb') unless defined?(INTEGRATION_DB)

data/spec/integration/timezone_test.rb

@@ -58,7 +58,7 @@ describe "Sequel timezone support" do
     test_timezone
   end
 
-  cspecify "should support using UTC for both database storage and for application", [:swift], [:do, :mysql], [:do, :postgres], [:oracle] do
+  cspecify "should support using UTC for both database storage and for application", [:do, :mysql], [:do, :postgres], [:oracle] do
     Sequel.default_timezone = :utc
     test_timezone
     Sequel.database_timezone = :local
@@ -79,7 +79,7 @@ describe "Sequel timezone support" do
     @db.timezone = :local
     t = Time.now
     @db[:t].insert(t)
-    s = @db[:t].get(:t.cast(String))
+    s = @db[:t].get(Sequel.cast(:t, String))
     if o = Date._parse(s)[:offset]
       o.should == t.utc_offset
     end

data/spec/integration/type_test.rb

@@ -9,10 +9,10 @@ describe "Supported types" do
   specify "should support casting correctly" do
     ds = create_items_table_with_column(:number, Integer)
     ds.insert(:number => 1)
-    ds.select(:number.cast_string.as(:n)).map(:n).should == %w'1'
+    ds.select(Sequel.cast(:number, String).as(:n)).map(:n).should == %w'1'
     ds = create_items_table_with_column(:name, String)
     ds.insert(:name=> '1')
-    ds.select(:name.cast_numeric.as(:n)).map(:n).should == [1]
+    ds.select(Sequel.cast(:name, Integer).as(:n)).map(:n).should == [1]
   end
 
   specify "should support NULL correctly" do
@@ -33,7 +33,7 @@ describe "Supported types" do
     ds.all.should == [{:number=>2}]
   end
   
-  cspecify "should support generic bignum type", [:swift, :sqlite] do
+  specify "should support generic bignum type" do
     ds = create_items_table_with_column(:number, Bignum)
     ds.insert(:number => 2**34)
     ds.all.should == [{:number=>2**34}]
@@ -93,10 +93,10 @@ describe "Supported types" do
     ds.first[:tim].strftime('%Y%m%d%H%M%S').should == t.strftime('%Y%m%d%H%M%S')
   end
   
-  cspecify "should support generic file type", [:do], [:odbc, :mssql], [:mysql2], [:swift], [:tinytds] do
+  cspecify "should support generic file type", [:do], [:odbc, :mssql], [:mysql2], [:tinytds] do
     ds = create_items_table_with_column(:name, File)
-    ds.insert(:name => ("a\0"*300).to_sequel_blob)
-    ds.all.should == [{:name=>("a\0"*300).to_sequel_blob}]
+    ds.insert(:name =>Sequel.blob("a\0"*300))
+    ds.all.should == [{:name=>Sequel.blob("a\0"*300)}]
     ds.first[:name].should be_a_kind_of(::Sequel::SQL::Blob)
   end
   
@@ -108,4 +108,13 @@ describe "Supported types" do
     ds.insert(:number => true)
     ds.all.should == [{:number=>true}]
   end
+  
+  cspecify "should support generic boolean type with defaults", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], [:odbc, :mssql], :oracle do
+    ds = create_items_table_with_column(:number, TrueClass, :default=>true)
+    ds.insert
+    ds.all.should == [{:number=>true}]
+    ds = create_items_table_with_column(:number, FalseClass, :default=>false)
+    ds.insert
+    ds.all.should == [{:number=>false}]
+  end
 end

data/spec/model/association_reflection_spec.rb

@@ -134,7 +134,7 @@ describe Sequel::Model::Associations::AssociationReflection, "#select" do
   it "should be the associated_table.* if :select is not present for a many_to_many associaiton" do
     @c.many_to_many :cs, :class=>'ParParent'
     @c.association_reflection(:cs).keys.should_not include(:select)
-    @c.association_reflection(:cs).select.should == :par_parents.*
+    @c.association_reflection(:cs).select.should == Sequel::SQL::ColumnAll.new(:par_parents)
   end
   it "should be if :select is not present for a many_to_one and one_to_many associaiton" do
     @c.one_to_many :cs, :class=>'ParParent'

data/spec/model/associations_spec.rb

@@ -259,7 +259,7 @@ describe Sequel::Model, "many_to_one" do
 
   it "should support :order, :limit (only for offset), and :dataset options, as well as a block" do
     @c2.many_to_one :child_20, :class => @c2, :key=>:id, :dataset=>proc{model.filter(:parent_id=>pk)}, :limit=>[10,20], :order=>:name do |ds|
-      ds.filter(:x.sql_number > 1)
+      ds.filter{x > 1}
     end
     @c2.load(:id => 100).child_20
     MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE ((parent_id = 100) AND (x > 1)) ORDER BY name LIMIT 1 OFFSET 20"]
@@ -833,7 +833,7 @@ describe Sequel::Model, "one_to_one" do
 
   it "should support :order, :limit (only for offset), and :dataset options, as well as a block" do
     @c2.one_to_one :child_20, :class => @c2, :key=>:id, :dataset=>proc{model.filter(:parent_id=>pk)}, :limit=>[10,20], :order=>:name do |ds|
-      ds.filter(:x.sql_number > 1)
+      ds.filter{x > 1}
     end
     @c2.load(:id => 100).child_20
     MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE ((parent_id = 100) AND (x > 1)) ORDER BY name LIMIT 1 OFFSET 20"]
@@ -1365,7 +1365,7 @@ describe Sequel::Model, "one_to_many" do
   it "should support a conditions option" do
     @c2.one_to_many :attributes, :class => @c1, :conditions => {:a=>32}
     @c2.new(:id => 1234).attributes_dataset.sql.should == "SELECT * FROM attributes WHERE ((attributes.node_id = 1234) AND (a = 32))"
-    @c2.one_to_many :attributes, :class => @c1, :conditions => ~:a
+    @c2.one_to_many :attributes, :class => @c1, :conditions => Sequel.~(:a)
     @c2.new(:id => 1234).attributes_dataset.sql.should == "SELECT * FROM attributes WHERE ((attributes.node_id = 1234) AND NOT a)"
   end
   
@@ -1886,7 +1886,7 @@ describe Sequel::Model, "many_to_many" do
   end
   
   it "should support an array for the select option" do
-    @c2.many_to_many :attributes, :class => @c1, :select => [:attributes.*, :attribute_nodes__blah2]
+    @c2.many_to_many :attributes, :class => @c1, :select => [Sequel::SQL::ColumnAll.new(:attributes), :attribute_nodes__blah2]
 
     @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.*, attribute_nodes.blah2 FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234))'
   end

data/spec/model/base_spec.rb

@@ -335,12 +335,12 @@ describe "Model.qualified_primary_key_hash" do
   end
   
   specify "should handle a single primary key" do
-    @c.qualified_primary_key_hash(1).should == {:id.qualify(:items)=>1}
+    @c.qualified_primary_key_hash(1).should == {Sequel.qualify(:items, :id)=>1}
   end
 
   specify "should handle a composite primary key" do
     @c.set_primary_key([:id1, :id2])
-    @c.qualified_primary_key_hash([1, 2]).should == {:id1.qualify(:items)=>1, :id2.qualify(:items)=>2}
+    @c.qualified_primary_key_hash([1, 2]).should == {Sequel.qualify(:items, :id1)=>1, Sequel.qualify(:items, :id2)=>2}
   end
 
   specify "should raise an error for no primary key" do
@@ -349,9 +349,9 @@ describe "Model.qualified_primary_key_hash" do
   end
 
   specify "should allow specifying a different qualifier" do
-    @c.qualified_primary_key_hash(1, :apple).should == {:id.qualify(:apple)=>1}
+    @c.qualified_primary_key_hash(1, :apple).should == {Sequel.qualify(:apple, :id)=>1}
     @c.set_primary_key([:id1, :id2])
-    @c.qualified_primary_key_hash([1, 2], :bear).should == {:id1.qualify(:bear)=>1, :id2.qualify(:bear)=>2}
+    @c.qualified_primary_key_hash([1, 2], :bear).should == {Sequel.qualify(:bear, :id1)=>1, Sequel.qualify(:bear, :id2)=>2}
   end
 end
 
@@ -608,7 +608,7 @@ describe Sequel::Model, ".[] optimization" do
     @c.simple_pk.should == '"id"'
     @c.set_primary_key :b
     @c.simple_pk.should == '"b"'
-    @c.set_primary_key :b__a.identifier
+    @c.set_primary_key Sequel.identifier(:b__a)
     @c.simple_pk.should == '"b__a"'
   end