activerecord-jdbc-adapter-onsite 1.2.2

data/lib/arjdbc/sybase.rb

@@ -0,0 +1,2 @@
+require 'arjdbc/jdbc'
+require 'arjdbc/sybase/adapter.rb'

data/lib/arjdbc/sybase/adapter.rb

@@ -0,0 +1,46 @@
+module ArJdbc
+  module Sybase
+    def add_limit_offset!(sql, options) # :nodoc:
+      @limit = options[:limit]
+      @offset = options[:offset]
+      if use_temp_table?
+        # Use temp table to hack offset with Sybase
+        sql.sub!(/ FROM /i, ' INTO #artemp FROM ')
+      elsif zero_limit?
+        # "SET ROWCOUNT 0" turns off limits, so we havesy
+        # to use a cheap trick.
+        if sql =~ /WHERE/i
+          sql.sub!(/WHERE/i, 'WHERE 1 = 2 AND ')
+        elsif sql =~ /ORDER\s+BY/i
+          sql.sub!(/ORDER\s+BY/i, 'WHERE 1 = 2 ORDER BY')
+        else
+          sql << 'WHERE 1 = 2'
+        end
+      end
+    end
+
+    # If limit is not set at all, we can ignore offset;
+    # if limit *is* set but offset is zero, use normal select
+    # with simple SET ROWCOUNT.  Thus, only use the temp table
+    # if limit is set and offset > 0.
+    def use_temp_table?
+      !@limit.nil? && !@offset.nil? && @offset > 0
+    end
+
+    def zero_limit?
+      !@limit.nil? && @limit == 0
+    end
+
+    def modify_types(tp) #:nodoc:
+      tp[:primary_key] = "NUMERIC(22,0) IDENTITY PRIMARY KEY"
+      tp[:integer][:limit] = nil
+      tp[:boolean] = {:name => "bit"}
+      tp[:binary] = {:name => "image"}
+      tp
+    end
+
+    def remove_index(table_name, options = {})
+      execute "DROP INDEX #{table_name}.#{index_name(table_name, options)}"
+    end
+  end
+end

data/lib/arjdbc/version.rb

@@ -0,0 +1,8 @@
+module ArJdbc
+  module Version
+    VERSION = "1.2.2"
+  end
+end
+# Compatibility with older versions of ar-jdbc for other extensions out there
+JdbcAdapter = ArJdbc
+JdbcSpec = ArJdbc

data/lib/generators/jdbc/USAGE

@@ -0,0 +1,10 @@
+Description:
+    Creates stubs that ensure activerecord-jdbc is bootstrapped in
+    your Rails application. 
+
+Example:
+    ./script/generate jdbc
+
+    This will create:
+        config/initializers/jdbc.rb
+	lib/tasks/jdbc.rake

data/lib/generators/jdbc/jdbc_generator.rb

@@ -0,0 +1,9 @@
+class JdbcGenerator < Rails::Generators::Base
+  def self.source_root
+    @source_root ||= File.expand_path('../../../../rails_generators/templates', __FILE__)
+  end
+
+  def create_jdbc_files
+    directory '.', '.'
+  end
+end

data/lib/jdbc_adapter.rb

@@ -0,0 +1,2 @@
+warn "DEPRECATED: require 'arjdbc' instead of 'jdbc_adapter'."
+require 'arjdbc'

data/lib/jdbc_adapter/rake_tasks.rb

@@ -0,0 +1,3 @@
+warn "DEPRECATED: require 'arjdbc/rake_tasks' instead of 'jdbc_adapter/rake_tasks'."
+require 'arjdbc/jdbc/rake_tasks'
+

data/lib/jdbc_adapter/version.rb

@@ -0,0 +1,3 @@
+warn "DEPRECATED: require 'arjdbc/version' instead of 'jdbc_adapter/version'."
+require 'arjdbc/version'
+

data/lib/pg.rb

