[postgres] remove the PgResultSetMetaDataWrapper

* AR uses the OID to map to named types for which handlers are registered
* JDBC can return the named types with getColumnTypeName()
* For normal (non-array, non-rage, etc.) this already works
* by adding handler based on the name as well as the OID,
  getColumnTypeName() can be used for everything. OID based mapping
  is still required for SchemaStatements.
* loading additional types needs to be adapted to handle OIDs as well
  as type names, with or without namespace
* pgjdbc returns two additional type: 'serial' and 'bigserial'. They're
  just int4 and int8 with auto-increment on top
* only trick thing is "fmod". luckily this is only used for "numeric"
  and can be re-constructed by using getPrecision() and getScale()
* one test needs to be excluded because it checks for a message containing
  an OID (number) instead of name (string) we get now

Author: dr-itz

lib/arjdbc/postgresql/oid_types.rb

@@ -9,6 +9,61 @@ module PostgreSQL
     # @private
     OID = ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID
 
+    # this version makes sure to register the types by name as well
+    # we still need to version with OID since it's used from SchemaStatements as well
+    class ArjdbcTypeMapInitializer < OID::TypeMapInitializer
+      private
+
+      def name_with_ns(row)
+        if row['in_ns']
+          row['typname']
+        else
+          %Q("#{row['nspname']}"."#{row['typname']}")
+        end
+      end
+
+      def register_enum_type(row)
+        super
+        register name_with_ns(row), OID::Enum.new
+      end
+
+      def register_array_type(row)
+        super
+        register_with_subtype(name_with_ns(row), row['typelem'].to_i) do |subtype|
+          OID::Array.new(subtype, row['typdelim'])
+        end
+      end
+
+      def register_range_type(row)
+        super
+        name = name_with_ns(row)
+        register_with_subtype(name, row['rngsubtype'].to_i) do |subtype|
+          OID::Range.new(subtype, name.to_sym)
+        end
+      end
+
+      def register_domain_type(row)
+        if base_type = @store.lookup(row['typbasetype'].to_i)
+          register row['oid'], base_type
+          register name_with_ns(row), base_type
+        else
+          warn "unknown base type (OID: #{row['typbasetype']}) for domain #{row['typname']}."
+        end
+      end
+
+      def register_composite_type(row)
+        if subtype = @store.lookup(row['typelem'].to_i)
+          register row['oid'], OID::Vector.new(row['typdelim'], subtype)
+          register name_with_ns(row), OID::Vector.new(row['typdelim'], subtype)
+        end
+      end
+
+      def assert_valid_registration(oid, oid_type)
+        ret = super
+        ret == 0 ? oid : ret
+      end
+    end
+
     # @private
     module OIDTypes
 
@@ -41,7 +96,7 @@ def lookup_cast_type(sql_type)
 
       def get_oid_type(oid, fmod, column_name, sql_type = '') # :nodoc:
         if !type_map.key?(oid)
