activerecord-jdbc-adapter 60.3-java → 61.0-java

data/lib/arjdbc/postgresql/column.rb

@@ -48,7 +48,7 @@ module ArJdbc
       end
 
       def has_default_function?(default_value, default)
-        !default_value && %r{\w+\(.*\)|\(.*\)::\w+|CURRENT_DATE|CURRENT_TIMESTAMP}.match?(default)
+        !default_value && default && %r{\w+\(.*\)|\(.*\)::\w+|CURRENT_DATE|CURRENT_TIMESTAMP}.match?(default)
       end
     end
 

data/lib/arjdbc/postgresql/oid_types.rb

@@ -145,7 +145,7 @@ module ArJdbc
         m.register_type 'uuid', OID::Uuid.new
         m.register_type 'xml', OID::Xml.new
         m.register_type 'tsvector', OID::SpecializedString.new(:tsvector)
-        m.register_type 'macaddr', OID::SpecializedString.new(:macaddr)
+        m.register_type 'macaddr', OID::Macaddr.new
         m.register_type 'citext', OID::SpecializedString.new(:citext)
         m.register_type 'ltree', OID::SpecializedString.new(:ltree)
         m.register_type 'line', OID::SpecializedString.new(:line)
@@ -155,9 +155,9 @@ module ArJdbc
         m.register_type 'polygon', OID::SpecializedString.new(:polygon)
         m.register_type 'circle', OID::SpecializedString.new(:circle)
 
-        m.register_type 'interval' do |_, _, sql_type|
+        m.register_type 'interval' do |*args, sql_type|
           precision = extract_precision(sql_type)
-          OID::SpecializedString.new(:interval, precision: precision)
+          OID::Interval.new(precision: precision)
         end
 
         register_class_with_precision m, 'time', Type::Time
@@ -244,6 +244,7 @@ module ArJdbc
       ActiveRecord::Type.register(:enum, OID::Enum, adapter: :postgresql)
       ActiveRecord::Type.register(:hstore, OID::Hstore, adapter: :postgresql)
       ActiveRecord::Type.register(:inet, OID::Inet, adapter: :postgresql)
+      ActiveRecord::Type.register(:interval, OID::Interval, adapter: :postgresql)
       ActiveRecord::Type.register(:json, Type::Json, adapter: :postgresql)
       ActiveRecord::Type.register(:jsonb, OID::Jsonb, adapter: :postgresql)
       ActiveRecord::Type.register(:money, OID::Money, adapter: :postgresql)

data/lib/arjdbc/sqlite3/adapter.rb

@@ -16,6 +16,33 @@ require "active_record/connection_adapters/sqlite3/schema_dumper"
 require "active_record/connection_adapters/sqlite3/schema_statements"
 require "active_support/core_ext/class/attribute"
 
+module SQLite3
+  module Constants
+    module Open
+      READONLY       = 0x00000001
+      READWRITE      = 0x00000002
+      CREATE         = 0x00000004
+      DELETEONCLOSE  = 0x00000008
+      EXCLUSIVE      = 0x00000010
+      AUTOPROXY      = 0x00000020
+      URI            = 0x00000040
+      MEMORY         = 0x00000080
+      MAIN_DB        = 0x00000100
+      TEMP_DB        = 0x00000200
+      TRANSIENT_DB   = 0x00000400
+      MAIN_JOURNAL   = 0x00000800
+      TEMP_JOURNAL   = 0x00001000
+      SUBJOURNAL     = 0x00002000
+      MASTER_JOURNAL = 0x00004000
+      NOMUTEX        = 0x00008000
+      FULLMUTEX      = 0x00010000
+      SHAREDCACHE    = 0x00020000
+      PRIVATECACHE   = 0x00040000
+      WAL            = 0x00080000
+    end
+  end
+end
+
 module ArJdbc
   # All the code in this module is a copy of ConnectionAdapters::SQLite3Adapter from active_record 5.
   # The constants at the front of this file are to allow the rest of the file to remain with no modifications
