sequel 5.57.0 → 5.60.0

data/lib/sequel/adapters/postgres.rb

@@ -5,6 +5,7 @@ require_relative 'shared/postgres'
 begin 
   require 'pg' 
 
+  # :nocov:
   Sequel::Postgres::PGError = PG::Error if defined?(PG::Error)
   Sequel::Postgres::PGconn = PG::Connection if defined?(PG::Connection)
   Sequel::Postgres::PGresult = PG::Result if defined?(PG::Result)
@@ -14,30 +15,40 @@ begin
     raise LoadError unless defined?(PGconn::CONNECTION_OK)
   end
 
-  Sequel::Postgres::USES_PG = true
   if defined?(PG::TypeMapByClass)
+  # :nocov:
     type_map = Sequel::Postgres::PG_QUERY_TYPE_MAP = PG::TypeMapByClass.new
     type_map[Integer] = PG::TextEncoder::Integer.new
     type_map[FalseClass] = type_map[TrueClass] = PG::TextEncoder::Boolean.new
     type_map[Float] = PG::TextEncoder::Float.new
   end
+
+  Sequel::Postgres::USES_PG = true
 rescue LoadError => e 
+  # :nocov:
   begin
-    require 'postgres-pr/postgres-compat'
-    Sequel::Postgres::USES_PG = false
+    require 'sequel/postgres-pr'
   rescue LoadError 
-    raise e 
+    begin
+      require 'postgres-pr/postgres-compat'
+    rescue LoadError 
+      raise e 
+    end 
   end 
+  Sequel::Postgres::USES_PG = false
+  # :nocov:
 end
 
 module Sequel
   module Postgres
-    if Sequel::Postgres::USES_PG
+    # :nocov:
+    if USES_PG
       # Whether the given sequel_pg version integer is supported.
       def self.sequel_pg_version_supported?(version)
         version >= 10617
       end
     end
+    # :nocov:
 
     # PGconn subclass for connection specific methods used with the
     # pg or postgres-pr driver.
@@ -45,7 +56,9 @@ module Sequel
       # The underlying exception classes to reraise as disconnect errors
       # instead of regular database errors.
       DISCONNECT_ERROR_CLASSES = [IOError, Errno::EPIPE, Errno::ECONNRESET]
+      # :nocov:
       if defined?(::PG::ConnectionBad)
+      # :nocov:
         DISCONNECT_ERROR_CLASSES << ::PG::ConnectionBad
       end
       DISCONNECT_ERROR_CLASSES.freeze
@@ -71,11 +84,14 @@ module Sequel
         # are SQL strings.
         attr_reader :prepared_statements
 
+      # :nocov:
         unless public_method_defined?(:async_exec_params)
           alias async_exec_params async_exec
         end
-      else
-        # Make postgres-pr look like pg
+      elsif !const_defined?(:CONNECTION_OK)
+        # Handle old postgres-pr
+        # sequel-postgres-pr already implements this API
+
         CONNECTION_OK = -1
 
         # Escape bytea values.  Uses historical format instead of hex
@@ -111,6 +127,7 @@ module Sequel
           alias cmd_tuples cmdtuples
         end 
       end
+      # :nocov:
       
       # Raise a Sequel::DatabaseDisconnectError if a one of the disconnect
       # error classes is raised, or a PGError is raised and the connection
@@ -143,7 +160,7 @@ module Sequel
         begin
           defined?(yield) ? yield(q) : q.cmd_tuples
         ensure
-          q.clear if q && q.respond_to?(:clear)
+          q.clear if q && defined?(q.clear)
         end
       end
 
@@ -204,7 +221,9 @@ module Sequel
             :sslmode => opts[:sslmode],
             :sslrootcert => opts[:sslrootcert]
           }.delete_if { |key, value| blank_object?(value) }
+          # :nocov:
           connection_params.merge!(opts[:driver_options]) if opts[:driver_options]
+          # :nocov:
           conn = Adapter.connect(opts[:conn_str] || connection_params)
 
           conn.instance_variable_set(:@prepared_statements, {})
