sequel 5.80.0 → 5.92.0

data/lib/sequel/database/schema_generator.rb

@@ -430,6 +430,10 @@ module Sequel
       #   add_unique_constraint(:name, name: :unique_name) # ADD CONSTRAINT unique_name UNIQUE (name)
       #
       # Supports the same :deferrable option as CreateTableGenerator#column.
+      #
+      # PostgreSQL specific options:
+      #
+      # :using_index :: Use the USING INDEX clause to specify an existing unique index
       def add_unique_constraint(columns, opts = OPTS)
         @operations << {:op => :add_constraint, :type => :unique, :columns => Array(columns)}.merge!(opts)
         nil
@@ -483,6 +487,10 @@ module Sequel
       #
       #   add_primary_key(:id) # ADD COLUMN id serial PRIMARY KEY
       #   add_primary_key([:artist_id, :name]) # ADD PRIMARY KEY (artist_id, name)
+      #
+      # PostgreSQL specific options:
+      #
+      # :using_index :: Use the USING INDEX clause to specify an existing unique index
       def add_primary_key(name, opts = OPTS)
         return add_composite_primary_key(name, opts) if name.is_a?(Array)
         opts = @db.serial_primary_key_options.merge(opts)

data/lib/sequel/database/schema_methods.rb

@@ -191,6 +191,8 @@ module Sequel
     #            The +any+ type is treated like a SQLite column in a non-strict table,
     #            allowing any type of data to be stored. This option is supported on
     #            SQLite 3.37.0+.
+    # :using :: Create a VIRTUAL table with the given USING clause. The value should be
+    #           a string, as it is used directly in the SQL query.
     # :without_rowid :: Create a WITHOUT ROWID table. Every row in SQLite has a special
     #                   'rowid' column, that uniquely identifies that row within the table.
     #                   If this option is used, the 'rowid' column is omitted, which can
@@ -775,7 +777,21 @@ module Sequel
 
     # SQL fragment for initial part of CREATE TABLE statement
     def create_table_prefix_sql(name, options)
-      "CREATE #{temporary_table_sql if options[:temp]}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)}"
+      "CREATE #{temporary_table_sql if options[:temp]}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{create_table_table_name_sql(name, options)}"
+    end
+
+    # The SQL to use for a table name when creating a table.
+    # Use of the :temp option can result in different SQL,
+    # because the rules for temp table naming can differ
+    # between databases, and temp tables should not use the
+    # default_schema.
+    def create_table_table_name_sql(name, options)
+      options[:temp] ? create_table_temp_table_name_sql(name, options) : quote_schema_table(name)
+    end
+
+    # The SQL to use for the table name for a temporary table.
+    def create_table_temp_table_name_sql(name, _options)
+      name.is_a?(String) ? quote_identifier(name) : literal(name)
     end
 
     # SQL fragment for initial part of CREATE VIEW statement

data/lib/sequel/dataset/actions.rb

@@ -217,7 +217,7 @@ module Sequel
       case args.length
       when 0
         unless block
-          return single_record
+          return(@opts[:sql] ? single_record! : single_record)
         end
       when 1
         arg = args[0]
@@ -282,6 +282,12 @@ module Sequel
     #
     #   DB[:table].get{[sum(id).as(sum), name]} # SELECT sum(id) AS sum, name FROM table LIMIT 1
     #   # => [6, 'foo']
+    #
+    # If called on a dataset with raw SQL, returns the
+    # first value in the dataset without changing the selection or setting a limit:
+    #
+    #   DB["SELECT id FROM table"].get # SELECT id FROM table
+    #   # =>  3
     def get(column=(no_arg=true; nil), &block)
       ds = naked
       if block
@@ -289,6 +295,8 @@ module Sequel
         ds = ds.select(&block)
         column = ds.opts[:select]
         column = nil if column.is_a?(Array) && column.length < 2
+      elsif no_arg && opts[:sql]
+        return ds.single_value!
       else
         case column
         when Array

data/lib/sequel/dataset/deprecated_singleton_class_methods.rb

@@ -19,7 +19,7 @@ module Sequel
       def with_extend(*mods, &block)
         c = _clone(:freeze=>false)
         c.extend(*mods) unless mods.empty?
-        c.extend(DatasetModule.new(&block)) if block
+        c.extend(Sequel.set_temp_name(DatasetModule.new(&block)){"Sequel::Dataset::_DatasetModule(#{block.source_location.join(':')})"}) if block
         c.freeze
       end
 

data/lib/sequel/dataset/prepared_statements.rb

@@ -20,7 +20,8 @@ module Sequel
     def self.prepared_statements_module(code, mods, meths=DEFAULT_PREPARED_STATEMENT_MODULE_METHODS, &block)
       code = PREPARED_STATEMENT_MODULE_CODE[code] || code
 
-      Module.new do
+      Module.new do 
+        Sequel.set_temp_name(self){"Sequel::Dataset::_PreparedStatementsModule(#{block.source_location.join(':') if block})"}
         Array(mods).each do |mod|
           include mod
         end

data/lib/sequel/dataset/query.rb

@@ -204,7 +204,7 @@ module Sequel
       # If no related extension file exists or the extension does not have
       # specific support for Dataset objects, an error will be raised.
       def extension(*exts)
-        Sequel.extension(*exts)
+        exts.each{|ext| Sequel.extension(ext) unless Sequel.synchronize{EXTENSIONS[ext]}}
         mods = exts.map{|ext| Sequel.synchronize{EXTENSION_MODULES[ext]}}
         if mods.all?
           with_extend(*mods)
@@ -1238,9 +1238,9 @@ module Sequel
       # Note that like Object#extend, when multiple modules are provided
       # as arguments the subclass includes the modules in reverse order.
       def with_extend(*mods, &block)
-        c = Class.new(self.class)
+        c = Sequel.set_temp_name(Class.new(self.class)){"Sequel::Dataset::_Subclass"}
         c.include(*mods) unless mods.empty?
-        c.include(DatasetModule.new(&block)) if block
+        c.include(Sequel.set_temp_name(DatasetModule.new(&block)){"Sequel::Dataset::_DatasetModule(#{block.source_location[0,2].join(':')})"}) if block
         o = c.freeze.allocate
         o.instance_variable_set(:@db, @db)
         o.instance_variable_set(:@opts, @opts)
@@ -1359,9 +1359,13 @@ module Sequel
     unless TRUE_FREEZE
       # Load the extensions into the receiver, without checking if the receiver is frozen.
       def _extension!(exts)
-        Sequel.extension(*exts)
         exts.each do |ext|
-          if pr = Sequel.synchronize{EXTENSIONS[ext]}
+          unless pr = Sequel.synchronize{EXTENSIONS[ext]}
+            Sequel.extension(ext)
+            pr = Sequel.synchronize{EXTENSIONS[ext]}
+          end
+
+          if pr
             pr.call(self)
           else
             raise(Error, "Extension #{ext} does not have specific support handling individual datasets (try: Sequel.extension #{ext.inspect})")

data/lib/sequel/dataset/sql.rb

@@ -901,18 +901,31 @@ module Sequel
     MERGE_TYPE_SQL = {
       :insert => ' WHEN NOT MATCHED',
       :delete => ' WHEN MATCHED',
+      :delete_not_matched_by_source => ' WHEN NOT MATCHED BY SOURCE',
       :update => ' WHEN MATCHED',
+      :update_not_matched_by_source => ' WHEN NOT MATCHED BY SOURCE',
       :matched => ' WHEN MATCHED',
       :not_matched => ' WHEN NOT MATCHED',
+      :not_matched_by_source => ' WHEN NOT MATCHED BY SOURCE',
     }.freeze
     private_constant :MERGE_TYPE_SQL
 
+    MERGE_NORMALIZE_TYPE_MAP = {
+      :delete_not_matched_by_source => :delete,
+      :update_not_matched_by_source => :update,
+      :matched => :do_nothing,
+      :not_matched => :do_nothing,
+      :not_matched_by_source => :do_nothing,
+    }.freeze
+    private_constant :MERGE_NORMALIZE_TYPE_MAP
+
     # Add the WHEN clauses to the MERGE SQL
     def _merge_when_sql(sql)
       raise Error, "no WHEN [NOT] MATCHED clauses provided for MERGE" unless merge_when = @opts[:merge_when]
       merge_when.each do |data|
         type = data[:type]
         sql << MERGE_TYPE_SQL[type]
+        type = MERGE_NORMALIZE_TYPE_MAP[type] || type
         _merge_when_conditions_sql(sql, data)
         send(:"_merge_#{type}_sql", sql, data)
       end
@@ -1019,7 +1032,7 @@ module Sequel
       if column_aliases
         raise Error, "#{db.database_type} does not support derived column lists" unless supports_derived_column_lists?
         sql << '('
-        identifier_list_append(sql, column_aliases)
+        derived_column_list_sql_append(sql, column_aliases)
         sql << ')'
       end
     end
@@ -1152,6 +1165,11 @@ module Sequel
       end
     end
 
+    # Append the column aliases to the SQL.
+    def derived_column_list_sql_append(sql, column_aliases)
+      identifier_list_append(sql, column_aliases)
+    end
+    
     # Disable caching of SQL for the current dataset
     def disable_sql_caching!
       cache_set(:_no_cache_sql, true)
@@ -1412,10 +1430,6 @@ module Sequel
     # calls +sql_literal+ if object responds to it, otherwise raises an error.
     # If a database specific type is allowed, this should be overriden in a subclass.
     def literal_other_append(sql, v)
-      # We can't be sure if v will always literalize to the same SQL, so
-      # don't cache SQL for a dataset that uses this.
-      disable_sql_caching!
-
       if v.respond_to?(:sql_literal_append)
         v.sql_literal_append(self, sql)
       elsif v.respond_to?(:sql_literal)
@@ -1423,6 +1437,12 @@ module Sequel
       else
         raise Error, "can't express #{v.inspect} as a SQL literal"
       end
+
+      if !v.respond_to?(:sql_literal_allow_caching?) || !v.sql_literal_allow_caching?(self)
+        # We can't be sure if v will always literalize to the same SQL, so
+        # don't cache SQL for a dataset that uses this.
+        disable_sql_caching!
+      end
     end
 
     # SQL fragment for Sequel::SQLTime, containing just the time part

data/lib/sequel/extensions/caller_logging.rb

@@ -37,6 +37,7 @@ module Sequel
   module CallerLogging
     SEQUEL_LIB_PATH = (File.expand_path('../../..', __FILE__) + '/').freeze
     RUBY_STDLIB = RbConfig::CONFIG["rubylibdir"]
+    INTERNAL = '<internal'
 
     # A regexp of caller lines to ignore, in addition to internal Sequel and Ruby code.
     attr_accessor :caller_logging_ignore
@@ -61,6 +62,7 @@ module Sequel
       c = caller.find do |line|
         !(line.start_with?(SEQUEL_LIB_PATH) ||
           line.start_with?(RUBY_STDLIB) ||
+          line.start_with?(INTERNAL) ||
           (ignore && line =~ ignore))
       end
 

data/lib/sequel/extensions/connection_validator.rb

@@ -105,18 +105,23 @@ module Sequel
       1.times do
         if (conn = super) &&
            (timer = sync{@connection_timestamps.delete(conn)}) &&
-           Sequel.elapsed_seconds_since(timer) > @connection_validation_timeout &&
-           !db.valid_connection?(conn)
+           Sequel.elapsed_seconds_since(timer) > @connection_validation_timeout
 
-          case pool_type
-          when :sharded_threaded, :sharded_timed_queue
-            sync{@allocated[a.last].delete(Sequel.current)}
-          else
-            sync{@allocated.delete(Sequel.current)}
-          end
+          begin
+            valid = db.valid_connection?(conn)
+          ensure
+            unless valid
+              case pool_type
+              when :sharded_threaded, :sharded_timed_queue
+                sync{@allocated[a.last].delete(Sequel.current)}
+              else
+                sync{@allocated.delete(Sequel.current)}
+              end
 
-          disconnect_connection(conn)
-          redo
+              disconnect_connection(conn)
+              redo if valid == false
+            end
+          end
         end
       end
 

data/lib/sequel/extensions/dataset_run.rb

@@ -0,0 +1,41 @@
+# frozen-string-literal: true
+#
+# The dataset_run extension is designed for cases where you want
+# to use dataset methods to build a query, but want to run that
+# query without returning a result.  The most common need would
+# be to easily use placeholders in an SQL string, which Database#run
+# does not support directly.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB["GRANT SELECT ON ? TO ?", :table, :user]
+#   ds = ds.extension(:dataset_run)
+#   ds.run
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:dataset_run)
+#   DB["GRANT SELECT ON ? TO ?", :table, :user].run
+#
+# Related module: Sequel::DatasetRun
+
+#
+module Sequel
+  module DatasetRun
+    # Run the dataset's SQL on the database.  Returns NULL.  This is
+    # useful when you want to run SQL without returning a result.
+    #
+    #   DB["GRANT SELECT ON ? TO ?", :table, :user].run
+    #   # GRANT SELECT ON "table" TO "user"
+    def run
+      if server = @opts[:server]
+        db.run(sql, :server=>server)
+      else
+        db.run(sql)
+      end
+    end
+  end
+
+  Dataset.register_extension(:dataset_run, DatasetRun)
+end

data/lib/sequel/extensions/migration.rb

@@ -223,7 +223,7 @@ module Sequel
       @actions << [:drop_join_table, *args]
     end
 
-    def create_table(name, opts=OPTS)
+    def create_table(name, opts=OPTS, &_)
       @actions << [:drop_table, name, opts]
     end
 
@@ -287,6 +287,10 @@ module Sequel
     def set_column_allow_null(name, allow_null=true)
       @actions << [:set_column_allow_null, name, !allow_null]
     end
+
+    def set_column_not_null(name)
+      @actions << [:set_column_allow_null, name]
+    end
   end
 
   # The preferred method for writing Sequel migrations, using a DSL:
@@ -371,7 +375,7 @@ module Sequel
   #
   # Part of the +migration+ extension.
   class Migrator
-    MIGRATION_FILE_PATTERN = /\A(\d+)_.+\.rb\z/i.freeze
+    MIGRATION_FILE_PATTERN = /\A(\d+)_(.+)\.rb\z/i.freeze
 
     # Mutex used around migration file loading
     MUTEX = Mutex.new
@@ -791,7 +795,23 @@ module Sequel
         next unless MIGRATION_FILE_PATTERN.match(file)
         files << File.join(directory, file)
       end
-      files.sort_by{|f| MIGRATION_FILE_PATTERN.match(File.basename(f))[1].to_i}
+      files.sort! do |a, b|
+        a_ver, a_name = split_migration_filename(a)
+        b_ver, b_name = split_migration_filename(b)
+        x = a_ver <=> b_ver
+        if x.zero?
+          x = a_name <=> b_name
+        end
+        x
+      end
+      files
+    end
+
+    # Return an integer and name (without extension) for the given path.
+    def split_migration_filename(path)
+      version, name = MIGRATION_FILE_PATTERN.match(File.basename(path)).captures
+      version = version.to_i
+      [version, name]
     end
     
     # Returns tuples of migration, filename, and direction

data/lib/sequel/extensions/null_dataset.rb

@@ -63,12 +63,12 @@ module Sequel
       end
 
       # Return self without sending a database query, never yielding.
-      def each
+      def each(&_)
         self
       end
 
       # Return nil without sending a database query, never yielding.
-      def fetch_rows(sql)
+      def fetch_rows(sql, &_)
         nil
       end
 

data/lib/sequel/extensions/pg_auto_parameterize.rb

@@ -394,7 +394,7 @@ module Sequel
         # there can be more than one parameter per column, so this doesn't prevent going
         # over the limit, though it does make it less likely.
         def default_import_slice
-          40
+          @opts[:no_auto_parameterize] ? super : 40
         end
 
         # Handle parameterization of multi_insert_sql

data/lib/sequel/extensions/pg_auto_parameterize_in_array.rb

@@ -21,15 +21,26 @@
 # DateTime :: timestamp (or timestamptz if pg_timestamptz extension is used)
 # Sequel::SQLTime :: time
 # Sequel::SQL::Blob :: bytea
+#
+# Arrays of string values are not automatically converted by default, because the Ruby
+# String class can represent a number of different database types.  To convert
+# arrays of Ruby strings to an untyped array (a query parameter with no explicit
+# type cast), set the +:treat_string_list_as_untyped_array+ Database option
+# before loading the extension.
 # 
-# String values are also supported using the +text+ type, but only if the 
-# +:treat_string_list_as_text_array+ Database option is used. This is because
-# treating strings as text can break programs, since the type for
-# literal strings in PostgreSQL is +unknown+, not +text+.
+# If you will only be using arrays of Ruby strings that represent the +text+ type,
+# you can use the +:treat_string_list_as_text_array+ Database option is used. This
+# can break programs, since the type for literal strings in PostgreSQL is +unknown+,
+# not +text+.
 #
-# The conversion is only done for single dimensional arrays that have more
-# than two elements, where all elements are of the same class (other than
-# nil values).
+# The conversion is only done for single dimensional arrays that have two or
+# more elements, where all elements are of the same class (other than
+# +nil+ values).  You can also do the conversion for arrays of 1 element by setting
+# <tt>pg_auto_parameterize_min_array_size: 1</tt> Database option.  This makes
+# finding cases that need special handling easier, but it doesn't match
+# how PostgreSQL internally converts the expression (PostgreSQL converts
+# <tt>IN (single_value)</tt> to <tt>= single_value</tt>, not
+# <tt>= ANY(ARRAY[single_value])</tt>).
 #
 # Related module: Sequel::Postgres::AutoParameterizeInArray
 
@@ -37,6 +48,47 @@ module Sequel
   module Postgres
     # Enable automatically parameterizing queries.
     module AutoParameterizeInArray
+      module TreatStringListAsUntypedArray
+        # Sentinal value to use as an auto param type to use auto parameterization
+        # of a string array without an explicit type cast.
+        NO_EXPLICIT_CAST = Object.new.freeze
+
+        # Wrapper for untyped PGArray values that will be parameterized directly
+        # into the query.  This should only be used in cases where you know the
+        # value should be added as a query parameter.
+        class ParameterizedUntypedPGArray < SQL::Wrapper
+          def to_s_append(ds, sql)
+            sql.add_arg(@value)
+          end
+        end
+
+        private
+
+        # Recognize NO_EXPLICIT_CAST sentinal value and use wrapped
+        # PGArray that will be parameterized into the query.
+        def _convert_array_to_pg_array_with_type(r, type)
+          if NO_EXPLICIT_CAST.equal?(type)
+            ParameterizedUntypedPGArray.new(Sequel.pg_array(r))
+          else
+            super
+          end
+        end
+
+        # Use a query parameter with no type cast for string arrays.
+        def _bound_variable_type_for_string_array(r)
+          NO_EXPLICIT_CAST
+        end
+      end
+
+      module TreatStringListAsTextArray
+        private
+
+        # Assume all string arrays used on RHS of IN/NOT IN are for type text[]
+        def _bound_variable_type_for_string_array(r)
+          "text"
+        end
+      end
+
       # Transform column IN (...) expressions into column = ANY($)
       # and column NOT IN (...) expressions into column != ALL($)
       # using an array bound variable for the ANY/ALL argument,
