saturnflyer-activerecord-jdbc-adapter 0.9.3

data/lib/jdbc_adapter/rake_tasks.rb

@@ -0,0 +1,10 @@
+if defined?(Rake.application) && Rake.application && ENV["SKIP_AR_JDBC_RAKE_REDEFINES"].nil?
+  jdbc_rakefile = File.dirname(__FILE__) + "/jdbc.rake"
+  if Rake.application.lookup("environment")
+    # rails tasks already defined; load the override tasks now
+    load jdbc_rakefile
+  else
+    # rails tasks not loaded yet; load as an import
+    Rake.application.add_import(jdbc_rakefile)
+  end
+end

data/lib/jdbc_adapter/tsql_helper.rb

@@ -0,0 +1,60 @@
+# Common methods for handling TSQL databases.
+module TSqlMethods
+
+  def modify_types(tp) #:nodoc:
+    tp[:primary_key] = "int NOT NULL IDENTITY(1, 1) PRIMARY KEY"
+    tp[:integer][:limit] = nil
+    tp[:boolean] = {:name => "bit"}
+    tp[:binary] = { :name => "image"}
+    tp
+  end
+
+  def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+    return 'uniqueidentifier' if (type.to_s == 'uniqueidentifier')
+    return super unless type.to_s == 'integer'
+    
+    if limit.nil? || limit == 4
+      'int'
+    elsif limit == 2
+      'smallint'
+    elsif limit == 1
+      'tinyint'
+    else
+      'bigint'
+    end
+  end
+
+  def add_limit_offset!(sql, options)
+    if options[:limit] and options[:offset]
+      total_rows = select_all("SELECT count(*) as TotalRows from (#{sql.gsub(/\bSELECT(\s+DISTINCT)?\b/i, "SELECT\\1 TOP 1000000000")}) tally")[0]["TotalRows"].to_i
+      if (options[:limit] + options[:offset]) >= total_rows
+        options[:limit] = (total_rows - options[:offset] >= 0) ? (total_rows - options[:offset]) : 0
+      end
+      sql.sub!(/^\s*SELECT(\s+DISTINCT)?/i, "SELECT * FROM (SELECT TOP #{options[:limit]} * FROM (SELECT\\1 TOP #{options[:limit] + options[:offset]} ")
+      sql << ") AS tmp1"
+      if options[:order]
+        options[:order] = options[:order].split(',').map do |field|
+          parts = field.split(" ")
+          tc = parts[0]
+          if sql =~ /\.\[/ and tc =~ /\./ # if column quoting used in query
+            tc.gsub!(/\./, '\\.\\[')
+            tc << '\\]'
+          end
+          if sql =~ /#{tc} AS (t\d_r\d\d?)/
+              parts[0] = $1
+          elsif parts[0] =~ /\w+\.(\w+)/
+            parts[0] = $1
+          end
+          parts.join(' ')
+        end.join(', ')
+        sql << " ORDER BY #{change_order_direction(options[:order])}) AS tmp2 ORDER BY #{options[:order]}"
+      else
+        sql << " ) AS tmp2"
+      end
+    elsif sql !~ /^\s*SELECT (@@|COUNT\()/i
+      sql.sub!(/^\s*SELECT(\s+DISTINCT)?/i) do
+        "SELECT#{$1} TOP #{options[:limit]}"
+      end unless options[:limit].nil?
+    end
+  end
+end

data/lib/jdbc_adapter/version.rb

@@ -0,0 +1,5 @@
+module JdbcAdapter
+  module Version
+    VERSION = "0.9.2"
+  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>0.9.2</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.1.6</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/rakelib/compile.rake

@@ -0,0 +1,23 @@
+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
+
+desc "Compile the native Java code."
+task :java_compile do
+  pkg_classes = File.join(*%w(pkg classes))
+  jar_name = File.join(*%w(lib jdbc_adapter jdbc_adapter_internal.jar))
+  mkdir_p pkg_classes
+  sh "javac -target 1.5 -source 1.5 -d pkg/classes #{java_classpath_arg} #{FileList['src/java/**/*.java'].join(' ')}"
+  sh "jar cf #{jar_name} -C #{pkg_classes} ."
+end
+file "lib/jdbc_adapter/jdbc_adapter_internal.jar" => :java_compile

data/rakelib/package.rake

@@ -0,0 +1,73 @@
+MANIFEST = FileList["History.txt", "Manifest.txt", "README.txt", 
+  "Rakefile", "LICENSE.txt", "lib/**/*.rb", "lib/jdbc_adapter/jdbc_adapter_internal.jar", "test/**/*.rb",
+   "lib/**/*.rake", "src/**/*.java"]
+
+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/jdbc_adapter/version"
+begin
+  require 'hoe'
+  Hoe.new("activerecord-jdbc-adapter", JdbcAdapter::Version::VERSION) do |p|
+    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.spec.dependencies.delete_if { |dep| dep.name == "hoe" }
+rescue LoadError
+  puts "You really need Hoe installed to be able to package this gem"
+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
+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)
+  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
+  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/src/java/jdbc_adapter/JdbcAdapterInternalService.java

@@ -0,0 +1,53 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2006-2009 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 jdbc_adapter;
+
+import java.io.IOException;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyObjectAdapter;
+import org.jruby.javasupport.JavaEmbedUtils;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class JdbcAdapterInternalService implements BasicLibraryService {
+    private static RubyObjectAdapter rubyApi;
+
+    public boolean basicLoad(final Ruby runtime) throws IOException {
+        RubyClass jdbcConnection = RubyJdbcConnection.createJdbcConnectionClass(runtime);
+        PostgresRubyJdbcConnection.createPostgresJdbcConnectionClass(runtime, jdbcConnection);
+        MssqlRubyJdbcConnection.createMssqlJdbcConnectionClass(runtime, jdbcConnection);
+        Sqlite3RubyJdbcConnection.createSqlite3JdbcConnectionClass(runtime, jdbcConnection);
+        RubyModule jdbcSpec = runtime.getOrCreateModule("JdbcSpec");
+
+        rubyApi = JavaEmbedUtils.newObjectAdapter();
+        JdbcMySQLSpec.load(jdbcSpec);
+        JdbcDerbySpec.load(jdbcSpec, rubyApi);
+        return true;
+    }
+}

data/src/java/jdbc_adapter/JdbcConnectionFactory.java

@@ -0,0 +1,36 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2006-2007 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 jdbc_adapter;
+
+import java.sql.Connection;
+
+/**
+ * Interface to be implemented in Ruby for retrieving a new connection
+ *  
+ * @author nicksieger
+ */
+public interface JdbcConnectionFactory {
+    Connection newConnection();
+}

data/src/java/jdbc_adapter/JdbcDerbySpec.java

@@ -0,0 +1,293 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Copyright (c) 2006-2007 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 jdbc_adapter;
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.RubyString;
+import org.jruby.RubyFloat;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyBignum;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyBigDecimal;
+import org.jruby.RubyRange;
+import org.jruby.RubyNumeric;
+
+import org.jruby.runtime.builtin.IRubyObject;
+
+import org.jruby.util.ByteList;
+
+import java.sql.SQLException;
+import org.jruby.RubyObjectAdapter;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+
+public class JdbcDerbySpec {
+    private static RubyObjectAdapter rubyApi;
+    public static void load(RubyModule jdbcSpec, RubyObjectAdapter adapter) {
+        RubyModule derby = jdbcSpec.defineModuleUnder("Derby");
+        derby.defineAnnotatedMethods(JdbcDerbySpec.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();
+            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());
+    }
+
+    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")) {
+            return conn.execute_query(context, args[0]);
+        } else {
+            return conn.execute_update(context, args[0]);
+        }
+    }
+}