sequel 5.33.0 → 5.35.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b83782f79b268011fa8a7dd3af1f6eefc03a92b58ac7f2cf4f3411ee3a0bc16e
-  data.tar.gz: '00679a6acd9fef127e040be0ac93666fdf86f6cdf77d9220168e8b7acf13b069'
+  metadata.gz: 7ac0d24707f9029714f4e5258c484148d7dc10a733c0c33865d252141cd4cc2e
+  data.tar.gz: cdabb1bb51fdfe7b7a22df0a6a9102dd15366bbdd98100907b2e3d74db4e5878
 SHA512:
-  metadata.gz: f3502c155f4bc2a38c799e4e633fdd9267add64b80e35ac9c77d01ade6666d294ccb60e5fe6e438e94bf0b94f16127c7c35da1c37a40272eafd9f025474ec17f
-  data.tar.gz: fd8fde26b14389192787cd59d91def5a9efd4c1b5a8faa2a53c7da16fd479788516a233242548edf0c7901f9080038e9c1a4b967088e7eef4503c82cb153d628
+  metadata.gz: d87a7d026c51d8897c964cca01ad30384b853bdbbda42811ee7245ef669ac23c1093e572a0e414db5daeb84b8f417e63c14c3ac13aa0b12ac9eb8f801ea6e6c2
+  data.tar.gz: 3e788cabe74d01035b930ca699b5ebc763a6a34410c1b8a3a5075d5a276c5155355d9476303b6b606d1b0a74d6a535ca4fdca696cdc0b83e32658be45c8f946e

data/CHANGELOG

