sequel 5.33.0 → 5.58.0

data/lib/sequel/plugins/lazy_attributes.rb

@@ -52,7 +52,9 @@ module Sequel
           unless select = dataset.opts[:select]
             select = dataset.columns.map{|c| Sequel.qualify(dataset.first_source, c)}
           end
+          db_schema = @db_schema
           set_dataset(dataset.select(*select.reject{|c| attrs.include?(dataset.send(:_hash_key_symbol, c))}))
+          @db_schema = db_schema
           attrs.each{|a| define_lazy_attribute_getter(a)}
         end
         
@@ -71,6 +73,7 @@ module Sequel
                 super()
               end
             end
+            alias_method(a, a)
           end
         end
       end
@@ -98,7 +101,7 @@ module Sequel
           end
 
           if retrieved_with
-            raise(Error, "Invalid primary key column for #{model}: #{pkc.inspect}") unless primary_key = model.primary_key
+            primary_key = model.primary_key
             composite_pk = true if primary_key.is_a?(Array)
             id_map = {}
             retrieved_with.each{|o| id_map[o.pk] = o unless o.values.has_key?(a) || o.frozen?}

data/lib/sequel/plugins/many_through_many.rb

@@ -123,16 +123,25 @@ module Sequel
           nil
         end
 
+        # Whether a separate query should be used for each join table.
+        def separate_query_per_table?
+          self[:separate_query_per_table]
+        end
+
         private
 
         def _associated_dataset
           ds = associated_class
-          (reverse_edges + [final_reverse_edge]).each do |t|
-            h = {:qualify=>:deep}
-            if t[:alias] != t[:table]
-              h[:table_alias] = t[:alias]
+          if separate_query_per_table?
+            ds = ds.dataset
+          else
+            (reverse_edges + [final_reverse_edge]).each do |t|
+              h = {:qualify=>:deep}
+              if t[:alias] != t[:table]
+                h[:table_alias] = t[:alias]
+              end
+              ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), h)
             end
-            ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), h)
           end
           ds
         end
@@ -208,6 +217,7 @@ module Sequel
         #            :right (last array element) :: The key joining the table to the next table. Can use an
         #                                           array of symbols for a composite key association.
         #            If a hash is provided, the following keys are respected when using eager_graph:
+        #            :db :: The Database containing the table.  This changes lookup to use a separate query for each join table.
         #            :block :: A proc to use as the block argument to join.
         #            :conditions :: Extra conditions to add to the JOIN ON clause.  Must be a hash or array of two pairs.
         #            :join_type :: The join type to use for the join, defaults to :left_outer.
@@ -233,32 +243,121 @@ module Sequel
             opts[:after_load].unshift(:array_uniq!)
           end
           opts[:cartesian_product_number] ||= one_through_many ? 0 : 2
-          opts[:through] = opts[:through].map do |e|
+          separate_query_per_table = false
+          through = opts[:through] = opts[:through].map do |e|
             case e
             when Array
               raise(Error, "array elements of the through option/argument for many_through_many associations must have at least three elements") unless e.length == 3
               {:table=>e[0], :left=>e[1], :right=>e[2]}
             when Hash
               raise(Error, "hash elements of the through option/argument for many_through_many associations must contain :table, :left, and :right keys") unless e[:table] && e[:left] && e[:right]
+              separate_query_per_table = true if e[:db]
               e
             else
               raise(Error, "the through option/argument for many_through_many associations must be an enumerable of arrays or hashes")
             end
           end
+          opts[:separate_query_per_table] = separate_query_per_table
 
           left_key = opts[:left_key] = opts[:through].first[:left]
           opts[:left_keys] = Array(left_key)
-          opts[:uses_left_composite_keys] = left_key.is_a?(Array)
+          uses_lcks = opts[:uses_left_composite_keys] = left_key.is_a?(Array)
           left_pk = (opts[:left_primary_key] ||= self.primary_key)
           raise(Error, "no primary key specified for #{inspect}") unless left_pk
           opts[:eager_loader_key] = left_pk unless opts.has_key?(:eager_loader_key)
           opts[:left_primary_keys] = Array(left_pk)
           lpkc = opts[:left_primary_key_column] ||= left_pk
           lpkcs = opts[:left_primary_key_columns] ||= Array(lpkc)
-          opts[:dataset] ||= opts.association_dataset_proc
 
           opts[:left_key_alias] ||= opts.default_associated_key_alias
