sequel 4.46.0 → 4.49.0

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

@@ -1,25 +1,17 @@
 # frozen-string-literal: true
 
-Sequel.require %w'pg_types unmodified_identifiers', 'adapters/utils'
+Sequel.require %w'adapters/utils/unmodified_identifiers'
 
 module Sequel
   # Top level module for holding all PostgreSQL-related modules and classes
-  # for Sequel.  There are a few module level accessors that are added via
-  # metaprogramming.  These are:
-  #
-  # client_min_messages :: Change the minimum level of messages that PostgreSQL will send to the
-  #                        the client.  The PostgreSQL default is NOTICE, the Sequel default is
-  #                        WARNING.  Set to nil to not change the server default. Overridable on
-  #                        a per instance basis via the :client_min_messages option.
-  # force_standard_strings :: Set to false to not force the use of standard strings.  Overridable
-  #                           on a per instance basis via the :force_standard_strings option.
-  #
-  # It is not recommened you use these module-level accessors.  Instead,
-  # use the database option to make the setting per-Database.
-  #
-  # All adapters that connect to PostgreSQL support the following option in
-  # addition to those mentioned above:
+  # for Sequel.  All adapters that connect to PostgreSQL support the following options:
   #
+  # :client_min_messages :: Change the minimum level of messages that PostgreSQL will send to the
+  #                         the client.  The PostgreSQL default is NOTICE, the Sequel default is
+  #                         WARNING.  Set to nil to not change the server default. Overridable on
+  #                         a per instance basis via the :client_min_messages option.
+  # :force_standard_strings :: Set to false to not force the use of standard strings.  Overridable
+  #                            on a per instance basis via the :force_standard_strings option.
   # :search_path :: Set the schema search_path for this Database's connections.
   #                 Allows to to set which schemas do not need explicit
   #                 qualification, and in which order to check the schemas when
@@ -27,6 +19,88 @@ module Sequel
   module Postgres
     Sequel::Database.set_shared_adapter_scheme(:postgres, self)
 
