sequel 4.44.0 → 4.45.0

data/lib/sequel/plugins/prepared_statements_associations.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+Sequel::Deprecation.deprecate("The prepared_statements_associations plugin", "Stop using the plugin, it is probably unneeded and making the application slower")
+
 module Sequel
   module Plugins
     # The prepared_statements_associations plugin modifies the regular association

data/lib/sequel/plugins/prepared_statements_with_pk.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+Sequel::Deprecation.deprecate("The prepared_statements_with_pk plugin", "Stop using the plugin, it is probably unneeded and making the application slower")
+
 module Sequel
   module Plugins
     # The prepared_statements_with_pk plugin allows Dataset#with_pk for model datasets

data/lib/sequel/plugins/schema.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+Sequel::Deprecation.deprecate("The schema plugin", "Switch to defining your schema using Database schema methods before creating your model classes")
+
 module Sequel
   module Plugins
     # Sequel's built in schema plugin allows you to define your schema

data/lib/sequel/plugins/scissors.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+Sequel::Deprecation.deprecate("The scissors plugin", "Running with scissors is dangerous")
+
 module Sequel
   module Plugins
     # The scissors plugin adds class methods for update, delete, and destroy.

data/lib/sequel/plugins/serialization.rb

@@ -120,9 +120,14 @@ module Sequel
         # called to serialize the column.
         attr_reader :serialization_map
 
-        # Module to store the serialized column accessor methods, so they can
-        # call be overridden and call super to get the serialization behavior
-        attr_accessor :serialization_module
+        def serialization_module
+          Sequel::Deprecation.deprecate('Sequel::Model.serialization_module', 'There is no replacement')
+          @serialization_module
+        end
+        def serialization_module=(v)
+          Sequel::Deprecation.deprecate('Sequel::Model.serialization_module=', 'There is no replacement')
+          @serialization_module = v
+        end
 
         Plugins.inherited_instance_variables(self, :@deserialization_map=>:dup, :@serialization_map=>:dup)
 
@@ -159,8 +164,8 @@ module Sequel
         # Add serializated attribute acessor methods to the serialization_module
         def define_serialized_attribute_accessor(serializer, deserializer, *columns)
           m = self
-          include(self.serialization_module ||= Module.new) unless serialization_module
-          serialization_module.class_eval do
+          include(@serialization_module ||= Module.new) unless @serialization_module
+          @serialization_module.class_eval do
             columns.each do |column|
               m.serialization_map[column] = serializer
               m.deserialization_map[column] = deserializer

data/lib/sequel/plugins/split_values.rb

@@ -47,7 +47,11 @@ module Sequel
         # If there isn't an entry in the values hash, but there is a noncolumn_values
         # hash, look in that hash for the value.
         def [](k)
-          super || (@noncolumn_values[k] if !@values.has_key?(k) && @noncolumn_values)
+          if  (res = super).nil?
+            @noncolumn_values[k] if !@values.has_key?(k) && @noncolumn_values
+          else
+            res
+          end
         end
 
         # Check all entries in the values hash.  If any of the keys are not columns,

data/lib/sequel/plugins/static_cache.rb

@@ -225,13 +225,13 @@ module Sequel
       module InstanceMethods
         # Disallowing destroying the object unless the :frozen=>false option was used.
         def before_destroy
-          return false unless model.static_cache_allow_modifications?
+          cancel_action("modifying model objects that use the static_cache plugin is not allowed") unless model.static_cache_allow_modifications?
           super
         end
 
         # Disallowing saving the object unless the :frozen=>false option was used.
         def before_save
-          return false unless model.static_cache_allow_modifications?
+          cancel_action("modifying model objects that use the static_cache plugin is not allowed") unless model.static_cache_allow_modifications?
           super
         end
       end

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -91,7 +91,7 @@ module Sequel
         # If there the association is not in the associations cache and the object
         # was reteived via Dataset#all, eagerly load the association for all model
         # objects retrieved with the current object.
-        def load_associated_objects(opts, dynamic_opts=nil, &block)
+        def load_associated_objects(opts, dynamic_opts=OPTS, &block)
           dynamic_opts = load_association_objects_options(dynamic_opts, &block)
           name = opts[:name]
           if (!associations.include?(name) || dynamic_opts[:eager_reload]) && retrieved_by && !frozen? && !dynamic_opts[:callback] && !dynamic_opts[:reload]

data/lib/sequel/plugins/validation_contexts.rb

