sequel 4.45.0 → 4.46.0

data/spec/model/model_spec.rb

@@ -185,8 +185,10 @@ end
 describe "Sequel::Model.freeze" do
   it "should freeze the model class and not allow any changes" do
     model = Class.new(Sequel::Model(:items))
-    model.set_allowed_columns [:id]
-    model.finder(:name=>:f_by_name){|pl, ds| ds.where(:name=>pl.arg).limit(1)}
+    deprecated do
+      model.set_allowed_columns [:id]
+      model.finder(:name=>:f_by_name){|pl, ds| ds.where(:name=>pl.arg).limit(1)}
+    end
     model.freeze
     model.f_by_name(1)
 
@@ -200,7 +202,10 @@ describe "Sequel::Model.freeze" do
     model.default_set_fields_options.frozen?.must_equal true
 
     proc{model.dataset_module{}}.must_raise RuntimeError, TypeError
-    proc{model.finder(:name=>:first_by_name){|pl, ds| ds.where(:name=>pl.arg).limit(1)}}.must_raise RuntimeError, TypeError
+    deprecated do
+      model.allowed_columns.frozen?.must_equal true
+      proc{model.finder(:name=>:first_by_name){|pl, ds| ds.where(:name=>pl.arg).limit(1)}}.must_raise RuntimeError, TypeError
+    end
   end
 
   it "should freeze a model class without a dataset without breaking" do
@@ -215,7 +220,9 @@ describe "Sequel::Model.freeze" do
     model.default_set_fields_options.frozen?.must_equal true
 
     proc{model.dataset_module{}}.must_raise RuntimeError, TypeError
-    proc{model.finder(:name=>:first_by_name){|pl, ds| ds.where(:name=>pl.arg).limit(1)}}.must_raise RuntimeError, TypeError
+    deprecated do
+      proc{model.finder(:name=>:first_by_name){|pl, ds| ds.where(:name=>pl.arg).limit(1)}}.must_raise RuntimeError, TypeError
+    end
   end
 
   it "should allow subclasses of frozen model classes to work correctly" do
@@ -226,7 +233,9 @@ describe "Sequel::Model.freeze" do
 
     model.dataset_module{}
     model.plugin Module.new
-    model.finder(:name=>:first_by_name){|pl, ds| ds.where(:name=>pl.arg).limit(1)}
+    deprecated do
+      model.finder(:name=>:first_by_name){|pl, ds| ds.where(:name=>pl.arg).limit(1)}
+    end
     model.first_by_name('a').values.must_equal(:id=>1, :x=>1)
     model.dataset.frozen?.must_equal false
 
@@ -304,37 +313,13 @@ describe Sequel::Model do
     @model.dataset.sql.must_equal 'SELECT * FROM foo'
   end
 
-  it "allows set_dataset to accept a Symbol" do
-    @model.db = DB
-    @model.set_dataset(:foo)
-    @model.table_name.must_equal :foo
-  end
-
-  it "allows set_dataset to accept a LiteralString" do
-    @model.db = DB
-    @model.set_dataset(Sequel.lit('foo'))
-    @model.table_name.must_equal Sequel.lit('foo')
-  end
-
-  it "allows set_dataset to acceptan SQL::Identifier" do
-    @model.db = DB
-    @model.set_dataset(Sequel.identifier(:foo))
-    @model.table_name.must_equal Sequel.identifier(:foo)
-  end
-
-  it "allows set_dataset to acceptan SQL::QualifiedIdentifier" do
-    @model.db = DB
-    @model.set_dataset(Sequel.qualify(:bar, :foo))
-    @model.table_name.must_equal Sequel.qualify(:bar, :foo)
-  end
-
-  it "allows set_dataset to acceptan SQL::AliasedExpression" do
-    @model.db = DB
-    @model.set_dataset(Sequel.as(:foo, :bar))
-    @model.table_name.must_equal :bar
-  end
 
   it "table_name should respect table aliases" do
+    @model.set_dataset(Sequel[:foo].as(:x))
+    @model.table_name.must_equal :x
+  end
+  
+  with_symbol_splitting "table_name should respect table alias symbols" do
     @model.set_dataset(:foo___x)
     @model.table_name.must_equal :x
   end
@@ -365,12 +350,12 @@ describe Sequel::Model do
 
   it "should raise an error on set_dataset if there is an error connecting to the database" do
     def @model.columns() raise Sequel::DatabaseConnectionError end
