sequel 5.39.0 → 5.72.0

data/lib/sequel/plugins/pg_xmin_optimistic_locking.rb

@@ -0,0 +1,109 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # This plugin implements optimistic locking mechanism on PostgreSQL based
+    # on the xmin of the row. The xmin system column is automatically set to
+    # the current transaction id whenever the row is inserted or updated:
+    # 
+    #   class Person < Sequel::Model
+    #     plugin :pg_xmin_optimistic_locking
+    #   end
+    #   p1 = Person[1]
+    #   p2 = Person[1]
+    #   p1.update(name: 'Jim') # works
+    #   p2.update(name: 'Bob') # raises Sequel::NoExistingObject
+    #
+    # The advantage of pg_xmin_optimistic_locking plugin compared to the
+    # regular optimistic_locking plugin as that it does not require any
+    # additional columns setup on the model.  This allows it to be loaded
+    # in the base model and have all subclasses automatically use
+    # optimistic locking.  The disadvantage is that testing can be
+    # more difficult if you are modifying the underlying row between
+    # when a model is retrieved and when it is saved.
+    #
+    # This plugin may not work with the class_table_inheritance plugin.
+    #
+    # This plugin relies on the instance_filters plugin.
+    module PgXminOptimisticLocking
+      WILDCARD = LiteralString.new('*').freeze
+      
+      # Define the xmin column accessor
+      def self.apply(model)
+        model.instance_exec do
+          plugin(:optimistic_locking_base)
+          @lock_column = :xmin
+          def_column_accessor(:xmin)
+        end
+      end
+
+      # Update the dataset to append the xmin column if it is usable
+      # and there is a dataset for the model.
+      def self.configure(model)
+        model.instance_exec do
+          set_dataset(@dataset) if @dataset
+        end
+      end
+
+      module ClassMethods
+        private
+
+        # Ensure the dataset selects the xmin column if doing so 
+        def convert_input_dataset(ds)
+          append_xmin_column_if_usable(super)
+        end
+
+        # If the xmin column is not already selected, and selecting it does not
+        # raise an error, append it to the selections.
+        def append_xmin_column_if_usable(ds)
+          select = ds.opts[:select]
+
+          unless select && select.include?(:xmin)
+            xmin_ds = ds.select_append(:xmin)
+            begin
+              columns = xmin_ds.columns!
+            rescue Sequel::DatabaseConnectionError, Sequel::DatabaseDisconnectError
+              raise
+            rescue Sequel::DatabaseError
+              # ignore, could be view, subquery, table returning function, etc.
+            else
+              ds = xmin_ds if columns.include?(:xmin)
+            end
+          end
+
+          ds
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Only set the lock column instance filter if there is an xmin value. 
+        def lock_column_instance_filter
+          super if @values[:xmin]
+        end
+
+        # Include xmin value when inserting initial row
+        def _insert_dataset
+          super.returning(WILDCARD, :xmin)
+        end
+        
+        # Remove the xmin from the columns to update.
+        # PostgreSQL automatically updates the xmin value, and it cannot be assigned.
+        def _save_update_all_columns_hash
+          v = super
+          v.delete(:xmin)
+          v
+        end
+
+        # Add an RETURNING clause to fetch the updated xmin when updating the row.
+        def _update_without_checking(columns)
+          ds = _update_dataset
+          rows = ds.clone(ds.send(:default_server_opts, :sql=>ds.returning(:xmin).update_sql(columns))).all
+          values[:xmin] = rows.first[:xmin] unless rows.empty?
+          rows.length
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/prepared_statements.rb

@@ -3,7 +3,8 @@
 module Sequel
   module Plugins
     # The prepared_statements plugin modifies the model to use prepared statements for
-    # instance level inserts and updates.
+    # instance level inserts and updates. This plugin exists for backwards compatibility
+    # and is not recommended for general use.
     #
     # 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
@@ -169,8 +170,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

@@ -5,7 +5,8 @@ module Sequel
     # The prepared_statements_safe plugin modifies the model to reduce the number of
     # prepared statements that can be created, by setting as many columns as possible
     # before creating, and by changing +save_changes+ to save all columns instead of
