sequel 5.23.0 → 5.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfbb05761d35a09172ba5f1d4d7847ae58f152e50648e1fa63d4b284f1999ad5
-  data.tar.gz: f7d4b90e74df4096171baba005935648519a0333aff77c5ba840bb634be8a4fd
+  metadata.gz: 7ea0327d7fbbc76458fc9dc6a088069f04bd100b37f91288e9db9f37db84bbb7
+  data.tar.gz: 6195027a34de796b5109ee2b2ed57407ce9a58f75b1661a3be0ab9b2acbba885
 SHA512:
-  metadata.gz: 345e4d6691206c1a353a2d103dc835b1fcaebed9f274717aa7356a3caf0da237aa14f168c659774261d02621934229966f9f75ad901eb663806359cb924df532
-  data.tar.gz: 0db48e9f07d0dbd598742e85640b8dba965d27bf476e120bf1568e61f7fb19f513e8d9d82b8d69310d1bfde44333553490e14e354a69ce2623943297fe17649f
+  metadata.gz: aaa9a71ee0562ccedaeee6144c4764a8024699214dfd4fd7ce46e8a301d8df72f1a709d373f7f5d47c455ff70407b61e1e0bf05ee7f30e20c49a3be51a1bbea2
+  data.tar.gz: d8343280ef3c09e930df1db0e12eeac349ce23f396fccf1dfcc055a5e760d5dbb50fd5d0a4f8ce591ac4d12644833b9afea6a94fa1b52991c580baba28c26926

data/CHANGELOG