@@ -0,0 +1,26 @@
+# Stub library for postgresql -- allows Rails to load
+# postgresql_adapter without error. Other than postgres-pr, there's no
+# other way to use PostgreSQL on JRuby anyway, right? If you've
+# installed ar-jdbc you probably want to use that to connect to pg.
+#
+# If by chance this library is installed in another Ruby and this file
+# got required then we'll just continue to try to load the next pg.rb
+# in the $LOAD_PATH.
+
+unless defined?(JRUBY_VERSION)
+  gem 'pg' if respond_to?(:gem)   # make sure pg gem is activated
+  after_current_file = false
+  $LOAD_PATH.each do |p|
+    require_file = File.join(p, 'pg.rb')
+
+    if File.expand_path(require_file) == File.expand_path(__FILE__)
+      after_current_file = true
+      next
+    end
+
+    if after_current_file && File.exist?(require_file)
+      load require_file
+      break
+    end
+  end
+end

data/pom.xml

@@ -0,0 +1,57 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>org.jruby.activerecord-jdbc</groupId>
+  <artifactId>activerecord-jdbc</artifactId>
+  <packaging>jar</packaging>
+  <version>1.0.0</version>
+  <name>activerecord-jdbc</name>
+  <description>
+    This POM for activerecord-jdbc is just for bootstrapping IDEs. You
+    can't use it to build the project at the moment.
+  </description>
+  <url>http://activerecord-jdbc.kenai.com/</url>
+
+  <issueManagement>
+    <system>JIRA</system>
+    <url>http://kenai.com/jira/browse/ACTIVERECORD_JDBC</url>
+  </issueManagement>
+
+  <scm>
+    <connection>scm:git:git://github.com/nicksieger/activerecord-jdbc-adapter.git</connection>
+    <developerConnection>scm:git:git@github.com:nicksieger/activerecord-jdbc-adapter.git</developerConnection>
+    <url>http://github.com/nicksieger/activerecord-jdbc-adapter</url>
+  </scm>
+
+  <licenses>
+    <license>
+      <name>BSD</name>
+      <url>http://www.opensource.org/licenses/bsd-license.php</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.jruby</groupId>
+      <artifactId>jruby-complete</artifactId>
+      <version>1.5.3</version>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <outputDirectory>pkg/classes</outputDirectory>
+    <sourceDirectory>src/java</sourceDirectory>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <configuration>
+          <source>1.5</source>
+          <target>1.5</target>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+
+</project>

data/rails_generators/jdbc_generator.rb

@@ -0,0 +1,15 @@
+class JdbcGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.directory 'config/initializers'
+      m.template 'config/initializers/jdbc.rb', File.join('config', 'initializers', 'jdbc.rb')
+      m.directory 'lib/tasks'
+      m.template 'lib/tasks/jdbc.rake', File.join('lib', 'tasks', 'jdbc.rake')
+    end
+  end
+
+  protected
+  def banner
+    "Usage: #{$0} jdbc\nGenerate JDBC bootstrapping files for your Rails application."
+  end
+end

data/rails_generators/templates/config/initializers/jdbc.rb

@@ -0,0 +1,7 @@
+# This file was generated by the "jdbc" generator, which is provided
+# by the activerecord-jdbc-adapter gem.
+#
+# This file allows the JDBC drivers to be hooked into ActiveRecord
+# such that you don't have to change anything else in your Rails
+# application.
+require 'arjdbc' if defined?(JRUBY_VERSION)

data/rails_generators/templates/lib/tasks/jdbc.rake

@@ -0,0 +1,8 @@
+# This file was generated by the "jdbc" generator, which is provided
+# by the activerecord-jdbc-adapter gem.
+#
+# This file allows you to use Rails' various db:* tasks with JDBC.
+if defined?(JRUBY_VERSION)
+  require 'arjdbc'
+  require 'arjdbc/jdbc/rake_tasks'
+end

data/rakelib/bundler_ext.rb

@@ -0,0 +1,11 @@
+module Bundler
+  class GemHelper
+    def guard_already_tagged
+      # parent project performs the tag
+    end
+    def tag_version
+      Bundler.ui.confirm "Parent project tagged #{version_tag}"
+      yield if block_given?
+    end
+  end
+end

data/rakelib/compile.rake