-    # just the changed ones.
+    # just the changed ones. This plugin exists for backwards compatibility
+    # and is not recommended for general use.
     #
     # This plugin depends on the +prepared_statements+ plugin.
     # 

data/lib/sequel/plugins/primary_key_lookup_check_values.rb

@@ -0,0 +1,154 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The primary_key_lookup_check_values plugin typecasts given primary key
+    # values before performing a lookup by primary key. If the given primary
+    # key value cannot be typecasted correctly, the lookup returns nil
+    # without issuing a query.  If the schema for the primary key column
+    # includes minimum and maximum values, this also checks the given value
+    # is not outside the range.  If the given value is outside the allowed
+    # range, the lookup returns nil without issuing a query.
+    #
+    # This affects the following Model methods:
+    #
+    # * Model.[] (when called with non-Hash)
+    # * Model.with_pk
+    # * Model.with_pk!
+    #
+    # It also affects the following Model dataset methods:
+    #
+    # * Dataset#[] (when called with Integer)
+    # * Dataset#with_pk
+    # * dataset#with_pk!
+    # 
+    # Note that this can break working code.  The above methods accept
+    # any filter condition by default, not just primary key values.  The
+    # plugin will handle Symbol, Sequel::SQL::Expression, and
+    # Sequel::LiteralString objects, but code such as the following will break:
+    #
+    #   # Return first Album where primary key is one of the given values
+    #   Album.dataset.with_pk([1, 2, 3])
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses support checking primary key values before
+    #   # lookup # (called before loading subclasses)
+    #   Sequel::Model.plugin :primary_key_lookup_check_values
+    #
+    #   # Make the Album class support checking primary key values before lookup
+    #   Album.plugin :primary_key_lookup_check_values
+    module PrimaryKeyLookupCheckValues
+      def self.configure(model)
+        model.instance_exec do
+          setup_primary_key_lookup_check_values if @dataset
+        end
+      end
+
+      module ClassMethods
+        Plugins.after_set_dataset(self, :setup_primary_key_lookup_check_values)
+
+        Plugins.inherited_instance_variables(self,
+          :@primary_key_type=>nil,
+          :@primary_key_value_range=>nil)
+
+        private
+
+        # Check the given primary key value.  Typecast it to the appropriate
+        # database type if the database type is known.  If it cannot be
+        # typecasted, or the typecasted value is outside the range of column
+        # values, return nil.
+        def _check_pk_lookup_value(pk)
+          return if nil == pk
+          case pk
+          when SQL::Expression, LiteralString, Symbol
+            return pk
+          end
+          return pk unless pk_type = @primary_key_type
+
+          if pk_type.is_a?(Array)
+            return unless pk.is_a?(Array)
+            return unless pk.size == pk_type.size
+            return if pk.any?(&:nil?)
+
+            pk_value_range = @primary_key_value_range
+            i = 0
+            pk.map do |v|
+              if type = pk_type[i]
+                v = _typecast_pk_lookup_value(v, type)
+                return if nil == v
+                if pk_value_range
+                  min, max = pk_value_range[i]
+                  return if min && v < min
+                  return if max && v > max
+                end
+              end
+              i += 1
+              v
+            end
+          elsif pk.is_a?(Array)
+            return
+          elsif nil != (pk = _typecast_pk_lookup_value(pk, pk_type))
+            min, max = @primary_key_value_range
+            return if min && pk < min
+            return if max && pk > max
+            pk
+          end
+        end
+
+        # Typecast the value to the appropriate type,
+        # returning nil if it cannot be typecasted.
+        def _typecast_pk_lookup_value(value, type)
+          db.typecast_value(type, value)
+        rescue InvalidValue
+          nil
+        end
+
+        # Skip the primary key lookup if the typecasted and checked
+        # primary key value is nil.
+        def primary_key_lookup(pk)
+          unless nil == (pk = _check_pk_lookup_value(pk))
+            super
+          end
+        end
+
+        # Setup the primary key type and value range used for checking
+        # primary key values during lookup.
+        def setup_primary_key_lookup_check_values
+          if primary_key.is_a?(Array)
+            types = []
+            value_ranges = []
+            primary_key.each do |pk|
+              type, min, max = _type_min_max_values_for_column(pk)
+              types << type
+              value_ranges << ([min, max].freeze if min || max)
+            end
+            @primary_key_type = (types.freeze if types.any?)
+            @primary_key_value_range = (value_ranges.freeze if @primary_key_type && value_ranges.any?)
+          else
+            @primary_key_type, min, max = _type_min_max_values_for_column(primary_key)
+            @primary_key_value_range = ([min, max].freeze if @primary_key_type && (min || max))
+          end
+        end
+
+        # Return the type, min_value, and max_value schema entries
+        # for the column, if they exist.
+        def _type_min_max_values_for_column(column)
+          if schema = db_schema[column]
+            schema.values_at(:type, :min_value, :max_value)
+          end
+        end
+      end
+
+      module DatasetMethods
+        # Skip the primary key lookup if the typecasted and checked
+        # primary key value is nil.
+        def with_pk(pk)
+          unless nil == (pk = model.send(:_check_pk_lookup_value, pk))
+            super
+          end
+        end
+      end
+    end
+  end
+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).
@@ -207,10 +209,12 @@ module Sequel
               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
