intentmedia-activerecord-jdbc-adapter 1.1.1.1

data/lib/arjdbc/version.rb

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

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/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/compile.rake

@@ -0,0 +1,25 @@
+def java_classpath_arg # myriad of ways to discover JRuby classpath
+  begin
+    cpath  = Java::java.lang.System.getProperty('java.class.path').split(File::PATH_SEPARATOR)
+    cpath += Java::java.lang.System.getProperty('sun.boot.class.path').split(File::PATH_SEPARATOR)
+    jruby_cpath = cpath.compact.join(File::PATH_SEPARATOR)
+  rescue => e
+  end
+  unless jruby_cpath
+    jruby_cpath = ENV['JRUBY_PARENT_CLASSPATH'] || ENV['JRUBY_HOME'] &&
+      FileList["#{ENV['JRUBY_HOME']}/lib/*.jar"].join(File::PATH_SEPARATOR)
+  end
+  jruby_cpath ? "-cp \"#{jruby_cpath}\"" : ""
+end
+
+jar_name = File.join(*%w(lib arjdbc jdbc adapter_java.jar))
+
+desc "Compile the native Java code."
+task :java_compile do
+  debug = ENV['DEBUG'] ? '-g' : ''
+  pkg_classes = File.join(*%w(pkg classes))
+  mkdir_p pkg_classes
+  sh "javac -target 1.5 -source 1.5 #{debug} -d pkg/classes #{java_classpath_arg} #{FileList['src/java/**/*.java'].join(' ')}"
+  sh "jar cf #{jar_name} -C #{pkg_classes} ."
+end
+file jar_name => :java_compile

data/rakelib/db.rake

@@ -0,0 +1,19 @@
+namespace :db do
+  task :load_arjdbc do
+    $LOAD_PATH.unshift 'test'
+    $LOAD_PATH.unshift 'lib'
+    require 'abstract_db_create'
+  end
+
+  desc "Creates the test database for MySQL."
+  task :mysql => :load_arjdbc do
+    load 'test/db/mysql.rb' rescue nil
+    def db_config
+      MYSQL_CONFIG
+    end
+    extend AbstractDbCreate
+    do_setup('arjdbc', nil)
+    Rake::Task['db:drop'].invoke rescue nil
+    Rake::Task['db:create'].invoke
+  end
+end

data/rakelib/package.rake

@@ -0,0 +1,91 @@
+MANIFEST = FileList["History.txt", "Manifest.txt", "README.txt",
+  "Rakefile", "LICENSE.txt", "lib/**/*.rb", "lib/arjdbc/jdbc/adapter_java.jar", "test/**/*.rb",
+   "lib/**/*.rake", "src/**/*.java", "rakelib/*.rake", "rails_generators/**/*"]
+
+file "Manifest.txt" => :manifest
+task :manifest do
+  File.open("Manifest.txt", "w") {|f| MANIFEST.each {|n| f << "#{n}\n"} }
+end
+Rake::Task['manifest'].invoke # Always regen manifest, so Hoe has up-to-date list of files
+
+require File.dirname(__FILE__) + "/../lib/arjdbc/version"
+begin
+  require 'hoe'
+  Hoe.plugin :gemcutter
+  hoe = Hoe.spec("activerecord-jdbc-adapter") do |p|
+    p.version = ArJdbc::Version::VERSION
+    p.spec_extras[:files] = MANIFEST
+    p.rubyforge_name = "jruby-extras"
+    p.url = "http://jruby-extras.rubyforge.org/activerecord-jdbc-adapter"
+    p.author = "Nick Sieger, Ola Bini and JRuby contributors"
+    p.email = "nick@nicksieger.com, ola.bini@gmail.com"
+    p.summary = "JDBC adapter for ActiveRecord, for use within JRuby on Rails."
+    p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+    p.description = p.paragraphs_of('README.txt', 0...1).join("\n\n")
+  end
+  hoe.spec.rdoc_options += ["-SHN", "-f", "darkfish"]
+
+  task :gemspec do
+    File.open("#{hoe.name}.gemspec", "w") {|f| f << hoe.spec.to_ruby }
+  end
+  task :package => :gemspec
+rescue LoadError => le
+  puts le.to_s, *le.backtrace
+  puts "Problem loading Hoe; please check the error above to ensure that Hoe is installed correctly"
+rescue => e
+  puts "ignoring error while loading Hoe: #{e.to_s}"
+end
+
+def rake(*args)
+  ruby "-S", "rake", *args
+end
+
+%w(test package install_gem release clean).each do |task|
+  desc "Run rake #{task} on all available adapters and drivers"
+  task "all:#{task}" => task
+  task "adapters:#{task}" => task
+end
+
+(Dir["drivers/*/Rakefile"] + Dir["adapters/*/Rakefile"]).each do |rakefile|
+  dir = File.dirname(rakefile)
+  prefix = dir.sub(%r{/}, ':')
+  tasks = %w(package install_gem debug_gem clean gemspec)
+  tasks << "test" if File.directory?(File.join(dir, "test"))
+  tasks.each do |task|
+    desc "Run rake #{task} on #{dir}"
+    task "#{prefix}:#{task}" do
+      Dir.chdir(dir) do
+        rake task
+      end
+    end
+
+    task "#{File.dirname(dir)}:#{task}" => "#{prefix}:#{task}"
+    task "all:#{task}" => "#{prefix}:#{task}"
+  end
+
+  # Copy all generated gems to the top-level pkg directory for convenience
+  task "#{prefix}:package" do
+    FileList["#{dir}/pkg/*.gem"].each {|gem| cp gem, "pkg"}
+  end
+
+  desc "Run rake release on #{dir}"
+  task "#{prefix}:release" do
+    Dir.chdir(dir) do
+      version = nil
+      if dir =~ /adapters/
+        version = ENV['VERSION']
+      else
+        Dir["lib/**/*.rb"].each do |file|
+          version ||= File.open(file) {|f| f.read =~ /VERSION = "([^"]+)"/ && $1}
+        end
+      end
+      rake "release", "VERSION=#{version}"
+    end
+  end
+  # Only release adapters synchronously with main release. Drivers are versioned
+  # according to their JDBC driver versions.
+  if dir =~ /adapters/
+    task "adapters:release" => "#{prefix}:release"
+    task "all:release" => "#{prefix}:release"
+  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 => "java_compile" 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}/drivers/#{_driver(driver)}/lib:#{ar_jdbc}/adapters/#{_adapter(driver)}/lib"
+    Dir.chdir(activerecord) do
+      rake "RUBYLIB=#{rubylib}", "#{_target(driver)}"
+    end
+  end
+end

