sequel 5.97.0 → 5.99.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 236cf31a3c7848a6699dc871558a387748593a83dda8a722aad2e1c6beaad2d9
-  data.tar.gz: 974c8617fcecc74f10fab9c7fa8dd9e2f74a7a56767cf47cafd95e1108cc5f57
+  metadata.gz: 7e5d22a32d8c5f27e15e00203d0c2ce2a2fb3f5352d7b7c25c82389f4947882c
+  data.tar.gz: 81909dc070cc8d48def396ae76e953a1f31dc478b45d3a5fa8b69646bc7df094
 SHA512:
-  metadata.gz: 5b396689d99af2a0882358e80150dc452b96a9cd09a73a9cdace42b903dd0958d341bf67e0570bd382dd051df54dc66b2d2b3e396506518c619d08bd006ebd1b
-  data.tar.gz: '0839e0177ccbb9d67880835b92e0b8767ea339b96375da914d0471a2cc24f25cdffbd8ada3b45ba69bdfc167a4609ed44fde1a7fd1db4c7574dff3f2efbfd80f'
+  metadata.gz: c24ae48ece66511a09b2d8a5ad8b5b82e7486a4446bcb66108140b8afe449cd9c9e7645a29ca0bbe0c994d5c060a52f1ab4c41434dc068175751b1d6bd57b5dc
+  data.tar.gz: e8acd2e5cb4272bd47aed87e3077018dfc5ba9673856b871c8222eec6b2de1be0843840969e046efc459b52902753e9e0f0e35b95dcdcf31914d98b5f487d78a

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/shared/mssql.rb

@@ -679,7 +679,7 @@ module Sequel
    
       # MSSQL uses the CONTAINS keyword for full text search
       def full_text_search(cols, terms, opts = OPTS)
-        terms = "\"#{terms.join('" OR "')}\"" if terms.is_a?(Array)
+        terms = "\"#{Sequel.array_or_set_join(terms, '" OR "')}\"" if terms.is_a?(Array) || terms.is_a?(Set)
         where(Sequel.lit("CONTAINS (?, ?)", cols, terms))
       end
 

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

@@ -797,7 +797,7 @@ module Sequel
       
       # MySQL specific full text search syntax.
       def full_text_sql(cols, terms, opts = OPTS)
-        terms = terms.join(' ') if terms.is_a?(Array)
+        terms = Sequel.array_or_set_join(terms, ' ') if terms.is_a?(Array) || terms.is_a?(Set)
         SQL::PlaceholderLiteralString.new((opts[:boolean] ? MATCH_AGAINST_BOOLEAN : MATCH_AGAINST), [Array(cols), terms])
       end
 

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

@@ -669,12 +669,26 @@ module Sequel
         _set_constraints(' IMMEDIATE', opts)
       end
 
-      # Use the pg_* system tables to determine indexes on a table
+      # Use the pg_* system tables to determine indexes on a table. Options:
+      #
+      # :include_partial :: Set to true to include partial indexes
+      # :invalid :: Set to true or :only to only return invalid indexes.
+      #             Set to :include to also return both valid and invalid indexes.
+      #             When not set or other value given, does not return invalid indexes.
       def indexes(table, opts=OPTS)
         m = output_identifier_meth
         cond = {Sequel[:tab][:oid]=>regclass_oid(table, opts)}
         cond[:indpred] = nil unless opts[:include_partial]
 
+        case opts[:invalid]
+        when true, :only
+          cond[:indisvalid] = false
+        when :include
+          # nothing
+        else
+          cond[:indisvalid] = true
+        end
+
         indexes = {}
         _indexes_ds.where_each(cond) do |r|
           i = indexes[m.call(r[:name])] ||= {:columns=>[], :unique=>r[:unique], :deferrable=>r[:deferrable]}
