sequel 4.48.0 → 4.49.0

data/lib/sequel/extensions/date_arithmetic.rb

@@ -67,6 +67,7 @@ module Sequel
         ACCESS_DURATION_UNITS = DURATION_UNITS.zip(%w'yyyy m d h n s'.map(&:freeze)).freeze
         DB2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s).freeze}).freeze
         FDBSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s.chop).freeze}).freeze
+        Sequel::Deprecation.deprecate_constant(self, :FDBSQL_DURATION_UNITS)
 
         # Append the SQL fragment for the DateAdd expression to the SQL query.
         def date_add_sql_append(sql, da)

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -43,6 +43,8 @@ module Sequel
       clone(:on_duplicate_columns=>handler||block)
     end
 
+    private
+
     # Override the attr_writer to check for duplicate columns, and call
     # handle_duplicate_columns if necessary.
     def columns=(cols)
@@ -52,8 +54,6 @@ module Sequel
       super
     end
 
-    private
-
     # Invoke the appropriate behavior when duplicate columns are present.
     def handle_duplicate_columns(cols)
       message = "#{caller(*CALLER_ARGS).first}: One or more duplicate columns present in #{cols.inspect}"

data/lib/sequel/extensions/migration.rb

@@ -352,8 +352,11 @@ module Sequel
   # Part of the +migration+ extension.
   class Migrator
     MIGRATION_FILE_PATTERN = /\A(\d+)_.+\.rb\z/i.freeze
+
     MIGRATION_SPLITTER = '_'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :MIGRATION_SPLITTER)
     MINIMUM_TIMESTAMP = 20000101
+    Sequel::Deprecation.deprecate_constant(self, :MINIMUM_TIMESTAMP)
 
     # Exception class raised when there is an error with the migrator's
     # file structure, database, or arguments.
@@ -408,7 +411,7 @@ module Sequel
       if self.equal?(Migrator)
         Dir.new(directory).each do |file|
           next unless MIGRATION_FILE_PATTERN.match(file)
-          return TimestampMigrator if file.split(MIGRATION_SPLITTER, 2).first.to_i > MINIMUM_TIMESTAMP
+          return TimestampMigrator if file.split('_', 2).first.to_i > 20000101
         end
         IntegerMigrator
       else
@@ -497,7 +500,7 @@ module Sequel
 
     # Return the integer migration version based on the filename.
     def migration_version_from_file(filename)
-      filename.split(MIGRATION_SPLITTER, 2).first.to_i
+      filename.split('_', 2).first.to_i
     end
   end
 

data/lib/sequel/extensions/null_dataset.rb

@@ -46,6 +46,7 @@ module Sequel
 
       # Nullify the current dataset
       def nullify!
+        Sequel::Deprecation.deprecate("Dataset#nullify! from the null_dataset extension", "Use Dataset#nullify, which returned a modified copy")
         extend NullDataset
       end
     end

data/lib/sequel/model/associations.rb

@@ -327,6 +327,7 @@ module Sequel
 
         # Alias of predicate_key, only for backwards compatibility.
         def eager_loading_predicate_key
+          Sequel::Deprecation.deprecate("AssociationReflection#eager_loading_predicate_key", "Use #predicate_key instead")
           predicate_key
         end
 
@@ -1803,6 +1804,7 @@ module Sequel
 
           opts[:eager_block] = opts[:block] unless opts.include?(:eager_block)
           if !opts.has_key?(:predicate_key) && opts.has_key?(:eager_loading_predicate_key)
+            Sequel::Deprecation.deprecate("The :eager_loading_predicate_key association option", "Use the :predicate_key option instead")
             opts[:predicate_key] = opts[:eager_loading_predicate_key]
           end
           opts[:graph_join_type] ||= :left_outer
@@ -2555,6 +2557,7 @@ module Sequel
             end
 
             if res == false and stop_on_false
