sequel 4.44.0 → 4.45.0

data/lib/sequel/exceptions.rb

@@ -9,48 +9,72 @@ module Sequel
     attr_accessor :wrapped_exception
   end  
     
+  (
   # Error raised when the adapter requested doesn't exist or can't be loaded.
   AdapterNotFound = Class.new(Error)
+  ).name
 
+  (
   # Generic error raised by the database adapters, indicating a
   # problem originating from the database server.  Usually raised
   # because incorrect SQL syntax is used.
   DatabaseError = Class.new(Error)
+  ).name
   
+  (
   # Error raised when the Sequel is unable to connect to the database with the
   # connection parameters it was given.
   DatabaseConnectionError = Class.new(DatabaseError)
+  ).name
 
+  (
   # Error raised by adapters when they determine that the connection
   # to the database has been lost.  Instructs the connection pool code to 
   # remove that connection from the pool so that other connections can be acquired
   # automatically.
   DatabaseDisconnectError = Class.new(DatabaseError)
+  ).name
 
+  (
   # Generic error raised when Sequel determines a database constraint has been violated.
   ConstraintViolation = Class.new(DatabaseError)
+  ).name
 
+  (
   # Error raised when Sequel determines a database check constraint has been violated.
   CheckConstraintViolation = Class.new(ConstraintViolation)
+  ).name
 
+  (
   # Error raised when Sequel determines a database foreign key constraint has been violated.
   ForeignKeyConstraintViolation = Class.new(ConstraintViolation)
+  ).name
 
+  (
   # Error raised when Sequel determines a database NOT NULL constraint has been violated.
   NotNullConstraintViolation = Class.new(ConstraintViolation)
+  ).name
 
+  (
   # Error raised when Sequel determines a database unique constraint has been violated.
   UniqueConstraintViolation = Class.new(ConstraintViolation)
+  ).name
 
+  (
   # Error raised when Sequel determines a serialization failure/deadlock in the database.
   SerializationFailure = Class.new(DatabaseError)
+  ).name
 
+  (
   # Error raised on an invalid operation, such as trying to update or delete
   # a joined or grouped dataset.
   InvalidOperation = Class.new(Error)
+  ).name
 
+  (
   # Error raised when attempting an invalid type conversion.
   InvalidValue = Class.new(Error)
+  ).name
 
   # Error raised when the user requests a record via the first! or similar
   # method, and the dataset does not yield any rows.
@@ -69,27 +93,32 @@ module Sequel
     end
   end
 
+  (
   # Error raised when the connection pool cannot acquire a database connection
   # before the timeout.
   PoolTimeout = Class.new(Error)
+  ).name
 
+  (
   # Error that you should raise to signal a rollback of the current transaction.
   # The transaction block will catch this exception, rollback the current transaction,
   # and won't reraise it (unless a reraise is requested).
   Rollback = Class.new(Error)
+  ).name
 
-  # Error raised when unbinding a dataset that has multiple different values
-  # for a given variable.
-  UnbindDuplicate = Class.new(Error)
-
-  # Call name on each class to set the name for the class, so it gets cached.
-  constants.map{|c| const_get(c)}.each do |c|
-    Class === c && c.name
-  end
+  # SEQUEL5: Remove
+  (UnbindDuplicate = Class.new(Error)).name
 
   Error::AdapterNotFound = AdapterNotFound
   Error::InvalidOperation = InvalidOperation
   Error::InvalidValue = InvalidValue
   Error::PoolTimeoutError = PoolTimeout
   Error::Rollback = Rollback
+
+  Sequel::Deprecation.deprecate_constant(self, :UnbindDuplicate)
+  Sequel::Deprecation.deprecate_constant(Error, :AdapterNotFound)
+  Sequel::Deprecation.deprecate_constant(Error, :InvalidOperation)
+  Sequel::Deprecation.deprecate_constant(Error, :InvalidValue)
+  Sequel::Deprecation.deprecate_constant(Error, :PoolTimeoutError)
+  Sequel::Deprecation.deprecate_constant(Error, :Rollback)
 end

data/lib/sequel/extensions/_deprecated_identifier_mangling.rb

