activerecord-jdbc-adapter 1.3.17 → 1.3.18

data/lib/arjdbc/oracle/column.rb

@@ -11,13 +11,13 @@ module ArJdbc
 
       def self.included(base)
         # NOTE: assumes a standalone OracleColumn class
-        class << base; include Cast; end
+        class << base; include Cast; end # unless AR42
       end
 
       def primary=(value)
         super
         @type = :integer if value && @sql_type =~ /^NUMBER$/i
-      end if ::ActiveRecord::VERSION::STRING < '4.2'
+      end unless AR42
 
       def type_cast(value)
         return nil if value.nil?
@@ -40,15 +40,19 @@ module ArJdbc
         end
       end
 
+      def sql_type
+        (@sql_type || '').start_with?('XMLTYPE') ? 'XMLTYPE' : @sql_type
+      end
+
       private
 
       def extract_limit(sql_type)
         case sql_type
         when /^(clob|date)/i then nil
-        when /^xml/i then @sql_type = 'XMLTYPE'; nil
+        when /^xml/i then nil
         else super
         end
-      end
+      end unless AR42
 
       def simplified_type(field_type)
         case field_type
@@ -67,7 +71,7 @@ module ArJdbc
         else
           super
         end
-      end
+      end unless AR42
 
       # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
       def default_value(value)

data/lib/arjdbc/oracle/connection_methods.rb

@@ -9,9 +9,12 @@ ArJdbc::ConnectionMethods.module_eval do
     return jndi_connection(config) if jndi_config?(config)
 
     config[:port] ||= 1521
-    config[:url] ||= "jdbc:oracle:thin:@#{config[:host]}:#{config[:port]}:#{config[:database]}"
+    config[:url] ||= "jdbc:oracle:thin:@#{config[:host]}:#{config[:port]}:#{config[:database] || 'XE'}"
     config[:driver] ||= "oracle.jdbc.driver.OracleDriver"
     config[:connection_alive_sql] ||= 'SELECT 1 FROM DUAL'
+    unless config.key?(:statement_escape_processing)
+      config[:statement_escape_processing] = true
+    end
     jdbc_connection(config)
   end
   alias_method :jdbcoracle_connection, :oracle_connection

data/lib/arjdbc/postgresql/_bc_time_cast_patch.rb

@@ -0,0 +1,21 @@
+  ActiveRecord::ConnectionAdapters::PostgreSQL::OID::DateTime.class_eval do
+    def cast_value(value)
+      if value.is_a?(::String)
+        case value
+        when 'infinity' then ::Float::INFINITY
+        when '-infinity' then -::Float::INFINITY
+        #when / BC$/
+        #  astronomical_year = format("%04d", value[/^\d+/].to_i)
+        #  super(value.sub(/ BC$/, "").sub(/^\d+/, astronomical_year))
+        else
+          if value.end_with?(' BC')
+            DateTime.parse("-#{value}"[0...-3])
+          else
+            super
+          end
+        end
+      else
+        value
+      end
+    end
+  end

data/lib/arjdbc/postgresql/adapter.rb

@@ -44,7 +44,9 @@ module ArJdbc
       end
     end
 
+    # @see ActiveRecord::ConnectionAdapters::Jdbc::ArelSupport
     def self.arel_visitor_type(config = nil)
+      require 'arel/visitors/postgresql_jdbc'
       ::Arel::Visitors::PostgreSQL
     end
 
@@ -916,7 +918,7 @@ module ArJdbc
     def _quote(value)
       case value
       when Type::Binary::Data
-        "'#{escape_bytea(value.to_s)}'"
+        "E'#{escape_bytea(value.to_s)}'"
       when OID::Xml::Data
         "xml '#{quote_string(value.to_s)}'"
       when OID::Bit::Data
@@ -1182,6 +1184,7 @@ module ArJdbc
       execute "ALTER INDEX #{quote_column_name(old_name)} RENAME TO #{quote_table_name(new_name)}"
     end
 
+    # @override
     def supports_foreign_keys?; true end
 
     def foreign_keys(table_name)
@@ -1477,6 +1480,9 @@ module ActiveRecord::ConnectionAdapters
 
     require 'arjdbc/postgresql/oid_types' if ::ArJdbc::AR40
     include ::ArJdbc::PostgreSQL::OIDTypes if ::ArJdbc::PostgreSQL.const_defined?(:OIDTypes)
+
+    load 'arjdbc/postgresql/_bc_time_cast_patch.rb' if ::ArJdbc::AR42
+
     include ::ArJdbc::PostgreSQL::ColumnHelpers if ::ArJdbc::AR42
 
     include ::ArJdbc::Util::QuotedCache

data/lib/arjdbc/postgresql/oid/bytea.rb

@@ -0,0 +1,3 @@
+class ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Bytea
+  remove_method :type_cast_from_database
+end