+              Sequel::Deprecation.deprecate("Having #{callback_type} association callback return false to cancel modification", "Instead, call Model#cancel_action inside the association callback")
               raise(HookFailed, "Unable to modify association for #{inspect}: one of the #{callback_type} hooks returned false")
             end
           end

data/lib/sequel/model/base.rb

@@ -26,9 +26,8 @@ module Sequel
       # (default: not set, so all columns not otherwise restricted are allowed).
       attr_reader :allowed_columns # SEQUEL5: Deprecate after release
 
-      # Whether to cache the anonymous models created by Sequel::Model().  This is
-      # required for reloading them correctly (avoiding the superclass mismatch).  True
-      # by default for backwards compatibility.
+      # Whether to cache the anonymous models created by Sequel::Model(), true by default.  This is
+      # required for reloading them correctly (avoiding the superclass mismatch).
       attr_accessor :cache_anonymous_models
 
       # Array of modules that extend this model's dataset.  Stored
@@ -716,7 +715,7 @@ module Sequel
         pluralize(underscore(demodulize(name))).to_sym
       end
   
-      # Calls #call with the values hash.  Only for backwards compatibility.
+      # Calls #call with the values hash.
       def load(values)
         call(values)
       end
@@ -992,7 +991,7 @@ module Sequel
       end
   
       # Add model methods that call dataset methods
-      Plugins.def_dataset_methods(self, (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS + [:each_server, :where_all, :where_each, :where_single_value]) - [:<<, :and, :or, :[], :columns, :columns!, :delete, :update, :add_graph_aliases])
+      Plugins.def_dataset_methods(self, (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS + [:each_server]) - [:<<, :and, :or, :[], :columns, :columns!, :delete, :update, :add_graph_aliases])
       # SEQUEL5: add :set_graph_aliases to remove list and remove :and
   
       private
@@ -1249,6 +1248,7 @@ module Sequel
           rescue LoadError => e
             begin
               require "sequel_#{plugin}"
+              Sequel::Deprecation.deprecate("requiring 'sequel_#{plugin}' to load a plugin", "Update the #{plugin} plugin to be required via 'sequel/plugins/#{plugin}'")
             rescue LoadError => e2
               e.message << "; #{e2.message}"
               raise e
@@ -2684,52 +2684,6 @@ module Sequel
         as_hash(*a)
       end
 
-      # Return an array of all rows matching the given filter condition, also
-      # yielding each row to the given block.  Basically the same as where(cond).all(&block),
-      # except it can be optimized to not create an intermediate dataset.
-      #
-      #   Artist.where_all(:id=>[1,2,3])
-      #   # SELECT * FROM artists WHERE (id IN (1, 2, 3))
-      def where_all(cond, &block)
-        if loader = _model_where_loader
-          loader.all(filter_expr(cond), &block)
-        else
-          where(cond).all(&block)
-        end
-      end
-
-      # Iterate over all rows matching the given filter condition, 
-      # yielding each row to the given block.  Basically the same as where(cond).each(&block),
-      # except it can be optimized to not create an intermediate dataset.
-      #
-      #   Artist.where_each(:id=>[1,2,3]){|row| p row}
-      #   # SELECT * FROM artists WHERE (id IN (1, 2, 3))
-      def where_each(cond, &block)
-        if loader = _model_where_loader
-          loader.each(filter_expr(cond), &block)
-        else
-          where(cond).each(&block)
-        end
-      end
-
-      # Filter the datasets using the given filter condition, then return a single value.
-      # This assumes that the dataset has already been setup to limit the selection to
-      # a single column.  Basically the same as where(cond).single_value,
-      # except it can be optimized to not create an intermediate dataset.
-      #
-      #   Artist.select(:name).where_single_value(:id=>1)
-      #   # SELECT name FROM artists WHERE (id = 1) LIMIT 1
-      def where_single_value(cond)
-        if loader = cached_placeholder_literalizer(:_model_where_single_value_loader) do |pl|
-            single_value_ds.where(pl.arg)
-          end
-
-          loader.get(filter_expr(cond))
-        else
-          where(cond).single_value
-        end
-      end
-
       # Given a primary key value, return the first record in the dataset with that primary key
       # value.  If no records matches, returns nil.
       #