@@ -0,0 +1,117 @@
+# frozen-string-literal: true
+
+#
+module Sequel
+  module DeprecatedIdentifierMangling
+    module DatabaseMethods
+      def self.extended(db)
+        db.instance_exec do
+          @identifier_input_method = nil
+          @identifier_output_method = nil
+          @quote_identifiers = nil
+          reset_identifier_mangling
+          extend_datasets(DatasetMethods)
+        end
+      end
+
+      attr_reader :identifier_input_method
+      attr_reader :identifier_output_method
+
+      def identifier_input_method=(v)
+        Sequel::Deprecation.deprecate("Database#identifier_input_method=", "Explicitly load the identifier_mangling extension if you would like to use this")
+        reset_default_dataset
+        @identifier_input_method = v
+      end
+      
+      def identifier_output_method=(v)
+        Sequel::Deprecation.deprecate("Database#identifier_output_method=", "Explicitly load the identifier_mangling extension if you would like to use this")
+        reset_default_dataset
+        @identifier_output_method = v
+      end
+
+      def quote_identifiers=(v)
+        Sequel::Deprecation.deprecate("Database#quote_identifiers=", "Explicitly load the identifier_mangling extension if you would like to use this")
+        reset_default_dataset
+        @quote_identifiers = v
+      end
+      
+      def quote_identifiers?
+        @quote_identifiers
+      end
+
+      private
+
+      def _metadata_dataset
+        super.clone(:identifier_input_method=>identifier_input_method_default, :identifier_output_method=>identifier_output_method_default, :skip_symbol_cache=>true)
+      end
+
+      def identifier_input_method_default
+        return super if defined?(super)
+        :upcase if folds_unquoted_identifiers_to_uppercase?
+      end
+
+      def identifier_output_method_default
+        return super if defined?(super)
+        :downcase if folds_unquoted_identifiers_to_uppercase?
+      end
+
+      def reset_identifier_mangling
+        @quote_identifiers = @opts.fetch(:quote_identifiers){(qi = Database.quote_identifiers).nil? ? quote_identifiers_default : qi}
+        @identifier_input_method = @opts.fetch(:identifier_input_method){(iim = Database.identifier_input_method).nil? ? identifier_input_method_default : (iim if iim)}
+        @identifier_output_method = @opts.fetch(:identifier_output_method){(iom = Database.identifier_output_method).nil? ? identifier_output_method_default : (iom if iom)}
+        reset_default_dataset
+      end
+    end
+
+    module DatasetMethods
+      def identifier_input_method
+        @opts.fetch(:identifier_input_method, db.identifier_input_method)
+      end
+      
+      def identifier_input_method=(v)
+        Sequel::Deprecation.deprecate("Dataset#identifier_input_method=", "Explicitly load the identifier_mangling extension if you would like to use this")
+        raise_if_frozen!("identifier_input_method=")
+        skip_symbol_cache!
+        @opts[:identifier_input_method] = v
+      end
+      
+      def identifier_output_method
+        @opts.fetch(:identifier_output_method, db.identifier_output_method)
+      end
+    
+      def identifier_output_method=(v)
+        Sequel::Deprecation.deprecate("Dataset#identifier_output_method=", "Explicitly load the identifier_mangling extension if you would like to use this")
+        raise_if_frozen!("identifier_output_method=")
+        @opts[:identifier_output_method] = v
+      end
+
+      def quote_identifiers?
+        @opts.fetch(:quote_identifiers, db.quote_identifiers?)
+      end
+
+      def with_identifier_input_method(meth)
+        Sequel::Deprecation.deprecate("Dataset#with_identifier_input_method", "Explicitly load the identifier_mangling extension if you would like to use this")
+        clone(:identifier_input_method=>meth, :skip_symbol_cache=>true)
+      end
+
+      def with_identifier_output_method(meth)
+        Sequel::Deprecation.deprecate("Dataset#with_identifier_output_method", "Explicitly load the identifier_mangling extension if you would like to use this")
+        clone(:identifier_output_method=>meth)
+      end
+      
+      private
+
+      def input_identifier(v)
+        (i = identifier_input_method) ? v.to_s.send(i) : v.to_s
+      end
+
+      def output_identifier(v)
+        v = 'untitled' if v == ''
+        (i = identifier_output_method) ? v.to_s.send(i).to_sym : v.to_sym
+      end
+    end
+  end
+
+  Database.register_extension(:_deprecated_identifier_mangling, DeprecatedIdentifierMangling::DatabaseMethods)
+end
+