data/lib/arjdbc/postgresql/oid_types.rb

@@ -5,6 +5,7 @@ module ArJdbc
 
     if AR42
       require 'active_record/connection_adapters/postgresql/oid'
+      require 'arjdbc/postgresql/oid/bytea.rb'
     else
       require 'arjdbc/postgresql/base/oid'
     end
@@ -264,4 +265,4 @@ module ArJdbc
 
     end
   end
-end
+end

data/lib/arjdbc/tasks/database_tasks.rb

@@ -7,6 +7,9 @@ module ArJdbc
         ActiveRecord::Tasks::DatabaseTasks.register_task(pattern, task)
       end
 
+      # support adapter: mariadb (as if it were mysql)
+      register_tasks(/mariadb/, ActiveRecord::Tasks::MySQLDatabaseTasks)
+
     else
 
       @@tasks = {}

data/lib/arjdbc/util/quoted_cache.rb

@@ -28,7 +28,7 @@ module ArJdbc
       # Caches quoted table names, the cache is stored in the class'
       # `QUOTED_TABLE_NAMES` constant.
       # @return [String]
-      def quote_table_name(name)
+      def quote_table_name(name, *args)
         if cache = self.class::QUOTED_TABLE_NAMES
           unless quoted = cache[name]
             quoted = super
@@ -43,7 +43,7 @@ module ArJdbc
       # Caches quoted table names, the cache is stored in the class'
       # `QUOTED_COLUMN_NAMES` constant.
       # @return [String]
-      def quote_column_name(name)
+      def quote_column_name(name, *args)
         if cache = self.class::QUOTED_COLUMN_NAMES
           unless quoted = cache[name]
             quoted = super

data/lib/arjdbc/util/serialized_attributes.rb

@@ -29,6 +29,15 @@ module ArJdbc
         SerializedAttributes.dump_column_value(self, column)
       end
 
+      if defined? ActiveRecord::Type::Serialized # ArJdbc::AR42
+
+      def self.dump_column_value(record, column)
+        value = record[ column.name.to_s ]
+        column.cast_type.type_cast_for_database(value)
+      end
+
+      else
+
       def self.dump_column_value(record, column)
         value = record[ name = column.name.to_s ]
         if record.class.respond_to?(:serialized_attributes)
@@ -45,6 +54,8 @@ module ArJdbc
         value
       end
 
+      end
+
       def self.setup(lob_type = nil, after_save_alias = nil)
         ActiveRecord::Base.send :include, self # include SerializedAttributes
         ActiveRecord::Base.lob_type = lob_type unless lob_type.nil?

data/lib/arjdbc/version.rb

@@ -1,5 +1,5 @@
 module ArJdbc
-  VERSION = "1.3.17"
+  VERSION = "1.3.18"
   # @deprecated
   module Version
     # @private 1.2.x compatibility

data/rakelib/02-test.rake

@@ -94,7 +94,7 @@ test_task_for :AS400, :desc => "Run tests against AS400 (DB2) (ensure driver is
   :files => FileList["test/db2*_test.rb"] + FileList["test/db/db2/*_test.rb"]
 
 test_task_for 'JDBC', :desc => 'Run tests against plain JDBC adapter (uses MySQL and Derby)',
-  :files => FileList['test/*jdbc_*test.rb'] do |test_task|
+  :prereqs => 'db:mysql', :files => FileList['test/*jdbc_*test.rb'] do |test_task|
   test_task.libs << 'jdbc-mysql/lib' << 'jdbc-derby/lib'
 end
 

data/rakelib/db.rake

@@ -32,7 +32,9 @@ SQL
 DROP DATABASE IF EXISTS #{POSTGRES_CONFIG[:database]};
 DROP USER IF EXISTS #{POSTGRES_CONFIG[:username]};
 CREATE USER #{POSTGRES_CONFIG[:username]} CREATEDB SUPERUSER LOGIN PASSWORD '#{POSTGRES_CONFIG[:password]}';
-CREATE DATABASE #{POSTGRES_CONFIG[:database]} OWNER #{POSTGRES_CONFIG[:username]};
+CREATE DATABASE #{POSTGRES_CONFIG[:database]} OWNER #{POSTGRES_CONFIG[:username]}
+       TEMPLATE template0
+       ENCODING '#{POSTGRES_CONFIG[:encoding]}' LC_COLLATE '#{POSTGRES_CONFIG[:collate]}' LC_CTYPE '#{POSTGRES_CONFIG[:collate]}';
 SQL
     params = { '-U' => ENV['PSQL_USER'] || 'postgres' }
     params['-q'] = nil unless $VERBOSE

data/src/java/arjdbc/firebird/FirebirdRubyJdbcConnection.java

