sequel 4.45.0 → 4.46.0

data/lib/sequel/adapters/postgres.rb

@@ -97,9 +97,12 @@ module Sequel
   module Postgres
     CONVERTED_EXCEPTIONS << PGError
 
-    PG_TYPES[17] = Class.new do
+    TYPE_CONVERTOR = Class.new do
       def bytea(s) ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s)) end
-    end.new.method(:bytea)
+    end.new
+
+    # SEQUEL5: Remove
+    PG_TYPES[17] = TYPE_CONVERTOR.method(:bytea)
 
     if Sequel::Postgres::USES_PG
       # Whether the given sequel_pg version integer is supported.
@@ -126,6 +129,7 @@ module Sequel
       if defined?(::PG::ConnectionBad)
         DISCONNECT_ERROR_CLASSES << ::PG::ConnectionBad
       end
+      #DISCONNECT_ERROR_CLASSES.freeze # SEQUEL5
       
       disconnect_errors = [
         'could not receive data from server',
@@ -542,6 +546,7 @@ module Sequel
       def adapter_initialize
         @use_iso_date_format = typecast_value_boolean(@opts.fetch(:use_iso_date_format, Postgres.use_iso_date_format))
         initialize_postgres_adapter
+        conversion_procs[17] = TYPE_CONVERTOR.method(:bytea)
         conversion_procs[1082] = TYPE_TRANSLATOR.method(:date) if @use_iso_date_format
         self.convert_infinite_timestamps = @opts[:convert_infinite_timestamps]
       end
@@ -578,6 +583,10 @@ module Sequel
         end
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       # Execute the prepared statement with the given name on an available
       # connection, using the given args.  If the connection has not prepared
       # a statement with the given name yet, prepare it.  If the connection
@@ -671,8 +680,11 @@ module Sequel
       include Sequel::Postgres::DatasetMethods
 
       Database::DatasetClass = self
-      APOS = Sequel::Dataset::APOS
+      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
+      APOS = "'".freeze
+      Sequel::Deprecation.deprecate_constant(self, :APOS)
       DEFAULT_CURSOR_NAME = 'sequel_cursor'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :DEFAULT_CURSOR_NAME)
       
       # Yield all rows returned by executing the given SQL and converting
       # the types.
@@ -720,7 +732,7 @@ module Sequel
       #   DB[:huge_table].use_cursor(:rows_per_fetch=>1).each do |row|
       #     DB[:huge_table].where_current_of.update(:column=>ruby_method(row))
       #   end
-      def where_current_of(cursor_name=DEFAULT_CURSOR_NAME)
+      def where_current_of(cursor_name='sequel_cursor')
         clone(:where=>Sequel.lit(['CURRENT OF '], Sequel.identifier(cursor_name)))
       end
 
@@ -787,7 +799,7 @@ module Sequel
         server_opts = {:server=>@opts[:server] || :read_only}
         cursor = @opts[:cursor]
         hold = cursor[:hold]
-        cursor_name = quote_identifier(cursor[:cursor_name] || DEFAULT_CURSOR_NAME)
+        cursor_name = quote_identifier(cursor[:cursor_name] || 'sequel_cursor')
         rows_per_fetch = cursor[:rows_per_fetch].to_i
 
         db.send(*(hold ? [:synchronize, server_opts[:server]] : [:transaction, server_opts])) do 
@@ -829,18 +841,18 @@ module Sequel
         res.nfields.times do |fieldnum|
           cols << [fieldnum, procs[res.ftype(fieldnum)], output_identifier(res.fname(fieldnum))]
         end
-        self.columns = cols.map{|c| c.at(2)}
+        self.columns = cols.map{|c| c[2]}
         cols
       end
       
       # Use the driver's escape_bytea
       def literal_blob_append(sql, v)
-        sql << APOS << db.synchronize(@opts[:server]){|c| c.escape_bytea(v)} << APOS
+        sql << "'" << db.synchronize(@opts[:server]){|c| c.escape_bytea(v)} << "'"
       end
       
       # Use the driver's escape_string
       def literal_string_append(sql, v)
-        sql << APOS << db.synchronize(@opts[:server]){|c| c.escape_string(v)} << APOS
+        sql << "'" << db.synchronize(@opts[:server]){|c| c.escape_string(v)} << "'"
       end
       
       # For each row in the result set, yield a hash with column name symbol

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

@@ -85,29 +85,49 @@ module Sequel
       include EmulateOffsetWithReverseAndCount
       include UnmodifiedIdentifiers::DatasetMethods
 
+      EXTRACT_MAP = {:year=>"'yyyy'", :month=>"'m'", :day=>"'d'", :hour=>"'h'", :minute=>"'n'", :second=>"'s'"}#.freeze # SEQUEL5
+      #EXTRACT_MAP.each_value(&:freeze) # SEQUEL5
+      OPS = {:'%'=>' Mod '.freeze, :'||'=>' & '.freeze}#.freeze # SEQUEL5
+      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 # SEQUEL5
+
       DATE_FORMAT = '#%Y-%m-%d#'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :DATE_FORMAT)
       TIMESTAMP_FORMAT = '#%Y-%m-%d %H:%M:%S#'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :TIMESTAMP_FORMAT)
       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