data/lib/sequel/extensions/date_arithmetic.rb

@@ -92,6 +92,7 @@ module Sequel
               args << "#{value} #{sql_unit}"
             end
             return function_sql_append(sql, Sequel.function(:datetime, *args))
+          # SEQUEL5: Remove cubrid
           when :mysql, :hsqldb, :cubrid
             if db_type == :hsqldb
               # HSQLDB requires 2.2.9+ for the DATE_ADD function

data/lib/sequel/extensions/identifier_mangling.rb

@@ -127,6 +127,7 @@ module Sequel
       # Reset the identifier mangling options.  Overrides any already set on
       # the instance.  Only for internal use by shared adapters.
       def reset_identifier_mangling
+        # SEQUEL5: Stop checking Database.*
         @quote_identifiers = @opts.fetch(:quote_identifiers){(qi = Database.quote_identifiers).nil? ? quote_identifiers_default : qi}
         @identifier_input_method = @opts.fetch(:identifier_input_method){(iim = Database.identifier_input_method).nil? ? identifier_input_method_default : (iim if iim)}
         @identifier_output_method = @opts.fetch(:identifier_output_method){(iom = Database.identifier_output_method).nil? ? identifier_output_method_default : (iom if iom)}
@@ -143,7 +144,7 @@ module Sequel
       
       # Set the method to call on identifiers going into the database for this dataset
       def identifier_input_method=(v)
-        raise_if_frozen!
+        raise_if_frozen!("identifier_input_method=")
         skip_symbol_cache!
         @opts[:identifier_input_method] = v
       end
@@ -156,7 +157,7 @@ module Sequel
     
       # Set the method to call on identifiers coming the database for this dataset
       def identifier_output_method=(v)
-        raise_if_frozen!
+        raise_if_frozen!("identifier_output_method=")
         @opts[:identifier_output_method] = v
       end
 

data/lib/sequel/extensions/pg_hstore.rb

@@ -141,7 +141,7 @@ module Sequel
       module DatabaseMethods
         def self.extended(db)
           db.instance_eval do
-            add_named_conversion_proc(:hstore)
+            add_named_conversion_proc(:hstore, &HStore.method(:parse))
             @schema_type_classes[:hstore] = HStore
           end
         end
@@ -306,10 +306,6 @@ module Sequel
         k.to_s.gsub(ESCAPE_RE, ESCAPE_REPLACE)
       end
     end
-
-    PG_NAMED_TYPES = {} unless defined?(PG_NAMED_TYPES)
-    # Associate the named types by default.
-    PG_NAMED_TYPES[:hstore] = HStore.method(:parse)
   end
 
   module SQL::Builders

data/lib/sequel/extensions/schema_dumper.rb

@@ -170,6 +170,8 @@ END_MIG
         [:table, :key, :on_delete, :on_update, :deferrable].each{|f| type_hash[f] = schema[f] if schema[f]}
         if type_hash == {:type=>Integer} || type_hash == {:type=>"integer"}
           type_hash.delete(:type)
+        elsif options[:same_db] && type_hash == {:type=>type_literal_generic_bignum_symbol(type_hash).to_s}
+          type_hash[:type] = :Bignum
         end
 
         unless gen.columns.empty?
@@ -243,7 +245,7 @@ END_MIG
     # Return a Schema::Generator object that will recreate the
     # table's schema.  Takes the same options as dump_schema_migration.
     def dump_table_generator(table, options=OPTS)
-      s = schema(table).dup
+      s = schema(table, options).dup
       pks = s.find_all{|x| x.last[:primary_key] == true}.map(&:first)
       options = options.merge(:single_pk=>true) if pks.length == 1
       m = method(:recreate_column)

data/lib/sequel/extensions/sequel_3_dataset_methods.rb

@@ -29,14 +29,14 @@ module Sequel
     COMMA = Dataset::COMMA
     # Change the database for this dataset.
     def db=(v)
