sequel 5.19.0 → 5.24.0

data/lib/sequel/plugins/finder.rb

@@ -35,8 +35,8 @@ module Sequel
     module Finder
       FINDER_TYPES = [:first, :all, :each, :get].freeze
 
-      def self.apply(mod)
-        mod.instance_exec do
+      def self.apply(model)
+        model.instance_exec do
           @finders ||= {}
           @finder_loaders ||= {}
         end

data/lib/sequel/plugins/hook_class_methods.rb

@@ -59,7 +59,14 @@ module Sequel
     
         # Yield every block related to the given hook.
         def hook_blocks(hook)
-          @hooks[hook].each{|k,v| yield v}
+          # SEQUEL6: Remove
+          Sequel::Deprecation.deprecate("The hook_blocks class method in the hook_class_methods plugin is deprecated and will be removed in Sequel 6.")
+          @hooks[hook].each{|_,v,_| yield v}
+        end
+
+        # Yield every method related to the given hook.
+        def hook_methods_for(hook)
+          @hooks[hook].each{|_,_,m| yield m}
         end
 
         Plugins.inherited_instance_variables(self, :@hooks=>:hash_dup)
@@ -75,23 +82,28 @@ module Sequel
             # Allow calling private hook methods
             block = proc {send(tag)}
           end
+
           h = @hooks[hook]
+
           if tag && (old = h.find{|x| x[0] == tag})
             old[1] = block
+            Plugins.def_sequel_method(self, old[2], 0, &block)
           else
+            meth = Plugins.def_sequel_method(self, "validation_class_methods_#{hook}", 0, &block)
             if hook.to_s =~ /^before/
-              h.unshift([tag,block])
+              h.unshift([tag, block, meth])
             else
-              h << [tag, block]
+              h << [tag, block, meth]
             end
           end
         end
       end
 
       module InstanceMethods
-        [:before_create, :before_update, :before_validation, :before_save, :before_destroy].each{|h| class_eval("def #{h}; model.hook_blocks(:#{h}){|b| instance_exec(&b)}; super end", __FILE__, __LINE__)}
+        # hook methods are private
+        [:before_create, :before_update, :before_validation, :before_save, :before_destroy].each{|h| class_eval("def #{h}; model.hook_methods_for(:#{h}){|m| send(m)}; super end", __FILE__, __LINE__)}
 
-        [:after_create, :after_update, :after_validation, :after_save, :after_destroy].each{|h| class_eval("def #{h}; super; model.hook_blocks(:#{h}){|b| instance_exec(&b)}; end", __FILE__, __LINE__)}
+        [:after_create, :after_update, :after_validation, :after_save, :after_destroy].each{|h| class_eval("def #{h}; super; model.hook_methods_for(:#{h}){|m| send(m)}; end", __FILE__, __LINE__)}
       end
     end
   end

data/lib/sequel/plugins/insert_conflict.rb

@@ -0,0 +1,72 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The insert_conflict plugin allows handling conflicts due to unique
+    # constraints when saving new model instance, using the INSERT ON CONFLICT
+    # support in PostgreSQL 9.5+ and SQLite 3.24.0+. Example:
+    #
+    #   class Album < Sequel::Model
+    #     plugin :insert_conflict
+    #   end
+    #
+    #   Album.new(name: 'Foo', copies_sold: 1000).
+    #     insert_conflict(
+    #       target: :name,
+    #       update: {copies_sold: Sequel[:excluded][:b]}
+    #     ).
+    #     save
+    #
+    # This example will try to insert the album, but if there is an existing
+    # album with the name 'Foo', this will update the copies_sold attribute
+    # for that album.  See the PostgreSQL and SQLite adapter documention for
+    # the options you can pass to the insert_conflict method.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses support insert_conflict
+    #   Sequel::Model.plugin :insert_conflict
+    #
+    #   # Make the Album class support insert_conflict
+    #   Album.plugin :insert_conflict
+    module InsertConflict
+      def self.configure(model)
+        model.instance_exec do
+          if @dataset && !@dataset.respond_to?(:insert_conflict)
+            raise Error, "#{self}'s dataset does not support insert_conflict"
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Set the insert_conflict options to pass to the dataset when inserting. 
+        def insert_conflict(opts=OPTS)
+          raise Error, "Model#insert_conflict is only supported on new model instances" unless new?
+          @insert_conflict_opts = opts
+          self
+        end
+
+        private
+
+        # Set the dataset used for inserting to use INSERT ON CONFLICT
+        # Model#insert_conflict has been called on the instance previously.
+        def _insert_dataset
+          ds = super
+
+          if @insert_conflict_opts
+            ds = ds.insert_conflict(@insert_conflict_opts)
+          end
+
+          ds
+        end
+
+        # Disable the use of prepared insert statements, as they are not compatible
+        # with this plugin.
+        def use_prepared_statements_for?(type)
+          return false if type == :insert || type == :insert_select
+          super if defined?(super)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/inverted_subsets.rb

