sequel 3.45.0 → 3.46.0

data/lib/sequel/plugins/validation_helpers.rb

@@ -161,7 +161,7 @@ module Sequel
         # Check if value is an instance of a class
         def validates_type(klass, atts, opts={})
           klass = klass.to_s.constantize if klass.is_a?(String) || klass.is_a?(Symbol)
-          validatable_attributes_for_type(:type, atts, opts){|a,v,m| validation_error_message(m, klass) if v && !v.is_a?(klass)}
+          validatable_attributes_for_type(:type, atts, opts){|a,v,m| validation_error_message(m, klass) if !v.nil? && !v.is_a?(klass)}
         end
     
         # Check attribute value(s) is not considered blank by the database, but allow false values.

data/lib/sequel/sql.rb

@@ -89,6 +89,9 @@ module Sequel
         # Create a to_s instance method that takes a dataset, and calls
         # the method provided on the dataset with args as the argument (self by default).
         # Used to DRY up some code.
+        #
+        # Do not call this method with untrusted input, as that can result in
+        # arbitrary code execution.
         def to_s_method(meth, args=:self) # :nodoc:
           class_eval("def to_s(ds) ds.#{meth}(#{args}) end", __FILE__, __LINE__)
           class_eval("def to_s_append(ds, sql) ds.#{meth}_append(sql, #{args}) end", __FILE__, __LINE__)

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 3
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 45
+  MINOR = 46
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/mssql_spec.rb

@@ -55,6 +55,27 @@ describe "A MSSQL database" do
   end
 end
 
+describe "MSSQL" do
+  before(:all) do
+    @db = MSSQL_DB
+    @db.create_table!(:test3){Integer :v3}
+    @db.create_table!(:test4){Integer :v4}
+    @db[:test3].import([:v3], [[1], [2]])
+    @db[:test4].import([:v4], [[1], [3]])
+  end
+  after(:all) do
+    @db.drop_table?(:test3, :test4)
+  end
+
+  specify "should should support CROSS APPLY" do
+    @db[:test3].cross_apply(@db[:test4].where(:test3__v3=>:test4__v4)).select_order_map([:v3, :v4]).should == [[1,1]]
+  end
+
+  specify "should should support OUTER APPLY" do
+    @db[:test3].outer_apply(@db[:test4].where(:test3__v3=>:test4__v4)).select_order_map([:v3, :v4]).should == [[1,1], [2, nil]]
+  end
+end
+
 # This spec is currently disabled as the SQL Server 2008 R2 Express doesn't support
 # full text searching.  Even if full text searching is supported,
 # you may need to create a full text catalog on the database first via:

data/spec/adapters/postgres_spec.rb

@@ -440,8 +440,8 @@ describe "A PostgreSQL dataset with a timestamp field" do
   before(:all) do
     @db = POSTGRES_DB
     @db.create_table! :test3 do
-      integer :value
-      timestamp :time
+      Date :date
+      DateTime :time
     end
     @d = @db[:test3]
   end
@@ -457,8 +457,8 @@ describe "A PostgreSQL dataset with a timestamp field" do
 
   cspecify "should store milliseconds in time fields for Time objects", :do, :swift do
     t = Time.now
-    @d << {:value=>1, :time=>t}
-    t2 = @d[:value =>1][:time]
+    @d << {:time=>t}
+    t2 = @d.get(:time)
     @d.literal(t2).should == @d.literal(t)
     t2.strftime('%Y-%m-%d %H:%M:%S').should == t.strftime('%Y-%m-%d %H:%M:%S')
     (t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000).should == t.usec
@@ -466,8 +466,8 @@ describe "A PostgreSQL dataset with a timestamp field" do
 
   cspecify "should store milliseconds in time fields for DateTime objects", :do, :swift do
     t = DateTime.now
-    @d << {:value=>1, :time=>t}
-    t2 = @d[:value =>1][:time]
+    @d << {:time=>t}
+    t2 = @d.get(:time)
     @d.literal(t2).should == @d.literal(t)
     t2.strftime('%Y-%m-%d %H:%M:%S').should == t.strftime('%Y-%m-%d %H:%M:%S')
     (t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000).should == t.strftime('%N').to_i/1000
