sequel 4.36.0 → 5.61.0

data/lib/sequel/adapters/jdbc/hsqldb.rb

@@ -1,7 +1,7 @@
 # frozen-string-literal: true
 
 Sequel::JDBC.load_driver('org.hsqldb.jdbcDriver', :HSQLDB)
-Sequel.require 'adapters/jdbc/transactions'
+require_relative 'transactions'
 
 module Sequel
   module JDBC
@@ -13,20 +13,19 @@ module Sequel
       end
     end
 
-    # Database and Dataset support for HSQLDB databases accessed via JDBC.
     module HSQLDB
-      # Instance methods for HSQLDB Database objects accessed via JDBC.
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
-        PRIMARY_KEY_INDEX_RE = /\Asys_idx_sys_pk_/i.freeze
-
         include ::Sequel::JDBC::Transactions
 
-        # HSQLDB uses the :hsqldb database type.
         def database_type
           :hsqldb
         end
 
+        def freeze
+          db_version
+          super
+        end
+
         # HSQLDB uses an IDENTITY sequence as the default value for primary
         # key columns.
         def serial_primary_key_options
@@ -35,11 +34,10 @@ module Sequel
 
         # The version of the database, as an integer (e.g 2.2.5 -> 20205)
         def db_version
-          @db_version ||= begin
-            v = get{DATABASE_VERSION(){}}
-            if v =~ /(\d+)\.(\d+)\.(\d+)/
-              $1.to_i * 10000 + $2.to_i * 100 + $3.to_i
-            end
+          return @db_version if defined?(@db_version)
+          v = get(Sequel.function(:DATABASE_VERSION))
+          @db_version = if v =~ /(\d+)\.(\d+)\.(\d+)/
+            $1.to_i * 10000 + $2.to_i * 100 + $3.to_i
           end
         end
         
@@ -50,13 +48,12 @@ module Sequel
 
         private
         
-        # HSQLDB specific SQL for renaming columns, and changing column types and/or nullity.
         def alter_table_sql(table, op)
           case op[:op]
           when :add_column
             if op[:table]
               [super(table, op.merge(:table=>nil)),
-               alter_table_sql(table, op.merge(:op=>:add_constraint, :type=>:foreign_key, :name=>op[:foreign_key_name], :columns=>[op[:name]], :table=>op[:table]))]
+               alter_table_sql(table, op.merge(:op=>:add_constraint, :type=>:foreign_key, :name=>op[:foreign_key_constraint_name], :columns=>[op[:name]], :table=>op[:table]))]
             else
               super
             end
@@ -109,7 +106,7 @@ module Sequel
         
         # Primary key indexes appear to start with sys_idx_sys_pk_ on HSQLDB
         def primary_key_index_re
-          PRIMARY_KEY_INDEX_RE
+          /\Asys_idx_sys_pk_/i
         end
 
         # If an :identity option is present in the column, add the necessary IDENTITY SQL.
@@ -140,17 +137,7 @@ module Sequel
         end
       end
       
-      # Dataset class for HSQLDB datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
-        BOOL_TRUE = 'TRUE'.freeze
-        BOOL_FALSE = 'FALSE'.freeze
-        SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
-        APOS = Dataset::APOS
-        HSTAR = "H*".freeze
-        BLOB_OPEN = "X'".freeze
-        DEFAULT_FROM = " FROM (VALUES (0))".freeze
-        TIME_FORMAT = "'%H:%M:%S'".freeze
-
         # Handle HSQLDB specific case insensitive LIKE and bitwise operator support.
         def complex_expression_sql_append(sql, op, args)
           case op
@@ -192,30 +179,36 @@ module Sequel
           true
         end
 
+        # HSQLDB 2.3.4+ supports MERGE.  Older versions also support MERGE, but not all
+        # features that are in Sequel's tests.
+        def supports_merge?
+          db.db_version >= 20304
+        end
+
         private
 
         def empty_from_sql
-          DEFAULT_FROM
+          " FROM (VALUES (0))"
         end
         
         # Use string in hex format for blob data.
         def literal_blob_append(sql, v)