-          opts[:eager_loader] ||= opts.method(:default_eager_loader)
+          if separate_query_per_table
+            opts[:use_placeholder_loader] = false
+            opts[:allow_eager_graph] = false
+            opts[:allow_filtering_by] = false
+            opts[:eager_limit_strategy] = nil
+
+            opts[:dataset] ||= proc do |r|
+              def_db = r.associated_class.db
+              vals = uses_lcks ? [lpkcs.map{|k| get_column_value(k)}] : get_column_value(left_pk)
+
+              has_results = through.each do |edge|
+                ds = (edge[:db] || def_db).from(edge[:table]).where(edge[:left]=>vals)
+                ds = ds.where(edge[:conditions]) if edge[:conditions]
+                right = edge[:right]
+                vals = ds.select_map(right)
+                if right.is_a?(Array)
+                  vals.delete_if{|v| v.any?(&:nil?)}
+                else
+                  vals.delete(nil)
+                end
+                break if vals.empty?
+              end
+
+              ds = r.associated_dataset.where(opts.right_primary_key=>vals)
+              ds = ds.clone(:no_results=>true) unless has_results
+              ds
+            end
+            opts[:eager_loader] ||= proc do |eo|
+              h = eo[:id_map]
+              assign_singular = opts.assign_singular?
+              uses_rcks = opts.right_primary_key.is_a?(Array)
+              rpk = uses_rcks ? opts.right_primary_keys : opts.right_primary_key
+              name = opts[:name]
+              def_db = opts.associated_class.db
+              join_map = h
+
+              run_query = through.each do |edge|
+                ds = (edge[:db] || def_db).from(edge[:table])
+                ds = ds.where(edge[:conditions]) if edge[:conditions]
+                left = edge[:left]
+                right = edge[:right]
+                prev_map = join_map
+                join_map = ds.where(left=>join_map.keys).select_hash_groups(right, left)
+                if right.is_a?(Array)
+                  join_map.delete_if{|v,| v.any?(&:nil?)}
+                else
+                  join_map.delete(nil)
+                end
+                break if join_map.empty?
+                join_map.each_value do |vs|
+                  vs.replace(vs.flat_map{|v| prev_map[v]})
+                  vs.uniq!
+                end
+              end
+
+              eo = Hash[eo]
+
+              if run_query
+                eo[:loader] = false
+                eo[:right_keys] = join_map.keys
+              else
+                eo[:no_results] = true
+              end
+
+              opts[:model].eager_load_results(opts, eo) do |assoc_record|
+                rpkv = if uses_rcks
+                  assoc_record.values.values_at(*rpk)
+                else
+                  assoc_record.values[rpk]
+                end
+
+                objects = join_map[rpkv]
+
+                if assign_singular
+                  objects.each do |object|
+                    object.associations[name] ||= assoc_record
+                  end
+                else
+                  objects.each do |object|
+                    object.associations[name].push(assoc_record)
+                  end
+                end
+              end
+            end
+          else
+            opts[:dataset] ||= opts.association_dataset_proc
+            opts[:eager_loader] ||= opts.method(:default_eager_loader)
+          end
 
           join_type = opts[:graph_join_type]
           select = opts[:graph_select]

data/lib/sequel/plugins/nested_attributes.rb

@@ -108,9 +108,10 @@ module Sequel
         #            array of the allowable fields.
         # :limit :: For *_to_many associations, a limit on the number of records
         #           that will be processed, to prevent denial of service attacks.
-        # :reject_if :: A proc that is given each attribute hash before it is
+        # :reject_if :: A proc that is called with each attribute hash before it is
         #               passed to its associated object. If the proc returns a truthy
         #               value, the attribute hash is ignored.
+        # :reject_nil :: Ignore nil objects passed to nested attributes setter methods.
         # :remove :: Allow disassociation of nested records (can remove the associated
         #            object from the parent object, but not destroy the associated object).
         # :require_modification :: Whether to require modification of nested objects when
@@ -145,9 +146,12 @@ module Sequel
         # class.
         def def_nested_attribute_method(reflection)
           @nested_attributes_module.class_eval do
-            define_method("#{reflection[:name]}_attributes=") do |v|
-              set_nested_attributes(reflection[:name], v)
+            meth = :"#{reflection[:name]}_attributes="
+            assoc = reflection[:name]
+            define_method(meth) do |v|
+              set_nested_attributes(assoc, v)
             end
+            alias_method meth, meth
           end
         end
       end