+      Sequel::Deprecation.deprecate_constant(self, :TOP)
+      BRACKET_CLOSE =  ']'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BRACKET_CLOSE)
+      BRACKET_OPEN = '['.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BRACKET_OPEN)
+      COMMA = ', '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :COMMA)
+      PAREN_CLOSE = ')'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :PAREN_CLOSE)
+      PAREN_OPEN = '('.freeze
+      Sequel::Deprecation.deprecate_constant(self, :PAREN_OPEN)
+      INTO = " INTO ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :INTO)
+      FROM = ' FROM '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :FROM)
+      SPACE = ' '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :SPACE)
       NOT_EQUAL = ' <> '.freeze
-      OPS = {:'%'=>' Mod '.freeze, :'||'=>' & '.freeze}
+      Sequel::Deprecation.deprecate_constant(self, :NOT_EQUAL)
       BOOL_FALSE = '0'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BOOL_FALSE)
       BOOL_TRUE = '-1'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BOOL_TRUE)
       DATE_FUNCTION = 'Date()'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :DATE_FUNCTION)
       NOW_FUNCTION = 'Now()'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :NOW_FUNCTION)
       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
+      Sequel::Deprecation.deprecate_constant(self, :TIME_FUNCTION)
       DATEPART_OPEN = "datepart(".freeze
+      Sequel::Deprecation.deprecate_constant(self, :DATEPART_OPEN)
+      EMULATED_FUNCTION_MAP = {:char_length=>:len}
+      Sequel::Deprecation.deprecate_constant(self, :EMULATED_FUNCTION_MAP)
 
       # Access doesn't support CASE, but it can be emulated with nested
       # IIF function calls.
@@ -119,9 +139,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)
@@ -131,19 +151,19 @@ module Sequel
         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
+          sql << '('
+          literal_append(sql, args[0])
+          sql << ' ' << op.to_s << ' '
+          literal_append(sql, args[1])
+          sql << ')'
         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|
@@ -151,19 +171,19 @@ module Sequel
             literal_append(sql, a)
             c ||= true
           end
-          sql << PAREN_CLOSE
+          sql << ')'
         when :**
-          sql << PAREN_OPEN
+          sql << '('
           literal_append(sql, args[0])
           sql << ' ^ '
           literal_append(sql, args[1])
-          sql << PAREN_CLOSE
+          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
@@ -173,11 +193,11 @@ module Sequel
       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
@@ -233,31 +253,40 @@ 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 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
@@ -265,7 +294,7 @@ module Sequel
 
       def select_into_sql(sql)
         if i = @opts[:into]
-          sql << INTO
+          sql << " INTO "
           identifier_append(sql, i)
         end
       end
@@ -275,7 +304,7 @@ module Sequel
         if js = @opts[:join]
           js.each do |j|
             literal_append(sql, j)
-            sql << PAREN_CLOSE
+            sql << ')'
           end
         end
       end
@@ -283,14 +312,14 @@ 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
+        sql << '[' << v.to_s << ']'
       end
     end
   end

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

@@ -13,7 +13,8 @@ module Sequel
       include UnmodifiedIdentifiers::DatabaseMethods
 
       AUTOINCREMENT = 'AUTO_INCREMENT'.freeze
-      COLUMN_DEFINITION_ORDER = [:auto_increment, :default, :null, :unique, :primary_key, :references]
+      Sequel::Deprecation.deprecate_constant(self, :AUTOINCREMENT)
+      COLUMN_DEFINITION_ORDER = [:auto_increment, :default, :null, :unique, :primary_key, :references]#.freeze # SEQUEL5
 
       def database_type
         :cubrid
@@ -115,7 +116,7 @@ module Sequel
       end
 
       def auto_increment_sql
-        AUTOINCREMENT
+        'AUTO_INCREMENT'
       end
 
       # CUBRID requires auto increment before primary key
@@ -168,13 +169,16 @@ module Sequel
     module DatasetMethods
       include UnmodifiedIdentifiers::DatasetMethods
 
-      COMMA = Sequel::Dataset::COMMA
-      LIMIT = Sequel::Dataset::LIMIT
+      COMMA = ', '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :COMMA)
+      LIMIT = " LIMIT ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :LIMIT)
       BOOL_FALSE = '0'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BOOL_FALSE)
       BOOL_TRUE = '1'.freeze
-
-      # Hope you don't have more than 2**32 + offset rows in your dataset
+      Sequel::Deprecation.deprecate_constant(self, :BOOL_TRUE)
       ONLY_OFFSET = ",4294967295".freeze
+      Sequel::Deprecation.deprecate_constant(self, :ONLY_OFFSET)
 
       def supports_join_using?
         false
