Fix statement caching

Using config[:prepared_statements] is not reliable because of different
defaults. Use the proper method instead.

Move the "prepare_statement" call to Java to ensure proper exception wrapping.

Also, while at it, align the method name "cached_statement_key" with
Rails to make PG test actually work.

Author: dr-itz

lib/arjdbc/abstract/database_statements.rb

@@ -26,8 +26,8 @@ def exec_query(sql, name = nil, binds = NO_BINDS, prepare: false)
           log(sql, name) { @connection.execute_query(sql) }
         else
           log(sql, name, binds) do
-            # It seems that #supports_statement_cache? is defined but isn't checked before setting "prepare" (AR 5.0)
-            cached_statement = fetch_cached_statement(sql) if prepare && supports_statement_cache?
+            # this is different from normal AR that always caches
+            cached_statement = fetch_cached_statement(sql) if prepare && @jdbc_statement_cache_enabled
             @connection.execute_prepared_query(sql, binds, cached_statement)
           end
         end

lib/arjdbc/abstract/statement_cache.rb

@@ -23,7 +23,7 @@ def initialize(*args) # (connection, logger, config)
         # Only say we support the statement cache if we are using prepared statements
         # and have a max number of statements defined
         statement_limit = self.class.type_cast_config_to_integer(config[:statement_limit])
-        @jdbc_statement_cache_enabled = config[:prepared_statements] && (statement_limit.nil? || statement_limit > 0)
+        @jdbc_statement_cache_enabled = prepared_statements && (statement_limit.nil? || statement_limit > 0)
 
         @statements = StatementPool.new(statement_limit) # AR (5.0) expects this to be stored as @statements
       end
@@ -34,11 +34,11 @@ def clear_cache!
       end
 
       def delete_cached_statement(sql)
-        @statements.delete(cached_statement_key(sql))
+        @statements.delete(sql_key(sql))
       end
 
       def fetch_cached_statement(sql)
-        @statements[cached_statement_key(sql)] ||= @connection.connection.prepare_statement(sql)
+        @statements[sql_key(sql)] ||= @connection.prepare_statement(sql)
       end
 
       def supports_statement_cache?
@@ -49,7 +49,7 @@ def supports_statement_cache?
 
       # This should be overridden by the adapter if the sql itself
       # is not enough to make the key unique
-      def cached_statement_key(sql)
+      def sql_key(sql)
         sql
       end
 

lib/arjdbc/postgresql/adapter.rb

@@ -736,7 +736,7 @@ def jdbc_connection_class(spec)
 
     # Prepared statements aren't schema aware so we need to make sure we
     # store different PreparedStatement objects for different schemas
-    def cached_statement_key(sql)
+    def sql_key(sql)
       "#{schema_search_path}-#{sql}"
     end
 

src/java/arjdbc/jdbc/RubyJdbcConnection.java

@@ -1112,6 +1112,22 @@ public IRubyObject call(final Connection connection) throws SQLException {
         });
     }
 
+    /**
+     * Prepares a query, returns a wrapped PreparedStatement. This takes care of exception wrapping
+     * @param context which context this method is executing on.
+     * @param sql the query to prepare-
+     * @return a Ruby <code>PreparedStatement</code>
+     */
+    @JRubyMethod(required = 1)
+    public IRubyObject prepare_statement(final ThreadContext context, final IRubyObject sql) {
+        return withConnection(context, new Callable<IRubyObject>() {
+            public IRubyObject call(Connection connection) throws SQLException {
+                final String query = sql.convertToString().getUnicodeValue();
+                return JavaUtil.convertJavaToRuby(context.runtime, connection.prepareStatement(query));
+            }
+        });
+    }
+
     // Called from exec_query in abstract/database_statements
     /**
      * Executes a query and returns the (AR) result.  There are three parameters: