sequel 4.45.0 → 4.46.0

data/lib/sequel/model/associations.rb

@@ -141,7 +141,7 @@ module Sequel
         def apply_window_function_eager_limit_strategy(ds, limit_and_offset=limit_and_offset())
           rn = ds.row_number_column 
           limit, offset = limit_and_offset
-          ds = ds.unordered.select_append{|o| o.row_number{}.over(:partition=>predicate_key, :order=>ds.opts[:order]).as(rn)}.from_self
+          ds = ds.unordered.select_append{|o| o.row_number.function.over(:partition=>predicate_key, :order=>ds.opts[:order]).as(rn)}.from_self
           ds = if !returns_array?
             ds.where(rn => offset ? offset+1 : 1)
           elsif offset
@@ -694,14 +694,12 @@ module Sequel
           v = fetch(:filter_limit_strategy, self[:eager_limit_strategy])
           if v || self[:limit] || !returns_array?
             case v ||= self[:model].default_eager_limit_strategy
-            when :union, :ruby
+            when true, :union, :ruby
               # Can't use a union or ruby-based strategy for filtering by associations, switch to default eager graph limit
               # strategy.
               true_eager_graph_limit_strategy
             when Symbol
               v
-            when true
-              true_eager_graph_limit_strategy
             end
           end
         end
@@ -2661,10 +2659,10 @@ END
         # types, this is a simple transformation, but for +many_to_many+ associations this 
         # creates a subquery to the join table.
         def complex_expression_sql_append(sql, op, args)
-          r = args.at(1)
+          r = args[1]
           if (((op == :'=' || op == :'!=') and r.is_a?(Sequel::Model)) ||
               (multiple = ((op == :IN || op == :'NOT IN') and ((is_ds = r.is_a?(Sequel::Dataset)) or r.all?{|x| x.is_a?(Sequel::Model)}))))
-            l = args.at(0)
+            l = args[0]
             if ar = model.association_reflections[l]
               if multiple
                 klass = ar.associated_class
@@ -3235,7 +3233,7 @@ END
           @records_map = records_map
 
           datasets = opts[:graph][:table_aliases].to_a.reject{|ta,ds| ds.nil?}
-          column_aliases = opts[:graph_aliases] || opts[:graph][:column_aliases]
+          column_aliases = opts[:graph_aliases] || opts[:graph][:column_aliases] # SEQUEL5: Remove :graph_aliases support
           primary_keys = {}
           column_maps = {}
           models = {}

data/lib/sequel/model/base.rb

@@ -12,7 +12,7 @@ module Sequel
     module ClassMethods
       # Which columns should be the only columns allowed in a call to a mass assignment method (e.g. set)
       # (default: not set, so all columns not otherwise restricted are allowed).
-      attr_reader :allowed_columns
+      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
@@ -238,7 +238,7 @@ module Sequel
       #   # => #<Artist {:name=>'Bob', ...}>
       def [](*args)
         args = args.first if args.size <= 1
-        args.is_a?(Hash) ? first_where(args) : (primary_key_lookup(args) unless args.nil?)
+        args.is_a?(Hash) ? first(args) : (primary_key_lookup(args) unless args.nil?)
       end
 
       # Initializes a model instance as an existing record. This constructor is
@@ -393,7 +393,10 @@ module Sequel
       # sharding support.
       def db=(db)
         @db = db
-        set_dataset(db.dataset.clone(@dataset.opts)) if @dataset
+        if @dataset
+          Sequel::Deprecation.deprecate("Sequel::Model.db= when the model has an existing dataset", "Use Sequel::Model.dataset= instead")
+          set_dataset(db.dataset.clone(@dataset.opts))
+        end
       end
       
       # Returns the cached schema information if available or gets it
@@ -446,8 +449,10 @@ module Sequel
 
         if block
           raise(Error, "Defining a dataset method using a block requires only one argument") if args.length > 1
+          Sequel::Deprecation.deprecate("Sequel::Model.def_dataset_method", "Define the method inside a dataset_module block, or use the def_dataset_method_plugin")
           dataset_module{define_method(args.first, &block)}
         else
+          Sequel::Deprecation.deprecate("Sequel::Model.def_dataset_method", "Define a class method that calls the dataset method, or use the def_dataset_method_plugin")
           args.each{|arg| def_model_dataset_method(arg)}
         end
       end