@@ -1,3 +1,19 @@
+=== 5.24.0 (2019-09-01)
+
+* Add Database#skip_logging? private method designed for extensions to force query timing even if no logger is present (adam12) (#1640)
+
+* Allow a hostname specified in a defaults_file in the mysql2 adapter, by not explicitly setting :host (sapio-bdeamer) (#1638)
+
+* Convert all database array types to Ruby arrays in the jdbc adapter (jeremyevans)
+
+* Add static_cache_cache plugin for caching rows for static_cache models to a file to avoid database queries during model initialization (jeremyevans)
+
+* Add :cache_file plugin option to pg_auto_constraint_validations plugin, for caching metadata to a file for faster initialization (jeremyevans)
+
+* Support :unique_deferrable and :primary_key_deferrable column options (jeremyevans)
+
+* Support :generated_always_as column option on PostgreSQL 12+ (jeremyevans)
+
 === 5.23.0 (2019-08-01)
 
 * Work around a bug on jdbc-sqlite3 3.27.2.1 when parsing schema for tables with columns with default values (jeremyevans)

data/doc/release_notes/5.24.0.txt

@@ -0,0 +1,56 @@
+= New Features
+
+* A :cache_file plugin option has been added to the
+  pg_auto_constraint_validations plugin.  This option specifies
+  a file to use to cache the metadata the plugin uses, so the
+  plugin does not need to run 5 queries per model at startup to
+  load the metadata.  This can dramatically improve startup time
+  when using the plugin with a large number of models.
+
+  To create the metadata file, load the plugin into Sequel::Model
+  (or whatever class you are using as the base class for your
+  model classes) with the :cache_file option, and after loading
+  all of the subclasses of that class, run:
+
+    Sequel::Model.dump_pg_auto_constraint_validations_cache
+
+  As when using the schema_caching and index_caching extensions,
+  it is up to the user to ensure that the cached metadata matches
+  the current database schema.  Sequel does no checking of this,
+  as checking would take more time, and the point of this plugin
+  is to improve startup performance.
+
+* A static_cache_cache plugin has been added.  This plugin allows
+  for caching rows for models using the static_cache plugin. This
+  prevents the need to issue a query at model creation time to
+  get the rows.  This plugin should be loaded into Sequel::Model
+  (or whatever class you are using as the base class for your
+  model classes) before loading the models using the static_cache
+  plugin.  To create the metadata file, after all subclasses of
+  that class have been loaded, run:
+
+    Sequel::Model.dump_static_cache_cache
+
+* :unique_deferrable and :primary_key_deferrable column
+  options are now supported on PostgreSQL 9+ and Oracle. This
+  allows you to created deferrable unique and primary key
+  column constraints.  You could already create deferrable
+  table constraints using the :deferrable option to the primary_key
+  and unique methods.
+
+* A :generated_always_as column option is now supported on
+  PostgreSQL 12+, for creating generated columns.
+
+* A Database#skip_logging? private method has been added.  This
+  is designed for use in extensions, to force log timing even
+  when no loggers are configured.
+
+= Other Improvements
+
+* Sequel no longer sets the :host option to localhost by default
+  in the mysql2 adapter.  This prevents Sequel from overriding
+  a host specified in the defaults_file.
+
+* All database array types are converted to Ruby arrays in the
+  jdbc adapter.  Previously, this was only done in the
+  jdbc/postgresql subadapter.

data/lib/sequel/adapters/jdbc.rb

@@ -102,12 +102,17 @@ module Sequel
           v.getSubString(1, v.length)
         end
       end
+      x = convertors[:RubyArray] = Object.new
+      def x.call(r, i)
+        if v = r.getArray(i)
+          v.array.to_ary
+        end
+      end 
 
       MAP = Hash.new(convertors[:Object])
       types = Java::JavaSQL::Types
 
       {
-        :ARRAY => :Array,
         :BOOLEAN => :Boolean,
         :CHAR => :String,
         :DOUBLE => :Double,
@@ -126,6 +131,7 @@ module Sequel
       BASIC_MAP = MAP.dup
 
       {
+        :ARRAY => :Array,
         :BINARY => :Blob,
         :BLOB => :Blob,
         :CLOB => :Clob,

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

@@ -195,17 +195,7 @@ module Sequel
 
         STRING_TYPE = Java::JavaSQL::Types::VARCHAR
         ARRAY_TYPE = Java::JavaSQL::Types::ARRAY
-        PG_SPECIFIC_TYPES = [ARRAY_TYPE, Java::JavaSQL::Types::OTHER, Java::JavaSQL::Types::STRUCT, Java::JavaSQL::Types::TIME_WITH_TIMEZONE, Java::JavaSQL::Types::TIME].freeze
-
-        # Return PostgreSQL array types as ruby Arrays instead of
-        # JDBC PostgreSQL driver-specific array type. Only used if the
-        # database does not have a conversion proc for the type.
-        ARRAY_METHOD = Object.new
-        def ARRAY_METHOD.call(r, i)
-          if v = r.getArray(i)
-            v.array.to_ary
-          end
-        end 
+        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
 
         # Return PostgreSQL hstore types as ruby Hashes instead of
         # Java HashMaps.  Only used if the database does not have a
@@ -223,8 +213,6 @@ module Sequel
             oid = meta.getField(i).getOID
             if pr = db.oid_convertor_proc(oid)
               pr
-            elsif type == ARRAY_TYPE
-              ARRAY_METHOD
             elsif oid == 2950 # UUID
               map[STRING_TYPE]
             elsif meta.getPGType(i) == 'hstore'

data/lib/sequel/adapters/mysql2.rb

@@ -36,7 +36,6 @@ module Sequel
       # options such as :local_infile.
       def connect(server)
         opts = server_opts(server)
-        opts[:host] ||= 'localhost'
         opts[:username] ||= opts.delete(:user)
         opts[:flags] ||= 0
         opts[:flags] |= ::Mysql2::Client::FOUND_ROWS if ::Mysql2::Client.const_defined?(:FOUND_ROWS)

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

@@ -97,13 +97,17 @@ module Sequel
       # Add an exclusion constraint when creating the table. Elements should be
       # an array of 2 element arrays, with the first element being the column or
       # expression the exclusion constraint is applied to, and the second element
-      # being the operator to use for the column/expression to check for exclusion.
-      #
-      # Example:
+      # being the operator to use for the column/expression to check for exclusion:
       #
       #   exclude([[:col1, '&&'], [:col2, '=']])
       #   # EXCLUDE USING gist (col1 WITH &&, col2 WITH =)
       #
+      # To use a custom operator class, you need to use Sequel.lit with the expression
+      # and operator class:
+      #
+      #   exclude([[Sequel.lit('col1 inet_ops'), '&&'], [:col2, '=']])
+      #   # EXCLUDE USING gist (col1 inet_ops WITH &&, col2 WITH =)
+      #
       # Options supported:
       #
       # :name :: Name the constraint with the given name (useful if you may
@@ -836,10 +840,14 @@ module Sequel
       # default value is given.
       def column_definition_default_sql(sql, column)
         super
-        if !column[:serial] && !['serial', 'bigserial'].include?(column[:type].to_s) && !column[:default] && (identity = column[:identity])
-          sql << " GENERATED "
-          sql << (identity == :always ? "ALWAYS" : "BY DEFAULT")
-          sql << " AS IDENTITY"
+        if !column[:serial] && !['serial', 'bigserial'].include?(column[:type].to_s) && !column[:default]
+          if (identity = column[:identity])
+            sql << " GENERATED "
+            sql << (identity == :always ? "ALWAYS" : "BY DEFAULT")
+            sql << " AS IDENTITY"
+          elsif (generated = column[:generated_always_as])
+            sql << " GENERATED ALWAYS AS (#{literal(generated)}) STORED"
+          end
         end
       end
 

data/lib/sequel/database/logging.rb

@@ -35,7 +35,7 @@ module Sequel
     # Yield to the block, logging any errors at error level to all loggers,
     # and all other queries with the duration at warn or info level.
     def log_connection_yield(sql, conn, args=nil)
-      return yield if @loggers.empty?
+      return yield if skip_logging?
       sql = "#{connection_info(conn) if conn && log_connection_info}#{sql}#{"; #{args.inspect}" if args}"
       timer = Sequel.start_timer
 
@@ -58,6 +58,12 @@ module Sequel
 
     private
 
+    # Determine if logging should be skipped. Defaults to true if no loggers
+    # have been specified.
+    def skip_logging?
+      @loggers.empty?
+    end
+
     # String including information about the connection, for use when logging
     # connection info.
     def connection_info(conn)

data/lib/sequel/database/schema_generator.rb

@@ -110,6 +110,9 @@ module Sequel
       #                yet exist on referenced table (but will exist before the transaction commits).
       #                Basically it adds DEFERRABLE INITIALLY DEFERRED on key creation.
       #                If you use :immediate as the value, uses DEFERRABLE INITIALLY IMMEDIATE.
+      # :generated_always_as :: Specify a GENERATED ALWAYS AS column expression,
+      #                         if generated columns are supported (PostgreSQL 12+, MariaDB 5.2.0+,
+      #                         and MySQL 5.7.6+).
       # :index :: Create an index on this column.  If given a hash, use the hash as the
       #           options for the index.
       # :key :: For foreign key columns, the column in the associated table
@@ -126,15 +129,21 @@ module Sequel
       #                 be used if you have a single, nonautoincrementing primary key column
       #                 (use the primary_key method in that case).
       # :primary_key_constraint_name :: The name to give the primary key constraint
+      # :primary_key_deferrable :: Similar to :deferrable, but for the primary key constraint
+      #                            if :primary_key is used.
       # :type :: Overrides the type given as the argument.  Generally not used by column
       #          itself, but can be passed as an option to other methods that call column.
       # :unique :: Mark the column as unique, generally has the same effect as
       #            creating a unique index on the column.
       # :unique_constraint_name :: The name to give the unique key constraint
+      # :unique_deferrable :: Similar to :deferrable, but for the unique constraint if :unique
+      #                       is used.
+      #
+      # PostgreSQL specific options:
+      #
+      # :identity :: Create an identity column.
       #
       # MySQL specific options:
-      # :generated_always_as :: Specify a GENERATED ALWAYS AS column expression,
-      #                         if generated columns are supported.
       # :generated_type :: Set the type of column when using :generated_always_as,
       #                    should be :virtual or :stored to force a type.
       def column(name, type, opts = OPTS)

data/lib/sequel/database/schema_methods.rb

@@ -586,6 +586,7 @@ module Sequel
           sql << " CONSTRAINT #{quote_identifier(name)}"
         end
         sql << ' PRIMARY KEY'
+        constraint_deferrable_sql_append(sql, column[:primary_key_deferrable])
       end
     end
     
@@ -606,6 +607,7 @@ module Sequel
           sql << " CONSTRAINT #{quote_identifier(name)}"
         end
         sql << ' UNIQUE'
+        constraint_deferrable_sql_append(sql, column[:unique_deferrable])
       end
     end
     

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -45,6 +45,31 @@ module Sequel
     # 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:
     #
@@ -67,13 +92,28 @@ module Sequel
       }.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
@@ -85,9 +125,16 @@ module Sequel
         # 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)
+        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]
@@ -122,39 +169,51 @@ module Sequel
             return
           end
 
-          checks = {}
-          indexes = {}
-          foreign_keys = {}
-          referenced_by = {}
+          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
+            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
-          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])
-
-          (@pg_auto_constraint_validations = {
-            :schema=>schema,
-            :table=>table,
-            :check=>checks,
-            :unique=>indexes,
-            :foreign_key=>foreign_keys,
-            :referenced_by=>referenced_by,
-            :overrides=>OPTS
-          }.freeze).each_value(&:freeze)
+          @pg_auto_constraint_validations = metadata
+          nil
         end
       end
 