@@ -1049,8 +1063,7 @@ module Sequel
             where{{
               indc[:relkind]=>%w'i I',
               ind[:indisprimary]=>false,
-              :indexprs=>nil,
-              :indisvalid=>true}}.
+              :indexprs=>nil}}.
             order(*order).
             select{[indc[:relname].as(:name), ind[:indisunique].as(:unique), att[:attname].as(:column), con[:condeferrable].as(:deferrable)]}
 
@@ -1757,7 +1770,7 @@ module Sequel
           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]}#{nulls_distinct}#{" TABLESPACE #{quote_identifier(index[:tablespace])}" if index[:tablespace]}#{filter}"
+        "CREATE #{unique}INDEX#{' CONCURRENTLY' if index[:concurrently]}#{if_not_exists} #{quote_identifier(index_name)} ON#{' ONLY' if index[:only]} #{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.
@@ -2160,7 +2173,7 @@ module Sequel
         end
 
         unless opts[:tsquery]
-          phrase_terms = terms.is_a?(Array) ? terms.join(' | ') : terms
+          phrase_terms = terms.is_a?(Array) || terms.is_a?(Set) ? Sequel.array_or_set_join(terms, ' | ') : terms
 
           query_func = case to_tsquery = opts[:to_tsquery]
           when :phrase, :plain

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

@@ -26,6 +26,8 @@ module Sequel
         h = {}
         o.each{|k, val| h[v(k)] = v(val)}
         h
+      when Set
+        Set.new(o.map{|x| v(x)})
       when SQL::NumericExpression
         if o.op == :extract
           o.class.new(o.op, o.args[0], v(o.args[1]))

data/lib/sequel/core.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-%w'bigdecimal date thread time uri'.each{|f| require f}
+%w'bigdecimal date set thread time uri'.each{|f| require f}
 
 # Top level module for Sequel
 #
@@ -164,6 +164,20 @@ module Sequel
       JSON::ParserError
     end
 
+    if RUBY_VERSION >= '3'
+      # Join the array or set.
+      def array_or_set_join(obj, arg)
+        obj.join(arg)
+      end
+    # :nocov:
+    else
+      def array_or_set_join(obj, arg)
+        obj = obj.to_a if obj.is_a?(Set)
+        obj.join(arg)
+      end
+    end
+    # :nocov:
+
     if RUBY_VERSION >= '3.3'
       # Create a new module using the block, and set the temporary name
       # on it using the given a containing module and name.

data/lib/sequel/database/misc.rb

@@ -635,7 +635,7 @@ module Sequel
     # Typecast the value to a String
     def typecast_value_string(value)
       case value
-      when Hash, Array
+      when Hash, Array, Set
         raise Sequel::InvalidValue, "invalid value for String: #{value.inspect}"
       else
         value.to_s

data/lib/sequel/database/schema_generator.rb

@@ -299,6 +299,7 @@ module Sequel
       # :opclass :: Set an opclass to use for all columns (per-column opclasses require
       #             custom SQL).
       # :tablespace :: Specify tablespace for index.
+      # :only :: Create index only for given table, not for any child tables (PostgreSQL 11+)
       #
       # Microsoft SQL Server specific options:
       #

data/lib/sequel/dataset/actions.rb

@@ -11,11 +11,12 @@ module Sequel
     
     # Action methods defined by Sequel that execute code on the database.
     ACTION_METHODS = (<<-METHS).split.map(&:to_sym).freeze
-      << [] all as_hash avg count columns columns! delete each
+      << [] all as_hash as_set avg count columns columns! delete each
       empty? fetch_rows first first! get import insert last
-      map max min multi_insert paged_each select_hash select_hash_groups select_map select_order_map
-      single_record single_record! single_value single_value! sum to_hash to_hash_groups truncate update
-      where_all where_each where_single_value
+      map max min multi_insert paged_each select_hash select_hash_groups
+      select_map select_order_map select_set single_record single_record!
+      single_value single_value! sum to_hash to_hash_groups
+      truncate update where_all where_each where_single_value
     METHS
 
     # The clone options to use when retrieving columns for a dataset.