@@ -475,7 +475,7 @@ describe "A PostgreSQL dataset with a timestamp field" do
 
   if POSTGRES_DB.adapter_scheme == :postgres
     specify "should handle infinite timestamps if convert_infinite_timestamps is set" do
-      @d << {:time=>Sequel.cast('infinity', :timestamp)}
+      @d << {:time=>Sequel.cast('infinity', DateTime)}
       @db.convert_infinite_timestamps = :nil
       @db[:test3].get(:time).should == nil
       @db.convert_infinite_timestamps = :string
@@ -483,7 +483,7 @@ describe "A PostgreSQL dataset with a timestamp field" do
       @db.convert_infinite_timestamps = :float
       @db[:test3].get(:time).should == 1.0/0.0
 
-      @d.update(:time=>Sequel.cast('-infinity', :timestamp))
+      @d.update(:time=>Sequel.cast('-infinity', DateTime))
       @db.convert_infinite_timestamps = :nil
       @db[:test3].get(:time).should == nil
       @db.convert_infinite_timestamps = :string
@@ -500,6 +500,33 @@ describe "A PostgreSQL dataset with a timestamp field" do
       c.new(:time=>1.0/0.0).time.should == 1.0/0.0
       c.new(:time=>-1.0/0.0).time.should == -1.0/0.0
     end
+
+    specify "should handle infinite dates if convert_infinite_timestamps is set" do
+      @d << {:date=>Sequel.cast('infinity', Date)}
+      @db.convert_infinite_timestamps = :nil
+      @db[:test3].get(:date).should == nil
+      @db.convert_infinite_timestamps = :string
+      @db[:test3].get(:date).should == 'infinity'
+      @db.convert_infinite_timestamps = :float
+      @db[:test3].get(:date).should == 1.0/0.0
+
+      @d.update(:date=>Sequel.cast('-infinity', :timestamp))
+      @db.convert_infinite_timestamps = :nil
+      @db[:test3].get(:date).should == nil
+      @db.convert_infinite_timestamps = :string
+      @db[:test3].get(:date).should == '-infinity'
+      @db.convert_infinite_timestamps = :float
+      @db[:test3].get(:date).should == -1.0/0.0
+    end
+
+    specify "should handle conversions from infinite strings/floats in models" do
+      c = Class.new(Sequel::Model(:test3))
+      @db.convert_infinite_timestamps = :float
+      c.new(:date=>'infinity').date.should == 'infinity'
+      c.new(:date=>'-infinity').date.should == '-infinity'
+      c.new(:date=>1.0/0.0).date.should == 1.0/0.0
+      c.new(:date=>-1.0/0.0).date.should == -1.0/0.0
+    end
   end
 
   specify "explain and analyze should not raise errors" do

data/spec/core/database_spec.rb

@@ -1663,6 +1663,10 @@ describe "Database#each_server with do/jdbc adapter connection string without :a
     end
     hosts.sort.should == [1, 3]
   end
+
+  specify "should raise if not given a block" do
+    proc{Sequel.mock.each_server}.should raise_error(Sequel::Error)
+  end
 end
 
 describe "Database#each_server" do

data/spec/core/dataset_spec.rb

@@ -2465,8 +2465,7 @@ end
 
 describe "Dataset #first and #last" do
   before do
-    @db = Sequel.mock(:fetch=>proc{|s| {:s=>s}})
-    @d = @db[:test]
+    @d = Sequel.mock(:fetch=>proc{|s| {:s=>s}})[:test]
   end
   
   specify "should return a single record if no argument is given" do
@@ -2504,6 +2503,10 @@ describe "Dataset #first and #last" do
     i = rand(10) + 10
     r = @d.order(:a).last(i){z > 26}.should == [{:s=>"SELECT * FROM test WHERE (z > 26) ORDER BY a DESC LIMIT #{i}"}]
   end
