sequel 5.8.0 → 5.38.0

data/lib/sequel/plugins/association_proxies.rb

@@ -64,6 +64,8 @@ module Sequel
         array = [].freeze
 
         if RUBY_VERSION < '2.6'
+          # :nocov:
+
           # Default proc used to determine whether to send the method to the dataset.
           # If the array would respond to it, sends it to the array instead of the dataset.
           DEFAULT_PROXY_TO_DATASET = proc do |opts|
@@ -73,10 +75,9 @@ module Sequel
             end
             !array_method
           end
-        else
           # :nocov:
+        else
           DEFAULT_PROXY_TO_DATASET = proc{|opts| !array.respond_to?(opts[:method])}
-          # :nocov:
         end
 
         # Set the association reflection to use, and whether the association should be
@@ -98,6 +99,7 @@ module Sequel
           end
           v.public_send(meth, *args, &block)
         end
+        ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
       end
 
       module ClassMethods
@@ -108,6 +110,8 @@ module Sequel
 
         Plugins.inherited_instance_variables(self, :@association_proxy_to_dataset=>nil)
 
+        private
+
         # Changes the association method to return a proxy instead of the associated objects
         # directly.
         def def_association_method(opts)

data/lib/sequel/plugins/auto_validations.rb

@@ -30,6 +30,12 @@ module Sequel
     #
     #   Model.skip_auto_validations(:all)
     #
+    # It is possible to skip auto validations on a per-model-instance basis via:
+    #
+    #   instance.skip_auto_validations(:unique, :not_null) do
+    #     puts instance.valid?
+    #   end
+    #
     # By default, the plugin uses a not_null validation for NOT NULL columns, but that
     # can be changed to a presence validation using an option:
     #
@@ -58,6 +64,7 @@ module Sequel
       MAX_LENGTH_OPTIONS = {:from=>:values, :allow_nil=>true}.freeze
       SCHEMA_TYPES_OPTIONS = NOT_NULL_OPTIONS
       UNIQUE_OPTIONS = NOT_NULL_OPTIONS
+      EMPTY_ARRAY = [].freeze
 
       def self.apply(model, opts=OPTS)
         model.instance_exec do
@@ -172,38 +179,50 @@ module Sequel
       end
 
       module InstanceMethods
+        # Skip the given types of auto validations on this instance inside the block.
+        def skip_auto_validations(*types)
+          types << :all if types.empty?
+          @_skip_auto_validations = types
+          yield
+        ensure
+          @_skip_auto_validations = nil
+        end
+
         # Validate the model's auto validations columns
         def validate
           super
+          skip = @_skip_auto_validations || EMPTY_ARRAY
+          return if skip.include?(:all)
           opts = model.auto_validate_options
 
-          unless (not_null_columns = model.auto_validate_not_null_columns).empty?
-            if model.auto_validate_presence?
-              validates_presence(not_null_columns, opts[:not_null])
-            else
-              validates_not_null(not_null_columns, opts[:not_null])
+
+          unless skip.include?(:not_null)
+            not_null_method = model.auto_validate_presence? ? :validates_presence : :validates_not_null
+            unless (not_null_columns = model.auto_validate_not_null_columns).empty?
+              public_send(not_null_method, not_null_columns, opts[:not_null])
             end
-          end
-          unless (not_null_columns = model.auto_validate_explicit_not_null_columns).empty?
-            if model.auto_validate_presence?
-              validates_presence(not_null_columns, opts[:explicit_not_null])
-            else
-              validates_not_null(not_null_columns, opts[:explicit_not_null])
+            unless (not_null_columns = model.auto_validate_explicit_not_null_columns).empty?
+              public_send(not_null_method, not_null_columns, opts[:explicit_not_null])
             end
           end
-          unless (max_length_columns = model.auto_validate_max_length_columns).empty?
+
+          unless skip.include?(:max_length) || (max_length_columns = model.auto_validate_max_length_columns).empty?
             max_length_columns.each do |col, len|
               validates_max_length(len, col, opts[:max_length])
             end
           end
 
-          validates_schema_types(keys, opts[:schema_types]) if model.auto_validate_types?
+          unless skip.include?(:types) || !model.auto_validate_types?
+            validates_schema_types(keys, opts[:schema_types])
+          end
 
-          unique_opts = Hash[opts[:unique]]
-          if model.respond_to?(:sti_dataset)
-            unique_opts[:dataset] = model.sti_dataset
+          unless skip.include?(:unique)
+            unique_opts = Hash[opts[:unique]]
+            if model.respond_to?(:sti_dataset)
+              unique_opts[:dataset] = model.sti_dataset
+            end
+            model.auto_validate_unique_columns.each{|cols| validates_unique(cols, unique_opts)}
           end
