sequel 4.36.0 → 5.61.0

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -0,0 +1,350 @@
+# 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
+              # :nocov:
+              case e
+              # :nocov:
+              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
+

data/lib/sequel/plugins/pg_row.rb

@@ -41,64 +41,21 @@ module Sequel
     #
     #   Address.register_row_type
     #
-    # Note that automatic conversion only works with the native postgres adapter.
-    # For other adapters that connect to PostgreSQL, you need to call the conversion
-    # proc manually.
-    #
     # In addition to returning row-valued/composite types as instances of Sequel::Model,
     # this also lets you use model instances in datasets when inserting, updating, and
     # filtering:
     #
-    #   DB[:company].insert(:name=>'MS', :address=>
-    #     Address.load(:street=>'123 Foo St', :city=>'Bar Town', :zip=>'12345'))
+    #   DB[:company].insert(name: 'MS', address:
+    #     Address.load(street: '123 Foo St', city: 'Bar Town', zip: '12345'))
     module PgRow
       # When loading the extension, make sure the database has the pg_row extension
       # loaded, load the custom database extensions, and automatically register the
       # row type if the model has a dataset.
       def self.configure(model)
-        model.db.extension(:pg_row)
-        model.db.extend(DatabaseMethods)
+        model.db.extension(:pg_row, :_model_pg_row)
         model.register_row_type if model.instance_variable_get(:@dataset)
       end
 