@@ -461,12 +466,7 @@ module Sequel
       #   Artist.find{name > 'M'}
       #   # SELECT * FROM artists WHERE (name > 'M') LIMIT 1
       def find(*args, &block)
-        if args.length == 1 && !block
-          # Use optimized finder
-          first_where(args.first)
-        else
-          where(*args, &block).first
-        end
+        first(*args, &block)
       end
       
       # Like +find+ but invokes create with given conditions when record does not
@@ -484,7 +484,6 @@ module Sequel
       def find_or_create(cond, &block)
         find(cond) || create(cond, &block)
       end
-    
 
       FINDER_TYPES = [:first, :all, :each, :get].freeze
 
@@ -544,6 +543,7 @@ module Sequel
       #
       # See Dataset::PlaceholderLiteralizer for additional caveats.
       def finder(meth=OPTS, opts=OPTS, &block)
+        Sequel::Deprecation.deprecate("Sequel::Model.finder and Sequel::Model.prepared_finder", "They have been moved to the finder plugin")
         if block
           raise Error, "cannot pass both a method name argument and a block of Model.finder" unless meth.is_a?(Hash)
           raise Error, "cannot pass two option hashes to Model.finder" unless opts.equal?(OPTS)
@@ -607,29 +607,21 @@ module Sequel
         end
       end
 
-      # An alias for calling first on the model's dataset, but with
-      # optimized handling of the single argument case.
-      def first(*args, &block)
-        if args.length == 1 && !block && !args.first.is_a?(Integer)
-          # Use optimized finder
-          first_where(args.first)
+      def first_where(cond)
+        Sequel::Deprecation.deprecate("Sequel::Model.first_where", "Instead, use Sequel::Model.first")
+        if cond.is_a?(Integer)
+          dataset.where(cond).first(cond)
         else
-          dataset.first(*args, &block)
+          dataset.first(cond)
         end
       end
 
-      # An alias for calling first! on the model's dataset, but with
-      # optimized handling of the single argument case.
-      def first!(*args, &block)
-        first(*args, &block) || raise(Sequel::NoMatchingRow.new(dataset))
-      end
-
       # Freeze a model class, disallowing any further changes to it.
       def freeze
         dataset_module.freeze
         overridable_methods_module.freeze
 
-        @finder_loaders.freeze
+        @finder_loaders.freeze # SEQUEL5: Remove
 
         if @dataset
           @dataset.freeze
@@ -637,16 +629,16 @@ module Sequel
           db_schema.freeze.each_value(&:freeze)
           columns.freeze
           setter_methods.freeze
-          @finder_loaders.each_key{|k| finder_for(k)}
+          @finder_loaders.each_key{|k| finder_for(k)} # SEQUEL5: Remove
         else
           @setter_methods = [].freeze
         end
 
         @dataset_method_modules.freeze
         @default_set_fields_options.freeze
-        @finders.freeze
+        @finders.freeze # SEQUEL5: Remove
         @plugins.freeze
-        @allowed_columns.freeze if @allowed_columns
+        @allowed_columns.freeze if @allowed_columns  # SEQUEL5: Remove
 
         super
       end
@@ -802,6 +794,7 @@ module Sequel
       # exception:
       # :type :: Specifies the type of prepared statement to create
       def prepared_finder(meth=OPTS, opts=OPTS, &block)
+        # SEQUEL5: Remove
         if block
           raise Error, "cannot pass both a method name argument and a block of Model.finder" unless meth.is_a?(Hash)
           meth = meth.merge(:prepare=>true)
@@ -837,6 +830,7 @@ module Sequel
       #   Artist.set(:name=>'Bob', :hometown=>'Sactown') # No Error
       #   Artist.set(:name=>'Bob', :records_sold=>30000) # Error
       def set_allowed_columns(*cols)
+        Sequel::Deprecation.deprecate("Sequel::Model.set_allowed_columns", "Load the whitelist_security plugin into the model class")
         clear_setter_methods_cache
         @allowed_columns = cols
       end
@@ -945,15 +939,9 @@ module Sequel
       # This method creates dataset methods that do not accept arguments.  To create
       # dataset methods that accept arguments, you should use define a
       # method directly inside a #dataset_module block.
