ruby-plsql 0.1.6 → 0.2.0

data/History.txt

@@ -1,3 +1,13 @@
+== 0.2.0 2008-06-26
+
+* New features
+  * Added JRuby and Oracle JDBC driver support with the same functionality as in case of MRI and ruby-oci8 driver
+  * All database driver specifics are extracted in separate Connection class with OCIConnection and JDBCConnection subclasses
+* Improvements
+  * PL/SQL functions/procedures with DATE return values and output parameters returns Time values by default (previously DateTime values
+    were returned by default). If value is too old then DateTime value is returned. From Ruby Time, DateTime and Date values can be
+    passed as arguments to DATE parameters.
+
 == 0.1.6 2008-06-16
 
 * Improvements

data/Manifest.txt

@@ -5,6 +5,8 @@ README.txt
 Rakefile
 config/hoe.rb
 config/requirements.rb
+lib/oradate_patch.rb
+lib/plsql/connection.rb
 lib/plsql/package.rb
 lib/plsql/procedure.rb
 lib/plsql/schema.rb

data/lib/oradate_patch.rb

@@ -0,0 +1,10 @@
+class OraDate
+  if defined? DateTime # ruby 1.8.0 or upper
+    # RSI: create DateTime in local timezone
+    def to_datetime
+      DateTime.parse(Time.local(year, month, day, hour, minute, second).iso8601)
+    rescue
+      DateTime.new(year, month, day, hour, minute, second)
+    end
+  end
+end

data/lib/plsql/connection.rb