-      raise_if_frozen!
+      raise_if_frozen!("db=")
       @db = v
       @cache = {}
     end
 
     # Change the options for this dataset.
     def opts=(v)
-      raise_if_frozen!
+      raise_if_frozen!("opts=")
       @opts = v
       @cache = {}
     end

data/lib/sequel/extensions/string_agg.rb

@@ -104,6 +104,7 @@ module Sequel
               f = f.distinct
             end
             literal_append(sql, f)
+          # SEQUEL5: Remove cubrid
           when :mysql, :hsqldb, :cubrid, :h2
             sql << "GROUP_CONCAT("
             if distinct

data/lib/sequel/model.rb

@@ -5,11 +5,13 @@ require 'sequel/core'
 module Sequel
   # Delegate to Sequel::Model, only for backwards compatibility.
   def self.cache_anonymous_models
+    Sequel::Deprecation.deprecate("Sequel.cache_anonymous_models", "Use Sequel::Model.cache_anonymous_models")
     Model.cache_anonymous_models
   end
 
   # Delegate to Sequel::Model, only for backwards compatibility.
   def self.cache_anonymous_models=(v)
+    Sequel::Deprecation.deprecate("Sequel.cache_anonymous_models=", "Use Sequel::Model.cache_anonymous_models=")
     Model.cache_anonymous_models = v
   end
 
@@ -29,13 +31,6 @@ module Sequel
   class Model
     OPTS = Sequel::OPTS
 
-    # Map that stores model classes created with <tt>Sequel::Model()</tt>, to allow the reopening
-    # of classes when dealing with code reloading.
-    ANONYMOUS_MODEL_CLASSES = @Model_cache = {}
-
-    # Mutex protecting access to ANONYMOUS_MODEL_CLASSES
-    ANONYMOUS_MODEL_CLASSES_MUTEX = @Model_mutex = Mutex.new
-
     # Class methods added to model that call the method of the same name on the dataset
     DATASET_METHODS = (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS + [:each_server, :where_all, :where_each, :where_single_value]) -
       [:and, :or, :[], :columns, :columns!, :delete, :update, :add_graph_aliases, :first, :first!]
@@ -51,8 +46,8 @@ module Sequel
 
     # Hooks that are called after an action.  When overriding these, it is recommended to call
     # +super+ on the first line of your method, so later hooks are called after earlier hooks.
-    AFTER_HOOKS = [:after_create, :after_update, :after_save, :after_destroy,
-      :after_validation, :after_commit, :after_rollback, :after_destroy_commit, :after_destroy_rollback]
+    AFTER_HOOKS = [:after_create, :after_update, :after_save, :after_destroy, :after_validation,
+    :after_commit, :after_rollback, :after_destroy_commit, :after_destroy_rollback] # SEQUEL5: Remove commit/rollback hooks
 
     # Hooks that are called around an action.  If overridden, these methods must call super
     # exactly once if the behavior they wrap is desired.  The can be used to rescue exceptions
@@ -78,7 +73,7 @@ module Sequel
       :@use_after_commit_rollback=>nil, :@fast_pk_lookup_sql=>nil,
       :@fast_instance_delete_sql=>nil, :@finders=>:dup, :@finder_loaders=>:dup,
       :@db=>nil, :@default_set_fields_options=>:dup, :@require_valid_table=>nil,
-      :@cache_anonymous_models=>nil, :@Model_mutex=>nil}
+      :@cache_anonymous_models=>nil, :@dataset_module_class=>nil}
 
     # Regular expression that determines if a method name is normal in the sense that
     # it could be used literally in ruby code without using send.  Used to
@@ -129,5 +124,23 @@ module Sequel
     RESTRICTED_SETTER_METHODS = instance_methods.map(&:to_s).grep(SETTER_METHOD_REGEXP)
 
     def_Model(::Sequel)
