sequel 4.26.0 → 5.37.0

data/lib/sequel/plugins/optimistic_locking.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # This plugin implements a simple database-independent locking mechanism
@@ -9,11 +11,11 @@ module Sequel
     #   end
     #   p1 = Person[1]
     #   p2 = Person[1]
-    #   p1.update(:name=>'Jim') # works
-    #   p2.update(:name=>'Bob') # raises Sequel::Plugins::OptimisticLocking::Error
+    #   p1.update(name: 'Jim') # works
+    #   p2.update(name: 'Bob') # raises Sequel::Plugins::OptimisticLocking::Error
     #
     # In order for this plugin to work, you need to make sure that the database
-    # table has a lock_version column (or other column you name via the lock_column
+    # table has a +lock_version+ column (or other column you name via the lock_column
     # class level accessor) that defaults to 0.
     #
     # This plugin relies on the instance_filters plugin.

data/lib/sequel/plugins/pg_array_associations.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   extension :pg_array, :pg_array_ops
 
@@ -73,12 +75,12 @@ module Sequel
     module PgArrayAssociations
       # The AssociationReflection subclass for many_to_pg_array associations.
       class ManyToPgArrayAssociationReflection < Sequel::Model::Associations::AssociationReflection
-        Sequel::Model::Associations::ASSOCIATION_TYPES[:many_to_pg_array] = self
+        Sequel.synchronize{Sequel::Model::Associations::ASSOCIATION_TYPES[:many_to_pg_array] = self}
 
         def array_type
           cached_fetch(:array_type) do
             if (sch = associated_class.db_schema) && (s = sch[self[:key]]) && (t = s[:db_type])
-              t
+              t.sub(/\[\]\z/, '').freeze
             else
               :integer
             end
@@ -120,6 +122,13 @@ module Sequel
           nil
         end
 
+        FINALIZE_SETTINGS = superclass::FINALIZE_SETTINGS.merge(
+          :array_type=>:array_type
+        ).freeze
+        def finalize_settings
+          FINALIZE_SETTINGS
+        end
+
         # Handle silent failure of add/remove methods if raise_on_save_failure is false.
         def handle_silent_modification_failure?
           self[:raise_on_save_failure] == false
@@ -151,7 +160,7 @@ module Sequel
 
         def filter_by_associations_add_conditions_dataset_filter(ds)
           key = qualify(associated_class.table_name, self[:key])
-          ds.select{unnest(key)}.exclude(key=>nil)
+          ds.cross_join(Sequel.function(:unnest, key).as(:_smtopgaa_, [:_smtopgaa_key_])).exclude(key=>nil).select(:_smtopgaa_key_)
         end
         
         def filter_by_associations_conditions_key
@@ -175,12 +184,12 @@ module Sequel
 
       # The AssociationReflection subclass for pg_array_to_many associations.
       class PgArrayToManyAssociationReflection < Sequel::Model::Associations::AssociationReflection
-        Sequel::Model::Associations::ASSOCIATION_TYPES[:pg_array_to_many] = self
+        Sequel.synchronize{Sequel::Model::Associations::ASSOCIATION_TYPES[:pg_array_to_many] = self}
 
         def array_type
           cached_fetch(:array_type) do
             if (sch = self[:model].db_schema) && (s = sch[self[:key]]) && (t = s[:db_type])
-              t
+              t.sub(/\[\]\z/, '').freeze
             else
               :integer
             end
@@ -227,6 +236,15 @@ module Sequel
           nil
         end
 
+        FINALIZE_SETTINGS = superclass::FINALIZE_SETTINGS.merge(
+          :array_type=>:array_type,
+          :primary_key=>:primary_key,
+          :primary_key_method=>:primary_key_method
+        ).freeze
+        def finalize_settings
+          FINALIZE_SETTINGS
+        end
+
         # Handle silent failure of add/remove methods if raise_on_save_failure is false
         # and save_after_modify is true.
         def handle_silent_modification_failure?
@@ -279,6 +297,11 @@ module Sequel
         end
       end
 
+      # Add the pg_array extension to the database
+      def self.apply(model)
+        model.db.extension(:pg_array)
+      end
+
       module ClassMethods
         # Create a many_to_pg_array association, for the case where the associated
         # table contains the array with foreign keys pointing to the current table.
@@ -305,18 +328,22 @@ module Sequel
           opts[:key] = opts.default_key unless opts.has_key?(:key)
           key = opts[:key]
           key_column = opts[:key_column] ||= opts[:key]
-          opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
+          if opts[:uniq]
+            opts[:after_load] ||= []
+            opts[:after_load].unshift(:array_uniq!)
+          end
           opts[:dataset] ||= lambda do
             opts.associated_dataset.where(Sequel.pg_array_op(opts.predicate_key).contains(Sequel.pg_array([get_column_value(pk)], opts.array_type)))
           end
           opts[:eager_loader] ||= proc do |eo|
             id_map = eo[:id_map]
+            eo = Hash[eo]
+            eo[:loader] = false
 
-            eager_load_results(opts, Hash[eo].merge!(:loader=>false)) do |assoc_record|
-              if pks ||= assoc_record.get_column_value(key)
+            eager_load_results(opts, eo) do |assoc_record|
+              if pks = assoc_record.get_column_value(key)
                 pks.each do |pkv|
-                  next unless objects = id_map[pkv]
-                  objects.each do |object| 
+                  id_map[pkv].each do |object| 
                     object.associations[name].push(assoc_record)
                   end
                 end
@@ -348,7 +375,7 @@ module Sequel
 
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
+            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
             ds
           end
 
@@ -374,7 +401,9 @@ module Sequel
           end
 
           opts[:clearer] ||= proc do
-            opts.associated_dataset.where(Sequel.pg_array_op(key).contains([get_column_value(pk)])).update(key=>Sequel.function(:array_remove, key, get_column_value(pk)))
+            pk_value = get_column_value(pk)
+            db_type = opts.array_type
+            opts.associated_dataset.where(Sequel.pg_array_op(key).contains(Sequel.pg_array([pk_value], db_type))).update(key=>Sequel.function(:array_remove, key, Sequel.cast(pk_value, db_type)))
           end
         end
 
@@ -385,7 +414,10 @@ module Sequel
           key = opts[:key]
           key_column = opts[:key_column] ||= key
           opts[:eager_loader_key] = nil
-          opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
+          if opts[:uniq]
+            opts[:after_load] ||= []
+            opts[:after_load].unshift(:array_uniq!)
+          end
           opts[:dataset] ||= lambda do
             opts.associated_dataset.where(opts.predicate_key=>get_column_value(key).to_a)
           end
@@ -402,7 +434,9 @@ module Sequel
               end
             end
 
-            eager_load_results(opts, Hash[eo].merge!(:id_map=>id_map)) do |assoc_record|
+            eo = Hash[eo]
+            eo[:id_map] = id_map
+            eager_load_results(opts, eo) do |assoc_record|
               if objects = id_map[assoc_record.get_column_value(pkm)]
                 objects.each do |object| 
                   object.associations[name].push(assoc_record)
@@ -435,7 +469,7 @@ module Sequel
 
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
+            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
             ds
           end
 
@@ -489,14 +523,14 @@ module Sequel
           expr = case obj
           when Sequel::Model
             if (assoc_pks = obj.get_column_value(key)) && !assoc_pks.empty?
-              Sequel.expr(pk=>assoc_pks.to_a)
+              Sequel[pk=>assoc_pks.to_a]
             end
           when Array
             if (assoc_pks = obj.map{|o| o.get_column_value(key)}.flatten.compact.uniq) && !assoc_pks.empty?
-              Sequel.expr(pk=>assoc_pks)
+              Sequel[pk=>assoc_pks]
             end
           when Sequel::Dataset
-            Sequel.expr(pk=>obj.select{Sequel.pg_array_op(ref.qualify(obj.model.table_name, ref[:key_column])).unnest})
+            obj.select(ref.qualify(obj.model.table_name, ref[:key_column]).as(:key)).from_self.where{{pk=>any(:key)}}.select(1).exists
           end
           expr = Sequel::SQL::Constants::FALSE unless expr
           expr = add_association_filter_conditions(ref, obj, expr)

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -0,0 +1,348 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The pg_auto_constraint_validations plugin automatically converts some constraint
+    # violation exceptions that are raised by INSERT/UPDATE queries into validation
+    # failures.  This can allow for using the same error handling code for both
+    # regular validation errors (checked before attempting the INSERT/UPDATE), and
+    # constraint violations (raised during the INSERT/UPDATE).
+    #
+    # This handles the following constraint violations:
+    #
+    # * NOT NULL
+    # * CHECK
+    # * UNIQUE (except expression/functional indexes)
+    # * FOREIGN KEY (both referencing and referenced by)
+    #
+    # If the plugin cannot convert the constraint violation error to a validation
+    # error, it just reraises the initial exception, so this should not cause
+    # problems if the plugin doesn't know how to convert the exception.
+    #
+    # 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 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
+    # it will be a no-op.
+    #
+    # Example:
+    #
+    #   album = Album.new(:artist_id=>1) # Assume no such artist exists
+    #   begin
+    #     album.save
+    #   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:
+    #
+    #   # Make all model subclasses automatically convert constraint violations
+    #   # to validation failures (called before loading subclasses)
+    #   Sequel::Model.plugin :pg_auto_constraint_validations
+    #
+    #   # Make the Album class automatically convert constraint violations
+    #   # to validation failures
+    #   Album.plugin :pg_auto_constraint_validations
+    module PgAutoConstraintValidations
+      (
+      # The default error messages for each constraint violation type.
+      DEFAULT_ERROR_MESSAGES = {
+        :not_null=>"is not present",
+        :check=>"is invalid",
+        :unique=>'is already taken',
+        :foreign_key=>'is invalid',
+        :referenced_by=>'cannot be changed currently'
+      }.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
+        # Hash of metadata checked when an instance attempts to convert a constraint
+        # violation into a validation failure.
+        attr_reader :pg_auto_constraint_validations
+
+        # Hash of error messages keyed by constraint type symbol to use in the
+        # 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, :@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
+        # table, and keys in the current table referenced by foreign keys in other
+        # tables.  Store this information so that if a constraint violation occurs,
+        # all necessary metadata is already available in the model, so a query is
+        # not required at runtime.  This is both for performance and because in
+        # general after the constraint violation failure you will be inside a
+        # failed transaction and not able to execute queries.
+        def setup_pg_auto_constraint_validations
+          return unless @dataset
+
+          case @dataset.first_source_table
+          when Symbol, String, SQL::Identifier, SQL::QualifiedIdentifier
+           convert_errors = db.respond_to?(:error_info)
+          end
+
+          unless convert_errors
+            # Might be a table returning function or subquery, skip handling those.
+            # Might have db not support error_info, skip handling that. 
+            @pg_auto_constraint_validations = nil
+            return
+          end
+
+          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 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
+
+          @pg_auto_constraint_validations = metadata
+          nil
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Yield to the given block, and if a Sequel::ConstraintViolation is raised, try
+        # to convert it to a Sequel::ValidationFailed error using the PostgreSQL error
+        # metadata.
+        def check_pg_constraint_error(ds)
+          yield
+        rescue Sequel::ConstraintViolation => e
+          begin
+            unless cv_info = model.pg_auto_constraint_validations
+              # Necessary metadata does not exist, just reraise the exception.
+              raise e
+            end
+
+            info = ds.db.error_info(e)
+            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
+
+            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
+              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
+          rescue
+            # If there is an error trying to conver the constraint violation
+            # into a validation failure, it's best to just raise the constraint
+            # violation.  This can make debugging the above block of code more
+            # difficult.
+            raise e
+          else
+            unless skip_schema_table_check
+              # The constraint violation could be caused by a trigger modifying 
+              # a different table.  Check that the error schema and table
+              # match the model's schema and table, or clear the validation error
+              # that was set above.
+              if schema != cv_info[:schema] || table != cv_info[:table]
+                errors.clear
+              end
+            end
+
+            if errors.empty?
+              # If we weren't able to parse the constraint violation metadata and
+              # convert it to an appropriate validation failure, or the schema/table
+              # didn't match, then raise the constraint violation.
+              raise e
+            end
+
+            # Integrate with error_splitter plugin to split any multi-column errors
+            # and add them as separate single column errors
+            if respond_to?(:split_validation_errors, true)
+              split_validation_errors(errors)
+            end
+
+            vf = ValidationFailed.new(self)
+            vf.set_backtrace(e.backtrace)
+            vf.wrapped_exception = e
+            raise vf
+          end
+        end
+
+        # If there is a single column instead of an array of columns, add the error
+        # for the column, otherwise add the error for the array of columns.
+        def add_pg_constraint_validation_error(column, message)
+          column = column.first if column.length == 1 
+          errors.add(column, message)
+        end
+
+        # Convert PostgreSQL constraint errors when inserting.
+        def _insert_raw(ds)
+          check_pg_constraint_error(ds){super}
+        end
+
+        # Convert PostgreSQL constraint errors when inserting.
+        def _insert_select_raw(ds)
+          check_pg_constraint_error(ds){super}
+        end
+
+        # Convert PostgreSQL constraint errors when updating.
+        def _update_without_checking(_)
+          check_pg_constraint_error(_update_dataset){super}
+        end
+      end
+    end
+  end
+end
+