@@ -0,0 +1,440 @@
+module PLSQL
+  class Connection
+    attr_reader :raw_connection
+    attr_reader :raw_driver
+
+    def initialize(raw_drv, raw_conn)
+      @raw_driver = raw_drv
+      @raw_connection = raw_conn
+    end
+    
+    def self.create(raw_conn)
+      if !raw_conn.respond_to?(:java_class) && defined?(OCI8)
+        OCIConnection.new(:oci, raw_conn)
+      elsif raw_conn.respond_to?(:java_class) && raw_conn.java_class.to_s =~ /jdbc/
+        JDBCConnection.new(:jdbc, raw_conn)
+      else
+        raise ArgumentError, "Unknown raw driver"
+      end
+    end
+    
+    def oci?
+      @raw_driver == :oci
+    end
+
+    def jdbc?
+      @raw_driver == :jdbc
+    end
+    
+    def logoff
+      raise NoMethodError, "Not implemented for this raw driver"
+    end
+
+    def select_first(sql, *bindvars)
+      raise NoMethodError, "Not implemented for this raw driver"
+    end
+
+    def select_all(sql, *bindvars, &block)
+      raise NoMethodError, "Not implemented for this raw driver"
+    end
+
+    def exec(sql, *bindvars)
+      raise NoMethodError, "Not implemented for this raw driver"
+    end
+
+    def parse(sql)
+      raise NoMethodError, "Not implemented for this raw driver"
+    end
+
+  end
+  
+  class OCIConnection < Connection
+    
+    def logoff
+      raw_connection.logoff
+    end
+    
+    def select_first(sql, *bindvars)
+      cursor = raw_connection.exec(sql, *bindvars)
+      result = cursor.fetch
+      if result
+        result.map { |val| ora_value_to_ruby_value(val) }
+      else
+        nil
+      end
+    ensure
+      cursor.close rescue nil
+    end
+
+    def select_all(sql, *bindvars, &block)
+      cursor = raw_connection.exec(sql, *bindvars)
+      results = []
+      row_count = 0
+      while row = cursor.fetch
+        row_with_typecast = row.map {|val| ora_value_to_ruby_value(val) }
+        if block_given?
+          yield(row_with_typecast)
+          row_count += 1
+        else
+          results << row_with_typecast
+        end
+      end
+      block_given? ? row_count : results
+    ensure
+      cursor.close rescue nil
+    end
+
+    def exec(sql, *bindvars)
+      raw_connection.exec(sql, *bindvars)
+    end
+
+    class Cursor
+      attr_accessor :raw_cursor
+      
+      def initialize(raw_cur)
+        @raw_cursor = raw_cur
+      end
+
+      def bind_param(key, value, type=nil, length=nil, in_out='IN')
+        raw_cursor.bind_param(key, value, type, length)
+      end
+      
+      def exec(*bindvars)
+        raw_cursor.exec(*bindvars)
+      end
+
+      def [](key)
+        raw_cursor[key]
+      end
+
+      def close
+        raw_cursor.close
+      end
+    end
+
+    def parse(sql)
+      Cursor.new(raw_connection.parse(sql))
+    end
+    
+
+    def plsql_to_ruby_data_type(data_type, data_length)
+      case data_type
+      when "VARCHAR2"
+        [String, data_length || 4000]
+      when "NUMBER"
+        [OraNumber, nil]
+      when "DATE"
+        [DateTime, nil]
+      when "TIMESTAMP"
+        [Time, nil]
+      # CLOB
+      # BLOB
+      else
+        [String, 4000]
+      end
+    end
+
+    def ruby_value_to_ora_value(val, type)
+      if type == OraNumber
+        val.nil? || val.is_a?(Fixnum) ? val : val.to_f
+      elsif type == DateTime
+        val ? val.to_datetime : nil
+      else
+        val
+      end
+    end
+
+    def ora_value_to_ruby_value(val)
+      case val
+      when Float, OraNumber
+        ora_number_to_ruby_number(val)
+      when DateTime, OraDate
+        ora_date_to_ruby_date(val)
+      else
+        val
+      end
+    end
+
+
+    private
+    
+    def ora_number_to_ruby_number(num)
+      num.to_i == num.to_f ? num.to_i : num.to_f
+    end
+    
+    def ora_date_to_ruby_date(val)
+      case val
+      when DateTime
+        Time.parse(val.strftime("%c")) rescue val
+      when OraDate
+        val.to_time rescue val.to_datetime
+      else
+        val
+      end
+    end
+
+  end
+  
+
+
+  class JDBCConnection < Connection
+    def logoff
+      raw_connection.close
+      true
+    rescue
+      false
+    end
+
+    def select_first(sql, *bindvars)
+      stmt = prepare_statement(sql, *bindvars)
+      rset = stmt.executeQuery
+      metadata = rset.getMetaData
+      column_count = metadata.getColumnCount
+      if rset.next
+        (1..column_count).map do |i|
+          get_ruby_value_from_result_set(rset,i,metadata.getColumnTypeName(i))
+        end
+      else
+        nil
+      end
+    ensure
+      rset.close rescue nil
+      stmt.close rescue nil
+    end
+
+    def select_all(sql, *bindvars, &block)
+      stmt = prepare_statement(sql, *bindvars)
+      results = []
+      row_count = 0
+      rset = stmt.executeQuery
+      metadata = rset.getMetaData
+      column_count = metadata.getColumnCount
+      while rset.next
+        row_with_typecast = (1..column_count).map do |i|
+          get_ruby_value_from_result_set(rset,i,metadata.getColumnTypeName(i))
+        end
+        if block_given?
+          yield(row_with_typecast)
+          row_count += 1
+        else
+          results << row_with_typecast
+        end
+      end
+      block_given? ? row_count : results
+    ensure
+      rset.close rescue nil
+      stmt.close rescue nil
+    end
+    
+    def exec(sql, *bindvars)
+      cs = prepare_call(sql, *bindvars)
+      cs.execute
+      true
+    ensure
+      cs.close rescue nil
+    end
+
+    class Cursor
+
+      def initialize(sql, conn)
+        @sql = sql
+        @connection = conn
+        @params = sql.scan(/\:\w+/)
+        @out_types = {}
+        @out_index = {}
+        @statement = @connection.prepare_call(sql)
+      end
+
+      def bind_param(key, value, type=nil, length=nil, in_out='IN')
+        @connection.set_bind_variable(@statement, key, value, type, length)
+        if in_out =~ /OUT/
+          @out_types[key] = type || value.class
+          @out_index[key] = bind_param_index(key)
+          @statement.registerOutParameter(@out_index[key],@connection.get_java_sql_type(value,type))
+        end
+      end
+      
+      def exec
+        @statement.execute
+      end
+
+      def [](key)
+        @connection.get_bind_variable(@statement, @out_index[key], @out_types[key])
+      end
+
+      def close
+        @statement.close
+      end
+      
+      private
+      
+      def bind_param_index(key)
+        return key if key.kind_of? Integer
+        key = ":#{key.to_s}" unless key.to_s =~ /^:/
+        @params.index(key)+1
+      end
+    end
+
+    def parse(sql)
+      Cursor.new(sql, self)
+    end
+
+    def prepare_statement(sql, *bindvars)
+      stmt = raw_connection.prepareStatement(sql)
+      bindvars.each_with_index do |bv, i|
+        set_bind_variable(stmt, i+1, bv)
+      end
+      stmt
+    end
+
+    def prepare_call(sql, *bindvars)
+      stmt = raw_connection.prepareCall(sql)
+      bindvars.each_with_index do |bv, i|
+        set_bind_variable(stmt, i+1, bv)
+      end
+      stmt
+    end
+
+    def get_java_sql_type(value, type)
+      case type ? type.to_s : value.class.to_s
+      when 'Fixnum', 'Bignum', 'Integer'
+        java.sql.Types::INTEGER
+      when 'Float'
+        java.sql.Types::FLOAT
+      when 'BigDecimal'
+        java.sql.Types::NUMERIC
+      when 'String'
+        java.sql.Types::VARCHAR
+      when 'Date'
+        java.sql.Types::DATE
+      when 'Time'
+        java.sql.Types::DATE
+      when 'DateTime'
+        java.sql.Types::DATE
+      else
+        java.sql.Types::VARCHAR
+      end
+    end
+
+    def set_bind_variable(stmt, i, value, type=nil, length=nil)
+      key = i.kind_of?(Integer) ? nil : i.to_s.gsub(':','')
+      case !value.nil? && type ? type.to_s : value.class.to_s
+      when 'Fixnum', 'Bignum', 'Integer'
+        stmt.send("setInt#{key && "AtName"}", key || i, value)
+      when 'Float'
+        stmt.send("setFloat#{key && "AtName"}", key || i, value)
+      when 'BigDecimal'
+        stmt.send("setBigDecimal#{key && "AtName"}", key || i, java.math.BigDecimal.new(value.to_s))
+      when 'String'
+        stmt.send("setString#{key && "AtName"}", key || i, value)
+      when 'Date'
+        stmt.send("setDate#{key && "AtName"}", key || i, java.sql.Date.new(Time.parse(value.to_s).to_i*1000))
+      when 'Time'
+        stmt.send("setTime#{key && "AtName"}", key || i, java.sql.Time.new(value.to_i*1000))
+      when 'DateTime'
+        stmt.send("setTime#{key && "AtName"}", key || i, java.sql.Time.new(Time.parse(value.strftime("%c")).to_i*1000))
+      when 'NilClass'
+        stmt.send("setNull#{key && "AtName"}", key || i, get_java_sql_type(value, type))
+      end
+    end
+    
+    def get_bind_variable(stmt, i, type)
+      case type.to_s
+      when 'Fixnum', 'Bignum', 'Integer'
+        stmt.getInt(i)
+      when 'Float'
+        stmt.getFloat(i)
+      when 'BigDecimal'
+        bd = stmt.getBigDecimal(i)
+        bd && BigDecimal.new(bd.to_s)
+      when 'String'
+        stmt.getString(i)
+      when 'Date','Time','DateTime'
+        ts = stmt.getTimestamp(i)
+        # ts && Time.parse(Time.at(ts.getTime/1000).iso8601)
+        ts && Time.local(1900+ts.year, ts.month+1, ts.date, ts.hours, ts.minutes, ts.seconds)
+      end
+    end
+
+    def get_ruby_value_from_result_set(rset, i, type_name)
+      case type_name
+      when "CHAR", "VARCHAR2"
+        rset.getString(i)
+      when "NUMBER"
+        d = rset.getBigDecimal(i)
+        if d.nil?
+          nil
+        elsif d.scale == 0
+          d.longValue
+        else
+          d.doubleValue
+        end
+      when "DATE", "TIMESTAMP"
+        Time.at(rset.getTimestamp(i).getTime/1000)
+      else
+        nil
+      end
+    end
+    
+    def plsql_to_ruby_data_type(data_type, data_length)
+      case data_type
+      when "VARCHAR2"
+        [String, data_length || 4000]
+      when "NUMBER"
+        [BigDecimal, nil]
+      when "DATE"
+        [Time, nil]
+      when "TIMESTAMP"
+        [Time, nil]
+      # CLOB
+      # BLOB
+      else
+        [String, 4000]
+      end
+    end
+
+    def ruby_value_to_ora_value(val, type)
+      if type == BigDecimal
+        val.nil? || val.is_a?(Fixnum) ? val : val.to_f
+      elsif type == Time
+        date_to_time(val)
+      else
+        val
+      end
+    end
+
+    def ora_value_to_ruby_value(val)
+      case val
+      when Float, BigDecimal
+        ora_number_to_ruby_number(val)
+      # when OraDate
+      #   ora_date_to_ruby_date(val)
+      else
+        val
+      end
+    end
+
+    private
+    
+    def ora_number_to_ruby_number(num)
+      num.to_i == num.to_f ? num.to_i : num.to_f
+    end
+    
+    # def ora_date_to_ruby_date(val)
+    #   val.to_time
+    # end
+
+    def date_to_time(val)
+      case val
+      when Time
+        val
+      when DateTime
+        Time.parse(val.strftime("%c"))
+      when Date
+        Time.parse(val.strftime("%c"))
+      end
+    end
+
+  end
+
+end

