sequel 5.96.0 → 5.99.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52123540e6fde4ed7ade970b36fc60898bae7463c0e22f63c4205748365cd82b
-  data.tar.gz: e3374571d1e4fc490d3e2dc847679a2d8893b196c152d26f760b723605951ddd
+  metadata.gz: 7e5d22a32d8c5f27e15e00203d0c2ce2a2fb3f5352d7b7c25c82389f4947882c
+  data.tar.gz: 81909dc070cc8d48def396ae76e953a1f31dc478b45d3a5fa8b69646bc7df094
 SHA512:
-  metadata.gz: a4a48515dcb90df9ca6dde4b657f6d1ccce0724b0bd6d09c2a36aed3f37d338fe468135f177fb7cd5f985c79a5e06a91d1459731dc2fdc21601083863d9efd1a
-  data.tar.gz: 3c18417f6991a190781cf0098aa81dae3077f52e5fed75162352ffe10fc2f065b5b9ffad1db3bdded7ecc8afed7ea698fc1047570a98dc8a7a87470e7cc2290e
+  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

@@ -571,6 +571,7 @@ module Sequel
       #         :if_exists :: Don't raise an error if the schema doesn't exist.
       def drop_schema(name, opts=OPTS)
         self << drop_schema_sql(name, opts)
+        remove_all_cached_schemas
       end
 
       # Drops a trigger from the database.  Arguments:
@@ -668,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]}
@@ -726,6 +741,14 @@ module Sequel
         Sequel.synchronize{@primary_key_sequences[quoted_table] = value} if value
       end
 
+      # Rename a schema in the database. Arguments:
+      # name :: Current name of the schema
+      # opts :: New name for the schema
+      def rename_schema(name, new_name)
+        self << rename_schema_sql(name, new_name)
+        remove_all_cached_schemas
+      end
+
       # Refresh the materialized view with the given name.
       # 
       #   DB.refresh_view(:items_view)
@@ -1040,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)]}
 
@@ -1748,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.
@@ -1806,6 +1828,18 @@ module Sequel
         super
       end
 
+      # Clear all cached schema information
+      def remove_all_cached_schemas
+        @primary_keys.clear
+        @primary_key_sequences.clear
+        @schemas.clear
+      end
+
+      # SQL for renaming a schema.
+      def rename_schema_sql(name, new_name)
+        "ALTER SCHEMA #{quote_identifier(name)} RENAME TO #{quote_identifier(new_name)}"
+      end
+
       # SQL DDL statement for renaming a table. PostgreSQL doesn't allow you to change a table's schema in
       # a rename table operation, so specifying a new schema in new_name will not have an effect.
       def rename_table_sql(name, new_name)
@@ -2139,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
@@ -1256,8 +1313,6 @@ module Sequel
     # receiver's current order. This yields the row and the array of order expressions
     # to the block, which should return an array of values to use.
     def ignore_values_preceding(row)
-      @opts[:order].map{|v| v.is_a?(SQL::OrderedExpression) ? v.expression : v}
-
       order_exprs = @opts[:order].map do |v|
         if v.is_a?(SQL::OrderedExpression)
           descending = v.descending

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

@@ -37,18 +37,11 @@ module Sequel
       value.to_s
     end
 
-    if RUBY_VERSION >= '2.4'
-      def _typecast_value_string_to_decimal(value)
-        BigDecimal(value)
-      rescue
-        BigDecimal('0.0')
-      end
-    else
-      # :nocov:
-      def _typecast_value_string_to_decimal(value)
-        BigDecimal(value)
-      end
-      # :nocov:
+    # Typecast invalid BigDecimal to 0.0.
+    def _typecast_value_string_to_decimal(value)
+      BigDecimal(value)
+    rescue
+      BigDecimal('0.0')
     end
   end
 

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($)