@@ -0,0 +1,23 @@
+jar_file = File.join(*%w(lib arjdbc jdbc adapter_java.jar))
+begin
+  require 'ant'
+  directory "pkg/classes"
+  CLEAN << "pkg"
+
+  file jar_file => FileList['src/java/**/*.java', 'pkg/classes'] do
+    rm_rf FileList['pkg/classes/**/*']
+    ant.javac :srcdir => "src/java", :destdir => "pkg/classes",
+      :source => "1.5", :target => "1.5", :debug => true,
+      :classpath => "${java.class.path}:${sun.boot.class.path}",
+      :includeantRuntime => false
+
+    ant.jar :basedir => "pkg/classes", :destfile => jar_file, :includes => "**/*.class"
+  end
+
+  desc "Compile the native Java code."
+  task :jar => jar_file
+rescue LoadError
+  task :jar do
+    puts "Run 'jar' with JRuby to re-compile the agent extension class"
+  end
+end

data/rakelib/db.rake

@@ -0,0 +1,39 @@
+namespace :db do
+  desc "Creates the test database for MySQL."
+  task :mysql do
+    load 'test/db/mysql.rb' rescue nil
+    t = Tempfile.new("mysql")
+    t.puts <<-SQL
+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 = ""
+    if ENV['DATABASE_YML']
+      require 'yaml'
+      password = YAML.load(File.new(ENV['DATABASE_YML']))["production"]["password"]
+      password_arg = " --password=#{password}"
+    end
+    sh "cat #{t.path} | mysql -u root#{password_arg}", :verbose => false # so password is not echoed
+  end
+
+  desc "Creates the test database for PostgreSQL."
+  task :postgres do
+    fail unless have_postgres?
+    load 'test/db/postgres.rb' rescue nil
+    t = Tempfile.new("psql")
+    t.puts <<-SQL
+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"
+  end
+end

data/rakelib/rails.rake