-      module DatabaseMethods
-        ESCAPE_RE = /("|\\)/.freeze
-        ESCAPE_REPLACEMENT = '\\\\\1'.freeze
-        COMMA = ','
-
-        # Handle Sequel::Model instances in bound variables.
-        def bound_variable_arg(arg, conn)
-          case arg
-          when Sequel::Model
-            "(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(COMMA)})"
-          else
-            super
-          end
-        end
-
-        # If a Sequel::Model instance is given, return it as-is
-        # instead of attempting to convert it.
-        def row_type(db_type, v)
-          if v.is_a?(Sequel::Model)
-            v
-          else
-            super
-          end
-        end
-
-        private
-
-        # Handle Sequel::Model instances in bound variable arrays.
-        def bound_variable_array(arg)
-          case arg
-          when Sequel::Model
-            "\"(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(COMMA).gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)})\""
-          else
-            super
-          end
-        end
-      end
-
       module ClassMethods
         # Register the model's row type with the database.
         def register_row_type
@@ -109,14 +66,11 @@ module Sequel
       end
 
       module InstanceMethods
-        ROW = 'ROW'.freeze
-        CAST = '::'.freeze
-
         # Literalize the model instance and append it to the sql.
         def sql_literal_append(ds, sql)
-          sql << ROW
+          sql << 'ROW'
           ds.literal_append(sql, values.values_at(*columns))
-          sql << CAST
+          sql << '::'
           ds.quote_schema_table_append(sql, model.dataset.first_source_table)
         end
       end

data/lib/sequel/plugins/prepared_statements.rb

@@ -1,26 +1,13 @@
 # frozen-string-literal: true
 
 module Sequel
-  class Model
-    module InstanceMethods
-      # Whether prepared statements should be used for the given type of query
-      # (:insert, :insert_select, :refresh, :update, or :delete).  True by default,
-      # can be overridden in other plugins to disallow prepared statements for
-      # specific types of queries.
-      def use_prepared_statements_for?(type)
-        true
-      end
-    end
-  end
-
   module Plugins
     # The prepared_statements plugin modifies the model to use prepared statements for
-    # instance level deletes and saves, as well as class level lookups by
-    # primary key.
+    # instance level inserts and updates.
     #
     # Note that this plugin is unsafe in some circumstances, as it can allow up to
     # 2^N prepared statements to be created for each type of insert and update query, where
-    # N is the number of colums in the table. It is recommended that you use the
+    # N is the number of columns in the table. It is recommended that you use the
     # +prepared_statements_safe+ plugin in addition to this plugin to reduce the number
     # of prepared statements that can be created, unless you tightly control how your
     # model instances are saved.
@@ -43,22 +30,20 @@ module Sequel
 
       # Setup the datastructure used to hold the prepared statements in the model.
       def self.apply(model)
-        model.instance_variable_set(:@prepared_statements, :insert=>{}, :insert_select=>{}, :update=>{}, :lookup_sql=>{}, :fixed=>{})
+        model.instance_variable_set(:@prepared_statements, {:insert=>{}, :insert_select=>{}, :update=>{}}.freeze)
       end
 
       module ClassMethods
-        Plugins.inherited_instance_variables(self, :@prepared_statements=>lambda{|v| {:insert=>{}, :insert_select=>{}, :update=>{}, :lookup_sql=>{}, :fixed=>{}}})
+        Plugins.inherited_instance_variables(self, :@prepared_statements=>lambda{|v| {:insert=>{}, :insert_select=>{}, :update=>{}}.freeze})
 
         private
 
         # Create a prepared statement, but modify the SQL used so that the model's columns are explicitly
         # selected instead of using *, assuming that the dataset selects from a single table.
         def prepare_explicit_statement(ds, type, vals=OPTS)
-          f = ds.opts[:from]
-          meth = type == :insert_select ? :returning : :select
-          s = ds.opts[meth]
-          if f && f.length == 1 && !ds.opts[:join] && (!s || s.empty?)
-            ds = ds.send(meth, *columns.map{|c| Sequel.identifier(c)})
+          s = ds.opts[:returning]
+          if !s || s.empty?
+            ds = ds.returning(*columns.map{|c| Sequel.identifier(c)})
           end 
           
           prepare_statement(ds, type, vals)
@@ -67,19 +52,12 @@ module Sequel
         # Create a prepared statement based on the given dataset with a unique name for the given
         # type of query and values.
         def prepare_statement(ds, type, vals=OPTS)
-          ps = ds.prepare(type, :"smpsp_#{NEXT.call}", vals)
-          ps.log_sql = true
-          ps
+          ds.clone(:log_sql=>true).prepare(type, :"smpsp_#{NEXT.call}", vals)
         end
 
         # Return a sorted array of columns for use as a hash key.
         def prepared_columns(cols)
-          RUBY_VERSION >= '1.9' ? cols.sort : cols.sort_by(&:to_s)
-        end
-
-        # Return a prepared statement that can be used to delete a row from this model's dataset.
-        def prepared_delete
-          cached_prepared_statement(:fixed, :delete){prepare_statement(filter(prepared_statement_key_array(primary_key)), :delete)}
+          cols.sort
         end
 
         # Return a prepared statement that can be used to insert a row using the given columns.
@@ -90,19 +68,7 @@ module Sequel
         # Return a prepared statement that can be used to insert a row using the given columns
         # and return that column values for the row created.
         def prepared_insert_select(cols)
-          if dataset.supports_insert_select?
-            cached_prepared_statement(:insert_select, prepared_columns(cols)){prepare_explicit_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)), :insert_select, prepared_statement_key_hash(cols))}
-          end
-        end
-
-        # Return a prepared statement that can be used to lookup a row solely based on the primary key.
-        def prepared_lookup
-          cached_prepared_statement(:fixed, :lookup){prepare_explicit_statement(filter(prepared_statement_key_array(primary_key)), :first)}
-        end
-
-        # Return a prepared statement that can be used to refresh a row to get new column values after insertion.
-        def prepared_refresh
-          cached_prepared_statement(:fixed, :refresh){prepare_explicit_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)).filter(prepared_statement_key_array(primary_key)), :first)}
+          cached_prepared_statement(:insert_select, prepared_columns(cols)){prepare_explicit_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)), :insert_select, prepared_statement_key_hash(cols))}
         end
 
         # Return an array of two element arrays with the column symbol as the first entry and the
@@ -129,12 +95,7 @@ module Sequel
 
         # Return a prepared statement that can be used to update row using the given columns.
         def prepared_update(cols)
-          cached_prepared_statement(:update, prepared_columns(cols)){prepare_statement(filter(prepared_statement_key_array(primary_key)), :update, prepared_statement_key_hash(cols))}
-        end
-
-        # Use a prepared statement to query the database for the row matching the given primary key.
-        def primary_key_lookup(pk)
-          prepared_lookup.call(primary_key_hash(pk))
+          cached_prepared_statement(:update, prepared_columns(cols)){prepare_statement(where(prepared_statement_key_array(primary_key)), :update, prepared_statement_key_hash(cols))}
         end
 
         # If a prepared statement has already been cached for the given type and subtype,
@@ -149,24 +110,21 @@ module Sequel
           ps = yield
           Sequel.synchronize{h[subtype] = ps}
         end
+
+        # Whether to use prepared statements for lookups by primary key.  True if the default
+        # primary key lookup isn't optimized.
+        def use_prepared_statements_for_pk_lookup?
+          !@fast_pk_lookup_sql && !dataset.joined_dataset?
+        end
       end
 
       module InstanceMethods
         private
 
