sequel 5.58.0 → 5.60.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f02f6a35677e8af2ea2b164f655cc869213864e5b27f67cdd3e17c7db28c546
-  data.tar.gz: ee09f1b4d5b3f4decbf4d4af3b8ae16ef7e488af40011808dac94f8ca05da89f
+  metadata.gz: cd8695696d6b55edf6337870f3ff172aeb6fe2ef9ba4bbc23daae0af26908649
+  data.tar.gz: 2483bbb3549adbcb9f179165119051b7bb234d6e714e4afa116c0ffddf379dc6
 SHA512:
-  metadata.gz: 89efe5f1a7f2c2eedba5ac1cf336adee1abf489278f79413756e70a41e4ba073ea818562aaf176c1f092e7ab9e763693473a0d96edc6782d9da037c759afd05d
-  data.tar.gz: 84986009ccb30a7a0fd15a555262631f539b95ef9ec8d74d6ca2a4078bd07c33ffda725092bad5afbc93b27901e67dc6d06ca735481448174ac695ef14b6ee99
+  metadata.gz: 0527cba1fcc06d8001cbd55473b3af5c23a9f5c004113fc24aa6f9e029c5ed2cf4f938bf184d79922164cdc3ea502d12860d46d64237bdbd306bf5ce50f59ffa
+  data.tar.gz: e13c17553592773e70c0e9a6753438444a5245f3cd0664c6c5a6c0a08a271d1d92180b110c7b7e5981f7ca6dc2b18d90da3feeb05a14ae863fcfd99d5673650e

data/CHANGELOG

