activerecord-jdbc-alt-adapter 51.7.0-java → 52.2.0-java

data/lib/arjdbc/postgresql/connection_methods.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 ArJdbc::ConnectionMethods.module_eval do
   def postgresql_connection(config)
-    config = config.deep_dup
     # NOTE: this isn't "really" necessary but Rails (in tests) assumes being able to :
     #   ActiveRecord::Base.postgresql_connection ActiveRecord::Base.configurations['arunit'].merge(:insert_returning => false)
     # ... while using symbols by default but than configurations returning string keys ;(
@@ -17,8 +16,7 @@ ArJdbc::ConnectionMethods.module_eval do
       ::Jdbc::Postgres.load_driver(:require) if defined?(::Jdbc::Postgres.load_driver)
     rescue LoadError # assuming driver.jar is on the class-path
     end
-    driver = (config[:driver] ||=
-      defined?(::Jdbc::Postgres.driver_name) ? ::Jdbc::Postgres.driver_name : 'org.postgresql.Driver')
+    driver = config[:driver] ||= 'org.postgresql.Driver'
 
     host = config[:host] ||= ( config[:hostaddr] || ENV['PGHOST'] || 'localhost' )
     port = config[:port] ||= ( ENV['PGPORT'] || 5432 )

data/lib/arjdbc/postgresql/oid_types.rb

@@ -88,12 +88,6 @@ module ArJdbc
         @extensions ||= super
       end
 
-      # @override
-      def lookup_cast_type(sql_type)
-        oid = execute("SELECT #{quote(sql_type)}::regtype::oid", "SCHEMA")
-        super oid.first['oid'].to_i
-      end
-
       def get_oid_type(oid, fmod, column_name, sql_type = '') # :nodoc:
         if !type_map.key?(oid)
           load_additional_types(type_map, oid)
@@ -120,7 +114,7 @@ module ArJdbc
 
       private
 
-      def initialize_type_map(m)
+      def initialize_type_map(m = type_map)
         register_class_with_limit m, 'int2', Type::Integer
         register_class_with_limit m, 'int4', Type::Integer
         register_class_with_limit m, 'int8', Type::Integer
@@ -136,13 +130,13 @@ module ArJdbc
         register_class_with_limit m, 'bit', OID::Bit
         register_class_with_limit m, 'varbit', OID::BitVarying
         m.alias_type 'timestamptz', 'timestamp'
-        m.register_type 'date', Type::Date.new
+        m.register_type 'date', OID::Date.new
 
         m.register_type 'money', OID::Money.new
         m.register_type 'bytea', OID::Bytea.new
         m.register_type 'point', OID::Point.new
         m.register_type 'hstore', OID::Hstore.new
-        m.register_type 'json', OID::Json.new
+        m.register_type 'json', Type::Json.new
         m.register_type 'jsonb', OID::Jsonb.new
         m.register_type 'cidr', OID::Cidr.new
         m.register_type 'inet', OID::Inet.new
@@ -228,7 +222,7 @@ module ArJdbc
             query += "WHERE t.typname = '%s' AND ns.nspname = ANY(current_schemas(true))" % oid
           end
         else
-          query += initializer.query_conditions_for_initial_load(type_map)
+          query += initializer.query_conditions_for_initial_load
         end
 
         records = execute(query, 'SCHEMA')
@@ -242,12 +236,13 @@ module ArJdbc
       ActiveRecord::Type.register(:bit_varying, OID::BitVarying, adapter: :postgresql)
       ActiveRecord::Type.register(:binary, OID::Bytea, adapter: :postgresql)
       ActiveRecord::Type.register(:cidr, OID::Cidr, adapter: :postgresql)
+      ActiveRecord::Type.register(:date, OID::Date, adapter: :postgresql)
       ActiveRecord::Type.register(:datetime, OID::DateTime, adapter: :postgresql)
       ActiveRecord::Type.register(:decimal, OID::Decimal, adapter: :postgresql)
       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(:json, OID::Json, 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)
       ActiveRecord::Type.register(:point, OID::Point, adapter: :postgresql)

data/lib/arjdbc/sqlite3/adapter.rb

@@ -12,6 +12,7 @@ require "active_record/connection_adapters/sqlite3/schema_creation"
 require "active_record/connection_adapters/sqlite3/schema_definitions"
 require "active_record/connection_adapters/sqlite3/schema_dumper"
 require "active_record/connection_adapters/sqlite3/schema_statements"
+require "active_support/core_ext/class/attribute"
 
 module ArJdbc
   # All the code in this module is a copy of ConnectionAdapters::SQLite3Adapter from active_record 5.
@@ -33,11 +34,10 @@ module ArJdbc
 
     # DIFFERENCE: FQN
     include ::ActiveRecord::ConnectionAdapters::SQLite3::Quoting
-    include ::ActiveRecord::ConnectionAdapters::SQLite3::ColumnDumper
     include ::ActiveRecord::ConnectionAdapters::SQLite3::SchemaStatements
 
     NATIVE_DATABASE_TYPES = {
-        primary_key:  "INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL",
+        primary_key:  "integer PRIMARY KEY AUTOINCREMENT NOT NULL",
         string:       { name: "varchar" },
         text:         { name: "text" },
         integer:      { name: "integer" },
@@ -47,9 +47,13 @@ module ArJdbc
         time:         { name: "time" },
         date:         { name: "date" },
         binary:       { name: "blob" },
-        boolean:      { name: "boolean" }
+        boolean:      { name: "boolean" },
+        json:         { name: "json" },
     }
 
+    # DIFFERENCE: class_attribute in original adapter is moved down to our section which is a class
+    #  since we cannot define it here in the module (original source this is a class).
+
     class StatementPool < ConnectionAdapters::StatementPool
       private
 
@@ -58,24 +62,10 @@ module ArJdbc
       end
     end
 
-    def update_table_definition(table_name, base) # :nodoc:
-      # DIFFERENCE: FQN
-      ::ActiveRecord::ConnectionAdapters::SQLite3::Table.new(table_name, base)
-    end
-
-    def schema_creation # :nodoc:
-      # DIFFERENCE: FQN
-      ::ActiveRecord::ConnectionAdapters::SQLite3::SchemaCreation.new self
-    end
-
-    def arel_visitor # :nodoc:
-      Arel::Visitors::SQLite.new(self)
-    end
-
     def initialize(connection, logger, connection_options, config)
       super(connection, logger, config)
 
-      @active     = nil
+      @active     = true
       @statements = StatementPool.new(self.class.type_cast_config_to_integer(config[:statement_limit]))
 
       configure_connection
@@ -93,12 +83,6 @@ module ArJdbc
       sqlite_version >= "3.8.0"
     end
 
-    # Returns true, since this connection adapter supports prepared statement
-    # caching.
-    def supports_statement_cache?
-      true
-    end
-
     def requires_reloading?
       true
     end
@@ -120,7 +104,7 @@ module ArJdbc
     end
 
     def active?
-      @active != false
+      @active
     end
 
     # Disconnects from the database if already connected. Otherwise, this
@@ -248,53 +232,6 @@ module ArJdbc
 
     # SCHEMA STATEMENTS ========================================
 
-    def new_column_from_field(table_name, field) # :nondoc:
-      case field["dflt_value"]
-      when /^null$/i
-        field["dflt_value"] = nil
-      when /^'(.*)'$/m
-        field["dflt_value"] = $1.gsub("''", "'")
-      when /^"(.*)"$/m
-        field["dflt_value"] = $1.gsub('""', '"')
-      end
-
-      collation = field["collation"]
-      sql_type = field["type"]
-      type_metadata = fetch_type_metadata(sql_type)
-      new_column(field["name"], field["dflt_value"], type_metadata, field["notnull"].to_i == 0, table_name, nil, collation)
-    end
-
-    # Returns an array of indexes for the given table.
-    def indexes(table_name, name = nil) #:nodoc:
-      if name
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Passing name to #indexes is deprecated without replacement.
-          MSG
-      end
-
-      exec_query("PRAGMA index_list(#{quote_table_name(table_name)})", "SCHEMA").map do |row|
-        sql = <<-SQL
-            SELECT sql
-            FROM sqlite_master
-            WHERE name=#{quote(row['name'])} AND type='index'
-            UNION ALL
-            SELECT sql
-            FROM sqlite_temp_master
-            WHERE name=#{quote(row['name'])} AND type='index'
-          SQL
-        index_sql = exec_query(sql).first["sql"]
-        match = /\sWHERE\s+(.+)$/i.match(index_sql)
-        where = match[1] if match
-        IndexDefinition.new(
-          table_name,
-          row["name"],
-          row["unique"] != 0,
-          exec_query("PRAGMA index_info('#{row['name']}')", "SCHEMA").map { |col|
-            col["name"]
-          }, nil, nil, where)
-      end
-    end
-
     def primary_keys(table_name) # :nodoc:
       pks = table_structure(table_name).select { |f| f["pk"] > 0 }
       pks.sort_by { |f| f["pk"] }.map { |f| f["name"] }
