sequel 4.45.0 → 4.46.0

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

@@ -67,7 +67,7 @@ module Sequel
       attr_accessor :force_standard_strings
     end
 
-    class CreateTableGenerator < Sequel::Schema::Generator
+    class CreateTableGenerator < Sequel::Schema::CreateTableGenerator
       # Add an exclusion constraint when creating the table. Elements should be
       # an array of 2 element arrays, with the first element being the column or
       # expression the exclusion constraint is applied to, and the second element
@@ -111,14 +111,17 @@ module Sequel
     module DatabaseMethods
       include UnmodifiedIdentifiers::DatabaseMethods
 
-      PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
       RE_CURRVAL_ERROR = /currval of sequence "(.*)" is not yet defined in this session|relation "(.*)" does not exist/.freeze
-      FOREIGN_KEY_LIST_ON_DELETE_MAP = {'a'.freeze=>:no_action, 'r'.freeze=>:restrict, 'c'.freeze=>:cascade, 'n'.freeze=>:set_null, 'd'.freeze=>:set_default}.freeze
+      Sequel::Deprecation.deprecate_constant(self, :RE_CURRVAL_ERROR)
       POSTGRES_DEFAULT_RE = /\A(?:B?('.*')::[^']+|\((-?\d+(?:\.\d+)?)\))\z/
+      Sequel::Deprecation.deprecate_constant(self, :POSTGRES_DEFAULT_RE)
       UNLOGGED = 'UNLOGGED '.freeze
-      ON_COMMIT = {
-        :drop => 'DROP', :delete_rows => 'DELETE ROWS', :preserve_rows => 'PRESERVE ROWS',
-      }.freeze
+      Sequel::Deprecation.deprecate_constant(self, :UNLOGGED)
+
+      PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
+      FOREIGN_KEY_LIST_ON_DELETE_MAP = {'a'=>:no_action, 'r'=>:restrict, 'c'=>:cascade, 'n'=>:set_null, 'd'=>:set_default}.freeze
+      ON_COMMIT = {:drop => 'DROP', :delete_rows => 'DELETE ROWS', :preserve_rows => 'PRESERVE ROWS'}.freeze
+      #ON_COMMIT.each_value(&:freeze) # SEQUEL5
 
       # SQL fragment for custom sequences (ones not created by serial primary key),
       # Returning the schema and literal form of the sequence name, by parsing
@@ -183,7 +186,7 @@ module Sequel
       # the conversion proc is looked up in the PG_NAMED_TYPES hash.
       def add_named_conversion_proc(name, &block)
         unless block
-          if block = PG_NAMED_TYPES[name]
+          if block = PG_NAMED__TYPES[name]
             Sequel::Deprecation.deprecate("Sequel::PG_NAMED_TYPES", "Call Database#add_named_conversion_proc directly for each database you want to support the #{name} type")
           end
         end
@@ -698,7 +701,7 @@ module Sequel
 
       # Handle PostgreSQL specific default format.
       def column_schema_normalize_default(default, type)
-        if m = POSTGRES_DEFAULT_RE.match(default)
+        if m = /\A(?:B?('.*')::[^']+|\((-?\d+(?:\.\d+)?)\))\z/.match(default)
           default = m[1] || m[2]
         end
         super(default, type)
@@ -795,11 +798,13 @@ module Sequel
       end
 
       EXCLUSION_CONSTRAINT_SQL_STATE = '23P01'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :EXCLUSION_CONSTRAINT_SQL_STATE)
       DEADLOCK_SQL_STATE = '40P01'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :DEADLOCK_SQL_STATE)
       def database_specific_error_class_from_sqlstate(sqlstate)
-        if sqlstate == EXCLUSION_CONSTRAINT_SQL_STATE
+        if sqlstate == '23P01'
           ExclusionConstraintViolation
-        elsif sqlstate == DEADLOCK_SQL_STATE
+        elsif sqlstate == '40P01'
           SerializationFailure
         else
           super
@@ -900,7 +905,7 @@ module Sequel
           raise(Error, "can't provide both :foreign and :unlogged to create_table") if options[:unlogged]
           'FOREIGN '
         elsif options[:unlogged]
-          UNLOGGED
+          'UNLOGGED '
         end
 
         "CREATE #{prefix_sql}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)}"
@@ -1014,10 +1019,10 @@ module Sequel
       def get_conversion_procs
         procs = PG_TYPES.dup
         procs[1184] = procs[1114] = method(:to_application_timestamp)
-        unless PG_NAMED_TYPES.empty?
-          Sequel::Deprecation.deprecate("Sequel::PG_NAMED_TYPES", "Call Database#add_named_conversion_proc directly for each Database instance where you want to support the following type(s): #{PG_NAMED_TYPES.keys.join(', ')}")
+        unless PG_NAMED__TYPES.empty?
+          Sequel::Deprecation.deprecate("Sequel::PG_NAMED_TYPES", "Call Database#add_named_conversion_proc directly for each Database instance where you want to support the following type(s): #{PG_NAMED__TYPES.keys.join(', ')}")
         end
-        add_named_conversion_procs(procs, PG_NAMED_TYPES)
+        add_named_conversion_procs(procs, PG_NAMED__TYPES)
         procs
       end
 
@@ -1236,43 +1241,71 @@ module Sequel
       include UnmodifiedIdentifiers::DatasetMethods
 
       ACCESS_SHARE = 'ACCESS SHARE'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :ACCESS_SHARE)
       ACCESS_EXCLUSIVE = 'ACCESS EXCLUSIVE'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :ACCESS_EXCLUSIVE)
       BOOL_FALSE = 'false'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BOOL_FALSE)
       BOOL_TRUE = 'true'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BOOL_TRUE)
       COMMA_SEPARATOR = ', '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :COMMA_SEPARATOR)
       EXCLUSIVE = 'EXCLUSIVE'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :EXCLUSIVE)
       EXPLAIN = 'EXPLAIN '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :EXPLAIN)
       EXPLAIN_ANALYZE = 'EXPLAIN ANALYZE '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :EXPLAIN_ANALYZE)
       FOR_SHARE = ' FOR SHARE'.freeze