@@ -198,11 +202,11 @@ module Sequel
       private
 
       def literal_false
-        BOOL_FALSE
+        '0'
       end
 
       def literal_true
-        BOOL_TRUE
+        '1'
       end
      
       # CUBRID supports multiple rows in INSERT.
@@ -217,14 +221,15 @@ module Sequel
         l = @opts[:limit]
         o = @opts[:offset]
         if l || o
-          sql << LIMIT
+          sql << " LIMIT "
           if o
             literal_append(sql, o)
             if l
-              sql << COMMA
+              sql << ', '
               literal_append(sql, l)
             else
-              sql << ONLY_OFFSET
+              # Hope you don't have more than 2**32 + offset rows in your dataset
+              sql << ",4294967295"
             end
           else
             literal_append(sql, l)

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

@@ -15,8 +15,11 @@ module Sequel
 
     module DatabaseMethods
       AUTOINCREMENT = 'GENERATED ALWAYS AS IDENTITY'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :AUTOINCREMENT)
       NOT_NULL      = ' NOT NULL'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :NOT_NULL)
       NULL          = ''.freeze
+      Sequel::Deprecation.deprecate_constant(self, :NULL)
 
       # DB2 always uses :db2 as it's database type
       def database_type
@@ -134,7 +137,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)}"
@@ -172,7 +175,7 @@ module Sequel
 
       # DB2 uses an identity column for autoincrement.
       def auto_increment_sql
-        AUTOINCREMENT
+        'GENERATED ALWAYS AS IDENTITY'
       end
 
       # DB2 does not allow adding primary key constraints to NULLable columns.
@@ -283,28 +286,43 @@ module Sequel
     module DatasetMethods
       include EmulateOffsetWithRowNumber
 
-      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}
+      BITWISE_METHOD_MAP = {:& =>:BITAND, :| => :BITOR, :^ => :BITXOR, :'B~'=>:BITNOT}#.freeze # SEQUEL5
+
+      PAREN_CLOSE = ')'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :PAREN_CLOSE)
+      PAREN_OPEN = '('.freeze
+      Sequel::Deprecation.deprecate_constant(self, :PAREN_OPEN)
       BOOL_TRUE = '1'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BOOL_TRUE)
       BOOL_FALSE = '0'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BOOL_FALSE)
       CAST_STRING_OPEN = "RTRIM(CHAR(".freeze
+      Sequel::Deprecation.deprecate_constant(self, :CAST_STRING_OPEN)
       CAST_STRING_CLOSE = "))".freeze
+      Sequel::Deprecation.deprecate_constant(self, :CAST_STRING_CLOSE)
       FETCH_FIRST_ROW_ONLY = " FETCH FIRST ROW ONLY".freeze
+      Sequel::Deprecation.deprecate_constant(self, :FETCH_FIRST_ROW_ONLY)
       FETCH_FIRST = " FETCH FIRST ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :FETCH_FIRST)
       ROWS_ONLY = " ROWS ONLY".freeze
+      Sequel::Deprecation.deprecate_constant(self, :ROWS_ONLY)
       EMPTY_FROM_TABLE = ' FROM "SYSIBM"."SYSDUMMY1"'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :EMPTY_FROM_TABLE)
       HSTAR = "H*".freeze
+      Sequel::Deprecation.deprecate_constant(self, :HSTAR)
       BLOB_OPEN = "BLOB(X'".freeze
+      Sequel::Deprecation.deprecate_constant(self, :BLOB_OPEN)
       BLOB_CLOSE = "')".freeze
+      Sequel::Deprecation.deprecate_constant(self, :BLOB_CLOSE)
+      EMULATED_FUNCTION_MAP = {:char_length=>'length'.freeze}
+      Sequel::Deprecation.deprecate_constant(self, :EMULATED_FUNCTION_MAP)
 
       # 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
@@ -317,10 +335,10 @@ 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
@@ -387,7 +405,7 @@ module Sequel
       private
 
       def empty_from_sql
-        EMPTY_FROM_TABLE
+        ' FROM "SYSIBM"."SYSDUMMY1"'
       end
 
       # Emulate offset with row number by default, and also when the limit_offset
@@ -405,12 +423,12 @@ module Sequel
 
       # Use 0 for false on DB2
       def literal_false
-        BOOL_FALSE
+        '0'
       end
 
       # Use 1 for true on DB2
       def literal_true
-        BOOL_TRUE
+        '1'
       end
 
       # DB2 uses a literal hexidecimal number for blob strings
@@ -418,7 +436,7 @@ module Sequel
         if ::Sequel::DB2.use_clob_as_blob
           super
         else
-          sql << BLOB_OPEN << v.unpack(HSTAR).first << BLOB_CLOSE
+          sql << "BLOB(X'" << v.unpack("H*").first << "')"
         end
       end
 
@@ -427,6 +445,15 @@ 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
@@ -447,11 +474,11 @@ module Sequel
 
         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