@@ -212,6 +231,13 @@ module Sequel
           if receiver = opts[:notice_receiver]
             conn.set_notice_receiver(&receiver)
           end
+
+          # :nocov:
+          if conn.respond_to?(:type_map_for_queries=) && defined?(PG_QUERY_TYPE_MAP)
+          # :nocov:
+            conn.type_map_for_queries = PG_QUERY_TYPE_MAP
+          end
+        # :nocov:
         else
           unless typecast_value_boolean(@opts.fetch(:force_standard_strings, true))
             raise Error, "Cannot create connection using postgres-pr unless force_standard_strings is set"
@@ -226,19 +252,19 @@ module Sequel
             opts[:password]
           )
         end
+        # :nocov:
 
         conn.instance_variable_set(:@db, self)
-        if USES_PG && conn.respond_to?(:type_map_for_queries=) && defined?(PG_QUERY_TYPE_MAP)
-          conn.type_map_for_queries = PG_QUERY_TYPE_MAP
-        end
 
+        # :nocov:
         if encoding = opts[:encoding] || opts[:charset]
-          if conn.respond_to?(:set_client_encoding)
+          if defined?(conn.set_client_encoding)
             conn.set_client_encoding(encoding)
           else
             conn.async_exec("set client_encoding to '#{encoding}'")
           end
         end
+        # :nocov:
 
         connection_configuration_sqls(opts).each{|sql| conn.execute(sql)}
         conn
@@ -265,7 +291,9 @@ module Sequel
         nil
       end
 
+      # :nocov:
       if USES_PG && Object.const_defined?(:PG) && ::PG.const_defined?(:Constants) && ::PG::Constants.const_defined?(:PG_DIAG_SCHEMA_NAME)
+      # :nocov:
         # Return a hash of information about the related PGError (or Sequel::DatabaseError that
         # wraps a PGError), with the following entries (any of which may be +nil+):
         #
@@ -316,7 +344,9 @@ module Sequel
         synchronize(opts[:server]){|conn| check_database_errors{_execute(conn, sql, opts, &block)}}
       end
 
+      # :nocov:
       if USES_PG
+      # :nocov:
         # +copy_table+ uses PostgreSQL's +COPY TO STDOUT+ SQL statement to return formatted
         # results directly to the caller.  This method is only supported if pg is the
         # underlying ruby driver.  This method should only be called if you want
@@ -462,12 +492,12 @@ module Sequel
                 opts[:after_listen].call(conn) if opts[:after_listen]
                 timeout = opts[:timeout]
                 if timeout
-                  timeout_block = timeout.respond_to?(:call) ? timeout : proc{timeout}
+                  timeout_block = defined?(timeout.call) ? timeout : proc{timeout}
                 end
 
                 if l = opts[:loop]
                   raise Error, 'calling #listen with :loop requires a block' unless block
-                  loop_call = l.respond_to?(:call)
+                  loop_call = defined?(l.call)
                   catch(:stop) do
                     while true
                       t = timeout_block ? [timeout_block.call] : []
@@ -509,8 +539,10 @@ module Sequel
       def adapter_initialize
         @use_iso_date_format = typecast_value_boolean(@opts.fetch(:use_iso_date_format, true))
         initialize_postgres_adapter
+        # :nocov:
         add_conversion_proc(17, method(:unescape_bytea)) if USES_PG
         add_conversion_proc(1082, TYPE_TRANSLATOR_DATE) if @use_iso_date_format
+        # :nocov:
         self.convert_infinite_timestamps = @opts[:convert_infinite_timestamps]
       end
 
@@ -520,19 +552,22 @@ module Sequel
       rescue => e
         raise_error(e, :classes=>database_error_classes)
       end
-
       # Set the DateStyle to ISO if configured, for faster date parsing.
       def connection_configuration_sqls(opts=@opts)
         sqls = super
+        # :nocov:
         sqls << "SET DateStyle = 'ISO'" if @use_iso_date_format
+        # :nocov:
         sqls
       end
 
+      # :nocov:
       if USES_PG
         def unescape_bytea(s)
           ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s))
         end
       end
+      # :nocov:
 
       DATABASE_ERROR_CLASSES = [PGError].freeze
       def database_error_classes