@@ -1,3 +1,35 @@
+=== 5.60.1 (2022-09-02)
+
+* Revert conversion of respond_to? to defined?, as it breaks with unused refinements on Ruby 2 (jeremyevans) (#1919)
+
+=== 5.60.0 (2022-09-01)
+
+* Support arbitrary expressions for date_arithmetic interval values on PostgreSQL 9.4+ (jeremyevans)
+
+* Support native IS DISTINCT FROM on SQLite 3.39+ instead of emulating support in the is_distinct_from extension (jeremyevans)
+
+* Support HAVING without GROUP BY on SQLite 3.39+ (jeremyevans)
+
+* Convert most respond_to? calls to equivalent defined? for better performance (jeremyevans)
+
+=== 5.59.0 (2022-08-01)
+
+* Set :allow_eager association option to false for instance specific associations without eager loaders (jeremyevans)
+
+* Add require_valid_schema plugin for checking that model classes have schema parsed as expected (jeremyevans)
+
+* Model classes created from aliased expressions and literal strings no longer use the simple table optimization (jeremyevans)
+
+* Model code that does not swallow connection errors will now also not swallow disconnect errors (jeremyevans) (#1892)
+
+* Add is_json and is_not_json methods to the pg_json_ops extension, for the PostgreSQL 15+ IS [NOT] JSON operator (jeremyevans)
+
+* Support :security_invoker view option on PostgreSQL 15+, for views where access uses permissions of user instead of owner (jeremyevans)
+
+* Support :nulls_distinct index option on PostgreSQL 15+, for NULLS [NOT] DISTINCT (jeremyevans)
+
+* Support sequel-postgres-pr driver in the postgres adapter (jeremyevans)
+
 === 5.58.0 (2022-07-01)
 
 * Support :disable_split_materialized Database option on MySQL to work around optimizer bug in MariaDB 10.5+ affecting association tests (jeremyevans)

data/README.rdoc

@@ -416,7 +416,7 @@ As with +delete+, +update+ affects all rows in the dataset, so +where+ first,
 
 === Merging records
 
-Merging records using the SQL MERGE statment is done using <tt>merge*</tt> methods.
+Merging records using the SQL MERGE statement is done using <tt>merge*</tt> methods.
 You use +merge_using+ to specify the merge source and join conditions.
 You can use +merge_insert+, +merge_delete+, and/or +merge_update+ to set the
 INSERT, DELETE, and UPDATE clauses for the merge. +merge_insert+ takes the same

data/bin/sequel

@@ -194,7 +194,11 @@ begin
     TO_DB = connect_proc[db2]
     same_db = DB.database_type==TO_DB.database_type
     index_opts = {:same_db=>same_db}
+
+    # :nocov:
     index_opts[:index_names] = :namespace if !DB.global_index_namespace? && TO_DB.global_index_namespace?
+    # :nocov:
+
     if DB.database_type == :sqlite && !same_db
       # SQLite integer types allows 64-bit integers
       TO_DB.extension :integer64
@@ -212,18 +216,20 @@ begin
     puts "Begin copying data"
     DB.transaction do
       TO_DB.transaction do
+        all_status_lines = ENV['SEQUEL_BIN_STATUS_ALL_LINES']
+
         DB.tables.each do |table|
           puts "Begin copying records for table: #{table}"
           time = Time.now
           to_ds = TO_DB.from(table)
           j = 0
           DB.from(table).each do |record|
-            if Time.now - time > 5
+            to_ds.insert(record)
+            j += 1
+            if Time.now - time > 5 || all_status_lines
               puts "Status: #{j} records copied" 
               time = Time.now
             end
-            to_ds.insert(record)
-            j += 1
           end
           puts "Finished copying #{j} records for table: #{table}"
         end
@@ -260,8 +266,10 @@ if !ARGV.empty?
   ARGV.each{|v| load(v)}
 elsif !$stdin.isatty
   eval($stdin.read)
+# :nocov:
 else
   require 'irb'
   puts "Your database is stored in DB..."
   IRB.start
 end
+# :nocov:

data/doc/opening_databases.rdoc

@@ -312,15 +312,14 @@ The following additional options are supported:
 
 === postgres
 
-Requires: pg (or postgres-pr/postgres-compat if pg is not available)
+Requires: pg (or sequel/postgres-pr or postgres-pr/postgres-compat if pg is not available)
 
-The Sequel postgres adapter works with the pg and postgres-pr ruby libraries.
+The Sequel postgres adapter works with the pg, sequel-postgres-pr, jeremyevans-postgres-pr, and postgres-pr ruby libraries.
 The pg library is the best supported, as it supports real bound variables and prepared statements.
 If the pg library is being used, Sequel will also attempt to load the sequel_pg library, which is
 a C extension that optimizes performance when Sequel is used with pg.  All users of Sequel who
-use pg are encouraged to install sequel_pg.  For users who want to use postgres-pr to avoid issues
-with C extensions, it is recommended to use jeremyevans-postgres-pr, which fixes many issues in
-the upstream postgres-pr gem, and is regularly tested with Sequel.
+use pg are encouraged to install sequel_pg.  For users who want to use one of the postgres-pr
+libraries to avoid issues with C extensions, it is recommended to use sequel-postgres-pr.
 
 The following additional options are supported:
 

data/doc/release_notes/5.59.0.txt

@@ -0,0 +1,73 @@
+= New Features
+
+* A require_valid_schema plugin has been added, for checking that
+  model classes have schema parsed as expected.  By default, model
+  classes are not required to have valid schema, because it is
+  allowed to have model classes based on arbitrary datasets (such
+  as those using joins or set-returning functions), and it is not
+  possible to determine the schema for arbitary datasets.
+
+  Sequel swallows non-connection errors when trying to parse schema
+  for a model's dataset, but if schema parsing fails when you would
+  expect it to succeed, it results in a model where typecasting does
+  not work as expected.
+
+  The require_valid_schema plugin will raise an error when setting
+  the dataset for a model if schema parsing fails and the dataset
+  uses a simple table where you would expect schema parsing to
+  succeed.  You can also provide an argument of :warn when loading
+  the plugin, to warn instead of raising an error.
+
+  This plugin may not work correctly in all cases for all adapters,
+  especially external adapters. Adapters are not required to support
+  schema parsing.  Even if supported, adapters may not support
+  parsing schema for qualified tables, or parsing schema for views.
+  You should consider this plugin as a possible safety net.  Users
+  are encouraged to try using it and report any unexpected breakage,
+  as that may help improve schema parsing in adapters that Sequel
+  ships.
+
+* is_json and is_not_json methods have been added to the pg_json_ops
+  extension, for the IS [NOT] JSON operator supported in PostgreSQL
+  15+.
+
+* Index creation methods on PostgreSQL 15+ now support a
+  :nulls_distinct option, for NULLS [NOT] DISTINCT.  This allows you
+  to create unique indexes where NULL values are not considered
+  distinct.
+
+* View creation methods on PostgreSQL 15+ now support a
+  :security_invoker option to create a view where access is
+  determined by the permissions of the role that is accessing the
+  view, instead of the role that created the view.
+
+= Other Improvements
+
+* The :allow_eager association option is now set to false by default
+  for associations explicitly marked as :instance_specific, if the
+  :eager_loader association is not given.
+  
+* The postgres adapter now supports the sequel-postgres-pr driver.
+  The sequel-postgres-pr driver is a slimmed down fork of the
+  postgres-pr driver designed specifically for use by Sequel.
+
+* Model code that explicitly does not swallow connection errors
+  will also now not swallow disconnect errors. This can fix issues
+  where model classes are being loaded at runtime, and the query to
+  get the columns/schema for the model uses a connection that has
+  been disconnected.
+
+* Model classes created from aliased expressions and literal
+  strings no longer use the simple_table optimization, as there
+  are cases where doing so is not safe.
+
+= Backwards Compatibility
+
+* The change to not swallow disconnect errors when not swallowing
+  connection errors can result in exceptions being raised which
+  weren't raised previously.  In most cases, this will alert you
+  to issues in your application that should be fixed, but it
+  potentially it can result in regressions if you were OK with
+  the errors being swallowed.  If this does result in regressions
+  in your application, please file an issue and we can probably
+  add a setting controlling this feature.

data/doc/release_notes/5.60.0.txt

@@ -0,0 +1,22 @@
+= New Features
+
+* The date_arithmetic extension now supports arbitrary expressions
+  as interval values on PostgreSQL 9.4+.  Previously, only integers
+  were supported for the interval values.
+
+= Other Improvements
+
+* Most Kernel#respond_to? calls have been converted to equivalent
+  defined? calls for better performance.  defined? is a keyword
+  and is about 50% faster for the same behavior.
+
+* The is_distinct_from extension now supports the IS DISTINCT FROM
+  syntax natively on SQLite 3.39+, instead of emulating it.
+
+* HAVING without GROUP BY is now supported on SQLite 3.39+.
+
+* Coverage testing has been significantly expanded.  Previously,
+  the core, model, plugin, and extension code had 100% line/branch
+  coverage.  100% line/branch coverage has been added for the
+  core extensions, bin/sequel, and the postgres adapter with the
+  pg driver.

data/lib/sequel/adapters/postgres.rb

@@ -5,6 +5,7 @@ require_relative 'shared/postgres'
 begin 
   require 'pg' 
 
+  # :nocov:
   Sequel::Postgres::PGError = PG::Error if defined?(PG::Error)
   Sequel::Postgres::PGconn = PG::Connection if defined?(PG::Connection)
   Sequel::Postgres::PGresult = PG::Result if defined?(PG::Result)
@@ -14,30 +15,40 @@ begin
     raise LoadError unless defined?(PGconn::CONNECTION_OK)
   end
 
-  Sequel::Postgres::USES_PG = true
   if defined?(PG::TypeMapByClass)
+  # :nocov:
     type_map = Sequel::Postgres::PG_QUERY_TYPE_MAP = PG::TypeMapByClass.new
     type_map[Integer] = PG::TextEncoder::Integer.new
     type_map[FalseClass] = type_map[TrueClass] = PG::TextEncoder::Boolean.new
     type_map[Float] = PG::TextEncoder::Float.new
   end
+
+  Sequel::Postgres::USES_PG = true
 rescue LoadError => e 
+  # :nocov:
   begin
-    require 'postgres-pr/postgres-compat'
-    Sequel::Postgres::USES_PG = false
+    require 'sequel/postgres-pr'
   rescue LoadError 
-    raise e 
+    begin
+      require 'postgres-pr/postgres-compat'
+    rescue LoadError 
+      raise e 
+    end 
   end 
+  Sequel::Postgres::USES_PG = false
+  # :nocov:
 end
 
 module Sequel
   module Postgres
-    if Sequel::Postgres::USES_PG
+    # :nocov:
+    if USES_PG
       # Whether the given sequel_pg version integer is supported.
       def self.sequel_pg_version_supported?(version)
         version >= 10617
       end
     end
+    # :nocov:
 
     # PGconn subclass for connection specific methods used with the
     # pg or postgres-pr driver.
@@ -45,7 +56,9 @@ module Sequel
       # The underlying exception classes to reraise as disconnect errors
       # instead of regular database errors.
       DISCONNECT_ERROR_CLASSES = [IOError, Errno::EPIPE, Errno::ECONNRESET]
+      # :nocov:
       if defined?(::PG::ConnectionBad)
+      # :nocov:
         DISCONNECT_ERROR_CLASSES << ::PG::ConnectionBad
       end
       DISCONNECT_ERROR_CLASSES.freeze
@@ -71,11 +84,14 @@ module Sequel
         # are SQL strings.
         attr_reader :prepared_statements
 
+      # :nocov:
         unless public_method_defined?(:async_exec_params)
           alias async_exec_params async_exec
         end
-      else
-        # Make postgres-pr look like pg
+      elsif !const_defined?(:CONNECTION_OK)
+        # Handle old postgres-pr
+        # sequel-postgres-pr already implements this API
+
         CONNECTION_OK = -1
 
         # Escape bytea values.  Uses historical format instead of hex
@@ -111,6 +127,7 @@ module Sequel
           alias cmd_tuples cmdtuples
         end 
       end
+      # :nocov:
       
       # Raise a Sequel::DatabaseDisconnectError if a one of the disconnect
       # error classes is raised, or a PGError is raised and the connection
@@ -204,7 +221,9 @@ module Sequel
             :sslmode => opts[:sslmode],
             :sslrootcert => opts[:sslrootcert]
           }.delete_if { |key, value| blank_object?(value) }
+          # :nocov:
           connection_params.merge!(opts[:driver_options]) if opts[:driver_options]
+          # :nocov:
           conn = Adapter.connect(opts[:conn_str] || connection_params)
 
           conn.instance_variable_set(:@prepared_statements, {})
@@ -212,6 +231,13 @@ module Sequel
           if receiver = opts[:notice_receiver]
             conn.set_notice_receiver(&receiver)
           end
+
+          # :nocov:
+          if conn.respond_to?(:type_map_for_queries=) && defined?(PG_QUERY_TYPE_MAP)
+          # :nocov:
+            conn.type_map_for_queries = PG_QUERY_TYPE_MAP
+          end
+        # :nocov:
         else
           unless typecast_value_boolean(@opts.fetch(:force_standard_strings, true))
             raise Error, "Cannot create connection using postgres-pr unless force_standard_strings is set"
@@ -226,12 +252,11 @@ module Sequel
             opts[:password]
           )
         end