@@ -51,6 +52,26 @@ module Sequel
       _all(block){|a| each{|r| a << r}}
     end
     
+    # Returns sets for column values for each record in the dataset.
+    #
+    #   DB[:table].as_set(:id) # SELECT * FROM table
+    #   # => Set[1, 2, 3, ...]
+    #
+    # You can also provide an array of column names, in which case the elements
+    # of the returned set are arrays (not sets):
+    #
+    #   DB[:table].as_set([:id, :name]) # SELECT * FROM table
+    #   # => Set[[1, 'A'], [2, 'B'], [3, 'C'], ...]
+    def as_set(column)
+      return naked.as_set(column) if row_proc
+
+      if column.is_a?(Array)
+        to_set{|r| r.values_at(*column)}
+      else
+        to_set{|r| r[column]}
+      end
+    end
+
     # Returns the average value for the given column/expression.
     # Uses a virtual row block if no argument is given.
     #
@@ -727,10 +748,7 @@ module Sequel
     end
 
     # Selects the column given (either as an argument or as a block), and
-    # returns an array of all values of that column in the dataset.  If you
-    # give a block argument that returns an array with multiple entries,
-    # the contents of the resulting array are undefined.  Raises an Error
-    # if called with both an argument and a block.
+    # returns an array of all values of that column in the dataset.
     #
     #   DB[:table].select_map(:id) # SELECT id FROM table
     #   # => [3, 5, 8, 1, ...]
@@ -768,6 +786,34 @@ module Sequel
       _select_map(column, true, &block)
     end
 
+    # Selects the column given (either as an argument or as a block), and
+    # returns a set of all values of that column in the dataset.
+    #
+    #   DB[:table].select_set(:id) # SELECT id FROM table
+    #   # => Set[3, 5, 8, 1, ...]
+    #
+    #   DB[:table].select_set{id * 2} # SELECT (id * 2) FROM table
+    #   # => Set[6, 10, 16, 2, ...]
+    #
+    # You can also provide an array of column names, which returns a set
+    # with array elements (not set elements):
+    #
+    #   DB[:table].select_map([:id, :name]) # SELECT id, name FROM table
+    #   # => Set[[1, 'A'], [2, 'B'], [3, 'C'], ...]
+    #
+    # If you provide an array of expressions, you must be sure that each entry
+    # in the array has an alias that Sequel can determine.
+    def select_set(column=nil, &block)
+      ds = ungraphed.naked
+      columns = Array(column)
+      virtual_row_columns(columns, block)
+      if column.is_a?(Array) || (columns.length > 1)
+        ds.select(*columns)._select_set_multiple(hash_key_symbols(columns))
+      else
+        ds.select(auto_alias_expression(columns.first))._select_set_single
+      end
+    end
+    
     # Limits the dataset to one record, and returns the first record in the dataset,
     # or nil if the dataset has no records. Users should probably use +first+ instead of
     # this method. Example:
@@ -1092,6 +1138,17 @@ module Sequel
       map{|r| r[k||=r.keys.first]}
     end
   
+    # Return a set of arrays of values given by the symbols in ret_cols.
+    def _select_set_multiple(ret_cols)
+      to_set{|r| r.values_at(*ret_cols)}
+    end
+  
+    # Returns a set of the first value in each row.
+    def _select_set_single
+      k = nil
+      to_set{|r| r[k||=r.keys.first]}
+    end
+  
     # A dataset for returning single values from the current dataset.
     def single_value_ds
       clone(:limit=>1).ungraphed.naked

data/lib/sequel/dataset/query.rb

@@ -1496,7 +1496,7 @@ module Sequel
         end
       when LiteralString
         LiteralString.new("(#{expr})")
