dbd-jdbc 0.1.6-java

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dbd-jdbc.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,27 @@
+(C) 2009 Chad Johnson <chad.j.johnson@gmail.com>.
+(C) 2008 Ola Bini <ola.bini@gmail.com>.
+(C) 2006 Kristopher Schmidt <krisschmidt@optonline.net>.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.txt

@@ -0,0 +1,85 @@
+RECENT CHANGES
+==============
+The dbd-jdbc project has recently moved to Github and can be found at the following url 
+(http://github.com/chadj/dbd-jdbc). Please report any bugs found to the issue 
+tracker on Github.
+
+OVERVIEW
+========
+The Jdbc driver for DBI runs only under JRuby, using JRuby's Java integration to act 
+as a thin wrapper around JDBC Connections obtained through DriverManager.  
+Theoretically this driver can support any database that has JDBC support, although the 
+behavior of certain aspects of the DBI API will differ slightly based on the 
+implementation of the JDBC driver and the underlying database (see LIMITATIONS) 
+
+INSTALLATION
+============
+Besides the ruby files being installed with DBI (in DBD/Jdbc), the JDBC driver classes 
+must be added to the JRuby classpath.  One way to do this on UNIX machines is to 
+place a JDBC driver jarfile in JRUBY_HOME/lib.  Another way is to set the CLASSPATH 
+environment variable.  The jruby (or jruby.bat) script can also be modified to add to 
+the classpath.  In the future there may be more dynamic ways to add jarfiles to the 
+classpath as well; check with the JRuby documentation.
+
+USAGE
+=====
+This driver is used like any standard DBI driver, by requiring 'dbi' and obtaining a 
+connection through the DBI.connect method.  The DSN for the database should be "dbi:" 
+followed by the standard Java database URL (jdbc:<subprotocol>:<subname>).  In 
+addition, the attributes hash passed to the connect method must contain the key/value 
+pair "driver" => <jdbc driver class name>.  For example (MySQL):
+
+dbh = DBI.connect('dbi:jdbc:mysql://localhost:3306/test', 'anonymous', '', 
+        { "driver" => "com.mysql.jdbc.Driver" } )
+
+SUPPORTED ATTRIBUTES
+====================
+Besides the mandatory "driver" attribute that must be passed in the DBI connect method, 
+there are additional attributes that can be passed to modify the behavior of the 
+driver.  In addition to setting these attributes during the connect call, they can be 
+set on a driver handle using []= (e.g. dbh["autocommit"] = true).  The currently 
+supported attributes are:
+
+1) autocommit:  sets the autoCommit status of the underlying JDBC Connection 
+   (there is a 1-1 relationship between a DBI Database instance and a JDBC Connection)
+2) nulltype: sets the java.sql.Types constant to use when binding nil to a Statement.  
+   See LIMITATIONS
+
+LIMITATIONS
+===========
+There are limitations to the JDBC driver that are largely based on incompatibilities 
+between the DBI and JDBC APIs, and the differences in underlying JDBC driver 
+implementations.  
+
+1) Binding nil to statements is somewhat unreliable due to the fact that JDBC requires 
+type information in PreparedStatement.setNull(int), but there is no type information 
+associated with nil in ruby.  E.g., statements like DBI.select_all("select * from a, b, 
+c where col1=? and col2=?", "a", nil) might run into problems.  One workaround is to 
+hardcode NULL in the sql statement.  If executing multiple inserts and some values 
+might be nil, the driver will call setNull with the type specified in the driver 
+attribute "nulltype".  If the default fails with a given driver, try specifying 
+different nulltypes such as "dbh['nulltype'] = java.sql.Types::NULL" or 
+"dbh['nulltype'] = java.sql.Types::OTHER" to see if it will work.
+
+2) Type conversion in result sets: Java to Ruby type conversion in results of queries 
+is more limited than in JDBC, since DBI returns an entire row at a time, without type 
+information specified (unlike JDBC ResultSet where getInt, getString, etc allow each 
+column to be typed appropriately).  The driver attempts to convert each data type, 
+relying mostly on getObject() and the JRuby type conversion system.  Due to the fact 
+that JDBC drivers are not constrained to the exact Java types returned for each SQL 
+type, it is possible for some conversion oddities to arise (e.g. returning Java 
+BigDecimal which isn't converted by JRuby, leading to a Java BigDecimal rather than 
+Ruby Fixnum/BigDecimal).
+
+3) Type conversion in prepared statements: In addition to not being able to use type 
+data when returning data, it isn't possible to specify type data directly when binding 
+parameters either (when binding multiple parameters, DBI has ability to set type data, 
+and when calling bind_param, this driver does not currently support type data in the 
+attributes).  Most conversions should work without problem, but there is ambiguity in 
+the Ruby Float type since it can be treated as float or double (or BigDecimal) in Java 
+(and FLOAT, DOUBLE, REAL, NUMERIC, DECIMAL, etc in java.sql.Types).  setDouble() is 
+used to try to retain the highest precision, but some problems have been seen (e.g. 
+Sybase REAL works better with setFloat()).  When doing inserts or retrieval, be sure 
+that the driver keeps the desired precision (the only workaround is to change the 
+database column type to something that works better for doubles with the given JDBC 
+driver and database)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/dbd-jdbc.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dbd/jdbc/version'
+
+Gem::Specification.new do |gem|
+  gem.name              = "dbd-jdbc"
+  gem.version           = DBI::DBD::Jdbc::VERSION
+  gem.authors           = ["Chad Johnson"]
+  gem.email             = ["chad.j.johnson@gmail.com"]
+  gem.description       = %q{A JDBC DBD driver for Ruby DBI}
+  gem.summary           = %q{JDBC driver for DBI, originally by Kristopher Schmidt and Ola Bini}
+  gem.homepage          = "http://github.com/chadj/dbd-jdbc"
+  gem.rubyforge_project = 'jruby-extras'
+  gem.platform          = Gem::Platform::JAVA
+  gem.files             = `git ls-files`.split($/)
+  gem.require_paths     = ["lib"]
+
+  gem.add_development_dependency 'rake'
+
+  # Not adding dbi as a hard dependency, since either the "real" dbi gem
+  # or rails-dbi will work.
+  gem.requirements << 'dbi or ruby-dbi gem'
+end