+        # :nocov:
 
         conn.instance_variable_set(:@db, self)
-        if USES_PG && conn.respond_to?(:type_map_for_queries=) && defined?(PG_QUERY_TYPE_MAP)
-          conn.type_map_for_queries = PG_QUERY_TYPE_MAP
-        end
 
+        # :nocov:
         if encoding = opts[:encoding] || opts[:charset]
           if conn.respond_to?(:set_client_encoding)
             conn.set_client_encoding(encoding)
@@ -239,6 +264,7 @@ module Sequel
             conn.async_exec("set client_encoding to '#{encoding}'")
           end
         end
+        # :nocov:
 
         connection_configuration_sqls(opts).each{|sql| conn.execute(sql)}
         conn
@@ -265,7 +291,9 @@ module Sequel
         nil
       end
 
+      # :nocov:
       if USES_PG && Object.const_defined?(:PG) && ::PG.const_defined?(:Constants) && ::PG::Constants.const_defined?(:PG_DIAG_SCHEMA_NAME)
+      # :nocov:
         # Return a hash of information about the related PGError (or Sequel::DatabaseError that
         # wraps a PGError), with the following entries (any of which may be +nil+):
         #
@@ -316,7 +344,9 @@ module Sequel
         synchronize(opts[:server]){|conn| check_database_errors{_execute(conn, sql, opts, &block)}}
       end
 
+      # :nocov:
       if USES_PG
+      # :nocov:
         # +copy_table+ uses PostgreSQL's +COPY TO STDOUT+ SQL statement to return formatted
         # results directly to the caller.  This method is only supported if pg is the
         # underlying ruby driver.  This method should only be called if you want