@@ -2756,11 +2710,12 @@ module Sequel
 
       private
 
-      # Loader used for where_all and where_each.
+      # SEQUEL5: Remove
       def _model_where_loader
-        cached_placeholder_literalizer(:_model_where_loader) do |pl|
-          where(pl.arg)
-        end
+        # :nocov:
+        Sequel::Deprecation.deprecate("Dataset#_model_where_loader", "Use _where_loader instead")
+        _where_loader
+        # :nocov:
       end
 
       # If the dataset is not already ordered, and the model has a primary key,

data/lib/sequel/model/dataset_module.rb

@@ -3,12 +3,11 @@
 module Sequel
   class Model
     # This Module subclass is used by Model.dataset_module
-    # to add dataset methods to classes.  It adds a couple
-    # of features standard Modules, allowing you to use
-    # the same subset method you can call on Model, as well
-    # as making sure that public methods added to the module
-    # automatically have class methods created for them.
-    class DatasetModule < ::Module
+    # to add dataset methods to classes.  In addition to the
+    # methods offered by Dataset::DatasetModule, it also
+    # automatically creates class methods for public dataset
+    # methods.
+    class DatasetModule < Dataset::DatasetModule
       # Store the model related to this dataset module.
       def initialize(model)
         @model = model
@@ -19,43 +18,6 @@ module Sequel
         where(name, *args, &block)
       end
 
-      %w'where exclude exclude_having having'.map(&:to_sym).each do |meth|
-        define_method(meth) do |name, *args, &block|
-          if block || args.flatten.any?{|arg| arg.is_a?(Proc)}
-            define_method(name){send(meth, *args, &block)}
-          else
-            key = :"_#{meth}_#{name}_ds"
-            define_method(name) do
-              cached_dataset(key){send(meth, *args)}
-            end
-          end
-        end
-      end
-
-      meths = (<<-METHS).split.map(&:to_sym)
-        distinct grep group group_and_count group_append 
-        limit offset order order_append order_prepend 
-        select select_all select_append select_group server
-      METHS
-
-      # Define a method in the module
-      def self.def_dataset_caching_method(mod, meth)
-        mod.send(:define_method, meth) do |name, *args, &block|
-          if block
-            define_method(name){send(meth, *args, &block)}
-          else
-            key = :"_#{meth}_#{name}_ds"
-            define_method(name) do
-              cached_dataset(key){send(meth, *args)}
-            end
-          end
-        end
-      end
-
-      meths.each do |meth|
-        def_dataset_caching_method(self, meth)
-      end
-
       private
 
       # Add a class method to the related model that

data/lib/sequel/model/errors.rb

@@ -6,6 +6,7 @@ module Sequel
     # with a few convenience methods.
     class Errors < ::Hash
       ATTRIBUTE_JOINER = ' and '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :ATTRIBUTE_JOINER)
 
       # Adds an error for the given attribute.
       #
@@ -40,7 +41,7 @@ module Sequel
       def full_messages
         inject([]) do |m, kv| 
           att, errors = *kv
-          errors.each {|e| m << (e.is_a?(LiteralString) ? e : "#{Array(att).join(ATTRIBUTE_JOINER)} #{e}")}
+          errors.each {|e| m << (e.is_a?(LiteralString) ? e : "#{Array(att).join(' and ')} #{e}")}
           m
         end
       end

data/lib/sequel/model/inflections.rb

@@ -26,17 +26,29 @@ module Sequel
   # already have been loaded.
   module Inflections
     CAMELIZE_CONVERT_REGEXP = /(^|_)(.)/.freeze
+    Sequel::Deprecation.deprecate_constant(self, :CAMELIZE_CONVERT_REGEXP)
     CAMELIZE_MODULE_REGEXP = /\/(.?)/.freeze
+    Sequel::Deprecation.deprecate_constant(self, :CAMELIZE_MODULE_REGEXP)
     DASH = '-'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :DASH)
     DEMODULIZE_CONVERT_REGEXP = /^.*::/.freeze