data/lib/dbd/Jdbc.rb

@@ -0,0 +1,103 @@
+#  (C) 2009 Chad Johnson <chad.j.johnson@gmail.com>.
+#  (C) 2008 Ola Bini <ola.bini@gmail.com>.
+#  (C) 2006 Kristopher Schmidt <krisschmidt@optonline.net>.
+#
+#  All rights reserved.
+#
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions
+#  are met:
+#  1. Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#  3. The name of the author may not be used to endorse or promote products
+#     derived from this software without specific prior written permission.
+#
+#  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+#  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+#  AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+#  THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+#  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+#  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+#  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+#  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+#  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+#  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+require 'java'
+require 'dbi'
+
+module DBI
+  module DBD
+    #
+    # DBD::Jdbc - Database Driver for Java / JDBC
+    #
+    # Requires DBI and JRuby
+    #
+    module Jdbc
+      java_import 'java.sql.Connection'
+      java_import 'java.sql.ResultSet'
+      java_import 'java.util.HashMap'
+      java_import 'java.util.Collections'
+
+      #
+      # Transaction isolation levels copied from JDBC
+      #
+      TRANSACTION_NONE = Connection::TRANSACTION_NONE
+      TRANSACTION_READ_COMMITTED = Connection::TRANSACTION_READ_COMMITTED
+      TRANSACTION_READ_UNCOMMITTED = Connection::TRANSACTION_READ_UNCOMMITTED
+      TRANSACTION_REPEATABLE_READ = Connection::TRANSACTION_REPEATABLE_READ
+      TRANSACTION_SERIALIZABLE = Connection::TRANSACTION_SERIALIZABLE
+      # Convience isolation levels
+      NONE = Connection::TRANSACTION_NONE
+      READ_COMMITTED = Connection::TRANSACTION_READ_COMMITTED
+      READ_UNCOMMITTED = Connection::TRANSACTION_READ_UNCOMMITTED
+      REPEATABLE_READ = Connection::TRANSACTION_REPEATABLE_READ
+      SERIALIZABLE = Connection::TRANSACTION_SERIALIZABLE
+
+      #
+      # returns 'Jdbc'
+      #
+      # See DBI::TypeUtil#convert for more information.
+      #
+      def self.driver_name
+        "Jdbc"
+      end
+
+      module Type
+        class Timestamp < DBI::Type::Null
+          def self.parse(obj)
+            obj = super
+            return obj unless obj
+
+            if obj.kind_of?(::DateTime) || obj.kind_of?(::Time) || obj.kind_of?(::Date)
+              return obj
+            elsif obj.kind_of?(::String)
+              return ::DateTime.strptime(obj, "%Y-%m-%d %H:%M:%S")
+            else
+              return ::DateTime.parse(obj.to_s)   if obj.respond_to? :to_s
+              return ::DateTime.parse(obj.to_str) if obj.respond_to? :to_str
+              return obj
+            end
+          end
+        end
+      end
+
+      #
+      # Bound values pass through this function before being handed to Statement.bind_param
+      #
+      # The false value prevents the default type conversion from occurring
+      #
+      DBI::TypeUtil.register_conversion(driver_name) do |obj|
+        [obj, false]
+      end
+    end
+  end
+end
+
+require 'dbd/jdbc/type_conversion'
+require 'dbd/jdbc/driver'
+require 'dbd/jdbc/database'
+require 'dbd/jdbc/statement'