@@ -268,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).
@@ -316,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/require_valid_schema.rb

@@ -0,0 +1,67 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The require_valid_schema plugin makes Sequel raise or warn if attempting
+    # to set the dataset of a model class to a simple table, where the database
+    # supports schema parsing, but schema parsing does not work for the model's
+    # table.
+    #
+    # The plugin's default behavior requires that all models that select from a
+    # single identifier have a valid table schema, if the database supports
+    # schema parsing. If the schema cannot be determined for such
+    # a model, an error is raised:
+    #   
+    #   Sequel::Model.plugin :require_valid_schema
+    #
+    # If you load the plugin with an argument of :warn, Sequel will warn instead
+    # of raising for such tables:
+    #
+    #   Sequel::Model.plugin :require_valid_schema, :warn
+    #
+    # This can catch bugs where you expect models to have valid schema, but
+    # they do not. This setting only affects future attempts to set datasets
+    # in the current class and subclasses created in the future.
+    #
+    # If you load the plugin with an argument of false, it will not require valid schema.
+    # This can be used in subclasses where you do not want to require valid schema,
+    # but the plugin must be loaded before a dataset with invalid schema is set:
+    #
+    #   Sequel::Model.plugin :require_valid_schema
+    #   InvalidSchemaAllowed = Class.new(Sequel::Model)
+    #   InvalidSchemaAllowed.plugin :require_valid_schema, false
+    #   class MyModel < InvalidSchemaAllowed
+    #   end
+    module RequireValidSchema
+      # Modify the current model's dataset selection, if the model
+      # has a dataset.
+      def self.configure(model, setting=true)
+        model.instance_variable_set(:@require_valid_schema, setting)
+      end
+
+      module ClassMethods
+        Plugins.inherited_instance_variables(self, :@require_valid_schema=>nil)
+
+        private
+
+        # If the schema cannot be determined, the model uses a simple table,
+        # require_valid_schema is set, and the database supports schema parsing, raise or
+        # warn based on the require_valid_schema setting.
+        def get_db_schema_array(reload)
+          schema_array = super
+
+          if !schema_array && simple_table && @require_valid_schema
+            message = "Not able to parse schema for model: #{inspect}, table: #{simple_table}"
+            if @require_valid_schema == :warn
+              warn message
+            else
+              raise Error, message
+            end
+          end
+
+          schema_array
+        end
+      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

@@ -253,6 +253,14 @@ module Sequel
 
         private
 
+        # Limit tactical eager loading objects to objects that support the same association.
+        def _filter_tactical_eager_load_objects(opts)
+          objects = defined?(super) ? super : retrieved_with.dup
+          name = opts[:name]
+          objects.select!{|x| x.model.association_reflections.include?(name)}
+          objects
+        end
+
         # Don't allow use of prepared statements.
         def use_prepared_statements_for?(type)
           false