-          load_additional_types(type_map, [oid])
+          load_additional_types(type_map, oid)
         end
 
         type_map.fetch(oid, fmod, sql_type) {
@@ -138,26 +193,45 @@ def initialize_type_map(m)
         end
 
         load_additional_types(m)
+
+        # pgjdbc returns these if the column is auto-incrmenting
+        m.alias_type 'serial', 'int4'
+        m.alias_type 'bigserial', 'int8'
       end
 
-      def load_additional_types(type_map, oids = nil) # :nodoc:
-        initializer = OID::TypeMapInitializer.new(type_map)
+      def load_additional_types(type_map, oid = nil) # :nodoc:
+        initializer = ArjdbcTypeMapInitializer.new(type_map)
 
         if supports_ranges?
           query = <<-SQL
-              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
+              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype,
+                ns.nspname, ns.nspname = ANY(current_schemas(true)) in_ns
               FROM pg_type as t
               LEFT JOIN pg_range as r ON oid = rngtypid
+              JOIN pg_namespace AS ns ON t.typnamespace = ns.oid
           SQL
         else
           query = <<-SQL
-              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, t.typtype, t.typbasetype
+              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, t.typtype, t.typbasetype,
+                ns.nspname, ns.nspname = ANY(current_schemas(true)) in_ns
               FROM pg_type as t
+              JOIN pg_namespace AS ns ON t.typnamespace = ns.oid
           SQL
         end
 
-        if oids
-          query += "WHERE t.oid::integer IN (%s)" % oids.join(", ")
+        if oid
+          if oid.is_a? Numeric || oid.match(/^\d+$/)
+            # numeric OID
+            query += "WHERE t.oid::integer = %s" % oid
+
+          elsif m = oid.match(/"?(\w+)"?\."?(\w+)"?/)
+            # namespace and type name
+            query += "WHERE ns.nspname = '%s' AND t.typname = '%s'" % [m[1], m[2]]
+
+          else
+            # only type name
+            query += "WHERE t.typname = '%s' AND ns.nspname = ANY(current_schemas(true))" % oid
+          end
         else
           query += initializer.query_conditions_for_initial_load(type_map)
         end

src/java/arjdbc/postgresql/PgResultSetMetaDataWrapper.java

@@ -4,6 +4,7 @@
 import arjdbc.jdbc.RubyJdbcConnection;
 
 import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 import java.sql.Types;
 
@@ -20,17 +21,13 @@
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
-import org.postgresql.core.Field;
-import org.postgresql.jdbc.PgResultSetMetaData;
-import org.postgresql.jdbc.PgResultSetMetaDataWrapper; // This is a hack unfortunately to get around method scoping
-
 /*
  * This class mimics the PG:Result class enough to get by
  */
 public class PostgreSQLResult extends JdbcResult {
 
     // These are needed when generating an AR::Result
-    private final PgResultSetMetaData resultSetMetaData;
+    private final ResultSetMetaData resultSetMetaData;
 
     /********* JRuby compat methods ***********/
 
@@ -60,7 +57,7 @@ private PostgreSQLResult(ThreadContext context, RubyClass clazz, RubyJdbcConnect
                              ResultSet resultSet) throws SQLException {
         super(context, clazz, connection, resultSet);
 
-        resultSetMetaData = (PgResultSetMetaData) resultSet.getMetaData();
+        resultSetMetaData = resultSet.getMetaData();
     }
 
     /**
@@ -73,16 +70,28 @@ private PostgreSQLResult(ThreadContext context, RubyClass clazz, RubyJdbcConnect
     protected IRubyObject columnTypeMap(final ThreadContext context) throws SQLException {
         Ruby runtime = context.runtime;
         RubyHash types = RubyHash.newHash(runtime);
-        PgResultSetMetaDataWrapper mdWrapper = new PgResultSetMetaDataWrapper(resultSetMetaData);
         int columnCount = columnNames.length;
 
         IRubyObject adapter = connection.adapter(context);
         for (int i = 0; i < columnCount; i++) {
-            final Field field = mdWrapper.getField(i + 1);
+            int col = i + 1;
+            String typeName = resultSetMetaData.getColumnTypeName(col);
+
+            int mod = 0;
+            if  ("numeric".equals(typeName)) {
+                // this field is only relevant for "numeric" type in AR
+                // AR checks (fmod - 4 & 0xffff).zero?
+                // pgjdbc:
+                //  - for typmod == -1, getScale() and getPrecision() return 0
+                //  - for typmod != -1, getScale() returns "(typmod - 4) & 0xFFFF;"
+                mod = resultSetMetaData.getScale(col);
+                mod = mod == 0 && resultSetMetaData.getPrecision(col) == 0 ? -1 : mod + 4;
+            }
+
             final RubyString name = columnNames[i];
             final IRubyObject type = Helpers.invoke(context, adapter, "get_oid_type",
-                    runtime.newFixnum(field.getOID()),
-                    runtime.newFixnum(field.getMod()),
+                    runtime.newString(typeName),
+                    runtime.newFixnum(mod),
                     name);
 
             if (!type.isNil()) types.fastASet(name, type);

src/java/arjdbc/postgresql/PostgreSQLResult.java

@@ -3,4 +3,6 @@
   exclude :test_exec_typecasts_bind_vals, 'it uses $1 for parameter mapping which is not currently supported'
 end
 
+exclude :test_only_warn_on_first_encounter_of_unrecognized_oid, 'expects warning with OID, ARJBC has name instead'
+exclude :test_only_warn_on_first_encounter_of_unknown_oid, 'expects warning with OID, ARJBC has name instead'
 exclude :test_default_sequence_name_bad_table, "ARJDBC does more quoting (which is not wrong)"