data/lib/dbd/jdbc/database.rb

@@ -0,0 +1,180 @@
+#  (C) 2009 Chad Johnson <chad.j.johnson@gmail.com>.
+#  (C) 2008 Ola Bini <ola.bini@gmail.com>.
+#  (C) 2006 Kristopher Schmidt <krisschmidt@optonline.net>.
+#
+#  All rights reserved.
+#
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions
+#  are met:
+#  1. Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#  3. The name of the author may not be used to endorse or promote products
+#     derived from this software without specific prior written permission.
+#
+#  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+#  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+#  AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+#  THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+#  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+#  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+#  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+#  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+#  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+#  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+module DBI::DBD::Jdbc
+  #
+  # Models the DBI::BaseDatabase API to create DBI::DatabaseHandle objects.
+  #
+  class Database < DBI::BaseDatabase
+    include TypeConversions
+
+    def initialize(connection)
+      @connection = connection
+      @attributes = {
+        #works with Sybase and Mysql.
+        "nulltype" => java.sql.Types::VARCHAR,
+        "allow_scroll" => false
+      }
+    end
+
+    def disconnect
+      @connection.rollback unless self["autocommit"]
+      @connection.close
+    rescue NativeException => error
+      raise DBI::DatabaseError.new(error.message)
+    end
+
+    def prepare(sql)
+      if self["allow_scroll"]
+        return Statement.new(@connection.prepareStatement(sql,ResultSet::TYPE_SCROLL_INSENSITIVE, ResultSet::CONCUR_READ_ONLY), self["nulltype"], self["allow_scroll"])
+      else
+        return Statement.new(@connection.prepareStatement(sql), self["nulltype"], self["allow_scroll"])
+      end
+    rescue NativeException => error
+      raise DBI::DatabaseError.new(error.message)
+    end
+
+    def do(statement, *bindvars)
+        res = nil
+        if bindvars.nil? || bindvars.empty?
+          stmt = @connection.createStatement()
+          begin
+            stmt.execute(statement)
+          ensure
+            stmt.close rescue NativeException
+          end
+        else
+          stmt = execute(statement, *bindvars)
+          res = stmt.rows
+          stmt.finish
+        end
+        return res
+      rescue NativeException => error
+        raise DBI::DatabaseError.new(error.message)
+      end
+
+      def ping
+        return !@connection.isClosed
+      rescue NativeException => error
+        raise DBI::DatabaseError.new(error.message)
+      end
+
+      def commit
+        @connection.commit()
+      rescue NativeException => error
+        raise DBI::DatabaseError.new(error.message)
+      end
+
+      def rollback
+        @connection.rollback()
+      rescue NativeException => error
+        raise DBI::DatabaseError.new(error.message)
+      end
+
+      def tables
+        rs = @connection.getMetaData.getTables(nil, nil, nil, nil)
+        tables = []
+        while(rs.next())
+          tables << rs.getString(3)
+        end
+        return tables
+      rescue NativeException => error
+        raise DBI::DatabaseError.new(error.message)
+      end
+
+      def columns(table)
+        (table,schema,db) = table.split(".").reverse
+          
+        metaData = @connection.getMetaData()
+        rs = metaData.getColumns(db, schema, table, nil)
+        columns = []
+        while(rs.next())
+          type_name, dbi_type = jdbc_to_dbi_sqltype(rs.getShort(5))
+          columns << {
+            "name" => rs.getString(4),
+            "sql_type" => type_name,
+            "type_name" => rs.getString(6),
+            "precision" => rs.getInt(7),
+            "scale" => rs.getInt(9),
+            "default" => rs.getString(13),
+            "nullable" => (rs.getInt(11) == 1)
+          }
+          columns[-1]["dbi_type"] = dbi_type if dbi_type
+        end
+        return columns
+      rescue NativeException => error
+        raise DBI::DatabaseError.new(error.message)
+      end
+
+      def [](attribute)
+        attribute = attribute.downcase
+        check_attribute(attribute)
+        case attribute
+        when "autocommit" then @connection.getAutoCommit()
+        when "isolation", "isolation_level" then @connection.getTransactionIsolation()
+        else
+          @attributes[attribute]
+        end
+      rescue NativeException => error
+        raise DBI::DatabaseError.new(error.message)
+      end
+
+      def []=(attribute, value)
+        attribute = attribute.downcase
+        check_attribute(attribute)
+        case attribute
+        when "autocommit" then @connection.setAutoCommit(value)
+        when "isolation", "isolation_level" then @connection.setTransactionIsolation(value)
+        else
+          @attributes[attribute] = value
+        end
+      rescue NativeException => error
+        raise DBI::DatabaseError.new(error.message)
+      end
+
+      def java_connection
+        return @connection
+      end
+
+      def self.from_java_connection(java_connection, type_coercion = true)
+        dbh = DBI::DatabaseHandle.new(Database.new(java_connection), type_coercion)
+        dbh.driver_name = "Jdbc"
+        dbh
+      end
+
+      private
+
+      def check_attribute(attribute)
+          raise DBI::NotSupportedError.new("Database attribute #{attribute} is not supported") unless (attribute == "autocommit" ||
+                                                                                                       attribute == "isolation" ||
+                                                                                                       attribute == "isolation_level" ||
+                                                                                                       @attributes.has_key?(attribute))
+      end
+
+    end
+  end # module DBI