+    Sequel::Deprecation.deprecate_constant(self, :DEMODULIZE_CONVERT_REGEXP)
     EMPTY_STRING= ''.freeze
+    Sequel::Deprecation.deprecate_constant(self, :EMPTY_STRING)
     SLASH = '/'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :SLASH)
     VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
+    Sequel::Deprecation.deprecate_constant(self, :VALID_CONSTANT_NAME_REGEXP)
     UNDERSCORE = '_'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :UNDERSCORE)
     UNDERSCORE_CONVERT_REGEXP1 = /([A-Z]+)([A-Z][a-z])/.freeze
+    Sequel::Deprecation.deprecate_constant(self, :UNDERSCORE_CONVERT_REGEXP1)
     UNDERSCORE_CONVERT_REGEXP2 = /([a-z\d])([A-Z])/.freeze
+    Sequel::Deprecation.deprecate_constant(self, :UNDERSCORE_CONVERT_REGEXP2)
     UNDERSCORE_CONVERT_REPLACE = '\1_\2'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :UNDERSCORE_CONVERT_REPLACE)
     UNDERSCORE_MODULE_REGEXP = /::/.freeze
+    Sequel::Deprecation.deprecate_constant(self, :UNDERSCORE_MODULE_REGEXP)
 
     @plurals, @singulars, @uncountables = [], [], []
 
@@ -113,7 +125,7 @@ module Sequel
     def camelize(s)
       s = s.to_s
       return s.camelize if s.respond_to?(:camelize)
-      s = s.gsub(CAMELIZE_MODULE_REGEXP){|x| "::#{x[-1..-1].upcase unless x == SLASH}"}.gsub(CAMELIZE_CONVERT_REGEXP){|x| x[-1..-1].upcase}
+      s = s.gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
       s
     end
   
@@ -123,7 +135,7 @@ module Sequel
     def constantize(s)
       s = s.to_s
       return s.constantize if s.respond_to?(:constantize)
-      raise(NameError, "#{s.inspect} is not a valid constant name!") unless m = VALID_CONSTANT_NAME_REGEXP.match(s)
+      raise(NameError, "#{s.inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(s)
       Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
     end
   
@@ -131,7 +143,7 @@ module Sequel
     def demodulize(s)
       s = s.to_s
       return s.demodulize if s.respond_to?(:demodulize)
-      s.gsub(DEMODULIZE_CONVERT_REGEXP, EMPTY_STRING)
+      s.gsub(/^.*::/, '')
     end
   
     # Returns the plural form of the word in the string.
@@ -157,8 +169,8 @@ module Sequel
     def underscore(s)
       s = s.to_s
       return s.underscore if s.respond_to?(:underscore)
-      s.gsub(UNDERSCORE_MODULE_REGEXP, SLASH).gsub(UNDERSCORE_CONVERT_REGEXP1, UNDERSCORE_CONVERT_REPLACE).
-        gsub(UNDERSCORE_CONVERT_REGEXP2, UNDERSCORE_CONVERT_REPLACE).tr(DASH, UNDERSCORE).downcase
+      s.gsub('::', '/').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+        gsub(/([a-z\d])([A-Z])/, '\1_\2').tr('-', '_').downcase
     end
   end
 end

data/lib/sequel/plugins/active_model.rb

@@ -18,8 +18,8 @@ module Sequel
     #   # Make the Album class active_model compliant
     #   Album.plugin :active_model
     module ActiveModel
-      # The default string to join composite primary keys with in to_param.
       DEFAULT_TO_PARAM_JOINER = '-'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :DEFAULT_TO_PARAM_JOINER)
       
       # ActiveModel compliant error class
       class Errors < Sequel::Model::Errors
@@ -119,7 +119,7 @@ module Sequel
         
         # The string to use to join composite primary key param strings.
         def to_param_joiner