-    proc{@model.set_dataset(Sequel::Database.new[:foo].join(:blah))}.must_raise Sequel::DatabaseConnectionError
+    proc{@model.set_dataset(Sequel::Database.new[:foo].join(:blah).from_self)}.must_raise Sequel::DatabaseConnectionError
   end
 
   it "should not raise an error if there is a problem getting the columns for a dataset" do
     def @model.columns() raise Sequel::Error end
-    @model.set_dataset(DB[:foo].join(:blah))
+    @model.set_dataset(DB[:foo].join(:blah).from_self)
   end
 
   it "doesn't raise an error on set_dataset if there is an error raised getting the schema" do
@@ -388,7 +373,7 @@ describe Sequel::Model do
   it "doesn't raise an error on inherited if there is an error setting the dataset" do
     db = Sequel.mock
     def db.schema(*) raise Sequel::Error; end
-    @model.db = db
+    @model.dataset = db[:foo]
     Class.new(@model)
   end
 
@@ -421,6 +406,38 @@ describe Sequel::Model do
   end
 end
 
+describe Sequel::Model do
+  before do
+    @model = Class.new(Sequel::Model)
+    DB.reset
+  end
+
+  it "allows set_dataset to accept a Symbol" do
+    @model.set_dataset(:foo)
+    @model.table_name.must_equal :foo
+  end
+
+  it "allows set_dataset to accept a LiteralString" do
+    @model.set_dataset(Sequel.lit('foo'))
+    @model.table_name.must_equal Sequel.lit('foo')
+  end
+
+  it "allows set_dataset to acceptan SQL::Identifier" do
+    @model.set_dataset(Sequel.identifier(:foo))
+    @model.table_name.must_equal Sequel.identifier(:foo)
+  end
+
+  it "allows set_dataset to acceptan SQL::QualifiedIdentifier" do
+    @model.set_dataset(Sequel.qualify(:bar, :foo))
+    @model.table_name.must_equal Sequel.qualify(:bar, :foo)
+  end
+
+  it "allows set_dataset to acceptan SQL::AliasedExpression" do
+    @model.set_dataset(Sequel.as(:foo, :bar))
+    @model.table_name.must_equal :bar
+  end
+end
+
 describe Sequel::Model, ".require_valid_table = true" do
   before do
     @db = Sequel.mock
@@ -556,7 +573,7 @@ describe Sequel::Model, ".subset" do
     DB.reset
   end
 
-  it "should create a filter on the underlying dataset" do
+  deprecated "should create a filter on the underlying dataset" do
     proc {@c.new_only}.must_raise(NoMethodError)
     
     @c.subset(:new_only){age < 'new'}
@@ -573,7 +590,7 @@ describe Sequel::Model, ".subset" do
     @c.new_only.pricey.sql.must_equal "SELECT * FROM items WHERE ((age < 'new') AND (price > 100))"
   end
 
-  it "should not override existing model methods" do
+  deprecated "should not override existing model methods" do
     def @c.active() true end
     @c.subset(:active, :active)
     @c.active.must_equal true
@@ -604,6 +621,17 @@ describe Sequel::Model, ".find" do
   end
 end
 
+describe Sequel::Model, ".first_where" do
+  deprecated "should take a condition and do a lookup" do
+    db = Sequel.mock(:fetch=>[])
+    c = Class.new(Sequel::Model(db[:items]))
+    db.sqls
+    c.first_where(:a)
+    db.sqls.must_equal ['SELECT * FROM items WHERE a LIMIT 1']
+    proc{c.first_where(1)}.must_raise Sequel::Error
+  end
+end
+
 describe Sequel::Model, ".finder" do
   before do
     @h = {:id=>1}
@@ -618,14 +646,14 @@ describe Sequel::Model, ".finder" do
     @db.sqls
   end
 
-  it "should create a method that calls the method given and returns the first instance" do
+  deprecated "should create a method that calls the method given and returns the first instance" do
     @c.finder :foo
     @c.first_foo(1, 2).must_equal @o
     @c.first_foo(3, 4).must_equal @o
     @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
   end
 
-  it "should work correctly when subclassing" do
+  deprecated "should work correctly when subclassing" do
     @c.finder(:foo)
     @sc = Class.new(@c)
     @sc.set_dataset :foos