-      when Numeric, SQL::NumericExpression, SQL::StringExpression, Proc, String
+      when Numeric, SQL::NumericExpression, SQL::StringExpression, Proc, String, Set
         raise Error, "Invalid filter expression: #{expr.inspect}"
       when TrueClass, FalseClass
         if supports_where_true?

data/lib/sequel/dataset/sql.rb

@@ -85,6 +85,8 @@ module Sequel
         literal_date_append(sql, v)
       when Dataset
         literal_dataset_append(sql, v)
+      when Set
+        literal_set_append(sql, v)
       else
         literal_other_append(sql, v)
       end
@@ -375,9 +377,9 @@ module Sequel
         cols = args[0]
         vals = args[1]
         col_array = true if cols.is_a?(Array)
-        if vals.is_a?(Array)
+        if vals.is_a?(Array) || vals.is_a?(Set)
           val_array = true
-          empty_val_array = vals == []
+          empty_val_array = vals.empty?
         end
         if empty_val_array
           literal_append(sql, empty_array_value(op, cols))
@@ -1448,6 +1450,12 @@ module Sequel
       end
     end
 
+    # Append a literalization of the set to SQL string.
+    # Treats as an expression as an SQL value list.
+    def literal_set_append(sql, v)
+      array_sql_append(sql, v)
+    end
+
     # SQL fragment for Sequel::SQLTime, containing just the time part
     def literal_sqltime(v)
       v.strftime(default_time_format)

data/lib/sequel/extensions/constraint_validations.rb

@@ -436,7 +436,7 @@ module Sequel
             else
               raise Error, "validates includes with a range only supports integers currently, cannot handle: #{arg.inspect}"
             end
-          elsif arg.is_a?(Array)
+          elsif arg.is_a?(Array) || arg.is_a?(Set)
             if arg.all?{|x| x.is_a?(Integer)}
               validation_type = :includes_int_array
             elsif arg.all?{|x| x.is_a?(String)}
@@ -444,9 +444,9 @@ module Sequel
             else
               raise Error, "validates includes with an array only supports strings and integers currently, cannot handle: #{arg.inspect}"
             end
-            arg = arg.join(',')
+            arg = Sequel.array_or_set_join(arg, ',')
           else
-            raise Error, "validates includes only supports arrays and ranges currently, cannot handle: #{arg.inspect}"
+            raise Error, "validates includes only supports arrays, sets, and ranges currently, cannot handle: #{arg.inspect}"
           end
         when :like, :ilike
           generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| Sequel.public_send(validation_type, c, arg)})

data/lib/sequel/extensions/empty_array_consider_nulls.rb

@@ -9,6 +9,13 @@
 #   DB[:test].exclude(name: [])
 #   # SELECT * FROM test WHERE (name = name)
 #
+# This works for sets in addition to arrays:
+#
+#   DB[:test].where(name: Set[])
+#   # SELECT * FROM test WHERE (name != name)
+#   DB[:test].exclude(name: Set[])
+#   # SELECT * FROM test WHERE (name = name)
+#
 # The default Sequel behavior is to ignore NULLs, as the above
 # query is not generally optimized well by databases.
 #

data/lib/sequel/extensions/eval_inspect.rb

@@ -34,6 +34,8 @@ module Sequel
         "#{obj.class}.new(#{obj.to_a.inspect})"
       when Array
         "[#{obj.map{|o| eval_inspect(o)}.join(', ')}]"
+      when Set
+        "Set[#{obj.map{|o| eval_inspect(o)}.join(', ')}]"
       when Hash
         "{#{obj.map{|k, v| "#{eval_inspect(k)} => #{eval_inspect(v)}"}.join(', ')}}"
       when Time

data/lib/sequel/extensions/pg_auto_parameterize.rb

@@ -408,9 +408,9 @@ module Sequel
           end
         end
 
-        # Whether the given argument is an array of integers or NULL values, recursively.
+        # Whether the given argument is an array or set of integers or NULL values, recursively.
         def _integer_array?(v)