@@ -0,0 +1,49 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The validation_contexts plugin adds support for a validation_context method inside a validate
+    # method.  You pass in the validation context to use via the :validation_context option to
+    # Sequel::Model#save && Sequel::Model#valid?:
+    #
+    #   class Album < Sequel::Model
+    #     plugin :validation_contexts
+    #     def validate
+    #       super
+    #       errors.add(:status_id, 'not 1') if status_id != 1 && validation_context == :initial
+    #       errors.add(:status_id, 'not 2') if status_id != 2 && validation_context == :approve
+    #     end
+    #   end
+    #
+    #   Album.new(:status_id=>1).valid?(:validation_context=>:initial) # => true
+    #   Album.new(:status_id=>2).valid?(:validation_context=>:initial) # => false
+    #
+    #   Album.new(:status_id=>1).valid?(:validation_context=>:approve) # => false
+    #   Album.new(:status_id=>2).valid?(:validation_context=>:approve) # => true
+    #
+    # There is no validation context used by default, so validation_context will be
+    # +nil+ if one is not specified.  If you want to differentiate between creating new
+    # objects and updating existing objects, just use +new?+.
+    #
+    # Once this plugin is loaded into a model, after you freeze an instance
+    # of that model, you can no longer specify a validation context when
+    # validating the instance.
+    module ValidationContexts
+      module InstanceMethods 
+        # The validation context to use for the current validation.
+        # Set via the :validation_context option passed to save/valid?.
+        attr_reader :validation_context
+
+        private
+
+        # Set validation context before running validations
+        def _valid?(opts)
+          @validation_context = opts[:validation_context] if opts[:validation_context]
+          super
+        ensure
+          @validation_context = nil if @validation_context
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/validation_helpers.rb

@@ -244,6 +244,7 @@ module Sequel
           atts.each do |a|
             arr = Array(a)
             next if arr.any?{|x| errors.on(x)}
+            # SEQUEL5: Default only_if_modified to true
             next if opts[:only_if_modified] && !new? && !arr.any?{|x| changed_columns.include?(x)}
             ds = opts[:dataset] || model.dataset
             ds = if where

data/lib/sequel/sql.rb

@@ -428,7 +428,7 @@ module Sequel
       #   Sequel.deep_qualify(:table, Sequel.+(:column, 1)) # "table"."column" + 1
       #   Sequel.deep_qualify(:table, Sequel.like(:a, 'b')) # "table"."a" LIKE 'b' ESCAPE '\'
       def deep_qualify(qualifier, expr)
-        Sequel::Qualifier.new(Sequel, qualifier).transform(expr)
+        Sequel::Qualifier.new(qualifier).transform(expr)
       end
 
       # Return a delayed evaluation that uses the passed block. This is used

data/lib/sequel/version.rb

@@ -5,7 +5,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 44
+  MINOR = 45
   # 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

@@ -264,6 +264,37 @@ describe "Offset support" do
   end
 end
 
+describe "Update/Delete on limited datasets" do
+  before do
+    @db = DB
+    @db.create_table!(:i){Integer :id}
+    @ds = @db[:i]
+    @ds.import [:id], [[1], [2]]
+  end
+  after do
+    @db.drop_table?(:i)
+  end
+  
+  it "should handle deletes and updates on limited datasets" do
+    @ds.limit(1).update(:id=>Sequel[:id]+10)
+    [[2, 11], [1, 12]].must_include @ds.select_order_map(:id)
+    @ds.limit(1).delete
+    [[1], [2]].must_include @ds.select_order_map(:id)
+  end
+  
+  it "should raise error for updates on ordered, limited datasets" do
+  end
+
+  it "should raise error for updates and deletes on datasets with offsets or limits with orders" do
+    proc{@ds.offset(1).delete}.must_raise Sequel::InvalidOperation
+    proc{@ds.offset(1).update(:id=>Sequel[:id]+10)}.must_raise Sequel::InvalidOperation
+    proc{@ds.limit(1, 1).delete}.must_raise Sequel::InvalidOperation
+    proc{@ds.limit(1, 1).update(:id=>Sequel[:id]+10)}.must_raise Sequel::InvalidOperation
+    proc{@ds.order(:id).limit(1).update(:id=>Sequel[:id]+10)}.must_raise Sequel::InvalidOperation
+    proc{@ds.order(:id).limit(1).delete}.must_raise Sequel::InvalidOperation
+  end if false # SEQUEL5 
+end if DB.dataset.send(:is_2012_or_later?)
+
 describe "Common Table Expressions" do
   before do
     @db = DB

data/spec/adapters/mysql_spec.rb