+
+    # SEQUEL5: Remove
+    class DeprecatedColumnsUpdated # :nodoc:
+      def initialize(columns_updated)
+        @columns_updated = columns_updated
+      end
+
+      def method_missing(*args, &block)
+        Sequel::Deprecation.deprecate("Accessing @columns_updated directly", "Use the columns_updated plugin and switch to the columns_updated method")
+        @columns_updated.send(*args, &block)
+      end
+    end
+      
+    ANONYMOUS_MODEL_CLASSES = @Model_cache # :nodoc:
+    Sequel::Deprecation.deprecate_constant(self, :ANONYMOUS_MODEL_CLASSES)
+
+    ANONYMOUS_MODEL_CLASSES_MUTEX = Mutex.new # :nodoc:
+    Sequel::Deprecation.deprecate_constant(self, :ANONYMOUS_MODEL_CLASSES_MUTEX)
   end
 end

data/lib/sequel/model/associations.rb

@@ -15,9 +15,15 @@ module Sequel
           @autoreloading_associations = {}
           @cache_associations = true
           @default_association_options = {}
+          @dataset_module_class = DatasetModule
         end
       end
 
+      # The dataset module to use for classes using the associations plugin.
+      class DatasetModule < Model::DatasetModule
+        def_dataset_caching_method(self, :eager)
+      end
+
       # AssociationReflection is a Hash subclass that keeps information on Sequel::Model associations. It
       # provides methods to reduce internal code duplication.  It should not
       # be instantiated by the user.
@@ -83,7 +89,7 @@ module Sequel
           end
           ds = ds.order(*self[:order]) if self[:order]
           ds = ds.limit(*self[:limit]) if self[:limit]
-          ds = ds.limit(1) if limit_to_single_row?
+          ds = ds.limit(1).skip_limit_check if limit_to_single_row?
           ds = ds.eager(self[:eager]) if self[:eager]
           ds = ds.distinct if self[:distinct]
           ds
@@ -426,7 +432,7 @@ module Sequel
           if use_placeholder_loader?
             cached_fetch(:placeholder_loader) do
               Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
-                ds.where(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)})
+                ds.where(Sequel.&(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)}))
               end
             end
           end
@@ -451,7 +457,7 @@ module Sequel
             when Symbol, SQL::Identifier
               SQL::QualifiedIdentifier.new(table, k)
             else
-              Sequel::Qualifier.new(self[:model].dataset, table).transform(k)
+              Sequel::Qualifier.new(table).transform(k)
             end
           end
         end
@@ -1891,7 +1897,10 @@ module Sequel
 
         # Adds the association method to the association methods module.
         def def_association_method(opts)
-          association_module_def(opts.association_method, opts){|*dynamic_opts, &block| load_associated_objects(opts, dynamic_opts[0], &block)}
+          association_module_def(opts.association_method, opts) do |*dynamic_opts, &block|
+            Sequel::Deprecation.deprecate("Passing multiple arguments to ##{opts.association_method}", "Additional arguments are currently ignored.") if dynamic_opts.length > 1
+            load_associated_objects(opts, dynamic_opts.length == 0 ? OPTS : dynamic_opts[0], &block)
+          end
         end
       
         # Define all of the association instance methods for this association.
@@ -2159,7 +2168,7 @@ module Sequel
                 cks.zip(cpks).each{|k, pk| o.set_column_value(:"#{k}=", get_column_value(pk))}
               end
               checked_transaction do
-                up_ds.update(ck_nil_hash)
+                up_ds.skip_limit_check.update(ck_nil_hash)
                 o.save(save_opts) || raise(Sequel::Error, "invalid associated object, cannot save") if o
               end
             end
@@ -2384,13 +2393,16 @@ module Sequel
         def load_association_objects_options(dynamic_opts, &block)
           dynamic_opts = case dynamic_opts
           when true, false, nil
+            Sequel::Deprecation.deprecate("Passing #{dynamic_opts.inspect} an argument to an association loading method", "Pass {:reload=>#{dynamic_opts.inspect}} instead")
             {:reload=>dynamic_opts}
           when Hash
             Hash[dynamic_opts]
           else
             if dynamic_opts.respond_to?(:call)
+              Sequel::Deprecation.deprecate("Passing callbable argument #{dynamic_opts.inspect} to an association loading method", "Pass a block to the method to use a callback")
               {:callback=>dynamic_opts}
             else
+              Sequel::Deprecation.deprecate("Passing #{dynamic_opts.inspect} an argument to an association loading method", "Pass {:reload=>true} if you would like to reload the association")
               {:reload=>true}
             end
           end