data/lib/dbd/jdbc/driver.rb

@@ -0,0 +1,70 @@
+#  (C) 2009 Chad Johnson <chad.j.johnson@gmail.com>.
+#  (C) 2008 Ola Bini <ola.bini@gmail.com>.
+#  (C) 2006 Kristopher Schmidt <krisschmidt@optonline.net>.
+#
+#  All rights reserved.
+#
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions
+#  are met:
+#  1. Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#  3. The name of the author may not be used to endorse or promote products
+#     derived from this software without specific prior written permission.
+#
+#  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+#  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+#  AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+#  THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+#  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+#  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+#  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+#  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+#  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+#  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+module DBI::DBD::Jdbc
+  #
+  # Models the DBI::BaseDriver API to create DBI::DriverHandle objects.
+  #
+  class Driver < DBI::BaseDriver
+
+    def initialize
+      super("0.4.0")
+      #attributes specific to this class.  All attributes in the
+      #connect attributes that aren't in this list will be
+      #applied to the database handle
+      @driverAttributes = [ "driver" ]
+      @loaded_drivers = Collections.synchronizedMap(HashMap.new)
+    end
+
+    def load(name)
+      unless @loaded_drivers.containsKey(name)
+        clazz = java.lang.Class.forName(name,true,JRuby.runtime.jruby_class_loader)
+        java.sql.DriverManager.registerDriver(clazz.newInstance)
+        
+        @loaded_drivers.put(name,true)
+      end
+    end
+
+    def connect(dbname, user, auth, attr)
+      driverClass = attr["driver"]
+      raise DBI::InterfaceError.new('driver class name must be specified as "driver" in connection attributes') unless driverClass
+
+      load(driverClass)
+
+      connection = java.sql.DriverManager.getConnection("jdbc:"+dbname, user, auth)
+      dbh = Database.new(connection)
+
+      (attr.keys - @driverAttributes).each { |key| dbh[key] = attr[key] }
+
+      return dbh
+    rescue NativeException => error
+      raise DBI::DatabaseError.new(error.message)
+    end
+
+  end #Driver
+end