data/lib/sequel/plugins/static_cache.rb

@@ -211,18 +211,23 @@ module Sequel
         # Reload the cache for this model by retrieving all of the instances in the dataset
         # freezing them, and populating the cached array and hash.
         def load_cache
-          a = dataset.all
+          @all = load_static_cache_rows
           h = {}
-          a.each do |o|
+          @all.each do |o|
             o.errors.freeze
             h[o.pk.freeze] = o.freeze
           end
-          @all = a.freeze
           @cache = h.freeze
         end
 
         private
 
+        # Load the static cache rows from the database.
+        def load_static_cache_rows
+          ret = super if defined?(super)
+          ret || dataset.all.freeze
+        end
+
         # Return the frozen object with the given pk, or nil if no such object exists
         # in the cache, without issuing a database query.
         def primary_key_lookup(pk)

data/lib/sequel/plugins/static_cache_cache.rb

@@ -0,0 +1,53 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The static_cache_cache plugin allows for caching the row content for subclasses
+    # that use the static cache plugin (or just the current class).  Using this plugin
+    # can avoid the need to query the database every time loading the plugin into a
+    # model, which can save time when you have a lot of models using the static_cache
+    # plugin.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses that use the static_cache plugin use
+    #   # the cached values in the given file
+    #   Sequel::Model.plugin :static_cache_cache, "static_cache.cache"
+    #
+    #   # Make the AlbumType model the cached values in the given file,
+    #   # should be loaded before the static_cache plugin
+    #   AlbumType.plugin :static_cache_cache, "static_cache.cache"
+    module StaticCacheCache
+      def self.configure(model, file)
+        model.instance_variable_set(:@static_cache_cache_file, file)
+        model.instance_variable_set(:@static_cache_cache, File.exist?(file) ? Marshal.load(File.read(file)) : {})
+      end
+
+      module ClassMethods
+        # Dump the in-memory cached rows to the cache file.
+        def dump_static_cache_cache
+          File.open(@static_cache_cache_file, 'wb'){|f| f.write(Marshal.dump(@static_cache_cache))}
+          nil
+        end
+
+        Plugins.inherited_instance_variables(self, :@static_cache_cache_file=>nil, :@static_cache_cache=>nil)
+
+        private
+
+        # Load the rows for the model from the cache if available.
+        # If not available, load the rows from the database, and
+        # then update the cache with the raw rows.
+        def load_static_cache_rows
+          if rows = Sequel.synchronize{@static_cache_cache[name]}
+            rows.map{|row| call(row)}.freeze
+          else
+            rows = dataset.all.freeze
+            raw_rows = rows.map(&:values)
+            Sequel.synchronize{@static_cache_cache[name] = raw_rows}
+            rows
+          end
+        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 = 23
+  MINOR = 24
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

data/spec/adapters/postgres_spec.rb

@@ -227,6 +227,24 @@ describe "PostgreSQL", '#create_table' do
     @db.convert_serial_to_identity(:tmp_dolls, :column=>:id)
   end if DB.server_version >= 100002 && DB.get{current_setting('is_superuser')} == 'on'
 
+  it "should support creating generated columns" do
+    @db.create_table(:tmp_dolls){Integer :a; Integer :b; Integer :c, :generated_always_as=>Sequel[:a] * 2 + :b + 1}
+    @db[:tmp_dolls].insert(:a=>100, :b=>10)
+    @db[:tmp_dolls].select_order_map([:a, :b, :c]).must_equal [[100, 10, 211]]
+  end if DB.server_version >= 120000
+
+  it "should support deferred primary key and unique constraints on columns" do
+    @db.create_table(:tmp_dolls){primary_key :id, :primary_key_deferrable=>true; Integer :i, :unique=>true, :unique_deferrable=>true}
+    @db[:tmp_dolls].insert(:i=>10)
+    DB.transaction do
+      @db[:tmp_dolls].insert(:id=>1, :i=>1)
+      @db[:tmp_dolls].insert(:id=>10, :i=>10)
+      @db[:tmp_dolls].where(:i=>1).update(:id=>2)
+      @db[:tmp_dolls].where(:id=>10).update(:i=>2)
+    end
+    @db[:tmp_dolls].select_order_map([:id, :i]).must_equal [[1, 10], [2, 1], [10, 2]]
+  end if DB.server_version >= 90000
+
   it "should support pg_loose_count extension" do
     @db.extension :pg_loose_count
     @db.create_table(:tmp_dolls){text :name}