-          model.auto_validate_unique_columns.each{|cols| validates_unique(cols, unique_opts)}
         end
       end
     end

data/lib/sequel/plugins/blacklist_security.rb

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

data/lib/sequel/plugins/boolean_subsets.rb

@@ -31,7 +31,10 @@ module Sequel
       # Create boolean subset methods for each boolean column.
       def self.configure(model, &block)
         model.instance_exec do
-          define_singleton_method(:boolean_subset_args, &block) if block
+          if block
+            define_singleton_method(:boolean_subset_args, &block)
+            singleton_class.send(:private, :boolean_subset_args)
+          end
           create_boolean_subsets if @dataset
         end
       end

data/lib/sequel/plugins/caching.rb

@@ -26,6 +26,9 @@ module Sequel
     # * Model.with_pk!
     # * Model.[] # when argument is not hash or nil
     # * many_to_one association method # without dynamic callback, when primary key matches
+    #
+    # You should not use this plugin if you are using sharding and there are different
+    # rows for the same primary key on different shards.
     # 
     # Usage:
     #

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -98,7 +98,7 @@ module Sequel
     #
     #   a = Executive.first
     #   a.values # {:id=>1, name=>'S', :kind=>'Executive', :num_staff=>4, :num_managers=>2}
-    #   
+    #
     # Note that when loading from a subclass, because the subclass dataset uses a subquery
     # that by default uses the same alias at the primary table, any qualified identifiers
     # should reference the subquery alias (and qualified identifiers should not be needed
@@ -108,6 +108,16 @@ module Sequel
     #   a = Executive.where{{employees[:id]=>1}}.first # works
     #   a = Executive.where{{executives[:id]=>1}}.first # doesn't work
     #
+    # Note that because subclass datasets select from a subquery, you cannot update,
+    # delete, or insert into them directly.  To delete related rows, you need to go
+    # through the related tables and remove the related rows.  Code that does this would
+    # be similar to:
+    #
+    #   pks = Executive.where{num_staff < 10}.select_map(:id)
+    #   Executive.cti_tables.reverse_each do |table|
+    #     DB.from(table).where(:id=>pks).delete
+    #   end
+    #
     # = Usage
     #
     #   # Use the default of storing the class name in the sti_key
@@ -198,6 +208,9 @@ module Sequel
       #               Overrides implicit table names.
       # :ignore_subclass_columns :: Array with column names as symbols that are ignored
       #                             on all sub-classes.
+      # :qualify_tables :: Boolean true to qualify automatically determined
+      #                    subclass tables with the same qualifier as their
+      #                    superclass.
       def self.configure(model, opts = OPTS)
         SingleTableInheritance.configure model, opts[:key], opts
 
@@ -207,8 +220,14 @@ module Sequel
           @cti_instance_dataset = @instance_dataset
           @cti_table_columns = columns
           @cti_table_map = opts[:table_map] || {}
-          @cti_alias = opts[:alias] || @dataset.first_source
+          @cti_alias = opts[:alias] || case source = @dataset.first_source
+          when SQL::QualifiedIdentifier
+            @dataset.unqualified_column_for(source)
+          else
+            source
+          end
           @cti_ignore_subclass_columns = opts[:ignore_subclass_columns] || []
+          @cti_qualify_tables = !!opts[:qualify_tables]
         end
       end
 
@@ -239,6 +258,13 @@ module Sequel
         # primary key column is always allowed to be duplicated
         attr_reader :cti_ignore_subclass_columns
 
+        # A boolean indicating whether or not to automatically qualify tables
+        # backing subclasses with the same qualifier as their superclass, if
+        # the superclass is qualified. Specified with the :qualify_tables
+        # option to the plugin and only applied to automatically determined
+        # table names (not to the :table_map option).
+        attr_reader :cti_qualify_tables
+
         # Freeze CTI information when freezing model class.
         def freeze
           @cti_models.freeze
@@ -250,7 +276,28 @@ module Sequel
           super
         end
 
-        Plugins.inherited_instance_variables(self, :@cti_models=>nil, :@cti_tables=>nil, :@cti_table_columns=>nil, :@cti_instance_dataset=>nil, :@cti_table_map=>nil, :@cti_alias=>nil, :@cti_ignore_subclass_columns=>nil)
+        Plugins.inherited_instance_variables(self, :@cti_models=>nil, :@cti_tables=>nil, :@cti_table_columns=>nil, :@cti_instance_dataset=>nil, :@cti_table_map=>nil, :@cti_alias=>nil, :@cti_ignore_subclass_columns=>nil, :@cti_qualify_tables=>nil)
+
+        # The table name for the current model class's main table.
+        def table_name
+          if cti_tables && cti_tables.length > 1
+            @cti_alias
+          else
+            super
+          end
+        end
+
+        # The name of the most recently joined table.
+        def cti_table_name
+          cti_tables.last
+        end
+
+        # The model class for the given key value.
+        def sti_class_from_key(key)
+          sti_class(sti_model_map[key])
+        end
+
+        private
 
         def inherited(subclass)
           ds = sti_dataset