-          DEFAULT_TO_PARAM_JOINER
+          '-'
         end
       end
     end

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -242,6 +242,7 @@ module Sequel
         # giving the columns to update in each backing database table.
         # For backwards compatibility.
         def cti_columns
+          Sequel::Deprecation.deprecate("#{self}.cti_columns", "Use #{self}.cti_models to get the models, cti_table_name to get the name for the model, and cti_table_columns to get the columns for the model")
           h = {}
           cti_models.each { |m| h[m.cti_table_name] = m.cti_table_columns }
           h

data/lib/sequel/plugins/composition.rb

@@ -123,9 +123,9 @@ module Sequel
               setters = setter_meths.zip(cov_methods)
               opts[:decomposer] = proc do
                 if (o = compositions[name]).nil?
-                  setter_meths.each{|sm| get_column_value(sm, nil)}
+                  setter_meths.each{|sm| set_column_value(sm, nil)}
                 else
-                  setters.each{|sm, cm| get_column_value(sm, o.send(cm))}
+                  setters.each{|sm, cm| set_column_value(sm, o.send(cm))}
                 end
               end
             end

data/lib/sequel/plugins/dataset_associations.rb

@@ -93,22 +93,34 @@ module Sequel
               where(r.qualify(r.join_table_alias, r[:left_keys])=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
             ds.where(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
           when :many_through_many, :one_through_many
-            fe, *edges = r.edges
-            edges << r.final_edge
-            if fre = r.reverse_edges.first
-              table = fre[:table]
-              left = fre[:left]
-              mds = model.join(fe[:table], Array(fe[:right]).zip(Array(fe[:left])), :implicit_qualifier=>model.table_name)
-            else
-              table = fe[:table]
-              left = edges.first[:left]
-              edges = []
+            if r.reverse_edges.empty?
               mds = r.associated_dataset
+              fe = r.edges.first
+              selection = Array(r.qualify(fe[:table], r.final_edge[:left]))
+              predicate_key = r.qualify(fe[:table], fe[:right])
+            else
+              mds = model.dataset
+              iq = model.table_name
+              edges = r.edges.map(&:dup)
+              edges << r.final_edge.dup
+              edges.each do |e|
+                alias_expr = e[:table]
+                aliaz = mds.unused_table_alias(e[:table])
+                unless aliaz == alias_expr
+                  alias_expr = Sequel.as(e[:table], aliaz)
+                end
+                e[:alias] = aliaz
+                mds = mds.join(alias_expr, Array(e[:right]).zip(Array(e[:left])), :implicit_qualifier=>iq)
+                iq = nil
+              end
+              fe, f1e, f2e = edges.values_at(0, -1, -2)
+              selection = Array(r.qualify(f2e[:alias], f1e[:left]))
+              predicate_key = r.qualify(fe[:alias], fe[:right])
             end
+
             mds = mds.
-              select(*Array(r.qualify(table, left))).
-              where(r.qualify(fe[:table], fe[:right])=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
-            edges.each{|e| mds = mds.join(e[:table], Array(e[:right]).zip(Array(e[:left])))}
+              select(*selection).
+              where(predicate_key=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
             ds.where(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
           when :pg_array_to_many
             ds.where(Sequel[r.primary_key=>sds.select{Sequel.pg_array_op(r.qualify(r[:model].table_name, r[:key])).unnest}])

data/lib/sequel/plugins/json_serializer.rb

@@ -321,7 +321,7 @@ module Sequel
             if inc.is_a?(Hash)
               inc.each do |k, v|
                 if k.is_a?(Sequel::SQL::AliasedExpression)
-                  key_name = k.aliaz.to_s
+                  key_name = k.alias.to_s
                   k = k.expression
                 else
                   key_name = k.to_s
@@ -346,7 +346,7 @@ module Sequel
             else
               Array(inc).each do |c|
                 if c.is_a?(Sequel::SQL::AliasedExpression)
-                  key_name = c.aliaz.to_s
+                  key_name = c.alias.to_s
                   c = c.expression
                 else
                   key_name = c.to_s