@@ -635,7 +663,7 @@ describe Sequel::Model, ".finder" do
     @db.sqls.must_equal ["SELECT * FROM foos WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM foos WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
   end
 
-  it "should work correctly when dataset is modified" do
+  deprecated "should work correctly when dataset is modified" do
     @c.finder(:foo)
     @c.first_foo(1, 2).must_equal @o
     @c.set_dataset :foos
@@ -643,21 +671,21 @@ describe Sequel::Model, ".finder" do
     @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM foos LIMIT 1", "SELECT * FROM foos WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
   end
 
-  it "should create a method based on the given block if no method symbol provided" do
+  deprecated "should create a method based on the given block if no method symbol provided" do
     @c.finder(:name=>:first_foo){|pl, ds| ds.where(pl.arg).limit(1)}
     @c.first_foo(:id=>1).must_equal @o
     @db.sqls.must_equal ["SELECT * FROM items WHERE (id = 1) LIMIT 1"]
   end
 
-  it "should raise an error if both a block and method symbol given" do
+  deprecated "should raise an error if both a block and method symbol given" do
     proc{@c.finder(:foo, :name=>:first_foo){|pl, ds| ds.where(pl.arg)}}.must_raise(Sequel::Error)
   end
 
-  it "should raise an error if two option hashes are provided" do
+  deprecated "should raise an error if two option hashes are provided" do
     proc{@c.finder({:name2=>:foo}, :name=>:first_foo){|pl, ds| ds.where(pl.arg)}}.must_raise(Sequel::Error)
   end
 
-  it "should support :type option" do
+  deprecated "should support :type option" do
     @c.finder :foo, :type=>:all
     @c.finder :foo, :type=>:each
     @c.finder :foo, :type=>:get
@@ -675,14 +703,14 @@ describe Sequel::Model, ".finder" do
     @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4", "SELECT * FROM items WHERE (bar = 5) ORDER BY 6 LIMIT 1"]
   end
 
-  it "should support :name option" do
+  deprecated "should support :name option" do
     @c.finder :foo, :name=>:find_foo
     @c.find_foo(1, 2).must_equal @o
     @c.find_foo(3, 4).must_equal @o
     @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
   end
 
-  it "should support :arity option" do
+  deprecated "should support :arity option" do
     def @c.foobar(*b)
       ds = dataset
       b.each_with_index do |a, i|
@@ -697,7 +725,7 @@ describe Sequel::Model, ".finder" do
     @db.sqls.must_equal ["SELECT * FROM items WHERE (0 = a) LIMIT 1", "SELECT * FROM items WHERE ((0 = a) AND (1 = b)) LIMIT 1"]
   end
 
-  it "should support :mod option" do
+  deprecated "should support :mod option" do
     m = Module.new
     @c.finder :foo, :mod=>m
     proc{@c.first_foo}.must_raise NoMethodError
@@ -707,7 +735,7 @@ describe Sequel::Model, ".finder" do
     @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
   end
 
-  it "should raise error when calling with the wrong arity" do
+  deprecated "should raise error when calling with the wrong arity" do
     @c.finder :foo
     proc{@c.first_foo(1)}.must_raise Sequel::Error
     proc{@c.first_foo(1,2,3)}.must_raise Sequel::Error
@@ -735,14 +763,14 @@ describe Sequel::Model, ".prepared_finder" do
     @db.sqls
   end
 
-  it "should create a method that calls the method given and returns the first instance" do
+  deprecated "should create a method that calls the method given and returns the first instance" do
     @c.prepared_finder :foo
     @c.first_foo(1, 2).must_equal @o
     @c.first_foo(3, 4).must_equal @o
     @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1 -- prepared", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1 -- prepared"]
   end
 
-  it "should work correctly when subclassing" do
+  deprecated "should work correctly when subclassing" do
     @c.prepared_finder(:foo)
     @sc = Class.new(@c)
     @sc.set_dataset :foos
@@ -752,7 +780,7 @@ describe Sequel::Model, ".prepared_finder" do
     @db.sqls.must_equal ["SELECT * FROM foos WHERE (bar = 1) ORDER BY 2 LIMIT 1 -- prepared", "SELECT * FROM foos WHERE (bar = 3) ORDER BY 4 LIMIT 1 -- prepared"]
   end
 
-  it "should work correctly when dataset is modified" do
+  deprecated "should work correctly when dataset is modified" do
     @c.prepared_finder(:foo)
     @c.first_foo(1, 2).must_equal @o
     @c.set_dataset :foos
@@ -760,21 +788,21 @@ describe Sequel::Model, ".prepared_finder" do
     @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1 -- prepared", "SELECT * FROM foos LIMIT 1", "SELECT * FROM foos WHERE (bar = 3) ORDER BY 4 LIMIT 1 -- prepared"]
   end
 
-  it "should create a method based on the given block if no method symbol provided" do
+  deprecated "should create a method based on the given block if no method symbol provided" do
     @c.prepared_finder(:name=>:first_foo){|a1| where(:id=>a1).limit(1)}
     @c.first_foo(1).must_equal @o
     @db.sqls.must_equal ["SELECT * FROM items WHERE (id = 1) LIMIT 1 -- prepared"]
   end
 