@@ -263,12 +310,16 @@ module Sequel
           # Set table if this is a class table inheritance
           table = nil
           columns = nil
-          if (n = subclass.name) && !n.empty?
+          if n = subclass.name
             if table = cti_table_map[n.to_sym]
-              columns = db.from(table).columns
+              columns = db.schema(table).map(&:first)
             else
-              table = subclass.implicit_table_name
-              columns = check_non_connection_error(false){db.from(table).columns}
+              table = if cti_qualify_tables && (schema = dataset.schema_and_table(cti_table_name).first)
+                SQL::QualifiedIdentifier.new(schema, subclass.implicit_table_name)
+              else
+                subclass.implicit_table_name
+              end
+              columns = check_non_connection_error(false){db.schema(table) && db.schema(table).map(&:first)}
               table = nil if !columns || columns.empty?
             end
           end
@@ -281,6 +332,7 @@ module Sequel
             if cti_tables.length == 1
               ds = ds.select(*self.columns.map{|cc| Sequel.qualify(cti_table_name, Sequel.identifier(cc))})
             end
+            ds.send(:columns=, self.columns)
             cols = (columns - [pk]) - cti_ignore_subclass_columns
             dup_cols = cols & ds.columns
             unless dup_cols.empty?
@@ -290,6 +342,7 @@ module Sequel
             @sti_dataset = ds = ds.join(table, pk=>pk).select_append(*sel_app)
 
             ds = ds.from_self(:alias=>@cti_alias)
+            ds.send(:columns=, self.columns + cols)
 
             set_dataset(ds)
             set_columns(self.columns)
@@ -304,30 +357,10 @@ module Sequel
             cti_tables.reverse_each do |ct|
               db.schema(ct).each{|sk,v| db_schema[sk] = v}
             end
+            setup_auto_validations if respond_to?(:setup_auto_validations, true)
           end
         end
 
-        # The table name for the current model class's main table.
-        def table_name
-          if cti_tables && cti_tables.length > 1
-            @cti_alias
-          else
-            super
-          end
-        end
-
-        # The name of the most recently joined table.
-        def cti_table_name
-          cti_tables ? cti_tables.last : dataset.first_source_alias
-        end
-
-        # The model class for the given key value.
-        def sti_class_from_key(key)
-          sti_class(sti_model_map[key])
-        end
-
-        private
-
         # If using a subquery for class table inheritance, also use a subquery
         # when setting subclass dataset.
         def sti_subclass_dataset(key)
@@ -350,11 +383,6 @@ module Sequel
           self
         end
 
-        # Don't allow use of prepared statements.
-        def use_prepared_statements_for?(type)
-          false
-        end
-
         # Set the sti_key column based on the sti_key_map.
         def before_validation
           if new? && (set = self[model.sti_key])
@@ -389,7 +417,7 @@ module Sequel
               @values[primary_key] ||= nid
             end
           end
-          db.dataset.supports_insert_select? ? nil : @values[primary_key]
+          @values[primary_key]
         end
 
         # Update rows in all backing tables, using the columns in each table.

data/lib/sequel/plugins/composition.rb

@@ -32,9 +32,10 @@ module Sequel
     #
     # The :mapping option is just a shortcut that works in particular
     # cases.  To handle any case, you can define a custom :composer
-    # and :decomposer procs.  The :composer proc will be instance_execed
-    # the first time the getter is called, and the :decomposer proc
-    # will be instance_execed before saving.  The above example could
+    # and :decomposer procs.  The :composer and :decomposer procs will
+    # be used to define instance methods.  The :composer will be called
+    # the first time the getter is called, and the :decomposer 
+    # will be called before saving.  The above example could
     # also be implemented as:
     #
     #   Album.composition :date,
@@ -74,9 +75,9 @@ module Sequel
         #
         # Options:
         # :class :: if using the :mapping option, the class to use, as a Class, String or Symbol.
-        # :composer :: A proc that is instance_execed when the composition getter method is called
+        # :composer :: A proc used to define the method that the composition getter method will call 
         #              to create the composition.
-        # :decomposer :: A proc that is instance_execed before saving the model object,
+        # :decomposer :: A proc used to define the method called before saving the model object,
         #                if the composition object exists, which sets the columns in the model object
         #                based on the value of the composition object.
         # :mapping :: An array where each element is either a symbol or an array of two symbols.
@@ -129,15 +130,17 @@ module Sequel
         
         # Define getter and setter methods for the composition object.
         def define_composition_accessor(name, opts=OPTS)