+
+  specify "should return nil if no records match" do
+    Sequel.mock[:t].first.should == nil
+  end
   
   specify "#last should raise if no order is given" do
     proc {@d.last}.should raise_error(Sequel::Error)
@@ -2520,6 +2523,44 @@ describe "Dataset #first and #last" do
   end
 end
 
+describe "Dataset #first!" do
+  before do
+    @db = Sequel.mock(:fetch=>proc{|s| {:s=>s}})
+    @d = @db[:test]
+  end
+  
+  specify "should return a single record if no argument is given" do
+    @d.order(:a).first!.should == {:s=>'SELECT * FROM test ORDER BY a LIMIT 1'}
+  end
+
+  specify "should return the first! matching record if argument is not an Integer" do
+    @d.order(:a).first!(:z => 26).should == {:s=>'SELECT * FROM test WHERE (z = 26) ORDER BY a LIMIT 1'}
+    @d.order(:a).first!('z = ?', 15).should == {:s=>'SELECT * FROM test WHERE (z = 15) ORDER BY a LIMIT 1'}
+  end
+  
+  specify "should set the limit and return an array of records if the given number is > 1" do
+    i = rand(10) + 10
+    r = @d.order(:a).first!(i).should == [{:s=>"SELECT * FROM test ORDER BY a LIMIT #{i}"}]
+  end
+  
+  specify "should return the first! matching record if a block is given without an argument" do
+    @d.first!{z > 26}.should == {:s=>'SELECT * FROM test WHERE (z > 26) LIMIT 1'}
+  end
+  
+  specify "should combine block and standard argument filters if argument is not an Integer" do
+    @d.first!(:y=>25){z > 26}.should == {:s=>'SELECT * FROM test WHERE ((z > 26) AND (y = 25)) LIMIT 1'}
+  end
+  
+  specify "should filter and return an array of records if an Integer argument is provided and a block is given" do
+    i = rand(10) + 10
+    r = @d.order(:a).first!(i){z > 26}.should == [{:s=>"SELECT * FROM test WHERE (z > 26) ORDER BY a LIMIT #{i}"}]
+  end
+
+  specify "should raise NoMatchingRow exception if no rows match" do
+    proc{Sequel.mock[:t].first!}.should raise_error(Sequel::NoMatchingRow)
+  end
+end
+  
 describe "Dataset compound operations" do
   before do
     @a = Sequel::Dataset.new(nil).from(:a).filter(:z => 1)
@@ -4038,6 +4079,11 @@ describe "Sequel::Dataset#select_map" do
     @ds.db.sqls.should == ['SELECT c, c FROM t']
   end
   
+  specify "should raise an error for plain strings" do
+    proc{@ds.select_map(['c', :c])}.should raise_error(Sequel::Error)
+    @ds.db.sqls.should == []
+  end
+  
   specify "should accept a block" do
     @ds.select_map{a(t__c)}.should == [1, 2]
     @ds.db.sqls.should == ['SELECT a(t.c) FROM t']

data/spec/core/schema_generator_spec.rb

@@ -121,6 +121,10 @@ describe Sequel::Schema::AlterTableGenerator do
       add_foreign_key :node_id, :nodes
       add_primary_key [:aaa, :bbb]
       add_foreign_key [:node_id, :prop_id], :nodes_props
+      add_foreign_key [:node_id, :prop_id], :nodes_props, :name => :fkey
+      drop_foreign_key :node_id
+      drop_foreign_key [:node_id, :prop_id]
+      drop_foreign_key [:node_id, :prop_id], :name => :fkey
     end
   end
   
@@ -144,7 +148,12 @@ describe Sequel::Schema::AlterTableGenerator do
       {:op => :add_column, :name => :id, :type => Integer, :primary_key=>true, :auto_increment=>true},
       {:op => :add_column, :name => :node_id, :type => Integer, :table=>:nodes},
       {:op => :add_constraint, :type => :primary_key, :columns => [:aaa, :bbb]},