-      NULL = LiteralString.new('NULL').freeze
+      Sequel::Deprecation.deprecate_constant(self, :FOR_SHARE)
       PG_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
+      Sequel::Deprecation.deprecate_constant(self, :PG_TIMESTAMP_FORMAT)
       QUERY_PLAN = 'QUERY PLAN'.to_sym
+      Sequel::Deprecation.deprecate_constant(self, :QUERY_PLAN)
       ROW_EXCLUSIVE = 'ROW EXCLUSIVE'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :ROW_EXCLUSIVE)
       ROW_SHARE = 'ROW SHARE'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :ROW_SHARE)
       SHARE = 'SHARE'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :SHARE)
       SHARE_ROW_EXCLUSIVE = 'SHARE ROW EXCLUSIVE'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :SHARE_ROW_EXCLUSIVE)
       SHARE_UPDATE_EXCLUSIVE = 'SHARE UPDATE EXCLUSIVE'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :SHARE_UPDATE_EXCLUSIVE)
       SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
-      SPACE = Dataset::SPACE
-      FROM = Dataset::FROM
-      APOS = Dataset::APOS
-      APOS_RE = Dataset::APOS_RE
-      DOUBLE_APOS = Dataset::DOUBLE_APOS
-      PAREN_OPEN = Dataset::PAREN_OPEN
-      PAREN_CLOSE = Dataset::PAREN_CLOSE
-      COMMA = Dataset::COMMA
-      ESCAPE = Dataset::ESCAPE
-      BACKSLASH = Dataset::BACKSLASH
-      AS = Dataset::AS
+      Sequel::Deprecation.deprecate_constant(self, :SQL_WITH_RECURSIVE)
+      SPACE = ' '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :SPACE)
+      FROM = ' FROM '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :FROM)
+      APOS = "'".freeze
+      Sequel::Deprecation.deprecate_constant(self, :APOS)
+      APOS_RE = /'/.freeze
+      Sequel::Deprecation.deprecate_constant(self, :APOS_RE)
+      DOUBLE_APOS = "''".freeze
+      Sequel::Deprecation.deprecate_constant(self, :DOUBLE_APOS)
+      PAREN_CLOSE = ')'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :PAREN_CLOSE)
+      PAREN_OPEN = '('.freeze
+      Sequel::Deprecation.deprecate_constant(self, :PAREN_OPEN)
+      COMMA = ', '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :COMMA)
+      ESCAPE = " ESCAPE ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :ESCAPE)
+      BACKSLASH = "\\".freeze
+      Sequel::Deprecation.deprecate_constant(self, :BACKSLASH)
+      AS = ' AS '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :AS)
       XOR_OP = ' # '.freeze
       CRLF = "\r\n".freeze
       BLOB_RE = /[\000-\037\047\134\177-\377]/n.freeze
       WINDOW = " WINDOW ".freeze
       SELECT_VALUES = "VALUES ".freeze
       EMPTY_STRING = ''.freeze
-      LOCK_MODES = ['ACCESS SHARE', 'ROW SHARE', 'ROW EXCLUSIVE', 'SHARE UPDATE EXCLUSIVE', 'SHARE', 'SHARE ROW EXCLUSIVE', 'EXCLUSIVE', 'ACCESS EXCLUSIVE'].each(&:freeze)
       SKIP_LOCKED = " SKIP LOCKED".freeze
 
+      NULL = LiteralString.new('NULL').freeze
+      LOCK_MODES = ['ACCESS SHARE', 'ROW SHARE', 'ROW EXCLUSIVE', 'SHARE UPDATE EXCLUSIVE', 'SHARE', 'SHARE ROW EXCLUSIVE', 'EXCLUSIVE', 'ACCESS EXCLUSIVE'].each(&:freeze)
       NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:cursor, :insert_conflict]).freeze
 
       Dataset.def_sql_method(self, :delete, [['if server_version >= 90100', %w'with delete from using where returning'], ['else', %w'delete from using where returning']])
@@ -1291,7 +1324,7 @@ module Sequel
       def complex_expression_sql_append(sql, op, args)
         case op
         when :^
-          j = XOR_OP
+          j = ' # '
           c = false
           args.each do |a|
             sql << j if c
@@ -1299,13 +1332,13 @@ module Sequel
             c ||= true
           end
         when :ILIKE, :'NOT ILIKE'
-          sql << PAREN_OPEN
-          literal_append(sql, args.at(0))
-          sql << SPACE << op.to_s << SPACE
-          literal_append(sql, args.at(1))
-          sql << ESCAPE
-          literal_append(sql, BACKSLASH)
-          sql << PAREN_CLOSE
+          sql << '('
+          literal_append(sql, args[0])
+          sql << ' ' << op.to_s << ' '
+          literal_append(sql, args[1])
+          sql << " ESCAPE "
+          literal_append(sql, "\\")
+          sql << ')'
         else
           super
         end
@@ -1331,7 +1364,7 @@ module Sequel
 
       # Return the results of an EXPLAIN query as a string
       def explain(opts=OPTS)
-        with_sql((opts[:analyze] ? EXPLAIN_ANALYZE : EXPLAIN) + select_sql).map(QUERY_PLAN).join(CRLF)
+        with_sql((opts[:analyze] ? 'EXPLAIN ANALYZE ' : 'EXPLAIN ') + select_sql).map(:'QUERY PLAN').join("\r\n")
       end
 
       # Return a cloned dataset which will use FOR SHARE to lock returned rows.
@@ -1379,7 +1412,7 @@ module Sequel
           terms = Sequel.function(query_func, lang, phrase_terms)
         end
 
-        ds = where(Sequel.lit(["(", " @@ ", ")"], cols, terms))
+        ds = where(Sequel.lit(["", " @@ ", ""], cols, terms))
 
         if opts[:phrase]
           raise Error, "can't use :phrase with either :tsvector or :tsquery arguments to full_text_search together" if opts[:tsvector] || opts[:tsquery]
@@ -1600,7 +1633,9 @@ module Sequel
         end
       end
 
-      # Return a clone of the dataset with an addition named window that can be referenced in window functions.
+      # Return a clone of the dataset with an addition named window that can be
+      # referenced in window functions. See {SQL::Window} for a list of options
+      # that can be passed in.
       def window(name, opts)
         clone(:window=>(@opts[:window]||[]) + [[name, SQL::Window.new(opts)]])
       end
@@ -1640,7 +1675,7 @@ module Sequel
 
       # Only include the primary table in the main delete clause
       def delete_from_sql(sql)
-        sql << FROM
+        sql << ' FROM '
         source_list_append(sql, @opts[:from][0..0])
       end
 
@@ -1697,7 +1732,7 @@ module Sequel
         if(from = @opts[:from][1..-1]).empty?
           raise(Error, 'Need multiple FROM tables if updating/deleting a dataset with JOINs') if @opts[:join]
         else
-          sql << SPACE << type.to_s << SPACE
+          sql << ' ' << type.to_s << ' '
           source_list_append(sql, from)
           select_join_sql(sql)
         end
@@ -1705,12 +1740,12 @@ module Sequel
 
       # Use a generic blob quoting method, hopefully overridden in one of the subadapter methods
       def literal_blob_append(sql, v)
-        sql << APOS << v.gsub(BLOB_RE){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"} << APOS
+        sql << "'" << v.gsub(/[\000-\037\047\134\177-\377]/n){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"} << "'"
       end
 
       # PostgreSQL uses FALSE for false values
       def literal_false
-        BOOL_FALSE
+        'false'
       end
       
       # PostgreSQL quotes NaN and Infinity.
@@ -1728,12 +1763,12 @@ module Sequel
 
       # Assume that SQL standard quoting is on, per Sequel's defaults
       def literal_string_append(sql, v)
-        sql << APOS << v.gsub(APOS_RE, DOUBLE_APOS) << APOS
+        sql << "'" << v.gsub("'", "''") << "'"
       end
 
       # PostgreSQL uses FALSE for false values
       def literal_true
-        BOOL_TRUE
+        'true'
       end
 
       # PostgreSQL supports multiple rows in INSERT.
@@ -1749,38 +1784,38 @@ module Sequel
       # PostgreSQL requires parentheses around compound datasets if they use
       # CTEs, and using them in other places doesn't hurt.
       def compound_dataset_sql_append(sql, ds)
-        sql << PAREN_OPEN
+        sql << '('
         super
-        sql << PAREN_CLOSE
+        sql << ')'
       end
 
       # Support FOR SHARE locking when using the :share lock style.
       # Use SKIP LOCKED if skipping locked rows.
       def select_lock_sql(sql)
         if @opts[:lock] == :share
-          sql << FOR_SHARE
+          sql << ' FOR SHARE'
         else
           super
         end
 
         if @opts[:skip_locked]
-          sql << SKIP_LOCKED
+          sql << " SKIP LOCKED"
         end
       end
 
       # Support VALUES clause instead of the SELECT clause to return rows.
       def select_values_sql(sql)
-        sql << SELECT_VALUES
+        sql << "VALUES "
         expression_list_append(sql, opts[:values])
       end
 
       # SQL fragment for named window specifications
       def select_window_sql(sql)
         if ws = @opts[:window]
-          sql << WINDOW
+          sql << " WINDOW "
           c = false
-          co = COMMA
-          as = AS
+          co = ', '
+          as = ' AS '
           ws.map do |name, window|
             sql << co if c
             literal_append(sql, name)
@@ -1793,7 +1828,7 @@ module Sequel
 
       # Use WITH RECURSIVE instead of WITH if any of the CTEs is recursive
       def select_with_sql_base
-        opts[:with].any?{|w| w[:recursive]} ? SQL_WITH_RECURSIVE : super
+        opts[:with].any?{|w| w[:recursive]} ? "WITH RECURSIVE " : super
       end
 
       # The version of the database server
@@ -1816,8 +1851,8 @@ module Sequel
 
       # Concatenate the expressions with a space in between
       def full_text_string_join(cols)
-        cols = Array(cols).map{|x| SQL::Function.new(:COALESCE, x, EMPTY_STRING)}
-        cols = cols.zip([SPACE] * cols.length).flatten
+        cols = Array(cols).map{|x| SQL::Function.new(:COALESCE, x, '')}
+        cols = cols.zip([' '] * cols.length).flatten
         cols.pop
         SQL::StringExpression.new(:'||', *cols)
       end
@@ -1829,7 +1864,7 @@ module Sequel
 
       # Only include the primary table in the main update clause
       def update_table_sql(sql)
-        sql << SPACE
+        sql << ' '
         source_list_append(sql, @opts[:from][0..0])
       end
     end

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

@@ -19,12 +19,19 @@ module Sequel
       attr_writer :convert_smallint_to_bool
 
       AUTO_INCREMENT = 'IDENTITY'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :AUTO_INCREMENT)
       SQL_BEGIN = "BEGIN TRANSACTION".freeze
+      Sequel::Deprecation.deprecate_constant(self, :SQL_BEGIN)
       SQL_COMMIT = "COMMIT TRANSACTION".freeze
+      Sequel::Deprecation.deprecate_constant(self, :SQL_COMMIT)
       SQL_ROLLBACK = "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION".freeze
+      Sequel::Deprecation.deprecate_constant(self, :SQL_ROLLBACK)
       TEMPORARY = "GLOBAL TEMPORARY ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :TEMPORARY)
       SMALLINT_RE = /smallint/i.freeze
-      DECIMAL_TYPE_RE = /numeric/io
+      Sequel::Deprecation.deprecate_constant(self, :SMALLINT_RE)
+      DECIMAL_TYPE_RE = /numeric/i
+      Sequel::Deprecation.deprecate_constant(self, :DECIMAL_TYPE_RE)
 
       # Whether to convert smallint to boolean arguments for this dataset.
       # Defaults to the SqlAnywhere module setting.
@@ -49,7 +56,7 @@ module Sequel
 
       # Convert smallint type to boolean if convert_smallint_to_bool is true
       def schema_column_type(db_type)
-        if convert_smallint_to_bool && db_type =~ SMALLINT_RE
+        if convert_smallint_to_bool && db_type =~ /smallint/i
           :boolean
         else
           super
@@ -67,9 +74,9 @@ module Sequel
           auto_increment = row.delete(:is_autoincrement)
           row[:auto_increment] = auto_increment == 1 || auto_increment == true
           row[:primary_key] = row.delete(:pkey) == 'Y'
-          row[:allow_null] = row[:nulls_allowed].is_a?(Fixnum) ? row.delete(:nulls_allowed) == 1 : row.delete(:nulls_allowed)
+          row[:allow_null] = row[:nulls_allowed].is_a?(Integer) ? row.delete(:nulls_allowed) == 1 : row.delete(:nulls_allowed)
           row[:db_type] = row.delete(:domain_name)
-          row[:type] = if row[:db_type] =~ DECIMAL_TYPE_RE and (row[:scale].is_a?(Fixnum) ? row[:scale] == 0 : !row[:scale])
+          row[:type] = if row[:db_type] =~ /numeric/i and (row[:scale].is_a?(Integer) ? row[:scale] == 0 : !row[:scale])
             :integer
           else
             schema_column_type(row[:db_type])
@@ -114,7 +121,7 @@ module Sequel
            si[:colnames].as(:columns),
            fks[:primary_tname].as(:table_name)]}.
          join(Sequel[:sys][:sysforeignkeys].as(:fks), :role => :role).
-         join(Sequel[:sys][:sysindexes].as(:si), [:iname=> Sequel[:fk][:role]], {:implicit_qualifier => :fk}).
+         join(Sequel[:sys][:sysindexes].as(:si), {:iname => Sequel[:fk][:role]}, {:implicit_qualifier => :fk}).
          where{{fks[:foreign_tname]=>im.call(table)}}.
          each do |r|
           unless r[:type].downcase == 'primary key'