-        # Use a prepared statement to delete the row.
-        def _delete_without_checking
-          if use_prepared_statements_for?(:delete)
-            model.send(:prepared_delete).call(pk_hash)
-          else
-            super
-          end
-        end
-
         # Use a prepared statement to insert the values into the model's dataset.
         def _insert_raw(ds)
           if use_prepared_statements_for?(:insert)
-            model.send(:prepared_insert, @values.keys).call(@values)
+            _set_prepared_statement_server(model.send(:prepared_insert, @values.keys)).call(@values)
           else
             super
           end
@@ -176,29 +134,59 @@ module Sequel
         # and return the new column values.
         def _insert_select_raw(ds)
           if use_prepared_statements_for?(:insert_select)
-            if ps = model.send(:prepared_insert_select, @values.keys)
-              ps.call(@values)
-            end
+            _set_prepared_statement_server(model.send(:prepared_insert_select, @values.keys)).call(@values)
           else
             super
           end
         end
 
-        # Use a prepared statement to refresh this model's column values.
-        def _refresh_get(ds)
-          if use_prepared_statements_for?(:refresh)
-            model.send(:prepared_refresh).call(pk_hash)
+        # Use a prepared statement to update this model's columns in the database.
+        def _update_without_checking(columns)
+          if use_prepared_statements_for?(:update)
+            _set_prepared_statement_server(model.send(:prepared_update, columns.keys)).call(columns.merge(pk_hash))
           else
             super
           end
         end
 
-        # Use a prepared statement to update this model's columns in the database.
-        def _update_without_checking(columns)
-          if use_prepared_statements_for?(:update)
-            model.send(:prepared_update, columns.keys).call(Hash[columns].merge!(pk_hash))
+        # If a server is set for the instance, return a prepared statement that will use that server.
+        def _set_prepared_statement_server(ps)
+          if @server
+            ps.server(@server)
           else
-            super
+            ps
+          end
+        end
+
+        # Whether prepared statements should be used for the given type of query
+        # (:insert, :insert_select, :update).  True by default,
+        # can be overridden in other plugins to disallow prepared statements for
+        # specific types of queries.
+        def use_prepared_statements_for?(type)
+          if defined?(super)
+            result = super
+            return result unless result.nil?
+          end
+
+          case type
+          when :insert, :update
+            true
+          when :insert_select
+            # SQLite RETURNING support has a bug that doesn't allow for committing transactions
+            # when a prepared statement with RETURNING has been used on the connection:
+            #
+            #   SQLite3::BusyException: cannot commit transaction - SQL statements in progress: COMMIT
+            #
+            # Disabling usage of prepared statements for insert_select on SQLite seems to be the
+            # simplest way to workaround the problem.
+            db.database_type != :sqlite
+          # :nocov:
+          when :delete, :refresh
+            Sequel::Deprecation.deprecate("The :delete and :refresh prepared statement types", "There should be no need to check if these types are supported")
+            false
+          # :nocov:
+          else
+            raise Error, "unsupported type used: #{type.inspect}"
           end
         end
       end

data/lib/sequel/plugins/prepared_statements_safe.rb

@@ -28,7 +28,7 @@ module Sequel
       end
 
       module ClassMethods
-        # A hash with column symbol keys and default values.  Instance's
+        # A hash with column symbol keys and default values.  Instance
         # values are merged into this hash before creating to reduce the
         # number of free columns (columns that may or may not be present
         # in the INSERT statement), as the number of prepared statements
@@ -38,6 +38,13 @@ module Sequel
         Plugins.inherited_instance_variables(self, :@prepared_statements_column_defaults=>:dup)
         Plugins.after_set_dataset(self, :set_prepared_statements_column_defaults)
 
+        # Freeze the prepared statements column defaults when freezing the model class.
+        def freeze
+          @prepared_statements_column_defaults.freeze if @prepared_statements_column_defaults
+
+          super
+        end
+
         private
 
         # Set the column defaults based on the database schema.  All columns
@@ -59,9 +66,7 @@ module Sequel
         # Merge the current values into the default values to reduce the number
         # of free columns.
         def before_create
-          if v = model.prepared_statements_column_defaults
-            @values = Hash[v].merge!(values)
-          end
+          @values = model.prepared_statements_column_defaults.merge(@values)
           super
         end