data/rakelib/test.rake

@@ -0,0 +1,81 @@
+require File.expand_path('../../test/helper', __FILE__)
+if defined?(JRUBY_VERSION)
+  databases = [:test_mysql, :test_jdbc, :test_sqlite3, :test_derby, :test_hsqldb, :test_h2]
+  if find_executable?("psql") && `psql -c '\\l'` && $?.exitstatus == 0
+    databases << :test_postgres
+  end
+  if File.exist?('test/fscontext.jar')
+    databases << :test_jndi
+  end
+  task :test => databases
+else
+  task :test => [:test_mysql]
+end
+
+def declare_test_task_for(adapter, options = {})
+  driver = options[:driver] || adapter
+  Rake::TestTask.new("test_#{adapter}") do |t|
+    files = FileList["test/#{adapter}*test.rb"]
+    if adapter == "derby"
+      files << 'test/activerecord/connection_adapters/type_conversion_test.rb'
+    end
+    t.test_files = files
+    t.libs = []
+    if defined?(JRUBY_VERSION)
+      t.ruby_opts << "-rjdbc/#{driver}"
+      t.libs << "lib" << "drivers/#{driver}/lib"
+      t.libs.push *FileList["adapters/#{adapter}*/lib"]
+    end
+    t.libs << "test"
+    t.verbose = true
+  end
+end
+
+declare_test_task_for :derby
+declare_test_task_for :h2
+declare_test_task_for :hsqldb
+declare_test_task_for :mssql, :driver => :jtds
+declare_test_task_for :mysql
+declare_test_task_for :postgres
+declare_test_task_for :sqlite3
+
+Rake::TestTask.new(:test_jdbc) do |t|
+  t.test_files = FileList['test/generic_jdbc_connection_test.rb']
+  t.libs << 'test' << 'drivers/mysql/lib'
+end
+
+Rake::TestTask.new(:test_jndi) do |t|
+  t.test_files = FileList['test/jndi*_test.rb']
+  t.libs << 'test' << 'drivers/derby/lib'
+end
+
+task :test_postgresql => [:test_postgres]
+task :test_pgsql => [:test_postgres]
+
+# Ensure driver for these DBs is on your classpath
+%w(oracle db2 cachedb informix).each do |d|
+  Rake::TestTask.new("test_#{d}") do |t|
+    t.test_files = FileList["test/#{d}*_test.rb"]
+    t.libs = []
+    t.libs << 'lib' if defined?(JRUBY_VERSION)
+    t.libs << 'test'
+  end
+end
+
+# Tests for JDBC adapters that don't require a database.
+Rake::TestTask.new(:test_jdbc_adapters) do | t |
+  t.test_files = FileList[ 'test/jdbc_adapter/jdbc_sybase_test.rb' ]
+  t.libs << 'test'
+end
+
+# Ensure that the jTDS driver is in your classpath before launching rake
+Rake::TestTask.new(:test_sybase_jtds) do |t|
+  t.test_files = FileList['test/sybase_jtds_simple_test.rb']
+  t.libs << 'test' 
+end
+
+# Ensure that the jConnect driver is in your classpath before launching rake
+Rake::TestTask.new(:test_sybase_jconnect) do |t|
+  t.test_files = FileList['test/sybase_jconnect_simple_test.rb']
+  t.libs << 'test' 
+end

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

@@ -0,0 +1,322 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2006-2007, 2010 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.RubyBigDecimal;
+import org.jruby.RubyBignum;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyFloat;
+import org.jruby.RubyModule;
+import org.jruby.RubyNumeric;
+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);
+            }
+            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 ((value instanceof RubyFloat) || (value instanceof RubyFixnum) || (value instanceof RubyBignum)) {
+                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;
+		}
+		if (value instanceof RubyBoolean) {
+            return value.isTrue() ? runtime.newString("1") : runtime.newString("0");
+		} else if (value instanceof RubyFloat || value instanceof RubyFixnum || value instanceof RubyBignum) {
+			return RubyString.objAsString(context, value);
+		} else if ( value instanceof RubyBigDecimal) {
+			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");
+        }
+
+        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((value instanceof RubyFloat) || (value instanceof RubyFixnum) || (value instanceof RubyBignum)) {
+            return RubyString.objAsString(context, value);
+        } else if(value instanceof RubyBigDecimal) {
+            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]);
+        }
+    }
+}