@@ -314,19 +251,20 @@ module ArJdbc
       rename_table_indexes(table_name, new_name)
     end
 
-    # See: http://www.sqlite.org/lang_altertable.html
-    # SQLite has an additional restriction on the ALTER TABLE statement
-    def valid_alter_table_type?(type)
-      type.to_sym != :primary_key
+    # DIFFERENCE: deprecated causes a JRuby 9.1 bug where "super" calls itself -> do inline
+    def valid_alter_table_type?(type, options = {})
+      ActiveSupport::Deprecation.deprecation_warning(__method__)
+      !invalid_alter_table_type?(type, options)
     end
+    #deprecate :valid_alter_table_type?
 
     def add_column(table_name, column_name, type, options = {}) #:nodoc:
-      if valid_alter_table_type?(type) && !options[:primary_key]
-        super(table_name, column_name, type, options)
-      else
+      if invalid_alter_table_type?(type, options)
         alter_table(table_name) do |definition|
           definition.column(column_name, type, options)
         end
+      else
+        super
       end
     end
 
@@ -391,8 +329,32 @@ module ArJdbc
         ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(table_name, row["table"], options)
       end
     end
+
+    def insert_fixtures(rows, table_name)
+      ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          `insert_fixtures` is deprecated and will be removed in the next version of Rails.
+          Consider using `insert_fixtures_set` for performance improvement.
+      MSG
+      insert_fixtures_set(table_name => rows)
+    end
+
+    def insert_fixtures_set(fixture_set, tables_to_delete = [])
+      disable_referential_integrity do
+        transaction(requires_new: true) do
+          tables_to_delete.each { |table| delete "DELETE FROM #{quote_table_name(table)}", "Fixture Delete" }
+
+          fixture_set.each do |table_name, rows|
+            rows.each { |row| insert_fixture(row, table_name) }
+          end
+        end
+      end
+    end
     
     private
+    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")
@@ -400,7 +362,13 @@ module ArJdbc
       table_structure_with_collation(table_name, structure)
     end
     alias column_definitions table_structure
-    
+
+    # See: https://www.sqlite.org/lang_altertable.html
+    # SQLite has an additional restriction on the ALTER TABLE statement
+    def invalid_alter_table_type?(type, options)
+      type.to_sym == :primary_key || options[:primary_key]
+    end
+
     def alter_table(table_name, options = {}) #:nodoc:
       altered_table_name = "a#{table_name}"
       caller = lambda { |definition| yield definition if block_given? }
@@ -551,23 +519,28 @@ module ArJdbc
       end
     end
 
-    def create_table_definition(*args)
-      # DIFFERENCE: FQN
-      ::ActiveRecord::ConnectionAdapters::SQLite3::TableDefinition.new(*args)
-    end
-
-    def extract_foreign_key_action(specifier)
-      case specifier
-      when "CASCADE"; :cascade
-      when "SET NULL"; :nullify
-      when "RESTRICT"; :restrict
-      end
+    def arel_visitor
+      Arel::Visitors::SQLite.new(self)
     end
 
     def configure_connection
       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
 
 module ActiveRecord::ConnectionAdapters
