ruby-plsql 0.2.4 → 0.3.0

data/History.txt

@@ -1,8 +1,21 @@
+== 0.3.0 2009-04-21
+
+* New features
+  * Added Ruby 1.9.1 and ruby-oci8 2.x support
+  * Use plsql.activerecord_class = ActiveRecord::Base to simplify usage with Rails
+* Improvements
+  * DATE to Time and DateTime conversion according to plsql.default_timezone (:local or :utc)
+    Use ActiveRecord::Base.default_timezone if plsql.activerecord_class=... is used
+  * Added BLOB data type support for input and output parameters and function return values
+  * Added support for private and public synonyms to functions/procedures and packages
+
 == 0.2.4 2009-03-06
+
 * Bug fixes
   * Fixed that procedures can be called with VARCHAR2 parameters with length up to 32767
 
 == 0.2.3 2008-10-17
+
 * Improvements
   * Added CLOB data type support for input and output parameters and function return values
     (both for MRI/OCI and JRuby/JDBC)

data/License.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2008 Raimonds Simanovskis
+Copyright (c) 2009 Raimonds Simanovskis
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.txt

@@ -5,8 +5,8 @@
 == DESCRIPTION:
 
 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.
+ruby-plsql support both Ruby 1.8 MRI, Ruby 1.9.1 YARV and JRuby runtime environments.
+This gem requires ruby-oci8 library version 1.x (if MRI is used) or 2.x (if Ruby 1.9.1 is used) or Oracle JDBC driver (ojdbc14.jar) (if JRuby is used) for connection to Oracle database.
 
 See http://blog.rayapps.com for more information.
 
@@ -14,7 +14,7 @@ Look ar RSpec tests under spec directory for usage examples.
 
 == FEATURES/PROBLEMS:
 
-* Currently just NUMBER, VARCHAR2, DATE, TIMESTAMP, CLOB argument types are supported for PL/SQL procedures
+* Currently just NUMBER, VARCHAR2, DATE, TIMESTAMP, CLOB, BLOB argument types are supported for PL/SQL procedures
 
 == SYNOPSIS:
 
@@ -34,10 +34,19 @@ plsql.test_package.test_uppercase('xxx') # => 'XXX'
 
 plsql.logoff
 
+
+If using with Rails then include in initializer file:
+
+plsql.activerecord_class = ActiveRecord::Base
+
+and then you do not need to specify plsql.connection (this is also safer when ActiveRecord reestablishes connection to database).
+
 == REQUIREMENTS:
 
-MRI
+Ruby 1.8 MRI
 * Requires ruby-oci8 library to connect to Oracle (please use version 1.0.3 or later)
+Ruby 1.9.1
+* Requires ruby-oci8 library to connect to Oracle (please use version 2.0 or later)
 JRuby
 * Requires Oracle JDBC driver (ojdbc14.jar should be somewhere in PATH) to connect to Oracle
 
@@ -49,7 +58,7 @@ JRuby
 
 (The MIT License)
 
-Copyright (c) 2008 Raimonds Simanovskis
+Copyright (c) 2009 Raimonds Simanovskis
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/plsql/connection.rb

@@ -1,23 +1,37 @@
 module PLSQL
   class Connection
-    attr_reader :raw_connection
     attr_reader :raw_driver
+    attr_reader :activerecord_class
 
-    def initialize(raw_drv, raw_conn)
+    def initialize(raw_drv, raw_conn, ar_class = nil)
       @raw_driver = raw_drv
       @raw_connection = raw_conn
+      @activerecord_class = ar_class
     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)