@@ -509,8 +539,10 @@ module Sequel
       def adapter_initialize
         @use_iso_date_format = typecast_value_boolean(@opts.fetch(:use_iso_date_format, true))
         initialize_postgres_adapter
+        # :nocov:
         add_conversion_proc(17, method(:unescape_bytea)) if USES_PG
         add_conversion_proc(1082, TYPE_TRANSLATOR_DATE) if @use_iso_date_format
+        # :nocov:
         self.convert_infinite_timestamps = @opts[:convert_infinite_timestamps]
       end
 
@@ -520,19 +552,22 @@ module Sequel
       rescue => e
         raise_error(e, :classes=>database_error_classes)
       end
-
       # Set the DateStyle to ISO if configured, for faster date parsing.
       def connection_configuration_sqls(opts=@opts)
         sqls = super
+        # :nocov:
         sqls << "SET DateStyle = 'ISO'" if @use_iso_date_format
+        # :nocov:
         sqls
       end
 
+      # :nocov:
       if USES_PG
         def unescape_bytea(s)
           ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s))
         end
       end
+      # :nocov:
 
       DATABASE_ERROR_CLASSES = [PGError].freeze
       def database_error_classes
@@ -546,7 +581,9 @@ module Sequel
       end
 
       def database_exception_sqlstate(exception, opts)
+        # :nocov:
         if exception.respond_to?(:result) && (result = exception.result)
+        # :nocov:
           result.error_field(PGresult::PG_DIAG_SQLSTATE)
         end
       end
@@ -656,7 +693,9 @@ module Sequel
         clone(:where=>Sequel.lit(['CURRENT OF '], Sequel.identifier(cursor_name)))
       end
 
+      # :nocov:
       if USES_PG
+      # :nocov:
         PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
         
         # PostgreSQL specific argument mapper used for mapping the named
@@ -803,6 +842,7 @@ module Sequel
   end
 end
 
+# :nocov:
 if Sequel::Postgres::USES_PG && !ENV['NO_SEQUEL_PG']
   begin
     require 'sequel_pg'
@@ -814,3 +854,4 @@ if Sequel::Postgres::USES_PG && !ENV['NO_SEQUEL_PG']
   rescue LoadError
   end
 end
+# :nocov:

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

@@ -230,7 +230,6 @@ module Sequel
     module DatabaseMethods
       include UnmodifiedIdentifiers::DatabaseMethods
 
-      PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
       FOREIGN_KEY_LIST_ON_DELETE_MAP = {'a'=>:no_action, 'r'=>:restrict, 'c'=>:cascade, 'n'=>:set_null, 'd'=>:set_default}.freeze
       ON_COMMIT = {:drop => 'DROP', :delete_rows => 'DELETE ROWS', :preserve_rows => 'PRESERVE ROWS'}.freeze
       ON_COMMIT.each_value(&:freeze)
@@ -365,9 +364,10 @@ module Sequel
 
         table_oid = regclass_oid(table)
         im = input_identifier_meth
-        unless column = im.call(opts[:column] || ((sch = schema(table).find{|_, sc| sc[:primary_key] && sc[:auto_increment]}) && sch[0]))
+        unless column = (opts[:column] || ((sch = schema(table).find{|_, sc| sc[:primary_key] && sc[:auto_increment]}) && sch[0]))
           raise Error, "could not determine column to convert from serial to identity automatically"
         end
+        column = im.call(column)
 
         column_num = ds.from(:pg_attribute).
           where(:attrelid=>table_oid, :attname=>column).
@@ -569,10 +569,12 @@ module Sequel
         if server_version >= 90500
           cpos = Sequel.expr{array_position(co[:conkey], ctable[:attnum])}
           rpos = Sequel.expr{array_position(co[:confkey], rtable[:attnum])}
+        # :nocov:
         else
           range = 0...32
           cpos = Sequel.expr{SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:conkey], [x]), x]}, 32, ctable[:attnum])}
           rpos = Sequel.expr{SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:confkey], [x]), x]}, 32, rtable[:attnum])}
+        # :nocov:
         end
 
         ds = metadata_dataset.
@@ -653,9 +655,11 @@ module Sequel
 
         if server_version >= 90500
           order = [Sequel[:indc][:relname], Sequel.function(:array_position, Sequel[:ind][:indkey], Sequel[:att][:attnum])]
+        # :nocov:
         else
           range = 0...32
           order = [Sequel[:indc][:relname], SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(Sequel[:ind][:indkey], [x]), x]}, 32, Sequel[:att][:attnum])]
+        # :nocov:
         end
 
         attnums = SQL::Function.new(:ANY, Sequel[:ind][:indkey])
@@ -676,8 +680,10 @@ module Sequel
           select{[indc[:relname].as(:name), ind[:indisunique].as(:unique), att[:attname].as(:column), con[:condeferrable].as(:deferrable)]}
 
         ds = ds.where(:indpred=>nil) unless opts[:include_partial]
+        # :nocov:
         ds = ds.where(:indisready=>true) if server_version >= 80300
         ds = ds.where(:indislive=>true) if server_version >= 90300
+        # :nocov:
 
         indexes = {}
         ds.each do |r|
@@ -758,10 +764,12 @@ module Sequel
           seq_ds = metadata_dataset.from(:pg_sequence).where(:seqrelid=>regclass_oid(LiteralString.new(seq)))
           increment_by = :seqincrement
           min_value = :seqmin
+        # :nocov:
         else
           seq_ds = metadata_dataset.from(LiteralString.new(seq))
           increment_by = :increment_by
           min_value = :min_value