@@ -677,6 +650,25 @@ module ActiveRecord::ConnectionAdapters
     include ArJdbc::Abstract::StatementCache
     include ArJdbc::Abstract::TransactionSupport
 
+    # Note: This is part of original AR sqlite3_adapter.rb and not an override by us.  This is to just
+    # work around our copy of Sqlite3Adapter being a module above and not a class.
+    ##
+    # :singleton-method:
+    # Indicates whether boolean values are stored in sqlite3 databases as 1
+    # and 0 or 't' and 'f'. Leaving <tt>ActiveRecord::ConnectionAdapters::SQLite3Adapter.represent_boolean_as_integer</tt>
+    # set to false is deprecated. SQLite databases have used 't' and 'f' to
+    # serialize boolean values and must have old data converted to 1 and 0
+    # (its native boolean serialization) before setting this flag to true.
+    # Conversion can be accomplished by setting up a rake task which runs
+    #
+    #   ExampleModel.where("boolean_column = 't'").update_all(boolean_column: 1)
+    #   ExampleModel.where("boolean_column = 'f'").update_all(boolean_column: 0)
+    # for all models and all boolean columns, after which the flag must be set
+    # to true by adding the following to your <tt>application.rb</tt> file:
+    #
+    #   Rails.application.config.active_record.sqlite3.represent_boolean_as_integer = true
+    class_attribute :represent_boolean_as_integer, default: false
+
     def supports_transaction_isolation?
       false
     end
@@ -704,5 +696,8 @@ module ActiveRecord::ConnectionAdapters
     def self.jdbc_connection_class
       ::ActiveRecord::ConnectionAdapters::SQLite3JdbcConnection
     end
+
+    # Note: This is not an override of ours but a moved line from AR Sqlite3Adapter to register ours vs our copied module (which would be their class).
+#    ActiveSupport.run_load_hooks(:active_record_sqlite3adapter, SQLite3Adapter)
   end
 end

data/lib/arjdbc/sqlite3/connection_methods.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 ArJdbc::ConnectionMethods.module_eval do
   def sqlite3_connection(config)
-    config = config.deep_dup
     config[:adapter_spec] ||= ::ArJdbc::SQLite3
     config[:adapter_class] = ActiveRecord::ConnectionAdapters::SQLite3Adapter unless config.key?(:adapter_class)
 

data/lib/arjdbc/tasks/database_tasks.rb

@@ -9,6 +9,7 @@ module ArJdbc
     register_tasks(/mariadb/, ActiveRecord::Tasks::MySQLDatabaseTasks)
 
     require 'arjdbc/tasks/jdbc_database_tasks'
+    require 'arjdbc/tasks/sqlite_database_tasks_patch'
     require 'arjdbc/tasks/mssql_database_tasks'
     #require 'arjdbc/tasks/db2_database_tasks'
     #require 'arjdbc/tasks/derby_database_tasks'

data/lib/arjdbc/tasks/sqlite_database_tasks_patch.rb

@@ -0,0 +1,17 @@
+# patch SQLiteDatabaseTasks for JRuby
+# The problem is that JRuby does not yet support the "out:" option for
+# Kernel.system(). Uses plain output redirection as a workaround.
+
+require 'active_record/tasks/sqlite_database_tasks'
+require 'shellwords'
+
+module ActiveRecord
+  module Tasks
+    class SQLiteDatabaseTasks
+      private
+        def run_cmd(cmd, args, out)
+          `#{cmd} #{Shellwords.join(args)} > "#{out}"`
+        end
+    end
+  end
+end

data/lib/arjdbc/version.rb

@@ -1,3 +1,3 @@
 module ArJdbc
-  VERSION = '51.7.0'
+  VERSION = '52.2.0'
 end

data/rakelib/01-tomcat.rake

@@ -1,6 +1,6 @@
 namespace :'tomcat-jndi' do # contains a FS JNDI impl (for tests)
 
-  TOMCAT_MAVEN_REPO = 'https://repo1.maven.org/maven2/org/apache/tomcat'
+  TOMCAT_MAVEN_REPO = 'http://repo2.maven.org/maven2/org/apache/tomcat'
   TOMCAT_VERSION = '7.0.54'
 
   DOWNLOAD_DIR = File.expand_path('../test/jars', File.dirname(__FILE__))
