sequel 5.45.0 → 5.77.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,30 +127,29 @@ 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
       # status cannot be determined or it is not OK.
       def check_disconnect_errors
+        yield
+      rescue *DISCONNECT_ERROR_CLASSES => e
+        disconnect = true
+        raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError))
+      rescue PGError => e
+        disconnect = false
         begin
-          yield
-        rescue *DISCONNECT_ERROR_CLASSES => e
+          s = status
+        rescue PGError
           disconnect = true
-          raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError))
-        rescue PGError => e
-          disconnect = false
-          begin
-            s = status
-          rescue PGError
-            disconnect = true
-          end
-          status_ok = (s == Adapter::CONNECTION_OK)
-          disconnect ||= !status_ok
-          disconnect ||= e.message =~ DISCONNECT_ERROR_RE
-          disconnect ? raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError)) : raise
-        ensure
-          block if status_ok && !disconnect
         end
+        status_ok = (s == Adapter::CONNECTION_OK)
+        disconnect ||= !status_ok
+        disconnect ||= e.message =~ DISCONNECT_ERROR_RE
+        disconnect ? raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError)) : raise
+      ensure
+        block if status_ok && !disconnect
       end
 
       # Execute the given SQL with this connection.  If a block is given,
@@ -143,7 +158,7 @@ module Sequel
         args = args.map{|v| @db.bound_variable_arg(v, self)} if args
         q = check_disconnect_errors{execute_query(sql, args)}
         begin
-          block_given? ? yield(q) : q.cmd_tuples
+          defined?(yield) ? yield(q) : q.cmd_tuples
         ensure
           q.clear if q && q.respond_to?(:clear)
         end
@@ -170,8 +185,12 @@ module Sequel
         case arg
         when Sequel::SQL::Blob
           {:value=>arg, :type=>17, :format=>1}
-        when DateTime, Time
-          literal(arg)
+        # :nocov:
+        # Not covered by tests as tests use pg_extended_date_support
+        # extension, which has basically the same code.
+        when Time, DateTime
+          @default_dataset.literal_date_or_time(arg)
+        # :nocov:
         else
           arg
         end
@@ -206,7 +225,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, {})
@@ -214,6 +235,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"
@@ -228,12 +256,11 @@ 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)
             conn.set_client_encoding(encoding)
@@ -241,6 +268,7 @@ module Sequel
             conn.async_exec("set client_encoding to '#{encoding}'")
           end
         end
+        # :nocov:
 
         connection_configuration_sqls(opts).each{|sql| conn.execute(sql)}
         conn
@@ -267,7 +295,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+):
         #
@@ -318,7 +348,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
@@ -350,7 +382,7 @@ module Sequel
           synchronize(opts[:server]) do |conn|
             conn.execute(copy_table_sql(table, opts))
             begin
-              if block_given?
+              if defined?(yield)
                 while buf = conn.get_copy_data
                   yield buf
                 end
@@ -400,16 +432,16 @@ module Sequel
           data = opts[:data]
           data = Array(data) if data.is_a?(String)
 
-          if block_given? && data
+          if defined?(yield) && data
             raise Error, "Cannot provide both a :data option and a block to copy_into"
-          elsif !block_given? && !data
+          elsif !defined?(yield) && !data
             raise Error, "Must provide either a :data option or a block to copy_into"
           end
 
           synchronize(opts[:server]) do |conn|
             conn.execute(copy_into_sql(table, opts))
             begin
-              if block_given?
+              if defined?(yield)
                 while buf = yield
                   conn.put_copy_data(buf)
                 end
@@ -511,32 +543,35 @@ 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
 
       # Convert exceptions raised from the block into DatabaseErrors.
       def check_database_errors
-        begin
-          yield
-        rescue => e
-          raise_error(e, :classes=>database_error_classes)
-        end
+        yield
+      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
@@ -550,7 +585,9 @@ module Sequel
       end
 
       def database_exception_sqlstate(exception, opts)
+        # :nocov:
         if exception.respond_to?(:result) && (result = exception.result)
+        # :nocov:
           result.error_field(PGresult::PG_DIAG_SQLSTATE)
         end
       end
@@ -590,7 +627,7 @@ module Sequel
 
         q = conn.check_disconnect_errors{log_connection_yield(log_sql, conn, args){_execute_prepared_statement(conn, ps_name, args, opts)}}
         begin
-          block_given? ? yield(q) : q.cmd_tuples
+          defined?(yield) ? yield(q) : q.cmd_tuples
         ensure
           q.clear if q && q.respond_to?(:clear)
         end
@@ -616,7 +653,7 @@ module Sequel
       
       # Use a cursor for paging.
       def paged_each(opts=OPTS, &block)
-        unless block_given?
+        unless defined?(yield)
           return enum_for(:paged_each, opts)
         end
         use_cursor(opts).each(&block)
@@ -635,6 +672,7 @@ module Sequel
       #          cursor usage.
       # :rows_per_fetch :: The number of rows per fetch (default 1000).  Higher
       #                    numbers result in fewer queries but greater memory use.