-          sql << BLOB_OPEN << v.unpack(HSTAR).first << APOS
+          sql << "X'" << v.unpack("H*").first << "'"
         end
 
         # HSQLDB uses FALSE for false values.
         def literal_false
-          BOOL_FALSE
+          'FALSE'
         end
 
         # HSQLDB handles fractional seconds in timestamps, but not in times
         def literal_sqltime(v)
-          v.strftime(TIME_FORMAT)
+          v.strftime("'%H:%M:%S'")
         end
 
         # HSQLDB uses TRUE for true values.
         def literal_true
-          BOOL_TRUE
+          'TRUE'
         end
 
         # HSQLDB supports multiple rows in INSERT.
@@ -225,7 +218,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
       end
     end

data/lib/sequel/adapters/jdbc/jtds.rb

@@ -1,24 +1,21 @@
 # frozen-string-literal: true
 
 Sequel::JDBC.load_driver('Java::net.sourceforge.jtds.jdbc.Driver', :JTDS)
-Sequel.require 'adapters/jdbc/mssql'
+require_relative 'mssql'
 
 module Sequel
   module JDBC
     Sequel.synchronize do
       DATABASE_SETUP[:jtds] = proc do |db|
         db.extend(Sequel::JDBC::JTDS::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::JTDS::Dataset
+        db.extend_datasets Sequel::MSSQL::DatasetMethods
         db.send(:set_mssql_unicode_strings)
         Java::net.sourceforge.jtds.jdbc.Driver
       end
     end
 
-    # Database and Dataset instance methods for JTDS specific
-    # support via JDBC.
     module JTDS
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::JDBC::MSSQL::DatabaseMethods
 
         private
@@ -37,11 +34,6 @@ module Sequel
           cps.setNull(i, cps.getParameterMetaData.getParameterType(i))
         end
       end
-
-      # Dataset class for JTDS datasets accessed via JDBC.
-      class Dataset < JDBC::Dataset
-        include Sequel::MSSQL::DatasetMethods
-      end
     end
   end
 end

data/lib/sequel/adapters/jdbc/mssql.rb

@@ -1,19 +1,11 @@
 # frozen-string-literal: true
 
-Sequel.require 'adapters/shared/mssql'
+require_relative '../shared/mssql'
 
 module Sequel
   module JDBC
-    # Database and Dataset instance methods for MSSQL specific
-    # support via JDBC.
     module MSSQL
-      # Database instance methods for MSSQL databases accessed via JDBC.
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
-        PRIMARY_KEY_INDEX_RE = /\Apk__/i.freeze
-        ATAT_IDENTITY = 'SELECT @@IDENTITY'.freeze
-        SCOPE_IDENTITY = 'SELECT SCOPE_IDENTITY()'.freeze
-        
         include Sequel::MSSQL::DatabaseMethods
         
         private
@@ -21,7 +13,7 @@ module Sequel
         # Get the last inserted id using SCOPE_IDENTITY().
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
-            sql = opts[:prepared] ? ATAT_IDENTITY : SCOPE_IDENTITY
+            sql = opts[:prepared] ? 'SELECT @@IDENTITY' : 'SELECT SCOPE_IDENTITY()'
             rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
             rs.next
             rs.getLong(1)
@@ -30,7 +22,7 @@ module Sequel
         
         # Primary key indexes appear to start with pk__ on MSSQL
         def primary_key_index_re
-          PRIMARY_KEY_INDEX_RE
+          /\Apk__/i
         end
       end
     end

data/lib/sequel/adapters/jdbc/mysql.rb

@@ -1,37 +1,24 @@
 # frozen-string-literal: true
 
-Sequel::JDBC.load_driver('com.mysql.jdbc.Driver', :MySQL)
-Sequel.require 'adapters/shared/mysql'
-
 module Sequel
   module JDBC
+    driver = Sequel::JDBC.load_driver(%w'com.mysql.cj.jdbc.Driver com.mysql.jdbc.Driver', :MySQL)
+    require_relative '../shared/mysql'
+
     Sequel.synchronize do
       DATABASE_SETUP[:mysql] = proc do |db|
         db.extend(Sequel::JDBC::MySQL::DatabaseMethods)
         db.extend_datasets Sequel::MySQL::DatasetMethods
-        com.mysql.jdbc.Driver
+        driver
       end
     end
 
-    # Database and Dataset instance methods for MySQL specific
-    # support via JDBC.
     module MySQL
-      # Database instance methods for MySQL databases accessed via JDBC.
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::MySQL::DatabaseMethods
-        LAST_INSERT_ID = 'SELECT LAST_INSERT_ID()'.freeze
         
         private
         
-        # The database name for the given database.  Need to parse it out
-        # of the connection string, since the JDBC does no parsing on the
-        # given connection string by default.
-        def database_name
-          u = URI.parse(uri.sub(/\Ajdbc:/, ''))
-          (m = /\/(.*)/.match(u.path)) && m[1]
-        end
-        
         # MySQL exception handling with SQLState is less accurate than with regexps.
         def database_exception_use_sqlstates?
           false
@@ -57,7 +44,7 @@ module Sequel
             end
           else
             statement(conn) do |st|
-              rs = st.executeQuery(LAST_INSERT_ID)
+              rs = st.executeQuery('SELECT LAST_INSERT_ID()')
               rs.next
               rs.getLong(1)
             end
@@ -67,12 +54,12 @@ module Sequel
         # MySQL 5.1.12 JDBC adapter requires generated keys
         # and previous versions don't mind.
         def execute_statement_insert(stmt, sql)
-          stmt.executeUpdate(sql, JavaSQL::Statement.RETURN_GENERATED_KEYS)
+          stmt.executeUpdate(sql, JavaSQL::Statement::RETURN_GENERATED_KEYS)
         end
 
         # Return generated keys for insert statements.
         def prepare_jdbc_statement(conn, sql, opts)
-          opts[:type] == :insert ? conn.prepareStatement(sql, JavaSQL::Statement.RETURN_GENERATED_KEYS) : super
+          opts[:type] == :insert ? conn.prepareStatement(sql, JavaSQL::Statement::RETURN_GENERATED_KEYS) : super
         end
 
         # Convert tinyint(1) type to boolean
@@ -86,6 +73,16 @@ module Sequel
           mysql_connection_setting_sqls.each{|sql| statement(conn){|s| log_connection_yield(sql, conn){s.execute(sql)}}}
           super
         end
+
+        # Handle unsigned integer values
+        def setup_type_convertor_map
+          super
+          TypeConvertor::BASIC_MAP.dup
+          @type_convertor_map[Java::JavaSQL::Types::SMALLINT] = @type_convertor_map[Java::JavaSQL::Types::INTEGER]
+          @type_convertor_map[Java::JavaSQL::Types::INTEGER] = @type_convertor_map[Java::JavaSQL::Types::BIGINT]
+          @basic_type_convertor_map[Java::JavaSQL::Types::SMALLINT] = @basic_type_convertor_map[Java::JavaSQL::Types::INTEGER]
+          @basic_type_convertor_map[Java::JavaSQL::Types::INTEGER] = @basic_type_convertor_map[Java::JavaSQL::Types::BIGINT]
+        end
       end
     end
   end

data/lib/sequel/adapters/jdbc/oracle.rb

@@ -1,8 +1,8 @@
 # frozen-string-literal: true
 
 Sequel::JDBC.load_driver('Java::oracle.jdbc.driver.OracleDriver')
-Sequel.require 'adapters/shared/oracle'
-Sequel.require 'adapters/jdbc/transactions'
+require_relative '../shared/oracle'
+require_relative 'transactions'
 
 module Sequel
   module JDBC
@@ -14,33 +14,34 @@ module Sequel
       end
     end
 
-    class TypeConvertor
+    module Oracle
       JAVA_BIG_DECIMAL_CONSTRUCTOR = java.math.BigDecimal.java_class.constructor(Java::long).method(:new_instance)
-
-      def OracleDecimal(r, i)
+      ORACLE_DECIMAL = Object.new
+      def ORACLE_DECIMAL.call(r, i)
         if v = r.getBigDecimal(i)
           i = v.long_value
           if v == JAVA_BIG_DECIMAL_CONSTRUCTOR.call(i)
             i
           else
-            BigDecimal.new(v.to_string)
+            ::Kernel::BigDecimal(v.to_string)
           end
         end
       end 
-    end
 
-    # Database and Dataset support for Oracle databases accessed via JDBC.
-    module Oracle
-      # Instance methods for Oracle Database objects accessed via JDBC.
-      module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
-        PRIMARY_KEY_INDEX_RE = /\Asys_/i.freeze
+      ORACLE_CLOB = Object.new
+      def ORACLE_CLOB.call(r, i)
+        return unless clob = r.getClob(i)
+        str = clob.getSubString(1, clob.length)
+        clob.freeTemporary if clob.isTemporary
+        str
+      end
 
+      module DatabaseMethods
         include Sequel::Oracle::DatabaseMethods
         include Sequel::JDBC::Transactions
 
         def self.extended(db)
-          db.instance_eval do
+          db.instance_exec do
             @autosequence = opts[:autosequence]
             @primary_key_sequences = {}
           end
@@ -84,7 +85,7 @@ module Sequel
 
         # Primary key indexes appear to start with sys_ on Oracle
         def primary_key_index_re
-          PRIMARY_KEY_INDEX_RE
+          /\Asys_/i
         end
 
         def schema_parse_table(*)
@@ -110,17 +111,18 @@ module Sequel
 
         def setup_type_convertor_map
           super
-          @type_convertor_map[:OracleDecimal] = TypeConvertor::INSTANCE.method(:OracleDecimal)
+          @type_convertor_map[:OracleDecimal] = ORACLE_DECIMAL
+          @type_convertor_map[:OracleClob] = ORACLE_CLOB
         end
       end
       
-      # Dataset class for Oracle datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::Oracle::DatasetMethods
 
         NUMERIC_TYPE = Java::JavaSQL::Types::NUMERIC
         TIMESTAMP_TYPE = Java::JavaSQL::Types::TIMESTAMP
-        TIMESTAMPTZ_TYPES = [Java::oracle.jdbc.OracleTypes::TIMESTAMPTZ, Java::oracle.jdbc.OracleTypes::TIMESTAMPLTZ]
+        CLOB_TYPE = Java::JavaSQL::Types::CLOB
+        TIMESTAMPTZ_TYPES = [Java::oracle.jdbc.OracleTypes::TIMESTAMPTZ, Java::oracle.jdbc.OracleTypes::TIMESTAMPLTZ].freeze
 
         def type_convertor(map, meta, type, i)
           case type
@@ -132,6 +134,8 @@ module Sequel
             end
           when *TIMESTAMPTZ_TYPES
             map[TIMESTAMP_TYPE]
+          when CLOB_TYPE 
+            map[:OracleClob]
           else
             super
           end

data/lib/sequel/adapters/jdbc/postgresql.rb

@@ -1,47 +1,20 @@
 # frozen-string-literal: true
 
 Sequel::JDBC.load_driver('org.postgresql.Driver', :Postgres)
-Sequel.require 'adapters/shared/postgres'
+require_relative '../shared/postgres'
 
 module Sequel
-  Postgres::CONVERTED_EXCEPTIONS << NativeException
-  
   module JDBC
     Sequel.synchronize do
       DATABASE_SETUP[:postgresql] = proc do |db|
-        db.extend(Sequel::JDBC::Postgres::DatabaseMethods)
         db.dataset_class = Sequel::JDBC::Postgres::Dataset
+        db.extend(Sequel::JDBC::Postgres::DatabaseMethods)
         org.postgresql.Driver
       end
     end
 
-    class TypeConvertor
-      # Return PostgreSQL array types as ruby Arrays instead of
-      # JDBC PostgreSQL driver-specific array type. Only used if the
-      # database does not have a conversion proc for the type.
-      def RubyPGArray(r, i)
-        if v = r.getArray(i)
-          v.array.to_ary
-        end
-      end 
-
-      # Return PostgreSQL hstore types as ruby Hashes instead of
-      # Java HashMaps.  Only used if the database does not have a
-      # conversion proc for the type.
-      def RubyPGHstore(r, i)
-        if v = r.getObject(i)
-          v.to_hash
-        end
-      end 
-    end
-
-    # Adapter, Database, and Dataset support for accessing a PostgreSQL
-    # database via JDBC.
     module Postgres
-      # Methods to add to Database instances that access PostgreSQL via
-      # JDBC.
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::Postgres::DatabaseMethods
 
         # Add the primary_keys and primary_key_sequences instance variables,
@@ -51,30 +24,40 @@ module Sequel
           db.send(:initialize_postgres_adapter)
         end
 
+        # Remove any current entry for the oid in the oid_convertor_map.
+        def add_conversion_proc(oid, *)
+          super
+          Sequel.synchronize{@oid_convertor_map.delete(oid)}
+        end
+
         # See Sequel::Postgres::Adapter#copy_into
         def copy_into(table, opts=OPTS)
           data = opts[:data]
           data = Array(data) if data.is_a?(String)
 
-          if block_given? && data
+          if defined?(yield) && data
             raise Error, "Cannot provide both a :data option and a block to copy_into"
-          elsif !block_given? && !data
+          elsif !defined?(yield) && !data
             raise Error, "Must provide either a :data option or a block to copy_into"
           end
 
-          synchronize(opts) do |conn|
+          synchronize(opts[:server]) do |conn|
             begin
               copy_manager = org.postgresql.copy.CopyManager.new(conn)
               copier = copy_manager.copy_in(copy_into_sql(table, opts))
-              if block_given?
+              if defined?(yield)
                 while buf = yield
-                  copier.writeToCopy(buf.to_java_bytes, 0, buf.length)
+                  java_bytes = buf.to_java_bytes
+                  copier.writeToCopy(java_bytes, 0, java_bytes.length)
                 end
               else
-                data.each { |d| copier.writeToCopy(d.to_java_bytes, 0, d.length) }
+                data.each do |d|
+                  java_bytes = d.to_java_bytes
+                  copier.writeToCopy(java_bytes, 0, java_bytes.length)
+                end
               end
             rescue Exception => e
-              copier.cancelCopy
+              copier.cancelCopy if copier
               raise
             ensure
               unless e
@@ -94,7 +77,7 @@ module Sequel
             copy_manager = org.postgresql.copy.CopyManager.new(conn)
             copier = copy_manager.copy_out(copy_table_sql(table, opts))
             begin
-              if block_given?
+              if defined?(yield)
                 while buf = copier.readFromCopy
                   yield(String.from_java_bytes(buf))
                 end
@@ -106,8 +89,12 @@ module Sequel
                 end
                 b
               end
+            rescue => e
+              raise_error(e, :disconnect=>true)
             ensure
-              raise DatabaseDisconnectError, "disconnecting as a partial COPY may leave the connection in an unusable state" if buf
+              if buf && !e
+                raise DatabaseDisconnectError, "disconnecting as a partial COPY may leave the connection in an unusable state"
+              end
             end
           end
         end
@@ -123,19 +110,13 @@ module Sequel
             else
               false
             end
-             Sequel.synchronize{@oid_convertor_map[oid] = conv}
+            Sequel.synchronize{@oid_convertor_map[oid] = conv}
           end
           conv
         end
 
         private
         
-        # Clear oid convertor map cache when conversion procs are updated.
-        def conversion_procs_updated
-          super
-          Sequel.synchronize{@oid_convertor_map = {}}
-        end
-
         def disconnect_error?(exception, opts)
           super || exception.message =~ /\A(This connection has been closed\.|FATAL: terminating connection due to administrator command|An I\/O error occurred while sending to the backend\.)\z/
         end
@@ -147,6 +128,21 @@ module Sequel
           nil
         end
 
+        # Work around issue when using Sequel's bound variable support where the
+        # same SQL is used in different bound variable calls, but the schema has
+        # changed between the calls.  This is necessary as jdbc-postgres versions
+        # after 9.4.1200 violate the JDBC API.  These versions cache separate
+        # PreparedStatement instances, which are eventually prepared server side after the
+        # prepareThreshold is met.  The JDBC API violation is that PreparedStatement#close
+        # does not release the server side prepared statement.
+        def prepare_jdbc_statement(conn, sql, opts)
+          ps = super
+          unless opts[:name]
+            ps.prepare_threshold = 0
+          end
+          ps
+        end
+
         # If the given argument is a recognized PostgreSQL-specific type, create
         # a PGObject instance with unknown type and the bound argument string value,
         # and set that as the prepared statement argument.
@@ -168,10 +164,10 @@ module Sequel
         end
 
         # Execute the connection configuration SQL queries on the connection.
-        def setup_connection(conn)
-          conn = super(conn)
+        def setup_connection_with_opts(conn, opts)
+          conn = super
           statement(conn) do |stmt|
-            connection_configuration_sqls.each{|sql| log_connection_yield(sql, conn){stmt.execute(sql)}}
+            connection_configuration_sqls(opts).each{|sql| log_connection_yield(sql, conn){stmt.execute(sql)}}
           end
           conn
         end
@@ -179,39 +175,43 @@ module Sequel
         def setup_type_convertor_map
           super
           @oid_convertor_map = {}
-          @type_convertor_map[:RubyPGArray] = TypeConvertor::INSTANCE.method(:RubyPGArray)
-          @type_convertor_map[:RubyPGHstore] = TypeConvertor::INSTANCE.method(:RubyPGHstore)
         end
       end
       
-      # Dataset subclass used for datasets that connect to PostgreSQL via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::Postgres::DatasetMethods
-        APOS = Dataset::APOS
-        
-        # Add the shared PostgreSQL prepared statement methods
-        def prepare(type, name=nil, *values)
-          ps = to_prepared_statement(type, values)
-          ps.extend(JDBC::Dataset::PreparedStatementMethods)
-          ps.extend(::Sequel::Postgres::DatasetMethods::PreparedStatementMethods)
-          if name
-            ps.prepared_statement_name = name
-            db.set_prepared_statement(name, ps)
-          end
-          ps
-        end
 
+        # Warn when calling as the fetch size is ignored by the JDBC adapter currently.
+        def with_fetch_size(size)
+          warn("Sequel::JDBC::Postgres::Dataset#with_fetch_size does not currently have an effect.", :uplevel=>1)
+          super
+        end
+        
         private
         
         # Literalize strings similar to the native postgres adapter
         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
+
+        # SQL fragment for Sequel::SQLTime, containing just the time part
+        def literal_sqltime(v)
+          v.strftime("'%H:%M:%S#{sprintf(".%03d", (v.usec/1000.0).round)}'")
         end
 
         STRING_TYPE = Java::JavaSQL::Types::VARCHAR
         ARRAY_TYPE = Java::JavaSQL::Types::ARRAY
-        PG_SPECIFIC_TYPES = [ARRAY_TYPE, Java::JavaSQL::Types::OTHER, Java::JavaSQL::Types::STRUCT]
-        HSTORE_TYPE = 'hstore'.freeze
+        PG_SPECIFIC_TYPES = [Java::JavaSQL::Types::ARRAY, Java::JavaSQL::Types::OTHER, Java::JavaSQL::Types::STRUCT, Java::JavaSQL::Types::TIME_WITH_TIMEZONE, Java::JavaSQL::Types::TIME].freeze
+
+        # Return PostgreSQL hstore types as ruby Hashes instead of
+        # Java HashMaps.  Only used if the database does not have a
+        # conversion proc for the type.
+        HSTORE_METHOD = Object.new
+        def HSTORE_METHOD.call(r, i)
+          if v = r.getObject(i)
+            v.to_hash
+          end
+        end 
 
         def type_convertor(map, meta, type, i)
           case type
@@ -219,12 +219,10 @@ module Sequel
             oid = meta.getField(i).getOID
             if pr = db.oid_convertor_proc(oid)
               pr
-            elsif type == ARRAY_TYPE
-              map[:RubyPGArray]
             elsif oid == 2950 # UUID
               map[STRING_TYPE]
-            elsif meta.getPGType(i) == HSTORE_TYPE
-              map[:RubyPGHstore]
+            elsif meta.getPGType(i) == 'hstore'
+              HSTORE_METHOD
             else
               super
             end