@@ -159,6 +163,7 @@ module Sequel
         def set_nested_attributes(assoc, obj, opts=OPTS)
           raise(Error, "no association named #{assoc} for #{model.inspect}") unless ref = model.association_reflection(assoc)
           raise(Error, "nested attributes are not enabled for association #{assoc} for #{model.inspect}") unless meta = ref[:nested_attributes]
+          return if obj.nil? && meta[:reject_nil]
           meta = meta.merge(opts)
           meta[:reflection] = ref
           if ref.returns_array?

data/lib/sequel/plugins/pg_array_associations.rb

@@ -341,10 +341,9 @@ module Sequel
             eo[:loader] = false
 
             eager_load_results(opts, eo) do |assoc_record|
-              if pks ||= assoc_record.get_column_value(key)
+              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
@@ -385,26 +384,32 @@ module Sequel
           save_opts = {:validate=>opts[:validate]}
           save_opts[:raise_on_failure] = opts[:raise_on_save_failure] != false
 
-          opts[:adder] ||= proc do |o|
-            if array = o.get_column_value(key)
-              array << get_column_value(pk)
-            else
-              o.set_column_value("#{key}=", Sequel.pg_array([get_column_value(pk)], opts.array_type))
+          unless opts.has_key?(:adder)
+            opts[:adder] = proc do |o|
+              if array = o.get_column_value(key)
+                array << get_column_value(pk)
+              else
+                o.set_column_value("#{key}=", Sequel.pg_array([get_column_value(pk)], opts.array_type))
+              end
+              o.save(save_opts)
             end
-            o.save(save_opts)
           end
-  
-          opts[:remover] ||= proc do |o|
-            if (array = o.get_column_value(key)) && !array.empty?
-              array.delete(get_column_value(pk))
-              o.save(save_opts)
+    
+          unless opts.has_key?(:remover)
+            opts[:remover] = proc do |o|
+              if (array = o.get_column_value(key)) && !array.empty?
+                array.delete(get_column_value(pk))
+                o.save(save_opts)
+              end
             end
           end
 
-          opts[:clearer] ||= proc do
-            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)))
+          unless opts.has_key?(:clearer)
+            opts[:clearer] = proc do
+              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
         end
 
@@ -427,10 +432,12 @@ module Sequel
             id_map = {}
             pkm = opts.primary_key_method
 
-            rows.each do |object|
-              if associated_pks = object.get_column_value(key)
-                associated_pks.each do |apk|
-                  (id_map[apk] ||= []) << object
+            Sequel.synchronize_with(eo[:mutex]) do
+              rows.each do |object|
+                if associated_pks = object.get_column_value(key)
+                  associated_pks.each do |apk|
+                    (id_map[apk] ||= []) << object
+                  end
                 end
               end
             end
@@ -485,30 +492,36 @@ module Sequel
             end
           end
 
-          opts[:adder] ||= proc do |o|
-            opk = o.get_column_value(opts.primary_key) 
-            if array = get_column_value(key)
-              modified!(key)
-              array << opk
-            else
-              set_column_value("#{key}=", Sequel.pg_array([opk], opts.array_type))
+          unless opts.has_key?(:adder)
+            opts[:adder] = proc do |o|
+              opk = o.get_column_value(opts.primary_key) 
+              if array = get_column_value(key)
+                modified!(key)
+                array << opk
+              else
+                set_column_value("#{key}=", Sequel.pg_array([opk], opts.array_type))
+              end
+              save_after_modify.call(self) if save_after_modify
             end
-            save_after_modify.call(self) if save_after_modify
           end
-  
-          opts[:remover] ||= proc do |o|
-            if (array = get_column_value(key)) && !array.empty?
-              modified!(key)
-              array.delete(o.get_column_value(opts.primary_key))
-              save_after_modify.call(self) if save_after_modify
+    
+          unless opts.has_key?(:remover)
+            opts[:remover] = proc do |o|
+              if (array = get_column_value(key)) && !array.empty?
+                modified!(key)
+                array.delete(o.get_column_value(opts.primary_key))
+                save_after_modify.call(self) if save_after_modify
+              end
             end
           end
 
-          opts[:clearer] ||= proc do
-            if (array = get_column_value(key)) && !array.empty?
-              modified!(key)
-              array.clear
-              save_after_modify.call(self) if save_after_modify
+          unless opts.has_key?(:clearer)
+            opts[:clearer] = proc do
+              if (array = get_column_value(key)) && !array.empty?
+                modified!(key)
+                array.clear
+                save_after_modify.call(self) if save_after_modify
+              end
             end
           end
         end
