activerecord-jdbc-adapter 1.2.5 → 1.2.8

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

@@ -24,110 +24,119 @@
 
 package arjdbc.mysql;
 
+import static arjdbc.util.QuotingUtils.BYTES_0;
+import static arjdbc.util.QuotingUtils.BYTES_1;
+
 import java.sql.Connection;
 
+import org.jcodings.specific.UTF8Encoding;
+
+import org.jruby.Ruby;
 import org.jruby.RubyModule;
 import org.jruby.RubyString;
-
 import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
-
 import org.jruby.util.ByteList;
 
 public class MySQLModule {
+    
     public static void load(RubyModule arJdbc) {
-        RubyModule mysql = arJdbc.defineModuleUnder("MySQL");
-        mysql.defineAnnotatedMethods(MySQLModule.class);
+        RubyModule mySQL = arJdbc.defineModuleUnder("MySQL");
+        mySQL.defineAnnotatedMethods(MySQLModule.class);
     }
 
-    private final static byte BACKQUOTE = '`';
-    private final static byte[] QUOTED_DOT = new byte[] {'`', '.', '`'};
-
-    private final static byte[] ZERO = new byte[] {'\\','0'};
-    private final static byte[] NEWLINE = new byte[] {'\\','n'};
-    private final static byte[] CARRIAGE = new byte[] {'\\','r'};
-    private final static byte[] ZED = new byte[] {'\\','Z'};
-    private final static byte[] DBL = new byte[] {'\\','"'};
-    private final static byte[] SINGLE = new byte[] {'\\','\''};
-    private final static byte[] ESCAPE = new byte[] {'\\','\\'};
-
-    @JRubyMethod(name = "quote_string", required = 1, frame=false)
-    public static IRubyObject quote_string(ThreadContext context, IRubyObject recv, IRubyObject string) {
-        ByteList bytes = ((RubyString) string).getByteList();
-        ByteList newBytes = new ByteList();
-
-        newBytes.append(bytes);
-
-        for(int i = newBytes.begin; i < newBytes.begin + newBytes.realSize; i++) {
-            byte[] rep = null;
-            switch (newBytes.bytes[i]) {
-            case 0: rep = ZERO; break;
-            case '\n': rep = NEWLINE; break;
-            case '\r': rep = CARRIAGE; break;
-            case 26: rep = ZED; break;
-            case '"': rep = DBL; break;
-            case '\'': rep = SINGLE; break;
-            case '\\': rep = ESCAPE; break;
+    //private final static byte[] ZERO = new byte[] {'\\','0'};
+    //private final static byte[] NEWLINE = new byte[] {'\\','n'};
+    //private final static byte[] CARRIAGE = new byte[] {'\\','r'};
+    //private final static byte[] ZED = new byte[] {'\\','Z'};
+    //private final static byte[] DBL = new byte[] {'\\','"'};
+    //private final static byte[] SINGLE = new byte[] {'\\','\''};
+    //private final static byte[] ESCAPE = new byte[] {'\\','\\'};
+
+    private static final int STRING_QUOTES_OPTIMISTIC_QUESS = 24;
+    
+    @JRubyMethod(name = "quote_string", required = 1, frame = false)
+    public static IRubyObject quote_string(final ThreadContext context, 
+        final IRubyObject recv, final IRubyObject string) {
+        
+        final ByteList stringBytes = ((RubyString) string).getByteList();
+        final byte[] bytes = stringBytes.bytes; // unsafeBytes();
+        final int begin = stringBytes.begin; // getBegin();
+        final int realSize = stringBytes.realSize; // getRealSize();
+        
+        ByteList quotedBytes = null; int appendFrom = begin;
+        for ( int i = begin; i < begin + realSize; i++ ) {
+            final byte byte2;
+            switch ( bytes[i] ) {
+                case   0  : byte2 = '0';  break;
+                case '\n' : byte2 = 'n';  break;
+                case '\r' : byte2 = 'r';  break;
+                case  26  : byte2 = 'Z';  break;
+                case '"'  : byte2 = '"';  break;
+                case '\'' : byte2 = '\''; break;
+                case '\\' : byte2 = '\\'; break;
+                default   : byte2 = 0;
             }
-
-            if (rep != null) {
-                newBytes.replace(i, 1, rep);
-                i += rep.length - 1; // We subtract one since for loop already adds one
+            if ( byte2 != 0 ) {
+                if ( quotedBytes == null ) {
+                    quotedBytes = new ByteList(
+                        new byte[realSize + STRING_QUOTES_OPTIMISTIC_QUESS], 
+                        stringBytes.encoding // getEncoding()
+                    );
+                    quotedBytes.begin = 0; // setBegin(0);
+                    quotedBytes.realSize = 0; // setRealSize(0);
+                } // copy string on-first quote we "optimize" for non-quoted
+                quotedBytes.append(bytes, appendFrom, i - appendFrom);
+                quotedBytes.append('\\').append(byte2);
+                appendFrom = i + 1;
             }
         }
+        if ( quotedBytes != null ) { // append what's left in the end :
+            quotedBytes.append(bytes, appendFrom, begin + realSize - appendFrom);
+        }
+        else return string; // nothing changed, can return original
 
-        // Nothing changed, can return original
-        if (newBytes.length() == bytes.length()) return string;
-
-        return context.getRuntime().newString(newBytes);
+        final Ruby runtime = context.getRuntime();
+        final RubyString quoted = runtime.newString(quotedBytes);
+        if ( runtime.is1_9() ) { // only due mysql2 compatibility
+            quoted.associateEncoding( UTF8Encoding.INSTANCE );
+        }
+        return quoted;
     }
 
-    @JRubyMethod(name = "quote_column_name", frame=false)
-    public static IRubyObject quote_column_name(ThreadContext context, IRubyObject recv, IRubyObject arg) {
-        ByteList bytes = arg.asString().getByteList();
-        ByteList newBytes = new ByteList();
-
-        newBytes.insert(0, BACKQUOTE);
-        newBytes.append(bytes);
-        newBytes.append(BACKQUOTE);
-
-        return context.getRuntime().newString(newBytes);
+    @JRubyMethod(name = "quoted_true", required = 0, frame = false)
+    public static IRubyObject quoted_true(
+            final ThreadContext context, 
+            final IRubyObject self) {
+        return RubyString.newString(context.getRuntime(), BYTES_1);
     }
-
-    @JRubyMethod(name = "quote_table_name", frame=false)
-    public static IRubyObject quote_table_name(ThreadContext context, IRubyObject recv, IRubyObject arg) {
-        ByteList bytes = arg.asString().getByteList();
-        ByteList newBytes = new ByteList();
-
-        newBytes.insert(0, BACKQUOTE);
-        newBytes.append(bytes);
-        int i = 0, j = 0;
-        while ((i = newBytes.indexOf('.', j)) != -1) {
-            newBytes.replace(i, 1, QUOTED_DOT);
-            j = i+3;
-        }
-        newBytes.append(BACKQUOTE);
-
-        return context.getRuntime().newString(newBytes);
+    
+    @JRubyMethod(name = "quoted_false", required = 0, frame = false)
+    public static IRubyObject quoted_false(
+            final ThreadContext context, 
+            final IRubyObject self) {
+        return RubyString.newString(context.getRuntime(), BYTES_0);
     }
-
+    
     /**
      * HACK HACK HACK See http://bugs.mysql.com/bug.php?id=36565
      * MySQL's statement cancel timer can cause memory leaks, so cancel it
      * if we loaded MySQL classes from the same classloader as JRuby
      */
     @JRubyMethod(module = true, frame = false)
-    public static IRubyObject kill_cancel_timer(ThreadContext context, IRubyObject recv, IRubyObject raw_connection) {
-        Connection conn = (Connection) raw_connection.dataGetStruct();
+    public static IRubyObject kill_cancel_timer(final ThreadContext context, 
+        final IRubyObject recv, final IRubyObject raw_connection) {
+        
+        final Connection conn = (Connection) raw_connection.dataGetStruct();
         if (conn != null && conn.getClass().getClassLoader() == recv.getRuntime().getJRubyClassLoader()) {
             try {
                 java.lang.reflect.Field f = conn.getClass().getDeclaredField("cancelTimer");
                 f.setAccessible(true);
                 java.util.Timer timer = (java.util.Timer) f.get(null);
                 timer.cancel();
-            } catch (Exception e) {
             }
+            catch (Exception e) { /* ignored */ }
         }
         return recv.getRuntime().getNil();
     }

data/src/java/arjdbc/oracle/OracleModule.java

@@ -0,0 +1,74 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2013 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.oracle;
+
+import static arjdbc.util.QuotingUtils.BYTES_0;
+import static arjdbc.util.QuotingUtils.BYTES_1;
+import static arjdbc.util.QuotingUtils.quoteCharWith;
+
+import org.jruby.RubyModule;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * ArJdbc::Oracle
+ * 
+ * @author kares
+ */
+public class OracleModule {
+    
+    public static void load(final RubyModule arJdbc) {
+        RubyModule oracle = arJdbc.defineModuleUnder("Oracle");
+        oracle.defineAnnotatedMethods( OracleModule.class );
+    }
+    
+    @JRubyMethod(name = "quote_string", required = 1, frame = false)
+    public static IRubyObject quote_string(
+            final ThreadContext context, 
+            final IRubyObject self, 
+            final IRubyObject string) { // string.gsub("'", "''") :
+        final char single = '\'';
+        final RubyString quoted = quoteCharWith(
+            context, (RubyString) string, single, single
+        );
+        return quoted;
+    }
+    
+    @JRubyMethod(name = "quoted_true", required = 0, frame = false)
+    public static IRubyObject quoted_true(
+            final ThreadContext context, 
+            final IRubyObject self) {
+        return RubyString.newString(context.getRuntime(), BYTES_1);
+    }
+    
+    @JRubyMethod(name = "quoted_false", required = 0, frame = false)
+    public static IRubyObject quoted_false(
+            final ThreadContext context, 
+            final IRubyObject self) {
+        return RubyString.newString(context.getRuntime(), BYTES_0);
+    }
+    
+}

data/src/java/arjdbc/oracle/OracleRubyJdbcConnection.java

@@ -63,23 +63,18 @@ public class OracleRubyJdbcConnection extends RubyJdbcConnection {
      * from NUMBER(x) or NUMBER(x,y).
      */
     @Override
-    protected String typeFromResultSet(ResultSet resultSet) throws SQLException {
+    protected String typeFromResultSet(final ResultSet resultSet) throws SQLException {
         int precision = intFromResultSet(resultSet, COLUMN_SIZE);
         int scale = intFromResultSet(resultSet, DECIMAL_DIGITS);
 
         // According to http://forums.oracle.com/forums/thread.jspa?threadID=658646
         // Unadorned NUMBER reports scale == null, so we look for that here.
-        if (scale < 0 && resultSet.getInt(DATA_TYPE) == java.sql.Types.DECIMAL) {
+        if ( scale < 0 && resultSet.getInt(DATA_TYPE) == java.sql.Types.DECIMAL ) {
             precision = -1;
         }
 
-        String type = resultSet.getString(TYPE_NAME);
-        if (precision > 0) {
-            type += "(" + precision;
-            if(scale > 0) type += "," + scale;
-            type += ")";
-        }
-
-        return type;
+        final String type = resultSet.getString(TYPE_NAME);
+        return formatTypeWithPrecisionAndScale(type, precision, scale);
     }
+
 }

data/src/java/arjdbc/sqlite3/SQLite3Module.java

@@ -0,0 +1,77 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2013 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.sqlite3;
+
+import static arjdbc.util.QuotingUtils.quoteCharWith;
+
+import org.jruby.RubyModule;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+
+/**
+ * ArJdbc::SQLite3
+ * 
+ * @author kares
+ */
+public class SQLite3Module {
+    
+    public static void load(final RubyModule arJdbc) {
+        RubyModule sqlite3 = arJdbc.defineModuleUnder("SQLite3");
+        sqlite3.defineAnnotatedMethods( SQLite3Module.class );
+    }
+    
+    @JRubyMethod(name = "quote_string", required = 1, frame = false)
+    public static IRubyObject quote_string(
+            final ThreadContext context, 
+            final IRubyObject self, 
+            final IRubyObject string) { // string.gsub("'", "''") :
+        final char single = '\'';
+        final RubyString quoted = quoteCharWith(
+            context, (RubyString) string, single, single
+        );
+        return quoted;
+    }
+
+    private static final ByteList Q_TRUE = new ByteList(new byte[] { '\'', 't', '\'' }, false);
+    
+    @JRubyMethod(name = "quoted_true", required = 0, frame = false)
+    public static IRubyObject quoted_true(
+            final ThreadContext context, 
+            final IRubyObject self) {
+        return RubyString.newString(context.getRuntime(), Q_TRUE);
+    }
+
+    private static final ByteList Q_FALSE = new ByteList(new byte[] { '\'', 'f', '\'' }, false);
+    
+    @JRubyMethod(name = "quoted_false", required = 0, frame = false)
+    public static IRubyObject quoted_false(
+            final ThreadContext context, 
+            final IRubyObject self) {
+        return RubyString.newString(context.getRuntime(), Q_FALSE);
+    }
+    
+}

data/src/java/arjdbc/sqlite3/SQLite3RubyJdbcConnection.java

@@ -0,0 +1,127 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2006-2010 Nick Sieger <nick@nicksieger.com>
+ * Copyright (c) 2006-2007 Ola Bini <ola.bini@gmail.com>
+ * Copyright (c) 2008-2009 Thomas E Enebo <enebo@acm.org>
+ *
+ * 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.
+ ***** END LICENSE BLOCK *****/
+
+package arjdbc.sqlite3;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Types;
+
+import arjdbc.jdbc.RubyJdbcConnection;
+import arjdbc.jdbc.SQLBlock;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ *
+ * @author enebo
+ */
+public class SQLite3RubyJdbcConnection extends RubyJdbcConnection {
+    
+    protected SQLite3RubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+    }
+
+    public static RubyClass createSQLite3JdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
+        final RubyClass clazz = getConnectionAdapters(runtime). // ActiveRecord::ConnectionAdapters
+            defineClassUnder("SQLite3JdbcConnection", jdbcConnection, SQLITE3_JDBCCONNECTION_ALLOCATOR);
+        clazz.defineAnnotatedMethods( SQLite3RubyJdbcConnection.class );
+        getConnectionAdapters(runtime).setConstant("Sqlite3JdbcConnection", clazz); // backwards-compat
+        return clazz;
+    }
+
+    private static ObjectAllocator SQLITE3_JDBCCONNECTION_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new SQLite3RubyJdbcConnection(runtime, klass);
+        }
+    };
+    
+    @JRubyMethod(name = "last_insert_row_id")
+    public IRubyObject getLastInsertRowId(final ThreadContext context) 
+        throws SQLException {
+        return (IRubyObject) withConnectionAndRetry(context, new SQLBlock() {
+                public Object call(Connection c) throws SQLException {
+                    Statement stmt = null;
+                    try {
+                        stmt = c.createStatement();
+                        return unmarshal_id_result(context.getRuntime(),
+                                                   stmt.getGeneratedKeys());
+                    } catch (SQLException sqe) {
+                        if (context.getRuntime().isDebug()) {
+                            System.out.println("Error SQL:" + sqe.getMessage());
+                        }
+                        throw sqe;
+                    } finally {
+                        close(stmt);
+                    }
+                }
+            });
+    }
+
+    @Override
+    protected IRubyObject tables(ThreadContext context, String catalog, String schemaPattern, String tablePattern, String[] types) {
+        return (IRubyObject) withConnectionAndRetry(context, tableLookupBlock(context.getRuntime(), catalog, schemaPattern, tablePattern, types, true));
+    }
+
+    @Override
+    protected IRubyObject jdbcToRuby(Ruby runtime, int column, int type, ResultSet resultSet)
+            throws SQLException {
+        try {
+            // This is rather gross, and only needed because the resultset metadata for SQLite tries to be overly
+            // clever, and returns a type for the column of the "current" row, so an integer value stored in a 
+            // decimal column is returned as Types.INTEGER.  Therefore, if the first row of a resultset was an
+            // integer value, all rows of that result set would get truncated.
+            if( resultSet instanceof ResultSetMetaData ) {
+                type = ((ResultSetMetaData)resultSet).getColumnType(column);
+            }
+            switch (type) {
+            case Types.BINARY:
+            case Types.BLOB:
+            case Types.LONGVARBINARY:
+            case Types.VARBINARY:
+                return streamToRuby(runtime, resultSet, new ByteArrayInputStream(resultSet.getBytes(column)));
+            case Types.LONGVARCHAR:
+                return runtime.is1_9() ?
+                    readerToRuby(runtime, resultSet, resultSet.getCharacterStream(column)) :
+                    streamToRuby(runtime, resultSet, new ByteArrayInputStream(resultSet.getBytes(column)));
+            default:
+                return super.jdbcToRuby(runtime, column, type, resultSet);
+            }
+        } catch (IOException ioe) {
+            throw (SQLException) new SQLException(ioe.getMessage()).initCause(ioe);
+        }
+    }
+}