sequel 5.70.0 → 5.71.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 780e8bd3203a4aa27f70c94dd2ddd29e28826ec7b74b86296a2571d40ff2a74a
-  data.tar.gz: f600cfad2e5401f2c1150838ecacac0cd34ba38da4a69bd3afd580dbadaee35f
+  metadata.gz: 17fbd14a63974634d39c289194210ea773d5e2017ad24ac3f6a5c89cc6eb481d
+  data.tar.gz: 390a9c664bf0a7710bb341ef8699e53b0ed2ea4d4fd2c221f7e140393d52047e
 SHA512:
-  metadata.gz: b22192e34739b2158a543f18f51b52b44063b86b02c6968a8f8e1ff2deec8338fa4f81176a4f5f2b27ace6fcefe9d3511ccaa73c43e2b660743a3a736f303080
-  data.tar.gz: 4540e3f53f53d6fe8b7a22212ab7d6678502e87bf67a5081c22d1da02ea8ea2090589e384fe17e4ca454c0c4c45358f1aaed1772d27e7732f7f68071e5914ea6
+  metadata.gz: 0af7a0afdad27b270d69eb8248e734408c0c132d209c111f03957a14d1fc2ef44fc4a6da66eaa4986dadf1565f428a140dc9b807bb0215117b015b69057445a1
+  data.tar.gz: a2aade8559d69fe43306b6834069e976f57809170e1a9102501e4031d899dd046119de95f485712024e68aa5b077cf63cccc74b7a77b244e821a2c42b87a09a3

data/CHANGELOG