-          Array === v && v.all?{|x| nil == x || Integer === x}
+          (Array === v || Set === v) && v.all?{|x| nil == x || Integer === x}
         end
 
         # Create the bound variable string that will be used for the IN (int, ...) to = ANY($)

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/extensions/pg_auto_parameterize_in_array.rb

@@ -120,7 +120,7 @@ module Sequel
       # The bound variable type string to use for the bound variable array.
       # Returns nil if a bound variable should not be used for the array.
       def _bound_variable_type_for_array(r)
-        return unless Array === r && r.size >= pg_auto_parameterize_min_array_size
+        return unless (Array === r || Set === r) && r.size >= pg_auto_parameterize_min_array_size
         classes = r.map(&:class)
         classes.uniq!
         classes.delete(NilClass)
@@ -165,6 +165,7 @@ module Sequel
 
       # Convert RHS of IN/NOT IN operator to PGArray with given type.
       def _convert_array_to_pg_array_with_type(r, type)
+        r = r.to_a if Set === r
         Sequel.pg_array(r, type)
       end
     end

data/lib/sequel/extensions/pg_hstore_ops.rb

@@ -294,13 +294,18 @@ module Sequel
         SQL::Function.new(name, self, *args)
       end
 
-      # Wrap argument in a PGArray if it is an array
+      # Wrap argument in a PGArray if it is an array or a set
       def wrap_input_array(obj)
-        if obj.is_a?(Array) && Sequel.respond_to?(:pg_array) 
-          Sequel.pg_array(obj)
-        else
-          obj
+        if Sequel.respond_to?(:pg_array)
+          case obj
+          when Array
+            return Sequel.pg_array(obj)
+          when Set
+            return Sequel.pg_array(obj.to_a)
+          end
         end
+
+        obj
       end
 
       # Wrap argument in an Hstore if it is a hash

data/lib/sequel/extensions/pg_json_ops.rb

@@ -841,13 +841,20 @@ module Sequel
         Sequel::SQL::BooleanExpression.new(:NOOP, Sequel::SQL::PlaceholderLiteralString.new(str, [value, other]))
       end
 
-      # Wrap argument in a PGArray if it is an array
+      # Wrap argument in a PGArray if it is an array or a set
       def wrap_input_array(obj)
-        if obj.is_a?(Array) && Sequel.respond_to?(:pg_array) 
-          Sequel.pg_array(obj)
-        else
-          obj
+        # :nocov:
+        if Sequel.respond_to?(:pg_array)
+        # :nocov:
+          case obj
+          when Array
+            return Sequel.pg_array(obj)
+          when Set
+            return Sequel.pg_array(obj.to_a)
+          end
         end
+
+        obj
       end
 
       # Wrap argument in a JSONBArray or JSONBHash if it is an array or hash.

data/lib/sequel/extensions/pg_row.rb

@@ -319,8 +319,8 @@ module Sequel
         end
 
         # Typecast the given object to the appropriate type using the
-        # typecaster.  Note that this does not conversion for the members
-        # of the composite type, since those conversion expect strings and
+        # typecaster.  Note that this does no conversion for the members
+        # of the composite type, since those conversions expect strings and
         # strings may not be provided.  
         def typecast(obj)
           case obj 

data/lib/sequel/extensions/set_literalizer.rb

@@ -1,56 +1,37 @@
 # frozen-string-literal: true
 #
-# The set_literalizer extension allows for using Set instances in many of the
-# same places that you would use Array instances:
-#
-#   DB[:table].where(column: Set.new([1, 2, 3]))
-#   # SELECT FROM table WHERE (column IN (1, 2, 3))
-#
-# To load the extension into all datasets created from a given Database:
-#
-#   DB.extension :set_literalizer
+# The set_literalizer extension should no longer be used, as Sequel
+# now supports Set values by default. For backwards compatibility
+# the set_literalizer extension will treat a set that contains only
+# 2 element arrays as a condition specifier (matching the behavior
+# for arrays where all elements are 2 element arrays). This is not
+# compatible with Sequel's current default behavior. If you are
+# relying on this behavior, it is recommended you convert the set
+# to an array.
 #
 # Related module: Sequel::Dataset::SetLiteralizer
 