+    def self.create(raw_conn, ar_class = nil)
+      if ar_class && !(defined?(::ActiveRecord) && [ar_class, ar_class.superclass].include?(::ActiveRecord::Base))
+        raise ArgumentError, "Wrong ActiveRecord class"
+      end
+      # MRI 1.8.6 or YARV 1.9.1
+      if (!defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby") && defined?(OCI8)
+        OCIConnection.new(:oci, raw_conn, ar_class)
+      # JRuby
+      elsif (defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby")
+        JDBCConnection.new(:jdbc, raw_conn, ar_class)
       else
         raise ArgumentError, "Unknown raw driver"
       end
     end
     
+    def raw_connection
+      if @activerecord_class
+        @activerecord_class.connection.raw_connection
+      else
+        @raw_connection
+      end
+    end
+    
     def oci?
       @raw_driver == :oci
     end

data/lib/plsql/jdbc_connection.rb

@@ -145,6 +145,8 @@ module PLSQL
         java.sql.Types::VARCHAR
       when 'Java::OracleSql::CLOB'
         Java::oracle.jdbc.OracleTypes::CLOB
+      when 'Java::OracleSql::BLOB'
+        Java::oracle.jdbc.OracleTypes::BLOB
       when 'Date'
         java.sql.Types::DATE
       when 'Time'
@@ -169,12 +171,10 @@ module PLSQL
         stmt.send("setString#{key && "AtName"}", key || i, value)
       when 'Java::OracleSql::CLOB'
         stmt.send("setClob#{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 'Java::OracleSql::BLOB'
+        stmt.send("setBlob#{key && "AtName"}", key || i, value)
+      when 'Date', 'Time', 'DateTime'
+        stmt.send("setDATE#{key && "AtName"}", key || i, Java::oracle.sql.DATE.new(value.strftime("%Y-%m-%d %H:%M:%S")))
       when 'NilClass'
         stmt.send("setNull#{key && "AtName"}", key || i, get_java_sql_type(value, type))
       end
@@ -193,10 +193,16 @@ module PLSQL
         stmt.getString(i)
       when 'Java::OracleSql::CLOB'
         stmt.getClob(i)
+      when 'Java::OracleSql::BLOB'
+        stmt.getBlob(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)
+        if dt = stmt.getDATE(i)
+          d = dt.dateValue
+          t = dt.timeValue
+          Time.send(plsql.default_timezone, d.year + 1900, d.month + 1, d.date, t.hours, t.minutes, t.seconds)
+        else
+          nil
+        end
       end
     end
 
@@ -206,17 +212,29 @@ module PLSQL
         rset.getString(i)
       when "CLOB"
         ora_value_to_ruby_value(rset.getClob(i))
+      when "BLOB"
+        ora_value_to_ruby_value(rset.getBlob(i))
       when "NUMBER"
         d = rset.getBigDecimal(i)
         if d.nil?
           nil
         elsif d.scale == 0
-          d.longValue
+          d.toBigInteger+0
         else
-          d.doubleValue
+          BigDecimal(d.toString)
         end
-      when "DATE", "TIMESTAMP"
-        Time.at(rset.getTimestamp(i).getTime/1000)
+      when "DATE"
+        if dt = rset.getDATE(i)
+          d = dt.dateValue
+          t = dt.timeValue
+          Time.send(plsql.default_timezone, d.year + 1900, d.month + 1, d.date, t.hours, t.minutes, t.seconds)
+        else
+          nil
+        end
+      when /^TIMESTAMP/
+        ts = rset.getTimestamp(i)
+        ts && Time.send(Base.default_timezone, ts.year + 1900, ts.month + 1, ts.date, ts.hours, ts.minutes, ts.seconds,
+          ts.nanos / 1000)
       else
         nil
       end
@@ -228,14 +246,14 @@ module PLSQL
         [String, data_length || 32767]
       when "CLOB"
         [Java::OracleSql::CLOB, nil]
+      when "BLOB"
+        [Java::OracleSql::BLOB, nil]
       when "NUMBER"
         [BigDecimal, nil]
       when "DATE"
         [Time, nil]
       when "TIMESTAMP"
         [Time, nil]
-      # CLOB
-      # BLOB
       else
         [String, 32767]
       end
@@ -243,9 +261,16 @@ module PLSQL
 
     def ruby_value_to_ora_value(val, type)
       if type == BigDecimal
-        val.nil? || val.is_a?(Fixnum) ? val : val.to_f
+        val.nil? || val.is_a?(Fixnum) || val.is_a?(BigDecimal) ? val : BigDecimal(val.to_s)
       elsif type == Time
-        date_to_time(val)
+        case val
+        when DateTime
+          Time.send(plsql.default_timezone, val.year, val.month, val.day, val.hour, val.min, val.sec)
+        when Date
+          Time.send(plsql.default_timezone, val.year, val.month, val.day, 0, 0, 0)
+        else
+          val
+        end
       elsif type == Java::OracleSql::CLOB
         if val
           clob = Java::OracleSql::CLOB.createTemporary(raw_connection, false, Java::OracleSql::CLOB::DURATION_SESSION)
@@ -254,6 +279,14 @@ module PLSQL
         else
           Java::OracleSql::CLOB.getEmptyCLOB
         end
+      elsif type == Java::OracleSql::BLOB
+        if val
+          blob = Java::OracleSql::BLOB.createTemporary(raw_connection, false, Java::OracleSql::BLOB::DURATION_SESSION)
+          blob.setBytes(1, val.to_java_bytes)
+          blob
+        else
+          Java::OracleSql::BLOB.getEmptyBLOB
+        end
       else
         val
       end
@@ -263,14 +296,18 @@ module PLSQL
       case val
       when Float, BigDecimal
         ora_number_to_ruby_number(val)
-      # when OraDate
-      #   ora_date_to_ruby_date(val)
       when Java::OracleSql::CLOB
         if val.isEmptyLob
           nil
         else
           val.getSubString(1, val.length)
         end
+      when Java::OracleSql::BLOB
+        if val.isEmptyLob
+          nil
+        else
+          String.from_java_bytes(val.getBytes(1, val.length))
+        end
       else
         val
       end
@@ -279,24 +316,11 @@ module PLSQL
     private
     
     def ora_number_to_ruby_number(num)
-      num.to_i == num.to_f ? num.to_i : num.to_f
+      # return BigDecimal instead of Float to avoid rounding errors
+      # num.to_i == num.to_f ? num.to_i : num.to_f
+      num == (num_to_i = num.to_i) ? num_to_i : BigDecimal.new(num.to_s)
     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/oci_connection.rb

@@ -91,6 +91,8 @@ module PLSQL
         [String, data_length || 32767]
       when "CLOB"
         [OCI8::CLOB, nil]
+      when "BLOB"
+        [OCI8::BLOB, nil]
       when "NUMBER"
         [OraNumber, nil]
       when "DATE"
@@ -106,13 +108,34 @@ module PLSQL
 
     def ruby_value_to_ora_value(val, type)
       if type == OraNumber
-        val.nil? || val.is_a?(Fixnum) ? val : val.to_f
+        # pass parameters as OraNumber to avoid rounding errors
+        case val
+        when Bignum
+          OraNumber.new(val.to_s)
+        when BigDecimal
+          OraNumber.new(val.to_s('F'))
+        else
+          val
+        end
       elsif type == DateTime
-        val ? val.to_datetime : nil
+        case val
+        when Time
+          ::DateTime.civil(val.year, val.month, val.day, val.hour, val.min, val.sec, Rational(val.utc_offset, 86400))
+        when DateTime
+          val
+        when Date
+          ::DateTime.civil(val.year, val.month, val.day, 0, 0, 0, 0)
+        else
+          val
+        end
       elsif type == OCI8::CLOB
         # ruby-oci8 cannot create CLOB from ''
         val = nil if val == ''
         OCI8::CLOB.new(raw_oci_connection, val)
+      elsif type == OCI8::BLOB
+        # ruby-oci8 cannot create BLOB from ''
+        val = nil if val == ''
+        OCI8::BLOB.new(raw_oci_connection, val)
       else
         val
       end
@@ -124,9 +147,13 @@ module PLSQL
         ora_number_to_ruby_number(val)
       when DateTime, OraDate
         ora_date_to_ruby_date(val)
-      when OCI8::CLOB
-        val.rewind
-        val.read
+      when OCI8::LOB
+        if val.available?
+          val.rewind
+          val.read
+        else
+          nil
+        end
       else
         val
       end
@@ -146,15 +173,29 @@ module PLSQL
     end
     
     def ora_number_to_ruby_number(num)
-      num.to_i == num.to_f ? num.to_i : num.to_f
+      # return BigDecimal instead of Float to avoid rounding errors
+      # num.to_i == num.to_f ? num.to_i : num.to_f
+      num == (num_to_i = num.to_i) ? num_to_i : BigDecimal.new(num.to_s)
     end
     
     def ora_date_to_ruby_date(val)
       case val
       when DateTime
-        Time.parse(val.strftime("%c")) rescue val
+        # similar implementation as in oracle_enhanced adapter
+        begin
+          Time.send(plsql.default_timezone, val.year, val.month, val.day, val.hour, val.min, val.sec)
+        rescue
+          offset = plsql.default_timezone.to_sym == :local ? plsql.local_timezone_offset : 0
+          DateTime.civil(val.year, val.month, val.day, val.hour, val.min, val.sec, offset)
+        end
       when OraDate
-        val.to_time rescue val.to_datetime
+        # similar implementation as in oracle_enhanced adapter
+        begin
+          Time.send(plsql.default_timezone, val.year, val.month, val.day, val.hour, val.minute, val.second)
+        rescue
+          offset = plsql.default_timezone.to_sym == :local ? plsql.local_timezone_offset : 0
+          DateTime.civil(val.year, val.month, val.day, val.hour, val.minute, val.second, offset)
+        end
       else
         val
       end

data/lib/plsql/package.rb

@@ -9,6 +9,18 @@ module PLSQL
               AND object_type = 'PACKAGE'",
             schema.schema_name, package.to_s.upcase)
         new(schema, package)
+      # search for synonym
+      elsif (row = schema.select_first("
+            SELECT o.owner, o.object_name
+            FROM all_synonyms s, all_objects o
+            WHERE s.owner IN (:owner, 'PUBLIC')
+              AND s.synonym_name = :synonym_name
+              AND o.owner = s.table_owner
+              AND o.object_name = s.table_name
+              AND o.object_type = 'PACKAGE'
+            ORDER BY DECODE(s.owner, 'PUBLIC', 1, 0)",
+            schema.schema_name, package.to_s.upcase))
+        new(schema, row[1], row[0])
       else
         nil
       end
@@ -18,8 +30,9 @@ module PLSQL
   class Package
     extend PackageClassMethods
 
-    def initialize(schema, package)
+    def initialize(schema, package, override_schema_name = nil)
       @schema = schema
+      @override_schema_name = override_schema_name
       @package = package.to_s.upcase
       @procedures = {}
     end
@@ -29,7 +42,7 @@ module PLSQL
     def method_missing(method, *args)
       if procedure = @procedures[method]
         procedure.exec(*args)
-      elsif procedure = Procedure.find(@schema, method, @package)
+      elsif procedure = Procedure.find(@schema, method, @package, @override_schema_name)
         @procedures[method] = procedure
         procedure.exec(*args)
       else

data/lib/plsql/procedure.rb

@@ -1,21 +1,37 @@
 module PLSQL
 
   module ProcedureClassMethods
-    def find(schema, procedure, package = nil)
-      if package.nil? && schema.select_first("
+    def find(schema, procedure, package = nil, override_schema_name = nil)
+      if package.nil?
+        if schema.select_first("
             SELECT object_name FROM all_objects
             WHERE owner = :owner
               AND object_name = :object_name
-              AND object_type IN ('PROCEDURE','FUNCTION')
-          ", schema.schema_name, procedure.to_s.upcase)
-        new(schema, procedure)
+              AND object_type IN ('PROCEDURE','FUNCTION')",
+            schema.schema_name, procedure.to_s.upcase)
+          new(schema, procedure)
+        # search for synonym
+        elsif (row = schema.select_first("
+            SELECT o.owner, o.object_name
+            FROM all_synonyms s, all_objects o
+            WHERE s.owner IN (:owner, 'PUBLIC')
+              AND s.synonym_name = :synonym_name
+              AND o.owner = s.table_owner
+              AND o.object_name = s.table_name
+              AND o.object_type IN ('PROCEDURE','FUNCTION')
+              ORDER BY DECODE(s.owner, 'PUBLIC', 1, 0)",
+            schema.schema_name, procedure.to_s.upcase))
+          new(schema, row[1], nil, row[0])
+        else
+          nil
+        end
       elsif package && schema.select_first("
             SELECT object_name FROM all_procedures
             WHERE owner = :owner
               AND object_name = :object_name
               AND procedure_name = :procedure_name
-          ", schema.schema_name, package, procedure.to_s.upcase)
-        new(schema, procedure, package)
+          ", override_schema_name || schema.schema_name, package, procedure.to_s.upcase)
+        new(schema, procedure, package, override_schema_name)
       else
         nil
       end
@@ -25,8 +41,9 @@ module PLSQL
   class Procedure
     extend ProcedureClassMethods
 
-    def initialize(schema, procedure, package = nil)
+    def initialize(schema, procedure, package = nil, override_schema_name = nil)
       @schema = schema
+      @schema_name = override_schema_name || schema.schema_name
       @procedure = procedure.to_s.upcase
       @package = package
       @arguments = {}
@@ -42,7 +59,7 @@ module PLSQL
         WHERE o.owner = :owner
         AND o.object_name = :object_name
         AND o.object_type <> 'PACKAGE BODY'
-        ", @schema.schema_name, @package ? @package : @procedure
+        ", @schema_name, @package ? @package : @procedure
       )[0] rescue nil
       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
@@ -51,7 +68,7 @@ module PLSQL
         AND a.owner = :owner
         AND a.object_name = :procedure_name
         AND NVL(a.package_name,'nil') = :package
-        ", object_id, @schema.schema_name, @procedure, @package ? @package : 'nil'
+        ", object_id, @schema_name, @procedure, @package ? @package : 'nil'
       ) do |r|
 
         argument_name, position, data_type, in_out, data_length, data_precision, data_scale, overload = r
@@ -122,7 +139,7 @@ module PLSQL
 
       sql = "BEGIN\n"
       sql << ":return := " if @return[overload]
-      sql << "#{@schema.schema_name}." if @schema
+      sql << "#{@schema_name}." if @schema_name
       sql << "#{@package}." if @package
       sql << "#{@procedure}("