sequel 3.35.0 → 3.36.0

data/spec/extensions/prepared_statements_spec.rb

@@ -54,4 +54,34 @@ describe "prepared_statements plugin" do
     c[1].should == c.load(:id=>1, :name=>'foo', :i=>2)
     @db.sqls.should == ["SELECT * FROM people WHERE (id = 1) LIMIT 1 -- read_only"]
   end 
+
+  describe " with placeholder type specifiers" do 
+    before do
+      @ds.meta_def(:requires_placeholder_type_specifiers?){true}
+    end
+
+    specify "should correctly handle without schema type" do
+      @c[1].should == @p
+      @db.sqls.should == ["SELECT * FROM people WHERE (id = 1) LIMIT 1 -- read_only"]
+    end
+
+    specify "should correctly handle with schema type" do
+      @c.db_schema[:id][:type] = :integer
+      ds = @c.send(:prepared_lookup)
+      def ds.literal_symbol_append(sql, v)
+        if @opts[:bind_vars] and match = /\A\$(.*)\z/.match(v.to_s)
+          s = match[1].split('__')[0].to_sym
+          if prepared_arg?(s)
+            literal_append(sql, prepared_arg(s))
+          else
+            sql << v.to_s
+          end
+        else
+          super
+        end
+      end
+      @c[1].should == @p
+      @db.sqls.should == ["SELECT * FROM people WHERE (id = 1) LIMIT 1 -- read_only"]
+    end 
+  end
 end

data/spec/extensions/rcte_tree_spec.rb

@@ -30,6 +30,15 @@ describe Sequel::Model, "rcte_tree" do
     @o.descendants_dataset.sql.should == 'WITH t AS (SELECT * FROM nodes WHERE (parent_id = 2) UNION ALL SELECT nodes.* FROM nodes INNER JOIN t ON (t.id = nodes.parent_id)) SELECT * FROM t AS nodes'
   end
   
+  it "should use the correct SQL for lazy associations when recursive CTEs require column aliases" do
+    @c.dataset.meta_def(:recursive_cte_requires_column_aliases?){true}
+    @c.plugin :rcte_tree
+    @o.parent_dataset.sql.should == 'SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1'
+    @o.children_dataset.sql.should == 'SELECT * FROM nodes WHERE (nodes.parent_id = 2)'
+    @o.ancestors_dataset.sql.should == 'WITH t(id, name, parent_id, i, pi) AS (SELECT id, name, parent_id, i, pi FROM nodes WHERE (id = 1) UNION ALL SELECT nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes INNER JOIN t ON (t.parent_id = nodes.id)) SELECT * FROM t AS nodes'
+    @o.descendants_dataset.sql.should == 'WITH t(id, name, parent_id, i, pi) AS (SELECT id, name, parent_id, i, pi FROM nodes WHERE (parent_id = 2) UNION ALL SELECT nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes INNER JOIN t ON (t.id = nodes.parent_id)) SELECT * FROM t AS nodes'
+  end
+  
   it "should use the correct SQL for lazy associations when giving options" do
     @c.plugin :rcte_tree, :primary_key=>:i, :key=>:pi, :cte_name=>:cte, :order=>:name, :ancestors=>{:name=>:as}, :children=>{:name=>:cs}, :descendants=>{:name=>:ds}, :parent=>{:name=>:p}
     @o.p_dataset.sql.should == 'SELECT * FROM nodes WHERE (nodes.i = 4) ORDER BY name LIMIT 1'

data/spec/extensions/schema_dumper_spec.rb

@@ -50,9 +50,9 @@ add_index :t, [:b, :c], :unique=>true
 END_CODE
 
     g.dump_indexes(:drop_index=>:t).should == (<<END_CODE).strip
-drop_index :t, [:a]
-drop_index :t, [:c, :e], :name=>:blah
 drop_index :t, [:b, :c], :unique=>true
+drop_index :t, [:c, :e], :name=>:blah
+drop_index :t, [:a]
 END_CODE
   end
 
@@ -340,6 +340,112 @@ end
 END_MIG
   end
 
+  it "should honor the :index_names => false option to not include names of indexes" do
+    @d.meta_def(:indexes) do |t|
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
+    end
+    @d.dump_table_schema(:t1, :index_names=>false).should == "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1]\n  index [:c2, :c1], :unique=>true\nend"
+    @d.dump_schema_migration(:index_names=>false).should == <<-END_MIG
+Sequel.migration do
+  up do
+    create_table(:t1, :ignore_index_errors=>true) do
+      primary_key :c1
+      String :c2, :size=>20
+      
+      index [:c1]
+      index [:c2, :c1], :unique=>true
+    end
+    
+    create_table(:t2, :ignore_index_errors=>true) do
+      Integer :c1, :null=>false
+      BigDecimal :c2, :null=>false
+      
+      primary_key [:c1, :c2]
+      
+      index [:c1]
+      index [:c2, :c1], :unique=>true
+    end
+  end
+  
+  down do
+    drop_table(:t2, :t1)
+  end
+end
+END_MIG
+  end
+  
+  it "should make :index_names => :namespace option a noop if there is a  global index namespace" do
+    @d.meta_def(:indexes) do |t|
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
+    end
+    @d.dump_table_schema(:t1, :index_names=>:namespace).should == "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1], :name=>:i1\n  index [:c2, :c1]\nend"
+    @d.dump_schema_migration(:index_names=>:namespace).should == <<-END_MIG
+Sequel.migration do
+  up do
+    create_table(:t1, :ignore_index_errors=>true) do
+      primary_key :c1
+      String :c2, :size=>20
+      
+      index [:c1], :name=>:i1
+      index [:c2, :c1]
+    end
+    
+    create_table(:t2, :ignore_index_errors=>true) do
+      Integer :c1, :null=>false
+      BigDecimal :c2, :null=>false
+      
+      primary_key [:c1, :c2]
+      
+      index [:c1], :name=>:i1
+      index [:c2, :c1], :name=>:t1_c2_c1_index
+    end
+  end
+  
+  down do
+    drop_table(:t2, :t1)
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :index_names => :namespace option to include names of indexes with prepended table name if there is no global index namespace" do
+    @d.meta_def(:global_index_namespace?){false}
+    @d.meta_def(:indexes) do |t|
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
+    end
+    @d.dump_table_schema(:t1, :index_names=>:namespace).should == "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1], :name=>:t1_i1\n  index [:c2, :c1]\nend"
+    @d.dump_schema_migration(:index_names=>:namespace).should == <<-END_MIG
+Sequel.migration do
+  up do
+    create_table(:t1, :ignore_index_errors=>true) do
+      primary_key :c1
+      String :c2, :size=>20
+      
+      index [:c1], :name=>:t1_i1
+      index [:c2, :c1]
+    end
+    
+    create_table(:t2, :ignore_index_errors=>true) do
+      Integer :c1, :null=>false
+      BigDecimal :c2, :null=>false
+      
+      primary_key [:c1, :c2]
+      
+      index [:c1], :name=>:t2_i1
+      index [:c2, :c1], :name=>:t2_t1_c2_c1_index
+    end
+  end
+  
+  down do
+    drop_table(:t2, :t1)
+  end
+end
+END_MIG
+  end
+
   it "should honor the :indexes => false option to not include indexes" do
     @d.meta_def(:indexes) do |t|
       {:i1=>{:columns=>[:c1], :unique=>false},
@@ -397,8 +503,84 @@ Sequel.migration do
   end
   
   down do
+    drop_index :t1, [:c2, :c1], :ignore_errors=>true, :unique=>true
     drop_index :t1, [:c1], :ignore_errors=>true, :name=>:i1
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :index_names => false option to not include names of indexes when dumping just indexes as a migration" do
+    @d.meta_def(:tables){|o| [:t1]}
+    @d.meta_def(:indexes) do |t|
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
+    end
+    @d.dump_indexes_migration(:index_names=>false).should == <<-END_MIG
+Sequel.migration do
+  up do
+    add_index :t1, [:c1], :ignore_errors=>true
+    add_index :t1, [:c2, :c1], :ignore_errors=>true, :unique=>true
+  end
+  
+  down do
     drop_index :t1, [:c2, :c1], :ignore_errors=>true, :unique=>true
+    drop_index :t1, [:c1], :ignore_errors=>true
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :index_names => :namespace option be a noop if there is a global index namespace" do
+    @d.meta_def(:tables){|o| [:t1, :t2]}
+    @d.meta_def(:indexes) do |t|
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
+    end
+    @d.dump_indexes_migration(:index_names=>:namespace).should == <<-END_MIG
+Sequel.migration do
+  up do
+    add_index :t1, [:c1], :ignore_errors=>true, :name=>:i1
+    add_index :t1, [:c2, :c1], :ignore_errors=>true
+    
+    add_index :t2, [:c1], :ignore_errors=>true, :name=>:i1
+    add_index :t2, [:c2, :c1], :ignore_errors=>true, :name=>:t1_c2_c1_index
+  end
+  
+  down do
+    drop_index :t2, [:c2, :c1], :ignore_errors=>true, :name=>:t1_c2_c1_index
+    drop_index :t2, [:c1], :ignore_errors=>true, :name=>:i1
+    
+    drop_index :t1, [:c2, :c1], :ignore_errors=>true
+    drop_index :t1, [:c1], :ignore_errors=>true, :name=>:i1
+  end
+end
+END_MIG
+  end
+
+  it "should honor the :index_names => :namespace option to include names of indexes with prepended table name when dumping just indexes as a migration if there is no global index namespace" do
+    @d.meta_def(:global_index_namespace?){false}
+    @d.meta_def(:tables){|o| [:t1, :t2]}
+    @d.meta_def(:indexes) do |t|
+      {:i1=>{:columns=>[:c1], :unique=>false},
+       :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
+    end
+    @d.dump_indexes_migration(:index_names=>:namespace).should == <<-END_MIG
+Sequel.migration do
+  up do
+    add_index :t1, [:c1], :ignore_errors=>true, :name=>:t1_i1
+    add_index :t1, [:c2, :c1], :ignore_errors=>true
+    
+    add_index :t2, [:c1], :ignore_errors=>true, :name=>:t2_i1
+    add_index :t2, [:c2, :c1], :ignore_errors=>true, :name=>:t2_t1_c2_c1_index
+  end
+  
+  down do
+    drop_index :t2, [:c2, :c1], :ignore_errors=>true, :name=>:t2_t1_c2_c1_index
+    drop_index :t2, [:c1], :ignore_errors=>true, :name=>:t2_i1
+    
+    drop_index :t1, [:c2, :c1], :ignore_errors=>true
+    drop_index :t1, [:c1], :ignore_errors=>true, :name=>:t1_i1
   end
 end
 END_MIG
@@ -508,7 +690,9 @@ END_MIG
       ["double precision", "timestamp with time zone", "timestamp without time zone",
        "time with time zone", "time without time zone", "character varying(20)"] +
       %w"nvarchar ntext smalldatetime smallmoney binary varbinary nchar" +
-      ["timestamp(6) without time zone", "timestamp(6) with time zone", "int(12) unsigned", 'bigint unsigned', 'tinyint(3) unsigned', 'identity', 'int identity']
+      ["timestamp(6) without time zone", "timestamp(6) with time zone", 'mediumint(10) unsigned', 'int(9) unsigned',
+       'int(10) unsigned', "int(12) unsigned", 'bigint unsigned', 'tinyint(3) unsigned', 'identity', 'int identity'] +
+      %w"integer(10)"
     @d.meta_def(:schema) do |t, *o|
       i = 0
       types.map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
@@ -579,10 +763,14 @@ create_table(:x) do
   DateTime :c62, :size=>6
   DateTime :c63, :size=>6
   Integer :c64
-  Bignum :c65
-  Integer :c66
-  Integer :c67
-  Integer :c68
+  Integer :c65
+  Bignum :c66
+  Bignum :c67
+  Bignum :c68
+  Integer :c69
+  Integer :c70
+  Integer :c71
+  Integer :c72
 end
 END_MIG
   end

data/spec/extensions/serialization_spec.rb

@@ -72,6 +72,10 @@ describe "Serialization plugin" do
     MODEL_DB.sqls.should == ["INSERT INTO items (abc) VALUES ('olleh')"]
   end
   
+  it "should raise an error if specificing serializer as an unregistered symbol" do
+    proc{@c.plugin :serialization, :foo, :abc}.should raise_error(Sequel::Error)
+  end
+  
   it "should translate values to and from yaml serialization format using accessor methods" do
     @c.set_primary_key :id
     @c.plugin :serialization, :yaml, :abc, :def

data/spec/extensions/spec_helper.rb

@@ -8,7 +8,15 @@ unless Sequel.const_defined?('Model')
   require 'sequel/model'
 end
 
-Sequel.extension(*%w'string_date_time inflector pagination query pretty_table blank migration schema_dumper looser_typecasting sql_expr thread_local_timezones to_dot columns_introspection server_block arbitrary_servers pg_auto_parameterize pg_statement_cache pg_hstore pg_hstore_ops schema_caching null_dataset select_remove query_literals')
+begin
+  # Attempt to load ActiveSupport inflector first, so Sequel inflector
+  # can override it.
+  require 'active_support/inflector'
+  require 'active_support/string/inflections'
+rescue LoadError
+end
+
+Sequel.extension(*%w'string_date_time inflector pagination query pretty_table blank migration schema_dumper looser_typecasting sql_expr thread_local_timezones to_dot columns_introspection server_block arbitrary_servers pg_auto_parameterize pg_statement_cache pg_hstore pg_hstore_ops pg_inet schema_caching null_dataset select_remove query_literals')
 {:hook_class_methods=>[], :schema=>[], :validation_class_methods=>[]}.each{|p, opts| Sequel::Model.plugin(p, *opts)}
 
 Sequel::Dataset.introspect_all_columns if ENV['SEQUEL_COLUMNS_INTROSPECTION']

data/spec/extensions/tactical_eager_loading_spec.rb

@@ -52,4 +52,12 @@ describe "Sequel::Plugins::TacticalEagerLoading" do
     @ds.should_not_receive(:eager_load)
     ts.map{|x| x.parent}.should == [ts[2], ts[3], nil, nil]
   end
+
+  it "should handle case where an association is valid on an instance, but not on all instances" do
+    c = Class.new(@c)
+    c.many_to_one :parent2, :class=>@c, :key=>:parent_id
+    @c.dataset.row_proc = proc{|r| (r[:parent_id] == 101 ? c : @c).call(r)}
+    @c.all{|x| x.parent2 if x.is_a?(c)}
+  end
+
 end

data/spec/integration/database_test.rb

@@ -24,7 +24,11 @@ describe Sequel::Database do
     begin
       INTEGRATION_DB << "SELECT"
     rescue Sequel::DatabaseError=>e
-      e.wrapped_exception.should be_a_kind_of(Exception)
+      if defined?(Java::JavaLang::Exception)
+        (e.wrapped_exception.is_a?(Exception) || e.wrapped_exception.is_a?(Java::JavaLang::Exception)).should be_true
+      else
+        e.wrapped_exception.should be_a_kind_of(Exception)
+      end
     end
   end
 

data/spec/integration/prepared_statement_test.rb

@@ -17,6 +17,7 @@ describe "Prepared Statements and Bound Arguments" do
   end
   
   specify "should support bound variables when selecting" do
+    @ds.filter(:numb=>:$n).call(:each, :n=>10){|h| h.should == {:id=>1, :numb=>10}}
     @ds.filter(:numb=>:$n).call(:select, :n=>10).should == [{:id=>1, :numb=>10}]
     @ds.filter(:numb=>:$n).call(:all, :n=>10).should == [{:id=>1, :numb=>10}]
     @ds.filter(:numb=>:$n).call(:first, :n=>10).should == {:id=>1, :numb=>10}
@@ -25,7 +26,9 @@ describe "Prepared Statements and Bound Arguments" do
     @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
+  specify "should support blocks for each, select, all, and map when using bound variables" do
+    a = []
+    @ds.filter(:numb=>:$n).call(:each, :n=>10){|r| r[:numb] *= 2; a << r}; a.should == [{:id=>1, :numb=>20}]
     @ds.filter(:numb=>:$n).call(:select, :n=>10){|r| r[:numb] *= 2}.should == [{:id=>1, :numb=>20}]
     @ds.filter(:numb=>:$n).call(:all, :n=>10){|r| r[:numb] *= 2}.should == [{:id=>1, :numb=>20}]
     @ds.filter(:numb=>:$n).call([:map], :n=>10){|r| r[:numb] * 2}.should == [20]
@@ -125,6 +128,8 @@ describe "Prepared Statements and Bound Arguments" do
   end
   
   specify "should support prepared statements when selecting" do
+    @ds.filter(:numb=>:$n).prepare(:each, :select_n)
+    @db.call(:select_n, :n=>10){|h| h.should == {:id=>1, :numb=>10}}
     @ds.filter(:numb=>:$n).prepare(:select, :select_n)
     @db.call(:select_n, :n=>10).should == [{:id=>1, :numb=>10}]
     @ds.filter(:numb=>:$n).prepare(:all, :select_n)
@@ -137,7 +142,20 @@ describe "Prepared Statements and Bound Arguments" do
     @db.call(:select_n, :n=>10).should == {1=>10}
   end
 
-  specify "should support prepared statements being call multiple times with different arguments" do
+  specify "should support blocks for each, select, all, and map when using prepared statements" do
+    a = []
+    @ds.filter(:numb=>:$n).prepare(:each, :select_n).call(:n=>10){|r| r[:numb] *= 2; a << r}; a.should == [{:id=>1, :numb=>20}]
+    a = []
+    @db.call(:select_n, :n=>10){|r| r[:numb] *= 2; a << r}; a.should == [{:id=>1, :numb=>20}]
+    @ds.filter(:numb=>:$n).prepare(:select, :select_n).call(:n=>10){|r| r[:numb] *= 2}.should == [{:id=>1, :numb=>20}]
+    @db.call(:select_n, :n=>10){|r| r[:numb] *= 2}.should == [{:id=>1, :numb=>20}]
+    @ds.filter(:numb=>:$n).prepare(:all, :select_n).call(:n=>10){|r| r[:numb] *= 2}.should == [{:id=>1, :numb=>20}]
+    @db.call(:select_n, :n=>10){|r| r[:numb] *= 2}.should == [{:id=>1, :numb=>20}]
+    @ds.filter(:numb=>:$n).prepare([:map], :select_n).call(:n=>10){|r| r[:numb] *= 2}.should == [20]
+    @db.call(:select_n, :n=>10){|r| r[:numb] *= 2}.should == [20]
+  end
+    
+  specify "should support prepared statements being called multiple times with different arguments" do
     @ds.filter(:numb=>:$n).prepare(:select, :select_n)
     @db.call(:select_n, :n=>10).should == [{:id=>1, :numb=>10}]
     @db.call(:select_n, :n=>0).should == []

data/spec/model/associations_spec.rb

@@ -457,6 +457,20 @@ describe Sequel::Model, "many_to_one" do
     MODEL_DB.sqls.should == []
   end
 
+  it "should have the setter not modify the reciprocal if set to same value as current" do
+    @c2.many_to_one :parent, :class => @c2
+    @c2.one_to_many :children, :class => @c2, :key=>:parent_id
+
+    c1 = @c2.load(:id => 1, :parent_id=>nil)
+    c2 = @c2.load(:id => 2, :parent_id=>1)
+    c3 = @c2.load(:id => 3, :parent_id=>1)
+    c1.associations[:children] = [c2, c3]
+    c2.associations[:parent] = c1
+    c2.parent = c1
+    c1.children.should == [c2, c3]
+    MODEL_DB.sqls.should == []
+  end
+
   it "should get all matching records and only return the first if :key option is set to nil" do
     @c2.one_to_many :children, :class => @c2, :key=>:parent_id
     @c2.many_to_one :first_grand_parent, :class => @c2, :key=>nil, :eager_graph=>:children, :dataset=>proc{model.filter(:children_id=>parent_id)}
@@ -959,6 +973,19 @@ describe Sequel::Model, "one_to_one" do
     f.child.should == nil
   end
 
+  it "should have the setter not modify the reciprocal if set to same value as current" do
+    @c2.one_to_one :parent, :class => @c2, :key=>:parent_id
+    @c2.many_to_one :child, :class => @c2, :key=>:parent_id
+
+    c1 = @c2.load(:id => 1, :parent_id=>nil)
+    c2 = @c2.load(:id => 2, :parent_id=>1)
+    c1.associations[:child] = c2
+    c2.associations[:parent] = c1
+    c2.parent = c1
+    c1.child.should == c2
+    MODEL_DB.sqls.should == []
+  end
+
   it "should not add associations methods directly to class" do
     @c2.one_to_one :parent, :class => @c2
     @c2.instance_methods.collect{|x| x.to_s}.should(include('parent'))

data/spec/model/base_spec.rb

@@ -9,6 +9,12 @@ describe "Model attribute setters" do
     MODEL_DB.reset
   end
 
+  specify "refresh should return self" do
+    @o = @c[1]
+    @o.stub(:_refresh).and_return([])
+    @o.refresh.should == @o
+  end
+
   it "should mark the column value as changed" do
     @o.changed_columns.should == []
 
@@ -349,6 +355,54 @@ describe "Model.qualified_primary_key_hash" do
   end
 end
 
+describe "Model.db" do
+  before do
+    @db = Sequel.mock
+    @databases = Sequel::DATABASES.dup
+    @model_db = Sequel::Model.db
+    Sequel::Model.db = nil
+    Sequel::DATABASES.clear
+  end
+  after do
+    Sequel::Model.instance_variable_get(:@db).should == nil
+    Sequel::DATABASES.replace(@databases)
+    Sequel::Model.db = @model_db
+  end
+
+  specify "should be required when create named model classes" do
+    begin
+      proc{class ModelTest < Sequel::Model; end}.should raise_error(Sequel::Error)
+    ensure
+      Object.send(:remove_const, :ModelTest)
+    end
+  end
+
+  specify "should be required when creating anonymous model classes without a database" do
+    proc{Sequel::Model(:foo)}.should raise_error(Sequel::Error)
+  end
+
+  specify "should not be required when creating anonymous model classes with a database" do
+    Sequel::Model(@db).db.should == @db
+    Sequel::Model(@db[:foo]).db.should == @db
+  end
+
+  specify "should work correctly when subclassing anonymous model classes with a database" do
+    begin
+      Class.new(Sequel::Model(@db)).db.should == @db
+      Class.new(Sequel::Model(@db[:foo])).db.should == @db
+      class ModelTest < Sequel::Model(@db)
+        db.should == @db
+      end
+      class ModelTest2 < Sequel::Model(@db[:foo])
+        db.should == @db
+      end
+    ensure
+      Object.send(:remove_const, :ModelTest)
+      Object.send(:remove_const, :ModelTest2)
+    end
+  end
+end
+
 describe "Model.db=" do
   before do
     @db1 = Sequel.mock