sequel 4.36.0 → 5.61.0

data/lib/sequel/adapters/postgresql.rb

@@ -1,3 +1,3 @@
 # frozen-string-literal: true
 
-Sequel.require 'adapters/postgres'
+require_relative 'postgres'

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

@@ -1,20 +1,23 @@
 # frozen-string-literal: true
 
-module Sequel
-  require 'adapters/utils/emulate_offset_with_reverse_and_count'
+require_relative '../utils/emulate_offset_with_reverse_and_count'
+require_relative '../utils/unmodified_identifiers'
+require_relative '../utils/columns_limit_1'
 
+module Sequel
   module Access
+    Sequel::Database.set_shared_adapter_scheme(:access, self)
+
     module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
+      include UnmodifiedIdentifiers::DatabaseMethods
 
-      # Access uses type :access as the database_type
       def database_type
         :access
       end
 
       # Doesn't work, due to security restrictions on MSysObjects
       #def tables
-      #  from(:MSysObjects).filter(: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,
@@ -54,19 +57,10 @@ module Sequel
         DATABASE_ERROR_REGEXPS
       end
 
-      # The SQL to drop an index for the table.
       def drop_index_sql(table, op)
         "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))} ON #{quote_schema_table(table)}"
       end
       
-      def identifier_input_method_default
-        nil
-      end
-      
-      def identifier_output_method_default
-        nil
-      end
-      
       # Access doesn't have a 64-bit integer type, so use integer and hope
       # the user isn't using more than 32 bits.
       def type_literal_generic_bignum_symbol(column)
@@ -89,33 +83,15 @@ module Sequel
         Dataset.def_sql_method(self, :select, %w'select distinct limit columns into from join where group order having compounds')
       end)
       include EmulateOffsetWithReverseAndCount
+      include UnmodifiedIdentifiers::DatasetMethods
+      include ::Sequel::Dataset::ColumnsLimit1
 
-      DATE_FORMAT = '#%Y-%m-%d#'.freeze
-      TIMESTAMP_FORMAT = '#%Y-%m-%d %H:%M:%S#'.freeze
-      TOP = " TOP ".freeze
-      BRACKET_CLOSE = Dataset::BRACKET_CLOSE
-      BRACKET_OPEN = Dataset::BRACKET_OPEN
-      PAREN_CLOSE = Dataset::PAREN_CLOSE
-      PAREN_OPEN = Dataset::PAREN_OPEN
-      INTO = Dataset::INTO
-      FROM = Dataset::FROM
-      SPACE = Dataset::SPACE
-      NOT_EQUAL = ' <> '.freeze
-      OPS = {:'%'=>' Mod '.freeze, :'||'=>' & '.freeze}
-      BOOL_FALSE = '0'.freeze
-      BOOL_TRUE = '-1'.freeze
-      DATE_FUNCTION = 'Date()'.freeze
-      NOW_FUNCTION = 'Now()'.freeze
-      TIME_FUNCTION = 'Time()'.freeze
-      CAST_TYPES = {String=>:CStr, Integer=>:CLng, Date=>:CDate, Time=>:CDate, DateTime=>:CDate, Numeric=>:CDec, BigDecimal=>:CDec, File=>:CStr, Float=>:CDbl, TrueClass=>:CBool, FalseClass=>:CBool}
-
-      EMULATED_FUNCTION_MAP = {:char_length=>:len}
-      EXTRACT_MAP = {:year=>"'yyyy'", :month=>"'m'", :day=>"'d'", :hour=>"'h'", :minute=>"'n'", :second=>"'s'"}
-      COMMA = Dataset::COMMA
-      DATEPART_OPEN = "datepart(".freeze
-
-      # Access doesn't support CASE, but it can be emulated with nested
-      # IIF function calls.
+      EXTRACT_MAP = {:year=>"'yyyy'", :month=>"'m'", :day=>"'d'", :hour=>"'h'", :minute=>"'n'", :second=>"'s'"}.freeze
+      EXTRACT_MAP.each_value(&:freeze)
+      OPS = {:'%'=>' Mod '.freeze, :'||'=>' & '.freeze}.freeze
+      CAST_TYPES = {String=>:CStr, Integer=>:CLng, Date=>:CDate, Time=>:CDate, DateTime=>:CDate, Numeric=>:CDec, BigDecimal=>:CDec, File=>:CStr, Float=>:CDbl, TrueClass=>:CBool, FalseClass=>:CBool}.freeze
+
+      # Access doesn't support CASE, so emulate it with nested IIF function calls.
       def case_expression_sql_append(sql, ce)
         literal_append(sql, ce.with_merged_expression.conditions.reverse.inject(ce.default){|exp,(cond,val)| Sequel::SQL::Function.new(:IIF, cond, val, exp)})
       end