-      {:op => :add_constraint, :type => :foreign_key, :columns => [:node_id, :prop_id], :table => :nodes_props}
+      {:op => :add_constraint, :type => :foreign_key, :columns => [:node_id, :prop_id], :table => :nodes_props},
+      {:op => :add_constraint, :type => :foreign_key, :columns => [:node_id, :prop_id], :table => :nodes_props, :name => :fkey},
+      {:op => :drop_constraint, :type => :foreign_key, :columns => [:node_id]},
+      {:op => :drop_column, :name => :node_id},
+      {:op => :drop_constraint, :type => :foreign_key, :columns => [:node_id, :prop_id]},
+      {:op => :drop_constraint, :type => :foreign_key, :columns => [:node_id, :prop_id], :name => :fkey},
     ]
   end
 end

data/spec/core/schema_spec.rb

@@ -113,6 +113,22 @@ describe "DB#create_table" do
     @db.sqls.should == ['CREATE TABLE cats (id serial PRIMARY KEY)']
   end
 
+  specify "should allow naming primary key constraint with :primary_key_constraint_name option" do
+    @db.create_table(:cats) do
+      primary_key :id, :primary_key_constraint_name=>:foo
+    end
+    @db.sqls.should == ['CREATE TABLE cats (id integer CONSTRAINT foo PRIMARY KEY AUTOINCREMENT)']
+  end
+
+  specify "should handling splitting named column constraints into table constraints if unsupported" do
+    def @db.supports_named_column_constraints?; false end
+    @db.create_table(:cats) do
+      primary_key :id, :primary_key_constraint_name=>:foo
+      foreign_key :cat_id, :cats, :unique=>true, :unique_constraint_name=>:bar, :foreign_key_constraint_name=>:baz, :deferrable=>true, :key=>:foo_id, :on_delete=>:cascade, :on_update=>:restrict
+    end
+    @db.sqls.should == ['CREATE TABLE cats (id integer AUTOINCREMENT, cat_id integer, CONSTRAINT foo PRIMARY KEY (id), CONSTRAINT baz FOREIGN KEY (cat_id) REFERENCES cats(foo_id) ON DELETE CASCADE ON UPDATE RESTRICT DEFERRABLE INITIALLY DEFERRED, CONSTRAINT bar UNIQUE (cat_id))']
+  end
+
   specify "should accept and literalize default values" do
     @db.create_table(:cats) do
       integer :id, :default => 123
@@ -147,6 +163,13 @@ describe "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (id integer, name text UNIQUE)"]
   end
   
+  specify "should allow naming unique constraint with :unique_constraint_name option" do
+    @db.create_table(:cats) do
+      text :name, :unique => true, :unique_constraint_name=>:foo
+    end
+    @db.sqls.should == ["CREATE TABLE cats (name text CONSTRAINT foo UNIQUE)"]
+  end
+  
   specify "should handle not deferred unique constraints" do
     @db.create_table(:cats) do
       integer :id
@@ -227,6 +250,13 @@ describe "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (project_id integer DEFAULT 3 REFERENCES projects)"]
   end
   
+  specify "should allowing naming foreign key constraint with :foreign_key_constraint_name option" do
+    @db.create_table(:cats) do
+      foreign_key :project_id, :projects, :foreign_key_constraint_name=>:foo
+    end
+    @db.sqls.should == ["CREATE TABLE cats (project_id integer CONSTRAINT foo REFERENCES projects)"]
+  end
+  
   specify "should raise an error if the table argument to foreign_key isn't a hash, symbol, or nil" do
     proc{@db.create_table(:cats){foreign_key :project_id, Object.new, :default=>3}}.should raise_error(Sequel::Error)
   end
@@ -949,6 +979,45 @@ describe "DB#alter_table" do
     @db.sqls.should == ["ALTER TABLE cats DROP CONSTRAINT valid_score CASCADE"]
   end
 