@@ -546,7 +581,9 @@ module Sequel
       end
 
       def database_exception_sqlstate(exception, opts)
-        if exception.respond_to?(:result) && (result = exception.result)
+        # :nocov:
+        if defined?(exception.result) && (result = exception.result)
+        # :nocov:
           result.error_field(PGresult::PG_DIAG_SQLSTATE)
         end
       end
@@ -588,7 +625,7 @@ module Sequel
         begin
           defined?(yield) ? yield(q) : q.cmd_tuples
         ensure
-          q.clear if q && q.respond_to?(:clear)
+          q.clear if q && defined?(q.clear)
         end
       end
 
@@ -656,7 +693,9 @@ module Sequel
         clone(:where=>Sequel.lit(['CURRENT OF '], Sequel.identifier(cursor_name)))
       end
 
+      # :nocov:
       if USES_PG
+      # :nocov:
         PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
         
         # PostgreSQL specific argument mapper used for mapping the named
@@ -803,6 +842,7 @@ module Sequel
   end
 end
 
+# :nocov:
 if Sequel::Postgres::USES_PG && !ENV['NO_SEQUEL_PG']
   begin
     require 'sequel_pg'
@@ -814,3 +854,4 @@ if Sequel::Postgres::USES_PG && !ENV['NO_SEQUEL_PG']
   rescue LoadError
   end
 end
+# :nocov:

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

@@ -338,6 +338,11 @@ module Sequel
         true
       end
       
+      # DB2 supports MERGE
+      def supports_merge?
+        true
+      end
+
       # DB2 does not support multiple columns in IN.
       def supports_multiple_column_in?
         false
@@ -360,6 +365,29 @@ module Sequel
 
       private
 
+      # Normalize conditions for MERGE WHEN.
+      def _merge_when_conditions_sql(sql, data)
+        if data.has_key?(:conditions)
+          sql << " AND "
+          literal_append(sql, _normalize_merge_when_conditions(data[:conditions]))
+        end
+      end
+
+      # Handle nil, false, and true MERGE WHEN conditions to avoid non-boolean
+      # type error.
+      def _normalize_merge_when_conditions(conditions)
+        case conditions
+        when nil, false
+          {1=>0}
+        when true
+          {1=>1}
+        when Sequel::SQL::DelayedEvaluation
+          Sequel.delay{_normalize_merge_when_conditions(conditions.call(self))}
+        else
+          conditions
+        end
+      end
+
       def empty_from_sql
         ' FROM "SYSIBM"."SYSDUMMY1"'
       end

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

@@ -205,7 +205,7 @@ module Sequel
           return @server_version = Integer(@opts[:server_version])
         end
         @server_version = synchronize(server) do |conn|
-          (conn.server_version rescue nil) if conn.respond_to?(:server_version)
+          (conn.server_version rescue nil) if defined?(conn.server_version)
         end
         unless @server_version
           m = /^(\d+)\.(\d+)\.(\d+)/.match(fetch("SELECT CAST(SERVERPROPERTY('ProductVersion') AS varchar)").single_value.to_s)
@@ -734,6 +734,11 @@ module Sequel
         false
       end
 
+      # MSSQL 2008+ supports MERGE
+      def supports_merge?
+        is_2008_or_later?
+      end
+
       # MSSQL 2005+ supports modifying joined datasets
       def supports_modifying_joins?
         is_2005_or_later?
@@ -824,6 +829,35 @@ module Sequel
 
       private
 
+      # Normalize conditions for MERGE WHEN.
+      def _merge_when_conditions_sql(sql, data)
+        if data.has_key?(:conditions)
+          sql << " AND "
+          literal_append(sql, _normalize_merge_when_conditions(data[:conditions]))
+        end
+      end
+
+      # Handle nil, false, and true MERGE WHEN conditions to avoid non-boolean
+      # type error.
+      def _normalize_merge_when_conditions(conditions)
+        case conditions
+        when nil, false
+          {1=>0}
+        when true
+          {1=>1}
+        when Sequel::SQL::DelayedEvaluation
+          Sequel.delay{_normalize_merge_when_conditions(conditions.call(self))}
+        else
+          conditions
+        end
+      end
+
+      # MSSQL requires a semicolon at the end of MERGE.
+      def _merge_when_sql(sql)
+        super
+        sql << ';'
+      end
+
       # MSSQL does not allow ordering in sub-clauses unless TOP (limit) is specified
       def aggregate_dataset
         (options_overlap(Sequel::Dataset::COUNT_FROM_SELF_OPTS) && !options_overlap([:limit])) ? unordered.from_self : super

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