@@ -4345,4 +4363,49 @@ describe "pg_auto_constraint_validations plugin" do
     proc{o.save}.must_raise Sequel::ValidationFailed
     o.errors.must_equal(:i=>['is invalid'], :id=>['is invalid'])
   end
+
+  it "should handle dumping cached metadata and loading metadata from cache" do
+    cache_file = "spec/files/pgacv-#{$$}.cache"
+    begin
+      c = Class.new(Sequel::Model)
+      c.plugin :pg_auto_constraint_validations, :cache_file=>cache_file
+      c1 = Class.new(c)
+      def c1.name; 'Foo' end
+      c1.dataset = DB[:test1]
+      c2 = Class.new(c)
+      def c2.name; 'Bar' end
+      c2.dataset = DB[:test2]
+      c1.unrestrict_primary_key
+      c2.unrestrict_primary_key
+
+      o = c1.new(:id=>5, :i=>12)
+      proc{o.save}.must_raise Sequel::ValidationFailed
+      o.errors.must_equal(:i=>['is invalid'])
+      o = c2.new(:test2_id=>4, :test1_id=>2)
+      proc{o.save}.must_raise Sequel::ValidationFailed
+      o.errors.must_equal(:test1_id=>['is invalid'])
+
+      c.dump_pg_auto_constraint_validations_cache
+
+      c = Class.new(Sequel::Model)
+      c.plugin :pg_auto_constraint_validations, :cache_file=>cache_file
+      c1 = Class.new(c)
+      def c1.name; 'Foo' end
+      c1.dataset = DB[:test1]
+      c2 = Class.new(c)
+      def c2.name; 'Bar' end
+      c2.dataset = DB[:test2]
+      c1.unrestrict_primary_key
+      c2.unrestrict_primary_key
+
+      o = c1.new(:id=>5, :i=>12)
+      proc{o.save}.must_raise Sequel::ValidationFailed
+      o.errors.must_equal(:i=>['is invalid'])
+      o = c2.new(:test2_id=>4, :test1_id=>2)
+      proc{o.save}.must_raise Sequel::ValidationFailed
+      o.errors.must_equal(:test1_id=>['is invalid'])
+    ensure
+      File.delete(cache_file) if File.file?(cache_file)
+    end
+  end
 end if DB.respond_to?(:error_info)

data/spec/core/database_spec.rb

@@ -264,6 +264,25 @@ describe "Database#log_connection_yield" do
     @o.logs.first.first.must_equal :info
     @o.logs.first.last.must_match(/\A\(\d\.\d{6}s\) blah; \[1, 2\]\z/)
   end
+
+  it "should log without a logger defined by forcing skip_logging? to return false" do
+    @db.logger = nil
+    @db.extend(Module.new do
+      def skip_logging?
+        false
+      end
+
+      def log_duration(*)
+        self.did_log = true
+      end
+
+      attr_accessor :did_log
+    end)
+
+    @db.log_connection_yield('some sql', @conn) {}
+
+    @db.did_log.must_equal true
+  end
 end
 
 describe "Database#uri" do