+  specify "should support drop_foreign_key" do
+    def @db.foreign_key_list(table_name)
+      [{:name=>:cats_node_id_fkey, :columns=>[:node_id]}] 
+    end
+    @db.alter_table(:cats) do
+      drop_foreign_key :node_id
+    end
+    @db.sqls.should == ["ALTER TABLE cats DROP CONSTRAINT cats_node_id_fkey", "ALTER TABLE cats DROP COLUMN node_id"]
+  end
+
+  specify "should support drop_foreign_key with composite foreign keys" do
+    def @db.foreign_key_list(table_name)
+      [{:name=>:cats_node_id_prop_id_fkey, :columns=>[:node_id, :prop_id]}] 
+    end
+    @db.alter_table(:cats) do
+      drop_foreign_key [:node_id, :prop_id]
+    end
+    @db.sqls.should == ["ALTER TABLE cats DROP CONSTRAINT cats_node_id_prop_id_fkey"]
+
+    @db.alter_table(:cats) do
+      drop_foreign_key [:node_id, :prop_id], :name => :cfk
+    end
+    @db.sqls.should == ["ALTER TABLE cats DROP CONSTRAINT cfk"]
+  end
+
+  specify "should have drop_foreign_key raise Error if no name is found" do
+    def @db.foreign_key_list(table_name)
+      [{:name=>:cats_node_id_fkey, :columns=>[:foo_id]}] 
+    end
+    lambda{@db.alter_table(:cats){drop_foreign_key :node_id}}.should raise_error(Sequel::Error)
+  end
+
+  specify "should have drop_foreign_key raise Error if multiple foreign keys found" do
+    def @db.foreign_key_list(table_name)
+      [{:name=>:cats_node_id_fkey, :columns=>[:node_id]}, {:name=>:cats_node_id_fkey2, :columns=>[:node_id]}] 
+    end
+    lambda{@db.alter_table(:cats){drop_foreign_key :node_id}}.should raise_error(Sequel::Error)
+  end
+
   specify "should support drop_index" do
     @db.alter_table(:cats) do
       drop_index :name

data/spec/extensions/composition_spec.rb

@@ -90,13 +90,32 @@ describe "Composition plugin" do
     called.should == true
   end
 
-  it "should clear compositions cache when reloading" do
+  it "should clear compositions cache when using set_values" do
     @c.composition :date, :composer=>proc{}, :decomposer=>proc{called = true}
     @o.date = Date.new(3, 4, 5)
-    @o.reload
+    @o.set_values(:id=>1)
     @o.compositions.should == {}
   end
 
+  it "should clear compositions cache when refreshing" do
+    @c.composition :date, :composer=>proc{}, :decomposer=>proc{called = true}
+    @o.date = Date.new(3, 4, 5)
+    @o.refresh
+    @o.compositions.should == {}
+  end
+
+  it "should clear compositions cache when refreshing after save" do
+    @c.composition :date, :composer=>proc{}, :decomposer=>proc{called = true}
+    @c.create(:date=>Date.new(3, 4, 5)).compositions.should == {}
+  end
+
+  it "should clear compositions cache when saving with insert_select" do
+    def (@c.instance_dataset).supports_insert_select?() true end
+    def (@c.instance_dataset).insert_select(*) {:id=>1} end
+    @c.composition :date, :composer=>proc{}, :decomposer=>proc{called = true}
+    @c.create(:date=>Date.new(3, 4, 5)).compositions.should == {}
+  end
+
   it "should instantiate compositions lazily" do
     @c.composition :date, :mapping=>[:year, :month, :day]
     @o.compositions.should == {}

data/spec/extensions/dirty_spec.rb

@@ -88,6 +88,11 @@ describe "Sequel::Plugins::Dirty" do
       @o.values.has_key?(:missing_changed).should == false
     end
     
+    it "set_values should clear the cached initial values" do
+      @o.set_values(:id=>1)
+      @o.column_changes.should == {}
+    end
+    
     it "refresh should clear the cached initial values" do
       @o.refresh
       @o.column_changes.should == {}