@@ -69,6 +96,10 @@ module ArJdbc
       true
     end
 
+    def supports_transaction_isolation?
+      true
+    end
+
     def supports_partial_index?
       database_version >= "3.9.0"
     end
@@ -85,6 +116,10 @@ module ArJdbc
       true
     end
 
+    def supports_check_constraints?
+      true
+    end
+
     def supports_views?
       true
     end
@@ -114,13 +149,6 @@ module ArJdbc
       true
     end
 
-    # Returns 62. SQLite supports index names up to 64
-    # characters. The rest is used by Rails internally to perform
-    # temporary rename operations
-    def allowed_index_name_length
-      index_name_length - 2
-    end
-
     def native_database_types #:nodoc:
       NATIVE_DATABASE_TYPES
     end
@@ -159,7 +187,7 @@ module ArJdbc
     #++
 
     READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
-      :begin, :commit, :explain, :select, :pragma, :release, :savepoint, :rollback, :with
+      :pragma
     ) # :nodoc:
     private_constant :READ_QUERY
 
@@ -187,15 +215,15 @@ module ArJdbc
     #def execute(sql, name = nil) #:nodoc:
 
     def begin_db_transaction #:nodoc:
-      log("begin transaction", nil) { @connection.transaction }
+      log("begin transaction", 'TRANSACTION') { @connection.transaction }
     end
 
     def commit_db_transaction #:nodoc:
-      log("commit transaction", nil) { @connection.commit }
+      log("commit transaction", 'TRANSACTION') { @connection.commit }
     end
 
     def exec_rollback_db_transaction #:nodoc:
-      log("rollback transaction", nil) { @connection.rollback }
+      log("rollback transaction", 'TRANSACTION') { @connection.rollback }
     end
 
     # SCHEMA STATEMENTS ========================================
@@ -205,8 +233,11 @@ module ArJdbc
       pks.sort_by { |f| f["pk"] }.map { |f| f["name"] }
     end
 
-    def remove_index(table_name, options = {}) #:nodoc:
-      index_name = index_name_for_remove(table_name, options)
+      def remove_index(table_name, column_name = nil, **options) # :nodoc:
+        return if options[:if_exists] && !index_exists?(table_name, column_name, **options)
+
+      index_name = index_name_for_remove(table_name, column_name, options)
+
       exec_query "DROP INDEX #{quote_column_name(index_name)}"
     end
 
@@ -215,14 +246,16 @@ module ArJdbc
     # Example:
     #   rename_table('octopuses', 'octopi')
     def rename_table(table_name, new_name)
+      schema_cache.clear_data_source_cache!(table_name.to_s)
+      schema_cache.clear_data_source_cache!(new_name.to_s)
       exec_query "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}"
       rename_table_indexes(table_name, new_name)
     end
 
-    def add_column(table_name, column_name, type, options = {}) #:nodoc:
+    def add_column(table_name, column_name, type, **options) #:nodoc:
       if invalid_alter_table_type?(type, options)
         alter_table(table_name) do |definition|
-          definition.column(column_name, type, options)
+          definition.column(column_name, type, **options)
         end
       else
         super
@@ -255,16 +288,11 @@ module ArJdbc
       end
     end
 
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+    def change_column(table_name, column_name, type, **options) #:nodoc:
       alter_table(table_name) do |definition|
         definition[column_name].instance_eval do
           self.type    = type
-          self.limit   = options[:limit] if options.include?(:limit)
-          self.default = options[:default] if options.include?(:default)
-          self.null    = options[:null] if options.include?(:null)
-          self.precision = options[:precision] if options.include?(:precision)
-          self.scale   = options[:scale] if options.include?(:scale)
-          self.collation = options[:collation] if options.include?(:collation)
+            self.options.merge!(options)
         end
       end
     end
@@ -313,12 +341,17 @@ module ArJdbc
         sql << " ON CONFLICT #{insert.conflict_target} DO NOTHING"
       elsif insert.update_duplicates?
         sql << " ON CONFLICT #{insert.conflict_target} DO UPDATE SET "