-  it "should raise an error if both a block and method symbol given" do
+  deprecated "should raise an error if both a block and method symbol given" do
     proc{@c.prepared_finder(:foo, :name=>:first_foo){|pl, ds| ds.where(pl.arg)}}.must_raise(Sequel::Error)
   end
 
-  it "should raise an error if two option hashes are provided" do
+  deprecated "should raise an error if two option hashes are provided" do
     proc{@c.prepared_finder({:name2=>:foo}, :name=>:first_foo){|pl, ds| ds.where(pl.arg)}}.must_raise(Sequel::Error)
   end
 
-  it "should support :type option" do
+  deprecated "should support :type option" do
     @c.prepared_finder :foo, :type=>:all
     @c.prepared_finder :foo, :type=>:each
 
@@ -789,14 +817,14 @@ describe Sequel::Model, ".prepared_finder" do
     @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 -- prepared", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 -- prepared"]
   end
 
-  it "should support :name option" do
+  deprecated "should support :name option" do
     @c.prepared_finder :foo, :name=>:find_foo
     @c.find_foo(1, 2).must_equal @o
     @c.find_foo(3, 4).must_equal @o
     @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1 -- prepared", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1 -- prepared"]
   end
 
-  it "should support :arity option" do
+  deprecated "should support :arity option" do
     def @c.foobar(*b)
       ds = dataset
       b.each_with_index do |a, i|
@@ -811,7 +839,7 @@ describe Sequel::Model, ".prepared_finder" do
     @db.sqls.must_equal ["SELECT * FROM items WHERE (0 = a) LIMIT 1 -- prepared", "SELECT * FROM items WHERE ((0 = a) AND (1 = b)) LIMIT 1 -- prepared"]
   end
 
-  it "should support :mod option" do
+  deprecated "should support :mod option" do
     m = Module.new
     @c.prepared_finder :foo, :mod=>m
     proc{@c.first_foo}.must_raise NoMethodError
@@ -821,7 +849,7 @@ describe Sequel::Model, ".prepared_finder" do
     @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1 -- prepared", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1 -- prepared"]
   end
 
-  it "should handle models with names" do
+  deprecated "should handle models with names" do
     def @c.name; 'foobar' end
     @c.prepared_finder :foo
     @c.first_foo(1, 2).must_equal @o
@@ -1010,12 +1038,18 @@ describe Sequel::Model, ".[]" do
     DB.sqls.must_equal ["SELECT * FROM items WHERE name = 'sharon'"]
   end
 
-  it "should use a qualified primary key if the dataset is joined" do
+  deprecated "should use a qualified primary key if the dataset is joined" do
     @c.dataset = @c.dataset.cross_join(:a)
     @c[1].must_equal @c.load(:name => 'sharon', :id => 1)
     DB.sqls.must_equal ["SELECT * FROM items CROSS JOIN a WHERE (items.id = 1) LIMIT 1"]
   end
 
+  it "should handle a dataset that uses a subquery" do
+    @c.dataset = @c.dataset.cross_join(:a).from_self(:alias=>:b)
+    @c[1].must_equal @c.load(:name => 'sharon', :id => 1)
+    DB.sqls.must_equal ["SELECT * FROM (SELECT * FROM items CROSS JOIN a) AS b WHERE (id = 1) LIMIT 1"]
+  end
+
   it "should work correctly for composite primary key specified as array" do
     @c.set_primary_key [:node_id, :kind]
     @c[3921, 201].must_be_kind_of(@c)
@@ -1084,7 +1118,7 @@ describe "Model.db_schema" do
     def @db.schema(table, opts={})
       raise Sequel::Error
     end
-    @c.dataset = @dataset.join(:x, :id).columns(:id, :x)
+    @c.dataset = @dataset.join(:x, :id).from_self.columns(:id, :x)
     @c.db_schema.must_equal(:x=>{}, :id=>{})
   end
   

data/spec/model/record_spec.rb

@@ -849,12 +849,18 @@ describe Sequel::Model, "#this" do
     instance.this.sql.must_equal "SELECT * FROM examples WHERE (a = 3) LIMIT 1"
   end
 
-  it "should use a qualified primary key if the dataset is joined" do
+  deprecated "should use a qualified primary key if the dataset is joined" do
     @example.dataset = @example.dataset.cross_join(:a)
     instance = @example.load(:id => 3)
     instance.this.sql.must_equal "SELECT * FROM examples CROSS JOIN a WHERE (examples.id = 3) LIMIT 1"
   end
 