data/spec/core/schema_spec.rb

@@ -240,6 +240,24 @@ describe "DB#create_table" do
     @db.sqls.must_equal ["CREATE TABLE cats (id integer, name text, UNIQUE (name) DEFERRABLE INITIALLY IMMEDIATE)"]
   end
   
+  it "should handle deferred unique column constraints" do
+    @db.create_table(:cats) do
+      integer :id, :unique=>true, :unique_deferrable=>true
+      integer :i, :unique=>true, :unique_deferrable=>:immediate
+      integer :j, :unique=>true, :unique_deferrable=>false
+    end
+    @db.sqls.must_equal ["CREATE TABLE cats (id integer UNIQUE DEFERRABLE INITIALLY DEFERRED, i integer UNIQUE DEFERRABLE INITIALLY IMMEDIATE, j integer UNIQUE NOT DEFERRABLE)"]
+  end
+  
+  it "should handle deferred primary key column constraints" do
+    @db.create_table(:cats) do
+      integer :id, :primary_key=>true, :primary_key_deferrable=>true
+      integer :i, :primary_key=>true, :primary_key_deferrable=>:immediate
+      integer :j, :primary_key=>true, :primary_key_deferrable=>false
+    end
+    @db.sqls.must_equal ["CREATE TABLE cats (id integer PRIMARY KEY DEFERRABLE INITIALLY DEFERRED, i integer PRIMARY KEY DEFERRABLE INITIALLY IMMEDIATE, j integer PRIMARY KEY NOT DEFERRABLE)"]
+  end
+  
   it "should accept unsigned definition" do
     @db.create_table(:cats) do
       integer :value, :unsigned => true

data/spec/extensions/insert_conflict_spec.rb

@@ -74,4 +74,30 @@ describe "insert_conflict plugin" do
     model.db.sqls.must_equal ["INSERT INTO t (s, o) VALUES ('A', 1) ON CONFLICT (s) DO UPDATE SET o = excluded.o",
       "SELECT * FROM t WHERE (id = 2) LIMIT 1"]
   end
+
+  it "should work if the prepared_statements plugin is loaded before" do
+    db = Sequel.mock(:host=>'sqlite', :fetch=>{:id=>1, :s=>2}, :autoid=>1, :numrows=>1)
+    db.extend_datasets{def quote_identifiers?; false end}
+    model = Class.new(Sequel::Model)
+    model.dataset = db[:t]
+    model.columns :id, :s
+    model.plugin :prepared_statements
+    model.plugin :insert_conflict
+    db.sqls
+    model.create(:s=>'a').update(:s=>'b')
+    db.sqls.must_equal ["INSERT INTO t (s) VALUES ('a')", "SELECT * FROM t WHERE (id = 1) LIMIT 1", "UPDATE t SET s = 'b' WHERE (id = 1)"]
+  end
+
+  it "should work if the prepared_statements plugin is loaded after" do
+    db = Sequel.mock(:host=>'postgres', :fetch=>{:id=>1, :s=>2}, :autoid=>1, :numrows=>1)
+    db.extend_datasets{def quote_identifiers?; false end}
+    model = Class.new(Sequel::Model)
+    model.dataset = db[:t]
+    model.columns :id, :s
+    model.plugin :insert_conflict
+    model.plugin :prepared_statements
+    db.sqls
+    model.create(:s=>'a').update(:s=>'b')
+    db.sqls.must_equal ["INSERT INTO t (s) VALUES ('a') RETURNING *", "UPDATE t SET s = 'b' WHERE (id = 1)"]
+  end
 end

data/spec/extensions/pg_auto_constraint_validations_spec.rb

@@ -169,4 +169,41 @@ describe "pg_auto_constraint_validations plugin" do
     proc{o.update(:i=>12)}.must_raise Sequel::ValidationFailed
     o.errors.must_equal(:i=>['foo bar'])
   end