+    NAN             = 0.0/0.0
+    PLUS_INFINITY   = 1.0/0.0
+    MINUS_INFINITY  = -1.0/0.0
+
+    NAN_STR             = 'NaN'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :NAN_STR)
+    PLUS_INFINITY_STR   = 'Infinity'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :PLUS_INFINITY_STR)
+    MINUS_INFINITY_STR  = '-Infinity'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :MINUS_INFINITY_STR)
+    TRUE_STR = 't'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :TRUE_STR)
+    DASH_STR = '-'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :DASH_STR)
+    
+    TYPE_TRANSLATOR = tt = Class.new do
+      def boolean(s) s == 't' end
+      def integer(s) s.to_i end
+      def float(s) 
+        case s
+        when 'NaN'
+          NAN
+        when 'Infinity'
+          PLUS_INFINITY
+        when '-Infinity'
+          MINUS_INFINITY
+        else
+          s.to_f 
+        end
+      end
+      def date(s) ::Date.new(*s.split('-').map(&:to_i)) end
+      def bytea(str)
+        str = if str =~ /\A\\x/
+          # PostgreSQL 9.0+ bytea hex format
+          str[2..-1].gsub(/(..)/){|s| s.to_i(16).chr}
+        else
+          # Historical PostgreSQL bytea escape format
+          str.gsub(/\\(\\|'|[0-3][0-7][0-7])/) {|s|
+            if s.size == 2 then s[1,1] else s[1,3].oct.chr end
+          }
+        end
+        ::Sequel::SQL::Blob.new(str)
+      end
+    end.new#.freeze # SEQUEL5
+
+    # Type OIDs for string types used by PostgreSQL.  These types don't
+    # have conversion procs associated with them (since the data is
+    # already in the form of a string).
+    STRING_TYPES = [18, 19, 25, 1042, 1043] # SEQUEL5: Remove
+
+    # Hash with type name strings/symbols and callable values for converting PostgreSQL types.
+    # Non-builtin types that don't have fixed numbers should use this to register
+    # conversion procs.
+    PG_NAMED_TYPES = {} unless defined?(PG_NAMED_TYPES)
+    PG_NAMED__TYPES = PG_NAMED_TYPES
+    Sequel::Deprecation.deprecate_constant(self, :PG_NAMED_TYPES)
+
+    # Hash with integer keys and callable values for converting PostgreSQL types.
+    PG_TYPES = {} unless defined?(PG_TYPES)
+
+    #CONVERSION_PROCS = {} # SEQUEL5
+
+    {
+      [16] => tt.method(:boolean),
+      [17] => tt.method(:bytea),
+      [20, 21, 23, 26] => tt.method(:integer),
+      [700, 701] => tt.method(:float),
+      [1700] => ::BigDecimal.method(:new),
+      [1083, 1266] => ::Sequel.method(:string_to_time),
+      [1082] => ::Sequel.method(:string_to_date),
+      [1184, 1114] => ::Sequel.method(:database_to_application_timestamp),
+    }.each do |k,v|
+      k.each do |n|
+        PG_TYPES[n] = v
+        #CONVERSION_PROCS[n] = v # SEQUEL5
+      end
+    end
+    PG__TYPES = PG_TYPES
+    Sequel::Deprecation.deprecate_constant(self, :PG_TYPES)
+
+    #CONVERSION_PROCS.freeze # SEQUEL5
+
     module MockAdapterDatabaseMethods
       def bound_variable_arg(arg, conn)
         arg
@@ -45,26 +119,30 @@ module Sequel
       end
     end
 
-    # Array of exceptions that need to be converted.  JDBC
-    # uses NativeExceptions, the native adapter uses PGError.
     CONVERTED_EXCEPTIONS = []
+    Sequel::Deprecation.deprecate_constant(self, :CONVERTED_EXCEPTIONS)
 
+    # SEQUEL5: Remove
     @client_min_messages = :warning
     @force_standard_strings = true
-
     class << self
-      # By default, Sequel sets the minimum level of log messages sent to the client
-      # to WARNING, where PostgreSQL uses a default of NOTICE.  This is to avoid a lot
-      # of mostly useless messages when running migrations, such as a couple of lines
-      # for every serial primary key field.
-      attr_accessor :client_min_messages
-
-      # By default, Sequel forces the use of standard strings, so that
-      # '\\' is interpreted as \\ and not \.  While PostgreSQL <9.1 defaults
-      # to interpreting plain strings, newer versions use standard strings by
-      # default.  Sequel assumes that SQL standard strings will be used.  Setting
-      # this to false means Sequel will use the database's default.
-      attr_accessor :force_standard_strings
+      def client_min_messages
+        Sequel::Deprecation.deprecate("Sequel::Postgres.client_min_messages", "Use the :client_min_messages Database option instead")
+        @client_min_messages
+      end
+      def client_min_messages=(v)
+        Sequel::Deprecation.deprecate("Sequel::Postgres.client_min_messages=", "Use the :client_min_messages Database option instead")
+        @client_min_messages = v
+      end
+
+      def force_standard_strings
+        Sequel::Deprecation.deprecate("Sequel::Postgres.force_standard_strings", "Use the :force_standard_strings Database option instead")
+        @force_standard_strings
+      end
+      def force_standard_strings=(v)
+        Sequel::Deprecation.deprecate("Sequel::Postgres.force_standard_strings=", "Use the :force_standard_strings Database option instead")
+        @force_standard_strings = v
+      end
     end
 
     class CreateTableGenerator < Sequel::Schema::CreateTableGenerator
@@ -179,6 +257,12 @@ module Sequel
       # having callable values for the conversion proc for that type.
       attr_reader :conversion_procs
 
+      # Set a conversion proc for the given oid.  The callable can
+      # be passed either as a argument or a block.
+      def add_conversion_proc(oid, callable=Proc.new)
+        conversion_procs[oid] = callable
+      end
+
       # Add a conversion proc for a named type.  This should be used 
       # for types without fixed OIDs, which includes all types that
       # are not included in a default PostgreSQL installation.  If 
@@ -190,7 +274,12 @@ module Sequel
             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
-        add_named_conversion_procs(conversion_procs, name=>block)
+        add_named_conversion_procs(conversion_procs, name=>block) # SEQUEL5: Remove
+        # SEQUEL5:
+        #unless oid = from(:pg_type).where(:typtype=>['b', 'e'], :typname=>name.to_s).get(:oid)
+        #  raise Error, "No matching type in pg_type for #{name.inspect}"
+        #end
+        #add_conversion_proc(oid, block) # SEQUEL5
       end
 
       # Commit an existing prepared transaction with the given transaction
@@ -316,68 +405,67 @@ module Sequel
       def foreign_key_list(table, opts=OPTS)
         m = output_identifier_meth
         schema, _ = opts.fetch(:schema, schema_and_table(table))
-        range = 0...32
         oid = regclass_oid(table)
 
-        base_ds = metadata_dataset.
+        if server_version >= 90500
+          cpos = Sequel.expr{array_position(co[:conkey], att[:attnum])}
+          rpos = Sequel.expr{array_position(co[:confkey], att2[:attnum])}
+        else
+          range = 0...32
+          cpos = Sequel.expr{SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:conkey], [x]), x]}, 32, att[:attnum])}
+          rpos = Sequel.expr{SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:confkey], [x]), x]}, 32, att2[:attnum])}
+        end
+
+        ds = metadata_dataset.
           from{pg_constraint.as(:co)}.
           join(Sequel[:pg_class].as(:cl), :oid=>:conrelid).
