activerecord-jdbc-adapter 1.3.0.beta2 → 1.3.0.rc1

data/rakelib/db.rake

@@ -1,41 +1,53 @@
 require File.expand_path('../../test/shared_helper', __FILE__)
 
 namespace :db do
-  desc "Creates the test database for MySQL."
+
+  desc "Creates the test database for MySQL"
   task :mysql do
-    load 'test/db/mysql_config.rb' rescue nil
-    t = Tempfile.new("mysql")
-    t.puts <<-SQL
+    load 'test/db/mysql_config.rb' # rescue nil
+    script = sql_script <<-SQL, 'mysql'
 DROP DATABASE IF EXISTS `#{MYSQL_CONFIG[:database]}`;
 CREATE DATABASE `#{MYSQL_CONFIG[:database]}` DEFAULT CHARACTER SET `utf8`;
 GRANT ALL PRIVILEGES ON `#{MYSQL_CONFIG[:database]}`.* TO #{MYSQL_CONFIG[:username]}@localhost;
 GRANT ALL PRIVILEGES ON `test\_%`.* TO #{MYSQL_CONFIG[:username]}@localhost;
 SET PASSWORD FOR #{MYSQL_CONFIG[:username]}@localhost = PASSWORD('#{MYSQL_CONFIG[:password]}');
 SQL
-    t.close
-    at_exit { t.unlink }
-    password = ""
+    params = { '-u' => 'root' }
     if ENV['DATABASE_YML']
       require 'yaml'
       password = YAML.load(File.new(ENV['DATABASE_YML']))["production"]["password"]
-      password_arg = " --password=#{password}"
+      params['--password'] = password
     end
-    sh "cat #{t.path} | mysql -u root#{password_arg}", :verbose => false # so password is not echoed
+    puts "Creating MySQL (test) database: #{MYSQL_CONFIG[:database]}"
+    sh "cat #{script.path} | mysql #{params.to_a.join(' ')}", :verbose => $VERBOSE # so password is not echoed
   end
 
-  desc "Creates the test database for PostgreSQL."
-  task :postgres do
+  desc "Creates the test database for PostgreSQL"
+  task :postgresql do
     fail unless PostgresHelper.have_postgres?
-    load 'test/db/postgres_config.rb' rescue nil
-    t = Tempfile.new("psql")
-    t.puts <<-SQL
+    load 'test/db/postgres_config.rb' # rescue nil
+    script = sql_script <<-SQL, 'psql'
 DROP DATABASE IF EXISTS #{POSTGRES_CONFIG[:database]};
 DROP USER IF EXISTS #{POSTGRES_CONFIG[:username]};
 CREATE USER #{POSTGRES_CONFIG[:username]} CREATEDB SUPERUSER LOGIN PASSWORD '#{POSTGRES_CONFIG[:password]}';
 CREATE DATABASE #{POSTGRES_CONFIG[:database]} OWNER #{POSTGRES_CONFIG[:username]};
 SQL
-    t.close
-    at_exit { t.unlink }
-    sh "cat #{t.path} | psql -U postgres"
+    params = { '-U' => ENV['PSQL_USER'] || 'postgres' }
+    params['-q'] = nil unless $VERBOSE
+    puts "Creating PostgreSQL (test) database: #{POSTGRES_CONFIG[:database]}"
+    sh "cat #{script.path} | psql #{params.to_a.join(' ')}", :verbose => $VERBOSE
   end
+  task :postgres => :postgresql
+
+  private
+
+  def sql_script(sql_content, name = 'sql_script')
+    script = Tempfile.new(name)
+    script.puts sql_content
+    yield(script) if block_given?
+    script.close
+    at_exit { script.unlink }
+    script
+  end
+
 end

data/src/java/arjdbc/ArJdbcModule.java