data/lib/dbd/jdbc/statement.rb

@@ -0,0 +1,212 @@
+#  (C) 2009 Chad Johnson <chad.j.johnson@gmail.com>.
+#  (C) 2008 Ola Bini <ola.bini@gmail.com>.
+#  (C) 2006 Kristopher Schmidt <krisschmidt@optonline.net>.
+#
+#  All rights reserved.
+#
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions
+#  are met:
+#  1. Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#  3. The name of the author may not be used to endorse or promote products
+#     derived from this software without specific prior written permission.
+#
+#  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+#  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+#  AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+#  THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+#  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+#  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+#  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+#  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+#  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+#  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+module DBI::DBD::Jdbc
+  #
+  # Models the DBI::BaseStatement API to create DBI::StatementHandle objects.
+  #
+  class Statement < DBI::BaseStatement
+    include TypeConversions
+
+    def initialize(statement, nulltype, allow_scroll = false)
+      @statement = statement
+      @nulltype = nulltype
+      @allow_scroll = allow_scroll
+      @rows = nil
+      @data = []
+    end
+
+    def bind_param(param, value, attribs)
+      raise DBI::InterfaceError.new("Statement.bind_param only supports numeric placeholder numbers") unless param.is_a?(Fixnum)
+      if value.nil?
+        @statement.setNull(param, @nulltype)
+      elsif value.is_a?(String)
+        #
+        # The syntax below appears to be the best way to ensure that
+        # RubyStrings get converted to Java Strings correctly if it
+        # contains UTF-8.
+        #
+        # java.lang.String.new() will assume the system default
+        # encoding when converting the RubyString bytes ....
+        #
+        @statement.setString(param, java.lang.String.new(value))
+      elsif value.is_a?(Fixnum)
+        #no reason not to coerce it to a long?
+        @statement.setLong(param, value)
+      elsif value.is_a?(Float)
+        #despite DBD spec saying Float->SQL Float, using Double gives
+        #better precision and passes tests that setFloat does not.
+        @statement.setDouble(param, value)
+      elsif value.is_a?(::DateTime) || value.is_a?(DBI::Timestamp)
+        @statement.setTimestamp(param, timestamp_to_jdbctimestamp(value))
+      elsif value.is_a?(::Date) || value.is_a?(DBI::Date)
+        @statement.setDate(param, date_to_jdbcdate(value))
+      elsif value.is_a?(::Time) || value.is_a?(DBI::Time)
+        @statement.setTime(param, time_to_jdbctime(value))
+      else
+        @statement.setObject(param, value)
+      end
+    rescue NativeException => error
+      raise DBI::DatabaseError.new(error.message)
+    end
+
+    def execute
+      if @statement.execute()
+        @rs = @statement.getResultSet
+        @rows = nil
+        @data.clear
+      else
+        @rs = nil
+        @rows = @statement.getUpdateCount
+      end
+    rescue NativeException => error
+      raise DBI::DatabaseError.new(error.message)
+    end
+
+    def finish
+      @statement.close()
+      @rs = nil
+      @rows = nil
+    rescue NativeException => error
+      raise DBI::DatabaseError.new(error.message)
+    end
+
+    def fetch
+      if (@rs && @rs.next())
+        return fill_data
+      else
+        return nil
+      end
+    rescue NativeException => error
+      raise DBI::DatabaseError.new(error.message)
+    end
+
+    def fill_data
+      @data.clear
+      metaData = @rs.getMetaData()
+      (1..metaData.getColumnCount()).each do |columnNumber|
+        @data << get_value(columnNumber, @rs, metaData)
+      end
+      return @data
+    end
+
+    #
+    # Unless "allow_scroll" was set on this connection this will default to the
+    # DBI::BaseStatement#fetch_scroll implementation.
+    #
+    # See DBI::BaseStatement#fetch_scroll. These additional constants are supported
+    # when "allow_scroll" is set on the connection.
+    #
+    # * DBI::SQL_FETCH_PRIOR: Fetch the row previous to the current one.
+    # * DBI::SQL_FETCH_FIRST: Fetch the first row.
+    # * DBI::SQL_FETCH_ABSOLUTE: Fetch the row at the offset provided.
+    # * DBI::SQL_FETCH_RELATIVE: Fetch the row at the current point + offset.
+    #
+    def fetch_scroll(direction, offset)
+      return super(direction, offset) unless @allow_scroll
+
+      case direction
+      when DBI::SQL_FETCH_NEXT
+        fill_data if @rs && @rs.next()
+      when DBI::SQL_FETCH_PRIOR
+        fill_data if @rs && @rs.previous()
+      when DBI::SQL_FETCH_FIRST
+        fill_data if @rs && @rs.first()
+      when DBI::SQL_FETCH_LAST
+        fill_data if @rs && @rs.last()
+      when DBI::SQL_FETCH_ABSOLUTE
+        fill_data if @rs && @rs.absolute(offset)
+      when DBI::SQL_FETCH_RELATIVE
+        fill_data if @rs && @rs.relative(offset)
+      else
+        raise DBI::NotSupportedError
+      end
+    rescue NativeException => error
+      raise DBI::NotSupportedError.new(error.message)
+    end
+
+    def column_info
+      info = Array.new
+      return info unless @rs
+      metaData = @rs.getMetaData()
+      (1..metaData.getColumnCount()).each do |columnNumber|
+        type_name, dbi_type = jdbc_to_dbi_sqltype(metaData.getColumnType(columnNumber))
+        info << {
+          "name" => metaData.getColumnName(columnNumber),
+          "sql_type" => type_name,
+          "type_name" => metaData.getColumnTypeName(columnNumber),
+          "precision" => metaData.getPrecision(columnNumber),
+          "scale" => metaData.getScale(columnNumber),
+          "nullable" => (metaData.isNullable(columnNumber) == 1)
+        }
+        info[-1]["dbi_type"] = dbi_type if dbi_type
+      end
+      return info
+    rescue NativeException => error
+      raise DBI::DatabaseError.new(error.message)
+    end
+
+    def rows
+      return @rows
+    end
+
+    def self.from_java_statement(java_statement, type_coercion = false, null_type = java.sql.Types::VARCHAR)
+      raise DBI::DatabaseError.new("Only java.sql.PreparedStatement instances accepted") unless java_statement.kind_of?(java.sql.PreparedStatement)
+
+      DBI::StatementHandle.new(Statement.new(java_statement, null_type), true, true, type_coercion)
+    end
+
+    private
+
+    def get_value(columnNumber, rs, metaData)
+      #note only map things that seem unlikely to coerce properly to jruby,
+      #since anything mapped as primitive type cannot be returned as null
+      return case metaData.getColumnType(columnNumber)
+      when java.sql.Types::BIT
+        rs.getBoolean(columnNumber)
+      when java.sql.Types::NUMERIC, java.sql.Types::DECIMAL
+        # TODO: Find a better way to return Numerics and Decimals as nil when they are null in the DB
+        if rs.getObject(columnNumber)
+            metaData.getScale(columnNumber) == 0 ? rs.getLong(columnNumber) : rs.getDouble(columnNumber)
+        else
+            nil
+        end
+      when java.sql.Types::DATE
+        jdbcdate_to_date(rs.getDate(columnNumber))
+      when java.sql.Types::TIME
+        jdbctime_to_time(rs.getTime(columnNumber))
+      when java.sql.Types::TIMESTAMP
+        jdbctimestamp_to_timestamp(rs.getTimestamp(columnNumber))
+      else
+        rs.getObject(columnNumber)
+      end
+    end
+
+  end # class Statement
+
+end # module Jdbc