-require 'set'
-
 module Sequel
+  # SEQUEL6: Remove
+  Sequel::Deprecation.deprecate("The set_literalizer extension", "Sequel now supports set literalization by default")
+
   class Dataset
     module SetLiteralizer
-      # Try to generate the same SQL for Set instances used in datasets
-      # that would be used for equivalent Array instances.
-      def complex_expression_sql_append(sql, op, args)
-        # Array instances are treated specially by
-        # Sequel::SQL::BooleanExpression.from_value_pairs. That cannot
-        # be modified by a dataset extension, so this tries to convert
-        # the complex expression values generated by default to what would
-        # be the complex expression values used for the equivalent array.
-        case op
-        when :'=', :'!='
-          if (set = args[1]).is_a?(Set)
-            op = op == :'=' ? :IN : :'NOT IN'
-            col = args[0]
-            array = set.to_a
-            if Sequel.condition_specifier?(array) && col.is_a?(Array)
-              array = Sequel.value_list(array)
-            end
-            args = [col, array]
-          end
-        end
-
-        super
-      end
-
       private
 
-      # Literalize Set instances by converting the set to array.
-      def literal_other_append(sql, v)
-        if Set === v
-          literal_append(sql, v.to_a) 
+      # Allow using sets as condition specifiers.
+      def filter_expr(expr = nil, &block)
+        if expr.is_a?(Set)
+          expr
         else
           super
         end
       end
+
+      # Literalize Set instances by converting the set to array.
+      def literal_set_append(sql, v)
+        literal_append(sql, v.to_a) 
+      end
     end
 
     register_extension(:set_literalizer, SetLiteralizer)

data/lib/sequel/extensions/split_array_nil.rb

@@ -25,6 +25,11 @@
 #   # with split_array_nils extension:
 #   #   SELECT * FROM table WHERE ((column NOT IN (1)) AND (column IS NOT NULL)))
 #
+# In addition to arrays, this splitting is also done for sets:
+#
+#   ds = DB[:table].where(column: Set[1, nil])
+#   # SELECT * FROM table WHERE ((column IN (1)) OR (column IS NULL)))
+#
 # To use this extension with a single dataset:
 #
 #   ds = ds.extension(:split_array_nil)
@@ -47,9 +52,14 @@ module Sequel
       case op
       when :IN, :"NOT IN"
         vals = args[1]
-        if vals.is_a?(Array) && vals.any?(&:nil?)
+        if (vals.is_a?(Array) || vals.is_a?(Set)) && vals.any?(&:nil?)
           cols = args[0]
-          vals = vals.compact
+          if vals.is_a?(Set)
+            vals = vals.dup
+            vals.delete(nil)
+          else
+            vals = vals.compact
+          end
           c = Sequel::SQL::BooleanExpression
           if op == :IN
             literal_append(sql, c.new(:OR, c.new(:IN, cols, vals), c.new(:IS, cols, nil)))

data/lib/sequel/extensions/to_dot.rb

@@ -79,6 +79,11 @@ module Sequel
         e.each_with_index do |val, j|
           v(val, j)
         end
+      when Set
+        dot "Set"
+        e.each_with_index do |val, j|
+          v(val, j)
+        end
       when Hash
         dot "Hash"
         e.each do |k, val|

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
@@ -3544,7 +3544,7 @@ module Sequel
           else
             vals = Array(obj).reject{|o| !meths.all?{|m| o.get_column_value(m)}}
             return SQL::Constants::FALSE if vals.empty?