@@ -124,9 +100,9 @@ module Sequel
       # type conversion
       def cast_sql_append(sql, expr, type)
         sql << CAST_TYPES.fetch(type, type).to_s
-        sql << PAREN_OPEN
+        sql << '('
         literal_append(sql, expr)
-        sql << PAREN_CLOSE
+        sql << ')'
       end
 
       def complex_expression_sql_append(sql, op, args)
@@ -135,20 +111,14 @@ module Sequel
           complex_expression_sql_append(sql, :LIKE, args)
         when :'NOT ILIKE'
           complex_expression_sql_append(sql, :'NOT LIKE', args)
-        when :LIKE, :'NOT LIKE'
-          sql << PAREN_OPEN
-          literal_append(sql, args.at(0))
-          sql << SPACE << op.to_s << SPACE
-          literal_append(sql, args.at(1))
-          sql << PAREN_CLOSE
         when :'!='
-          sql << PAREN_OPEN
-          literal_append(sql, args.at(0))
-          sql << NOT_EQUAL
-          literal_append(sql, args.at(1))
-          sql << PAREN_CLOSE
+          sql << '('
+          literal_append(sql, args[0])
+          sql << ' <> '
+          literal_append(sql, args[1])
+          sql << ')'
         when :'%', :'||'
-          sql << PAREN_OPEN
+          sql << '('
           c = false
           op_str = OPS[op]
           args.each do |a|
@@ -156,27 +126,33 @@ module Sequel
             literal_append(sql, a)
             c ||= true
           end
-          sql << PAREN_CLOSE
+          sql << ')'
+        when :**
+          sql << '('
+          literal_append(sql, args[0])
+          sql << ' ^ '
+          literal_append(sql, args[1])
+          sql << ')'
         when :extract
-          part = args.at(0)
+          part = args[0]
           raise(Sequel::Error, "unsupported extract argument: #{part.inspect}") unless format = EXTRACT_MAP[part]
-          sql << DATEPART_OPEN << format.to_s << COMMA
-          literal_append(sql, args.at(1))
-          sql << PAREN_CLOSE
+          sql << "datepart(" << format.to_s << ', '
+          literal_append(sql, args[1])
+          sql << ')'
         else
           super
         end
       end
 
-      # Use Date() and Now() for CURRENT_DATE and CURRENT_TIMESTAMP
+      # Use Date(), Now(), and Time() for CURRENT_DATE, CURRENT_TIMESTAMP, and CURRENT_TIME
       def constant_sql_append(sql, constant)
         case constant
         when :CURRENT_DATE
-          sql << DATE_FUNCTION
+          sql << 'Date()'
         when :CURRENT_TIMESTAMP
-          sql << NOW_FUNCTION
+          sql << 'Now()'
         when :CURRENT_TIME
-          sql << TIME_FUNCTION
+          sql << 'Time()'
         else
           super
         end
@@ -197,6 +173,12 @@ module Sequel
         clone(:into => table)
       end
 
+      # Access uses [] for quoting identifiers, and can't handle
+      # ] inside identifiers.
+      def quoted_identifier_append(sql, v)
+        sql << '[' << v.to_s << ']'
+      end
+
       # Access does not support derived column lists.
       def supports_derived_column_lists?
         false
@@ -232,31 +214,50 @@ module Sequel
 
       # Access uses # to quote dates
       def literal_date(d)
-        d.strftime(DATE_FORMAT)
+        d.strftime('#%Y-%m-%d#')
       end
 
       # Access uses # to quote datetimes
       def literal_datetime(t)
-        t.strftime(TIMESTAMP_FORMAT)
+        t.strftime('#%Y-%m-%d %H:%M:%S#')
       end
       alias literal_time literal_datetime
 
       # Use 0 for false on MSSQL
       def literal_false