data/lib/dbd/jdbc/type_conversion.rb

@@ -0,0 +1,123 @@
+#  (C) 2009 Chad Johnson <chad.j.johnson@gmail.com>.
+#  (C) 2008 Ola Bini <ola.bini@gmail.com>.
+#  (C) 2006 Kristopher Schmidt <krisschmidt@optonline.net>.
+#
+#  All rights reserved.
+#
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions
+#  are met:
+#  1. Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#  3. The name of the author may not be used to endorse or promote products
+#     derived from this software without specific prior written permission.
+#
+#  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+#  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+#  AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+#  THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+#  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+#  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+#  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+#  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+#  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+#  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+module DBI::DBD::Jdbc::TypeConversions
+  java_import 'java.util.Calendar'
+  java_import 'java.sql.Types'
+
+  def jdbc_to_dbi_sqltype(jdbctype)
+    return case jdbctype
+    when Types::BIGINT then [DBI::SQL_BIGINT, nil]
+    when Types::BINARY then [DBI::SQL_BINARY, nil]
+    when Types::BIT then [DBI::SQL_BIT, DBI::Type::Boolean]
+    when Types::CHAR then [DBI::SQL_CHAR, nil]
+    when Types::DATE then [DBI::SQL_DATE, DBI::DBD::Jdbc::Type::Timestamp]
+    when Types::DECIMAL then [DBI::SQL_DECIMAL, nil]
+    when Types::DOUBLE then [DBI::SQL_DOUBLE, nil]
+    when Types::FLOAT then [DBI::SQL_FLOAT, nil]
+    when Types::INTEGER then [DBI::SQL_INTEGER, nil]
+    when Types::LONGVARBINARY then [DBI::SQL_LONGVARBINARY, nil]
+    when Types::LONGVARCHAR then [DBI::SQL_LONGVARCHAR, nil]
+    when Types::NUMERIC then [DBI::SQL_NUMERIC, nil]
+    when Types::REAL then [DBI::SQL_REAL, nil]
+    when Types::SMALLINT then [DBI::SQL_SMALLINT, nil]
+    when Types::TIME then [DBI::SQL_TIME, DBI::DBD::Jdbc::Type::Timestamp]
+    when Types::TIMESTAMP then [DBI::SQL_TIMESTAMP, DBI::DBD::Jdbc::Type::Timestamp]
+    when Types::TINYINT then [DBI::SQL_TINYINT, nil]
+    when Types::VARBINARY then [DBI::SQL_VARBINARY, nil]
+    when Types::VARCHAR then [DBI::SQL_VARCHAR, nil]
+    else
+      [DBI::SQL_OTHER, nil]
+    end
+  end
+
+  def date_to_jdbcdate(dbidate)
+    cal = Calendar.getInstance()
+    set_calendar_date_fields(dbidate, cal)
+    return java.sql.Date.new(cal.getTime().getTime())
+  end
+
+  def time_to_jdbctime(dbitime)
+    cal = Calendar.getInstance()
+    set_calendar_date_fields(dbitime, cal)
+    set_calendar_time_fields(dbitime, cal)
+    return java.sql.Time.new(cal.getTime().getTime())
+  end
+
+  def timestamp_to_jdbctimestamp(dbitimestamp)
+    cal = Calendar.getInstance()
+    set_calendar_date_fields(dbitimestamp, cal)
+    set_calendar_time_fields(dbitimestamp, cal)
+    return java.sql.Timestamp.new(cal.getTime().getTime())
+  end
+
+  def jdbcdate_to_date(jdbcdate)
+    return nil if jdbcdate.nil?
+    cal = get_calendar(jdbcdate)
+    return ::Date.new(cal.get(Calendar::YEAR), cal.get(Calendar::MONTH)+1, cal.get(Calendar::DAY_OF_MONTH))
+  end
+
+  def jdbctime_to_time(jdbctime)
+    return nil if jdbctime.nil?
+    cal = get_calendar(jdbctime)
+    return ::Time.mktime(cal.get(Calendar::YEAR), cal.get(Calendar::MONTH)+1, cal.get(Calendar::DAY_OF_MONTH), cal.get(Calendar::HOUR_OF_DAY), cal.get(Calendar::MINUTE), cal.get(Calendar::SECOND), cal.get(Calendar::MILLISECOND) * 1000)
+  end
+
+  def jdbctimestamp_to_timestamp(jdbctimestamp)
+    return nil if jdbctimestamp.nil?
+    cal = get_calendar(jdbctimestamp)
+    return ::DateTime.new(cal.get(Calendar::YEAR), cal.get(Calendar::MONTH)+1, cal.get(Calendar::DAY_OF_MONTH), cal.get(Calendar::HOUR_OF_DAY), cal.get(Calendar::MINUTE), cal.get(Calendar::SECOND))
+  end
+
+  private
+
+  def set_calendar_date_fields(dbidate, cal)
+    cal.set(Calendar::YEAR, dbidate.year) if dbidate.respond_to? :year
+    cal.set(Calendar::MONTH, dbidate.month-1) if dbidate.respond_to? :month
+    cal.set(Calendar::DAY_OF_MONTH, dbidate.day) if dbidate.respond_to? :day
+  end
+
+  def set_calendar_time_fields(dbitime, cal)
+    cal.set(Calendar::HOUR_OF_DAY, dbitime.hour)
+    cal.set(Calendar::MINUTE, dbitime.min)
+    cal.set(Calendar::SECOND, dbitime.sec)
+
+    if dbitime.respond_to? :strftime
+      cal.set(Calendar::MILLISECOND, dbitime.strftime('%L').to_i)
+    else
+      cal.set(Calendar::MILLISECOND, 0)
+    end
+  end
+
+  def get_calendar(jdbctype)
+    cal = Calendar.getInstance()
+    cal.setTime(java.util.Date.new(jdbctype.getTime()))
+    return cal
+  end
+
+end