+        # :nocov:
         end
 
         get{setval(seq, db[table].select(coalesce(max(pk)+seq_ds.select(increment_by), seq_ds.select(min_value))), false)}
@@ -774,7 +782,9 @@ module Sequel
       # PostgreSQL uses SERIAL psuedo-type instead of AUTOINCREMENT for
       # managing incrementing primary keys.
       def serial_primary_key_options
+        # :nocov:
         auto_increment_key = server_version >= 100002 ? :identity : :serial
+        # :nocov:
         {:primary_key => true, auto_increment_key => true, :type=>Integer}
       end
 
@@ -1152,7 +1162,7 @@ module Sequel
         when :hash
           mod, remainder = generator.hash_values
           sql << " FOR VALUES WITH (MODULUS #{literal(mod)}, REMAINDER #{literal(remainder)})"
-        when :default
+        else # when :default
           sql << " DEFAULT"
         end
 
@@ -1247,6 +1257,10 @@ module Sequel
       def create_view_prefix_sql(name, options)
         sql = create_view_sql_append_columns("CREATE #{'OR REPLACE 'if options[:replace]}#{'TEMPORARY 'if options[:temp]}#{'RECURSIVE ' if options[:recursive]}#{'MATERIALIZED ' if options[:materialized]}VIEW #{quote_schema_table(name)}", options[:columns] || options[:recursive])
 
+        if options[:security_invoker]
+          sql += " WITH (security_invoker)"
+        end
+
         if tablespace = options[:tablespace]
           sql += " TABLESPACE #{quote_identifier(tablespace)}"
         end
@@ -1304,16 +1318,20 @@ module Sequel
       def index_definition_sql(table_name, index)
         cols = index[:columns]
         index_name = index[:name] || default_index_name(table_name, cols)
+
         expr = if o = index[:opclass]
           "(#{Array(cols).map{|c| "#{literal(c)} #{o}"}.join(', ')})"
         else
           literal(Array(cols))
         end
+
         if_not_exists = " IF NOT EXISTS" if index[:if_not_exists]
         unique = "UNIQUE " if index[:unique]
         index_type = index[:type]
         filter = index[:where] || index[:filter]
         filter = " WHERE #{filter_expr(filter)}" if filter
+        nulls_distinct = " NULLS#{' NOT' if index[:nulls_distinct] == false} DISTINCT" unless index[:nulls_distinct].nil?
+
         case index_type
         when :full_text
           expr = "(to_tsvector(#{literal(index[:language] || 'simple')}::regconfig, #{literal(dataset.send(:full_text_string_join, cols))}))"
@@ -1321,7 +1339,8 @@ module Sequel
         when :spatial
           index_type = :gist
         end
-        "CREATE #{unique}INDEX#{' CONCURRENTLY' if index[:concurrently]}#{if_not_exists} #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{"USING #{index_type} " if index_type}#{expr}#{" INCLUDE #{literal(Array(index[:include]))}" if index[:include]}#{" TABLESPACE #{quote_identifier(index[:tablespace])}" if index[:tablespace]}#{filter}"
+
+        "CREATE #{unique}INDEX#{' CONCURRENTLY' if index[:concurrently]}#{if_not_exists} #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{"USING #{index_type} " if index_type}#{expr}#{" INCLUDE #{literal(Array(index[:include]))}" if index[:include]}#{nulls_distinct}#{" TABLESPACE #{quote_identifier(index[:tablespace])}" if index[:tablespace]}#{filter}"
       end
 
       # Setup datastructures shared by all postgres adapters.
@@ -1347,11 +1366,6 @@ module Sequel
         end
       end
 
-      # Use a dollar sign instead of question mark for the argument placeholder.
-      def prepared_arg_placeholder
-        PREPARED_ARG_PLACEHOLDER
-      end
-
       # Return an expression the oid for the table expr.  Used by the metadata parsing
       # code to disambiguate unqualified tables.
       def regclass_oid(expr, opts=OPTS)
@@ -1425,10 +1439,14 @@ module Sequel
           where{{pg_class[:oid]=>oid}}.
           order{pg_attribute[:attnum]}
 
+        # :nocov:
         if server_version > 100000
+        # :nocov:
           ds = ds.select_append{pg_attribute[:attidentity]}
 
+          # :nocov:
           if server_version > 120000
+          # :nocov:
             ds = ds.select_append{Sequel.~(pg_attribute[:attgenerated]=>'').as(:generated)}
           end
         end
@@ -1516,7 +1534,9 @@ module Sequel
 
       # PostgreSQL 9.4+ supports views with check option.
       def view_with_check_option_support
+        # :nocov:
         :local if server_version >= 90400
+        # :nocov:
       end
     end
 
@@ -1912,6 +1932,8 @@ module Sequel
           server_version >= 90000
         when :groups, :exclude
           server_version >= 110000
+        else
+          false
         end
       end
     
@@ -2058,12 +2080,11 @@ module Sequel
 
       # Return the primary key to use for RETURNING in an INSERT statement
       def insert_pk
-        if (f = opts[:from]) && !f.empty?
-          case t = f.first
-          when Symbol, String, SQL::Identifier, SQL::QualifiedIdentifier
-            if pk = db.primary_key(t)
-              Sequel::SQL::Identifier.new(pk)
-            end
+        (f = opts[:from]) && !f.empty? && (t = f.first)
+        case t
+        when Symbol, String, SQL::Identifier, SQL::QualifiedIdentifier
+          if pk = db.primary_key(t)
+            Sequel::SQL::Identifier.new(pk)
           end
         end
       end

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

@@ -663,7 +663,7 @@ module Sequel
       
       # HAVING requires GROUP BY on SQLite
       def having(*cond)