@@ -56,7 +108,7 @@ module Sequel
               op = :!=
               func = :ALL
             end
-            args = [l, Sequel.function(func, Sequel.pg_array(r, type))]
+            args = [l, Sequel.function(func, _convert_array_to_pg_array_with_type(r, type))]
           end
         end
 
@@ -68,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 > 1
+        return unless Array === r && r.size >= pg_auto_parameterize_min_array_size
         classes = r.map(&:class)
         classes.uniq!
         classes.delete(NilClass)
@@ -81,7 +133,7 @@ module Sequel
           # arrays natively (though the SQL used is different)
           "int8"
         elsif klass == String
-          "text" if db.typecast_value(:boolean, db.opts[:treat_string_list_as_text_array])
+          _bound_variable_type_for_string_array(r)
         elsif klass == BigDecimal
           "numeric"
         elsif klass == Date
@@ -100,11 +152,42 @@ module Sequel
           "bytea"
         end
       end
+
+      # Do not auto parameterize string arrays by default.
+      def _bound_variable_type_for_string_array(r)
+        nil
+      end
+
+      # The minimium size of array to auto parameterize.
+      def pg_auto_parameterize_min_array_size
+        2
+      end
+
+      # Convert RHS of IN/NOT IN operator to PGArray with given type.
+      def _convert_array_to_pg_array_with_type(r, type)
+        Sequel.pg_array(r, type)
+      end
     end
   end
 
   Database.register_extension(:pg_auto_parameterize_in_array) do |db|
     db.extension(:pg_array, :pg_auto_parameterize)
     db.extend_datasets(Postgres::AutoParameterizeInArray)
+
+    if db.typecast_value(:boolean, db.opts[:treat_string_list_as_text_array])
+      db.extend_datasets(Postgres::AutoParameterizeInArray::TreatStringListAsTextArray)
+    elsif db.typecast_value(:boolean, db.opts[:treat_string_list_as_untyped_array])
+      db.extend_datasets(Postgres::AutoParameterizeInArray::TreatStringListAsUntypedArray)
+    end
+
+    if min_array_size = db.opts[:pg_auto_parameterize_min_array_size]
+      min_array_size = db.typecast_value(:integer, min_array_size)
+      mod = Module.new do
+        define_method(:pg_auto_parameterize_min_array_size){min_array_size}
+        private :pg_auto_parameterize_min_array_size
+      end
+      Sequel.set_temp_name(mod){"Sequel::Postgres::AutoParameterizeInArray::_MinArraySize#{min_array_size}"}
+      db.extend_datasets(mod)
+    end
   end
 end

data/lib/sequel/extensions/pg_enum.rb

@@ -149,12 +149,12 @@ module Sequel
             from(:pg_type).
             where(:oid=>enum_labels.keys).
             exclude(:typarray=>0).
-            select_map([:typname, Sequel.cast(:typarray, Integer).as(:v)])
+            select_map([:typname, Sequel.cast(:typarray, Integer).as(:v), Sequel.cast(:oid, Integer).as(:sv)])
 
           existing_oids = conversion_procs.keys
-          array_types.each do |name, oid|
+          array_types.each do |name, oid, scalar_oid|
             next if existing_oids.include?(oid)
-            register_array_type(name, :oid=>oid)
+            register_array_type(name, :oid=>oid, :scalar_oid=>scalar_oid)
           end
         end