+          join(Sequel[:pg_attribute].as(:att), :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
+          join(Sequel[:pg_class].as(:cl2), :oid=>Sequel[:co][:confrelid]).
+          join(Sequel[:pg_attribute].as(:att2), :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:confkey])).
+          order{[co[:conname], cpos]}.
           where{{
             cl[:relkind]=>'r',
             co[:contype]=>'f',
-            cl[:oid]=>oid}}
-
-        # We split the parsing into two separate queries, which are merged manually later.
-        # This is because PostgreSQL stores both the referencing and referenced columns in
-        # arrays, and I don't know a simple way to not create a cross product, as PostgreSQL
-        # doesn't appear to have a function that takes an array and element and gives you
-        # the index of that element in the array.
-
-        ds = base_ds.
-          join(Sequel[:pg_attribute].as(:att), :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
-          order{[
-            co[:conname],
-            SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:conkey], [x]), x]}, 32, att[:attnum])]}.
+            cl[:oid]=>oid,
+            cpos=>rpos
+            }}.
           select{[
             co[:conname].as(:name),
             att[:attname].as(:column),
             co[:confupdtype].as(:on_update),
             co[:confdeltype].as(:on_delete),
-            SQL::BooleanExpression.new(:AND, co[:condeferrable], co[:condeferred]).as(:deferrable)]}
-
-        ref_ds = base_ds.
-          join(Sequel[:pg_class].as(:cl2), :oid=>Sequel[:co][:confrelid]).
-          join(Sequel[:pg_attribute].as(:att2), :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:confkey])).
-          order{[
-            co[:conname],
-            SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:confkey], [x]), x]}, 32, att2[:attnum])]}.
-          select{[
-            co[:conname].as(:name),
             cl2[:relname].as(:table),
-            att2[:attname].as(:refcolumn)]}
+            att2[:attname].as(:refcolumn),
+            SQL::BooleanExpression.new(:AND, co[:condeferrable], co[:condeferred]).as(:deferrable)
+          ]}
 
         # If a schema is given, we only search in that schema, and the returned :table
         # entry is schema qualified as well.
         if schema
-          ref_ds = ref_ds.join(Sequel[:pg_namespace].as(:nsp2), :oid=>Sequel[:cl2][:relnamespace]).
+          ds = ds.join(Sequel[:pg_namespace].as(:nsp2), :oid=>Sequel[:cl2][:relnamespace]).
             select_append{nsp2[:nspname].as(:schema)}
         end
 
         h = {}
         fklod_map = FOREIGN_KEY_LIST_ON_DELETE_MAP 
+
         ds.each do |row|
           if r = h[row[:name]]
             r[:columns] << m.call(row[:column])
+            r[:key] << m.call(row[:refcolumn])
           else
-            h[row[:name]] = {:name=>m.call(row[:name]), :columns=>[m.call(row[:column])], :on_update=>fklod_map[row[:on_update]], :on_delete=>fklod_map[row[:on_delete]], :deferrable=>row[:deferrable]}
+            h[row[:name]] = {
+              :name=>m.call(row[:name]),
+              :columns=>[m.call(row[:column])],
+              :key=>[m.call(row[:refcolumn])],
+              :on_update=>fklod_map[row[:on_update]],
+              :on_delete=>fklod_map[row[:on_delete]],
+              :deferrable=>row[:deferrable],
+              :table=>schema ? SQL::QualifiedIdentifier.new(m.call(row[:schema]), m.call(row[:table])) : m.call(row[:table])
+            }
           end
         end