data/lib/plsql/procedure.rb

@@ -34,7 +34,7 @@ module PLSQL
       @out_list = {}
       @return = {}
       @overloaded = false
-      num_rows = @schema.connection.exec("
+      num_rows = @schema.connection.select_all("
         SELECT a.argument_name, a.position, a.data_type, a.in_out, a.data_length, a.data_precision, a.data_scale, a.overload
         FROM all_arguments a, all_objects o
         WHERE o.owner = :owner
@@ -76,7 +76,7 @@ module PLSQL
       @overloads = @arguments.keys.sort
       @overloads.each do |overload|
         @argument_list[overload] = @arguments[overload].keys.sort {|k1, k2| @arguments[overload][k1][:position] <=> @arguments[overload][k2][:position]}
-        @out_list[overload] = @argument_list[overload].select {|k| @arguments[overload][k][:in_out] == 'OUT'}
+        @out_list[overload] = @argument_list[overload].select {|k| @arguments[overload][k][:in_out] =~ /OUT/}
       end
     end
     
@@ -145,12 +145,13 @@ module PLSQL
       
       args_list.each do |k|
         data_type, data_length = plsql_to_ruby_data_type(@arguments[overload][k])
-        cursor.bind_param(":#{k.to_s}", ruby_value_to_ora_value(args_hash[k], data_type), data_type, data_length)
+        cursor.bind_param(":#{k.to_s}", ruby_value_to_ora_value(args_hash[k], data_type),
+                                        data_type, data_length, @arguments[overload][k][:in_out])
       end
       
       if @return[overload]
         data_type, data_length = plsql_to_ruby_data_type(@return[overload])
-        cursor.bind_param(":return", nil, data_type, data_length)
+        cursor.bind_param(":return", nil, data_type, data_length, 'OUT')
       end
       
       cursor.exec
@@ -181,47 +182,15 @@ module PLSQL
     private
     
     def plsql_to_ruby_data_type(argument)
-      case argument[:data_type]
-      when "VARCHAR2"
-        [String, argument[:data_length] ? argument[:data_length] : 4000]
-      when "NUMBER"
-        [OraNumber, nil]
-      when "DATE"
-        [DateTime, nil]
-      when "TIMESTAMP"
-        [Time, nil]
-      # CLOB
-      # BLOB
-      else
-        [String, 4000]
-      end
+      @schema.connection.plsql_to_ruby_data_type(argument[:data_type],argument[:data_length])
     end
     
     def ruby_value_to_ora_value(val, type)
-      if type == OraNumber
-        val.nil? || val.is_a?(Fixnum) ? val : val.to_f
-      elsif type == DateTime
-        val ? val.to_datetime : nil
-      else
-        val
-      end
-    end
-    
-    def ora_number_to_ruby_number(num)
-      if num.to_i == num.to_f
-        num.to_i
-      else
-        num.to_f
-      end
+      @schema.connection.ruby_value_to_ora_value(val, type)
     end
     
     def ora_value_to_ruby_value(val)
-      case val
-      when OraNumber
-        ora_number_to_ruby_number(val)
-      else
-        val
-      end
+      @schema.connection.ora_value_to_ruby_value(val)
     end
 
   end

data/lib/plsql/schema.rb

@@ -14,8 +14,8 @@ module PLSQL
 
     end
     
-    def initialize(conn = nil, schema = nil, first = true)
-      self.connection = conn
+    def initialize(raw_conn = nil, schema = nil, first = true)
+      self.connection = raw_conn
       @schema_name = schema ? schema.to_s.upcase : nil
       @first = first
     end
@@ -24,8 +24,8 @@ module PLSQL
       @connection
     end
     
-    def connection=(conn)
-      @connection = conn
+    def connection=(raw_conn)
+      @connection = raw_conn ? Connection.create(raw_conn) : nil
       if @connection
         @procedures = {}
         @packages = {}
@@ -48,10 +48,11 @@ module PLSQL
     end
 
     def select_first(sql, *bindvars)
-      cursor = connection.exec(sql, *bindvars)
-      result = cursor.fetch
-      cursor.close
-      result
+      # cursor = connection.exec(sql, *bindvars)
+      # result = cursor.fetch
+      # cursor.close
+      # result
+      connection.select_first(sql, *bindvars)
     end
     
     def commit
@@ -87,7 +88,7 @@ module PLSQL
     def find_other_schema(name)
       return nil unless @first && connection
       if select_first("SELECT username FROM all_users WHERE username = :username", name.to_s.upcase)
-        Schema.new(connection, name, false)
+        Schema.new(connection.raw_connection, name, false)
       else
         nil
       end

data/lib/ruby_plsql.rb

@@ -3,14 +3,41 @@ $:.unshift File.dirname(__FILE__)
 module RubyPlsql #:nodoc:
 end
 
-begin
-  require "oci8"
-
-  %w(schema procedure package).each do |file|
-    require File.dirname(__FILE__) + "/plsql/#{file}"
+unless defined?(JRUBY_VERSION)
+  begin
+    require "oci8"
+    require "oradate_patch"
+  rescue LoadError
+      puts <<-EOS
+    To use ruby_plsql you must install ruby-oci8 library.
+      EOS
+  end
+else
+  begin
+    require "java"
+    ojdbc_jar = "ojdbc14.jar"
+    if ojdbc_jar_path = ENV["PATH"].split(":").find{|d| File.exists?(File.join(d,ojdbc_jar))}
+      require File.join(ojdbc_jar_path,ojdbc_jar)
+    else
+      require ojdbc_jar
+    end
+    import java.sql.Statement
+    import java.sql.Connection
+    import java.sql.SQLException
+    import java.sql.Types
+    import java.sql.DriverManager
+    DriverManager.registerDriver Java::oracle.jdbc.driver.OracleDriver.new
+  rescue LoadError
+      puts <<-EOS
+    To use ruby_plsql you must have Oracle JDBC driver installed.
+      EOS
   end
-rescue LoadError
-    puts <<-EOS
-  To use ruby_plsql you must install ruby-oci8 library.
-    EOS
+end
+
+require "time"
+require "date"
+require "bigdecimal"
+
+%w(connection schema procedure package).each do |file|
+  require File.dirname(__FILE__) + "/plsql/#{file}"
 end

data/lib/ruby_plsql/version.rb

@@ -1,8 +1,8 @@
 module RubyPlsql #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 1
-    TINY  = 6
+    MINOR = 2
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/spec/plsql/package_spec.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 describe "Package" do
   before(:all) do
-    plsql.connection = conn = OCI8.new("hr","hr","xe")
+    plsql.connection = get_connection
     plsql.connection.exec <<-EOS
       CREATE OR REPLACE PACKAGE test_package IS
         FUNCTION test_procedure ( p_string VARCHAR2 )

data/spec/plsql/procedure_spec.rb

@@ -6,7 +6,7 @@ require "activerecord"
 describe "Function with string parameters" do
   
   before(:all) do
-    plsql.connection = conn = OCI8.new("hr","hr","xe")
+    plsql.connection = get_connection
     plsql.connection.exec <<-EOS
       CREATE OR REPLACE FUNCTION test_uppercase
         ( p_string VARCHAR2 )
@@ -59,7 +59,7 @@ end
 describe "Function with numeric parameters" do
   
   before(:all) do
-    plsql.connection = conn = OCI8.new("hr","hr","xe")
+    plsql.connection = get_connection
     plsql.connection.exec <<-EOS
       CREATE OR REPLACE FUNCTION test_sum
         ( p_num1 NUMBER, p_num2 NUMBER )
@@ -100,7 +100,7 @@ end
 describe "Function with date parameters" do
   
   before(:all) do
-    plsql.connection = conn = OCI8.new("hr","hr","xe")
+    plsql.connection = get_connection
     plsql.connection.exec <<-EOS
       CREATE OR REPLACE FUNCTION test_date
         ( p_date DATE )
@@ -116,26 +116,49 @@ describe "Function with date parameters" do
     plsql.logoff
   end
   
-  it "should process DateTime parameters" do
-    now = DateTime.new(2008,8,12,14,28,0)
-    plsql.test_date(now).should == now + 1
+  it "should process Time parameters" do
+    now = Time.local(2008,8,12,14,28,0)
+    plsql.test_date(now).should == now + 60*60*24
   end
 
+  it "should process DateTime parameters" do
+    now = DateTime.parse(Time.local(2008,8,12,14,28,0).iso8601)
+    result = plsql.test_date(now)
+    result.class.should == Time
+    result.should == Time.parse((now + 1).strftime("%c"))
+  end
+  
   it "should process old DateTime parameters" do
-    now = DateTime.new(1900,1,1,12,0,0)
-    plsql.test_date(now).should == now + 1
+    now = DateTime.new(1901,1,1,12,0,0)
+    result = plsql.test_date(now)
+    unless defined?(JRUBY_VERSION)
+      result.class.should == DateTime
+      result.should == now + 1
+    else
+      result.class.should == Time
+      result.should == Time.parse((now + 1).strftime("%c"))
+    end
   end
 
   it "should process Date parameters" do
     now = Date.new(2008,8,12)
-    plsql.test_date(now).should == now + 1
+    result = plsql.test_date(now)
+    result.class.should == Time    
+    result.should == Time.parse((now + 1).strftime("%c"))
   end
-
+  
   it "should process old Date parameters" do
-    now = Date.new(1900,1,1)
-    plsql.test_date(now).should == now + 1
+    now = Date.new(1901,1,1)
+    result = plsql.test_date(now)
+    unless defined?(JRUBY_VERSION)
+      # result.class.should == DateTime
+      result.should == now + 1
+    else
+      result.class.should == Time
+      result.should == Time.parse((now + 1).strftime("%c"))
+    end
   end
-
+  
   it "should process nil date parameter as NULL" do
     plsql.test_date(nil).should be_nil
   end
@@ -145,7 +168,7 @@ end
 describe "Function with timestamp parameters" do
   
   before(:all) do
-    plsql.connection = conn = OCI8.new("hr","hr","xe")
+    plsql.connection = get_connection
     plsql.connection.exec <<-EOS
       CREATE OR REPLACE FUNCTION test_timestamp
         ( p_time TIMESTAMP )
@@ -170,7 +193,7 @@ end
 
 describe "Procedure with output parameters" do
   before(:all) do
-    plsql.connection = conn = OCI8.new("hr","hr","xe")
+    plsql.connection = get_connection
     plsql.connection.exec <<-EOS
       CREATE OR REPLACE PROCEDURE test_copy
         ( p_from VARCHAR2, p_to OUT VARCHAR2, p_to_double OUT VARCHAR2 )
@@ -206,7 +229,7 @@ end
 
 describe "Package with procedures with same name but different argument lists" do
   before(:all) do
-    plsql.connection = conn = OCI8.new("hr","hr","xe")
+    plsql.connection = get_connection
     plsql.connection.exec <<-EOS
       CREATE OR REPLACE PACKAGE test_package2 IS
         FUNCTION test_procedure ( p_string VARCHAR2 )
@@ -295,7 +318,7 @@ end
 
 describe "Function with output parameters" do
   before(:all) do
-    plsql.connection = conn = OCI8.new("hr","hr","xe")
+    plsql.connection = get_connection
     plsql.connection.exec <<-EOS
       CREATE OR REPLACE FUNCTION test_copy_function
         ( p_from VARCHAR2, p_to OUT VARCHAR2, p_to_double OUT VARCHAR2 )
@@ -334,7 +357,7 @@ end
 
 describe "Function without parameters" do
   before(:all) do
-    plsql.connection = conn = OCI8.new("hr","hr","xe")
+    plsql.connection = get_connection
     plsql.connection.exec <<-EOS
       CREATE OR REPLACE FUNCTION test_no_params
         RETURN VARCHAR2

data/spec/plsql/schema_spec.rb

@@ -8,24 +8,28 @@ describe "Schema" do
   
 end
 
-describe "Connection" do
+describe "Schema connection" do
   
   before(:each) do
-    @conn = OCI8.new("hr","hr","xe")
+    @conn = get_connection
   end
 
   after(:each) do
-    @conn.logoff
+    unless defined? JRUBY_VERSION
+      @conn.logoff
+    else
+      @conn.close
+    end
   end
 
   it "should connect to test database" do
     plsql.connection = @conn
-    plsql.connection.should == @conn
+    plsql.connection.raw_connection.should == @conn
   end
 
   it "should connect to test database using connection alias" do
     plsql(:hr).connection = @conn
-    plsql(:hr).connection.should == @conn
+    plsql(:hr).connection.raw_connection.should == @conn
   end
   
   it "should return schema name" do
@@ -41,12 +45,11 @@ end
 
 describe "Named Schema" do
   before(:all) do
-    @conn = OCI8.new("hr","hr","xe")
-    plsql.connection = @conn
+    plsql.connection = @conn = get_connection
   end
 
   after(:all) do
-    @conn.logoff
+    plsql.connection.logoff
   end
 
   it "should find existing schema" do
@@ -54,7 +57,7 @@ describe "Named Schema" do
   end
 
   it "should have the same connection as default schema" do
-    plsql.hr.connection.should == @conn
+    plsql.hr.connection.raw_connection.should == @conn
   end
 
   it "should return schema name" do

data/spec/spec_helper.rb

@@ -7,3 +7,11 @@ rescue LoadError
 end
 
 require File.expand_path(File.dirname(__FILE__) + "/../lib/ruby_plsql")
+
+def get_connection
+  unless defined?(JRUBY_VERSION)
+    OCI8.new("hr","hr","xe")
+  else
+    DriverManager.getConnection("jdbc:oracle:thin:@ubuntu710:1521:XE","hr","hr")
+  end
+end

data/website/index.html

@@ -33,7 +33,7 @@
     <h1>Ruby API for PL/SQL</h1>
     <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/ruby-plsql"; return false'>
       <p>Get Version</p>
-      <a href="http://rubyforge.org/projects/ruby-plsql" class="numbers">0.1.6</a>
+      <a href="http://rubyforge.org/projects/ruby-plsql" class="numbers">0.2.0</a>
     </div>
     <h1>&#x2192; &#8216;ruby-plsql&#8217;</h1>
 
@@ -41,7 +41,9 @@
 	<h2>What</h2>
 
 
-	<p>ruby-plsql gem provides simple Ruby <span class="caps">API</span> for calling Oracle PL/SQL procedures. This gem requires ruby-oci8 for connection to Oracle database.</p>
+	<p>ruby-plsql gem provides simple Ruby <span class="caps">API</span> for calling Oracle PL/SQL procedures.
+ruby-plsql support both <span class="caps">MRI</span> and JRuby runtime environments.
+This gem requires ruby-oci8 library (if <span class="caps">MRI</span> is used) or Oracle <span class="caps">JDBC</span> driver (ojdbc14.jar) (if JRuby is used) for connection to Oracle database.</p>
 
 
 	<h2>Installing</h2>
@@ -88,10 +90,10 @@
 	<h2>How to submit patches</h2>
 
 
-	<p>Submit bugs and patches to <a href="http://rubyforge.org/tracker/?group_id=5816">RubyForge</a></p>
+	<p>Submit bugs and patches to <a href="http://rsim.lighthouseapp.com/projects/11470-ruby-plsql">Lighthouse</a></p>
 
 
-	<p>The trunk repository is <code>http://ruby-plsql.rubyforge.org/svn/</code> for anonymous access.</p>
+	<p>Source code is located at <a href="http://github.com/rsim/ruby-plsql">GitHub</a></p>
 
 
 	<h2>License</h2>
@@ -99,7 +101,7 @@
 
 	<p>This code is free to use under the terms of the <span class="caps">MIT</span> license.</p>
     <p class="coda">
-      <a href="http://blog.rayapps.com">Raimonds Simanovskis</a>, 16th March 2008<br>
+      <a href="http://blog.rayapps.com">Raimonds Simanovskis</a>, 26th June 2008<br>
       Theme extended from <a href="http://rb2js.rubyforge.org/">Paul Battley</a>
     </p>
 </div>

data/website/index.txt

@@ -5,7 +5,9 @@ h1. → 'ruby-plsql'
 
 h2. What
 
-ruby-plsql gem provides simple Ruby API for calling Oracle PL/SQL procedures. This gem requires ruby-oci8 for connection to Oracle database.
+ruby-plsql gem provides simple Ruby API for calling Oracle PL/SQL procedures.
+ruby-plsql support both MRI and JRuby runtime environments.
+This gem requires ruby-oci8 library (if MRI is used) or Oracle JDBC driver (ojdbc14.jar) (if JRuby is used) for connection to Oracle database.
 
 h2. Installing
 
@@ -41,9 +43,9 @@ Submit your feedback as comments "here.":http://blog.rayapps.com/2008/03/15/ruby
 
 h2. How to submit patches
 
-Submit bugs and patches to "RubyForge":http://rubyforge.org/tracker/?group_id=5816
+Submit bugs and patches to "Lighthouse":http://rsim.lighthouseapp.com/projects/11470-ruby-plsql
 
-The trunk repository is <code>http://ruby-plsql.rubyforge.org/svn/</code> for anonymous access.
+Source code is located at "GitHub":http://github.com/rsim/ruby-plsql
 
 h2. License
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-plsql
 version: !ruby/object:Gem::Version 
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors: 
 - Raimonds Simanovskis
@@ -34,6 +34,8 @@ files:
 - Rakefile
 - config/hoe.rb
 - config/requirements.rb
+- lib/oradate_patch.rb
+- lib/plsql/connection.rb
 - lib/plsql/package.rb
 - lib/plsql/procedure.rb
 - lib/plsql/schema.rb