sequel 4.45.0 → 4.46.0

data/spec/extensions/prepared_statements_spec.rb

@@ -13,20 +13,29 @@ describe "prepared_statements plugin" do
     @db.sqls
   end
 
-  it "should correctly lookup by primary key for joined dataset" do
+  deprecated "should correctly lookup by primary key for joined dataset" do
     @c.dataset = @c.dataset.from(:people, :people2)
     @db.sqls
     @c[1].must_equal @p
     @db.sqls.must_equal ["SELECT * FROM people, people2 WHERE (people.id = 1) LIMIT 1 -- read_only"]
   end 
 
+  it "should correctly lookup by primary key for dataset using subquery" do
+    @c.dataset = @c.dataset.from(:people, :people2).from_self(:alias=>:people)
+    @db.sqls
+    @c[1].must_equal @p
+    @db.sqls.must_equal ["SELECT * FROM (SELECT * FROM people, people2) AS people WHERE (id = 1) LIMIT 1 -- read_only"]
+  end 
+
   it "should use prepared statements for pk lookups only if default is not optimized" do
     @c.send(:use_prepared_statements_for_pk_lookup?).must_equal false 
     @c.set_primary_key [:id, :name]
     @c.send(:use_prepared_statements_for_pk_lookup?).must_equal true
     @c.set_primary_key :id
+    deprecated do
     @c.dataset = @c.dataset.from(:people, :people2)
     @c.send(:use_prepared_statements_for_pk_lookup?).must_equal false
+    end
     @c.dataset = @db[:people].select(:id, :name, :i)
     @c.send(:use_prepared_statements_for_pk_lookup?).must_equal true
   end

data/spec/extensions/query_spec.rb

@@ -31,7 +31,7 @@ describe "Dataset#query" do
   
   it "should support #select" do
     q = @d.query do
-      select :a, :b___mongo
+      select :a, Sequel[:b].as(:mongo)
       from :yyy
     end
     q.class.must_equal @d.class
@@ -91,7 +91,7 @@ describe "Dataset#query" do
   unless Sequel.mock.dataset.frozen?
     deprecated "should have an appropriate mutation method" do
       @d.query! do
-        select :a, :b___mongo
+        select :a, Sequel[:b].as(:mongo)
         from :yyy
       end
       @d.sql.must_equal "SELECT a, b AS mongo FROM yyy"

data/spec/extensions/schema_dumper_spec.rb

@@ -1,9 +1,9 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
-describe "Sequel::Schema::Generator dump methods" do
+describe "Sequel::Schema::CreateTableGenerator dump methods" do
   before do
     @d = Sequel::Database.new.extension(:schema_dumper)
-    @g = Sequel::Schema::Generator
+    @g = Sequel::Schema::CreateTableGenerator
   end
 
   it "should allow the same table information to be converted to a string for evaling inside of another instance with the same result" do

data/spec/extensions/schema_spec.rb

@@ -60,12 +60,12 @@ describe Sequel::Model, "create_table and schema" do
   end
 
   it "should return the schema generator via schema" do
-    @model.schema.must_be_kind_of(Sequel::Schema::Generator)
+    @model.schema.must_be_kind_of(Sequel::Schema::CreateTableGenerator)
   end
 
   it "should use the superclasses schema if it exists" do
     @submodel = Class.new(@model)
-    @submodel.schema.must_be_kind_of(Sequel::Schema::Generator)
+    @submodel.schema.must_be_kind_of(Sequel::Schema::CreateTableGenerator)
   end
 
   it "should return nil if no schema is present" do

data/spec/extensions/set_overrides_spec.rb

@@ -2,7 +2,9 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Dataset #set_defaults" do
   before do
-    @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides).set_defaults(:x=>1)
+    deprecated do
+      @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides).set_defaults(:x=>1)
+    end
   end
 
   it "should set the default values for inserts" do
@@ -21,7 +23,7 @@ describe "Sequel::Dataset #set_defaults" do
     @ds.set_defaults(:x=>2).update_sql.must_equal "UPDATE items SET x = 2"
   end
 
-  it "should not affect String update arguments" do
+  deprecated "should not affect String update arguments" do
     @ds.update_sql('y = 2').must_equal "UPDATE items SET y = 2"
   end
 
@@ -37,7 +39,9 @@ end
 
 describe "Sequel::Dataset #set_overrides" do
   before do
