sequel 5.97.0 → 5.98.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 236cf31a3c7848a6699dc871558a387748593a83dda8a722aad2e1c6beaad2d9
-  data.tar.gz: 974c8617fcecc74f10fab9c7fa8dd9e2f74a7a56767cf47cafd95e1108cc5f57
+  metadata.gz: 28641a0240d39f16a5b6f2d30986d44a8744c26e24de5e78b8e3823a409c48d2
+  data.tar.gz: 25435173509b5058e781f4b06b1ebf8005244e86864c5a72ac35bc739656a6b1
 SHA512:
-  metadata.gz: 5b396689d99af2a0882358e80150dc452b96a9cd09a73a9cdace42b903dd0958d341bf67e0570bd382dd051df54dc66b2d2b3e396506518c619d08bd006ebd1b
-  data.tar.gz: '0839e0177ccbb9d67880835b92e0b8767ea339b96375da914d0471a2cc24f25cdffbd8ada3b45ba69bdfc167a4609ed44fde1a7fd1db4c7574dff3f2efbfd80f'
+  metadata.gz: 11c7f62e3e296c43bef8af4de71ecaaf01e2e4d7e034910403991b91bc2075778dde0d16e899bc3ddacc1351e38da0f61f43476272e3b90c9a2aee5b09d82599
+  data.tar.gz: 173dfc5d3bbc19846a2d27b077d2241e6f64473f8a8f16ba052d9fd021d514036af1cf42cade4ea8974f2d920e126d4c23e824ab0e2d49a9062857ecd7e93342

data/lib/sequel/adapters/amalgalite.rb

@@ -62,11 +62,26 @@ module Sequel
       
       # Mimic the file:// uri, by having 2 preceding slashes specify a relative
       # path, and 3 preceding slashes specify an absolute path.
+      # Also support no preceding slashes to specify a relative path.
       def self.uri_to_options(uri) # :nodoc:
-        { :database => (uri.host.nil? && uri.path == '/') ? nil : "#{uri.host}#{uri.path}" }
+        database = if uri.host.nil?
+          case uri.path
+          when '/'
+            nil
+          when nil
+            uri.opaque
+          else
+            uri.path
+          end
+        else
+          "#{uri.host}#{uri.path}"
+        end
+
+        { :database => database }
       end
       private_class_method :uri_to_options
       
+      
       # Connect to the database.  Since SQLite is a file based database,
       # the only options available are :database (to specify the database
       # name), and :timeout, to specify how long to wait for the database to

data/lib/sequel/adapters/postgres.rb

@@ -516,6 +516,7 @@ module Sequel
                 end
               ensure
                 conn.execute("UNLISTEN *")
+                true while conn.wait_for_notify(0)
               end
             end
           end

data/lib/sequel/adapters/sqlite.rb

@@ -89,8 +89,22 @@ module Sequel
       
       # Mimic the file:// uri, by having 2 preceding slashes specify a relative
       # path, and 3 preceding slashes specify an absolute path.
+      # Also support no preceding slashes to specify a relative path.
       def self.uri_to_options(uri) # :nodoc:
-        { :database => (uri.host.nil? && uri.path == '/') ? nil : "#{uri.host}#{uri.path}" }
+        database = if uri.host.nil?
+          case uri.path
+          when '/'
+            nil
+          when nil
+            uri.opaque
+          else
+            uri.path
+          end
+        else
+          "#{uri.host}#{uri.path}"
+        end
+
+        { :database => database }
       end
       
       private_class_method :uri_to_options

data/lib/sequel/extensions/pg_auto_parameterize_duplicate_query_detection.rb

@@ -0,0 +1,191 @@
+# frozen-string-literal: true
+#
+# The pg_auto_parameterize_duplicate_query_detection extension builds on the
+# pg_auto_parameterize extension, adding support for detecting duplicate
+# queries inside a block that occur at the same location. This is designed
+# mostly to catch duplicate query issues (e.g. N+1 queries) during testing.
+#
+# To detect duplicate queries inside a block of code, wrap the code with
+# +detect_duplicate_queries+:
+#
+#   DB.detect_duplicate_queries{your_code}
+#
+# With this approach, if the test runs code where the same query is executed
+# more than once with the same call stack, a
+# Sequel::Postgres::AutoParameterizeDuplicateQueryDetection::DuplicateQueries
+# exception will be raised.
+#
+# You can pass the +:warn+ option to +detect_duplicate_queries+ to warn
+# instead of raising. Note that if the block passed to +detect_duplicate_queries+
+# raises, this extension will warn, and raise the original exception.
+#
+# For more control, you can pass the +:handler+ option to
+# +detect_duplicate_queries+. If the +:handler+ option is provided, this
+# extension will call the +:handler+ option with the hash of duplicate
+# query information, and will not raise or warn. This can be useful in
+# production environments, to record duplicate queries for later analysis.
+#
+# For accuracy, the entire call stack is always used as part of the hash key
+# to determine whether a query is duplicate. However, you can filter the
+# displayed backtrace by using the +:backtrace_filter+ option.
+#
+# +detect_duplicate_queries+ is concurrency aware, it uses the same approach
+# that Sequel's default connection pools use. So if you are running multiple
+# threads, +detect_duplicate_queries+ will only report duplicate queries for
+# the current thread (or fiber if the fiber_concurrency extension is used).
+#
+# When testing applications, it's probably best to use this to wrap the
+# application being tested. For example, testing with rack-test, if your app
+# is +App+, you would want to wrap it:
+#
+#   include Rack::Test::Methods
+#
+#   WrappedApp = lambda do |env|
+#     DB.detect_duplicate_queries{App.call(env)}
+#   end
+#
+#   def app
+#     WrappedApp
+#   end
+#
+# It is possible to use this to wrap each separate spec using an around hook,
+# but that can result in false positives when using libraries that have
+# implicit retrying (such as Capybara), as you can have the same call stack
+# for multiple requests.
+#
+# Related module: Sequel::Postgres::AutoParameterizeDuplicateQueryDetection
+
+module Sequel
+  module Postgres
+    # Enable detecting duplicate queries inside a block
+    module AutoParameterizeDuplicateQueryDetection
+      def self.extended(db)
+        db.instance_exec do
+          @duplicate_query_detection_contexts = {}
+          @duplicate_query_detection_mutex = Mutex.new
+        end
+      end
+
+      # Exception class raised when duplicate queries are detected.
+      class DuplicateQueries < Sequel::Error
+        # A hash of queries that were duplicate. Keys are arrays
+        # with 2 entries, the first being the query SQL, and the
+        # second being the related call stack (backtrace).
+        # The values are the number of query executions.
+        attr_reader :queries
+
+        def initialize(message, queries)
+          @queries = queries
+          super(message)
+        end
+      end
+
+      # Record each query executed so duplicates can be detected,
+      # if queries are being recorded.
+      def execute(sql, opts=OPTS, &block)
+        record, queries = duplicate_query_recorder_state
+
+        if record
+          queries[[sql.is_a?(Symbol) ? sql : sql.to_s, caller].freeze] += 1
+        end
+
+        super
+      end
+
+      # Ignore (do not record) queries inside given block. This can
+      # be useful in situations where you want to run your entire test suite
+      # with duplicate query detection, but you have duplicate queries in
+      # some parts of your application where it is not trivial to use a
+      # different approach. You can mark those specific sections with
+      # +ignore_duplicate_queries+, and still get duplicate query detection
+      # for the rest of the application.
+      def ignore_duplicate_queries(&block)
+        if state = duplicate_query_recorder_state
+          change_duplicate_query_recorder_state(state, false, &block)
+        else
+          # If we are not inside a detect_duplicate_queries block, there is
+          # no need to do anything, since we are not recording queries.
+          yield
+        end
+      end
+
+      # Run the duplicate query detector during the block.
+      # Options:
+      #
+      # :backtrace_filter :: Regexp used to filter the displayed backtrace.
+      # :handler :: If present, called with hash of duplicate query information,
+      #             instead of raising or warning.
+      # :warn :: Always warn instead of raising for duplicate queries.
+      #
+      # Note that if you nest calls to this method, only the top
+      # level call will respect the passed options.
+      def detect_duplicate_queries(opts=OPTS, &block)
+        current = Sequel.current
+        if state = duplicate_query_recorder_state(current)
+          return change_duplicate_query_recorder_state(state, true, &block)
+        end
+
+        @duplicate_query_detection_mutex.synchronize do
+          @duplicate_query_detection_contexts[current] = [true, Hash.new(0)]
+        end
+
+        begin
+          yield
+        rescue Exception => e
+          raise
+        ensure
+          _, queries = @duplicate_query_detection_mutex.synchronize do
+            @duplicate_query_detection_contexts.delete(current)
+          end
+          queries.delete_if{|_,v| v < 2}
+
+          unless queries.empty?
+            if handler = opts[:handler]
+              handler.call(queries)
+            else
+              backtrace_filter = opts[:backtrace_filter]
+              backtrace_filter_note = backtrace_filter ? " (filtered)" : ""
+              query_info = queries.map do |k,v|
+                backtrace = k[1]
+                backtrace = backtrace.grep(backtrace_filter) if backtrace_filter
+                "times:#{v}\nsql:#{k[0]}\nbacktrace#{backtrace_filter_note}:\n#{backtrace.join("\n")}\n"
+              end
+              message = "duplicate queries detected:\n\n#{query_info.join("\n")}"
+
+              if e || opts[:warn]
+                warn(message)
+              else
+                raise DuplicateQueries.new(message, queries)
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      # Get the query record state for the given context.
+      def duplicate_query_recorder_state(current=Sequel.current)
+        @duplicate_query_detection_mutex.synchronize{@duplicate_query_detection_contexts[current]}
+      end
+
+      # Temporarily change whether to record queries for the block, resetting the
+      # previous setting after the block exits.
+      def change_duplicate_query_recorder_state(state, setting)
+        prev = state[0]
+        state[0] = setting
+        
+        begin
+          yield
+        ensure
+          state[0] = prev
+        end
+      end
+    end
+  end
+
+  Database.register_extension(:pg_auto_parameterize_duplicate_query_detection) do |db|
+    db.extension(:pg_auto_parameterize)
+    db.extend(Postgres::AutoParameterizeDuplicateQueryDetection)
+  end
+end