-            if obj.is_a?(Array)
+            if obj.is_a?(Array) || obj.is_a?(Set)
               if keys.length == 1
                 meth = meths.first
                 {keys.first=>vals.map{|o| o.get_column_value(meth)}}

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, as_set, 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,
@@ -17,7 +19,7 @@ module Sequel
     #   natural_join, natural_left_join, natural_right_join, offset, order, order_append, order_by,
     #   order_more, order_prepend, paged_each, qualify, reverse, reverse_order, right_join,
     #   right_outer_join, select, select_all, select_append, select_group, select_hash,
-    #   select_hash_groups, select_map, select_more, select_order_map, select_prepend, server,
+    #   select_hash_groups, select_map, select_more, select_order_map, select_prepend, select_set, server,
     #   single_record, single_record!, single_value, single_value!, sum, to_hash, to_hash_groups,
     #   truncate, unfiltered, ungraphed, ungrouped, union, unlimited, unordered, where, where_all,
     #   where_each, where_single_value, with, with_recursive, with_sql
@@ -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:
       #
@@ -2328,5 +2344,17 @@ END
     # :nocov:
       singleton_class.send(:undef_method, :initialize_clone, :initialize_dup)
     end
+
+    # :nocov:
+    if defined?(Sequel::Postgres::SEQUEL_PG_VERSION_INTEGER) && Sequel::Postgres::SEQUEL_PG_VERSION_INTEGER >= 11800
+      # Automatically optimize model loading when sequel/core was loaded,
+      # then sequel/adapters/postgres (with sequel_pg), then sequel/model
+      begin
+        require "sequel_pg/model"
+      rescue LoadError
+        # nothing
+      end
+    end
+    # :nocov:
   end
 end

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

@@ -541,7 +541,7 @@ module Sequel
             if (assoc_pks = obj.get_column_value(key)) && !assoc_pks.empty?
               Sequel[pk=>assoc_pks.to_a]
             end
-          when Array
+          when Array, Set
             if (assoc_pks = obj.map{|o| o.get_column_value(key)}.flatten.compact.uniq) && !assoc_pks.empty?
               Sequel[pk=>assoc_pks]
             end
@@ -563,7 +563,7 @@ module Sequel
             if pkv = obj.get_column_value(ref.primary_key_method)
               Sequel.pg_array_op(key).contains(Sequel.pg_array([pkv], ref.array_type))
             end
-          when Array
+          when Array, Set
             if (pkvs = obj.map{|o| o.get_column_value(ref.primary_key_method)}.compact) && !pkvs.empty?
               Sequel.pg_array(key).overlaps(Sequel.pg_array(pkvs, ref.array_type))
             end

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

@@ -176,6 +176,19 @@ module Sequel
           h
         end
 
+        # Use the cache instead of a query to get the results.
+        def as_set(column)
+          set = Set.new
+
+          if column.is_a?(Array)
+            @all.each{|r| set.add(r.values.values_at(*column))}
+          else
+            @all.each{|r| set.add(r[column])}
+          end
+
+          set
+        end
+
         # Alias of as_hash for backwards compatibility.
         def to_hash(*a)
           as_hash(*a)

data/lib/sequel/plugins/subset_static_cache.rb

@@ -226,6 +226,21 @@ module Sequel
           h
         end
 
+        # Use the cache instead of a query to get the results.
+        def as_set(column)
+          return super unless all = @cache[:subset_static_cache_all]
+
+          set = Set.new
+
+          if column.is_a?(Array)
+            all.each{|r| set.add(r.values.values_at(*column))}
+          else
+            all.each{|r| set.add(r[column])}
+          end
+
+          set
+        end
+
         # Alias of as_hash for backwards compatibility.
         def to_hash(*a)
           as_hash(*a)

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

@@ -1108,7 +1108,7 @@ module Sequel
           else
             new(:'=', 1, 1)
           end
-        when ::Array
+        when ::Array, ::Set
           r = r.dup.freeze unless r.frozen?
           new(:IN, l, r)
         when ::String

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 = 99
 
   # 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.99.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