@@ -29,8 +29,8 @@ module Sequel
     #   # SELECT * FROM albums WHERE (published IS NOT TRUE)
     #
     module InvertedSubsets
-      def self.apply(mod, &block)
-        mod.instance_exec do
+      def self.apply(model, &block)
+        model.instance_exec do
           @dataset_module_class = Class.new(@dataset_module_class) do
             include DatasetModuleMethods
             if block

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -22,8 +22,9 @@ module Sequel
     # This plugin is not intended as a replacement for other validations,
     # it is intended as a last resort.  The purpose of validations is to provide nice
     # error messages for the user, and the error messages generated by this plugin are
-    # fairly generic.  The error messages can be customized using the :messages plugin
-    # option, but there is only a single message used per constraint type.
+    # fairly generic by default.  The error messages can be customized per constraint type
+    # using the :messages plugin option, and individually per constraint using
+    # +pg_auto_constraint_validation_override+ (see below).
     #
     # This plugin only works on the postgres adapter when using the pg 0.16+ driver,
     # PostgreSQL 9.3+ server, and PostgreSQL 9.3+ client library (libpq). In other cases
@@ -37,6 +38,38 @@ module Sequel
     #   rescue Sequel::ValidationFailed
     #     album.errors.on(:artist_id) # ['is invalid']
     #   end
+    #
+    # While the database usually provides enough information to correctly associated
+    # constraint violations with model columns, there are cases where it does not.
+    # In those cases, you can override the handling of specific constraint violations
+    # to be associated to particular column(s), and use a specific error message:
+    #
+    #   Album.pg_auto_constraint_validation_override(:constraint_name, [:column1], "validation error message")
+    #
+    # Using the pg_auto_constraint_validations plugin requires 5 queries per
+    # model at load time in order to gather the necessary metadata.  For applications
+    # with a large number of models, this can result in a noticeable delay during model
+    # initialization.  To mitigate this issue, you can cache the necessary metadata in
+    # a file with the :cache_file option:
+    #
+    #   Sequel::Model.plugin :pg_auto_constraint_validations, cache_file: 'db/pgacv.cache'
+    #
+    # The file does not have to exist when loading the plugin.  If it exists, the plugin
+    # will load the cache and use the cached results instead of issuing queries if there
+    # is an entry in the cache.  If there is no entry in the cache, it will update the
+    # in-memory cache with the metadata results.  To save the in in-memory cache back to
+    # the cache file, run:
+    #
+    #   Sequel::Model.dump_pg_auto_constraint_validations_cache
+    # 
+    # Note that when using the :cache_file option, it is up to the application to ensure
+    # that the dumped cached metadata reflects the current state of the database.  Sequel
+    # does no checking to ensure this, as checking would take time and the
+    # purpose of this code is to take a shortcut.
+    #
+    # The cached schema is dumped in Marshal format, since it is the fastest
+    # and it handles all ruby objects used in the metadata.  Because of this,
+    # you should not attempt to load the metadata from a untrusted file.
     # 
     # Usage:
     #
@@ -59,13 +92,28 @@ module Sequel
       }.freeze).each_value(&:freeze)
 
       # Setup the constraint violation metadata.  Options:
+      # :cache_file :: File storing cached metadata, to avoid queries for each model
       # :messages :: Override the default error messages for each constraint
       #              violation type (:not_null, :check, :unique, :foreign_key, :referenced_by)
       def self.configure(model, opts=OPTS)
         model.instance_exec do
+          if @pg_auto_constraint_validations_cache_file = opts[:cache_file]
+            @pg_auto_constraint_validations_cache = if ::File.file?(@pg_auto_constraint_validations_cache_file)
+              cache = Marshal.load(File.read(@pg_auto_constraint_validations_cache_file))
+              cache.each_value do |hash|
+                hash.freeze.each_value(&:freeze)
+              end
+            else
+              {}
+            end
+          else
+            @pg_auto_constraint_validations_cache = nil
+          end
+
           setup_pg_auto_constraint_validations
           @pg_auto_constraint_validations_messages = (@pg_auto_constraint_validations_messages || DEFAULT_ERROR_MESSAGES).merge(opts[:messages] || OPTS).freeze
         end
+        nil
       end
 
       module ClassMethods
@@ -77,9 +125,26 @@ module Sequel
         # generated validation failures.
         attr_reader :pg_auto_constraint_validations_messages
 