@@ -202,10 +202,23 @@ describe "A MySQL dataset" do
     @d.order(:name).update_sql(:value => 1).must_equal 'UPDATE `items` SET `value` = 1 ORDER BY `name`'
   end
 
-  it "should support LIMIT clause in UPDATE statements" do
-    @d.limit(10).update_sql(:value => 1).must_equal 'UPDATE `items` SET `value` = 1 LIMIT 10'
+  it "should support updating a limited dataset" do
+    @d.import [:value], [[2], [3]]
+    @d.limit(1).update(:value => 4).must_equal 1
+    [[2,4], [3,4]].must_include @d.select_order_map(:value)
   end
 
+  it "should support updating a ordered, limited dataset" do
+    @d.import [:value], [[2], [3]]
+    @d.order(:value).limit(1).update(:value => 4).must_equal 1
+    @d.select_order_map(:value).must_equal [3,4]
+  end
+
+  it "should raise error for updating a dataset with an offset" do
+    proc{@d.offset(1).update(:value => 4)}.must_raise Sequel::InvalidOperation
+    proc{@d.order(:value).offset(1).update(:value => 4)}.must_raise Sequel::InvalidOperation
+  end if false # SEQUEL5
+
   it "should support regexps" do
     @d << {:name => 'abc', :value => 1}
     @d << {:name => 'bcd', :value => 2}
@@ -338,6 +351,11 @@ describe "A MySQL database" do
   it "should handle the creation and dropping of an InnoDB table with foreign keys" do
     DB.create_table!(:test_innodb, :engine=>:InnoDB){primary_key :id; foreign_key :fk, :test_innodb, :key=>:id}
   end
+
+  it "should handle qualified tables in #indexes" do
+    DB.create_table!(:test_innodb){primary_key :id; String :name; index :name, :unique=>true, :name=>:test_innodb_name_idx}
+    DB.indexes(Sequel.qualify(DB.get{database{}}, :test_innodb)).must_equal(:test_innodb_name_idx=>{:unique=>true, :columns=>[:name]})
+  end
 end
 
 describe "A MySQL database" do

data/spec/adapters/postgres_spec.rb

@@ -1041,11 +1041,11 @@ describe "A PostgreSQL database" do
   end
 
   it "should support indexes with index type" do
-    @db.create_table(:posts){varchar :title, :size => 5; index :title, :type => 'hash'}
+    @db.create_table(:posts){point :p; index :p, :type => 'gist'}
     check_sqls do
       @db.sqls.must_equal [
-        'CREATE TABLE "posts" ("title" varchar(5))',
-        'CREATE INDEX "posts_title_index" ON "posts" USING hash ("title")'
+        'CREATE TABLE "posts" ("p" point)',
+        'CREATE INDEX "posts_p_index" ON "posts" USING gist ("p")'
       ]
     end
   end
@@ -1739,36 +1739,33 @@ if DB.adapter_scheme == :postgres
     end
   end
 
-  describe "Postgres::PG_NAMED_TYPES" do
+  describe "Database#add_named_conversion_proc" do
     before(:all) do
       @db = DB
       @old_cp = @db.conversion_procs[1013]
       @db.conversion_procs.delete(1013)
-      Sequel::Postgres::PG_NAMED_TYPES[:oidvector] = lambda{|v| v.reverse}
-      @db.reset_conversion_procs
-      @db.register_array_type('oidvector')
+      @db.add_named_conversion_proc(:oidvector, &:reverse)
     end
     after(:all) do
-      Sequel::Postgres::PG_NAMED_TYPES.delete(:oidvector)
       @db.conversion_procs.delete(30)
       @db.conversion_procs[1013] = @old_cp
       @db.drop_table?(:foo)
-      @db.drop_enum(:foo_enum)
+      @db.drop_enum(:foo_enum) rescue nil
     end
 
-    it "should look up conversion procs by name" do
+    it "should work for scalar types" do
       @db.create_table!(:foo){oidvector :bar}
       @db[:foo].insert(Sequel.cast('21', :oidvector))
       @db[:foo].get(:bar).must_equal '12'
     end
 
-    it "should handle array types of named types" do
+    it "should work for array types" do
       @db.create_table!(:foo){column :bar, 'oidvector[]'}
       @db[:foo].insert(Sequel.pg_array(['21'], :oidvector))
       @db[:foo].get(:bar).must_equal ['12']
     end
 
-    it "should work with conversion procs on enums" do
+    it "should work with for enums" do
       @db.drop_enum(:foo_enum) rescue nil
       @db.create_enum(:foo_enum, %w(foo bar))
       @db.add_named_conversion_proc(:foo_enum){|string| string.reverse}