@@ -333,6 +333,12 @@ module Sequel
           sqls <<  "SET sql_mode = '#{sql_mode}'"
         end
 
+        # Disable the use of split_materialized in the optimizer. This is
+        # needed to pass association tests on MariaDB 10.5+.
+        if opts[:disable_split_materialized] && typecast_value_boolean(opts[:disable_split_materialized])
+          sqls <<  "SET SESSION optimizer_switch='split_materialized=off'"
+        end
+
         sqls
       end
       

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

@@ -121,7 +121,7 @@ module Sequel
       def server_version(server=nil)
         return @server_version if @server_version
         @server_version = synchronize(server) do |conn|
-          (conn.server_version rescue nil) if conn.respond_to?(:server_version)
+          (conn.server_version rescue nil) if defined?(conn.server_version)
         end
         unless @server_version
           @server_version = if m = /(\d+)\.(\d+)\.?(\d+)?\.?(\d+)?/.match(fetch("select version from PRODUCT_COMPONENT_VERSION where lower(product) like 'oracle%'").single_value)
@@ -478,6 +478,11 @@ module Sequel
         false
       end
     
+      # Oracle supports MERGE
+      def supports_merge?
+        true
+      end
+
       # Oracle supports NOWAIT.
       def supports_nowait?
         true
@@ -525,6 +530,70 @@ module Sequel
 
       private
 
+      # Handle nil, false, and true MERGE WHEN conditions to avoid non-boolean
+      # type error.
+      def _normalize_merge_when_conditions(conditions)
+        case conditions
+        when nil, false
+          {1=>0}
+        when true
+          {1=>1}
+        when Sequel::SQL::DelayedEvaluation
+          Sequel.delay{_normalize_merge_when_conditions(conditions.call(self))}
+        else
+          conditions
+        end
+      end
+
+      # Handle Oracle's non standard MERGE syntax
+      def _merge_when_sql(sql)
+        raise Error, "no WHEN [NOT] MATCHED clauses provided for MERGE" unless merge_when = @opts[:merge_when]
+        insert = update = delete = nil
+        types = merge_when.map{|d| d[:type]}
+        raise Error, "Oracle does not support multiple INSERT, UPDATE, or DELETE clauses in MERGE" if types != types.uniq
+
+        merge_when.each do |data|
+          case data[:type]
+          when :insert
+            insert = data
+          when :update
+            update = data
+          else # when :delete
+            delete = data
+          end
+        end
+
+        if delete
+          raise Error, "Oracle does not support DELETE without UPDATE clause in MERGE" unless update
+          raise Error, "Oracle does not support DELETE without conditions clause in MERGE" unless delete.has_key?(:conditions)
+        end
+
+        if update
+          sql << " WHEN MATCHED"
+          _merge_update_sql(sql, update)
+          _merge_when_conditions_sql(sql, update)
+
+          if delete
+            sql << " DELETE"
+            _merge_when_conditions_sql(sql, delete)
+          end
+        end
+
+        if insert
+          sql << " WHEN NOT MATCHED"
+          _merge_insert_sql(sql, insert)
+          _merge_when_conditions_sql(sql, insert)
+        end
+      end
+
+      # Handle Oracle's non-standard MERGE WHEN condition syntax.
+      def _merge_when_conditions_sql(sql, data)
+        if data.has_key?(:conditions)
+          sql << " WHERE "
+          literal_append(sql, _normalize_merge_when_conditions(data[:conditions]))
+        end
+      end
+
       # Allow preparing prepared statements, since determining the prepared sql to use for
       # a prepared statement requires calling prepare on that statement.
       def allow_preparing_prepared_statements?