-        Plugins.inherited_instance_variables(self, :@pg_auto_constraint_validations=>nil, :@pg_auto_constraint_validations_messages=>nil)
+        Plugins.inherited_instance_variables(self, :@pg_auto_constraint_validations=>nil, :@pg_auto_constraint_validations_messages=>nil, :@pg_auto_constraint_validations_cache=>nil, :@pg_auto_constraint_validations_cache_file=>nil)
         Plugins.after_set_dataset(self, :setup_pg_auto_constraint_validations)
 
+        # Dump the in-memory cached metadata to the cache file.
+        def dump_pg_auto_constraint_validations_cache
+          raise Error, "No pg_auto_constraint_validations setup" unless file = @pg_auto_constraint_validations_cache_file
+          File.open(file, 'wb'){|f| f.write(Marshal.dump(@pg_auto_constraint_validations_cache))}
+          nil
+        end
+
+        # Override the constraint validation columns and message for a given constraint
+        def pg_auto_constraint_validation_override(constraint, columns, message)
+          pgacv = Hash[@pg_auto_constraint_validations]
+          overrides = pgacv[:overrides] = Hash[pgacv[:overrides]]
+          overrides[constraint] = [Array(columns), message].freeze
+          overrides.freeze
+          @pg_auto_constraint_validations = pgacv.freeze
+          nil
+        end
+
         private
 
         # Get the list of constraints, unique indexes, foreign keys in the current
@@ -104,38 +169,51 @@ module Sequel
             return
           end
 
-          checks = {}
-          indexes = {}
-          foreign_keys = {}
-          referenced_by = {}
+          cache = @pg_auto_constraint_validations_cache
+          literal_table_name = dataset.literal(table_name)
+          unless cache && (metadata = cache[literal_table_name])
+            checks = {}
+            indexes = {}
+            foreign_keys = {}
+            referenced_by = {}
 
-          db.check_constraints(table_name).each do |k, v|
-            checks[k] = v[:columns].dup.freeze
-          end
-          db.indexes(table_name, :include_partial=>true).each do |k, v|
-            if v[:unique]
-              indexes[k] = v[:columns].dup.freeze
+            db.check_constraints(table_name).each do |k, v|
+              checks[k] = v[:columns].dup.freeze unless v[:columns].empty?
+            end
+            db.indexes(table_name, :include_partial=>true).each do |k, v|
+              if v[:unique]
+                indexes[k] = v[:columns].dup.freeze
+              end
+            end
+            db.foreign_key_list(table_name, :schema=>false).each do |fk|
+              foreign_keys[fk[:name]] = fk[:columns].dup.freeze
+            end
+            db.foreign_key_list(table_name, :reverse=>true, :schema=>false).each do |fk|
+              referenced_by[[fk[:schema], fk[:table], fk[:name]].freeze] = fk[:key].dup.freeze
+            end
+
+            schema, table = db[:pg_class].
+              join(:pg_namespace, :oid=>:relnamespace, db.send(:regclass_oid, table_name)=>:oid).
+              get([:nspname, :relname])
+
+            metadata = {
+              :schema=>schema,
+              :table=>table,
+              :check=>checks,
+              :unique=>indexes,
+              :foreign_key=>foreign_keys,
+              :referenced_by=>referenced_by,
+              :overrides=>OPTS
+            }.freeze
+            metadata.each_value(&:freeze)
+
+            if cache
+              cache[literal_table_name] = metadata
             end
-          end
-          db.foreign_key_list(table_name, :schema=>false).each do |fk|
-            foreign_keys[fk[:name]] = fk[:columns].dup.freeze
-          end
-          db.foreign_key_list(table_name, :reverse=>true, :schema=>false).each do |fk|
-            referenced_by[[fk[:schema], fk[:table], fk[:name]].freeze] = fk[:key].dup.freeze
           end
 
-          schema, table = db[:pg_class].
-            join(:pg_namespace, :oid=>:relnamespace, db.send(:regclass_oid, table_name)=>:oid).
-            get([:nspname, :relname])
-
-          (@pg_auto_constraint_validations = {
-            :schema=>schema,
-            :table=>table,
-            :check=>checks,
-            :unique=>indexes,
-            :foreign_key=>foreign_keys,
-            :referenced_by=>referenced_by
-          }.freeze).each_value(&:freeze)
+          @pg_auto_constraint_validations = metadata
+          nil
         end
       end
 
@@ -158,40 +236,50 @@ module Sequel
             m = ds.method(:output_identifier)
             schema = info[:schema]
             table = info[:table]
+
             if constraint = info[:constraint]
               constraint = m.call(constraint)
+
+              columns, message = cv_info[:overrides][constraint]
+              if columns
+                override = true
+                add_pg_constraint_validation_error(columns, message)
+              end
             end
+
             messages = model.pg_auto_constraint_validations_messages
 