+        sql << insert.touch_model_timestamps_unless { |column| "#{column} IS excluded.#{column}" }
         sql << insert.updatable_columns.map { |column| "#{column}=excluded.#{column}" }.join(",")
       end
 
       sql
     end
 
+    def shared_cache?
+      config[:properties] && config[:properties][:shared_cache] == true
+    end
+
     def get_database_version # :nodoc:
       SQLite3Adapter::Version.new(query_value("SELECT sqlite_version(*)"))
     end
@@ -327,15 +360,6 @@ module ArJdbc
       "DELETE FROM #{quote_table_name(table_name)}"
     end
 
-    def build_truncate_statements(*table_names)
-      table_names.flatten.map { |table_name| build_truncate_statement table_name }
-    end
-
-    def truncate(table_name, name = nil)
-      ActiveRecord::Base.clear_query_caches_for_current_thread if @query_cache_enabled
-      execute(build_truncate_statement(table_name), name)
-    end
-
     def check_version
       if database_version < "3.8.0"
         raise "Your version of SQLite (#{database_version}) is too old. Active Record supports SQLite >= 3.8."
@@ -349,11 +373,6 @@ module ArJdbc
       999
     end
 
-    def initialize_type_map(m = type_map)
-      super
-      register_class_with_limit m, %r(int)i, SQLite3Integer
-    end
-
     def table_structure(table_name)
       structure = exec_query("PRAGMA table_info(#{quote_table_name(table_name)})", "SCHEMA")
       raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure.empty?
@@ -368,7 +387,12 @@ module ArJdbc
         options[:null] == false && options[:default].nil?
     end
 
-    def alter_table(table_name, foreign_keys = foreign_keys(table_name), **options)
+    def alter_table(
+      table_name,
+      foreign_keys = foreign_keys(table_name),
+      check_constraints = check_constraints(table_name),
+      **options
+    )
       altered_table_name = "a#{table_name}"
 
       caller = lambda do |definition|
@@ -378,7 +402,11 @@ module ArJdbc
             fk.options[:column] = column
           end
           to_table = strip_table_name_prefix_and_suffix(fk.to_table)
-          definition.foreign_key(to_table, fk.options)
+          definition.foreign_key(to_table, **fk.options)
+        end
+
+        check_constraints.each do |chk|
+          definition.check_constraint(chk.expression, **chk.options)
         end
 
         yield definition if block_given?
@@ -400,11 +428,12 @@ module ArJdbc
     def copy_table(from, to, options = {})
       from_primary_key = primary_key(from)
       options[:id] = false
-      create_table(to, options) do |definition|
+      create_table(to, **options) do |definition|
         @definition = definition
         if from_primary_key.is_a?(Array)
           @definition.primary_keys from_primary_key
         end
+
         columns(from).each do |column|
           column_name = options[:rename] ?
             (options[:rename][column.name] ||
@@ -432,7 +461,7 @@ module ArJdbc
         name = index.name
         # indexes sqlite creates for internal use start with `sqlite_` and
         # don't need to be copied
-        next if name.starts_with?("sqlite_")
+        next if name.start_with?("sqlite_")
         if to == "a#{from}"
           name = "t#{name}"
         elsif from == "a#{to}"
@@ -449,10 +478,10 @@ module ArJdbc
 
         unless columns.empty?
           # index name can't be the same
-          opts = { name: name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), internal: true }
-          opts[:unique] = true if index.unique
-          opts[:where] = index.where if index.where
-          add_index(to, columns, opts)
+          options = { name: name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), internal: true }
+          options[:unique] = true if index.unique
+          options[:where] = index.where if index.where
+          add_index(to, columns, **options)
         end
       end
     end
@@ -517,7 +546,7 @@ module ArJdbc
           collation_hash[$1] = $2 if COLLATE_REGEX =~ column_string
         end
 
-        basic_structure.map! do |column|
+        basic_structure.map do |column|
           column_name = column["name"]
 
           if collation_hash.has_key? column_name