@@ -521,7 +534,9 @@ module Sequel
         def many_to_pg_array_association_filter_expression(op, ref, obj)
           pk = ref.qualify(model.table_name, ref.primary_key)
           key = ref[:key]
+          # :nocov:
           expr = case obj
+          # :nocov:
           when Sequel::Model
             if (assoc_pks = obj.get_column_value(key)) && !assoc_pks.empty?
               Sequel[pk=>assoc_pks.to_a]
@@ -541,7 +556,9 @@ module Sequel
         # Support filtering by pg_array_to_many associations using a subquery.
         def pg_array_to_many_association_filter_expression(op, ref, obj)
           key = ref.qualify(model.table_name, ref[:key_column])
+          # :nocov:
           expr = case obj
+          # :nocov:
           when Sequel::Model
             if pkv = obj.get_column_value(ref.primary_key_method)
               Sequel.pg_array_op(key).contains(Sequel.pg_array([pkv], ref.array_type))

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -250,7 +250,9 @@ module Sequel
             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])

data/lib/sequel/plugins/prepared_statements.rb

@@ -41,11 +41,9 @@ module Sequel
         # 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.public_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)
@@ -70,9 +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
+          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
@@ -138,9 +134,7 @@ 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)
-              _set_prepared_statement_server(ps).call(@values)
-            end
+            _set_prepared_statement_server(model.send(:prepared_insert_select, @values.keys)).call(@values)
           else
             super
           end
@@ -175,8 +169,17 @@ module Sequel
           end
 
           case type
-          when :insert, :insert_select, :update
+          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")

data/lib/sequel/plugins/prepared_statements_safe.rb

@@ -66,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 = v.merge(values)
-          end
+          @values = model.prepared_statements_column_defaults.merge(@values)
           super
         end
 

data/lib/sequel/plugins/rcte_tree.rb

@@ -170,11 +170,13 @@ module Sequel
           id_map = eo[:id_map]
           parent_map = {}
           children_map = {}
-          eo[:rows].each do |obj|
-            parent_map[prkey_conv[obj]] = obj
-            (children_map[key_conv[obj]] ||= []) << obj
-            obj.associations[ancestors] = []
-            obj.associations[parent] = nil
+          Sequel.synchronize_with(eo[:mutex]) do
+            eo[:rows].each do |obj|
+              parent_map[prkey_conv[obj]] = obj
+              (children_map[key_conv[obj]] ||= []) << obj
+              obj.associations[ancestors] = []
+              obj.associations[parent] = nil
+            end
           end
           r = model.association_reflection(ancestors)
           base_case = model.where(prkey=>id_map.keys).
@@ -192,29 +194,27 @@ module Sequel
              :args=>((key_aliases + col_aliases) if col_aliases))
           ds = r.apply_eager_dataset_changes(ds)
           ds = ds.select_append(ka) unless ds.opts[:select] == nil
-          model.eager_load_results(r, eo.merge(:loader=>false, :initalize_rows=>false, :dataset=>ds, :id_map=>nil)) do |obj|
+          model.eager_load_results(r, eo.merge(:loader=>false, :initialize_rows=>false, :dataset=>ds, :id_map=>nil)) do |obj|
             opk = prkey_conv[obj]
-            if parent_map.has_key?(opk)
-              if idm_obj = parent_map[opk]
-                key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
-                obj = idm_obj
-              end
+            if idm_obj = parent_map[opk]
+              key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
+              obj = idm_obj
             else
               obj.associations[parent] = nil
               parent_map[opk] = obj
               (children_map[key_conv[obj]] ||= []) << obj
             end
             
-            if roots = id_map[extract_key_alias[obj]]
-              roots.each do |root|
-                root.associations[ancestors] << obj
-              end
+            id_map[extract_key_alias[obj]].each do |root|
+              root.associations[ancestors] << obj
             end
           end
-          parent_map.each do |parent_id, obj|
-            if children = children_map[parent_id]
-              children.each do |child|
-                child.associations[parent] = obj
+          Sequel.synchronize_with(eo[:mutex]) do
+            parent_map.each do |parent_id, obj|
+              if children = children_map[parent_id]
+                children.each do |child|
+                  child.associations[parent] = obj
+                end
               end
             end
           end