@@ -1,3 +1,45 @@
+=== 5.35.0 (2020-08-01)
+
+* Recognize another disconnect error in the oracle adapter (sterlzbd) (#1705)
+
+* Consider all associations with :dataset options as instance-specific associations (jeremyevans)
+
+* Make Model.finalize_associations not break with instance-specific associations (jeremyevans)
+
+* Make association placeholder loader consider block if instance_specific: false association option is used (jeremyevans)
+
+* Copy composite unique constraints when emulating alter table operations on SQLite (jeremyevans) (#1704)
+
+* Add instance_specific_default plugin for setting default association :instance_specific value, or warning/raising for cases where it is not specified (jeremyevans)
+
+* Make Model.plugin issue deprecation warning if loading plugin with arguments and block if plugin does not accept arguments/block (jeremyevans)
+
+* Make validation_class_methods consider all :if, :allow_missing, :allow_nil, and :allow_blank settings, instead of just the first (jeremyevans)
+
+* Include hash entries with nil keys in Dataset#to_dot output in to_dot extension (jeremyevans)
+
+* Remove unneeded conditionals from plugins and extensions (jeremyevans)
+
+* Fix exception class in run_transaction_hooks extension if calling run_after_{commit,rollback}_hooks outside of a transaction (jeremyevans)
+
+=== 5.34.0 (2020-07-01)
+
+* Make eager_graph work correctly if called with no associations (jeremyevans)
+
+* Make :ruby eager limit strategy handle cases where there is no limit or offset (jeremyevans)
+
+* Do not keep a reference to a Sequel::Database instance that raises an exception during initialization (jeremyevans)
+
+* Make Database#pool.all_connections not yield for a single connection pool in disconnected state (jeremyevans)
+
+* Raise an exception if trying to disconnect a server that doesn't exist in the sharded connection pools (jeremyevans)
+
+* Support :refresh option when calling *_pks getter method in the association_pks plugin (jeremyevans)
+
+* Support caching of repeated calls to *_pks getter method in the association_pks plugin using :cache_pks association option (jeremyevans)
+
+* Add *_pks_dataset methods for one_to_many and many_to_many associations when using the association_pks plugin (jeremyevans)
+
 === 5.33.0 (2020-06-01)
 
 * Support custom join types on a per-association basis when using eager_graph/association_join (jeremyevans)

data/doc/association_basics.rdoc

@@ -1676,11 +1676,16 @@ instances.
 ==== :instance_specific
 
 This allows you to override the setting of whether the dataset contains instance
-specific code.  For example, if you are passing a block to the association,
+specific code.  If you are passing a block to the association,
 Sequel sets this to true by default, which disables some optimizations that
 would be invalid if the association is instance specific.  If you know that the
 block does not contain instance specific code, you can set this to false to
-reenable the optimizations.
+reenable the optimizations.  Instance specific code is mostly commonly calling
+model instance methods inside an association block, but also
+includes cases where the association block can return different values based
+on the runtime environment, such as calls to <tt>Time.now</tt> in the block.
+Associations that use the :dataset option are always considered instance specific,
+even if explicitly specified otherwise.
 
 ==== :cartesian_product_number 
 

data/doc/dataset_filtering.rdoc

@@ -36,8 +36,8 @@ Ranges (both inclusive and exclusive) can also be used:
 
 If you need to select multiple items from a dataset, you can supply an array:
 
-	items.where(id: [1, 38, 47, 99]).sql
-	# "SELECT * FROM items WHERE (id IN (1, 38, 47, 99))"
+  items.where(id: [1, 38, 47, 99]).sql
+  # "SELECT * FROM items WHERE (id IN (1, 38, 47, 99))"
 
 == Filtering using expressions
 

data/doc/release_notes/5.34.0.txt

@@ -0,0 +1,40 @@
+= New Features
+
+* The association_pks plugin now creates *_pks_dataset methods for
+  each association.  These are similar to the existing *_pks getter
+  methods, but they return a dataset of the keys instead of the keys
+  themselves.
+
+* The association_pks plugin now supports a :cache_pks association
+  option, which will cache calls to the *_pks getter method. The
+  default behavior remains that the *_pks getter method only returns
+  cached values if the *_pks= setter method has been used to set the
+  values.
+
+* The *_pks getter methods supported by the association_pks plugin
+  now support a :refresh option to ignore any cached values, similar
+  to how the association getter methods work.
+
+= Other Improvements
+
+* If trying to disconnect a server that doesn't exist when using a
+  sharded connection pool, a Sequel::Error is now raised.  Previously,
+  the sharded threaded pool raised a NoMethodError and the sharded
+  single connection pool did not raise an error.
+
+* If using the :savepoint option when savepoints are not supported,
+  a Sequel::InvalidOperation exception is now raised, instead of a
+  NoMethodError.
+
+* Calling Dataset#eager_graph with no arguments now returns the
+  dataset.
+
+* If not connected to the database, the single connection pool will
+  not yield any connections to Database#pool.all_connections.
+
+* Forcing a :ruby eager limit strategy for an association without a
+  limit or offset now works correctly.
+
+* Multiple unnecessary conditionals have been removed.
+
+* Sequel core and model code now have 100% branch coverage.

data/doc/release_notes/5.35.0.txt

@@ -0,0 +1,56 @@
+= New Features
+
+* An instance_specific_default plugin has been added for setting the
+  default for the :instance_specific association option, or
+  warning/raises in cases where it is not specified.  This allows
+  you to easily find associations that would be considering instance
+  specific by default, and mark them as not instance specific for
+  better performance.
+
+= Other Improvements
+
+* Setting the :instance_specific association option to false now
+  works correctly if the association uses a block.  Associations
+  that set the :dataset option are now always considered instance
+  specific, even if the :instance_specific option is explicitly
+  passed.
+
+* The validation_class_methods plugin now considers all :if,
+  :allow_missing, :allow_nil, and :allow_blank options.  Previously,
+  it only considered the first of those options that was set.
+
+* Model.finalize_associations no longer breaks if you have
+  instance-specific associations.
+
+* Model.plugin now warns if you load the plugin with arguments or a
+  block if the plugin does not accept arguments or block.  This is
+  because a future change to Sequel could break the call.
+
+* When emulating unsupported alter table operations on SQLite, Sequel
+  now copies composite unique constraints unless the alter table
+  operation is the dropping of a unique constraint.
+
+* Sequel now recognizes an additional disconnect error in the oracle
+  adapter.
+
+* In the run_transaction_hooks extension, calling
+  run_after_{commit,rollback}_hooks now raises the correct exception
+  class.
+
+* In the pg_range extension, conversion procs for the tsrange[] and
+  tstzrange[] types are not added unless the Database uses the
+  pg_array extension.
+
+* Multiple unnecessary conditionals in plugins and extensions have
+  been removed.
+
+* Sequel plugin and extension code now have 100% branch coverage.
+
+* Sequel now avoids a statement not reached verbose warning in
+  Dataset#clone.
+
+= Backwards Compatibility
+
+* The output of Dataset#to_dot in the to_dot extension has changed
+  slightly, including hash entries with nil keys.  These entries
+  were previously ignored.

data/lib/sequel/adapters/oracle.rb

@@ -14,7 +14,8 @@ module Sequel
       # ORA-02396: exceeded maximum idle time, please connect again
       # ORA-03113: end-of-file on communication channel
       # ORA-03114: not connected to ORACLE
-      CONNECTION_ERROR_CODES = [ 28, 1012, 2396, 3113, 3114 ].freeze
+      # ORA-03135: connection lost contact
+      CONNECTION_ERROR_CODES = [ 28, 1012, 2396, 3113, 3114, 3135 ].freeze
       
       ORACLE_TYPES = {
         :blob=>lambda{|b| Sequel::SQL::Blob.new(b.read)},

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

@@ -269,6 +269,8 @@ module Sequel
             else
               duplicate_table(table, :no_foreign_keys=>true)
             end
+          when :unique
+            duplicate_table(table, :no_unique=>true)
           else
             duplicate_table(table)
           end
@@ -422,8 +424,12 @@ module Sequel
         skip_indexes = []
         indexes(table, :only_autocreated=>true).each do |name, h|
           skip_indexes << name
-          if h[:columns].length == 1 && h[:unique]
-            unique_columns.concat(h[:columns])
+          if h[:unique]
+            if h[:columns].length == 1
+              unique_columns.concat(h[:columns])
+            elsif h[:columns].map(&:to_s) != pks && !opts[:no_unique]
+              constraints << {:type=>:unique, :columns=>h[:columns]}
+            end
           end
         end
         unique_columns -= pks

data/lib/sequel/adapters/tinytds.rb

@@ -16,6 +16,7 @@ module Sequel
         c = TinyTds::Client.new(opts)
         c.query_options.merge!(:cache_rows=>false)
 
+        # SEQUEL6: Default to ansi: true
         if opts[:ansi]
           sql = %w(
             ANSI_NULLS

data/lib/sequel/connection_pool/sharded_single.rb

@@ -41,7 +41,10 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   # :server :: Should be a symbol specifing the server to disconnect from,
   #            or an array of symbols to specify multiple servers.
   def disconnect(opts=OPTS)
-    (opts[:server] ? Array(opts[:server]) : servers).each{|s| disconnect_server(s)}
+    (opts[:server] ? Array(opts[:server]) : servers).each do |s|
+      raise Sequel::Error, "invalid server: #{s}" unless @servers.has_key?(s)
+      disconnect_server(s)
+    end
   end
 
   def freeze

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -95,9 +95,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   #            or an array of symbols to specify multiple servers.
   def disconnect(opts=OPTS)
     (opts[:server] ? Array(opts[:server]) : sync{@servers.keys}).each do |s|
-      if conns = sync{disconnect_server_connections(s)}
-        disconnect_connections(conns)
-      end
+      disconnect_connections(sync{disconnect_server_connections(s)})
     end
   end
   
@@ -203,9 +201,9 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
 
     until conn = assign_connection(thread, server)
       elapsed = Sequel.elapsed_seconds_since(timer)
+      # :nocov:
       raise_pool_timeout(elapsed, server) if elapsed > timeout
 
-      # :nocov:
       # It's difficult to get to this point, it can only happen if there is a race condition
       # where a connection cannot be acquired even after the thread is signalled by the condition variable
       sync do
@@ -278,13 +276,15 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # Mark any allocated connections to be removed when they are checked back in. The calling
   # code should already have the mutex before calling this.
   def disconnect_server_connections(server)
-    @connections_to_remove.concat(allocated(server).values)
+    remove_conns = allocated(server)
+    dis_conns = available_connections(server)
+    raise Sequel::Error, "invalid server: #{server}" unless remove_conns && dis_conns
 
-    if dis_conns = available_connections(server)
-      conns = dis_conns.dup
-      dis_conns.clear
-      @waiters[server].signal
-    end
+    @connections_to_remove.concat(remove_conns.values)
+
+    conns = dis_conns.dup
+    dis_conns.clear
+    @waiters[server].signal
     conns
   end
 

data/lib/sequel/connection_pool/single.rb

@@ -11,7 +11,7 @@ class Sequel::SingleConnectionPool < Sequel::ConnectionPool
 
   # Yield the connection if one has been made.
   def all_connections
-    yield @conn.first if @conn
+    yield @conn.first unless @conn.empty?
   end
 
   # Disconnect the connection from the database.

data/lib/sequel/connection_pool/threaded.rb

@@ -152,9 +152,9 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
 
     until conn = assign_connection(thread)
       elapsed = Sequel.elapsed_seconds_since(timer)
+      # :nocov:
       raise_pool_timeout(elapsed) if elapsed > timeout
 
-      # :nocov:
       # It's difficult to get to this point, it can only happen if there is a race condition
       # where a connection cannot be acquired even after the thread is signalled by the condition variable
       sync do

data/lib/sequel/database/connecting.rb

@@ -36,7 +36,7 @@ module Sequel
           c = adapter_class(scheme)
           uri_options = c.send(:uri_to_options, uri)
           uri.query.split('&').map{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v if k && !k.empty?} unless uri.query.to_s.strip.empty?
-          uri_options.to_a.each{|k,v| uri_options[k] = (defined?(URI::DEFAULT_PARSER) ? URI::DEFAULT_PARSER : URI).unescape(v) if v.is_a?(String)}
+          uri_options.to_a.each{|k,v| uri_options[k] = URI::DEFAULT_PARSER.unescape(v) if v.is_a?(String)}
           opts = uri_options.merge(opts).merge!(:orig_opts=>opts.dup, :uri=>conn_string, :adapter=>scheme)
         end
       when Hash

data/lib/sequel/database/misc.rb

@@ -153,19 +153,23 @@ module Sequel
       reset_default_dataset
       adapter_initialize
 
-      unless typecast_value_boolean(@opts[:keep_reference]) == false
-        Sequel.synchronize{::Sequel::DATABASES.push(self)}
-      end
-      Sequel::Database.run_after_initialize(self)
+      keep_reference = typecast_value_boolean(@opts[:keep_reference]) != false
+      begin
+        Sequel.synchronize{::Sequel::DATABASES.push(self)} if keep_reference
+        Sequel::Database.run_after_initialize(self)
 
-      initialize_load_extensions(:preconnect_extensions)
+        initialize_load_extensions(:preconnect_extensions)
 
-      if typecast_value_boolean(@opts[:preconnect]) && @pool.respond_to?(:preconnect, true)
-        concurrent = typecast_value_string(@opts[:preconnect]) == "concurrently"
-        @pool.send(:preconnect, concurrent)
-      end
+        if typecast_value_boolean(@opts[:preconnect]) && @pool.respond_to?(:preconnect, true)
+          concurrent = typecast_value_string(@opts[:preconnect]) == "concurrently"
+          @pool.send(:preconnect, concurrent)
+        end
 
-      initialize_load_extensions(:extensions)
+        initialize_load_extensions(:extensions)
+      rescue
+        Sequel.synchronize{::Sequel::DATABASES.delete(self)} if keep_reference
+        raise
+      end
     end
 
     # Freeze internal data structures for the Database instance.
@@ -185,7 +189,9 @@ module Sequel
 
     # Disallow dup/clone for Database instances
     undef_method :dup, :clone, :initialize_copy
+    # :nocov:
     if RUBY_VERSION >= '1.9.3'
+    # :nocov:
       undef_method :initialize_clone, :initialize_dup
     end
 

data/lib/sequel/database/query.rb

@@ -344,7 +344,9 @@ module Sequel
 
     # Post process the schema values.  
     def schema_post_process(cols)
+      # :nocov:
       if RUBY_VERSION >= '2.5'
+      # :nocov:
         cols.each do |_, h|
           db_type = h[:db_type]
           if db_type.is_a?(String)

data/lib/sequel/database/schema_generator.rb

@@ -38,7 +38,6 @@ module Sequel
         @constraints = []
         @primary_key = nil
         instance_exec(&block) if block
-        @columns.unshift(@primary_key) if @primary_key && !has_column?(primary_key_name)
       end
 
       # Use custom Bignum method to use :Bignum instead of Bignum class, to work

data/lib/sequel/database/schema_methods.rb

@@ -494,7 +494,9 @@ module Sequel
       when :drop_index
         drop_index_sql(table, op)
       else
-        "ALTER TABLE #{quote_schema_table(table)} #{alter_table_op_sql(table, op)}"
+        if sql = alter_table_op_sql(table, op)
+          "ALTER TABLE #{quote_schema_table(table)} #{sql}"
+        end
       end
     end
 
@@ -811,23 +813,20 @@ module Sequel
     # Proxy the filter_expr call to the dataset, used for creating constraints.
     # Support passing Proc arguments as blocks, as well as treating plain strings
     # as literal strings, so that previous migrations that used this API do not break.
-    def filter_expr(*args, &block)
-      if args.length == 1
-        arg = args.first
-        if arg.is_a?(Proc) && !block
-          block = args.first
-          args = nil
-        elsif arg.is_a?(String)
-          args = [Sequel.lit(*args)]
-        elsif arg.is_a?(Array)
-          if arg.first.is_a?(String)
-            args = [Sequel.lit(*arg)]
-          elsif arg.length > 1
-            args = [Sequel.&(*arg)]
-          end
+    def filter_expr(arg=nil, &block)
+      if arg.is_a?(Proc) && !block
+        block = arg
+        arg = nil
+      elsif arg.is_a?(String)
+        arg = Sequel.lit(arg)
+      elsif arg.is_a?(Array)
+        if arg.first.is_a?(String)
+          arg = Sequel.lit(*arg)
+        elsif arg.length > 1
+          arg = Sequel.&(*arg)
         end
       end
-      schema_utility_dataset.literal(schema_utility_dataset.send(:filter_expr, *args, &block))
+      schema_utility_dataset.literal(schema_utility_dataset.send(:filter_expr, arg, &block))
     end
 
     # SQL statement for creating an index for the table with the given name

data/lib/sequel/database/transactions.rb

@@ -205,6 +205,10 @@ module Sequel
             end
           end
 
+          if opts[:savepoint] && !supports_savepoints?
+            raise Sequel::InvalidOperation, "savepoints not supported on #{database_type}"
+          end
+
           if already_in_transaction?(conn, opts)
             if opts[:rollback] == :always && !opts.has_key?(:savepoint)
               if supports_savepoints? 
@@ -418,11 +422,10 @@ module Sequel
     end
 
     # Retrieve the savepoint hooks that should be run for the given
-    # connection and commit status.
+    # connection and commit status.  This expacts that you are
+    # already inside a savepoint when calling.
     def savepoint_hooks(conn, committed)
-      if in_savepoint?(conn)
-        _trans(conn)[:savepoints].last[committed ? :after_commit : :after_rollback]
-      end
+      _trans(conn)[:savepoints].last[committed ? :after_commit : :after_rollback]
     end
 
     # Retrieve the transaction hooks that should be run for the given