-        BOOL_FALSE
+        '0'
       end
 
-      # Use 0 for false on MSSQL
+      # Use -1 for true on MSSQL
       def literal_true
-        BOOL_TRUE
+        '-1'
+      end
+
+      # Emulate the char_length function with len
+      def native_function_name(emulated_function)
+        if emulated_function == :char_length
+          'len'
+        else
+          super
+        end
+      end
+
+      # Access does not natively support NULLS FIRST/LAST.
+      def requires_emulating_nulls_first?
+        true
+      end
+
+      # Access doesn't support ESCAPE for LIKE.
+      def requires_like_escape?
+        false
       end
 
       # Access requires parentheses when joining more than one table
       def select_from_sql(sql)
         if f = @opts[:from]
-          sql << FROM
+          sql << ' FROM '
           if (j = @opts[:join]) && !j.empty?
-            sql << (PAREN_OPEN * j.length)
+            sql << ('(' * j.length)
           end
           source_list_append(sql, f)
         end
@@ -264,7 +265,7 @@ module Sequel
 
       def select_into_sql(sql)
         if i = @opts[:into]
-          sql << INTO
+          sql << " INTO "
           identifier_append(sql, i)
         end
       end
@@ -274,7 +275,7 @@ module Sequel
         if js = @opts[:join]
           js.each do |j|
             literal_append(sql, j)
-            sql << PAREN_CLOSE
+            sql << ')'
           end
         end
       end
@@ -282,15 +283,10 @@ module Sequel
       # Access uses TOP for limits
       def select_limit_sql(sql)
         if l = @opts[:limit]
-          sql << TOP
+          sql << " TOP "
           literal_append(sql, l)
         end
       end
-
-      # Access uses [] for quoting identifiers
-      def quoted_identifier_append(sql, v)
-        sql << BRACKET_OPEN << v.to_s << BRACKET_CLOSE
-      end
     end
   end
 end

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

@@ -1,24 +1,16 @@
 # frozen-string-literal: true
 
-Sequel.require 'adapters/utils/emulate_offset_with_row_number'
+require_relative '../utils/emulate_offset_with_row_number'
+require_relative '../utils/columns_limit_1'
 
 module Sequel
   module DB2
-    @use_clob_as_blob = false
-
-    class << self
-      # Whether to use clob as the generic File type, true by default.
-      attr_accessor :use_clob_as_blob
-    end
+    Sequel::Database.set_shared_adapter_scheme(:db2, self)
 
     module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
-
-      AUTOINCREMENT = 'GENERATED ALWAYS AS IDENTITY'.freeze
-      NOT_NULL      = ' NOT NULL'.freeze
-      NULL          = ''.freeze
+      # Whether to use clob as the generic File type, false by default.
+      attr_accessor :use_clob_as_blob
 
-      # DB2 always uses :db2 as it's database type
       def database_type
         :db2
       end
@@ -26,11 +18,17 @@ module Sequel
       # Return the database version as a string.  Don't rely on this,
       # it may return an integer in the future.
       def db2_version
-        return @db2_version if @db2_version
+        return @db2_version if defined?(@db2_version)
         @db2_version = metadata_dataset.with_sql("select service_level from sysibmadm.env_inst_info").first[:service_level]
       end
       alias_method :server_version, :db2_version
 
+      def freeze
+        db2_version
+        offset_strategy
+        super
+      end
+
       # Use SYSIBM.SYSCOLUMNS to get the information on the tables.
       def schema_parse_table(table, opts = OPTS)
         m = output_identifier_meth(opts[:dataset])
@@ -72,9 +70,10 @@ module Sequel
       # Use SYSCAT.INDEXES to get the indexes for the table
       def indexes(table, opts = OPTS)
         m = output_identifier_meth
+        table = table.value if table.is_a?(Sequel::SQL::Identifier)
         indexes = {}
         metadata_dataset.
-         from(:syscat__indexes).
+         from(Sequel[:syscat][:indexes]).
          select(:indname, :uniquerule, :colnames).
          where(:tabname=>input_identifier_meth.call(table), :system_required=>0).
          each do |r|
@@ -83,6 +82,17 @@ module Sequel
         indexes
       end
 