+  it "should use a primary key if the dataset uses a subquery" do
+    @example.dataset = @example.dataset.cross_join(:a).from_self(:alias=>:b)
+    instance = @example.load(:id => 3)
+    instance.this.sql.must_equal "SELECT * FROM (SELECT * FROM examples CROSS JOIN a) AS b WHERE (id = 3) LIMIT 1"
+  end
+
   it "should support composite primary keys" do
     @example.set_primary_key [:x, :y]
     instance = @example.load(:x => 4, :y => 5)
@@ -1038,7 +1044,7 @@ describe Sequel::Model, "#set" do
 
   it "should raise error if strict_param_setting is true and column is restricted" do
     @o1.strict_param_setting = true
-    @c.set_allowed_columns
+    @c.setter_methods.delete("x=")
     proc{@o1.set('x' => 1)}.must_raise(Sequel::MassAssignmentRestriction)
   end
 
@@ -1277,17 +1283,19 @@ end
 
 describe Sequel::Model, "#(set|update)_(all|only)" do
   before do
-    @c = Class.new(Sequel::Model(:items)) do
-      set_primary_key :id
-      columns :x, :y, :z, :id
-      set_allowed_columns :x
+    deprecated do
+      @c = Class.new(Sequel::Model(:items)) do
+        set_primary_key :id
+        columns :x, :y, :z, :id
+        set_allowed_columns :x
+      end
     end
     @c.strict_param_setting = false
     @o1 = @c.new
     DB.reset
   end
 
-  it "should raise errors if not all hash fields can be set and strict_param_setting is true" do
+  deprecated "should raise errors if not all hash fields can be set and strict_param_setting is true" do
     @c.strict_param_setting = true
 
     proc{@c.new.set_all(:x => 1, :y => 2, :z=>3, :use_after_commit_rollback => false)}.must_raise(Sequel::MassAssignmentRestriction)
@@ -1300,19 +1308,19 @@ describe Sequel::Model, "#(set|update)_(all|only)" do
     o.values.must_equal(:x => 1, :y => 2)
   end
 
-  it "#set_all should set all attributes including the primary key" do
+  deprecated "#set_all should set all attributes including the primary key" do
     @o1.set_all(:x => 1, :y => 2, :z=>3, :id=>4)
     @o1.values.must_equal(:id =>4, :x => 1, :y => 2, :z=>3)
   end
 
-  it "#set_all should set not set restricted fields" do
+  deprecated "#set_all should set not set restricted fields" do
     @o1.use_after_commit_rollback.must_be_nil
     @o1.set_all(:x => 1, :use_after_commit_rollback => true)
     @o1.use_after_commit_rollback.must_be_nil
     @o1.values.must_equal(:x => 1)
   end
 
-  it "#set_only should only set given attributes" do
+  deprecated "#set_only should only set given attributes" do
     @o1.set_only({:x => 1, :y => 2, :z=>3, :id=>4}, [:x, :y])
     @o1.values.must_equal(:x => 1, :y => 2)
     @o1.set_only({:x => 4, :y => 5, :z=>6, :id=>7}, :x, :y)
@@ -1321,7 +1329,7 @@ describe Sequel::Model, "#(set|update)_(all|only)" do
     @o1.values.must_equal(:x => 9, :y => 8, :id=>7)
   end
 
-  it "#update_all should update all attributes" do
+  deprecated "#update_all should update all attributes" do
     @c.new.update_all(:x => 1)
     DB.sqls.must_equal ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE id = 10"]
     @c.new.update_all(:y => 1)
@@ -1330,7 +1338,7 @@ describe Sequel::Model, "#(set|update)_(all|only)" do
     DB.sqls.must_equal ["INSERT INTO items (z) VALUES (1)", "SELECT * FROM items WHERE id = 10"]
   end
 
-  it "#update_only should only update given attributes" do
+  deprecated "#update_only should only update given attributes" do
     @o1.update_only({:x => 1, :y => 2, :z=>3, :id=>4}, [:x])
     DB.sqls.must_equal ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE id = 10"]
     @c.new.update_only({:x => 1, :y => 2, :z=>3, :id=>4}, :x)
@@ -1459,7 +1467,7 @@ describe Sequel::Model, "#each" do
     @m = @model.load(:a => 1, :b => 2, :id => 4444)
   end
   
-  it "should iterate over the values" do
+  deprecated "should iterate over the values" do
     h = {}
     @m.each{|k, v| h[k] = v}
     h.must_equal(:a => 1, :b => 2, :id => 4444)