-        ref_ds.each do |row|
-          r = h[row[:name]]
-          r[:table] ||= schema ? SQL::QualifiedIdentifier.new(m.call(row[:schema]), m.call(row[:table])) : m.call(row[:table])
-          r[:key] ||= []
-          r[:key] << m.call(row[:refcolumn])
-        end
+
         h.values
       end
 
@@ -391,9 +479,18 @@ module Sequel
       # Use the pg_* system tables to determine indexes on a table
       def indexes(table, opts=OPTS)
         m = output_identifier_meth
-        range = 0...32
-        attnums = server_version >= 80100 ? SQL::Function.new(:ANY, Sequel[:ind][:indkey]) : range.map{|x| SQL::Subscript.new(Sequel[:ind][:indkey], [x])}
         oid = regclass_oid(table, opts)
+
+        if server_version >= 90500
+          order = [Sequel[:indc][:relname], Sequel.function(:array_position, Sequel[:ind][:indkey], Sequel[:att][:attnum])]
+        else
+          range = 0...32
+          order = [Sequel[:indc][:relname], SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(Sequel[:ind][:indkey], [x]), x]}, 32, Sequel[:att][:attnum])]
+          attnums = range.map{|x| SQL::Subscript.new(Sequel[:ind][:indkey], [x])} unless server_version >= 80100 
+        end
+
+        attnums ||= SQL::Function.new(:ANY, Sequel[:ind][:indkey])
+
         ds = metadata_dataset.
           from{pg_class.as(:tab)}.
           join(Sequel[:pg_index].as(:ind), :indrelid=>:oid).
@@ -407,7 +504,7 @@ module Sequel
             :indpred=>nil,
             :indisvalid=>true,
             tab[:oid]=>oid}}.
-          order{[indc[:relname], SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(ind[:indkey], [x]), x]}, 32, att[:attnum])]}.
+          order(*order).
           select{[indc[:relname].as(:name), ind[:indisunique].as(:unique), att[:attname].as(:column), con[:condeferrable].as(:deferrable)]}
 
         ds = ds.where(:indisready=>true, :indcheckxmin=>false) if server_version >= 80300
@@ -478,9 +575,9 @@ module Sequel
         run "REFRESH MATERIALIZED VIEW#{' CONCURRENTLY' if opts[:concurrently]} #{quote_schema_table(name)}"
       end
       
-      # Reset the database's conversion procs, requires a server query if there
-      # any named types.
+      # SEQUEL5: Remove
       def reset_conversion_procs
+        Sequel::Deprecation.deprecate('Database#reset_conversion_procs', 'There should no longer be a need to reset conversion procs')
         @conversion_procs = get_conversion_procs
         conversion_procs_updated
         @conversion_procs
@@ -614,18 +711,19 @@ module Sequel
       # Array of symbols specifying view names in the current database.
       #
       # Options:
+      # :materialized :: Return materialized views
       # :qualify :: Return the views as Sequel::SQL::QualifiedIdentifier instances,
       #             using the schema the view is located in as the qualifier.
       # :schema :: The schema to search
       # :server :: The server to use
       def views(opts=OPTS)
-        pg_class_relname('v', opts)
+        relkind = opts[:materialized] ? 'm' : 'v'
+        pg_class_relname(relkind, opts)
       end
 
       private
 
-      # Do a type name-to-oid lookup using the database and update the procs
-      # with the related proc if the database supports the type.
+      # SEQUEL5: Remove
       def add_named_conversion_procs(procs, named_procs)
         unless (named_procs).empty?
           convert_named_procs_to_procs(named_procs).each do |oid, pr|
@@ -728,9 +826,10 @@ module Sequel
       def connection_configuration_sqls
         sqls = []
 
-        sqls << "SET standard_conforming_strings = ON" if typecast_value_boolean(@opts.fetch(:force_standard_strings, Postgres.force_standard_strings))
+        sqls << "SET standard_conforming_strings = ON" if typecast_value_boolean(@opts.fetch(:force_standard_strings, Postgres.instance_variable_get(:@force_standard_strings))) # , true)) # SEQUEL5
 
-        if (cmm = @opts.fetch(:client_min_messages, Postgres.client_min_messages)) && !cmm.to_s.empty?
+        cmm = @opts.fetch(:client_min_messages, Postgres.instance_variable_get(:@client_min_messages)) # , :warning) # SEQUEL5
+        if cmm && !cmm.to_s.empty?
           cmm = cmm.to_s.upcase.strip
           unless VALID_CLIENT_MIN_MESSAGES.include?(cmm)
             raise Error, "Unsupported client_min_messages setting: #{cmm}"