-      def subset(name, *args, &block)
-        if block || args.flatten.any?{|arg| arg.is_a?(Proc)}
-          def_dataset_method(name){filter(*args, &block)}
-        else
-          key = :"_subset_#{name}_ds"
-          def_dataset_method(name) do
-            cached_dataset(key){filter(*args)}
-          end
-        end
+      def subset(*args, &block)
+        Sequel::Deprecation.deprecate("Sequel::Model.subset", "Use the subset method inside a dataset_module block, or use the def_dataset_method plugin")
+        dataset_module{where(*args, &block)}
       end
       
       # Returns name of primary table for the dataset. If the table for the dataset
@@ -1011,6 +999,10 @@ module Sequel
           self.simple_table = db.literal(ds).freeze
           ds = db.from(ds)
         when Dataset
+          if ds.joined_dataset?
+            Sequel::Deprecation.deprecate("Using a joined dataset as a Sequel::Model dataset", respond_to?(:cti_base_model) ? "Use the class_table_inheritance plugin :alias option in #{cti_base_model.inspect}" : "Call from_self on the dataset to wrap it in a subquery")
+          end
+
           self.simple_table = if ds.send(:simple_select_all?)
             ds.literal(ds.first_source_table).freeze
           end
@@ -1072,12 +1064,14 @@ module Sequel
       # Define a finder method in the given module with the given method name that
       # load rows using the finder with the given name.
       def def_finder_method(mod, meth, type)
+        # SEQUEL5: Remove
         mod.send(:define_method, meth){|*args, &block| finder_for(meth).send(type, *args, &block)}
       end
 
       # Define a prepared_finder method in the given module that will call the associated prepared
       # statement.
       def def_prepare_method(mod, meth)
+        # SEQUEL5: Remove
         mod.send(:define_method, meth){|*args, &block| finder_for(meth).call(prepare_method_arg_hash(args), &block)}
       end
 
@@ -1085,6 +1079,7 @@ module Sequel
       # for the method, load the finder and set correctly in the finders hash, then
       # return the finder.
       def finder_for(meth)
+        # SEQUEL5: Remove
         unless finder = (frozen? ? @finders[meth] : Sequel.synchronize{@finders[meth]})
           finder_loader = @finder_loaders.fetch(meth)
           finder = finder_loader.call(self)
@@ -1143,6 +1138,7 @@ module Sequel
       # that want to modify the methods used.
       def get_setter_methods
         if allowed_columns
+          # SEQUEL5: Remove allowed_columns handling
           allowed_columns.map{|x| "#{x}="}
         else
           meths = instance_methods.collect(&:to_s).grep(SETTER_METHOD_REGEXP) - RESTRICTED_SETTER_METHODS
@@ -1223,6 +1219,7 @@ module Sequel
       # An hash of prepared argument values for the given arguments, with keys
       # starting at a.  Used by the methods created by prepared_finder.
       def prepare_method_arg_hash(args)
+        # SEQUEL5: Remove
         h = {}
         prepare_method_args('a', args.length).zip(args).each{|k, v| h[k] = v}
         h
@@ -1230,6 +1227,7 @@ module Sequel
 
       # An array of prepared statement argument names, of length n and starting with base.
       def prepare_method_args(base, n)
+        # SEQUEL5: Remove
         (0...n).map do
           s = base.to_sym
           base = base.next
@@ -1251,9 +1249,9 @@ module Sequel
           ds.fetch_rows(sql){|r| return ds.row_proc.call(r)}
           nil
         elsif dataset.joined_dataset?
-          first_where(qualified_primary_key_hash(pk))
+          dataset.first(qualified_primary_key_hash(pk))
         else
-          first_where(primary_key_hash(pk))
+          dataset.first(primary_key_hash(pk))
         end
       end
 
@@ -1276,7 +1274,7 @@ module Sequel
       # Reset the instance dataset to a modified copy of the current dataset,
       # should be used whenever the model's dataset is modified.
       def reset_instance_dataset
-        Sequel.synchronize{@finders.clear if @finders}
+        Sequel.synchronize{@finders.clear} if @finders && !@finders.frozen?
         @instance_dataset = @dataset.limit(1).naked.skip_limit_check if @dataset
       end
   
@@ -1800,6 +1798,7 @@ module Sequel
       #   artist.set_all(:name=>'Jim')
       #   artist.name # => 'Jim'
       def set_all(hash)
+        Sequel::Deprecation.deprecate("Sequel::Model#set_all", "Switch to set or load the whitelist_security plugin into the model class")
         set_restricted(hash, :all)
       end
   