-    @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides).set_overrides(:x=>1)
+    deprecated do
+      @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides).set_overrides(:x=>1)
+    end
   end
 
   it "should override the given values for inserts" do

data/spec/extensions/sql_expr_spec.rb

@@ -44,7 +44,6 @@ describe "Sequel sql_expr extension" do
 
   it "Proc#sql_expr should should treat the object as a virtual row block" do
     @ds.literal(proc{a}.sql_expr).must_equal "a"
-    @ds.literal(proc{a__b}.sql_expr).must_equal "a.b"
     @ds.literal(proc{a(b)}.sql_expr).must_equal "a(b)"
   end
 

data/spec/extensions/subset_conditions_spec.rb

@@ -7,13 +7,13 @@ describe "subset_conditions plugin" do
   end
 
   it "should provide *_conditions method return the arguments passed" do
-    @c.subset(:published, :published => true)
+    @c.dataset_module{subset(:published, :published => true)}
     @c.where(@c.published_conditions).sql.must_equal @c.published.sql
 
-    @c.subset(:active, :active)
+    @c.dataset_module{where(:active, :active)}
     @c.where(@c.active_conditions).sql.must_equal @c.active.sql
 
-    @c.subset(:active_published, Sequel.&(:active, :published => true))
+    @c.dataset_module{subset(:active_published, Sequel.&(:active, :published => true))}
     @c.where(@c.active_published_conditions).sql.must_equal @c.active_published.sql
     @c.where(Sequel.&(@c.active_conditions, @c.published_conditions)).sql.must_equal @c.active_published.sql
     @c.where(Sequel.|(@c.active_conditions, @c.published_conditions)).sql.must_equal "SELECT * FROM a WHERE (active OR (published IS TRUE))"
@@ -22,14 +22,14 @@ describe "subset_conditions plugin" do
 
   it "should work with blocks" do
     p1 = proc{{:published=>true}}
-    @c.subset(:published, &p1)
+    @c.dataset_module{subset(:published, &p1)}
     @c.where(@c.published_conditions).sql.must_equal @c.published.sql
 
     p2 = :active
-    @c.subset(:active, p2)
+    @c.dataset_module{subset(:active, p2)}
     @c.where(@c.active_conditions).sql.must_equal @c.active.sql
 
-    @c.subset(:active_published, p2, &p1)
+    @c.dataset_module{subset(:active_published, p2, &p1)}
     @c.where(@c.active_published_conditions).sql.must_equal @c.active_published.sql
     @c.where(Sequel.&(@c.active_conditions, @c.published_conditions)).sql.must_equal @c.active_published.sql
     @c.where(Sequel.|(@c.active_conditions, @c.published_conditions)).sql.must_equal "SELECT * FROM a WHERE (active OR (published IS TRUE))"

data/spec/extensions/table_select_spec.rb

@@ -17,25 +17,16 @@ describe "Sequel::Plugins::TableSelect" do
   end
 
   it "should handle qualified tables" do
-    @Album.dataset = :s__albums
-    @Album.plugin :table_select
-    @Album.dataset.sql.must_equal 'SELECT s.albums.* FROM s.albums'
-
     @Album.dataset = Sequel.qualify(:s2, :albums)
+    @Album.plugin :table_select
     @Album.dataset.sql.must_equal 'SELECT s2.albums.* FROM s2.albums'
   end
 
   it "should handle aliases" do
-    @Album.dataset = :albums___a
-    @Album.plugin :table_select
-    @Album.dataset.sql.must_equal 'SELECT a.* FROM albums AS a'
-
     @Album.dataset = Sequel.as(:albums, :b)
+    @Album.plugin :table_select
     @Album.dataset.sql.must_equal 'SELECT b.* FROM albums AS b'
 
-    @Album.dataset = :s__albums___a
-    @Album.dataset.sql.must_equal 'SELECT a.* FROM s.albums AS a'
-
     @Album.dataset = @Album.db[:albums].from_self
     @Album.dataset.sql.must_equal 'SELECT t1.* FROM (SELECT * FROM albums) AS t1'
 
@@ -43,6 +34,18 @@ describe "Sequel::Plugins::TableSelect" do
     @Album.dataset.sql.must_equal 'SELECT b.* FROM (SELECT * FROM albums) AS b'
   end
 