@@ -773,12 +872,12 @@ module Sequel
         end
       end
 
-      # Callback used when conversion procs are updated.
+      # SEQUEL5: Remove
       def conversion_procs_updated
         nil
       end
 
-      # Convert the hash of named conversion procs into a hash a oid conversion procs. 
+      # SEQUEL5: Remove
       def convert_named_procs_to_procs(named_procs)
         h = {}
         from(:pg_type).where(:typtype=>['b', 'e'], :typname=>named_procs.keys.map(&:to_s)).select_map([:oid, :typname]).each do |oid, name|
@@ -787,12 +886,12 @@ module Sequel
         h
       end
 
-      # Copy the conversion procs related to the given oids from PG_TYPES into
-      # the conversion procs for this instance.
+      # SEQUEL5: Remove
       def copy_conversion_procs(oids)
+        Sequel::Deprecation.deprecate("Database#copy_conversion_procs", "There is no reason to use this anymore")
         procs = conversion_procs
         oids.each do |oid|
-          procs[oid] = PG_TYPES[oid]
+          procs[oid] = PG__TYPES[oid]
         end
         conversion_procs_updated
       end
@@ -963,11 +1062,6 @@ module Sequel
         create_view_sql_append_columns("CREATE #{'OR REPLACE 'if options[:replace]}#{'TEMPORARY 'if options[:temp]}#{'RECURSIVE ' if options[:recursive]}#{'MATERIALIZED ' if options[:materialized]}VIEW #{quote_schema_table(name)}", options[:columns] || options[:recursive])
       end
 
-      # The errors that the main adapters can raise, depends on the adapter being used
-      def database_error_classes
-        CONVERTED_EXCEPTIONS
-      end
-
       # SQL for dropping a function from the database.
       def drop_function_sql(name, opts=OPTS)
         "DROP FUNCTION#{' IF EXISTS' if opts[:if_exists]} #{name}#{sql_function_args(opts[:args])}#{' CASCADE' if opts[:cascade]}"
@@ -1015,9 +1109,9 @@ module Sequel
         ds.where{{pg_namespace[:nspname]=>expr}}
       end
 
-      # Return a hash with oid keys and callable values, used for converting types.
+      # SEQUEL5: Remove
       def get_conversion_procs
-        procs = PG_TYPES.dup
+        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(', ')}")
@@ -1054,8 +1148,10 @@ module Sequel
         @primary_keys = {}
         @primary_key_sequences = {}
         @supported_types = {}
-        @conversion_procs = PG_TYPES.dup
-        reset_conversion_procs
+        @conversion_procs = get_conversion_procs # SEQUEL5: Remove
+        conversion_procs_updated # SEQUEL5: Remove
+        # @conversion_procs = CONVERSION_PROCS.dup # SEQUEL5
+        # procs[1184] = procs[1114] = method(:to_application_timestamp) # SEQUEL5
       end
 
       # Backbone of the tables and views support.
@@ -1297,16 +1393,24 @@ module Sequel
       AS = ' AS '.freeze
       Sequel::Deprecation.deprecate_constant(self, :AS)
       XOR_OP = ' # '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :XOR_OP)
       CRLF = "\r\n".freeze
+      Sequel::Deprecation.deprecate_constant(self, :CRLF)
       BLOB_RE = /[\000-\037\047\134\177-\377]/n.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BLOB_RE)
       WINDOW = " WINDOW ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :WINDOW)
       SELECT_VALUES = "VALUES ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :SELECT_VALUES)
       EMPTY_STRING = ''.freeze
+      Sequel::Deprecation.deprecate_constant(self, :EMPTY_STRING)
       SKIP_LOCKED = " SKIP LOCKED".freeze
+      Sequel::Deprecation.deprecate_constant(self, :SKIP_LOCKED)
+      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:cursor, :insert_conflict]).freeze
+      Sequel::Deprecation.deprecate_constant(self, :NON_SQL_OPTIONS)
 
       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
+      LOCK_MODES = ['ACCESS SHARE', 'ROW SHARE', 'ROW EXCLUSIVE', 'SHARE UPDATE EXCLUSIVE', 'SHARE', 'SHARE ROW EXCLUSIVE', 'EXCLUSIVE', 'ACCESS EXCLUSIVE'].each(&:freeze)#.freeze # SEQUEL5
 
       Dataset.def_sql_method(self, :delete, [['if server_version >= 90100', %w'with delete from using where returning'], ['else', %w'delete from using where returning']])
       Dataset.def_sql_method(self, :insert, [['if server_version >= 90500', %w'with insert into columns values conflict returning'], ['elsif server_version >= 90100', %w'with insert into columns values returning'], ['else', %w'insert into columns values returning']])