-          composer = opts[:composer]
+          composer_meth = opts[:composer_method] = Plugins.def_sequel_method(@composition_module, "#{name}_composer", 0, &opts[:composer])
+          opts[:decomposer_method] = Plugins.def_sequel_method(@composition_module, "#{name}_decomposer", 0, &opts[:decomposer])
           @composition_module.class_eval do
             define_method(name) do 
               if compositions.has_key?(name)
                 compositions[name]
               elsif frozen?
-                instance_exec(&composer)
+                # composer_meth is private
+                send(composer_meth)
               else
-                compositions[name] = instance_exec(&composer)
+                compositions[name] = send(composer_meth)
               end
             end
             define_method("#{name}=") do |v|
@@ -171,7 +174,8 @@ module Sequel
         # For each composition, set the columns in the model class based
         # on the composition object.
         def before_validation
-          @compositions.keys.each{|n| instance_exec(&model.compositions[n][:decomposer])} if @compositions
+          # decomposer_method is private
+          @compositions.keys.each{|n| send(model.compositions[n][:decomposer_method])} if @compositions
           super
         end
         

data/lib/sequel/plugins/csv_serializer.rb

@@ -65,8 +65,6 @@ module Sequel
     #   # Add CSV output capability to Album class instances
     #   Album.plugin :csv_serializer
     module CsvSerializer
-      CSV = Object.const_defined?(:CSV) ? ::CSV : ::FasterCSV
-
       # Set up the column readers to do deserialization and the column writers
       # to save the value in deserialized_values
       def self.configure(model, opts = OPTS)
@@ -75,13 +73,31 @@ module Sequel
         end
       end
 
+      # Avoid keyword argument separation warnings on Ruby 2.7, while still
+      # being compatible with 1.9.
+      if RUBY_VERSION >= "2.0"
+        instance_eval(<<-END, __FILE__, __LINE__+1)
+          def self.csv_call(*args, opts, &block)
+            CSV.send(*args, **opts, &block)
+          end
+        END
+      else
+        # :nocov:
+        # :nodoc:
+        def self.csv_call(*args, opts, &block)
+          CSV.send(*args, opts, &block)
+        end
+        # :nodoc:
+        # :nocov:
+      end
+
       module ClassMethods
         # The default opts to use when serializing model objects to CSV
         attr_reader :csv_serializer_opts
 
         # Attempt to parse an array of instances from the given CSV string
         def array_from_csv(csv, opts = OPTS)
-          CSV.parse(csv, process_csv_serializer_opts(opts)).map do |row|
+          CsvSerializer.csv_call(:parse, csv, process_csv_serializer_opts(opts)).map do |row|
             row = row.to_hash
             row.delete(nil)
             new(row)
@@ -108,7 +124,8 @@ module Sequel
           opts_cols = opts.delete(:columns)
           opts_include = opts.delete(:include)
           opts_except = opts.delete(:except)
-          opts[:headers] ||= Array(opts.delete(:only) || opts_cols || columns) + Array(opts_include) - Array(opts_except)
+          only = opts.delete(:only) 
+          opts[:headers] ||= Array(only || opts_cols || columns) + Array(opts_include) - Array(opts_except)
           opts
         end
 
@@ -130,7 +147,7 @@ module Sequel
         # :headers :: The headers to use for the CSV line. Use nil for a header
         #             to specify the column should be ignored.
         def from_csv(csv, opts = OPTS)
-          row = CSV.parse_line(csv, model.process_csv_serializer_opts(opts)).to_hash
+          row = CsvSerializer.csv_call(:parse_line, csv, model.process_csv_serializer_opts(opts)).to_hash
           row.delete(nil)
           set(row)
         end
@@ -146,9 +163,10 @@ module Sequel
         #             attributes to include in the CSV output.
         def to_csv(opts = OPTS)
           opts = model.process_csv_serializer_opts(opts)
+          headers = opts[:headers]
 
-          CSV.generate(opts) do |csv|
-            csv << opts[:headers].map{|k| public_send(k)}
+          CsvSerializer.csv_call(:generate, model.process_csv_serializer_opts(opts)) do |csv|
+            csv << headers.map{|k| public_send(k)}
           end
         end
       end
@@ -164,10 +182,11 @@ module Sequel
         def to_csv(opts = OPTS)
           opts = model.process_csv_serializer_opts({:columns=>columns}.merge!(opts))
           items = opts.delete(:array) || self
+          headers = opts[:headers]
 
-          CSV.generate(opts) do |csv|
+          CsvSerializer.csv_call(:generate, opts) do |csv|
             items.each do |object|
-              csv << opts[:headers].map{|header| object.public_send(header) }
+              csv << headers.map{|header| object.public_send(header)}
             end
           end
         end