+  with_symbol_splitting "should handle splittable symbols" do
+    @Album.dataset = :albums___a
+    @Album.plugin :table_select
+    @Album.dataset.sql.must_equal 'SELECT a.* FROM albums AS a'
+
+    @Album.dataset = :s__albums___a
+    @Album.dataset.sql.must_equal 'SELECT a.* FROM s.albums AS a'
+
+    @Album.dataset = :s__albums
+    @Album.dataset.sql.must_equal 'SELECT s.albums.* FROM s.albums'
+  end
+
   it "should not add a table.* selection on existing dataset with explicit selection" do
     @Album.dataset = @Album.dataset.select(:name)
     @Album.plugin :table_select
@@ -52,7 +55,16 @@ describe "Sequel::Plugins::TableSelect" do
     @Album.dataset.sql.must_equal 'SELECT name, artist FROM albums'
   end
 
-  it "should not add a table.* selection on existing dataset with multiple tables" do
+  it "should add a table.* selection on existing dataset with subquery" do
+    @Album.dataset = @Album.db.from(:a1, :a2).from_self(:alias=>:foo)
+    @Album.plugin :table_select
+    @Album.dataset.sql.must_equal 'SELECT foo.* FROM (SELECT * FROM a1, a2) AS foo'
+
+    @Album.dataset = @Album.db.from(:a1).cross_join(:a2).from_self(:alias=>:foo)
+    @Album.dataset.sql.must_equal 'SELECT foo.* FROM (SELECT * FROM a1 CROSS JOIN a2) AS foo'
+  end
+
+  deprecated "should not add a table.* selection on existing dataset with multiple tables" do
     @Album.dataset = @Album.db.from(:a1, :a2)
     @Album.plugin :table_select
     @Album.dataset.sql.must_equal 'SELECT * FROM a1, a2'

data/spec/extensions/to_dot_spec.rb

@@ -80,7 +80,7 @@ END
   end
 
   it "should handle LiteralStrings" do
-    dot(@ds.filter('a')).must_equal ["1 -> 2 [label=\"where\"];", "2 [label=\"Sequel.lit(\\\"(a)\\\")\"];"]
+    dot(@ds.filter(Sequel.lit('a'))).must_equal ["1 -> 2 [label=\"where\"];", "2 [label=\"Sequel.lit(\\\"(a)\\\")\"];"]
   end
 
   it "should handle true, false, nil" do
@@ -96,7 +96,7 @@ END
   end
 
   it "should handle SQL::QualifiedIdentifiers" do
-    dot(@ds.select{a__b}).must_equal ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"QualifiedIdentifier\"];", "3 -> 4 [label=\"table\"];", "4 [label=\"\\\"a\\\"\"];", "3 -> 5 [label=\"column\"];", "5 [label=\"\\\"b\\\"\"];"]
+    dot(@ds.select{a[b]}).must_equal ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"QualifiedIdentifier\"];", "3 -> 4 [label=\"table\"];", "4 [label=\"\\\"a\\\"\"];", "3 -> 5 [label=\"column\"];", "5 [label=\"\\\"b\\\"\"];"]
   end
 
   it "should handle SQL::OrderedExpressions" do
@@ -128,11 +128,11 @@ END
   end
 
   it "should handle SQL::Function with a window" do
-    dot(@ds.select{sum{}.over(:partition=>:a)}).must_equal ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Function: sum\"];", "3 -> 4 [label=\"args\"];", "4 [label=\"Array\"];", "3 -> 5 [label=\"opts\"];", "5 [label=\"Hash\"];", "5 -> 6 [label=\"over\"];", "6 [label=\"Window\"];", "6 -> 7 [label=\"opts\"];", "7 [label=\"Hash\"];", "7 -> 8 [label=\"partition\"];", "8 [label=\":a\"];"]
+    dot(@ds.select(Sequel.function(:sum).over(:partition=>:a))).must_equal ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Function: sum\"];", "3 -> 4 [label=\"args\"];", "4 [label=\"Array\"];", "3 -> 5 [label=\"opts\"];", "5 [label=\"Hash\"];", "5 -> 6 [label=\"over\"];", "6 [label=\"Window\"];", "6 -> 7 [label=\"opts\"];", "7 [label=\"Hash\"];", "7 -> 8 [label=\"partition\"];", "8 [label=\":a\"];"]
   end
 
   it "should handle SQL::PlaceholderLiteralString" do
