sequel 4.46.0 → 4.49.0

data/lib/sequel/plugins/rcte_tree.rb

@@ -12,26 +12,6 @@ module Sequel
     # level (where level 1 is children, level 2 is children and grandchildren
     # etc.) in a single query.
     #
-    # = Background
-    # 
-    # There are two types of common models for storing tree structured data
-    # in an SQL database, the adjacency list model and the nested set model.
-    # Before recursive common table expressions (or similar capabilities such
-    # as CONNECT BY for Oracle), the nested set model was the only easy way
-    # to retrieve all ancestors and descendants in a single query.  However,
-    # it has significant performance corner cases.
-    #
-    # On PostgreSQL 8.4, with a significant number of rows, the nested set
-    # model is almost 500 times slower than using a recursive common table
-    # expression with the adjacency list model to get all descendants, and
-    # almost 24,000 times slower to get all descendants to a given level.
-    #
-    # Considering that the nested set model requires more difficult management
-    # than the adjacency list model, it's almost always better to use the
-    # adjacency list model if your database supports common table expressions.
-    # See http://explainextended.com/2009/09/24/adjacency-list-vs-nested-sets-postgresql/
-    # for detailed analysis.
-    #
     # = Usage
     #
     # The rcte_tree plugin adds four associations to the model: parent, children, ancestors, and
@@ -153,7 +133,7 @@ module Sequel
           base_ds = model.where(prkey_array.zip(key_array.map{|k| get_column_value(k)}))
           recursive_ds = model.join(t, key_array.zip(prkey_array))
           if c = a[:conditions]