@@ -116,16 +121,6 @@ describe "Sequel::Plugins::Dirty" do
         o.column_change(:initial).should == [v, 'a']
       end
     end
-
-    it "save should clear the cached initial values" do
-      @o.save
-      @o.column_changes.should == {}
-    end
-
-    it "save_changes should clear the cached initial values" do
-      @o.save_changes
-      @o.column_changes.should == {}
-    end
   end
 
   describe "with new instance" do
@@ -136,6 +131,18 @@ describe "Sequel::Plugins::Dirty" do
     end
 
     it_should_behave_like "dirty plugin"
+
+    it "save should clear the cached initial values" do
+      @o.save
+      @o.column_changes.should == {}
+    end
+
+    it "save_changes should clear the cached initial values" do
+      def (@c.instance_dataset).supports_insert_select?() true end
+      def (@c.instance_dataset).insert_select(*) {:id=>1} end
+      @o.save
+      @o.column_changes.should == {}
+    end
   end
 
   describe "with existing instance" do

data/spec/extensions/eager_each_spec.rb

@@ -17,7 +17,10 @@ describe "Sequel::Plugins::EagerEach" do
     ds.each{|c| a << c}
     a.should == [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
     a.map{|c| c.associations[:children]}.should == [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
-    @c.db.sqls.should == ['SELECT * FROM items', 'SELECT * FROM items WHERE (items.parent_id IN (1, 2))']
+    sqls = @c.db.sqls
+    sqls.shift.should == 'SELECT * FROM items'
+    ['SELECT * FROM items WHERE (items.parent_id IN (1, 2))', 
+     'SELECT * FROM items WHERE (items.parent_id IN (2, 1))'].should include(sqls.pop)
   end
 
   it "should make #each on an eager_graph dataset do eager loading" do

data/spec/extensions/looser_typecasting_spec.rb

@@ -4,36 +4,33 @@ describe "LooserTypecasting Extension" do
   before do
     @db = Sequel::Database.new({})
     def @db.schema(*args)
-      [[:id, {}], [:z, {:type=>:float}], [:b, {:type=>:integer}]]
+      [[:id, {}], [:z, {:type=>:float}], [:b, {:type=>:integer}], [:d, {:type=>:decimal}]]
     end 
     @c = Class.new(Sequel::Model(@db[:items]))
+    @db.extension(:looser_typecasting)
     @c.instance_eval do
-      @columns = [:id, :b, :z] 
+      @columns = [:id, :b, :z, :d] 
       def columns; @columns; end 
     end
   end
 
-  specify "Should use to_i instead of Integer() for typecasting integers" do
-    proc{@c.new(:b=>'a')}.should raise_error(Sequel::InvalidValue)
-    @db.extension(:looser_typecasting)
+  specify "should not raise errors for invalid strings in integer columns" do
     @c.new(:b=>'a').b.should == 0
-
-    o = Object.new
-    def o.to_i
-      1
-    end
-    @c.new(:b=>o).b.should == 1
+    @c.new(:b=>'a').b.should be_a_kind_of(Integer)
   end
 
-  specify "Should use to_f instead of Float() for typecasting floats" do
-    proc{@c.new(:z=>'a')}.should raise_error(Sequel::InvalidValue)
-    @db.extension(:looser_typecasting)
+  specify "should not raise errors for invalid strings in float columns" do
     @c.new(:z=>'a').z.should == 0.0
+    @c.new(:z=>'a').z.should be_a_kind_of(Float)
+  end
 
-    o = Object.new
-    def o.to_f
-      1.0
-    end
-    @c.new(:z=>o).z.should == 1.0
+  specify "should not raise errors for invalid strings in decimal columns" do
+    @c.new(:d=>'a').d.should == 0.0
+    @c.new(:d=>'a').d.should be_a_kind_of(BigDecimal)
+  end
+
+  specify "should not affect conversions of other types in decimal columns" do
+    @c.new(:d=>1).d.should == 1
+    @c.new(:d=>'a').d.should be_a_kind_of(BigDecimal)
   end
 end