data/lib/sequel/model/associations.rb

@@ -302,7 +302,7 @@ module Sequel
 
             if strategy == :window_function
               delete_rn = ds.row_number_column 
-              objects.each{|obj| obj.values.delete(delete_rn)}
+              objects.each{|obj| obj.remove_key!(delete_rn)}
             end
           elsif strategy == :union
             objects = []
@@ -1291,11 +1291,11 @@ module Sequel
           name = self[:name]
 
           self[:model].eager_load_results(self, eo) do |assoc_record|
-            assoc_record.values.delete(delete_rn) if delete_rn
+            assoc_record.remove_key!(delete_rn) if delete_rn
             hash_key = if uses_lcks
-              left_key_alias.map{|k| assoc_record.values.delete(k)}
+              left_key_alias.map{|k| assoc_record.remove_key!(k)}
             else
-              assoc_record.values.delete(left_key_alias)
+              assoc_record.remove_key!(left_key_alias)
             end
 
             objects = h[hash_key]
@@ -2387,7 +2387,7 @@ module Sequel
             delete_rn = opts.delete_row_number_column
 
             eager_load_results(opts, eo) do |assoc_record|
-              assoc_record.values.delete(delete_rn) if delete_rn
+              assoc_record.remove_key!(delete_rn) if delete_rn
               hash_key = uses_cks ? km.map{|k| assoc_record.get_column_value(k)} : assoc_record.get_column_value(km)
               objects = h[hash_key]
               if assign_singular