-    dot(@ds.where("?", true)).must_equal ["1 -> 2 [label=\"where\"];", "2 [label=\"PlaceholderLiteralString: \\\"(?)\\\"\"];", "2 -> 3 [label=\"args\"];", "3 [label=\"Array\"];", "3 -> 4 [label=\"0\"];", "4 [label=\"true\"];"]
+    dot(@ds.where(Sequel.lit("?", true))).must_equal ["1 -> 2 [label=\"where\"];", "2 [label=\"PlaceholderLiteralString: \\\"(?)\\\"\"];", "2 -> 3 [label=\"args\"];", "3 [label=\"Array\"];", "3 -> 4 [label=\"0\"];", "4 [label=\"true\"];"]
   end
 
   it "should handle JOIN ON" do

data/spec/extensions/whitelist_security_spec.rb

@@ -0,0 +1,131 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+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
+    end
+    @c.plugin :whitelist_security
+    @c.set_allowed_columns :x
+    @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
+    @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)
+    (o = @c.new).set_all(:x => 1, :y => 2, :z=>3)
+    o.values.must_equal(:x => 1, :y => 2, :z=>3)
+
+    proc{@c.new.set_only({:x => 1, :y => 2, :z=>3, :id=>4}, :x, :y)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{@c.new.set_only({:x => 1, :y => 2, :z=>3}, :x, :y)}.must_raise(Sequel::MassAssignmentRestriction)
+    (o = @c.new).set_only({:x => 1, :y => 2}, :x, :y)
+    o.values.must_equal(:x => 1, :y => 2)
+  end
+
+  it "#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
+    @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
+    @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)
+    @o1.values.must_equal(:x => 4, :y => 5)
+    @o1.set_only({:x => 9, :y => 8, :z=>6, :id=>7}, :x, :y, :id)
+    @o1.values.must_equal(:x => 9, :y => 8, :id=>7)
+  end
+
+  it "#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)
+    DB.sqls.must_equal ["INSERT INTO items (y) VALUES (1)", "SELECT * FROM items WHERE id = 10"]
+    @c.new.update_all(:z => 1)
+    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
+    @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)
+    DB.sqls.must_equal ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE id = 10"]
+  end
+end
+
+describe Sequel::Model, ".strict_param_setting" do
+  before do
+    @c = Class.new(Sequel::Model(:blahblah)) do
+      columns :x, :y, :z, :id
+    end
+    @c.plugin :whitelist_security
+    @c.set_allowed_columns :x, :y
+  end
+
+  it "should raise an error if a missing/restricted column/method is accessed" do
+    proc{@c.new(:z=>1)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{@c.create(:z=>1)}.must_raise(Sequel::MassAssignmentRestriction)
+    c = @c.new
+    proc{c.set(:z=>1)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{c.update(:z=>1)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{c.set_all(:use_after_commit_rollback => false)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{c.set_only({:x=>1}, :y)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{c.update_all(:use_after_commit_rollback=>false)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{c.update_only({:x=>1}, :y)}.must_raise(Sequel::MassAssignmentRestriction)
+  end
+end
+
+describe Sequel::Model, ".allowed_columns " do
+  before do
+    @c = Class.new(Sequel::Model(:blahblah)) do
+      columns :x, :y, :z
+    end
+    @c.plugin :whitelist_security
+    @c.strict_param_setting = false
+    @c.instance_variable_set(:@columns, [:x, :y, :z])
+    DB.reset
+  end
+  
+  it "should set the allowed columns correctly" do
+    @c.allowed_columns.must_be_nil
+    @c.set_allowed_columns :x
+    @c.allowed_columns.must_equal [:x]
+    @c.set_allowed_columns :x, :y
+    @c.allowed_columns.must_equal [:x, :y]
+  end
+
+  it "should only set allowed columns by default" do
+    @c.set_allowed_columns :x, :y
+    i = @c.new(:x => 1, :y => 2, :z => 3)
+    i.values.must_equal(:x => 1, :y => 2)
+    i.set(:x => 4, :y => 5, :z => 6)
+    i.values.must_equal(:x => 4, :y => 5)
+
+    @c.dataset = @c.dataset.with_fetch(:x => 7)
+    i = @c.new
+    i.update(:x => 7, :z => 9)
+    i.values.must_equal(:x => 7)
+    DB.sqls.must_equal ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE id = 10"]
+  end
+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.plugin :whitelist_security
+    model.set_allowed_columns [:id]
+    model.freeze
+    model.allowed_columns.frozen?.must_equal true
+  end
+end

data/spec/integration/dataset_test.rb

@@ -866,9 +866,9 @@ if DB.dataset.supports_window_functions?
     end
       
     it "should give correct results for ranking window functions with orders" do
-      @ds.select(:id){rank{}.over(:partition=>:group_id, :order=>:id).as(:rank)}.all.
+      @ds.select(:id){rank.function.over(:partition=>:group_id, :order=>:id).as(:rank)}.all.
         must_equal [{:rank=>1, :id=>1}, {:rank=>2, :id=>2}, {:rank=>3, :id=>3}, {:rank=>1, :id=>4}, {:rank=>2, :id=>5}, {:rank=>3, :id=>6}]
-      @ds.select(:id){rank{}.over(:order=>id).as(:rank)}.all.
+      @ds.select(:id){rank.function.over(:order=>id).as(:rank)}.all.
         must_equal [{:rank=>1, :id=>1}, {:rank=>2, :id=>2}, {:rank=>3, :id=>3}, {:rank=>4, :id=>4}, {:rank=>5, :id=>5}, {:rank=>6, :id=>6}]
     end
       
@@ -1568,8 +1568,10 @@ describe "Dataset string methods" do
     @db = DB
     csc = {}
     cic = {}
-    csc[:collate] = @db.dataset_class::CASE_SENSITIVE_COLLATION if defined? @db.dataset_class::CASE_SENSITIVE_COLLATION
-    cic[:collate] = @db.dataset_class::CASE_INSENSITIVE_COLLATION if defined? @db.dataset_class::CASE_INSENSITIVE_COLLATION
+    if @db.database_type == :mssql
+      csc[:collate] = 'Latin1_General_CS_AS'
+      cic[:collate] = 'Latin1_General_CI_AS'
+    end
     @db.create_table!(:a) do
       String :a, csc
       String :b, cic
@@ -1752,7 +1754,9 @@ describe "Dataset defaults and overrides" do
   before(:all) do
     @db = DB
     @db.create_table!(:a){Integer :a}
-    @ds = @db[:a].order(:a).extension(:set_overrides)
+    deprecated do
+      @ds = @db[:a].order(:a).extension(:set_overrides)
+    end
   end
   before do
     @ds.delete

data/spec/integration/model_test.rb

@@ -24,6 +24,7 @@ describe "Sequel::Model basic support" do
   
   it ".finder should create method that returns first matching item" do
     def Item.by_name(name) where(:name=>name) end
+    Item.plugin :finder
     Item.finder :by_name
     Item.first_by_name('J').must_be_nil
     Item.create(:name=>'J')
@@ -33,6 +34,7 @@ describe "Sequel::Model basic support" do
   
   it ".prepared_finder should create method that returns first matching item" do
     def Item.by_name(name) where(:name=>name) end
+    Item.plugin :finder
     Item.prepared_finder :by_name
     Item.first_by_name('J').must_be_nil
     Item.create(:name=>'J')

data/spec/integration/plugin_test.rb

@@ -26,7 +26,7 @@ describe "Class Table Inheritance Plugin" do
   before do
     [:staff, :executives, :managers, :employees].each{|t| @db[t].delete}
     class ::Employee < Sequel::Model(@db)
-      plugin :class_table_inheritance, :key=>:kind, :table_map=>{:Staff=>:staff}
+      plugin :class_table_inheritance, :key=>:kind, :table_map=>{:Staff=>:staff}, :alias=>:employees
     end 
     class ::Manager < Employee
       one_to_many :staff_members, :class=>:Staff
@@ -166,7 +166,7 @@ describe "Class Table Inheritance Plugin" do
   end
   
   it "should handle eagerly graphing one_to_many relationships" do
-    es = Executive.where(:name=>'Ex').eager_graph(:staff_members).all
+    es = Executive.where(Sequel[:employees][:name]=>'Ex').eager_graph(:staff_members).all
     es.must_equal [Executive[@i4]]
     es.map{|x| x.staff_members}.must_equal [[Staff[@i2]]]
   end