@@ -1777,6 +1774,40 @@ if DB.adapter_scheme == :postgres
       @db[:foo].get(:bar).must_equal 'foo'.reverse
     end
   end
+
+  describe "Postgres::PG_NAMED_TYPES" do
+    before(:all) do
+      deprecated do
+        @db = DB
+        @old_cp = @db.conversion_procs[1013]
+        @db.conversion_procs.delete(1013)
+        Sequel::Postgres::PG_NAMED_TYPES[:oidvector] = lambda{|v| v.reverse}
+        @db.reset_conversion_procs
+        @db.register_array_type('oidvector')
+      end
+    end
+    after(:all) do
+      deprecated do
+        Sequel::Postgres::PG_NAMED_TYPES.delete(:oidvector)
+        @db.conversion_procs.delete(30)
+        @db.conversion_procs[1013] = @old_cp
+        @db.drop_table?(:foo)
+        @db.drop_enum(:foo_enum) rescue nil
+      end
+    end
+
+    deprecated "should look up conversion procs by name" do
+      @db.create_table!(:foo){oidvector :bar}
+      @db[:foo].insert(Sequel.cast('21', :oidvector))
+      @db[:foo].get(:bar).must_equal '12'
+    end
+
+    deprecated "should handle array types of named types" do
+      @db.create_table!(:foo){column :bar, 'oidvector[]'}
+      @db[:foo].insert(Sequel.pg_array(['21'], :oidvector))
+      @db[:foo].get(:bar).must_equal ['12']
+    end
+  end
 end
 
 if uses_pg_or_jdbc && DB.server_version >= 90000

data/spec/adapters/spec_helper.rb

@@ -20,11 +20,8 @@ Sequel.split_symbols = false if ENV['SEQUEL_NO_SPLIT_SYMBOLS']
 Sequel::Database.extension :duplicate_column_handler if ENV['SEQUEL_DUPLICATE_COLUMN_HANDLER']
 Sequel::Database.extension :columns_introspection if ENV['SEQUEL_COLUMNS_INTROSPECTION']
 Sequel::Model.cache_associations = false if ENV['SEQUEL_NO_CACHE_ASSOCIATIONS']
-if ENV['SEQUEL_MODEL_PREPARED_STATEMENTS']
-  Sequel::Model.plugin :prepared_statements
-  Sequel::Model.plugin :prepared_statements_associations
-end
-Sequel.cache_anonymous_models = false
+Sequel::Model.plugin :prepared_statements if ENV['SEQUEL_MODEL_PREPARED_STATEMENTS']
+Sequel::Model.cache_anonymous_models = false
 
 class Sequel::Database
   def log_duration(duration, message)