@@ -539,18 +568,6 @@ module ArJdbc
       execute("PRAGMA foreign_keys = ON", "SCHEMA")
     end
 
-    # DIFFERENCE: FQN
-    class SQLite3Integer < ::ActiveRecord::Type::Integer # :nodoc:
-      private
-      def _limit
-        # INTEGER storage class can be stored 8 bytes value.
-        # See https://www.sqlite.org/datatype3.html#storage_classes_and_datatypes
-        limit || 8
-      end
-    end
-
-    # DIFFERENCE: FQN
-    ::ActiveRecord::Type.register(:integer, SQLite3Integer, adapter: :sqlite3)
   end
   # DIFFERENCE: A registration here is moved down to concrete class so we are not registering part of an adapter.
 end
@@ -671,7 +688,9 @@ module ActiveRecord::ConnectionAdapters
     end
 
     def begin_isolated_db_transaction(isolation)
-      raise ActiveRecord::TransactionIsolationError, 'adapter does not support setting transaction isolation'
+      raise ActiveRecord::TransactionIsolationError, "SQLite3 only supports the `read_uncommitted` transaction isolation level" if isolation != :read_uncommitted
+      raise StandardError, "You need to enable the shared-cache mode in SQLite mode before attempting to change the transaction isolation level" unless shared_cache?
+      super
     end
 
     # SQLite driver doesn't support all types of insert statements with executeUpdate so
@@ -707,5 +726,23 @@ module ActiveRecord::ConnectionAdapters
         total_sql
       end
     end
+
+    def initialize_type_map(m = type_map)
+      super
+      register_class_with_limit m, %r(int)i, SQLite3Integer
+    end
+
+    # DIFFERENCE: FQN
+    class SQLite3Integer < ::ActiveRecord::Type::Integer # :nodoc:
+      private
+      def _limit
+        # INTEGER storage class can be stored 8 bytes value.
+        # See https://www.sqlite.org/datatype3.html#storage_classes_and_datatypes
+        limit || 8
+      end
+    end
+
+    # DIFFERENCE: FQN
+    ::ActiveRecord::Type.register(:integer, SQLite3Integer, adapter: :sqlite3)
   end
 end

data/lib/arjdbc/sqlite3/connection_methods.rb

@@ -35,7 +35,17 @@ ArJdbc::ConnectionMethods.module_eval do
       # * http://sqlite.org/c3ref/open.html
       # * http://sqlite.org/c3ref/c_open_autoproxy.html
       # => 0x01 = readonly, 0x40 = uri (default in JDBC)
-      config[:properties][:open_mode] = 0x01 | 0x40
+      config[:properties][:open_mode] = ::SQLite3::Constants::Open::READONLY | ::SQLite3::Constants::Open::URI
+    end
+
+    if config[:flags]
+      config[:properties][:open_mode] ||= 0
+      config[:properties][:open_mode] |= config[:flags]
+
+      # JDBC driver has an extra flag for it
+      if config[:flags] & ::SQLite3::Constants::Open::SHAREDCACHE != 0
+        config[:properties][:shared_cache] = true
+      end
     end
 
     timeout = config[:timeout]

data/lib/arjdbc/tasks/databases.rake

@@ -5,15 +5,17 @@ module ActiveRecord::Tasks
   DatabaseTasks.module_eval do
 
     # @override patched to adapt jdbc configuration
-    def each_current_configuration(environment, spec_name = nil)
+    def each_current_configuration(environment, name = nil)
       environments = [environment]
       environments << 'test' if environment == 'development'
 
       environments.each do |env|
         ActiveRecord::Base.configurations.configs_for(env_name: env).each do |db_config|
-          next if spec_name && spec_name != db_config.spec_name
+          next if name && name != db_config.name
 
-          yield adapt_jdbc_config(db_config.config), db_config.spec_name, env unless db_config.config['database'].blank?
+          if db_config.database
+            yield adapt_jdbc_config(db_config), db_config.name, env
+          end
         end
       end
     end