-            (base_ds, recursive_ds) = [base_ds, recursive_ds].collect do |ds|
+            (base_ds, recursive_ds) = [base_ds, recursive_ds].map do |ds|
               (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
@@ -201,7 +181,7 @@ module Sequel
           recursive_case = model.join(t, key_array.zip(prkey_array)).
            select(*recursive_case_columns)
           if c = r[:conditions]
-            (base_case, recursive_case) = [base_case, recursive_case].collect do |ds|
+            (base_case, recursive_case) = [base_case, recursive_case].map do |ds|
               (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
@@ -248,7 +228,7 @@ module Sequel
           base_ds = model.where(key_array.zip(prkey_array.map{|k| get_column_value(k)}))
           recursive_ds = model.join(t, prkey_array.zip(key_array))
           if c = d[:conditions]
-            (base_ds, recursive_ds) = [base_ds, recursive_ds].collect do |ds|
+            (base_ds, recursive_ds) = [base_ds, recursive_ds].map do |ds|
               (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
@@ -299,7 +279,7 @@ module Sequel
           recursive_case = model.join(t, prkey_array.zip(key_array)).
            select(*recursive_case_columns)
           if c = r[:conditions]
-            (base_case, recursive_case) = [base_case, recursive_case].collect do |ds|
+            (base_case, recursive_case) = [base_case, recursive_case].map do |ds|
               (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end

data/lib/sequel/plugins/serialization.rb

@@ -7,11 +7,11 @@ module Sequel
     # when you call an accessor.
     #
     # This plugin works by keeping the serialized value in the values, and
-    # adding a @deserialized_values hash.  The reader method for serialized columns
-    # will check the @deserialized_values for the value, return it if present,
-    # or deserialized the entry in @values and return it.  The writer method will
-    # set the @deserialized_values entry.  This plugin adds a before_save hook
-    # that serializes all @deserialized_values to @values.
+    # adding a deserialized_values hash.  The reader method for serialized columns
+    # will check the deserialized_values for the value, return it if present,
+    # or deserialized the entry in values and return it.  The writer method will
+    # set the deserialized_values entry.  This plugin adds a before_save hook
+    # that serializes all deserialized_values to values.
     #
     # You can specify the serialization format as a pair of serializer/deserializer
     # callable objects.  You can also specify the serialization format as a single
@@ -97,16 +97,9 @@ module Sequel
       end
       register_format(:marshal, lambda{|v| [Marshal.dump(v)].pack('m')},
         lambda do |v|
-          begin
-            Marshal.load(v.unpack('m')[0])
-          rescue => e
-            begin
-              # Backwards compatibility for unpacked marshal output.
-              Marshal.load(v)
-            rescue
-              raise e
-            end
-          end
+          # Handle unpacked marshalled data for backwards compat
+          v = v.unpack('m')[0] unless v[0..1] == "\x04\x08"
+          Marshal.load(v)
         end)
       register_format(:yaml, lambda(&:to_yaml), lambda{|v| YAML.load(v)})
       register_format(:json, lambda{|v| Sequel.object_to_json(v)}, lambda{|v| Sequel.parse_json(v)})
@@ -156,6 +149,7 @@ module Sequel
         # The columns that will be serialized.  This is only for
         # backwards compatibility, use serialization_map in new code.
         def serialized_columns
+          Sequel::Deprecation.deprecate("#{self}.serialized_columns in the serialization plugin", "Use #{self}.serialization_map.keys instead")
           serialization_map.keys
         end
 

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -95,7 +95,7 @@ module Sequel
                 end
               end
               km.each do |k,v|
-                h[k.to_s] = [ ] unless h.key?(k.to_s)
+                h[k.to_s] = [] unless h.key?(k.to_s)
                 h[k.to_s].push( *Array(v) )
               end
               h
@@ -111,7 +111,7 @@ module Sequel
               end
             end
             sti_model_map.each do |k,v|
-              h[v.to_s] = [ ] unless h.key?(v.to_s)
+              h[v.to_s] = [] unless h.key?(v.to_s)
               h[v.to_s] << k
             end
             h
@@ -182,7 +182,12 @@ module Sequel
         # Return an instance of the class specified by sti_key,
         # used by the row_proc.
         def sti_load(r)
-          sti_class(sti_model_map[r[sti_key]]).call(r)
+          sti_class_from_sti_key(r[sti_key]).call(r)
+        end
+
+        # Return the sti class based on one of the keys from sti_model_map.
+        def sti_class_from_sti_key(key)
+          sti_class(sti_model_map[key])
         end
 
         # Make sure that all subclasses of the parent class correctly include 

data/lib/sequel/plugins/split_values.rb

@@ -57,11 +57,12 @@ module Sequel
         # Check all entries in the values hash.  If any of the keys are not columns,
         # move the entry into the noncolumn_values hash.
         def split_noncolumn_values
-          @values.keys.each do |k|
-            unless columns.include?(k)
-              (@noncolumn_values ||= {})[k] = @values.delete(k)
-            end
-          end
+          cols = (@values.keys - columns)
+          return self if cols.empty?
+
+          nc = @noncolumn_values ||= {}
+          vals = @values
+          cols.each{|k| nc[k] = vals.delete(k)}
           self
         end
       end

data/lib/sequel/plugins/static_cache.rb

@@ -26,6 +26,7 @@ module Sequel
     # * Model.each
     # * Model.count (without an argument or block)
     # * Model.map
+    # * Model.as_hash
     # * Model.to_hash
     # * Model.to_hash_groups
     #
@@ -127,41 +128,46 @@ module Sequel
         Plugins.inherited_instance_variables(self, :@static_cache_frozen=>nil)
 
         # Use the cache instead of a query to get the results.
-        def to_hash(key_column = nil, value_column = nil)
-        if key_column.nil? && value_column.nil?
-          if @static_cache_frozen
-            return Hash[cache]
-          else
-            key_column = primary_key
+        def as_hash(key_column = nil, value_column = nil, opts = OPTS)
+          if key_column.nil? && value_column.nil?
+            if @static_cache_frozen && !opts[:hash]
+              return Hash[cache]
+            else
+              key_column = primary_key
+            end
           end
-        end
 
-        h = {}
-        if value_column
-          if value_column.is_a?(Array)
-            if key_column.is_a?(Array)
-              @all.each{|r| h[r.values.values_at(*key_column)] = r.values.values_at(*value_column)}
+          h = opts[:hash] || {}
+          if value_column
+            if value_column.is_a?(Array)
+              if key_column.is_a?(Array)
+                @all.each{|r| h[r.values.values_at(*key_column)] = r.values.values_at(*value_column)}
+              else
+                @all.each{|r| h[r[key_column]] = r.values.values_at(*value_column)}
+              end
             else
-              @all.each{|r| h[r[key_column]] = r.values.values_at(*value_column)}
+              if key_column.is_a?(Array)
+                @all.each{|r| h[r.values.values_at(*key_column)] = r[value_column]}
+              else
+                @all.each{|r| h[r[key_column]] = r[value_column]}
+              end
             end
+          elsif key_column.is_a?(Array)
+            @all.each{|r| h[r.values.values_at(*key_column)] = static_cache_object(r)}
           else
-            if key_column.is_a?(Array)
-              @all.each{|r| h[r.values.values_at(*key_column)] = r[value_column]}
-            else
-              @all.each{|r| h[r[key_column]] = r[value_column]}
-            end
+            @all.each{|r| h[r[key_column]] = static_cache_object(r)}
           end
-        elsif key_column.is_a?(Array)
-          @all.each{|r| h[r.values.values_at(*key_column)] = static_cache_object(r)}
-        else
-          @all.each{|r| h[r[key_column]] = static_cache_object(r)}
+          h
         end
-        h
+
+        # Alias of as_hash for backwards compatibility.
+        def to_hash(*a)
+          as_hash(*a)
         end
 
         # Use the cache instead of a query to get the results
-        def to_hash_groups(key_column, value_column = nil)
-          h = {}
+        def to_hash_groups(key_column, value_column = nil, opts = OPTS)
+          h = opts[:hash] || {}
           if value_column
             if value_column.is_a?(Array)
               if key_column.is_a?(Array)

data/lib/sequel/plugins/subset_conditions.rb

@@ -13,7 +13,9 @@ module Sequel
     #   Album.plugin :subset_conditions
     #
     #   # This will now create a published_conditions method
-    #   Album.subset :published, :published => true
+    #   Album.dataset_module do
+    #     subset :published, :published => true
+    #   end
     #
     #   Album.where(Album.published_conditions).sql
     #   # SELECT * FROM albums WHERE (published IS TRUE)

data/lib/sequel/plugins/table_select.rb

@@ -32,7 +32,7 @@ module Sequel
         # has no explicit selection, select table.* from that table.
         def convert_input_dataset(ds)
           ds = super
-          if !ds.opts[:select] && (from = ds.opts[:from]) && from.length == 1 && !ds.opts[:join]
+          if !ds.opts[:select] && (from = ds.opts[:from]) && from.length == 1 && !ds.opts[:join] # SEQUEL5: Only !ds.opts[:select]
             ds = ds.select_all(ds.first_source)
           end
           ds

data/lib/sequel/plugins/touch.rb

@@ -31,6 +31,7 @@ module Sequel
     module Touch
       # The default column to update when touching
       TOUCH_COLUMN_DEFAULT = :updated_at
+      Sequel::Deprecation.deprecate_constant(self, :TOUCH_COLUMN_DEFAULT)
 
       def self.apply(model, opts=OPTS)
         model.instance_variable_set(:@touched_associations, {})
@@ -46,7 +47,7 @@ module Sequel
       #                  If a hash is used, the value is used as the column to update.
       # :column :: The column to modify when touching a model instance.
       def self.configure(model, opts=OPTS)
-        model.touch_column = opts[:column] || TOUCH_COLUMN_DEFAULT if opts[:column] || !model.touch_column
+        model.touch_column = opts[:column] || :updated_at if opts[:column] || !model.touch_column
         model.touch_associations(opts[:associations]) if opts[:associations]
       end
 
@@ -136,10 +137,11 @@ module Sequel
               # Can't update all values at once, so update each instance individually.
               # Instead if doing a simple save, update via the instance's dataset,
               # to avoid going into an infinite loop in some cases.
-              send(r[:name]).each{|x| x.this.update(column=>touch_association_value)}
+              send(assoc).each{|x| x.this.update(column=>touch_association_value)}
             else
               # Update all values at once for performance reasons.
               ds.update(column=>touch_association_value)
+              associations.delete(assoc)
             end
           end
         end

data/lib/sequel/plugins/validation_class_methods.rb

@@ -1,8 +1,6 @@
 # frozen-string-literal: true
 
 module Sequel
-  extension :blank
-
   module Plugins
     # Sequel's built-in validation_class_methods plugin adds backwards compatibility
     # for the legacy class-level validation methods (e.g. validates_presence_of :column).
@@ -11,7 +9,7 @@ module Sequel
     # as it is less complex and more flexible.  However, this plugin provides reflection
     # support, since it is class-level, while the instance-level validation_helpers
     # plugin does not.
-    # 
+    #
     # Usage:
     #
     #   # Add the validation class methods to all model subclasses (called before loading subclasses)
@@ -118,7 +116,7 @@ module Sequel
           validations.each do |att, procs|
             v = case att
             when Array
-              att.collect{|a| o.get_column_value(a)}
+              att.map{|a| o.get_column_value(a)}
             else
               o.get_column_value(att)
             end
@@ -194,11 +192,12 @@ module Sequel
         # :tag :: The tag to use for this validation.
         def validates_each(*atts, &block)
           opts = extract_options!(atts)
+          blank_meth = db.method(:blank_object?).to_proc
           blk = if (i = opts[:if]) || (am = opts[:allow_missing]) || (an = opts[:allow_nil]) || (ab = opts[:allow_blank])
             proc do |o,a,v|
               next if i && !validation_if_proc(o, i)
               next if an && Array(v).all?(&:nil?)
-              next if ab && Array(v).all?(&:blank?)
+              next if ab && Array(v).all?(&blank_meth)
               next if am && Array(a).all?{|x| !o.values.has_key?(x)}
               block.call(o,a,v)
             end
@@ -317,7 +316,7 @@ module Sequel
           reflect_validation(:presence, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
-            o.errors.add(a, opts[:message]) if v.blank? && v != false
+            o.errors.add(a, opts[:message]) if db.send(:blank_object?, v) && v != false
           end
         end
         

data/lib/sequel/plugins/validation_helpers.rb

@@ -2,8 +2,8 @@
 
 module Sequel
   module Plugins
-    # The validation_helpers plugin contains instance method equivalents for most of the legacy
-    # class-level validations.  The names and APIs are different, though. Example:
+    # The validation_helpers plugin contains validate_* methods designed to be called inside Model#validate
+    # to perform validations:
     #
     #   Sequel::Model.plugin :validation_helpers
     #   class Album < Sequel::Model
@@ -19,9 +19,7 @@ module Sequel
     # atts :: Single attribute symbol or an array of attribute symbols specifying the
     #         attribute(s) to validate.
     # Options:
-    # :allow_blank :: Whether to skip the validation if the value is blank.  You should
-    #                 make sure all objects respond to blank if you use this option, which you can do by:
-    #                     Sequel.extension :blank
+    # :allow_blank :: Whether to skip the validation if the value is blank.
     # :allow_missing :: Whether to skip the validation if the attribute isn't a key in the
     #                   values hash.  This is different from allow_nil, because Sequel only sends the attributes
     #                   in the values when doing an insert or update.  If the attribute is not present, Sequel
@@ -92,6 +90,8 @@ module Sequel
         :presence=>{:message=>lambda{"is not present"}},
         :unique=>{:message=>lambda{'is already taken'}}
       }
+      DEFAULT__OPTIONS = DEFAULT_OPTIONS
+      Sequel::Deprecation.deprecate_constant(self, :DEFAULT_OPTIONS)
 
       module InstanceMethods 
         # Check that the attribute values are the given exact length.
@@ -131,7 +131,13 @@ module Sequel
         # Accepts a :nil_message option that is the error message to use when the
         # value is nil instead of being too long.
         def validates_max_length(max, atts, opts=OPTS)
-          validatable_attributes_for_type(:max_length, atts, opts){|a,v,m| v ? validation_error_message(m, max) : validation_error_message(opts[:nil_message] || DEFAULT_OPTIONS[:max_length][:nil_message]) if v.nil? || v.length > max}
+          validatable_attributes_for_type(:max_length, atts, opts) do |a,v,m|
+            if v.nil?
+              validation_error_message(opts[:nil_message] || default_validation_helpers_options(:max_length)[:nil_message])
+            elsif v.length > max
+              validation_error_message(m, max)
+            end
+          end
         end
 
         # Check that the attribute values are not shorter than the given min length.
@@ -270,7 +276,7 @@ module Sequel
         # The hash return must include a :message option that is either a
         # proc or string.
         def default_validation_helpers_options(type)
-          DEFAULT_OPTIONS[type]
+          DEFAULT__OPTIONS[type]
         end
 
         # Skip validating any attribute that matches one of the allow_* options.
@@ -284,7 +290,7 @@ module Sequel
             next if am && !values.has_key?(a)
             v = from_values ? values[a] : get_column_value(a)
             next if an && v.nil?
-            next if ab && v.respond_to?(:blank?) && v.blank?
+            next if ab && model.db.send(:blank_object?, v)
             if message = yield(a, v, m)
               errors.add(a, message)
             end

data/lib/sequel/plugins/xml_serializer.rb

@@ -158,7 +158,7 @@ module Sequel
             opts[:builder]
           else
             builder_opts = if opts[:builder_opts]
-              opts[:builder_opts]
+              Hash[opts[:builder_opts]]
             else
               {}
             end
@@ -234,10 +234,10 @@ module Sequel
           if assocs = opts[:associations]
             assocs = case assocs
             when Symbol
-              {assocs=>{}}
+              {assocs=>OPTS}
             when Array
               assocs_tmp = {}
-              assocs.each{|v| assocs_tmp[v] = {}}
+              assocs.each{|v| assocs_tmp[v] = OPTS}
               assocs_tmp
             when Hash
               assocs
@@ -347,7 +347,7 @@ module Sequel
             cols.each do |c|
               attrs = {}
               if types
-                attrs[:type] = db_schema.fetch(c, {})[:type]
+                attrs[:type] = db_schema.fetch(c, OPTS)[:type]
               end
               v = vals[c]
               if v.nil?

data/lib/sequel/sql.rb

@@ -1030,10 +1030,13 @@ module Sequel
       # The expression to alias
       attr_reader :expression
 
-      # The alias to use for the expression, not +alias+ since that is
-      # a keyword in ruby.
-      attr_reader :aliaz
-      alias_method :alias, :aliaz
+      # The alias to use for the expression
+      attr_reader :alias
+
+      def aliaz
+        Sequel::Deprecation.deprecate("Sequel::SQL::AliasedExpression#aliaz", "Use #alias instead")
+        self.alias
+      end
 
       # The columns aliases to use, for when the aliased expression is
       # a record or set of records (such as a dataset). 
@@ -1042,7 +1045,7 @@ module Sequel
       # Create an object with the given expression and alias.
       def initialize(expression, aliaz, columns=nil)
         @expression = expression
-        @aliaz = aliaz
+        @alias = aliaz
         @columns = columns
         freeze
       end
@@ -1150,7 +1153,7 @@ module Sequel
         when BooleanExpression
           case op = ce.op
           when :AND, :OR
-            BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.collect{|a| BooleanExpression.invert(a)})
+            BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.map{|a| BooleanExpression.invert(a)})
           else
             BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.dup)
           end
@@ -1359,7 +1362,11 @@ module Sequel
 
       # The SQL function to call
       attr_reader :name
-      alias f name
+
+      def f
+        Sequel::Deprecation.deprecate("Sequel::SQL::Function#f", "Use #name instead")
+        name
+      end
       
       # The array of arguments to pass to the function (may be blank)
       attr_reader :args
@@ -1764,7 +1771,7 @@ module Sequel
       def self.like(l, *ces)
         l, lre, lci = like_element(l)
         lci = (ces.last.is_a?(Hash) ? ces.pop : {})[:case_insensitive] ? true : lci
-        ces.collect! do |ce|
+        ces.map! do |ce|
           r, rre, rci = like_element(ce)
           BooleanExpression.new(LIKE_MAP[[lre||rre, lci||rci]], l, r)
         end
@@ -1917,7 +1924,9 @@ module Sequel
     # For a more detailed explanation, see the {Virtual Rows guide}[rdoc-ref:doc/virtual_rows.rdoc].
     class VirtualRow < BasicObject
       QUESTION_MARK = LiteralString.new('?').freeze
+      Sequel::Deprecation.deprecate_constant(self, :QUESTION_MARK)
       DOUBLE_UNDERSCORE = '__'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :DOUBLE_UNDERSCORE)
 
       include OperatorBuilders
 
@@ -1972,7 +1981,7 @@ module Sequel
             end
           elsif args.empty?
             if split = Sequel.split_symbols?
-              table, column = m.to_s.split(DOUBLE_UNDERSCORE, 2)
+              table, column = m.to_s.split('__', 2)
               if column && split == :deprecated
                 Sequel::Deprecation.deprecate("Splitting virtual row method names", "Either set Sequel.split_symbols = true, or change #{m.inspect} to #{table}[:#{column}]")
               end

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 = 46
+  MINOR = 49
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0