+      def offset_strategy
+        return @offset_strategy if defined?(@offset_strategy)
+
+        @offset_strategy = case strategy = opts[:offset_strategy].to_s
+        when "limit_offset", "offset_fetch"
+          opts[:offset_strategy] = strategy.to_sym
+        else
+          opts[:offset_strategy] = :emulate
+        end
+      end
+
       # DB2 supports transaction isolation levels.
       def supports_transaction_isolation_levels?
         true
@@ -109,7 +119,6 @@ module Sequel
 
       private
 
-      # Handle DB2 specific alter table operations.
       def alter_table_sql(table, op)
         case op[:op]
         when :add_column
@@ -117,7 +126,7 @@ module Sequel
             [
             "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op.merge(:auto_increment=>false, :primary_key=>false, :default=>0, :null=>false))}",
             "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{literal(op[:name])} DROP DEFAULT",
-            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{literal(op[:name])} SET #{AUTOINCREMENT}"
+            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{literal(op[:name])} SET #{auto_increment_sql}"
             ]
           else
             "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op)}"
@@ -155,16 +164,12 @@ module Sequel
 
       # DB2 uses an identity column for autoincrement.
       def auto_increment_sql
-        AUTOINCREMENT
+        'GENERATED ALWAYS AS IDENTITY'
       end
 
-      # Add null/not null SQL fragment to column creation SQL.
-      def column_definition_null_sql(sql, column)
-        null = column.fetch(:null, column[:allow_null]) 
-        null = false  if column[:primary_key]
-
-        sql << NOT_NULL if null == false
-        sql << NULL if null == true
+      # DB2 does not allow adding primary key constraints to NULLable columns.
+      def can_add_primary_key_constraint_on_nullable_columns?
+        false
       end
 
       # Supply columns with NOT NULL if they are part of a composite
@@ -234,7 +239,7 @@ module Sequel
 
       # Treat clob as blob if use_clob_as_blob is true
       def schema_column_type(db_type)
-        (::Sequel::DB2::use_clob_as_blob && db_type.downcase == 'clob') ? :blob : super
+        (use_clob_as_blob && db_type.downcase == 'clob') ? :blob : super
       end
 
       # SQL to set the transaction isolation level
@@ -247,7 +252,7 @@ module Sequel
       # use this for blob value:
       #     cast(X'fffefdfcfbfa' as blob(2G))
       def type_literal_generic_file(column)
-        ::Sequel::DB2::use_clob_as_blob ? :clob : :blob
+        use_clob_as_blob ? :clob : :blob
       end
 
       # DB2 uses smallint to store booleans.
@@ -269,29 +274,16 @@ module Sequel
 
     module DatasetMethods
       include EmulateOffsetWithRowNumber
+      include ::Sequel::Dataset::ColumnsLimit1
 
-      PAREN_CLOSE = Dataset::PAREN_CLOSE
-      PAREN_OPEN = Dataset::PAREN_OPEN
-      BITWISE_METHOD_MAP = {:& =>:BITAND, :| => :BITOR, :^ => :BITXOR, :'B~'=>:BITNOT}
-      EMULATED_FUNCTION_MAP = {:char_length=>'length'.freeze}
-      BOOL_TRUE = '1'.freeze
-      BOOL_FALSE = '0'.freeze
-      CAST_STRING_OPEN = "RTRIM(CHAR(".freeze
-      CAST_STRING_CLOSE = "))".freeze
-      FETCH_FIRST_ROW_ONLY = " FETCH FIRST ROW ONLY".freeze
-      FETCH_FIRST = " FETCH FIRST ".freeze
-      ROWS_ONLY = " ROWS ONLY".freeze
-      EMPTY_FROM_TABLE = ' FROM "SYSIBM"."SYSDUMMY1"'.freeze
-      HSTAR = "H*".freeze
-      BLOB_OPEN = "BLOB(X'".freeze
-      BLOB_CLOSE = "')".freeze
+      BITWISE_METHOD_MAP = {:& =>:BITAND, :| => :BITOR, :^ => :BITXOR, :'B~'=>:BITNOT}.freeze
 
       # DB2 casts strings using RTRIM and CHAR instead of VARCHAR.
       def cast_sql_append(sql, expr, type)
         if(type == String)