@@ -1,3 +1,13 @@
+=== 5.71.0 (2023-08-01)
+
+* Support ILIKE ANY on PostgreSQL by not forcing the use of ESCAPE for ILIKE (gilesbowkett) (#2066)
+
+* Add pg_xmin_optimistic_locking plugin for optimistic locking for all models without database changes (jeremyevans)
+
+* Recognize the xid PostgreSQL type as an integer type in the jdbc/postgresql adapter (jeremyevans)
+
+* Make set_column_allow_null method reversible in migrations (enescakir) (#2060)
+
 === 5.70.0 (2023-07-01)
 
 * Make static_cache plugin better handle cases where forbid_lazy_load plugin is already loaded (jeremyevans)

data/doc/migration.rdoc

@@ -86,6 +86,7 @@ the following methods:
   * +add_full_text_index+
   * +add_spatial_index+
   * +rename_column+
+  * +set_column_allow_null+
 
 If you use any other methods, you should create your own +down+ block.
 

data/doc/release_notes/5.71.0.txt

@@ -0,0 +1,21 @@
+= New Features
+
+* A pg_xmin_optimistic_locking plugin has been added.  This plugin
+  uses PostgreSQL's xmin system column to implement optimistic
+  locking.  The xmin system column is automatically updated whenever
+  the database row is updated.  You can load this plugin into a
+  base model and have all models that subclass from it use optimistic
+  locking, without needing any user-defined lock columns.
+
+= Other Improvements
+
+* set_column_allow_null is now a reversible migration method inside
+  alter_table blocks.
+
+* The use of ILIKE no longer forces the ESCAPE clause on PostgreSQL,
+  which allows the use of ILIKE ANY and other constructions.  There
+  is no need to use the ESCAPE clause with ILIKE, because the value
+  Sequel uses is PostgreSQL's default.
+
+* The xid PostgreSQL type is now recognized as an integer type in the
+  jdbc/postgresql adapter.

data/lib/sequel/adapters/jdbc/postgresql.rb

@@ -199,6 +199,7 @@ module Sequel
           v.strftime("'%H:%M:%S#{sprintf(".%03d", (v.usec/1000.0).round)}'")
         end
 
+        INTEGER_TYPE = Java::JavaSQL::Types::INTEGER
         STRING_TYPE = Java::JavaSQL::Types::VARCHAR
         ARRAY_TYPE = Java::JavaSQL::Types::ARRAY
         PG_SPECIFIC_TYPES = [Java::JavaSQL::Types::ARRAY, Java::JavaSQL::Types::OTHER, Java::JavaSQL::Types::STRUCT, Java::JavaSQL::Types::TIME_WITH_TIMEZONE, Java::JavaSQL::Types::TIME].freeze
@@ -219,6 +220,8 @@ module Sequel
             oid = meta.getField(i).getOID
             if pr = db.oid_convertor_proc(oid)
               pr
+            elsif oid == 28 # XID (Transaction ID)
+              map[INTEGER_TYPE]
             elsif oid == 2950 # UUID
               map[STRING_TYPE]
             elsif meta.getPGType(i) == 'hstore'

data/lib/sequel/adapters/shared/postgres.rb

@@ -1745,8 +1745,6 @@ module Sequel
           literal_append(sql, args[0])
           sql << ' ' << op.to_s << ' '
           literal_append(sql, args[1])
-          sql << " ESCAPE "
-          literal_append(sql, "\\")
           sql << ')'
         else
           super

data/lib/sequel/extensions/migration.rb

@@ -270,6 +270,10 @@ module Sequel
     def rename_column(name, new_name)
       @actions << [:rename_column, new_name, name]
     end
+
+    def set_column_allow_null(name, allow_null=true)
+      @actions << [:set_column_allow_null, name, !allow_null]
+    end
   end
 
   # The preferred method for writing Sequel migrations, using a DSL:

data/lib/sequel/plugins/mssql_optimistic_locking.rb

@@ -26,57 +26,27 @@ module Sequel
     module MssqlOptimisticLocking
       # Load the instance_filters plugin into the model.
       def self.apply(model, opts=OPTS)
-        model.plugin :instance_filters
+        model.plugin(:optimistic_locking_base)
       end
 
-      # Set the lock_column to the :lock_column option (default: :timestamp)
+      # Set the lock column
       def self.configure(model, opts=OPTS)
-        model.lock_column = opts[:lock_column] || :timestamp
+        model.lock_column = opts[:lock_column] || model.lock_column || :timestamp
       end
-
-      module ClassMethods
-        # The timestamp/rowversion column containing the version for the current row.
-        attr_accessor :lock_column
-
-        Plugins.inherited_instance_variables(self, :@lock_column=>nil)
-      end
-
+      
       module InstanceMethods
-        # Add the lock column instance filter to the object before destroying it.
-        def before_destroy
-          lock_column_instance_filter
-          super
-        end
-        
-        # Add the lock column instance filter to the object before updating it.
-        def before_update
-          lock_column_instance_filter
-          super
-        end
-        
         private
         
-        # Add the lock column instance filter to the object.
-        def lock_column_instance_filter
-          lc = model.lock_column
-          instance_filter(lc=>Sequel.blob(get_column_value(lc)))
-        end
-
-        # Clear the instance filters when refreshing, so that attempting to
-        # refresh after a failed save removes the previous lock column filter
-        # (the new one will be added before updating).
-        def _refresh(ds)
-          clear_instance_filters
-          super
+        # Make the instance filter value a blob.
+        def lock_column_instance_filter_value
+          Sequel.blob(super)
         end
 
         # Remove the lock column from the columns to update.
         # SQL Server automatically updates the lock column value, and does not like
         # it to be assigned.
         def _save_update_all_columns_hash
-          v = @values.dup
-          cc = changed_columns
-          Array(primary_key).each{|x| v.delete(x) unless cc.include?(x)}
+          v = super
           v.delete(model.lock_column)
           v
         end

data/lib/sequel/plugins/optimistic_locking.rb

@@ -12,64 +12,31 @@ module Sequel
     #   p1 = Person[1]
     #   p2 = Person[1]
     #   p1.update(name: 'Jim') # works
-    #   p2.update(name: 'Bob') # raises Sequel::Plugins::OptimisticLocking::Error
+    #   p2.update(name: 'Bob') # raises Sequel::NoExistingObject
     #
     # 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
-    # class level accessor) that defaults to 0.
+    # table has a +lock_version+ column that defaults to 0. To change the column
+    # used, provide a +:lock_column+ option when loading the plugin:
+    #
+    #     plugin :optimistic_locking, lock_column: :version
     #
     # This plugin relies on the instance_filters plugin.
     module OptimisticLocking
       # Exception class raised when trying to update or destroy a stale object.
       Error = Sequel::NoExistingObject
       
-      # Load the instance_filters plugin into the model.
       def self.apply(model, opts=OPTS)
-        model.plugin :instance_filters
+        model.plugin(:optimistic_locking_base)
       end
 
-      # Set the lock_column to the :lock_column option, or :lock_version if
-      # that option is not given.
+      # Set the lock column
       def self.configure(model, opts=OPTS)
-        model.lock_column = opts[:lock_column] || :lock_version
+        model.lock_column = opts[:lock_column] || model.lock_column || :lock_version
       end
-      
-      module ClassMethods
-        # The column holding the version of the lock
-        attr_accessor :lock_column
-        
-        Plugins.inherited_instance_variables(self, :@lock_column=>nil)
-      end
-    
+
       module InstanceMethods
-        # Add the lock column instance filter to the object before destroying it.
-        def before_destroy
-          lock_column_instance_filter
-          super
-        end
-        
-        # Add the lock column instance filter to the object before updating it.
-        def before_update
-          lock_column_instance_filter
-          super
-        end
-        
         private
         
-        # Add the lock column instance filter to the object.
-        def lock_column_instance_filter
-          lc = model.lock_column
-          instance_filter(lc=>get_column_value(lc))
-        end
-
-        # Clear the instance filters when refreshing, so that attempting to
-        # refresh after a failed save removes the previous lock column filter
-        # (the new one will be added before updating).
-        def _refresh(ds)
-          clear_instance_filters
-          super
-        end
-        
         # Only update the row if it has the same lock version, and increment the
         # lock version.
         def _update_columns(columns)

data/lib/sequel/plugins/optimistic_locking_base.rb

@@ -0,0 +1,55 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # Base for other optimistic locking plugins
+    module OptimisticLockingBase
+      # Load the instance_filters plugin into the model.
+      def self.apply(model)
+        model.plugin :instance_filters
+      end
+
+      module ClassMethods
+        # The column holding the version of the lock
+        attr_accessor :lock_column
+        
+        Plugins.inherited_instance_variables(self, :@lock_column=>nil)
+      end
+    
+      module InstanceMethods
+        # Add the lock column instance filter to the object before destroying it.
+        def before_destroy
+          lock_column_instance_filter
+          super
+        end
+        
+        # Add the lock column instance filter to the object before updating it.
+        def before_update
+          lock_column_instance_filter
+          super
+        end
+        
+        private
+        
+        # Add the lock column instance filter to the object.
+        def lock_column_instance_filter
+          instance_filter(model.lock_column=>lock_column_instance_filter_value)
+        end
+
+        # Use the current value of the lock column
+        def lock_column_instance_filter_value
+          public_send(model.lock_column)
+        end
+
+        # Clear the instance filters when refreshing, so that attempting to
+        # refresh after a failed save removes the previous lock column filter
+        # (the new one will be added before updating).
+        def _refresh(ds)
+          clear_instance_filters
+          super
+        end
+      end
+    end
+  end
+end
+

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/version.rb

@@ -6,7 +6,7 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 70
+  MINOR = 71
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.70.0
+  version: 5.71.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-01 00:00:00.000000000 Z
+date: 2023-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -203,6 +203,7 @@ extra_rdoc_files:
 - doc/release_notes/5.69.0.txt
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.70.0.txt
+- doc/release_notes/5.71.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
 files:
@@ -301,6 +302,7 @@ files:
 - doc/release_notes/5.69.0.txt
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.70.0.txt
+- doc/release_notes/5.71.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
 - doc/schema_modification.rdoc
@@ -552,9 +554,11 @@ files:
 - lib/sequel/plugins/mssql_optimistic_locking.rb
 - lib/sequel/plugins/nested_attributes.rb
 - lib/sequel/plugins/optimistic_locking.rb
+- lib/sequel/plugins/optimistic_locking_base.rb
 - lib/sequel/plugins/pg_array_associations.rb
 - lib/sequel/plugins/pg_auto_constraint_validations.rb
 - lib/sequel/plugins/pg_row.rb
+- lib/sequel/plugins/pg_xmin_optimistic_locking.rb
 - lib/sequel/plugins/prepared_statements.rb
 - lib/sequel/plugins/prepared_statements_safe.rb
 - lib/sequel/plugins/primary_key_lookup_check_values.rb