-            case e
-            when Sequel::NotNullConstraintViolation
-              if column = info[:column]
-                add_pg_constraint_validation_error([m.call(column)], messages[:not_null])
-              end
-            when Sequel::CheckConstraintViolation
-              if columns = cv_info[:check][constraint]
-                add_pg_constraint_validation_error(columns, messages[:check])
-              end
-            when Sequel::UniqueConstraintViolation
-              if columns = cv_info[:unique][constraint]
-                add_pg_constraint_validation_error(columns, messages[:unique])
-              end
-            when Sequel::ForeignKeyConstraintViolation
-              message_primary = info[:message_primary]
-              if message_primary.start_with?('update')
-                # This constraint violation is different from the others, because the constraint
-                # referenced is a constraint for a different table, not for this table.  This
-                # happens when another table references the current table, and the referenced
-                # column in the current update is modified such that referential integrity
-                # would be broken.  Use the reverse foreign key information to figure out
-                # which column is affected in that case.
-                skip_schema_table_check = true
-                if columns = cv_info[:referenced_by][[m.call(schema), m.call(table), constraint]]
-                  add_pg_constraint_validation_error(columns, messages[:referenced_by])
+            unless override
+              case e
+              when Sequel::NotNullConstraintViolation
+                if column = info[:column]
+                  add_pg_constraint_validation_error([m.call(column)], messages[:not_null])
+                end
+              when Sequel::CheckConstraintViolation
+                if columns = cv_info[:check][constraint]
+                  add_pg_constraint_validation_error(columns, messages[:check])
+                end
+              when Sequel::UniqueConstraintViolation
+                if columns = cv_info[:unique][constraint]
+                  add_pg_constraint_validation_error(columns, messages[:unique])
                 end
-              elsif message_primary.start_with?('insert')
-                if columns = cv_info[:foreign_key][constraint]
-                  add_pg_constraint_validation_error(columns, messages[:foreign_key])
+              when Sequel::ForeignKeyConstraintViolation
+                message_primary = info[:message_primary]
+                if message_primary.start_with?('update')
+                  # This constraint violation is different from the others, because the constraint
+                  # referenced is a constraint for a different table, not for this table.  This
+                  # happens when another table references the current table, and the referenced
+                  # column in the current update is modified such that referential integrity
+                  # would be broken.  Use the reverse foreign key information to figure out
+                  # which column is affected in that case.
+                  skip_schema_table_check = true
+                  if columns = cv_info[:referenced_by][[m.call(schema), m.call(table), constraint]]
+                    add_pg_constraint_validation_error(columns, messages[:referenced_by])
+                  end
+                elsif message_primary.start_with?('insert')
+                  if columns = cv_info[:foreign_key][constraint]
+                    add_pg_constraint_validation_error(columns, messages[:foreign_key])
+                  end
                 end
               end
             end

data/lib/sequel/plugins/rcte_tree.rb

@@ -126,6 +126,9 @@ module Sequel
         a = opts.merge(opts.fetch(:ancestors, OPTS))
         ancestors = a.fetch(:name, :ancestors)
         a[:read_only] = true unless a.has_key?(:read_only)
+        a[:eager_grapher] = proc do |_|
+          raise Sequel::Error, "the #{ancestors} association for #{self} does not support eager graphing"
+        end
         a[:eager_loader_key] = key
         a[:dataset] ||= proc do
           base_ds = model.where(prkey_array.zip(key_array.map{|k| get_column_value(k)}))
@@ -221,6 +224,9 @@ module Sequel
         d = opts.merge(opts.fetch(:descendants, OPTS))
         descendants = d.fetch(:name, :descendants)
         d[:read_only] = true unless d.has_key?(:read_only)
+        d[:eager_grapher] = proc do |_|
+          raise Sequel::Error, "the #{descendants} association for #{self} does not support eager graphing"
+        end
         la = d[:level_alias] ||= :x_level_x
         d[:dataset] ||= proc do
           base_ds = model.where(key_array.zip(prkey_array.map{|k| get_column_value(k)}))

data/lib/sequel/plugins/static_cache.rb

@@ -211,18 +211,23 @@ module Sequel
         # Reload the cache for this model by retrieving all of the instances in the dataset
         # freezing them, and populating the cached array and hash.
         def load_cache
-          a = dataset.all
+          @all = load_static_cache_rows
           h = {}
-          a.each do |o|
+          @all.each do |o|
             o.errors.freeze
             h[o.pk.freeze] = o.freeze
           end
-          @all = a.freeze
           @cache = h.freeze
         end
 
         private
 
+        # Load the static cache rows from the database.
+        def load_static_cache_rows
+          ret = super if defined?(super)
+          ret || dataset.all.freeze
+        end
+
         # Return the frozen object with the given pk, or nil if no such object exists
         # in the cache, without issuing a database query.
         def primary_key_lookup(pk)