data/lib/dbd/jdbc/version.rb

@@ -0,0 +1,7 @@
+module DBI
+  module DBD
+    module Jdbc
+      VERSION = "0.1.6"
+    end
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: dbd-jdbc
+version: !ruby/object:Gem::Version
+  version: 0.1.6
+  prerelease:
+platform: java
+authors:
+- Chad Johnson
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-01-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+description: A JDBC DBD driver for Ruby DBI
+email:
+- chad.j.johnson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.txt
+- Rakefile
+- dbd-jdbc.gemspec
+- lib/dbd/Jdbc.rb
+- lib/dbd/jdbc/database.rb
+- lib/dbd/jdbc/driver.rb
+- lib/dbd/jdbc/statement.rb
+- lib/dbd/jdbc/type_conversion.rb
+- lib/dbd/jdbc/version.rb
+homepage: http://github.com/chadj/dbd-jdbc
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      segments:
+      - 0
+      version: !binary |-
+        MA==
+      hash: 2
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      segments:
+      - 0
+      version: !binary |-
+        MA==
+      hash: 2
+  none: false
+requirements:
+- dbi or ruby-dbi gem
+rubyforge_project: jruby-extras
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: JDBC driver for DBI, originally by Kristopher Schmidt and Ola Bini
+test_files: []