@@ -40,11 +40,11 @@ import org.jruby.runtime.builtin.IRubyObject;
 
 /**
  * ::ArJdbc
- * 
+ *
  * @author kares
  */
 public class ArJdbcModule {
-    
+
     public static RubyModule load(final Ruby runtime) {
         final RubyModule arJdbc = runtime.getOrCreateModule("ArJdbc");
         arJdbc.defineAnnotatedMethods( ArJdbcModule.class );
@@ -52,9 +52,9 @@ public class ArJdbcModule {
     }
 
     /**
-     * Load the Java parts for the given adapter spec module, e.g. to load 
+     * Load the Java parts for the given adapter spec module, e.g. to load
      * ArJdbc::MySQL's Java part: <code>ArJdbc.load_java_part :MySQL</code>
-     * 
+     *
      * NOTE: this method is not intended to be called twice for a given adapter !
      * @param context
      * @param self
@@ -62,15 +62,15 @@ public class ArJdbcModule {
      * @return true
      */
     @JRubyMethod(name = "load_java_part", meta = true, required = 1, optional = 2)
-    public static IRubyObject load_java_part(final ThreadContext context, 
+    public static IRubyObject load_java_part(final ThreadContext context,
         final IRubyObject self, final IRubyObject[] args) {
-        
+
         String connectionClass = args.length > 1 ? args[1].toString() : null;
         String moduleClass = args.length > 2 ? args[2].toString() : null;
-        
+
         final String moduleName = args[0].toString(); // e.g. 'MySQL'
         final String packagePrefix = "arjdbc." + moduleName.toLowerCase() + "."; // arjdbc.mysql
-        
+
         // NOTE: due previous (backwards compatible) conventions there are
         // 2 things we load, the adapter spec module's Java implemented methods
         // and a custom JdbcConnection class (both are actually optional) e.g. :
@@ -78,7 +78,7 @@ public class ArJdbcModule {
         //   MySQLModule.load(RubyModule); // 'arjdbc.mysql' package is assumed
         //   MySQLRubyJdbcConnection.createMySQLJdbcConnectionClass(Ruby, RubyClass);
         //
-        
+
         String connectionClass2 = null;
         if (connectionClass == null) {
              // 'arjdbc.mysql.' + 'MySQL' + 'RubyJdbcConnection'
@@ -89,10 +89,10 @@ public class ArJdbcModule {
              // 'arjdbc.mysql.' + 'MySQL' + 'Module'
             moduleClass = packagePrefix + moduleName + "Module";
         }
-        
+
         final Ruby runtime = context.getRuntime();
         final RubyModule arJdbc = runtime.getModule("ArJdbc");
-        
+
         try {
             final Class<?> module = Class.forName(moduleClass);
              // MySQLModule.load( arJdbc ) :
@@ -108,7 +108,7 @@ public class ArJdbcModule {
         catch (InvocationTargetException e) {
             throw newNativeException(runtime, e);
         }
-        
+
         try {
             Class<?> connection = null;
             try {
@@ -136,10 +136,10 @@ public class ArJdbcModule {
         catch (InvocationTargetException e) {
             throw newNativeException(runtime, e);
         }
-        
+
         return runtime.getTrue();
     }
-    
+
     /**
      * <code>ArJdbc.modules</code>
      * @param context
@@ -150,26 +150,29 @@ public class ArJdbcModule {
     public static IRubyObject modules(final ThreadContext context, final IRubyObject self) {
         final Ruby runtime = context.getRuntime();
         final RubyModule arJdbc = (RubyModule) self;
-        
+
         final Collection<String> constants = arJdbc.getConstantNames();
         final RubyArray modules = runtime.newArray( constants.size() );
-        
+
         for ( final String name : constants ) {
            IRubyObject value = arJdbc.getConstant(name, false);
            // isModule: return false for Ruby Classes
            if ( value != null && value.isModule() ) {
                if ( "MissingFunctionalityHelper".equals(name) ) continue;
+               if ( "SerializedAttributesHelper".equals(name) ) continue;
+               if ( "QuotedPrimaryKeyExtension".equals(name) ) continue;
+               if ( "Util".equals(name) ) continue;
                if ( "Version".equals(name) ) continue;
                modules.append(value);
            }
         }
         return modules;
     }
-    
+
     private static RaiseException newNativeException(final Ruby runtime, final Throwable cause) {
         RubyClass nativeClass = runtime.getClass(NativeException.CLASS_NAME);
         NativeException nativeException = new NativeException(runtime, nativeClass, cause);
         throw new RaiseException(cause, nativeException);
     }
-    
+
 }

data/src/java/arjdbc/db2/DB2RubyJdbcConnection.java

@@ -25,35 +25,34 @@
  ***** END LICENSE BLOCK *****/
 package arjdbc.db2;
 
+import arjdbc.jdbc.Callable;
 import arjdbc.jdbc.RubyJdbcConnection;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
 
 /**
  *
  * @author mikestone
  */
 public class DB2RubyJdbcConnection extends RubyJdbcConnection {
-    
-    private static final String[] TABLE_TYPES = new String[]{ "TABLE", "VIEW", "SYNONYM", "MATERIALIZED QUERY TABLE", "ALIAS" };
 
     protected DB2RubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
     }
 
-    @Override
-    protected String[] getTableTypes() {
-        return TABLE_TYPES;
-    }
-
-    @Override
-    protected boolean databaseSupportsSchemas() {
-        return true;
-    }
-
     public static RubyClass createDB2JdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
         RubyClass clazz = RubyJdbcConnection.getConnectionAdapters(runtime).defineClassUnder("DB2JdbcConnection",
                 jdbcConnection, DB2_JDBCCONNECTION_ALLOCATOR);
@@ -67,4 +66,77 @@ public class DB2RubyJdbcConnection extends RubyJdbcConnection {
             return new DB2RubyJdbcConnection(runtime, klass);
         }
     };
+
+    @JRubyMethod(name = "select?", required = 1, meta = true, frame = false)
+    public static IRubyObject select_p(final ThreadContext context,
+        final IRubyObject self, final IRubyObject sql) {
+        if ( isValues(sql.convertToString()) ) {
+            return context.getRuntime().newBoolean( true );
+        }
+        return arjdbc.jdbc.RubyJdbcConnection.select_p(context, self, sql);
+    }
+
+    // DB2 supports 'stand-alone' VALUES expressions
+    private static final byte[] VALUES = new byte[]{ 'v','a','l','u', 'e', 's' };
+
+    private static boolean isValues(final RubyString sql) {
+        final ByteList sqlBytes = sql.getByteList();
+        return startsWithIgnoreCase(sqlBytes, VALUES);
+    }
+
+    private static final String[] TABLE_TYPES = new String[] {
+        "TABLE", "VIEW", "SYNONYM", "MATERIALIZED QUERY TABLE", "ALIAS"
+    };
+
+    @Override
+    protected String[] getTableTypes() {
+        return TABLE_TYPES;
+    }
+
+    @Override
+    protected boolean databaseSupportsSchemas() {
+        return true;
+    }
+
+    @JRubyMethod(name = {"identity_val_local", "last_insert_id"})
+    public IRubyObject identity_val_local(final ThreadContext context)
+        throws SQLException {
+        return withConnection(context, new Callable<IRubyObject>() {
+            public IRubyObject call(final Connection connection) throws SQLException {
+                PreparedStatement statement = null; ResultSet genKeys = null;
+                try {
+                    statement = connection.prepareStatement("VALUES IDENTITY_VAL_LOCAL()");
+                    genKeys = statement.executeQuery();
+                    return doMapGeneratedKeys(context.getRuntime(), genKeys, true);
+                }
+                catch (final SQLException e) {
+                    debugMessage(context, "failed to get generated keys: " + e.getMessage());
+                    throw e;
+                }
+                finally { close(genKeys); close(statement); }
+            }
+        });
+    }
+
+    // NOTE: this is non-sense or DB2 - but it has been originally implemented this way !
+    //@JRubyMethod(name = {"identity_val_local", "last_insert_id"}, required = 1)
+    private IRubyObject identity_val_local(final ThreadContext context, final IRubyObject table)
+        throws SQLException {
+        return withConnection(context, new Callable<IRubyObject>() {
+            public IRubyObject call(final Connection connection) throws SQLException {
+                Statement statement = null; ResultSet genKeys = null;
+                try {
+                    statement = connection.createStatement();
+                    genKeys = statement.executeQuery("SELECT IDENTITY_VAL_LOCAL() FROM " + table);
+                    return doMapGeneratedKeys(context.getRuntime(), genKeys, true);
+                }
+                catch (final SQLException e) {
+                    debugMessage(context, "failed to get generated keys: " + e.getMessage());
+                    throw e;
+                }
+                finally { close(genKeys); close(statement); }
+            }
+        });
+    }
+
 }

data/src/java/arjdbc/derby/DerbyModule.java

@@ -24,29 +24,21 @@
 
 package arjdbc.derby;
 
-import java.sql.SQLException;
-
 import static arjdbc.util.QuotingUtils.BYTES_0;
 import static arjdbc.util.QuotingUtils.BYTES_1;
-
-import arjdbc.jdbc.RubyJdbcConnection;
+import static arjdbc.util.QuotingUtils.BYTES_SINGLE_Q_x2;
 
 import org.jruby.Ruby;
 import org.jruby.RubyBoolean;
 import org.jruby.RubyModule;
-import org.jruby.RubyObjectAdapter;
 import org.jruby.RubyString;
 import org.jruby.anno.JRubyMethod;
-import org.jruby.javasupport.JavaEmbedUtils;
-import org.jruby.runtime.Block;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ByteList;
 
 public class DerbyModule {
-    
-    static final RubyObjectAdapter rubyApi = JavaEmbedUtils.newObjectAdapter();
-    
+
     public static RubyModule load(final RubyModule arJdbc) {
         RubyModule derby = arJdbc.defineModuleUnder("Derby");
         derby.defineAnnotatedMethods( DerbyModule.class );
@@ -56,170 +48,189 @@ public class DerbyModule {
     }
 
     public static class Column {
+
         @JRubyMethod(name = "type_cast", required = 1)
-        public static IRubyObject type_cast(IRubyObject recv, IRubyObject value) {
-            Ruby runtime = recv.getRuntime();
+        public static IRubyObject type_cast(final ThreadContext context,
+            final IRubyObject self, final IRubyObject value) {
 
-            if (value.isNil() || ((value instanceof RubyString) && value.toString().trim().equalsIgnoreCase("null"))) {
-                return runtime.getNil();
+            if ( value.isNil() ||
+            ( (value instanceof RubyString) && value.toString().trim().equalsIgnoreCase("null") ) ) {
+                return context.getRuntime().getNil();
             }
 
-            String type = rubyApi.getInstanceVariable(recv, "@type").toString();
+            final String type = self.getInstanceVariables().getInstanceVariable("@type").toString();
 
             switch (type.charAt(0)) {
             case 's': //string
                 return value;
             case 't': //text, timestamp, time
-                if (type.equals("text")) {
-                    return value;
-                } else if (type.equals("timestamp")) {
-                    return rubyApi.callMethod(recv.getMetaClass(), "string_to_time", value);
-                } else { //time
-                    return rubyApi.callMethod(recv.getMetaClass(), "string_to_dummy_time", value);
+                if ( type.equals("time") ) {
+                    return self.getMetaClass().callMethod(context, "string_to_dummy_time", value);
                 }
+                if ( type.equals("timestamp") ) {
+                    return self.getMetaClass().callMethod(context, "string_to_time", value);
+                }
+                return value; // text
             case 'i': //integer
             case 'p': //primary key
-                if (value.respondsTo("to_i")) {
-                    return rubyApi.callMethod(value, "to_i");
-                } else {
-                    return runtime.newFixnum(value.isTrue() ? 1 : 0);
+                if ( value.respondsTo("to_i") ) {
+                    return value.callMethod(context, "to_i");
                 }
+                return context.getRuntime().newFixnum( value.isTrue() ? 1 : 0 );
             case 'd': //decimal, datetime, date
-                if (type.equals("datetime")) {
-                    return rubyApi.callMethod(recv.getMetaClass(), "string_to_time", value);
-                } else if (type.equals("date")) {
-                    return rubyApi.callMethod(recv.getMetaClass(), "string_to_date", value);
-                } else {
-                    return rubyApi.callMethod(recv.getMetaClass(), "value_to_decimal", value);
+                if ( type.equals("datetime") ) {
+                    return self.getMetaClass().callMethod(context, "string_to_time", value);
+                }
+                if ( type.equals("date") ) {
+                    return self.getMetaClass().callMethod(context, "string_to_date", value);
                 }
+                return self.getMetaClass().callMethod(context, "value_to_decimal", value);
             case 'f': //float
-                return rubyApi.callMethod(value, "to_f");
+                return value.callMethod(context, "to_f");
             case 'b': //binary, boolean
-                if (type.equals("binary")) {
-                    return rubyApi.callMethod(recv.getMetaClass(), "binary_to_string", value);
-                } else {
-                    return rubyApi.callMethod(recv.getMetaClass(), "value_to_boolean", value);
-                }
+                return type.equals("binary") ?
+                    self.getMetaClass().callMethod(context, "binary_to_string", value) :
+                    self.getMetaClass().callMethod(context, "value_to_boolean", value) ;
             }
             return value;
         }
+
     }
 
     @JRubyMethod(name = "quote", required = 1, optional = 1)
-    public static IRubyObject quote(final ThreadContext context, final IRubyObject self, 
-        final IRubyObject[] args) {
+    public static IRubyObject quote(final ThreadContext context,
+        final IRubyObject self, final IRubyObject[] args) {
         final Ruby runtime = self.getRuntime();
         IRubyObject value = args[0];
         if ( args.length > 1 ) {
             final IRubyObject column = args[1];
-            final String columnType = column.isNil() ? "" : rubyApi.callMethod(column, "type").toString();
+            final String columnType = column.isNil() ? "" : column.callMethod(context, "type").toString();
             // intercept and change value, maybe, if the column type is :text or :string
             if ( columnType.equals("text") || columnType.equals("string") ) {
-            	value = make_ruby_string_for_text_column(context, self, runtime, value);
+            	value = toRubyStringForTextColumn(context, runtime, self, value);
             }
-            final String metaClass = value.getMetaClass().getName();
 
             if ( value instanceof RubyString ) {
                 if ( columnType.equals("string") ) {
-                    return quote_string_with_surround(runtime, "'", (RubyString) value, "'");
-                }
-                else if ( columnType.equals("text") ) {
-                    return quote_string_with_surround(runtime, "CAST('", (RubyString) value, "' AS CLOB)");
+                    return quoteString(runtime, "'", value, "'");
                 }
-                else if ( columnType.equals("binary") ) {
-                    return hexquote_string_with_surround(runtime, "CAST(X'", (RubyString) value, "' AS BLOB)");
+                if ( columnType.equals("text") ) {
+                    return quoteString(runtime, "CAST('", value, "' AS CLOB)");
                 }
-                else if ( columnType.equals("xml") ) {
-                    return quote_string_with_surround(runtime, "XMLPARSE(DOCUMENT '", (RubyString) value, "' PRESERVE WHITESPACE)");
+                if ( columnType.equals("binary") ) {
+                    return quoteStringHex(runtime, "CAST(X'", value, "' AS BLOB)");
                 }
-                else { // column type :integer or other numeric or date version
-                    return only_digits((RubyString) value) ? value : super_quote(context, self, runtime, value, column);
+                if ( columnType.equals("xml") ) {
+                    return quoteString(runtime, "XMLPARSE(DOCUMENT '", value, "' PRESERVE WHITESPACE)");
                 }
+                // column type :integer or other numeric or date version
+                return isDigitsOnly(value) ? value : quoteDefault(context, runtime, self, value, column, columnType);
             }
-            else if ( metaClass.equals("Float") || metaClass.equals("Fixnum") || metaClass.equals("Bignum") ) {
+
+            final String metaClass = value.getMetaClass().getName();
+            if ( metaClass.equals("Float") || metaClass.equals("Fixnum") || metaClass.equals("Bignum") ) {
                 if ( columnType.equals("string") ) {
-                    return quote_string_with_surround(runtime, "'", RubyString.objAsString(context, value), "'");
+                    return quoteString(runtime, "'", RubyString.objAsString(context, value), "'");
                 }
             }
         }
-        return super_quote(context, self, runtime, value, runtime.getNil());
+        return quoteDefault(context, runtime, self, value, runtime.getNil(), null);
+    }
+
+    private static IRubyObject quoted_date_OR_to_yaml(final ThreadContext context,
+        final Ruby runtime, final IRubyObject self, final IRubyObject value) {
+
+        if ( value.callMethod(context, "acts_like?", runtime.newSymbol("date")).isTrue()
+          || value.callMethod(context, "acts_like?", runtime.newSymbol("time")).isTrue() ) {
+            return self.callMethod(context, "quoted_date", value);
+        }
+        else {
+            return value.callMethod(context, "to_yaml");
+        }
     }
 
     /*
-     * Derby is not permissive like MySql. Try and send an Integer to a CLOB or VARCHAR column and Derby will vomit.
+     * Derby is not permissive like MySql. Try and send an Integer to a CLOB or
+     * VARCHAR column and Derby will vomit.
      * This method turns non stringy things into strings.
      */
-    private static IRubyObject make_ruby_string_for_text_column(ThreadContext context, IRubyObject recv, Ruby runtime, IRubyObject value) {
-    	final RubyModule multibyteChars = getMultibyteChars(runtime);
-        if (value instanceof RubyString || rubyApi.isKindOf(value, multibyteChars) || value.isNil()) {
+    private static IRubyObject toRubyStringForTextColumn(
+        final ThreadContext context, final Ruby runtime, final IRubyObject self,
+        final IRubyObject value) {
+
+        if ( value instanceof RubyString || value.isNil() || isMultibyteChars(runtime, value) ) {
             return value;
         }
 
-        String metaClass = value.getMetaClass().getName();
+        if ( value instanceof RubyBoolean ) return quoteBoolean(runtime, value);
 
-        if (value instanceof RubyBoolean) {
-            return value.isTrue() ? runtime.newString("1") : runtime.newString("0");
-        } else if (metaClass.equals("Float") || metaClass.equals("Fixnum") || metaClass.equals("Bignum")) {
+        final String className = value.getMetaClass().getName();
+        if ( className.equals("Float") || className.equals("Fixnum") || className.equals("Bignum") ) {
             return RubyString.objAsString(context, value);
-        } else if (metaClass.equals("BigDecimal")) {
-            return rubyApi.callMethod(value, "to_s", runtime.newString("F"));
-        } else {
-            if (rubyApi.callMethod(value, "acts_like?", runtime.newString("date")).isTrue() || rubyApi.callMethod(value, "acts_like?", runtime.newString("time")).isTrue()) {
-                return (RubyString)rubyApi.callMethod(recv, "quoted_date", value);
-            } else {
-                return (RubyString)rubyApi.callMethod(value, "to_yaml");
-            }
         }
+        if ( className.equals("BigDecimal") ) {
+            return value.callMethod(context, "to_s", runtime.newString("F"));
+        }
+
+        return quoted_date_OR_to_yaml(context, runtime, self, value);
     }
 
-    private final static ByteList NULL = new ByteList("NULL".getBytes());
+    private final static ByteList NULL = new ByteList("NULL".getBytes(), false);
+
+    private static IRubyObject quoteDefault(final ThreadContext context,
+        final Ruby runtime, final IRubyObject self,
+        final IRubyObject value, final IRubyObject column, final String columnType) {
 
-    private static IRubyObject super_quote(ThreadContext context, IRubyObject recv, Ruby runtime, IRubyObject value, IRubyObject col) {
-        if (value.respondsTo("quoted_id")) {
-            return rubyApi.callMethod(value, "quoted_id");
+        if ( value.respondsTo("quoted_id") ) {
+            return value.callMethod(context, "quoted_id");
         }
 
-        String metaClass = value.getMetaClass().getName();
-
-        IRubyObject type = (col.isNil()) ? col : rubyApi.callMethod(col, "type");
-        final RubyModule multibyteChars = getMultibyteChars(runtime);
-        if (value instanceof RubyString || rubyApi.isKindOf(value, multibyteChars)) {
-            RubyString svalue = RubyString.objAsString(context, value);
-            if (type == runtime.newSymbol("binary") && col.getType().respondsTo("string_to_binary")) {
-                return quote_string_with_surround(runtime, "'", (RubyString)(rubyApi.callMethod(col.getType(), "string_to_binary", svalue)), "'");
-            } else if (type == runtime.newSymbol("integer") || type == runtime.newSymbol("float")) {
-                return RubyString.objAsString(context, ((type == runtime.newSymbol("integer")) ?
-                                                        rubyApi.callMethod(svalue, "to_i") :
-                                                        rubyApi.callMethod(svalue, "to_f")));
-            } else {
-                return quote_string_with_surround(runtime, "'", svalue, "'");
-            }
-        } else if (value.isNil()) {
+        if ( value.isNil() ) {
             return runtime.newString(NULL);
-        } else if (value instanceof RubyBoolean) {
-            return (value.isTrue() ?
-                    (type == runtime.newSymbol(":integer")) ? runtime.newString("1") : rubyApi.callMethod(recv, "quoted_true") :
-                    (type == runtime.newSymbol(":integer")) ? runtime.newString("0") : rubyApi.callMethod(recv, "quoted_false"));
-        } else if (metaClass.equals("Float") || metaClass.equals("Fixnum") || metaClass.equals("Bignum")) {
+        }
+        if ( value instanceof RubyBoolean ) {
+            if ( columnType == (Object) "integer" ) return quoteBoolean(runtime, value);
+            return self.callMethod(context, value.isTrue() ? "quoted_true" : "quoted_false");
+        }
+        if ( value instanceof RubyString || isMultibyteChars(runtime, value) ) {
+
+            final RubyString strValue = RubyString.objAsString(context, value);
+
+            if ( columnType == (Object) "binary" && column.getType().respondsTo("string_to_binary") ) {
+                IRubyObject str = column.getType().callMethod(context, "string_to_binary", strValue);
+                return quoteString(runtime, "'", str, "'");
+            }
+
+            if ( columnType == (Object) "integer" ) {
+                return RubyString.objAsString( context, strValue.callMethod(context, "to_i") );
+            }
+
+            if ( columnType == (Object) "float" ) {
+                return RubyString.objAsString( context, strValue.callMethod(context, "to_f") );
+            }
+
+            return quoteString(runtime, "'", strValue, "'");
+        }
+
+        final String className = value.getMetaClass().getName();
+        if ( className.equals("Float") || className.equals("Fixnum") || className.equals("Bignum") ) {
             return RubyString.objAsString(context, value);
-        } else if (metaClass.equals("BigDecimal")) {
-            return rubyApi.callMethod(value, "to_s", runtime.newString("F"));
-        } else if (rubyApi.callMethod(value, "acts_like?", runtime.newString("date")).isTrue() || rubyApi.callMethod(value, "acts_like?", runtime.newString("time")).isTrue()) {
-            return quote_string_with_surround(runtime, "'", (RubyString)(rubyApi.callMethod(recv, "quoted_date", value)), "'");
-        } else {
-            return quote_string_with_surround(runtime, "'", (RubyString)(rubyApi.callMethod(value, "to_yaml")), "'");
         }
+        if ( className.equals("BigDecimal") ) {
+            return value.callMethod(context, "to_s", runtime.newString("F"));
+        }
+
+        IRubyObject strValue = quoted_date_OR_to_yaml(context, runtime, self, value);
+        return quoteString(runtime, "'", strValue, "'");
     }
 
-    private final static ByteList TWO_SINGLE = new ByteList(new byte[]{'\'','\''});
+    private static IRubyObject quoteString(final Ruby runtime,
+        final String before, final IRubyObject string, final String after) {
 
-    private static IRubyObject quote_string_with_surround(final Ruby runtime, 
-        final String before, final RubyString string, final String after) {
-        
-        final ByteList input = string.getByteList();
+        final ByteList input = ((RubyString) string).getByteList();
         final ByteList output = new ByteList(before.getBytes(), input.getEncoding());
         final byte[] inputBytes = input.unsafeBytes();
-        
+
         for(int i = input.getBegin(); i< input.getBegin() + input.getRealSize(); i++) {
             switch ( inputBytes[i] ) {
                 case '\'': output.append(inputBytes[i]); // FALLTHROUGH
@@ -234,13 +245,13 @@ public class DerbyModule {
 
     private final static byte[] HEX = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
 
-    private static IRubyObject hexquote_string_with_surround(final Ruby runtime, 
-        final String before, final RubyString string, final String after) {
-        
-        final ByteList input = string.getByteList();
+    private static IRubyObject quoteStringHex(final Ruby runtime,
+        final String before, final IRubyObject string, final String after) {
+
+        final ByteList input = ((RubyString) string).getByteList();
         final ByteList output = new ByteList(before.getBytes());
         final byte[] inputBytes = input.unsafeBytes();
-        
+
         int written = 0;
         for(int i = input.getBegin(); i< input.getBegin() + input.getRealSize(); i++) {
             byte b1 = inputBytes[i];
@@ -259,8 +270,8 @@ public class DerbyModule {
         return RubyString.newStringShared(runtime, output);
     }
 
-    private static boolean only_digits(final RubyString string) {
-        final ByteList input = string.getByteList();
+    private static boolean isDigitsOnly(final IRubyObject string) {
+        final ByteList input = ((RubyString) string).getByteList();
         final byte[] inputBytes = input.unsafeBytes();
         for ( int i = input.getBegin(); i< input.getBegin() + input.getRealSize(); i++ ) {
             if ( inputBytes[i] < '0' || inputBytes[i] > '9' ) {
@@ -270,10 +281,14 @@ public class DerbyModule {
         return true;
     }
 
+    private static boolean isMultibyteChars(final Ruby runtime, final IRubyObject value) {
+        return getMultibyteChars(runtime).isInstance(value);
+    }
+
     @JRubyMethod(name = "quote_string", required = 1)
     public static IRubyObject quote_string(final IRubyObject self, IRubyObject string) {
         ByteList bytes = ((RubyString) string).getByteList();
-        
+
         boolean replacement = false;
         for ( int i = 0; i < bytes.length(); i++ ) {
             switch ( bytes.get(i) ) {
@@ -286,52 +301,34 @@ public class DerbyModule {
                 replacement = true;
             }
 
-            bytes.replace(i, 1, TWO_SINGLE);
+            bytes.replace(i, 1, BYTES_SINGLE_Q_x2);
             i += 1;
         }
-        
+
         return replacement ? RubyString.newStringShared(self.getRuntime(), bytes) : string;
     }
 
     @JRubyMethod(name = "quoted_true", required = 0, frame = false)
     public static IRubyObject quoted_true(
-            final ThreadContext context, 
+            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 ThreadContext context,
             final IRubyObject self) {
         return RubyString.newString(context.getRuntime(), BYTES_0);
     }
 
-    @JRubyMethod(name = "_execute", required = 1, optional = 1)
-    public static IRubyObject _execute(final ThreadContext context, final IRubyObject self, final IRubyObject[] args) 
-        throws SQLException {
-        final IRubyObject sql = args[0];
-        
-        String sqlStr = sql.toString().trim();
-        if ( sqlStr.charAt(0) == '(' ) sqlStr = sqlStr.substring(1).trim();
-        sqlStr = sqlStr.substring( 0, Math.min(6, sqlStr.length()) ).toLowerCase();
-        
-        final RubyJdbcConnection connection = (RubyJdbcConnection) rubyApi.getInstanceVariable(self, "@connection");
-        
-        if (sqlStr.startsWith("insert")) {
-            return connection.execute_insert(context, sql);
-        }
-        else if (sqlStr.startsWith("select") || sqlStr.startsWith("show") || sqlStr.startsWith("values")) {
-            return connection.execute_query_raw(context, sql, Block.NULL_BLOCK);
-        }
-        else {
-            return connection.execute_update(context, sql);
-        }
+    private static RubyString quoteBoolean(final Ruby runtime, final IRubyObject value) {
+        return value.isTrue() ? runtime.newString(BYTES_1) : runtime.newString(BYTES_0);
     }
-    
+
     private static RubyModule getMultibyteChars(final Ruby runtime) {
         return (RubyModule) ((RubyModule) runtime.getModule("ActiveSupport").
                 getConstant("Multibyte")).getConstantAt("Chars");
     }
-    
+
 }