-          sql << CAST_STRING_OPEN
+          sql << "RTRIM(CHAR("
           literal_append(sql, expr)
-          sql << CAST_STRING_CLOSE
+          sql << "))"
         else
           super
         end
@@ -304,15 +296,19 @@ module Sequel
         when :'B~'
           literal_append(sql, SQL::Function.new(:BITNOT, *args))
         when :extract
-          sql << args.at(0).to_s
-          sql << PAREN_OPEN
-          literal_append(sql, args.at(1))
-          sql << PAREN_CLOSE
+          sql << args[0].to_s
+          sql << '('
+          literal_append(sql, args[1])
+          sql << ')'
         else
           super
         end
       end
 
+      def quote_identifiers?
+        @opts.fetch(:quote_identifiers, false)
+      end
+
       def supports_cte?(type=:select)
         type == :select
       end
@@ -342,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
@@ -352,11 +353,6 @@ module Sequel
         false
       end
 
-      # DB2 does not support fractional seconds in timestamps.
-      def supports_timestamp_usecs?
-        false
-      end
-
       # DB2 supports window functions
       def supports_window_functions?
         true
@@ -369,8 +365,38 @@ 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
-        EMPTY_FROM_TABLE
+        ' FROM "SYSIBM"."SYSDUMMY1"'
+      end
+
+      # Emulate offset with row number by default, and also when the limit_offset
+      # strategy is used without a limit, as DB2 doesn't support that syntax with
+      # no limit.
+      def emulate_offset_with_row_number?
+        super && (db.offset_strategy == :emulate || (db.offset_strategy == :limit_offset && !@opts[:limit]))
       end
 
       # DB2 needs the standard workaround to insert all default values into
@@ -381,20 +407,25 @@ module Sequel
 
       # Use 0 for false on DB2
       def literal_false
-        BOOL_FALSE
+        '0'
+      end
+
+      # DB2 doesn't support fractional seconds in times, only fractional seconds in timestamps.
+      def literal_sqltime(v)
+        v.strftime("'%H:%M:%S'")
       end
 
       # Use 1 for true on DB2
       def literal_true
-        BOOL_TRUE
+        '1'
       end
 
       # DB2 uses a literal hexidecimal number for blob strings
       def literal_blob_append(sql, v)
-        if ::Sequel::DB2.use_clob_as_blob
+        if db.use_clob_as_blob
           super
         else
-          sql << BLOB_OPEN << v.unpack(HSTAR).first << BLOB_CLOSE
+          sql << "BLOB(X'" << v.unpack("H*").first << "')"
         end
       end
 
@@ -403,29 +434,45 @@ module Sequel
         :union
       end
 
+      # Emulate the char_length function with length
+      def native_function_name(emulated_function)
+        if emulated_function == :char_length
+          'length'
+        else
+          super
+        end
+      end
+
       # DB2 does not require that ROW_NUMBER be ordered.
       def require_offset_order?
         false
       end
 
-      # Modify the sql to limit the number of rows returned
-      # Note: 
-      #
-      #     After db2 v9.7, MySQL flavored "LIMIT X OFFSET Y" can be enabled using
-      #
-      #     db2set DB2_COMPATIBILITY_VECTOR=MYSQL
-      #     db2stop
-      #     db2start
-      #
-      #     Support for this feature is not used in this adapter however.
+      # At least some versions of DB do not support NULLS FIRST/LAST.
+      def requires_emulating_nulls_first?
+        true
+      end
+
+      # Modify the sql to limit the number of rows returned.
+      # Uses :offset_strategy Database option to determine how to format the
+      # limit and offset.
       def select_limit_sql(sql)
+        strategy = db.offset_strategy
+        return super if strategy == :limit_offset
+
+        if strategy == :offset_fetch && (o = @opts[:offset]) 
+          sql << " OFFSET "
+          literal_append(sql, o)
+          sql << " ROWS"
+        end
+
         if l = @opts[:limit]
           if l == 1
-            sql << FETCH_FIRST_ROW_ONLY
+            sql << " FETCH FIRST ROW ONLY"
           else
-            sql << FETCH_FIRST
+            sql << " FETCH FIRST "
             literal_append(sql, l)
-            sql << ROWS_ONLY
+            sql << " ROWS ONLY"
           end
         end
       end