@@ -272,10 +272,12 @@ module Sequel
           associations = eo[:associations]
           parent_map = {}
           children_map = {}
-          eo[:rows].each do |obj|
-            parent_map[prkey_conv[obj]] = obj
-            obj.associations[descendants] = []
-            obj.associations[childrena] = []
+          Sequel.synchronize_with(eo[:mutex]) do
+            eo[:rows].each do |obj|
+              parent_map[prkey_conv[obj]] = obj
+              obj.associations[descendants] = []
+              obj.associations[childrena] = []
+            end
           end
           r = model.association_reflection(descendants)
           base_case = model.where(key=>id_map.keys).
@@ -300,17 +302,15 @@ module Sequel
               :args=>((key_aliases + col_aliases + (level ? [la] : [])) if col_aliases))
           ds = r.apply_eager_dataset_changes(ds)
           ds = ds.select_append(ka) unless ds.opts[:select] == nil
-          model.eager_load_results(r, eo.merge(:loader=>false, :initalize_rows=>false, :dataset=>ds, :id_map=>nil, :associations=>OPTS)) do |obj|
+          model.eager_load_results(r, eo.merge(:loader=>false, :initialize_rows=>false, :dataset=>ds, :id_map=>nil, :associations=>OPTS)) do |obj|
             if level
               no_cache = no_cache_level == obj.values.delete(la)
             end
             
             opk = prkey_conv[obj]
-            if parent_map.has_key?(opk)
-              if idm_obj = parent_map[opk]
-                key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
-                obj = idm_obj
-              end
+            if idm_obj = parent_map[opk]
+              key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
+              obj = idm_obj
             else
               obj.associations[childrena] = [] unless no_cache
               parent_map[opk] = obj
@@ -322,12 +322,14 @@ module Sequel
             
             (children_map[key_conv[obj]] ||= []) << obj
           end
-          children_map.each do |parent_id, objs|
-            objs = objs.uniq
-            parent_obj = parent_map[parent_id]
-            parent_obj.associations[childrena] = objs
-            objs.each do |obj|
-              obj.associations[parent] = parent_obj
+          Sequel.synchronize_with(eo[:mutex]) do
+            children_map.each do |parent_id, objs|
+              objs = objs.uniq
+              parent_obj = parent_map[parent_id]
+              parent_obj.associations[childrena] = objs
+              objs.each do |obj|
+                obj.associations[parent] = parent_obj
+              end
             end
           end
         end

data/lib/sequel/plugins/serialization.rb

@@ -127,7 +127,7 @@ module Sequel
         def serialize_attributes(format, *columns)
           if format.is_a?(Symbol)
             unless format = Sequel.synchronize{REGISTERED_FORMATS[format]}
-              raise(Error, "Unsupported serialization format: #{format} (valid formats: #{Sequel.synchronize{REGISTERED_FORMATS.keys}.map(&:inspect).join})")
+              raise(Error, "Unsupported serialization format: #{format} (valid formats: #{Sequel.synchronize{REGISTERED_FORMATS.keys}.inspect})")
             end
           end
           serializer, deserializer = format
@@ -154,7 +154,10 @@ module Sequel
                   deserialized_values[column] = deserialize_value(column, super())
                 end
               end
-              define_method("#{column}=") do |v| 
+              alias_method(column, column)
+
+              setter = :"#{column}="
+              define_method(setter) do |v| 
                 cc = changed_columns
                 if !cc.include?(column) && (new? || get_column_value(column) != v)
                   cc << column
@@ -164,6 +167,7 @@ module Sequel
 
                 deserialized_values[column] = v
               end
+              alias_method(setter, setter)
             end
           end
         end
@@ -177,8 +181,10 @@ module Sequel
 
         # Freeze the deserialized values
         def freeze
-          deserialized_values.freeze
+          deserialized_values
           super
+          deserialized_values.freeze
+          self
         end
 
         # Serialize deserialized values before saving

data/lib/sequel/plugins/serialization_modification_detection.rb

@@ -50,8 +50,9 @@ module Sequel
         # Freeze the original deserialized values when freezing the instance.
         def freeze
           @original_deserialized_values ||= {}
-          @original_deserialized_values.freeze
           super
+          @original_deserialized_values.freeze
+          self
         end
 
         private

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -250,6 +250,13 @@ module Sequel
           end
           super
         end
+
+        private
+
+        # Don't allow use of prepared statements.
+        def use_prepared_statements_for?(type)
+          false
+        end
       end
     end
   end