@@ -1870,6 +1869,7 @@ module Sequel
       #
       #   artist.set_only({:hometown=>'LA'}, :name) # Raise Error
       def set_only(hash, *only)
+        Sequel::Deprecation.deprecate("Sequel::Model#set_only", "Switch to set_fields with the :missing=>:skip option or load the whitelist_security plugin into the model class")
         set_restricted(hash, only.flatten)
       end
   
@@ -1916,6 +1916,7 @@ module Sequel
       #   Artist.set_allowed_columns(:num_albums)
       #   artist.update_all(:name=>'Jim') # UPDATE artists SET name = 'Jim' WHERE (id = 1)
       def update_all(hash)
+        Sequel::Deprecation.deprecate("Sequel::Model#update_all", "Switch to update or load the whitelist_security plugin into the model class")
         update_restricted(hash, :all)
       end
   
@@ -1941,6 +1942,7 @@ module Sequel
       #
       #   artist.update_only({:hometown=>'LA'}, :name) # Raise Error
       def update_only(hash, *only)
+        Sequel::Deprecation.deprecate("Sequel::Model#update_only", "Switch to update_fields with the :missing=>:skip option or load the whitelist_security plugin into the model class")
         update_restricted(hash, only.flatten)
       end
       
@@ -2002,8 +2004,6 @@ module Sequel
       # even if validation is skipped.  This is a private hook.  It exists so that
       # plugins can set values automatically before validation (as the values
       # need to be validated), but should be set even if validation is skipped.
-      # Unlike the regular before_validation hook, we do not skip the save/validation
-      # if this returns false.
       def _before_validation
       end
 
@@ -2428,7 +2428,7 @@ module Sequel
       # Array :: Only allow setting of columns in the given array.
       def setter_methods(type)
         if type == :default
-          if !@singleton_setter_added || model.allowed_columns
+          if !@singleton_setter_added || model.allowed_columns # SEQUEL5: Remove model.allowed_columns
             return model.setter_methods
           end
         end
@@ -2503,7 +2503,7 @@ module Sequel
       #
       #   Artist.dataset[1] # SELECT * FROM artists WHERE (id = 1) LIMIT 1
       def [](*args)
-        if args.length == 1 && (i = args.at(0)) && i.is_a?(Integer)
+        if args.length == 1 && (i = args[0]) && i.is_a?(Integer)
           with_pk(i)
         else
           super
@@ -2531,6 +2531,7 @@ module Sequel
       #   # FROM artists LEFT OUTER JOIN albums ON (albums.artist_id = artists.id)
       def graph(table, *args, &block)
         if table.is_a?(Class) && table < Sequel::Model
+          Sequel::Deprecation.deprecate("Passing Sequel::Model class as first argument to Sequel::Dataset#graph", "Pass the model's dataset as the first argument instead")
           super(table.dataset, *args, &block)
         else
           super
@@ -2544,7 +2545,8 @@ module Sequel
       #   Album.insert(Album.load(:name=>'A'))
       #   # INSERT INTO albums (name) VALUES ('A')
       def insert_sql(*values)
-        if values.size == 1 && (v = values.at(0)).is_a?(Sequel::Model) && !v.respond_to?(:sql_literal_append)
+        if values.size == 1 && (v = values[0]).is_a?(Sequel::Model) && !v.respond_to?(:sql_literal_append)
+          Sequel::Deprecation.deprecate("Passing Sequel::Model instance argument to Sequel::Dataset#insert", "Pass model_instance.values or model_instance.to_hash as the argument instead")
           super(v.to_hash)
         else
           super
@@ -2558,6 +2560,7 @@ module Sequel
       #   # SELECT * FROM artists INNER JOIN albums ON (albums.artist_id = artists.id)
       def join_table(type, table, *args, &block)
         if table.is_a?(Class) && table < Sequel::Model
+          Sequel::Deprecation.deprecate("Passing Sequel::Model class to a dataset join method", "Pass the model's table name or dataset as the first argument instead")
           if table.dataset.simple_select_all?
             super(type, table.table_name, *args, &block)
           else
@@ -2721,6 +2724,5 @@ module Sequel
 
     extend ClassMethods
     plugin self
-    finder(:where, :arity=>1, :mod=>ClassMethods)
   end
 end

data/lib/sequel/model/dataset_module.rb

@@ -14,24 +14,18 @@ module Sequel
         @model = model
       end
 
-      # Define a named filter for this dataset, see
-      # Model.subset for details.
+      # Alias for where.
       def subset(name, *args, &block)