@@ -152,7 +159,7 @@ module Sequel
 
       # Sybase uses the IDENTITY column for autoincrementing columns.
       def auto_increment_sql
-        AUTO_INCREMENT
+        'IDENTITY'
       end
       
       # Sybase does not allow adding primary key constraints to NULLable columns.
@@ -162,22 +169,22 @@ module Sequel
 
       # SQL fragment for marking a table as temporary
       def temporary_table_sql
-        TEMPORARY
+        "GLOBAL TEMPORARY "
       end
 
       # SQL to BEGIN a transaction.
       def begin_transaction_sql
-        SQL_BEGIN
+        "BEGIN TRANSACTION"
       end
 
       # SQL to ROLLBACK a transaction.
       def rollback_transaction_sql
-        SQL_ROLLBACK
+        "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION"
       end
 
       # SQL to COMMIT a transaction.
       def commit_transaction_sql
-        SQL_COMMIT
+        "COMMIT TRANSACTION"
       end
 
       # Sybase has both datetime and timestamp classes, most people are going
@@ -267,26 +274,47 @@ module Sequel
 
     module DatasetMethods
       BOOL_TRUE = '1'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BOOL_TRUE)
       BOOL_FALSE = '0'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BOOL_FALSE)
       WILDCARD = LiteralString.new('%').freeze
+      Sequel::Deprecation.deprecate_constant(self, :WILDCARD)
       TOP = " TOP ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :TOP)
       START_AT = " START AT ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :START_AT)
       SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :SQL_WITH_RECURSIVE)
       DATE_FUNCTION = 'today()'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :DATE_FUNCTION)
       NOW_FUNCTION = 'now()'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :NOW_FUNCTION)
       DATEPART = 'datepart'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :DATEPART)
       REGEXP = 'REGEXP'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :REGEXP)
       NOT_REGEXP = 'NOT REGEXP'.freeze
-      APOS = Dataset::APOS
-      APOS_RE = Dataset::APOS_RE
-      DOUBLE_APOS = Dataset::DOUBLE_APOS
+      Sequel::Deprecation.deprecate_constant(self, :NOT_REGEXP)
+      APOS = "'".freeze
+      Sequel::Deprecation.deprecate_constant(self, :APOS)
+      APOS_RE = /'/.freeze
+      Sequel::Deprecation.deprecate_constant(self, :APOS_RE)
+      DOUBLE_APOS = "''".freeze
+      Sequel::Deprecation.deprecate_constant(self, :DOUBLE_APOS)
       BACKSLASH_RE = /\\/.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BACKSLASH_RE)
       QUAD_BACKSLASH = "\\\\\\\\".freeze
+      Sequel::Deprecation.deprecate_constant(self, :QUAD_BACKSLASH)
       BLOB_START = "0x".freeze
+      Sequel::Deprecation.deprecate_constant(self, :BLOB_START)
       HSTAR = "H*".freeze
+      Sequel::Deprecation.deprecate_constant(self, :HSTAR)
       CROSS_APPLY = 'CROSS APPLY'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :CROSS_APPLY)
       OUTER_APPLY = 'OUTER APPLY'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :OUTER_APPLY)
       ONLY_OFFSET = " TOP 2147483647".freeze
+      Sequel::Deprecation.deprecate_constant(self, :ONLY_OFFSET)
 
       Dataset.def_sql_method(self, :insert, %w'with insert into columns values')
       Dataset.def_sql_method(self, :select, %w'with select distinct limit columns into from join where group having compounds order lock')
@@ -347,12 +375,12 @@ module Sequel
         when :<<, :>>
           complex_expression_emulate_append(sql, op, args)
         when :LIKE, :"NOT LIKE"
-          sql << Sequel::Dataset::PAREN_OPEN
-          literal_append(sql, args.at(0))
-          sql << Sequel::Dataset::SPACE << (op == :LIKE ? REGEXP : NOT_REGEXP) << Sequel::Dataset::SPACE
+          sql << '('
+          literal_append(sql, args[0])
+          sql << (op == :LIKE ? ' REGEXP ' : ' NOT REGEXP ')
           pattern = String.new
           last_c = ''