+
+  it "should handle dumping cached metadata and loading metadata from cache" do
+    cache_file = "spec/files/pgacv-spec-#{$$}.cache"
+    begin
+      @ds = @db[:items]
+      @ds.send(:columns=, [:id, :i])
+      @db.fetch = @metadata_results.dup
+      c = Sequel::Model(@ds)
+      def c.name; 'Foo' end
+      @db.sqls
+      c.plugin :pg_auto_constraint_validations, :cache_file=>cache_file
+      @db.sqls.length.must_equal 5
+
+      o = c.new(:i=>12)
+      @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_id_check']
+      proc{o.save}.must_raise Sequel::ValidationFailed
+
+      c.dump_pg_auto_constraint_validations_cache
+
+      @db.fetch = []
+      c = Sequel::Model(@ds)
+      def c.name; 'Foo' end
+      @db.sqls
+      c.plugin :pg_auto_constraint_validations, :cache_file=>cache_file
+      @db.sqls.must_be_empty
+
+      o = c.new(:i=>12)
+      @set_error[Sequel::CheckConstraintViolation, :constraint=>'items_i_id_check']
+      proc{o.save}.must_raise Sequel::ValidationFailed
+    ensure
+      File.delete(cache_file) if File.file?(cache_file)
+    end
+  end
+
+  it "should raise error if attempting to dump cached metadata when not using caching" do
+    proc{@c.dump_pg_auto_constraint_validations_cache}.must_raise Sequel::Error
+  end
 end

data/spec/extensions/static_cache_cache_spec.rb

@@ -0,0 +1,35 @@
+require_relative "spec_helper"
+
+describe "static_cache_cache plugin" do
+  before do
+    @db = Sequel.mock
+    @db.fetch = [{:id=>1, :name=>'A'}, {:id=>2, :name=>'B'}]
+    @c = Class.new(Sequel::Model(@db[:t]))
+    def @c.name; 'Foo' end
+    @c.columns :id, :name
+    @file = "spec/files/static_cache_cache-spec-#{$$}.cache"
+  end
+  after do
+    File.delete(@file) if File.file?(@file)
+  end
+
+  it "should allow dumping and loading static cache rows from a cache file" do
+    @c.plugin :static_cache_cache, @file
+    @db.sqls
+    @c.plugin :static_cache
+    @db.sqls.must_equal ['SELECT * FROM t']
+    @c.all.must_equal [@c.load(:id=>1, :name=>'A'), @c.load(:id=>2, :name=>'B')]
+
+    @c.dump_static_cache_cache
+
+    @db.fetch = []
+    c = Class.new(Sequel::Model(@db[:t]))
+    def c.name; 'Foo' end
+    c.columns :id, :name
+    @c.plugin :static_cache_cache, @file
+    @db.sqls
+    @c.plugin :static_cache
+    @db.sqls.must_be_empty
+    @c.all.must_equal [@c.load(:id=>1, :name=>'A'), @c.load(:id=>2, :name=>'B')]
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.23.0
+  version: 5.24.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-01 00:00:00.000000000 Z
+date: 2019-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -207,6 +207,7 @@ extra_rdoc_files:
 - doc/release_notes/5.21.0.txt
 - doc/release_notes/5.22.0.txt
 - doc/release_notes/5.23.0.txt
+- doc/release_notes/5.24.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -301,6 +302,7 @@ files:
 - doc/release_notes/5.21.0.txt
 - doc/release_notes/5.22.0.txt
 - doc/release_notes/5.23.0.txt
+- doc/release_notes/5.24.0.txt
 - doc/release_notes/5.3.0.txt
 - doc/release_notes/5.4.0.txt
 - doc/release_notes/5.5.0.txt
@@ -542,6 +544,7 @@ files:
 - lib/sequel/plugins/skip_create_refresh.rb
 - lib/sequel/plugins/split_values.rb
 - lib/sequel/plugins/static_cache.rb
+- lib/sequel/plugins/static_cache_cache.rb
 - lib/sequel/plugins/string_stripper.rb
 - lib/sequel/plugins/subclasses.rb
 - lib/sequel/plugins/subset_conditions.rb
@@ -712,6 +715,7 @@ files:
 - spec/extensions/split_values_spec.rb
 - spec/extensions/sql_comments_spec.rb
 - spec/extensions/sql_expr_spec.rb
+- spec/extensions/static_cache_cache_spec.rb
 - spec/extensions/static_cache_spec.rb
 - spec/extensions/string_agg_spec.rb
 - spec/extensions/string_date_time_spec.rb