@@ -21,21 +23,24 @@ module ActiveRecord::Tasks
     # @override patched to adapt jdbc configuration
     def each_local_configuration
       ActiveRecord::Base.configurations.configs_for.each do |db_config|
-        next unless db_config.config['database']
+        next unless db_config.database
 
-        if local_database?(db_config.config)
-          yield adapt_jdbc_config(db_config.config)
+        if local_database?(db_config)
+          yield adapt_jdbc_config(db_config)
         else
-          $stderr.puts "This task only modifies local databases. #{db_config.config['database']} is on a remote host."
+          $stderr.puts "This task only modifies local databases. #{db_config.database} is on a remote host."
         end
       end
     end
 
     private
 
-    def adapt_jdbc_config(config)
-      return config unless config['adapter']
-      config.merge 'adapter' => config['adapter'].sub(/^jdbc/, '')
+    def adapt_jdbc_config(db_config)
+      if db_config.adapter.start_with? 'jdbc'
+        config = db_config.configuration_hash.merge(adapter: db_config.adapter.sub(/^jdbc/, ''))
+        db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new(db_config.env_name, db_config.name, config)
+      end
+      db_config
     end
 
   end

data/lib/arjdbc/version.rb

@@ -1,3 +1,3 @@
 module ArJdbc
-  VERSION = '60.3'
+  VERSION = '61.0'
 end

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

@@ -86,6 +86,7 @@ import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.ext.bigdecimal.RubyBigDecimal;
 import org.jruby.ext.date.RubyDate;
+import org.jruby.ext.date.RubyDateTime;
 import org.jruby.javasupport.JavaEmbedUtils;
 import org.jruby.javasupport.JavaUtil;
 import org.jruby.runtime.Block;