@@ -48,4 +48,4 @@ namespace :'tomcat-jndi' do # contains a FS JNDI impl (for tests)
     rm jar_path if File.exist?(jar_path)
   end
 
-end
+end

data/rakelib/02-test.rake

@@ -76,6 +76,8 @@ end
   test_task_for adapter, :desc => "Run tests against #{adapter} (ensure driver is on class-path)"
 end
 
+#test_task_for :MSSQL, :name => 'test_sqlserver', :driver => nil, :database_name => 'MS-SQL using SQLJDBC'
+
 test_task_for :AS400, :desc => "Run tests against AS400 (DB2) (ensure driver is on class-path)",
               :files => FileList["test/db2*_test.rb"] + FileList["test/db/db2/*_test.rb"]
 

data/rakelib/rails.rake

@@ -57,7 +57,7 @@ namespace :rails do
       ruby_opts_string += " -C \"#{ar_path}\""
       ruby_opts_string += " -rbundler/setup"
       ruby_opts_string += " -rminitest -rminitest/excludes" unless ENV['NO_EXCLUDES'].eql?('true')
-      file_list = ENV["TEST"] ? FileList[ ENV["TEST"].split(',') ] : test_files_finder.call
+      file_list = ENV["TEST"] ? FileList[ ENV["TEST"] ] : test_files_finder.call
       file_list_string = file_list.map { |fn| "\"#{fn}\"" }.join(' ')
       # test_loader_code = "-e \"ARGV.each{|f| require f}\"" # :direct
       option_list = ( ENV["TESTOPTS"] || ENV["TESTOPT"] || ENV["TEST_OPTS"] || '' )

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

@@ -487,7 +487,7 @@ public class RubyJdbcConnection extends RubyObject {
                 savepoint = ((IRubyObject) savepoint).toJava(Savepoint.class);
             }
 
-            releaseSavepoint(connection, (Savepoint) savepoint);
+            connection.releaseSavepoint((Savepoint) savepoint);
             return context.nil;
         }
         catch (SQLException e) {
@@ -495,11 +495,6 @@ public class RubyJdbcConnection extends RubyObject {
         }
     }
 
