activerecord-jdbc-adapter 5.0.pre1 → 51.0

data/src/java/arjdbc/mysql/MySQLModule.java

@@ -100,9 +100,9 @@ public class MySQLModule {
 
         final Ruby runtime = context.getRuntime();
         final RubyString quoted = runtime.newString(quotedBytes);
-        if ( runtime.is1_9() ) { // only due mysql2 compatibility
-            quoted.associateEncoding( UTF8Encoding.INSTANCE );
-        }
+
+        quoted.associateEncoding(UTF8Encoding.INSTANCE);
+
         return quoted;
     }
 

data/src/java/arjdbc/mysql/MySQLRubyJdbcConnection.java

@@ -26,7 +26,6 @@
 package arjdbc.mysql;
 
 import arjdbc.jdbc.RubyJdbcConnection;
-import arjdbc.jdbc.Callable;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
@@ -43,17 +42,18 @@ import java.util.TimeZone;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import org.joda.time.DateTime;
 import org.jruby.Ruby;
-import org.jruby.RubyArray;
 import org.jruby.RubyClass;
-import org.jruby.RubyFloat;
 import org.jruby.RubyInteger;
-import org.jruby.RubyModule;
 import org.jruby.RubyString;
+import org.jruby.RubyTime;
+import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.TypeConverter;
 
 /**
  *
@@ -79,25 +79,20 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
         return clazz;
     }
 
-    @Override
-    protected boolean doExecute(final Statement statement, final String query)
-        throws SQLException {
-        return statement.execute(query, Statement.RETURN_GENERATED_KEYS);
+    @JRubyMethod
+    public IRubyObject query(final ThreadContext context, final IRubyObject sql) throws SQLException {
+        final String query = sql.convertToString().getUnicodeValue(); // sql
+        return executeUpdate(context, query, false);
     }
 
     @Override
-    protected IRubyObject mapGeneratedKeysOrUpdateCount(final ThreadContext context,
-        final Connection connection, final Statement statement) throws SQLException {
-        final Ruby runtime = context.getRuntime();
-        final IRubyObject key = mapGeneratedKeys(runtime, connection, statement);
-        return ( key == null || key.isNil() ) ? runtime.newFixnum( statement.getUpdateCount() ) : key;
+    protected boolean doExecute(final Statement statement, final String query) throws SQLException {
+        return statement.execute(query, Statement.RETURN_GENERATED_KEYS);
     }
 
     @Override
-    protected IRubyObject jdbcToRuby(
-        final ThreadContext context, final Ruby runtime,
-        final int column, final int type, final ResultSet resultSet)
-        throws SQLException {
+    protected IRubyObject jdbcToRuby(final ThreadContext context, final Ruby runtime,
+        final int column, final int type, final ResultSet resultSet) throws SQLException {
         if ( type == Types.BIT ) {
             final int value = resultSet.getInt(column);
             return resultSet.wasNull() ? runtime.getNil() : runtime.newFixnum(value);
@@ -106,53 +101,50 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
     }
 
     @Override // can not use statement.setTimestamp( int, Timestamp, Calendar )
-    protected void setTimestampParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value.isNil() ) statement.setNull(index, Types.TIMESTAMP);
-        else {
-            value = getTimeInDefaultTimeZone(context, value);
-            if ( value instanceof RubyString ) { // yyyy-[m]m-[d]d hh:mm:ss[.f...]
-                final Timestamp timestamp = Timestamp.valueOf( value.toString() );
-                statement.setTimestamp( index, timestamp ); // assume local time-zone
-            }
-            else { // Time or DateTime ( ActiveSupport::TimeWithZone.to_time )
-                final double time = adjustTimeFromDefaultZone(value);
-                final RubyFloat timeValue = context.getRuntime().newFloat( time );
-                statement.setTimestamp( index, convertToTimestamp(timeValue) );
-            }
-        }
+    protected void setTimestampParameter(ThreadContext context, Connection connection, PreparedStatement statement,
+        int index, IRubyObject value, IRubyObject column, int type) throws SQLException {
+        value = callMethod(context, "time_in_default_timezone", value);
+        TypeConverter.checkType(context, value, context.runtime.getTime());
+        setTimestamp(statement, index, (RubyTime) value, type);
     }
 
-    @Override // can not use statement.setTime( int, Time, Calendar )
-    protected void setTimeParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value.isNil() ) statement.setNull(index, Types.TIME);
-        else {
-            value = getTimeInDefaultTimeZone(context, value);
-            if ( value instanceof RubyString ) {
-                final Time time = Time.valueOf( value.toString() );
-                statement.setTime( index, time ); // assume local time-zone
-            }
-            else { // Time or DateTime ( ActiveSupport::TimeWithZone.to_time )
-                final double timeValue = adjustTimeFromDefaultZone(value);
-                final Time time = new Time(( (long) timeValue ) * 1000); // millis
-                // java.sql.Time is expected to be only up to second precision
-                statement.setTime( index, time );
-            }
-        }
+    @Override
+    protected void setTimeParameter(ThreadContext context, Connection connection, PreparedStatement statement,
+        int index, IRubyObject value, IRubyObject column, int type) throws SQLException {
+        setTimestampParameter(context, connection, statement, index, value, column, type);
     }
 
-    private static double adjustTimeFromDefaultZone(final IRubyObject value) {
-        // Time's to_f is : ( millis * 1000 + usec ) / 1_000_000.0
-        final double time = value.convertToFloat().getDoubleValue(); // to_f
-        // NOTE: MySQL assumes default TZ thus need to adjust to match :
-        final int offset = TimeZone.getDefault().getOffset((long) time * 1000);
-        // Time's to_f is : ( millis * 1000 + usec ) / 1_000_000.0
-        return time - ( offset / 1000.0 );
+    // FIXME: we should detect adapter and not do this timezone offset calculation is it is jdbc version 6+.
+    private void setTimestamp(PreparedStatement statement, int index, RubyTime value, int type) throws SQLException {
+        DateTime dateTime = value.getDateTime();
+        int offset = TimeZone.getDefault().getOffset(dateTime.getMillis()); // JDBC <6.x ignores time zone info (we adjust manually).
+        Timestamp timestamp = new Timestamp(dateTime.getMillis() - offset);
+
+        // 1942-11-30T01:02:03.123_456
+        if (type != Types.DATE && value.getNSec() >= 0) timestamp.setNanos((int) (timestamp.getNanos() + value.getNSec()));
+
+        statement.setTimestamp(index, timestamp);
+    }
+
+    // FIXME: I think we can unify this back to main adapter code since previous conflict involved not using
+    // the raw string return type and not the extra formatting logic.
+    @Override
+    protected IRubyObject timeToRuby(ThreadContext context, Ruby runtime, ResultSet resultSet, int column) throws SQLException {
+        Time value = resultSet.getTime(column);
+
+        if (value == null) return resultSet.wasNull() ? runtime.getNil() : runtime.newString();
+
+        String strValue = value.toString();
+
+        // If time is column type but that time had a precision which included
+        // nanoseconds we used timestamp to save the data.  Since this is conditional
+        // we grab data a second time as a timestamp to look for nsecs.
+        Timestamp nsecTimeHack = resultSet.getTimestamp(column);
+        if (nsecTimeHack.getNanos() != 0) {
+            strValue = String.format("%s.%09d", strValue, nsecTimeHack.getNanos());
+        }
+
+        return RubyString.newUnicodeString(runtime,strValue);
     }
 
     @Override
@@ -192,80 +184,7 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
     }
 
     @Override
-    protected IRubyObject indexes(final ThreadContext context, final String tableName, final String name, final String schemaName) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                final Ruby runtime = context.getRuntime();
-                final RubyModule indexDefinition = getIndexDefinition(runtime);
-                final String jdbcTableName = caseConvertIdentifierForJdbc(connection, tableName);
-                final String jdbcSchemaName = caseConvertIdentifierForJdbc(connection, schemaName);
-                final IRubyObject rubyTableName = RubyString.newUnicodeString(
-                    runtime, caseConvertIdentifierForJdbc(connection, tableName)
-                );
-
-                StringBuilder query = new StringBuilder("SHOW KEYS FROM ");
-                if (jdbcSchemaName != null) {
-                    query.append(jdbcSchemaName).append(".");
-                }
-                query.append(jdbcTableName);
-                query.append(" WHERE key_name != 'PRIMARY'");
-
-                final RubyArray indexes = runtime.newArray(8);
-                PreparedStatement statement = null;
-                ResultSet keySet = null;
-
-                try {
-                    statement = connection.prepareStatement(query.toString());
-                    keySet = statement.executeQuery();
-
-                    String currentKeyName = null;
-
-                    while ( keySet.next() ) {
-                        final String keyName = caseConvertIdentifierForRails(connection, keySet.getString("key_name"));
-
-                        if ( ! keyName.equals(currentKeyName) ) {
-                            currentKeyName = keyName;
-
-                            final boolean nonUnique = keySet.getBoolean("non_unique");
-
-                            IRubyObject[] args = new IRubyObject[] {
-                                rubyTableName, // table_name
-                                RubyString.newUnicodeString(runtime, keyName), // index_name
-                                runtime.newBoolean( ! nonUnique ), // unique
-                                runtime.newArray(), // [] for column names, we'll add to that in just a bit
-                                runtime.newArray() // lengths
-                            };
-
-                            indexes.append( indexDefinition.callMethod(context, "new", args) ); // IndexDefinition.new
-                        }
-
-                        IRubyObject lastIndexDef = indexes.isEmpty() ? null : indexes.entry(-1);
-                        if ( lastIndexDef != null ) {
-                            final String columnName = caseConvertIdentifierForRails(connection, keySet.getString("column_name"));
-                            final int length = keySet.getInt("sub_part");
-                            final boolean nullLength = keySet.wasNull();
-
-                            lastIndexDef.callMethod(context, "columns").callMethod(context,
-                                    "<<", RubyString.newUnicodeString(runtime, columnName));
-                            lastIndexDef.callMethod(context, "lengths").callMethod(context,
-                                    "<<", nullLength ? runtime.getNil() : runtime.newFixnum(length));
-                        }
-                    }
-
-                    return indexes;
-                }
-                finally {
-                    close(keySet);
-                    close(statement);
-                }
-            }
-        });
-    }
-
-    @Override
-    protected String caseConvertIdentifierForRails(final Connection connection, final String value)
-        throws SQLException {
-        if ( value == null ) return null;
+    protected String caseConvertIdentifierForRails(Connection connection, String value) throws SQLException {
         return value; // MySQL does not storesUpperCaseIdentifiers() :
     }