-        raise(InvalidOperation, "Can only specify a HAVING clause on a grouped dataset") unless @opts[:group]
+        raise(InvalidOperation, "Can only specify a HAVING clause on a grouped dataset") if !@opts[:group] && db.sqlite_version < 33900
         super
       end
       

data/lib/sequel/database/schema_generator.rb

@@ -262,6 +262,7 @@ module Sequel
       #                  operations on the table while the index is being
       #                  built.
       # :if_not_exists :: Only create the index if an index of the same name doesn't already exist.
+      # :nulls_distinct :: Set whether separate NULLs should be considered distinct values in unique indexes.
       # :opclass :: Set an opclass to use for all columns (per-column opclasses require
       #             custom SQL).
       # :tablespace :: Specify tablespace for index.

data/lib/sequel/database/schema_methods.rb

@@ -295,6 +295,9 @@ module Sequel
     #               in a subquery, if you are providing a Dataset as the source
     #               argument, if should probably call the union method with the
     #               all: true and from_self: false options.
+    # :security_invoker :: Set the security_invoker property on the view, making
+    #                      the access to the view use the current user's permissions,
+    #                      instead of the view owner's permissions.
     # :tablespace :: The tablespace to use for materialized views.
     def create_view(name, source, options = OPTS)
       execute_ddl(create_view_sql(name, source, options))

data/lib/sequel/extensions/date_arithmetic.rb

@@ -32,6 +32,10 @@
 #
 #   DB[:table].select(add.as(:d)).where(sub > Sequel::CURRENT_TIMESTAMP)
 #
+# On most databases, the values you provide for years/months/days/etc. must
+# be numeric values and not arbitrary SQL expressions.  However, on PostgreSQL
+# 9.4+, use of arbitrary SQL expressions is supported.
+#
 # Related module: Sequel::SQL::DateAdd
 
 #
@@ -54,7 +58,16 @@ module Sequel
           interval = interval.parts
         end
         parts = {}
-        interval.each{|k,v| parts[k] = -v unless v.nil?}
+        interval.each do |k,v|
+          case v
+          when nil
+            # ignore
+          when Numeric
+            parts[k] = -v
+          else
+            parts[k] = Sequel::SQL::NumericExpression.new(:*, v, -1)
+          end
+        end
         DateAdd.new(expr, parts, opts)
       end
     end
@@ -68,6 +81,7 @@ module Sequel
       module DatasetMethods
         DURATION_UNITS = [:years, :months, :days, :hours, :minutes, :seconds].freeze
         DEF_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| s.to_s.freeze}).freeze
+        POSTGRES_DURATION_UNITS = DURATION_UNITS.zip([:years, :months, :days, :hours, :mins, :secs].map{|s| s.to_s.freeze}).freeze
         MYSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s.upcase[0...-1]).freeze}).freeze
         MSSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s[0...-1]).freeze}).freeze
         H2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| s.to_s[0...-1].freeze}).freeze
@@ -87,14 +101,28 @@ module Sequel
 
           cast = case db_type = db.database_type
           when :postgres
-            interval = String.new
-            each_valid_interval_unit(h, DEF_DURATION_UNITS) do |value, sql_unit|
-              interval << "#{value} #{sql_unit} "
+            casted = Sequel.cast(expr, cast_type)
+
+            if db.server_version >= 90400
+              placeholder = []
+              vals = []
+              each_valid_interval_unit(h, POSTGRES_DURATION_UNITS) do |value, sql_unit|
+                placeholder << "#{', ' unless placeholder.empty?}#{sql_unit} := "
+                vals << value
+              end
+              interval = Sequel.function(:make_interval, Sequel.lit(placeholder, *vals)) unless vals.empty?
+            else
+              parts = String.new
+              each_valid_interval_unit(h, DEF_DURATION_UNITS) do |value, sql_unit|
+                parts << "#{value} #{sql_unit} "
+              end
+              interval = Sequel.cast(parts, :interval) unless parts.empty?
             end
-            if interval.empty?
-              return literal_append(sql, Sequel.cast(expr, cast_type))
+
+            if interval
+              return complex_expression_sql_append(sql, :+, [casted, interval])
             else
-              return complex_expression_sql_append(sql, :+, [Sequel.cast(expr, cast_type), Sequel.cast(interval, :interval)])
+              return literal_append(sql, casted)
             end
           when :sqlite
             args = [expr]

data/lib/sequel/extensions/is_distinct_from.rb

@@ -3,7 +3,7 @@
 # The is_distinct_from extension adds the ability to use the
 # SQL standard IS DISTINCT FROM operator, which is similar to the
 # not equals operator, except that NULL values are considered
-# equal.  Only PostgreSQL and H2 currently support this operator.  On 
+# equal.  PostgreSQL, SQLite 3.39+, and H2 currently support this operator.  On 
 # other databases, support is emulated.
 #
 # First, you need to load the extension into the database:
@@ -90,6 +90,8 @@ module Sequel
           case db.database_type
           when :postgres, :h2
             true
+          when :sqlite
+            db.sqlite_version >= 33900
           else
             false
           end

data/lib/sequel/extensions/pg_json_ops.rb

@@ -123,6 +123,15 @@
 #   c = Sequel.pg_jsonb_op(:c)
 #   DB[:t].update(c['key1'] => 1.to_json, c['key2'] => "a".to_json)
 #
+# On PostgreSQL 15+, the <tt>IS [NOT] JSON</tt> operator is supported:
+#
+#   j.is_json                              # j IS JSON
+#   j.is_json(type: :object)               # j IS JSON OBJECT
+#   j.is_json(type: :object, unique: true) # j IS JSON OBJECT WITH UNIQUE
+#   j.is_not_json                          # j IS NOT JSON
+#   j.is_json(type: :array)                # j IS NOT JSON ARRAY
+#   j.is_json(unique: true)                # j IS NOT JSON WITH UNIQUE
+#
 # If you are also using the pg_json extension, you should load it before
 # loading this extension.  Doing so will allow you to use the #op method on
 # JSONHash, JSONHarray, JSONBHash, and JSONBArray, allowing you to perform json/jsonb operations
@@ -151,6 +160,18 @@ module Sequel
       GET_PATH = ["(".freeze, " #> ".freeze, ")".freeze].freeze
       GET_PATH_TEXT = ["(".freeze, " #>> ".freeze, ")".freeze].freeze
 
+      IS_JSON = ["(".freeze, " IS JSON".freeze, "".freeze, ")".freeze].freeze
+      IS_NOT_JSON = ["(".freeze, " IS NOT JSON".freeze, "".freeze, ")".freeze].freeze
+      EMPTY_STRING = Sequel::LiteralString.new('').freeze
+      WITH_UNIQUE = Sequel::LiteralString.new(' WITH UNIQUE').freeze
+      IS_JSON_MAP = {
+        nil => EMPTY_STRING,
+        :value => Sequel::LiteralString.new(' VALUE').freeze,
+        :scalar => Sequel::LiteralString.new(' SCALAR').freeze,
+        :object => Sequel::LiteralString.new(' OBJECT').freeze,
+        :array => Sequel::LiteralString.new(' ARRAY').freeze
+      }.freeze
+
       # Get JSON array element or object field as json.  If an array is given,
       # gets the object at the specified path.
       #
@@ -233,6 +254,30 @@ module Sequel
         end
       end
 
+      # Return whether the json object can be parsed as JSON.
+      #
+      # Options:
+      # :type :: Check whether the json object can be parsed as a specific type
+      #          of JSON (:value, :scalar, :object, :array).
+      # :unique :: Check JSON objects for unique keys.
+      #
+      #   json_op.is_json                 # json IS JSON
+      #   json_op.is_json(type: :object)  # json IS JSON OBJECT
+      #   json_op.is_json(unique: true)   # json IS JSON WITH UNIQUE
+      def is_json(opts=OPTS)
+        _is_json(IS_JSON, opts)
+      end
+
+      # Return whether the json object cannot be parsed as JSON. The opposite
+      # of #is_json. See #is_json for options.
+      #
+      #   json_op.is_not_json                 # json IS NOT JSON
+      #   json_op.is_not_json(type: :object)  # json IS NOT JSON OBJECT
+      #   json_op.is_not_json(unique: true)   # json IS NOT JSON WITH UNIQUE
+      def is_not_json(opts=OPTS)
+        _is_json(IS_NOT_JSON, opts)
+      end
+
       # Returns a set of keys AS text in the json object.
       #
       #   json_op.keys # json_object_keys(json)
@@ -286,6 +331,13 @@ module Sequel
 
       private
 
+      # Internals of IS [NOT] JSON support
+      def _is_json(lit_array, opts)
+        raise Error, "invalid is_json :type option: #{opts[:type].inspect}" unless type = IS_JSON_MAP[opts[:type]]
+        unique = opts[:unique] ? WITH_UNIQUE : EMPTY_STRING
+        Sequel::SQL::BooleanExpression.new(:NOOP, Sequel::SQL::PlaceholderLiteralString.new(lit_array, [self, type, unique]))
+      end
+
       # Return a placeholder literal with the given str and args, wrapped
       # in an JSONOp or JSONBOp, used by operators that return json or jsonb.
       def json_op(str, args)

data/lib/sequel/extensions/symbol_aref.rb

@@ -35,6 +35,7 @@ if RUBY_VERSION >= '2.0'
   class Symbol
     prepend Sequel::SymbolAref
   end
+# :nocov:
 else
   class Symbol
     if method_defined?(:[])
@@ -51,3 +52,4 @@ else
     end
   end
 end
+# :nocov:

data/lib/sequel/model/associations.rb

@@ -1717,6 +1717,8 @@ module Sequel
         # :graph_select :: A column or array of columns to select from the associated table
         #                  when eagerly loading the association via +eager_graph+. Defaults to all
         #                  columns in the associated table.
+        # :instance_specific :: Marks the association as instance specific. Should be used if the association block
+        #                       uses instance specific state, or transient state (accessing current date/time, etc.).
         # :limit :: Limit the number of records to the provided value.  Use
         #           an array with two elements for the value to specify a
         #           limit (first element) and an offset (second element).
@@ -1856,6 +1858,16 @@ module Sequel
             # in certain places to disable optimizations.
             opts[:instance_specific] = _association_instance_specific_default(name)
           end
+          if (orig_opts[:instance_specific] || orig_opts[:dataset]) && !opts.has_key?(:allow_eager) && !opts[:eager_loader]
+            # For associations explicitly marked as instance specific, or that use the
+            # :dataset option, where :allow_eager is not set, and no :eager_loader is
+            # provided, disallow eager loading.  In these cases, eager loading is
+            # unlikely to work.  This is not done for implicit setting of :instance_specific,
+            # because implicit use is done by default for all associations with blocks,
+            # and the vast majority of associations with blocks use the block for filtering
+            # in a manner compatible with eager loading.
+            opts[:allow_eager] = false
+          end
           opts = assoc_class.new.merge!(opts)
 
           if opts[:clone] && !opts.cloneable?(cloned_assoc)

data/lib/sequel/model/base.rb

@@ -680,10 +680,11 @@ module Sequel
   
       private
       
-      # Yield to the passed block and if do_raise is false, swallow all errors other than DatabaseConnectionErrors.
+      # Yield to the passed block and if do_raise is false, swallow Sequel::Errors other than DatabaseConnectionError
+      # and DatabaseDisconnectError.
       def check_non_connection_error(do_raise=require_valid_table)
         db.transaction(:savepoint=>:only){yield}
-      rescue Sequel::DatabaseConnectionError
+      rescue Sequel::DatabaseConnectionError, Sequel::DatabaseDisconnectError
         raise
       rescue Sequel::Error
         raise if do_raise
@@ -693,9 +694,12 @@ module Sequel
       # this model's dataset.
       def convert_input_dataset(ds)
         case ds
-        when Symbol, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression, LiteralString
+        when Symbol, SQL::Identifier, SQL::QualifiedIdentifier
           self.simple_table = db.literal(ds).freeze
           ds = db.from(ds)
+        when SQL::AliasedExpression, LiteralString
+          self.simple_table = nil
+          ds = db.from(ds)
         when Dataset
           ds = ds.from_self(:alias=>ds.first_source) if ds.joined_dataset?
 
@@ -784,7 +788,7 @@ module Sequel
         schema_hash = {}
         ds_opts = dataset.opts
         get_columns = proc{check_non_connection_error{columns} || []}
-        schema_array = check_non_connection_error(false){db.schema(dataset, :reload=>reload)} if db.supports_schema_parsing?
+        schema_array = get_db_schema_array(reload) if db.supports_schema_parsing?
         if schema_array
           schema_array.each{|k,v| schema_hash[k] = v}
 
@@ -821,6 +825,12 @@ module Sequel
         schema_hash
       end
 
+      # Get the array of schema information for the dataset.  Returns nil if
+      # the schema information cannot be determined.
+      def get_db_schema_array(reload)
+        check_non_connection_error(false){db.schema(dataset, :reload=>reload)}
+      end
+
       # Uncached version of setter_methods, to be overridden by plugins
       # that want to modify the methods used.
       def get_setter_methods

data/lib/sequel/plugins/list.rb

@@ -33,7 +33,9 @@ module Sequel
     # You can provide a <tt>:scope</tt> option to scope the list.  This option
     # can be a symbol or array of symbols specifying column name(s), or a proc
     # that accepts a model instance and returns a dataset representing the list
-    # the object is in.
+    # the object is in.  You will need to provide a <tt>:scope</tt> option if
+    # the model's dataset uses a subquery (such as when using the class_table_inheritance
+    # plugin).
     # 
     # For example, if each item has a +user_id+ field, and you want every user
     # to have their own list:

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

@@ -63,7 +63,7 @@ module Sequel
           end
         end
         # :nocov:
-        ruby2_keywords(meth) if respond_to?(:ruby2_keywords, false)
+        mod.send(:ruby2_keywords, meth) if mod.respond_to?(:ruby2_keywords, true)
         # :nocov:
       end
 
@@ -97,7 +97,7 @@ module Sequel
             end
           end
           # :nocov:
-          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, false)
+          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
           # :nocov:
         end
 
@@ -129,7 +129,7 @@ module Sequel
             end
           end
           # :nocov:
-          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, false)
+          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
           # :nocov:
         end
 
@@ -159,7 +159,7 @@ module Sequel
             end
           end
           # :nocov:
-          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, false)
+          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
           # :nocov:
         end
 

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -109,6 +109,13 @@ module Sequel
     # to eagerly set the associated objects, and having separate threads
     # modify the same model instance is not thread-safe.
     #
+    # Because this plugin will automatically use eager loading for
+    # performance, it can break code that defines associations that
+    # do not support eager loading, without marking that they do not
+    # support eager loading via the <tt>allow_eager: false</tt> option.
+    # Make sure to set <tt>allow_eager: false</tt> on any association
+    # used with this plugin if the association doesn't support eager loading.
+    #
     # Usage:
     #
     #   # Make all model subclass instances use tactical eager loading (called before loading subclasses)

data/lib/sequel/version.rb

@@ -6,11 +6,11 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 58
+  MINOR = 60
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
-  TINY  = 0
+  TINY  = 1
   
   # The version of Sequel you are using, as a string (e.g. "2.11.0")
   VERSION = [MAJOR, MINOR, TINY].join('.').freeze

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.58.0
+  version: 5.60.1
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-01 00:00:00.000000000 Z
+date: 2022-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -189,7 +189,9 @@ extra_rdoc_files:
 - doc/release_notes/5.56.0.txt
 - doc/release_notes/5.57.0.txt
 - doc/release_notes/5.58.0.txt
+- doc/release_notes/5.59.0.txt
 - doc/release_notes/5.6.0.txt
+- doc/release_notes/5.60.0.txt
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
@@ -275,7 +277,9 @@ files:
 - doc/release_notes/5.56.0.txt
 - doc/release_notes/5.57.0.txt
 - doc/release_notes/5.58.0.txt
+- doc/release_notes/5.59.0.txt
 - doc/release_notes/5.6.0.txt
+- doc/release_notes/5.60.0.txt
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
@@ -527,6 +531,7 @@ files:
 - lib/sequel/plugins/prepared_statements.rb
 - lib/sequel/plugins/prepared_statements_safe.rb
 - lib/sequel/plugins/rcte_tree.rb
+- lib/sequel/plugins/require_valid_schema.rb
 - lib/sequel/plugins/serialization.rb
 - lib/sequel/plugins/serialization_modification_detection.rb
 - lib/sequel/plugins/sharding.rb