data/lib/sequel/model/base.rb

@@ -2,13 +2,15 @@
 
 module Sequel
   class Model
+    # SEQUEL6: Remove Enumerable here, and send all Enumerable methods to dataset
+    # by default, with a plugin for the current behavior.
     extend Enumerable
     extend Inflections
 
     # Class methods for Sequel::Model that implement basic model functionality.
     #
     # * All of the following methods have class methods created that send the method
-    #   to the model's dataset: all, as_hash, avg, count, cross_join, distinct, each,
+    #   to the model's dataset: all, any?, as_hash, avg, count, cross_join, distinct, each,
     #   each_server, empty?, except, exclude, exclude_having, fetch_rows,
     #   filter, first, first!, for_update, from, from_self, full_join, full_outer_join,
     #   get, graph, grep, group, group_and_count, group_append, group_by, having, import,
@@ -695,7 +697,7 @@ module Sequel
       end
   
       # Add model methods that call dataset methods
-      Plugins.def_dataset_methods(self, (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS + [:each_server]) - [:<<, :or, :[], :columns, :columns!, :delete, :update, :set_graph_aliases, :add_graph_aliases])
+      Plugins.def_dataset_methods(self, (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS + [:any?, :each_server]) - [:<<, :or, :[], :columns, :columns!, :delete, :update, :set_graph_aliases, :add_graph_aliases])
   
       private
       
@@ -1499,6 +1501,20 @@ END
         refresh
       end
   
+      # Remove a key from the instances values, and return the value
+      # of the key.
+      #
+      #   a = Album[1]
+      #   a.values
+      #   # => {id: 1, artist_id: 2}
+      #   a.remove_key!(:artist_id)
+      #   # => 2
+      #   a.values
+      #   # => {id: 1}
+      def remove_key!(key)
+        @values.delete(key)
+      end
+
       # Creates or updates the record, after making sure the record
       # is valid and before hooks execute successfully. Fails if:
       #

data/lib/sequel/plugins/insert_returning_select.rb

@@ -2,7 +2,7 @@
 
 module Sequel
   module Plugins
-    # If the model's dataset selects explicit columns and the
+    # If the model's dataset selects explicit columns (or table.*) and the
     # database supports it, the insert_returning_select plugin will
     # automatically set the RETURNING clause on the dataset used to
     # insert rows to the columns selected, which allows the default model
@@ -45,6 +45,9 @@ module Sequel
           ret
         end
 
+        RETURN_ALL = [Sequel::Dataset::WILDCARD].freeze
+        private_constant :RETURN_ALL
+
         # Determine the columns to use for the returning clause, or return nil
         # if they can't be determined and a returning clause should not be
         # added automatically.
@@ -52,6 +55,12 @@ module Sequel
           return unless ds.supports_returning?(:insert)
           return unless values = ds.opts[:select]
 
+          # SELECT table.* -> RETURNING *
+          if values.length == 1 && values[0].is_a?(Sequel::SQL::ColumnAll)
+            return RETURN_ALL
+          end
+
+          # SELECT column1, table.column2, ... -> RETURNING column1, column2, ...
           values = values.map{|v| ds.unqualified_column_for(v)}
           if values.all?
             values

data/lib/sequel/plugins/rcte_tree.rb

@@ -111,7 +111,7 @@ module Sequel
           ancestor_base_case_columns = prkey_array.zip(key_aliases).map{|k, ka_| SQL::AliasedExpression.new(k, ka_)} + c_all
           descendant_base_case_columns = key_array.zip(key_aliases).map{|k, ka_| SQL::AliasedExpression.new(k, ka_)} + c_all
           recursive_case_columns = prkey_array.zip(key_aliases).map{|k, ka_| SQL::QualifiedIdentifier.new(t, ka_)} + c_all