@@ -0,0 +1,190 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2015 Karol Bucek.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package arjdbc.firebird;
+
+import arjdbc.jdbc.RubyJdbcConnection;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.PreparedStatement;
+import java.sql.ResultSetMetaData;
+import java.sql.Types;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyString;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * @author kares
+ */
+public class FirebirdRubyJdbcConnection extends RubyJdbcConnection {
+
+    protected FirebirdRubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+    }
+
+    public static RubyClass createFirebirdJdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
+        final RubyClass clazz = RubyJdbcConnection.getConnectionAdapters(runtime).
+            defineClassUnder("FirebirdJdbcConnection", jdbcConnection, ALLOCATOR);
+        clazz.defineAnnotatedMethods(FirebirdRubyJdbcConnection.class);
+        return clazz;
+    }
+
+    private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new FirebirdRubyJdbcConnection(runtime, klass);
+        }
+    };
+
+    @Override // resultSet.wasNull() might be falsy for '' treated as null
+    protected IRubyObject stringToRuby(final ThreadContext context,
+        final Ruby runtime, final ResultSet resultSet, final int column)
+        throws SQLException {
+        final String value = resultSet.getString(column);
+        if ( value == null ) return runtime.getNil();
+        return RubyString.newUnicodeString(runtime, value);
+    }
+
+    @Override // booleans are emulated can not setNull(index, Types.BOOLEAN)
+    protected void setBooleanParameter(final ThreadContext context,
+        final Connection connection, final PreparedStatement statement,
+        final int index, final Object value,
+        final IRubyObject column, final int type) throws SQLException {
+        if ( value instanceof IRubyObject ) {
+            setBooleanParameter(context, connection, statement, index, (IRubyObject) value, column, type);
+        }
+        else {
+            if ( value == null ) statement.setNull(index, Types.CHAR);
+            else {
+                statement.setBoolean(index, ((Boolean) value).booleanValue());
+            }
+        }
+    }
+
+    @Override // booleans are emulated can not setNull(index, Types.BOOLEAN)
+    protected void setBooleanParameter(final ThreadContext context,
+        final Connection connection, final PreparedStatement statement,
+        final int index, final IRubyObject value,
+        final IRubyObject column, final int type) throws SQLException {
+        if ( value.isNil() ) statement.setNull(index, Types.CHAR);
+        else {
+            statement.setBoolean(index, value.isTrue());
+        }
+    }
+
+    protected IRubyObject jdbcToRuby(
+        final ThreadContext context, final Ruby runtime,
+        final int column, final int type, final ResultSet resultSet)
+        throws SQLException {
+
+        switch (type) {
+        case SMALL_CHAR_1:
+            return smallChar1ToRuby(runtime, resultSet, column);
+        case SMALL_CHAR_2:
+            return smallChar2ToRuby(runtime, resultSet, column);
+        }
+        return super.jdbcToRuby(context, runtime, column, type, resultSet);
+    }
+
+    private static IRubyObject smallChar1ToRuby(
+        final Ruby runtime, final ResultSet resultSet, final int column)
+        throws SQLException {
+        String value = resultSet.getString(column);
+        if ( value == null ) return runtime.getNil();
+        if ( value.length() > 1 && value.charAt(1) == ' ' ) {
+            value = value.substring(0, 1);
+        }
+        return RubyString.newUnicodeString(runtime, value);
+    }
+
+    private static IRubyObject smallChar2ToRuby(
+        final Ruby runtime, final ResultSet resultSet, final int column)
+        throws SQLException {
+        String value = resultSet.getString(column);
+        if ( value == null ) return runtime.getNil();
+        if ( value.length() > 2 && value.charAt(2) == ' ' ) {
+            value = value.substring(0, 2);
+        }
+        return RubyString.newUnicodeString(runtime, value);
+    }
+
+    private final static int SMALL_CHAR_1 = 31431001;
+    private final static int SMALL_CHAR_2 = 31431002;
+
+    @Override
+    protected ColumnData[] extractColumns(final Ruby runtime,
+        final Connection connection, final ResultSet resultSet,
+        final boolean downCase) throws SQLException {
+
+        final ResultSetMetaData resultMetaData = resultSet.getMetaData();
+
+        final int columnCount = resultMetaData.getColumnCount();
+        final ColumnData[] columns = new ColumnData[columnCount];
+
+        for ( int i = 1; i <= columnCount; i++ ) { // metadata is one-based
+            String name = resultMetaData.getColumnLabel(i);
+            if ( downCase ) {
+                name = name.toLowerCase();
+            } else {
+                name = caseConvertIdentifierForRails(connection, name);
+            }
+            final RubyString columnName = RubyString.newUnicodeString(runtime, name);
+
+            int columnType = resultMetaData.getColumnType(i);
+            if (columnType == Types.CHAR) {
+                // CHAR(1) 'aligned' by JayBird to "1  "
+                final int prec = resultMetaData.getPrecision(i);
+                if ( prec == 1 ) {
+                    columnType = SMALL_CHAR_1;
+                }
+                else if ( prec == 2 ) {
+                    columnType = SMALL_CHAR_2;
+                }
+            }
+
+            columns[i - 1] = new ColumnData(columnName, columnType, i);
+        }
+
+        return columns;
+    }
+
+    // storesMixedCaseIdentifiers() return false;
+    // storesLowerCaseIdentifiers() return false;
+    // storesUpperCaseIdentifiers() return true;
+
+    @Override
+    protected String caseConvertIdentifierForRails(final Connection connection, final String value) {
+        return value == null ? null : value.toLowerCase();
+    }
+
+    @Override
+    protected String caseConvertIdentifierForJdbc(final Connection connection, final String value) {
+        return value == null ? null : value.toUpperCase();
+    }
+
+}