@@ -0,0 +1,41 @@
+namespace :rails do
+  def _adapter(n)
+    case n
+    when /postgres/
+      'postgresql'
+    else
+      n
+    end
+  end
+
+  def _driver(n)
+    case n
+    when /postgres/
+      'postgres'
+    else
+      n
+    end
+  end
+
+  def _target(n)
+    case n
+    when /postgres/
+      'test_jdbcpostgresql'
+    else
+      "test_jdbc#{n}"
+    end
+  end
+
+  task :test => :jar do
+    driver = ENV['DRIVER']
+    raise "need a DRIVER" unless driver
+    activerecord = ENV['RAILS']
+    raise "need location of RAILS source code" unless activerecord
+    activerecord = File.join(activerecord, 'activerecord') unless activerecord =~ /activerecord$/
+    ar_jdbc = File.expand_path(File.dirname(__FILE__) + '/..')
+    rubylib = "#{ar_jdbc}/lib:#{ar_jdbc}/jdbc-#{_driver(driver)}/lib:#{ar_jdbc}/activerecord-jdbc#{_adapter(driver)}-adapter/lib"
+    Dir.chdir(activerecord) do
+      rake "RUBYLIB=#{rubylib}", "#{_target(driver)}"
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+/*
+ **** 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.db2;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import arjdbc.jdbc.RubyJdbcConnection;
+
+/**
+ *
+ * @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);
+        clazz.defineAnnotatedMethods(DB2RubyJdbcConnection.class);
+
+        return clazz;
+    }
+
+    private static ObjectAllocator DB2_JDBCCONNECTION_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new DB2RubyJdbcConnection(runtime, klass);
+        }
+    };
+}

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

@@ -0,0 +1,324 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2006-2011 Nick Sieger <nick@nicksieger.com>
+ * Copyright (c) 2006-2007 Ola Bini <ola.bini@gmail.com>
+ *
+ * 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.derby;
+
+import java.sql.SQLException;
+
+import arjdbc.jdbc.RubyJdbcConnection;
+
+import org.jruby.Ruby;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyModule;
+import org.jruby.RubyObjectAdapter;
+import org.jruby.RubyRange;
+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 DerbyModule {
+    private static RubyObjectAdapter rubyApi;
+    public static void load(RubyModule arJdbc, RubyObjectAdapter adapter) {
+        RubyModule derby = arJdbc.defineModuleUnder("Derby");
+        derby.defineAnnotatedMethods(DerbyModule.class);
+        RubyModule column = derby.defineModuleUnder("Column");
+        column.defineAnnotatedMethods(Column.class);
+        rubyApi = adapter;
+    }
+
+    public static class Column {
+        @JRubyMethod(name = "type_cast", required = 1)
+        public static IRubyObject type_cast(IRubyObject recv, IRubyObject value) {
+            Ruby runtime = recv.getRuntime();
+
+            if (value.isNil() || ((value instanceof RubyString) && value.toString().trim().equalsIgnoreCase("null"))) {
+                return runtime.getNil();
+            }
+
+            String type = rubyApi.getInstanceVariable(recv, "@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);
+                }
+            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);
+                }
+            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);
+                }
+            case 'f': //float
+                return rubyApi.callMethod(value, "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 value;
+        }
+    }
+
+    @JRubyMethod(name = "quote", required = 1, optional = 1)
+    public static IRubyObject quote(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+        Ruby runtime = recv.getRuntime();
+        IRubyObject value = args[0];
+        if (args.length > 1) {
+            IRubyObject col = args[1];
+            String type = rubyApi.callMethod(col, "type").toString();
+            // intercept and change value, maybe, if the column type is :text or :string
+            if (type.equals("text") || type.equals("string")) {
+            	value = make_ruby_string_for_text_column(context, recv, runtime, value);
+            }
+            String metaClass = value.getMetaClass().getName();
+
+            if (value instanceof RubyString) {
+                if (type.equals("string")) {
+                    return quote_string_with_surround(runtime, "'", (RubyString)value, "'");
+                } else if (type.equals("text")) {
+                    return quote_string_with_surround(runtime, "CAST('", (RubyString)value, "' AS CLOB)");
+                } else if (type.equals("binary")) {
+                    return hexquote_string_with_surround(runtime, "CAST(X'", (RubyString)value, "' AS BLOB)");
+                } else {
+                    // column type :integer or other numeric or date version
+                    if (only_digits((RubyString)value)) {
+                        return value;
+                    } else {
+                        return super_quote(context, recv, runtime, value, col);
+                    }
+                }
+            } else if (metaClass.equals("Float") || metaClass.equals("Fixnum") || metaClass.equals("Bignum")) {
+                if (type.equals("string")) {
+                    return quote_string_with_surround(runtime, "'", RubyString.objAsString(context, value), "'");
+                }
+            }
+        }
+        return super_quote(context, recv, runtime, value, runtime.getNil());
+    }
+
+    /*
+     * 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) {
+    	RubyModule multibyteChars = (RubyModule)
+            ((RubyModule) ((RubyModule) runtime.getModule("ActiveSupport")).getConstant("Multibyte")).getConstantAt("Chars");
+        if (value instanceof RubyString || rubyApi.isKindOf(value, multibyteChars) || value.isNil()) {
+            return value;
+        }
+
+        String metaClass = value.getMetaClass().getName();
+
+        if (value instanceof RubyBoolean) {
+            return value.isTrue() ? runtime.newString("1") : runtime.newString("0");
+        } else if (metaClass.equals("Float") || metaClass.equals("Fixnum") || metaClass.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");
+            }
+        }
+    }
+
+    private final static ByteList NULL = new ByteList("NULL".getBytes());
+
+    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");
+        }
+
+        String metaClass = value.getMetaClass().getName();
+
+        IRubyObject type = (col.isNil()) ? col : rubyApi.callMethod(col, "type");
+        RubyModule multibyteChars = (RubyModule)
+            ((RubyModule) ((RubyModule) runtime.getModule("ActiveSupport")).getConstant("Multibyte")).getConstantAt("Chars");
+        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()) {
+            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")) {
+            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")), "'");
+        }
+    }
+
+    private final static ByteList TWO_SINGLE = new ByteList(new byte[]{'\'','\''});
+
+    private static IRubyObject quote_string_with_surround(Ruby runtime, String before, RubyString string, String after) {
+        ByteList input = string.getByteList();
+        ByteList output = new ByteList(before.getBytes());
+        for(int i = input.begin; i< input.begin + input.realSize; i++) {
+            switch(input.bytes[i]) {
+            case '\'':
+                output.append(input.bytes[i]);
+                //FALLTHROUGH
+            default:
+                output.append(input.bytes[i]);
+            }
+
+        }
+
+        output.append(after.getBytes());
+
+        return runtime.newString(output);
+    }
+
+    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(Ruby runtime, String before, RubyString string, String after) {
+        ByteList input = string.getByteList();
+        ByteList output = new ByteList(before.getBytes());
+        int written = 0;
+        for(int i = input.begin; i< input.begin + input.realSize; i++) {
+            byte b1 = input.bytes[i];
+            byte higher = HEX[(((char)b1)>>4)%16];
+            byte lower = HEX[((char)b1)%16];
+            output.append(higher);
+            output.append(lower);
+            written += 2;
+            if(written >= 16334) { // max hex length = 16334
+                output.append("'||X'".getBytes());
+                written = 0;
+            }
+        }
+
+        output.append(after.getBytes());
+        return runtime.newStringShared(output);
+    }
+
+    private static boolean only_digits(RubyString inp) {
+        ByteList input = inp.getByteList();
+        for(int i = input.begin; i< input.begin + input.realSize; i++) {
+            if(input.bytes[i] < '0' || input.bytes[i] > '9') {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @JRubyMethod(name = "quote_string", required = 1)
+    public static IRubyObject quote_string(IRubyObject recv, IRubyObject string) {
+        boolean replacementFound = false;
+        ByteList bl = ((RubyString) string).getByteList();
+
+        for(int i = bl.begin; i < bl.begin + bl.realSize; i++) {
+            switch (bl.bytes[i]) {
+            case '\'': break;
+            default: continue;
+            }
+
+            // On first replacement allocate a different bytelist so we don't manip original
+            if(!replacementFound) {
+                i-= bl.begin;
+                bl = new ByteList(bl);
+                replacementFound = true;
+            }
+
+            bl.replace(i, 1, TWO_SINGLE);
+            i+=1;
+        }
+        if(replacementFound) {
+            return recv.getRuntime().newStringShared(bl);
+        } else {
+            return string;
+        }
+    }
+
+    @JRubyMethod(name = "select_all", rest = true)
+    public static IRubyObject select_all(IRubyObject recv, IRubyObject[] args) {
+        return rubyApi.callMethod(recv, "execute", args);
+    }
+
+    @JRubyMethod(name = "select_one", rest = true)
+    public static IRubyObject select_one(IRubyObject recv, IRubyObject[] args) {
+        IRubyObject limit = rubyApi.getInstanceVariable(recv, "@limit");
+        if (limit == null || limit.isNil()) {
+            rubyApi.setInstanceVariable(recv, "@limit", recv.getRuntime().newFixnum(1));
+        }
+        try {
+            IRubyObject result = rubyApi.callMethod(recv, "execute", args);
+            return rubyApi.callMethod(result, "first");
+        } finally {
+            rubyApi.setInstanceVariable(recv, "@limit", recv.getRuntime().getNil());
+        }
+    }
+
+    @JRubyMethod(name = "_execute", required = 1, optional = 1)
+    public static IRubyObject _execute(ThreadContext context, IRubyObject recv, IRubyObject[] args) throws SQLException, java.io.IOException {
+        Ruby runtime = recv.getRuntime();
+        RubyJdbcConnection conn = (RubyJdbcConnection) rubyApi.getInstanceVariable(recv, "@connection");
+        String sql = args[0].toString().trim().toLowerCase();
+        if (sql.charAt(0) == '(') {
+            sql = sql.substring(1).trim();
+        }
+        if (sql.startsWith("insert")) {
+            return conn.execute_insert(context, args[0]);
+        } else if (sql.startsWith("select") || sql.startsWith("show") || sql.startsWith("values")) {
+            return conn.execute_query(context, args[0]);
+        } else {
+            return conn.execute_update(context, args[0]);
+        }
+    }
+}