-          args.at(1).each_char do |c|
+          args[1].each_char do |c|
             if  c == '_' and not pattern.end_with?('\\') and last_c != '\\'
               pattern << '.'
             elsif c == '%' and not pattern.end_with?('\\') and last_c != '\\'
@@ -375,17 +403,17 @@ module Sequel
             end
           end
           literal_append(sql, pattern)
-          sql << Sequel::Dataset::ESCAPE
-          literal_append(sql, Sequel::Dataset::BACKSLASH)
-          sql << Sequel::Dataset::PAREN_CLOSE
+          sql << " ESCAPE "
+          literal_append(sql, "\\")
+          sql << ')'
         when :ILIKE, :"NOT ILIKE"
           super(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), args)
         when :extract
-          sql << DATEPART + Sequel::Dataset::PAREN_OPEN
-          literal_append(sql, args.at(0))
+          sql << 'datepart('
+          literal_append(sql, args[0])
           sql << ','
-          literal_append(sql, args.at(1))
-          sql << Sequel::Dataset::PAREN_CLOSE
+          literal_append(sql, args[1])
+          sql << ')'
         else
           super
         end
@@ -400,9 +428,9 @@ module Sequel
       def constant_sql_append(sql, constant)
         case constant
         when :CURRENT_DATE
-          sql << DATE_FUNCTION
+          sql << 'today()'
         when :CURRENT_TIMESTAMP, :CURRENT_TIME
-          sql << NOW_FUNCTION
+          sql << 'now()'
         else
           super
         end
@@ -417,17 +445,17 @@ module Sequel
 
       # Use 1 for true on Sybase
       def literal_true
-        BOOL_TRUE
+        '1'
       end
 
       # Use 0 for false on Sybase
       def literal_false
-        BOOL_FALSE
+        '0'
       end
 
       # SQL fragment for String.  Doubles \ and ' by default.
       def literal_string_append(sql, v)
-        sql << APOS << v.gsub(BACKSLASH_RE, QUAD_BACKSLASH).gsub(APOS_RE, DOUBLE_APOS) << APOS
+        sql << "'" << v.gsub("\\", "\\\\\\\\").gsub("'", "''") << "'"
       end
 
       # SqlAnywhere uses a preceding X for hex escaping strings
@@ -435,7 +463,7 @@ module Sequel
         if v.empty?
           literal_append(sql, "")
         else
-          sql << BLOB_START << v.unpack(HSTAR).first
+          sql << "0x" << v.unpack("H*").first
         end
       end
 
@@ -446,7 +474,7 @@ module Sequel
 
       def select_into_sql(sql)
         if i = @opts[:into]
-          sql << Sequel::Dataset::INTO
+          sql << " INTO "
           identifier_append(sql, i)
         end
       end
@@ -458,14 +486,14 @@ module Sequel
         o = @opts[:offset]
         if l || o
           if l
-            sql << TOP
+            sql << " TOP "
             literal_append(sql, l)
           else
-            sql << ONLY_OFFSET
+            sql << " TOP 2147483647"
           end
 
           if o 
-            sql << START_AT + "("
+            sql << " START AT ("
             literal_append(sql, o)
             sql << " + 1)"
           end
@@ -474,15 +502,15 @@ module Sequel
 
       # Use WITH RECURSIVE instead of WITH if any of the CTEs is recursive
       def select_with_sql_base
-        opts[:with].any?{|w| w[:recursive]} ? SQL_WITH_RECURSIVE : super
+        opts[:with].any?{|w| w[:recursive]} ? "WITH RECURSIVE " : super
       end
 
       def join_type_sql(join_type)
         case join_type
         when :cross_apply
-          CROSS_APPLY
+          'CROSS APPLY'
         when :outer_apply
-          OUTER_APPLY
+          'OUTER APPLY'
         else
           super
         end