data/src/java/arjdbc/jdbc/RubyJdbcConnection.java

@@ -54,6 +54,7 @@ import java.sql.Types;
 import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -152,6 +153,15 @@ public class RubyJdbcConnection extends RubyObject {
         return getConnectionAdapters(runtime).getClass("IndexDefinition");
     }
 
+    /**
+     * @param runtime
+     * @return <code>ActiveRecord::ConnectionAdapters::ForeignKeyDefinition</code>
+     * @note only since AR 4.2
+     */
+    protected static RubyClass getForeignKeyDefinition(final Ruby runtime) {
+        return getConnectionAdapters(runtime).getClass("ForeignKeyDefinition");
+    }
+
     /**
      * @param runtime
      * @return <code>ActiveRecord::JDBCError</code>
@@ -1168,7 +1178,7 @@ public class RubyJdbcConnection extends RubyObject {
 
                     final DatabaseMetaData metaData = connection.getMetaData();
                     columns = metaData.getColumns(components.catalog, components.schema, components.name, null);
-                    return unmarshalColumns(context, metaData, components, columns);
+                    return mapColumnsResult(context, metaData, components, columns);
                 }
                 finally {
                     close(columns);
@@ -1205,7 +1215,7 @@ public class RubyJdbcConnection extends RubyObject {
         return withConnection(context, new Callable<IRubyObject>() {
             public IRubyObject call(final Connection connection) throws SQLException {
                 final Ruby runtime = context.getRuntime();
-                final RubyClass indexDefinition = getIndexDefinition(runtime);
+                final RubyClass IndexDefinition = getIndexDefinition(context);
 
                 String _tableName = caseConvertIdentifierForJdbc(connection, tableName);
                 String _schemaName = caseConvertIdentifierForJdbc(connection, schemaName);
@@ -1248,7 +1258,7 @@ public class RubyJdbcConnection extends RubyObject {
                                 // orders, (since AR 3.2) where, type, using (AR 4.0)
                             };
 
-                            indexes.add( indexDefinition.callMethod(context, "new", args) ); // IndexDefinition.new
+                            indexes.add( IndexDefinition.callMethod(context, "new", args) ); // IndexDefinition.new
                         }
 
                         // One or more columns can be associated with an index
@@ -1265,6 +1275,103 @@ public class RubyJdbcConnection extends RubyObject {
         });
     }
 
+    protected RubyClass getIndexDefinition(final ThreadContext context) {
+        final RubyClass adapterClass = getAdapter(context).getMetaClass();
+        IRubyObject IDef = adapterClass.getConstantAt("IndexDefinition");
+        return IDef != null ? (RubyClass) IDef : getIndexDefinition(context.runtime);
+    }
+
+    @JRubyMethod
+    public IRubyObject foreign_keys(final ThreadContext context, IRubyObject table_name) {
+        return foreignKeys(context, table_name.toString(), null, null);
+    }
+
+    protected IRubyObject foreignKeys(final ThreadContext context, final String tableName, final String schemaName, final String catalog) {
+        return withConnection(context, new Callable<IRubyObject>() {
+            public IRubyObject call(final Connection connection) throws SQLException {
+                final Ruby runtime = context.getRuntime();
+                final RubyClass FKDefinition = getForeignKeyDefinition(context);
+
+                String _tableName = caseConvertIdentifierForJdbc(connection, tableName);
+                String _schemaName = caseConvertIdentifierForJdbc(connection, schemaName);
+                final TableName table = extractTableName(connection, catalog, _schemaName, _tableName);
+
+                ResultSet fkInfoSet = null;
+                final List<IRubyObject> fKeys = new ArrayList<IRubyObject>(8);
+                try {
+                    final DatabaseMetaData metaData = connection.getMetaData();
+                    fkInfoSet = metaData.getImportedKeys(table.catalog, table.schema, table.name);
+
+                    while ( fkInfoSet.next() ) {
+                        final RubyHash options = RubyHash.newHash(runtime);
+
+                        String fkName = fkInfoSet.getString("FK_NAME");
+                        if (fkName != null) {
+                            fkName = caseConvertIdentifierForRails(metaData, fkName);
+                            options.put(runtime.newSymbol("name"), fkName);
+                        }
+
+                        String columnName = fkInfoSet.getString("FKCOLUMN_NAME");
+                        options.put(runtime.newSymbol("column"), caseConvertIdentifierForRails(metaData, columnName));
+
+                        columnName = fkInfoSet.getString("PKCOLUMN_NAME");
+                        options.put(runtime.newSymbol("primary_key"), caseConvertIdentifierForRails(metaData, columnName));
+
+                        String fkTableName = fkInfoSet.getString("FKTABLE_NAME");
+                        fkTableName = caseConvertIdentifierForRails(metaData, fkTableName);
+
+                        String pkTableName = fkInfoSet.getString("PKTABLE_NAME");
+                        pkTableName = caseConvertIdentifierForRails(metaData, pkTableName);
+
+                        final String onDelete = extractForeignKeyRule( fkInfoSet.getInt("DELETE_RULE") );
+                        if ( onDelete != null ) options.op_aset(context, runtime.newSymbol("on_delete"), runtime.newSymbol(onDelete));
+
+                        final String onUpdate = extractForeignKeyRule( fkInfoSet.getInt("UPDATE_RULE") );
+                        if ( onUpdate != null ) options.op_aset(context, runtime.newSymbol("on_update"), runtime.newSymbol(onUpdate));
+
+                        IRubyObject[] args = new IRubyObject[] {
+                            RubyString.newUnicodeString(runtime, fkTableName), // from_table
+                            RubyString.newUnicodeString(runtime, pkTableName), // to_table
+                            options
+                        };
+
+                        fKeys.add( FKDefinition.callMethod(context, "new", args) ); // ForeignKeyDefinition.new
+                    }
+
+                    return runtime.newArray(fKeys);
+
+                } finally { close(fkInfoSet); }
+            }
+        });
+    }
+
+    protected String extractForeignKeyRule(final int rule) {
+        switch (rule) {
+            case DatabaseMetaData.importedKeyNoAction :  return null ;
+            case DatabaseMetaData.importedKeyCascade :   return "cascade" ;
+            case DatabaseMetaData.importedKeySetNull :   return "nullify" ;
+            case DatabaseMetaData.importedKeySetDefault: return "default" ;
+        }
+        return null;
+    }
+
+    protected RubyClass getForeignKeyDefinition(final ThreadContext context) {
+        final RubyClass adapterClass = getAdapter(context).getMetaClass();
+        IRubyObject FKDef = adapterClass.getConstantAt("ForeignKeyDefinition");
+        return FKDef != null ? (RubyClass) FKDef : getForeignKeyDefinition(context.runtime);
+    }
+
+
+    @JRubyMethod(name = "supports_foreign_keys?")
+    public IRubyObject supports_foreign_keys_p(final ThreadContext context) throws SQLException {
+        return withConnection(context, new Callable<IRubyObject>() {
+            public IRubyObject call(final Connection connection) throws SQLException {
+                final DatabaseMetaData metaData = connection.getMetaData();
+                return context.getRuntime().newBoolean( metaData.supportsIntegrityEnhancementFacility() );
+            }
+        });
+    }
+
     @JRubyMethod(name = "supports_views?")
     public IRubyObject supports_views_p(final ThreadContext context) throws SQLException {
         return withConnection(context, new Callable<IRubyObject>() {
@@ -1785,6 +1892,16 @@ public class RubyJdbcConnection extends RubyObject {
         return value;
     }
 
+    /**
+     * @return AR::Type-casted value
+     * @since 1.3.18
+     */
+    protected static IRubyObject typeCastFromDatabase(final ThreadContext context,
+        final IRubyObject adapter, final RubySymbol typeName, final RubyString value) {
+        final IRubyObject type = adapter.callMethod(context, "lookup_cast_type", typeName);
+        return type.callMethod(context, "type_cast_from_database", value);
+    }
+
     protected IRubyObject dateToRuby(final ThreadContext context,
         final Ruby runtime, final ResultSet resultSet, final int column)
         throws SQLException {
@@ -1800,6 +1917,11 @@ public class RubyJdbcConnection extends RubyObject {
 
         final IRubyObject adapter = callMethod(context, "adapter"); // self.adapter
         if ( adapter.isNil() ) return strValue; // NOTE: we warn on init_connection
+
+        if ( usesType(runtime) ) {
+            // NOTE: this CAN NOT be 100% correct - as :date is just a type guess!
+            return typeCastFromDatabase(context, adapter, runtime.newSymbol("date"), strValue);
+        }
         return adapter.callMethod(context, "_string_to_date", strValue);
     }
 
@@ -1818,6 +1940,11 @@ public class RubyJdbcConnection extends RubyObject {
 
         final IRubyObject adapter = callMethod(context, "adapter"); // self.adapter
         if ( adapter.isNil() ) return strValue; // NOTE: we warn on init_connection
+
+        if ( usesType(runtime) ) {
+            // NOTE: this CAN NOT be 100% correct - as :time is just a type guess!
+            return typeCastFromDatabase(context, adapter, runtime.newSymbol("time"), strValue);
+        }
         return adapter.callMethod(context, "_string_to_time", strValue);
     }
 
@@ -1836,6 +1963,11 @@ public class RubyJdbcConnection extends RubyObject {
 
         final IRubyObject adapter = callMethod(context, "adapter"); // self.adapter
         if ( adapter.isNil() ) return strValue; // NOTE: we warn on init_connection
+
+        if ( usesType(runtime) ) {
+            // NOTE: this CAN NOT be 100% correct - as :timestamp is just a type guess!
+            return typeCastFromDatabase(context, adapter, runtime.newSymbol("timestamp"), strValue);
+        }
         return adapter.callMethod(context, "_string_to_timestamp", strValue);
     }
 
@@ -2032,9 +2164,17 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     protected void setStatementParameter(final ThreadContext context,
-        final Ruby runtime, final Connection connection,
-        final PreparedStatement statement, final int index,
-        final Object value, final IRubyObject column) throws SQLException {
+            final Ruby runtime, final Connection connection,
+            final PreparedStatement statement, final int index,
+            final Object rawValue, final IRubyObject column) throws SQLException {
+        final Object value;
+
+        if ( isAr42(column) ) {
+            final IRubyObject castType = column.callMethod(context, "cast_type");
+            value = castType.callMethod(context, "type_cast_for_database", (IRubyObject) rawValue);
+        } else {
+            value = rawValue;
+        }
 
         final int type = jdbcTypeFor(context, runtime, column, value);
 
@@ -2078,7 +2218,7 @@ public class RubyJdbcConnection extends RubyObject {
                 setXmlParameter(context, connection, statement, index, value, column, type);
                 break;
             case Types.ARRAY:
-                setArrayParameter(context, connection, statement, index, value, column, type);
+                setArrayParameter(context, connection, statement, index, rawValue, column, type);
                 break;
             case Types.JAVA_OBJECT:
             case Types.OTHER:
@@ -2135,7 +2275,49 @@ public class RubyJdbcConnection extends RubyObject {
         if ( column == null || column.isNil() ) {
             throw runtime.newArgumentError("nil column passed");
         }
-        return (RubySymbol) column.callMethod(context, "type");
+
+        final IRubyObject type = column.callMethod(context, "type");
+        if ( type.isNil() || ! (type instanceof RubySymbol) ) {
+            throw new IllegalStateException("unexpected type = " + type.inspect() + " for " + column.inspect());
+        }
+        return (RubySymbol) type;
+    }
+
+    protected static final Map<String, Integer> JDBC_TYPE_FOR = new HashMap<String, Integer>(32, 1);
+    static {
+        JDBC_TYPE_FOR.put("string", Types.VARCHAR);
+        JDBC_TYPE_FOR.put("text", Types.CLOB);
+        JDBC_TYPE_FOR.put("integer", Types.INTEGER);
+        JDBC_TYPE_FOR.put("float", Types.FLOAT);
+        JDBC_TYPE_FOR.put("real", Types.REAL);
+        JDBC_TYPE_FOR.put("decimal", Types.DECIMAL);
+        JDBC_TYPE_FOR.put("date", Types.DATE);
+        JDBC_TYPE_FOR.put("time", Types.TIME);
+        JDBC_TYPE_FOR.put("datetime", Types.TIMESTAMP);
+        JDBC_TYPE_FOR.put("timestamp", Types.TIMESTAMP);
+        JDBC_TYPE_FOR.put("binary", Types.BLOB);
+        JDBC_TYPE_FOR.put("boolean", Types.BOOLEAN);
+        JDBC_TYPE_FOR.put("array", Types.ARRAY);
+        JDBC_TYPE_FOR.put("xml", Types.SQLXML);
+
+        // also mapping standard SQL names :
+        JDBC_TYPE_FOR.put("bit", Types.BIT);
+        JDBC_TYPE_FOR.put("tinyint", Types.TINYINT);
+        JDBC_TYPE_FOR.put("smallint", Types.SMALLINT);
+        JDBC_TYPE_FOR.put("bigint", Types.BIGINT);
+        JDBC_TYPE_FOR.put("int", Types.INTEGER);
+        JDBC_TYPE_FOR.put("double", Types.DOUBLE);
+        JDBC_TYPE_FOR.put("numeric", Types.NUMERIC);
+        JDBC_TYPE_FOR.put("char", Types.CHAR);
+        JDBC_TYPE_FOR.put("varchar", Types.VARCHAR);
+        JDBC_TYPE_FOR.put("binary", Types.BINARY);
+        JDBC_TYPE_FOR.put("varbinary", Types.VARBINARY);
+        //JDBC_TYPE_FOR.put("struct", Types.STRUCT);
+        JDBC_TYPE_FOR.put("blob", Types.BLOB);
+        JDBC_TYPE_FOR.put("clob", Types.CLOB);
+        JDBC_TYPE_FOR.put("nchar", Types.NCHAR);
+        JDBC_TYPE_FOR.put("nvarchar", Types.NVARCHAR);
+        JDBC_TYPE_FOR.put("nclob", Types.NCLOB);
     }
 
     protected int jdbcTypeFor(final ThreadContext context, final Ruby runtime,
@@ -2150,39 +2332,20 @@ public class RubyJdbcConnection extends RubyObject {
                 internedType = "array";
             }
             else {
-                final RubySymbol columnType = resolveColumnType(context, runtime, column);
-                internedType = columnType.asJavaString();
+                internedType = resolveColumnType(context, runtime, column).asJavaString();
             }
         }
         else {
-            if ( value instanceof RubyInteger ) {
-                internedType = "integer";
-            }
-            else if ( value instanceof RubyNumeric ) {
-                internedType = "float";
-            }
-            else if ( value instanceof RubyTime ) {
-                internedType = "timestamp";
-            }
-            else {
-                internedType = "string";
-            }
+            if ( value instanceof RubyInteger ) internedType = "integer";
+            else if ( value instanceof RubyNumeric ) internedType = "float";
+            else if ( value instanceof RubyTime ) internedType = "timestamp";
+            else internedType = "string";
         }
 
-        if ( internedType == (Object) "string" ) return Types.VARCHAR;
-        else if ( internedType == (Object) "text" ) return Types.CLOB;
-        else if ( internedType == (Object) "integer" ) return Types.INTEGER;
-        else if ( internedType == (Object) "decimal" ) return Types.DECIMAL;
-        else if ( internedType == (Object) "float" ) return Types.FLOAT;
-        else if ( internedType == (Object) "date" ) return Types.DATE;
-        else if ( internedType == (Object) "time" ) return Types.TIME;
-        else if ( internedType == (Object) "datetime" ) return Types.TIMESTAMP;
-        else if ( internedType == (Object) "timestamp" ) return Types.TIMESTAMP;
-        else if ( internedType == (Object) "binary" ) return Types.BLOB;
-        else if ( internedType == (Object) "boolean" ) return Types.BOOLEAN;
-        else if ( internedType == (Object) "xml" ) return Types.SQLXML;
-        else if ( internedType == (Object) "array" ) return Types.ARRAY;
-        else return Types.OTHER; // -1 as well as 0 are used in Types
+        final Integer sqlType = JDBC_TYPE_FOR.get(internedType);
+        if ( sqlType != null ) return sqlType.intValue();
+
+        return Types.OTHER; // -1 as well as 0 are used in Types
     }
 
     protected void setIntegerParameter(final ThreadContext context,
@@ -2338,6 +2501,9 @@ public class RubyJdbcConnection extends RubyObject {
             if ( value.getMetaClass().getName().indexOf("BigDecimal") != -1 ) {
                 statement.setBigDecimal(index, getBigDecimalValue(value));
             }
+            else if ( value instanceof RubyInteger ) {
+                statement.setBigDecimal(index, new BigDecimal(((RubyInteger) value).getBigIntegerValue()));
+            }
             else if ( value instanceof RubyNumeric ) {
                 statement.setDouble(index, ((RubyNumeric) value).getDoubleValue());
             }
@@ -2617,15 +2783,15 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     protected void setArrayParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, final Object value,
-        final IRubyObject column, final int type) throws SQLException {
+            final Connection connection, final PreparedStatement statement,
+            final int index, final Object value,
+            final IRubyObject column, final int type) throws SQLException {
         if ( value instanceof IRubyObject ) {
             setArrayParameter(context, connection, statement, index, (IRubyObject) value, column, type);
-        }
-        else {
-            if ( value == null ) statement.setNull(index, Types.ARRAY);
-            else {
+        } else {
+            if ( value == null ) {
+                statement.setNull(index, Types.ARRAY);
+            } else {
                 String typeName = resolveArrayBaseTypeName(context, value, column, type);
                 Array array = connection.createArrayOf(typeName, (Object[]) value);
                 statement.setArray(index, array);
@@ -2637,8 +2803,9 @@ public class RubyJdbcConnection extends RubyObject {
         final Connection connection, final PreparedStatement statement,
         final int index, final IRubyObject value,
         final IRubyObject column, final int type) throws SQLException {
-        if ( value.isNil() ) statement.setNull(index, Types.ARRAY);
-        else {
+        if ( value.isNil() ) {
+            statement.setNull(index, Types.ARRAY);
+        } else {
             String typeName = resolveArrayBaseTypeName(context, value, column, type);
             Array array = connection.createArrayOf(typeName, ((RubyArray) value).toArray());
             statement.setArray(index, array);
@@ -2963,15 +3130,41 @@ public class RubyJdbcConnection extends RubyObject {
         return defaultValue == null ? runtime.getNil() : RubyString.newUnicodeString(runtime, defaultValue);
     }
 
-    private RubyArray unmarshalColumns(final ThreadContext context,
+    /**
+     * Internal API that might be subject to change!
+     * @since 1.3.18
+     */
+    protected static boolean usesType(final Ruby runtime) { // AR 4.2
+        return runtime.getModule("ActiveRecord").getConstantAt("Type") != null;
+    }
+
+    /**
+     * This method is considered internal and is not part of AR-JDBC's Java ext
+     * API and thus might be subject to change in the future.
+     * Please copy it to your own class if you rely on it to avoid issues.
+     */
+    protected static boolean isAr42(IRubyObject column) {
+        return column.respondsTo("cast_type");
+    }
+
+    protected RubyArray mapColumnsResult(final ThreadContext context,
         final DatabaseMetaData metaData, final TableName components, final ResultSet results)
         throws SQLException {
 
-        final Ruby runtime = context.getRuntime();
-        final RubyClass JdbcColumn = getJdbcColumnClass(context);
-
+        final RubyClass Column = getJdbcColumnClass(context);
+        final boolean lookupCastType = Column.isMethodBound("cast_type", false);
         // NOTE: primary/primary= methods were removed from Column in AR 4.2
-        final boolean setPrimary = JdbcColumn.isMethodBound("primary=", false);
+        // setPrimary = ! lookupCastType by default ... it's better than checking
+        // whether primary= is bound since it might be a left over in AR-JDBC ext
+        return mapColumnsResult(context, metaData, components, results, Column, lookupCastType, ! lookupCastType);
+    }
+
+    protected final RubyArray mapColumnsResult(final ThreadContext context,
+        final DatabaseMetaData metaData, final TableName components, final ResultSet results,
+        final RubyClass Column, final boolean lookupCastType, final boolean setPrimary)
+        throws SQLException {
+
+        final Ruby runtime = context.getRuntime();
 
         final Collection<String> primaryKeyNames =
             setPrimary ? getPrimaryKeyNames(metaData, components) : null;
@@ -2980,22 +3173,27 @@ public class RubyJdbcConnection extends RubyObject {
         final IRubyObject config = getConfig(context);
         while ( results.next() ) {
             final String colName = results.getString(COLUMN_NAME);
-            IRubyObject column = JdbcColumn.callMethod(context, "new",
-                new IRubyObject[] {
-                    config,
-                    RubyString.newUnicodeString( runtime, caseConvertIdentifierForRails(metaData, colName) ),
-                    defaultValueFromResultSet( runtime, results ),
-                    RubyString.newUnicodeString( runtime, typeFromResultSet(results) ),
-                    runtime.newBoolean( ! results.getString(IS_NULLABLE).trim().equals("NO") )
-                });
+            final RubyString railsColumnName = RubyString.newUnicodeString(runtime, caseConvertIdentifierForRails(metaData, colName));
+            final IRubyObject defaultValue = defaultValueFromResultSet( runtime, results );
+            final RubyString sqlType = RubyString.newUnicodeString( runtime, typeFromResultSet(results) );
+            final RubyBoolean nullable = runtime.newBoolean( ! results.getString(IS_NULLABLE).trim().equals("NO") );
+            final IRubyObject[] args;
+            if ( lookupCastType ) {
+                final IRubyObject castType = getAdapter(context).callMethod(context, "lookup_cast_type", sqlType);
+                args = new IRubyObject[] {config, railsColumnName, defaultValue, castType, sqlType, nullable};
+            } else {
+                args = new IRubyObject[] {config, railsColumnName, defaultValue, sqlType, nullable};
+            }
+
+            IRubyObject column = Column.callMethod(context, "new", args);
             columns.append(column);
 
-            if ( primaryKeyNames != null && primaryKeyNames.contains(colName) ) {
-                column.callMethod(context, "primary=", runtime.getTrue());
+            if ( primaryKeyNames != null ) {
+                final RubyBoolean primary = runtime.newBoolean( primaryKeyNames.contains(colName) );
+                column.getInstanceVariables().setInstanceVariable("@primary", primary);
             }
         }
         return columns;
-
     }
 
     private static Collection<String> getPrimaryKeyNames(final DatabaseMetaData metaData,