+      # :skip_transaction :: Same as :hold, but :hold takes priority.
       #
       # Usage:
       #
@@ -660,7 +698,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
@@ -717,19 +757,21 @@ module Sequel
         sql = String.new
         sql << "CALL "
         identifier_append(sql, name)
-        literal_append(sql, args)
+        sql << "("
+        expression_list_append(sql, args)
+        sql << ")"
         with_sql_first(sql)
       end
 
       # Use a cursor to fetch groups of records at a time, yielding them to the block.
       def cursor_fetch_rows(sql)
-        server_opts = {:server=>@opts[:server] || :read_only}
         cursor = @opts[:cursor]
-        hold = cursor[:hold]
+        hold = cursor.fetch(:hold){cursor[:skip_transaction]}
+        server_opts = {:server=>@opts[:server] || :read_only, :skip_transaction=>hold}
         cursor_name = quote_identifier(cursor[:cursor_name] || 'sequel_cursor')
         rows_per_fetch = cursor[:rows_per_fetch].to_i
 
-        db.public_send(*(hold ? [:synchronize, server_opts[:server]] : [:transaction, server_opts])) do 
+        db.transaction(server_opts) do 
           begin
             execute_ddl("DECLARE #{cursor_name} NO SCROLL CURSOR WITH#{'OUT' unless hold} HOLD FOR #{sql}", server_opts)
             rows_per_fetch = 1000 if rows_per_fetch <= 0
@@ -805,6 +847,7 @@ module Sequel
   end
 end
 
+# :nocov:
 if Sequel::Postgres::USES_PG && !ENV['NO_SEQUEL_PG']
   begin
     require 'sequel_pg'
@@ -816,3 +859,4 @@ if Sequel::Postgres::USES_PG && !ENV['NO_SEQUEL_PG']
   rescue LoadError
   end
 end
+# :nocov:

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

@@ -2,6 +2,7 @@
 
 require_relative '../utils/emulate_offset_with_reverse_and_count'
 require_relative '../utils/unmodified_identifiers'
+require_relative '../utils/columns_limit_1'
 
 module Sequel
   module Access
@@ -16,7 +17,7 @@ module Sequel
 
       # Doesn't work, due to security restrictions on MSysObjects
       #def tables
-      #  from(:MSysObjects).where(:Type=>1, :Flags=>0).select_map(:Name).map(&:to_sym)
+      #  from(:MSysObjects).where(Type: 1, Flags: 0).select_map(:Name).map(&:to_sym)
       #end
       
       # Access doesn't support renaming tables from an SQL query,
@@ -56,6 +57,14 @@ module Sequel
         DATABASE_ERROR_REGEXPS
       end
 
+      # Access's Byte type will accept much larger values,
+      # even though it only stores 0-255.  Do not set min/max
+      # values for the Byte type.
+      def column_schema_integer_min_max_values(column)
+        return if /byte/i =~ column[:db_type]
+        super
+      end
+
       def drop_index_sql(table, op)
         "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))} ON #{quote_schema_table(table)}"
       end
@@ -83,6 +92,7 @@ module Sequel
       end)
       include EmulateOffsetWithReverseAndCount
       include UnmodifiedIdentifiers::DatasetMethods
+      include ::Sequel::Dataset::ColumnsLimit1
 
       EXTRACT_MAP = {:year=>"'yyyy'", :month=>"'m'", :day=>"'d'", :hour=>"'h'", :minute=>"'n'", :second=>"'s'"}.freeze
       EXTRACT_MAP.each_value(&:freeze)

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

@@ -1,6 +1,7 @@
 # frozen-string-literal: true
 
 require_relative '../utils/emulate_offset_with_row_number'
+require_relative '../utils/columns_limit_1'
 
 module Sequel
   module DB2
@@ -214,6 +215,18 @@ module Sequel
         DATABASE_ERROR_REGEXPS
       end
 
+      DISCONNECT_SQL_STATES = %w'40003 08001 08003'.freeze
+      def disconnect_error?(exception, opts)
+        sqlstate = database_exception_sqlstate(exception, opts)
+
+        case sqlstate
+        when *DISCONNECT_SQL_STATES
+          true
+        else
+          super
+        end
+      end
+
       # DB2 has issues with quoted identifiers, so
       # turn off database quoting by default.
       def quote_identifiers_default
@@ -273,6 +286,7 @@ module Sequel
 
     module DatasetMethods
       include EmulateOffsetWithRowNumber
+      include ::Sequel::Dataset::ColumnsLimit1
 
       BITWISE_METHOD_MAP = {:& =>:BITAND, :| => :BITOR, :^ => :BITXOR, :'B~'=>:BITNOT}.freeze
 
@@ -336,6 +350,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
@@ -358,6 +377,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

@@ -24,6 +24,10 @@ module Sequel
       # Database object.
       attr_accessor :mssql_unicode_strings
 
+      # Whether to use LIKE without COLLATE Latin1_General_CS_AS.  Skipping the COLLATE
+      # can significantly increase performance in some cases.
+      attr_accessor :like_without_collate
+
       # Execute the given stored procedure with the given name.
       #
       # Options:
@@ -321,6 +325,11 @@ module Sequel
         false
       end
 
+      # MSSQL tinyint types are unsigned.
+      def column_schema_tinyint_type_is_unsigned?
+        true
+      end
+
       # Handle MSSQL specific default format.
       def column_schema_normalize_default(default, type)
         if m = /\A(?:\(N?('.*')\)|\(\((-?\d+(?:\.\d+)?)\)\))\z/.match(default)
@@ -395,10 +404,15 @@ module Sequel
       # Backbone of the tables and views support.
       def information_schema_tables(type, opts)
         m = output_identifier_meth
-        metadata_dataset.from(Sequel[:information_schema][:tables].as(:t)).
+        schema = opts[:schema]||'dbo'
+        tables = metadata_dataset.from(Sequel[:information_schema][:tables].as(:t)).
           select(:table_name).
-          where(:table_type=>type, :table_schema=>(opts[:schema]||'dbo').to_s).
+          where(:table_type=>type, :table_schema=>schema.to_s).
           map{|x| m.call(x[:table_name])}
+
+        tables.map!{|t| Sequel.qualify(m.call(schema).to_s, m.call(t).to_s)} if opts[:qualify]
+
+        tables
       end
 
       # Always quote identifiers in the metadata_dataset, so schema parsing works.
@@ -548,9 +562,9 @@ module Sequel
         when :'||'
           super(sql, :+, args)
         when :LIKE, :"NOT LIKE"
-          super(sql, op, args.map{|a| Sequel.lit(["(", " COLLATE Latin1_General_CS_AS)"], a)})
+          super(sql, op, complex_expression_sql_like_args(args, " COLLATE Latin1_General_CS_AS)"))
         when :ILIKE, :"NOT ILIKE"
-          super(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), args.map{|a| Sequel.lit(["(", " COLLATE Latin1_General_CI_AS)"], a)})
+          super(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), complex_expression_sql_like_args(args, " COLLATE Latin1_General_CI_AS)"))
         when :<<, :>>
           complex_expression_emulate_append(sql, op, args)
         when :extract
@@ -582,6 +596,18 @@ module Sequel
         end
       end
       
+      # For a dataset with custom SQL, since it may include ORDER BY, you
+      # cannot wrap it in a subquery.  Load entire query in this case to get
+      # the number of rows. In general, you should avoid calling this method
+      # on datasets with custom SQL.
+      def count(*a, &block)
+        if (@opts[:sql] && a.empty? && !block)
+          naked.to_a.length
+        else
+          super
+        end
+      end
+
       # Uses CROSS APPLY to join the given table into the current dataset.
       def cross_apply(table)
         join_table(:cross_apply, table)
@@ -592,6 +618,19 @@ module Sequel
         clone(:disable_insert_output=>true)
       end
 
+      # For a dataset with custom SQL, since it may include ORDER BY, you
+      # cannot wrap it in a subquery.  Run query, and if it returns any
+      # records, return true. In general, you should avoid calling this method
+      # on datasets with custom SQL.
+      def empty?
+        if @opts[:sql]
+          naked.each{return false}
+          true
+        else
+          super
+        end
+      end
+
       # MSSQL treats [] as a metacharacter in LIKE expresions.
       def escape_like(string)
         string.gsub(/[\\%_\[\]]/){|m| "\\#{m}"}
@@ -730,6 +769,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?
@@ -791,11 +835,10 @@ module Sequel
         if opts[:return] == :primary_key && !@opts[:output]
           output(nil, [SQL::QualifiedIdentifier.new(:inserted, first_primary_key)])._import(columns, values, opts)
         elsif @opts[:output]
-          statements = multi_insert_sql(columns, values)
-          ds = naked
-          @db.transaction(opts.merge(:server=>@opts[:server])) do
-            statements.map{|st| ds.with_sql(st)}
-          end.first.map{|v| v.length == 1 ? v.values.first : v}
+          # no transaction: our multi_insert_sql_strategy should guarantee
+          # that there's only ever a single statement.
+          sql = multi_insert_sql(columns, values)[0]
+          naked.with_sql(sql).map{|v| v.length == 1 ? v.values.first : v}
         else
           super
         end
@@ -820,6 +863,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
@@ -847,11 +919,20 @@ module Sequel
         server_version >= 11000000
       end
 
+      # Determine whether to add the COLLATE for LIKE arguments, based on the Database setting.
+      def complex_expression_sql_like_args(args, collation)
+        if db.like_without_collate
+          args
+        else
+          args.map{|a| Sequel.lit(["(", collation], a)}
+        end
+      end
+      
       # Use strict ISO-8601 format with T between date and time,
       # since that is the format that is multilanguage and not
       # DATEFORMAT dependent.
       def default_timestamp_format
-        "'%Y-%m-%dT%H:%M:%S%N%z'"
+        "'%Y-%m-%dT%H:%M:%S.%3N'"
       end
 
       # Only include the primary table in the main delete clause