sequel 5.98.0 → 5.99.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28641a0240d39f16a5b6f2d30986d44a8744c26e24de5e78b8e3823a409c48d2
-  data.tar.gz: 25435173509b5058e781f4b06b1ebf8005244e86864c5a72ac35bc739656a6b1
+  metadata.gz: 7e5d22a32d8c5f27e15e00203d0c2ce2a2fb3f5352d7b7c25c82389f4947882c
+  data.tar.gz: 81909dc070cc8d48def396ae76e953a1f31dc478b45d3a5fa8b69646bc7df094
 SHA512:
-  metadata.gz: 11c7f62e3e296c43bef8af4de71ecaaf01e2e4d7e034910403991b91bc2075778dde0d16e899bc3ddacc1351e38da0f61f43476272e3b90c9a2aee5b09d82599
-  data.tar.gz: 173dfc5d3bbc19846a2d27b077d2241e6f64473f8a8f16ba052d9fd021d514036af1cf42cade4ea8974f2d920e126d4c23e824ab0e2d49a9062857ecd7e93342
+  metadata.gz: c24ae48ece66511a09b2d8a5ad8b5b82e7486a4446bcb66108140b8afe449cd9c9e7645a29ca0bbe0c994d5c060a52f1ab4c41434dc068175751b1d6bd57b5dc
+  data.tar.gz: e8acd2e5cb4272bd47aed87e3077018dfc5ba9673856b871c8222eec6b2de1be0843840969e046efc459b52902753e9e0f0e35b95dcdcf31914d98b5f487d78a

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/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_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

@@ -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

@@ -10,7 +10,7 @@ module Sequel
     # 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, any?, 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,
@@ -19,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
@@ -2344,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/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/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/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 = 98
+  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.98.0
+  version: 5.99.0
 platform: ruby
 authors:
 - Jeremy Evans