-          extract_key_alias = lambda{|m| key_aliases.map{|ka_| bd_conv[m.values.delete(ka_)]}}
+          extract_key_alias = lambda{|m| key_aliases.map{|ka_| bd_conv[m.remove_key!(ka_)]}}
         else
           key_present = key_conv = lambda{|m| m[key]}
           prkey_conv = lambda{|m| m[prkey]}
@@ -119,7 +119,7 @@ module Sequel
           ancestor_base_case_columns = [SQL::AliasedExpression.new(prkey, ka)] + c_all
           descendant_base_case_columns = [SQL::AliasedExpression.new(key, ka)] + c_all
           recursive_case_columns = [SQL::QualifiedIdentifier.new(t, ka)] + c_all
-          extract_key_alias = lambda{|m| bd_conv[m.values.delete(ka)]}
+          extract_key_alias = lambda{|m| bd_conv[m.remove_key!(ka)]}
         end
         
         parent = opts.merge(opts.fetch(:parent, OPTS)).fetch(:name, :parent)
@@ -200,7 +200,7 @@ module Sequel
           model.eager_load_results(r, eo.merge(:loader=>false, :initialize_rows=>false, :dataset=>ds, :id_map=>nil)) do |obj|
             opk = prkey_conv[obj]
             if idm_obj = parent_map[opk]
-              key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
+              key_aliases.each{|ka_| idm_obj[ka_] = obj[ka_]}
               obj = idm_obj
             else
               obj.associations[parent] = nil
@@ -307,12 +307,12 @@ module Sequel
           ds = ds.select_append(ka) unless ds.opts[:select] == nil
           model.eager_load_results(r, eo.merge(:loader=>false, :initialize_rows=>false, :dataset=>ds, :id_map=>nil, :associations=>OPTS)) do |obj|
             if level
-              no_cache = no_cache_level == obj.values.delete(la)
+              no_cache = no_cache_level == obj.remove_key!(la)
             end
             
             opk = prkey_conv[obj]
             if idm_obj = parent_map[opk]
-              key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
+              key_aliases.each{|ka_| idm_obj[ka_] = obj[ka_]}
               obj = idm_obj
             else
               obj.associations[childrena] = [] unless no_cache

data/lib/sequel/plugins/split_values.rb

@@ -54,6 +54,16 @@ module Sequel
           end
         end
 
+        # Remove the key from noncolumn values if it is present there. If it is not
+        # present there, then use the default behavior of removing it from values.
+        def remove_key!(key)
+          if @noncolumn_values && @noncolumn_values.key?(key)
+            @noncolumn_values.delete(key)
+          else
+            super
+          end
+        end
+
         # Check all entries in the values hash.  If any of the keys are not columns,
         # move the entry into the noncolumn_values hash.
         def split_noncolumn_values

data/lib/sequel/plugins/table_select.rb

@@ -9,6 +9,13 @@ module Sequel
     # in the result sets (and possibly overwrite columns in the
     # current model with the same name).
     #
+    # Note that by default on databases that supporting RETURNING,
+    # using this plugin will cause instance creations
+    # to use two queries (insert and refresh) instead of a single
+    # query using RETURNING.  You can use the insert_returning_select
+    # plugin to automatically use RETURNING for instance creations
+    # for models using this plugin.
+    #
     # Usage:
     #
     #   # Make all model subclasses select table.*

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 = 97
+  MINOR = 98
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.97.0
+  version: 5.98.0
 platform: ruby
 authors:
 - Jeremy Evans
@@ -250,6 +250,7 @@ files:
 - lib/sequel/extensions/pg_array.rb
 - lib/sequel/extensions/pg_array_ops.rb
 - lib/sequel/extensions/pg_auto_parameterize.rb
+- lib/sequel/extensions/pg_auto_parameterize_duplicate_query_detection.rb
 - lib/sequel/extensions/pg_auto_parameterize_in_array.rb
 - lib/sequel/extensions/pg_enum.rb
 - lib/sequel/extensions/pg_extended_date_support.rb