@@ -48,10 +45,10 @@ IDENTIFIER_MANGLING = !ENV['SEQUEL_NO_MANGLE'] unless defined?(IDENTIFIER_MANGLI
 unless defined?(DB)
   env_var = "SEQUEL_#{SEQUEL_ADAPTER_TEST.to_s.upcase}_URL"
   env_var = ENV.has_key?(env_var) ? env_var : 'SEQUEL_INTEGRATION_URL'
-  opts = {}
-  opts[:identifier_mangling] = false unless IDENTIFIER_MANGLING
-  DB = Sequel.connect(ENV[env_var], opts)
+  # SEQUEL5: Remove :identifier_mangling=>false
+  DB = Sequel.connect(ENV[env_var], :identifier_mangling=>false)
   DB.extension(:freeze_datasets) if ENV['SEQUEL_FREEZE_DATASETS']
+  DB.extension(:identifier_mangling) if IDENTIFIER_MANGLING
 end
 
 if dch = ENV['SEQUEL_DUPLICATE_COLUMNS_HANDLER']

data/spec/core/database_spec.rb

@@ -5,11 +5,23 @@ describe "A new Database" do
     @db = Sequel::Database.new(1 => 2, :logger => 3)
   end
   after do
-    Sequel.quote_identifiers = false
-    Sequel.identifier_input_method = nil
-    Sequel.identifier_output_method = nil
+    deprecated do
+      Sequel.quote_identifiers = false
+      Sequel.identifier_input_method = nil
+      Sequel.identifier_output_method = nil
+    end
   end
   
+  deprecated "should allow dup/clone" do
+    @db.dup.must_be_kind_of @db.class
+    @db.clone.must_be_kind_of @db.class
+  end
+
+  it "should not allow dup/clone" do
+    proc{@db.dup}.must_raise Sequel::Error
+    proc{@db.clone}.must_raise Sequel::Error
+  end if false # SEQUEL5
+
   it "should receive options" do
     @db.opts[1].must_equal 2
     @db.opts[:logger].must_equal 3  
@@ -328,7 +340,7 @@ describe "Database#dataset" do
     e.sql.must_equal 'SELECT * FROM miu'
   end
   
-  it "should provide a filtered #from dataset if a block is given" do
+  deprecated "should provide a filtered #from dataset if a block is given" do
     d = @db.from(:mau){x.sql_number > 100}
     d.must_be_kind_of(Sequel::Dataset)
     d.sql.must_equal 'SELECT * FROM mau WHERE (x > 100)'
@@ -1375,7 +1387,7 @@ end
 
 describe "A single threaded database" do
   after do
-    Sequel::Database.single_threaded = false
+    Sequel.single_threaded = false
   end
   
   it "should use a SingleConnectionPool instead of a ConnectionPool" do
@@ -1388,14 +1400,17 @@ describe "A single threaded database" do
     db.pool.must_be_kind_of(Sequel::SingleConnectionPool)
   end
   
-  it "should be constructable using Database.single_threaded = true" do
+  deprecated "should be constructable using Database.single_threaded = true" do
     Sequel::Database.single_threaded = true
+    Sequel.single_threaded.must_equal true
+    Sequel::Database.single_threaded.must_equal true
     db = Sequel::Database.new{123}
     db.pool.must_be_kind_of(Sequel::SingleConnectionPool)
   end
 
   it "should be constructable using Sequel.single_threaded = true" do
     Sequel.single_threaded = true
+    Sequel.single_threaded.must_equal true
     db = Sequel::Database.new{123}
     db.pool.must_be_kind_of(Sequel::SingleConnectionPool)
   end
@@ -1440,7 +1455,7 @@ end
 
 describe "A database" do
   after do
-    Sequel::Database.single_threaded = false
+    Sequel.single_threaded = false
   end
   
   it "should have single_threaded? respond to true if in single threaded mode" do
@@ -1453,7 +1468,7 @@ describe "A database" do
     db = Sequel::Database.new
     db.wont_be :single_threaded?
     
-    Sequel::Database.single_threaded = true
+    Sequel.single_threaded = true
     
     db = Sequel::Database.new{123}
     db.must_be :single_threaded?
@@ -1719,8 +1734,28 @@ describe "Database#remove_servers" do
   end
 end
 
+describe "Database#add_servers and #remove_servers when not sharded" do
+  deprecated "should do nothing" do
+    db = Sequel.mock
+    db.opts[:servers].must_be_nil
+    db.add_servers(:foo=>{}).must_be_nil
+    db.opts[:servers].must_be_nil
+    db.remove_servers(:foo).must_be_nil
+    db.opts[:servers].must_be_nil
+  end
+
+  it "should raise Error" do
+    db = Sequel.mock
+    db.opts[:servers].must_be_nil
+    proc{db.add_servers(:foo=>{})}.must_raise Sequel::Error
+    db.opts[:servers].must_be_nil
+    proc{db.remove_servers(:foo)}.must_raise Sequel::Error
+    db.opts[:servers].must_be_nil
+  end if false # SEQUEL5
+end
+
 describe "Database#each_server with do/jdbc adapter connection string without :adapter option" do
-  it "should yield a separate database object for each server" do
+  deprecated "should yield a separate database object for each server" do
     require 'sequel/adapters/mock'
     klass = Class.new(Sequel::Database)
     def klass.adapter_class(v)
@@ -1740,7 +1775,7 @@ describe "Database#each_server with do/jdbc adapter connection string without :a
     hosts.sort.must_equal [1, 3]
   end
 
-  it "should raise if not given a block" do
+  deprecated "should raise if not given a block" do
     proc{Sequel.mock.each_server}.must_raise(Sequel::Error)
   end
 end
@@ -1750,7 +1785,7 @@ describe "Database#each_server" do
     @db = Sequel.mock(:host=>1, :database=>2, :servers=>{:server1=>{:host=>3}, :server2=>{:host=>4}})
   end
 
-  it "should yield a separate database object for each server" do
+  deprecated "should yield a separate database object for each server" do
     hosts = []
     @db.each_server do |db|
       db.must_be_kind_of(Sequel::Database)
@@ -1762,7 +1797,7 @@ describe "Database#each_server" do
     hosts.sort.must_equal [1, 3, 4]
   end
 
-  it "should disconnect and remove entry from Sequel::DATABASES after use" do
+  deprecated "should disconnect and remove entry from Sequel::DATABASES after use" do
     dbs = []
     dcs = []
     @db.each_server do |db|