@@ -124,6 +125,7 @@ public class RubyJdbcConnection extends RubyObject {
     private IRubyObject config;
     private IRubyObject adapter; // the AbstractAdapter instance we belong to
     private volatile boolean connected = true;
+    private RubyClass attributeClass;
 
     private boolean lazy = false; // final once set on initialize
     private boolean jndi; // final once set on initialize
@@ -132,6 +134,7 @@ public class RubyJdbcConnection extends RubyObject {
 
     protected RubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
+        attributeClass = runtime.getModule("ActiveModel").getClass("Attribute");
     }
 
     private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
@@ -359,7 +362,7 @@ public class RubyJdbcConnection extends RubyObject {
             if ( ! connection.getAutoCommit() ) {
                 try {
                     connection.commit();
-                    resetSavepoints(context); // if any
+                    resetSavepoints(context, connection); // if any
                     return context.runtime.newBoolean(true);
                 }
                 finally {
@@ -380,7 +383,7 @@ public class RubyJdbcConnection extends RubyObject {
             if ( ! connection.getAutoCommit() ) {
                 try {
                     connection.rollback();
-                    resetSavepoints(context); // if any
+                    resetSavepoints(context, connection); // if any
                     return context.tru;
                 } finally {
                     connection.setAutoCommit(true);
@@ -516,7 +519,7 @@ public class RubyJdbcConnection extends RubyObject {
         return null;
     }
 
-    protected boolean resetSavepoints(final ThreadContext context) {
+    protected boolean resetSavepoints(final ThreadContext context, final Connection connection) throws SQLException {
         if ( hasInternalVariable("savepoints") ) {
             removeInternalVariable("savepoints");
             return true;
@@ -610,11 +613,7 @@ public class RubyJdbcConnection extends RubyObject {
                 return convertJavaToRuby( connection.unwrap(Connection.class) );
             }
         }
-        catch (AbstractMethodError e) {
-            debugStackTrace(context, e);
-            warn(context, "driver/pool connection does not support unwrapping: " + e);
-        }
-        catch (SQLException e) {
+        catch (AbstractMethodError | SQLException e) {
             debugStackTrace(context, e);
             warn(context, "driver/pool connection does not support unwrapping: " + e);
         }
@@ -860,27 +859,25 @@ public class RubyJdbcConnection extends RubyObject {
      */
     @JRubyMethod(name = "execute_insert_pk", required = 2)
     public IRubyObject execute_insert_pk(final ThreadContext context, final IRubyObject sql, final IRubyObject pk) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                Statement statement = null;
-                final String query = sqlString(sql);
-                try {
-
-                    statement = createStatement(context, connection);
+        return withConnection(context, connection -> {
+            Statement statement = null;
+            final String query = sqlString(sql);
+            try {
 
-                    if (pk == context.nil || pk == context.fals || !supportsGeneratedKeys(connection)) {
-                        statement.executeUpdate(query, Statement.RETURN_GENERATED_KEYS);
-                    } else {
-                        statement.executeUpdate(query, createStatementPk(pk));
-                    }
+                statement = createStatement(context, connection);
 
-                    return mapGeneratedKeys(context, connection, statement);
-                } catch (final SQLException e) {
-                    debugErrorSQL(context, query);
-                    throw e;
-                } finally {
-                    close(statement);
+                if (pk == context.nil || pk == context.fals || !supportsGeneratedKeys(connection)) {
+                    statement.executeUpdate(query, Statement.RETURN_GENERATED_KEYS);
+                } else {
+                    statement.executeUpdate(query, createStatementPk(pk));
                 }
+
+                return mapGeneratedKeys(context, connection, statement);
+            } catch (final SQLException e) {
+                debugErrorSQL(context, query);
+                throw e;
+            } finally {
+                close(statement);
             }
         });
     }
@@ -903,26 +900,24 @@ public class RubyJdbcConnection extends RubyObject {
     @JRubyMethod(name = "execute_insert_pk", required = 3)
     public IRubyObject execute_insert_pk(final ThreadContext context, final IRubyObject sql, final IRubyObject binds,
                                          final IRubyObject pk) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                PreparedStatement statement = null;
-                final String query = sqlString(sql);
-                try {
-                    if (pk == context.nil || pk == context.fals || !supportsGeneratedKeys(connection)) {
-                        statement = connection.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
-                    } else {
-                        statement = connection.prepareStatement(query, createStatementPk(pk));
-                    }
-
-                    setStatementParameters(context, connection, statement, (RubyArray) binds);
-                    statement.executeUpdate();
-                    return mapGeneratedKeys(context, connection, statement);
-                } catch (final SQLException e) {
-                    debugErrorSQL(context, query);
-                    throw e;
-                } finally {
-                    close(statement);
+        return withConnection(context, connection -> {
+            PreparedStatement statement = null;
+            final String query = sqlString(sql);
+            try {
+                if (pk == context.nil || pk == context.fals || !supportsGeneratedKeys(connection)) {
+                    statement = connection.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
+                } else {
+                    statement = connection.prepareStatement(query, createStatementPk(pk));
                 }
+
+                setStatementParameters(context, connection, statement, (RubyArray) binds);
+                statement.executeUpdate();
+                return mapGeneratedKeys(context, connection, statement);
+            } catch (final SQLException e) {
+                debugErrorSQL(context, query);
+                throw e;
+            } finally {
+                close(statement);
             }
         });
     }
@@ -1012,12 +1007,12 @@ public class RubyJdbcConnection extends RubyObject {
                     binds = null;
                 } else {                              // (sql, binds)
                     maxRows = 0;
-                    binds = (RubyArray) TypeConverter.checkArrayType(args[1]);
+                    binds = (RubyArray) TypeConverter.checkArrayType(context, args[1]);
                 }
                 break;
             case 3:                                   // (sql, max_rows, binds)
                 maxRows = RubyNumeric.fix2int(args[1]);
-                binds = (RubyArray) TypeConverter.checkArrayType(args[2]);
+                binds = (RubyArray) TypeConverter.checkArrayType(context, args[2]);
                 break;
             default:                                  // (sql) 1-arg
                 maxRows = 0;
@@ -1106,6 +1101,28 @@ public class RubyJdbcConnection extends RubyObject {
         });
     }
 
+    @JRubyMethod(required = 1)
+    public IRubyObject get_first_value(final ThreadContext context, final IRubyObject sql) {
+        return withConnection(context, connection -> {
+            Statement statement = null;
+            final String query = sqlString(sql);
+            try {
+                statement = createStatement(context, connection);
+                statement.execute(query);
+                ResultSet rs = statement.getResultSet();
+                if (rs == null || !rs.next()) return context.nil;
+
+                return jdbcToRuby(context, context.getRuntime(), 1, rs.getMetaData().getColumnType(1), rs);
+
+            } catch (final SQLException e) {
+                debugErrorSQL(context, query);
+                throw e;
+            } finally {
+                close(statement);
+            }
+        });
+    }
+
     /**
      * Prepares a query, returns a wrapped PreparedStatement. This takes care of exception wrapping
      * @param context which context this method is executing on.
@@ -2402,9 +2419,16 @@ public class RubyJdbcConnection extends RubyObject {
             final Connection connection, final PreparedStatement statement,
             final int index, IRubyObject attribute) throws SQLException {
 
-        //debugMessage(context, attribute);
-        final int type = jdbcTypeForAttribute(context, attribute);
-        IRubyObject value = valueForDatabase(context, attribute);
+        final IRubyObject value;
+        final int type;
+
+        if (attributeClass.isInstance(attribute)) {
+            type = jdbcTypeForAttribute(context, attribute);
+            value = valueForDatabase(context, attribute);
+        } else {
+            type = jdbcTypeForPrimitiveAttribute(context, attribute);
+            value = attribute;
+        }
 
         // All the set methods were calling this first so save a method call in the nil case
         if ( value == context.nil ) {
@@ -2520,6 +2544,34 @@ public class RubyJdbcConnection extends RubyObject {
         return Types.OTHER; // -1 as well as 0 are used in Types
     }
 
+    protected String internedTypeForPrimitive(final ThreadContext context, final IRubyObject value) throws SQLException {
+        if (value instanceof RubyString) {
+            return "string";
+        }
+        if (value instanceof RubyInteger) {
+            return "integer";
+        }
+        if (value instanceof RubyNumeric) {
+            return "float";
+        }
+        if (value instanceof RubyTime || value instanceof RubyDateTime) {
+            return "timestamp";
+        }
+        if (value instanceof RubyDate) {
+            return "date";
+        }
+        if (value instanceof RubyBoolean) {
+            return "boolean";
+        }
+        return "string";
+    }
+
+    protected Integer jdbcTypeForPrimitiveAttribute(final ThreadContext context,
+                                                    final IRubyObject attribute) throws SQLException {
+        final String internedType = internedTypeForPrimitive(context, attribute);
+        return jdbcTypeFor(internedType);
+    }
+
     protected Integer jdbcTypeFor(final String type) {
         return JDBC_TYPE_FOR.get(type);
     }
@@ -2531,7 +2583,9 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     protected static IRubyObject attributeSQLType(final ThreadContext context, final IRubyObject attribute) {
-        return attributeType(context, attribute).callMethod(context, "type");
+        final IRubyObject type = attributeType(context, attribute);
+        if (type != null) return type.callMethod(context, "type");
+        return context.nil;
     }
 
     private final CachingCallSite value_site = new FunctionalCachingCallSite("value"); // AR::Attribute#value
@@ -2544,23 +2598,7 @@ public class RubyJdbcConnection extends RubyObject {
 
         final IRubyObject value = value_site.call(context, attribute, attribute);
 
-        if (value instanceof RubyInteger) {
-            return "integer";
-        }
-
-        if (value instanceof RubyNumeric) {
-            return "float";
-        }
-
-        if (value instanceof RubyTime) {
-            return "timestamp";
-        }
-
-        if (value instanceof RubyBoolean) {
-            return "boolean";
-        }
-
-        return "string";
+        return internedTypeForPrimitive(context, value);
     }
 
     protected final RubyTime timeInDefaultTimeZone(final ThreadContext context, final IRubyObject value) {