-        @model.subset(name, *args, &block)
+        where(name, *args, &block)
       end
 
-      # Alias for subset
-      def where(name, *args, &block)
-        subset(name, *args, &block)
-      end
-
-      %w'exclude exclude_having having'.map(&:to_sym).each do |meth|
+      %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)}
-            @model.def_dataset_method(name){send(meth, *args, &block)}
+            define_method(name){send(meth, *args, &block)}
           else
             key = :"_#{meth}_#{name}_ds"
-            @model.def_dataset_method(name) do
+            define_method(name) do
               cached_dataset(key){send(meth, *args)}
             end
           end
@@ -48,10 +42,10 @@ module Sequel
       def self.def_dataset_caching_method(mod, meth)
         mod.send(:define_method, meth) do |name, *args, &block|
           if block
-            @model.def_dataset_method(name){send(meth, *args, &block)}
+            define_method(name){send(meth, *args, &block)}
           else
             key = :"_#{meth}_#{name}_ds"
-            @model.def_dataset_method(name) do
+            define_method(name) do
               cached_dataset(key){send(meth, *args)}
             end
           end
@@ -67,7 +61,8 @@ module Sequel
       # Add a class method to the related model that
       # calls the dataset method of the same name.
       def method_added(meth)
-        @model.send(:def_model_dataset_method, meth)
+        @model.send(:def_model_dataset_method, meth) if public_method_defined?(meth)
+        super
       end
     end
 

data/lib/sequel/model/plugins.rb

@@ -25,6 +25,9 @@ module Sequel
     # In the given module +mod+, define methods that are call the same method
     # on the dataset.  This is designed for plugins to define dataset methods
     # inside ClassMethods that call the implementations in DatasetMethods.
+    #
+    # This should not be called with untrusted input or method names that
+    # can't be used literally, since it uses class_eval.
     def self.def_dataset_methods(mod, meths)
       Array(meths).each do |meth|
         mod.class_eval("def #{meth}(*args, &block); dataset.#{meth}(*args, &block) end", __FILE__, __LINE__)

data/lib/sequel/no_core_ext.rb

@@ -1,3 +1,4 @@
 # frozen-string-literal: true
 
 require 'sequel'
+Sequel::Deprecation.deprecate("requiring 'sequel/no_core_ext'", "Just require 'sequel' instead")

data/lib/sequel/plugins/blacklist_security.rb

@@ -58,7 +58,7 @@ module Sequel
         # restricted_columns.
         def get_setter_methods
           meths = super
-          if !allowed_columns && restricted_columns
+          if !(respond_to?(:allowed_columns) && allowed_columns) && restricted_columns
             meths -= restricted_columns.map{|x| "#{x}="}
           end
           meths

data/lib/sequel/plugins/boolean_subsets.rb

@@ -9,7 +9,7 @@ module Sequel
     # <tt>column IS TRUE</tt> (assuming the database supports that syntax).
     #
     # You can provide a block to the plugin, which will be called with column name
-    # symbol, and should return an array of arguments to pass to +subset+.
+    # symbol, and should return an array of arguments to pass to +dataset_module.where+.
     # Using this, you can change the method name and arguments for each column.
     # This block is executed in the context of the model class.
     #
@@ -28,12 +28,11 @@ module Sequel
     #     [column.to_s.sub(/\Ais_/, ''), {column=>'Y'}]
     #   end
     module BooleanSubsets
-      # Add the boolean_attribute? class method to the model, and create
-      # attribute? boolean reader methods for the class's columns if the class has a dataset.
+      # Create boolean subset methods for each boolean column.
       def self.configure(model, &block)
         model.instance_eval do
           (class << self; self; end).send(:define_method, :boolean_subset_args, &block) if block
-          send(:create_boolean_subsets) if @dataset
+          create_boolean_subsets if @dataset
         end
       end
 
@@ -50,7 +49,10 @@ module Sequel
         # Add subset methods for all of the boolean columns in this model.
         def create_boolean_subsets
           if cs = check_non_connection_error{columns}
-            cs.each{|c| subset(*boolean_subset_args(c)) if db_schema[c][:type] == :boolean}
+            cs = cs.select{|c| db_schema[c][:type] == :boolean}.map{|c| boolean_subset_args(c)}
+            dataset_module do
+              cs.each{|c| where(*c)}
+            end
           end
         end
       end