@@ -1766,7 +1870,7 @@ module Sequel
         sql << "'" << v.gsub("'", "''") << "'"
       end
 
-      # PostgreSQL uses FALSE for false values
+      # PostgreSQL uses true for true values
       def literal_true
         'true'
       end
@@ -1777,8 +1881,8 @@ module Sequel
       end
 
       # Dataset options that do not affect the generated SQL.
-      def non_sql_options
-        NON_SQL_OPTIONS
+      def non_sql_option?(key)
+        super || key == :cursor || key == :insert_conflict
       end
 
       # PostgreSQL requires parentheses around compound datasets if they use

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

@@ -4,12 +4,17 @@ module Sequel
   module SqlAnywhere
     Sequel::Database.set_shared_adapter_scheme(:sqlanywhere, self)
 
+    # SEQUEL5: Remove
     @convert_smallint_to_bool = true
-
     class << self
-      # Whether to convert smallint values to bool, false by default.
-      # Can also be overridden per dataset.
-      attr_accessor :convert_smallint_to_bool
+      def convert_smallint_to_bool
+        Sequel::Deprecation.deprecate("Sequel::SqlAnywhere.convert_smallint_to_bool", "Call this method on the Database instance")
+        @convert_smallint_to_bool
+      end
+      def convert_smallint_to_bool=(v)
+        Sequel::Deprecation.deprecate("Sequel::SqlAnywhere.convert_smallint_to_bool=", "Call this method on the Database instance")
+        @convert_smallint_to_bool = v
+      end
     end
 
     module DatabaseMethods
@@ -36,7 +41,7 @@ module Sequel
       # Whether to convert smallint to boolean arguments for this dataset.
       # Defaults to the SqlAnywhere module setting.
       def convert_smallint_to_bool
-        defined?(@convert_smallint_to_bool) ? @convert_smallint_to_bool : (@convert_smallint_to_bool = ::Sequel::SqlAnywhere.convert_smallint_to_bool)
+        defined?(@convert_smallint_to_bool) ? @convert_smallint_to_bool : (@convert_smallint_to_bool = ::Sequel::SqlAnywhere.instance_variable_get(:@convert_smallint_to_bool)) # true) # SEQUEL5
       end
 
       # Sysbase Server uses the :sqlanywhere type.
@@ -319,14 +324,22 @@ module Sequel
       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')
 
+      # Override the default IBMDB.convert_smallint_to_bool setting for this dataset.
+      def convert_smallint_to_bool=(v)
+        Sequel::Deprecation.deprecate("Sequel::SqlAnywhere::Dataset#convert_smallint_to_bool=", "Call with_convert_smallint_to_bool instead, which returns a modified copy instead of modifying the object")
+        @opts[:convert_smallint_to_bool] = v
+      end
+
       # Whether to convert smallint to boolean arguments for this dataset.
-      # Defaults to the SqlAnywhere module setting.
+      # Defaults to the IBMDB module setting.
       def convert_smallint_to_bool
-        defined?(@convert_smallint_to_bool) ? @convert_smallint_to_bool : (@convert_smallint_to_bool = @db.convert_smallint_to_bool)
+        opts.has_key?(:convert_smallint_to_bool) ? opts[:convert_smallint_to_bool] : db.convert_smallint_to_bool
       end
 
-      # Override the default SqlAnywhere.convert_smallint_to_bool setting for this dataset.
-      attr_writer :convert_smallint_to_bool
+      # Return a cloned dataset with the convert_smallint_to_bool option set.
+      def with_convert_smallint_to_bool(v)
+        clone(:convert_smallint_to_bool=>v)
+      end
 
       def supports_cte?(type=:select)
         type == :select || type == :insert
@@ -424,7 +437,7 @@ module Sequel
         string.gsub(/[\\%_\[]/){|m| "\\#{m}"}
       end
 
-      # Use Date() and Now() for CURRENT_DATE and CURRENT_TIMESTAMP
+      # Use today() and Now() for CURRENT_DATE and CURRENT_TIMESTAMP
       def constant_sql_append(sql, constant)
         case constant
         when :CURRENT_DATE