-    // MSSQL doesn't support releasing savepoints so we make it possible to override the actual release action
-    protected void releaseSavepoint(final Connection connection, final Savepoint savepoint) throws SQLException {
-        connection.releaseSavepoint(savepoint);
-    }
-
     protected static RuntimeException newSavepointNotSetError(final ThreadContext context, final IRubyObject name, final String op) {
         RubyClass StatementInvalid = ActiveRecord(context).getClass("StatementInvalid");
         return context.runtime.newRaiseException(StatementInvalid, "could not " + op + " savepoint: '" + name + "' (not set)");
@@ -727,10 +722,7 @@ public class RubyJdbcConnection extends RubyObject {
 
     private void connectImpl(final boolean forceConnection) throws SQLException {
         setConnection( forceConnection ? newConnection() : null );
-        if (forceConnection) {
-            if (getConnectionImpl() == null) throw new SQLException("Didn't get a connection. Wrong URL?");
-            configureConnection();
-        }
+        if ( forceConnection ) configureConnection();
     }
 
     @JRubyMethod(name = "read_only?")
@@ -888,31 +880,15 @@ public class RubyJdbcConnection extends RubyObject {
         return mapQueryResult(context, connection, resultSet);
     }
 
-    private static String[] createStatementPk(IRubyObject pk) {
-        String[] statementPk;
-        if (pk instanceof RubyArray) {
-            RubyArray ary = (RubyArray) pk;
-            int size = ary.size();
-            statementPk = new String[size];
-            for (int i = 0; i < size; i++) {
-                statementPk[i] = sqlString(ary.eltInternal(i));
-            }
-        } else {
-            statementPk = new String[] { sqlString(pk) };
-        }
-        return statementPk;
-    }
-
     /**
      * Executes an INSERT SQL statement
      * @param context
      * @param sql
-     * @param pk Rails PK
      * @return ActiveRecord::Result
      * @throws SQLException
      */
-    @JRubyMethod(name = "execute_insert_pk", required = 2)
-    public IRubyObject execute_insert_pk(final ThreadContext context, final IRubyObject sql, final IRubyObject pk) {
+    @JRubyMethod(name = "execute_insert", required = 1)
+    public IRubyObject execute_insert(final ThreadContext context, final IRubyObject sql) {
         return withConnection(context, new Callable<IRubyObject>() {
             public IRubyObject call(final Connection connection) throws SQLException {
                 Statement statement = null;
@@ -920,13 +896,7 @@ public class RubyJdbcConnection extends RubyObject {
                 try {
 
                     statement = createStatement(context, connection);
-
-                    if (pk == context.nil || pk == context.fals || !supportsGeneratedKeys(connection)) {
-                        statement.executeUpdate(query, Statement.RETURN_GENERATED_KEYS);
-                    } else {
-                        statement.executeUpdate(query, createStatementPk(pk));
-                    }
-
+                    statement.executeUpdate(query, Statement.RETURN_GENERATED_KEYS);
                     return mapGeneratedKeys(context, connection, statement);
 
                 } catch (final SQLException e) {
@@ -939,35 +909,23 @@ public class RubyJdbcConnection extends RubyObject {
         });
     }
 
-    @Deprecated
-    @JRubyMethod(name = "execute_insert", required = 1)
-    public IRubyObject execute_insert(final ThreadContext context, final IRubyObject sql) {
-        return execute_insert_pk(context, sql, context.nil);
-    }
-
     /**
      * Executes an INSERT SQL statement using a prepared statement
      * @param context
      * @param sql
      * @param binds RubyArray of values to be bound to the query
-     * @param pk Rails PK
      * @return ActiveRecord::Result
      * @throws SQLException
      */
-    @JRubyMethod(name = "execute_insert_pk", required = 3)
-    public IRubyObject execute_insert_pk(final ThreadContext context, final IRubyObject sql, final IRubyObject binds,
-                                         final IRubyObject pk) {
+    @JRubyMethod(name = "execute_insert", required = 2)
+    public IRubyObject execute_insert(final ThreadContext context, final IRubyObject sql, final IRubyObject binds) {
         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));
-                    }
 
+                    statement = connection.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
                     setStatementParameters(context, connection, statement, (RubyArray) binds);
                     statement.executeUpdate();
                     return mapGeneratedKeys(context, connection, statement);
@@ -982,12 +940,6 @@ public class RubyJdbcConnection extends RubyObject {
         });
     }
 
-    @Deprecated
-    @JRubyMethod(name = "execute_insert", required = 2)
-    public IRubyObject execute_insert(final ThreadContext context, final IRubyObject binds, final IRubyObject sql) {
-        return execute_insert_pk(context, sql, binds, context.nil);
-    }
-
     /**
      * Executes an UPDATE (DELETE) SQL statement
      * @param context
@@ -2947,9 +2899,8 @@ public class RubyJdbcConnection extends RubyObject {
             value = value.callMethod(context, "to_date");
         }
 
-        // NOTE: Here we rely in ActiveRecord (ActiveSupport) to get
-        // the date as a string in the database format.
-        statement.setDate(index, Date.valueOf(value.callMethod(context, "to_s", context.runtime.newSymbol("db")).toString()));
+        // NOTE: assuming Date#to_s does right ...
+        statement.setDate(index, Date.valueOf(value.toString()));
     }
 
     protected void setBooleanParameter(final ThreadContext context,
@@ -3976,12 +3927,6 @@ public class RubyJdbcConnection extends RubyObject {
         }
     }
 
-    public static void debugMessage(final ThreadContext context, final IRubyObject obj) {
-        if ( isDebug(context.runtime) ) {
-            debugMessage(context.runtime, obj.callMethod(context, "inspect"));
-        }
-    }
-
     public static void debugMessage(final Ruby runtime, final String msg, final Object e) {
         if ( isDebug(runtime) ) {
             final PrintStream out = runtime != null ? runtime.getOut() : System.out;