ruby-plsql 0.3.1 → 0.4.0

data/.gitignore

@@ -0,0 +1,10 @@
+.svn
+.DS_Store
+coverage
+doc
+pkg
+log
+tmp
+sqlnet.log
+ruby-plsql.gemspec
+

data/History.txt

@@ -1,3 +1,10 @@
+== 0.4.0 2009-11-23
+
+* New features
+  * Support for PL/SQL RECORD, BOOLEAN, TABLE, VARRAY, OBJECT and CURSOR parameters and return values
+  * Support for basic table and sequence operations
+* A lot of refactoring
+
 == 0.3.1 2009-06-05
 
 * Bug fixes

data/README.rdoc

@@ -1,58 +1,126 @@
 = ruby-plsql
 
-* http://rubyforge.org/projects/ruby-plsql/
+Ruby API for calling Oracle PL/SQL procedures.
 
-== DESCRIPTION:
+== DESCRIPTION
 
-ruby-plsql gem provides simple Ruby API for calling Oracle PL/SQL procedures.
-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.
+ruby-plsql gem provides simple Ruby API for calling Oracle PL/SQL procedures. It could be used both for accessing Oracle PL/SQL API procedures in legacy applications as well as it could be used to create PL/SQL unit tests using Ruby testing libraries.
 
-See http://blog.rayapps.com for more information.
+NUMBER, VARCHAR2, DATE, TIMESTAMP, CLOB, BLOB, BOOLEAN, PL/SQL RECORD, TABLE, VARRAY, OBJECT and CURSOR types are supported for input and output parameters and return values of PL/SQL procedures and functions.
 
-Look ar RSpec tests under spec directory for usage examples.
+ruby-plsql support both Ruby 1.8 MRI, Ruby 1.9.1 YARV and JRuby 1.3/1.4 runtime environments.
 
-== FEATURES/PROBLEMS:
+== USAGE
 
-* Currently just NUMBER, VARCHAR2, DATE, TIMESTAMP, CLOB, BLOB argument types are supported for PL/SQL procedures
+=== Calling PL/SQL functions and procedures:
 
-== SYNOPSIS:
+  require "rubygems"
+  require "ruby-plsql"
 
-Usage examples:
+  plsql.connection = OCI8.new("hr","hr","xe")
 
-require "ruby_plsql"
+  plsql.test_uppercase('xxx')               # => "XXX"
+  plsql.test_uppercase(:p_string => 'xxx')  # => "XXX"
+  plsql.test_copy("abc", nil, nil)          # => { :p_to => "abc", :p_to_double => "abcabc" }
+  plsql.test_copy(:p_from => "abc", :p_to => nil, :p_to_double => nil)
+                                            # => { :p_to => "abc", :p_to_double => "abcabc" }
+  plsql.hr.test_uppercase('xxx')            # => "XXX"
+  plsql.test_package.test_uppercase('xxx')  # => 'XXX'
 
-plsql.connection = OCI8.new("hr","hr","xe")
+  # PL/SQL records or object type parameters should be passed as Hash
+  p_employee = { :employee_id => 1, :first_name => 'First', :last_name => 'Last', :hire_date => Time.local(2000,01,31) }
+  plsql.test_full_name(p_employee)
 
-plsql.test_uppercase('xxx')              # => "XXX"
-plsql.test_uppercase(:p_string => 'xxx') # => "XXX"
-plsql.test_copy("abc", nil, nil)         # => { :p_to => "abc", :p_to_double => "abcabc" }
-plsql.test_copy(:p_from => "abc", :p_to => nil, :p_to_double => nil)
-                                         # => { :p_to => "abc", :p_to_double => "abcabc" }
-plsql.hr.test_uppercase('xxx')           # => "XXX"
-plsql.test_package.test_uppercase('xxx') # => 'XXX'
+  # TABLE or VARRAY parameters should be passed as Array
+  plsql.test_sum([1,2,3,4])
 
-plsql.logoff
+  # Nested objects or arrays are also supported
+  p_employee = { :employee_id => 1, :first_name => 'First', :last_name => 'Last', :hire_date => Time.local(2000,01,31),
+    :address => {:street => 'Street', :city => 'City', :country => 'Country},
+    :phones => [{:type => 'mobile', :phone_number => '123456'}, {:type => 'fixed', :phone_number => '654321'}]}
+  plsql.test_store_employee(p_employee)
 
+  # Returned cursor can be fetched
+  plsql.test_cursor do |cursor|
+    cursor.fetch                            # => one row from cursor
+    cursor.fetch_all                        # => all rows from cursor
+  end
+
+  plsql.connection.autocommit = false
+  plsql.commit
+  plsql.rollback
+
+  plsql.logoff
+
+Look at RSpec tests under spec directory for more usage examples.
+
+
+=== Table operations:
+
+ruby-plsql also provides simple API for select/insert/update/delete table operations (with Sequel-like syntax). This could be useful if ruby-plsql is used without ActiveRecord (e.g. for writing PL/SQL unit tests):
+
+  # insert record in table
+  employee = { :employee_id => 1, :first_name => 'First', :last_name => 'Last', :hire_date => Time.local(2000,01,31) }
+  plsql.employees.insert employee           # INSERT INTO employees VALUES (1, 'First', 'Last', ...)
+
+  # insert many records 
+  employees = [employee1, employee2, ... ]  # array of many Hashes
+  plsql.employees.insert employees
+
+  # select one record
+  plsql.employees.first                     # SELECT * FROM employees
+                                            # fetch first row => {:employee_id => ..., :first_name => '...', ...}
+  plsql.employees.first(:employee_id => 1)  # SELECT * FROM employees WHERE employee_id = 1
+  plsql.employees.first("WHERE employee_id = 1")
+  plsql.employees.first("WHERE employee_id = :employee_id", 1)
+
+  # select many records
+  plsql.employees.all                       # => [{...}, {...}, ...]
+  plsql.employees.all(:order_by => :employee_id)
+  plsql.employees.all("WHERE employee_id > :employee_id", 5)
+
+  # count records
+  plsql.employees.count                     # SELECT COUNT(*) FROM employees
+  plsql.employees.count("WHERE employee_id > :employee_id", 5)
+
+  # update records
+  plsql.employees.update(:first_name => 'Second', :where => {:employee_id => 1})
+                                            # UPDATE employees SET first_name = 'Second' WHERE employee_id = 1
+
+  # delete records
+  plsql.employees.delete(:employee_id => 1) # DELETE FROM employees WHERE employee_id = 1
+
+  # select from sequences
+  plsql.employees_seq.nextval               # SELECT employees_seq.NEXTVAL FROM dual
+  plsql.employees_seq.currval               # SELECT employees_seq.CURRVAL FROM dual
+
+
+=== Usage with Rails:
 
 If using with Rails then include in initializer file:
 
-plsql.activerecord_class = ActiveRecord::Base
+  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:
 
-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
+Ruby 1.8.6/1.8.7 MRI / Ruby 1.9.1 YARV
+* Requires ruby-oci8 library (please use version 2.0.3 or later)
+JRuby 1.3/1.4
+* Requires Oracle JDBC driver (ojdbc14.jar should be somewhere in PATH or should be available for Java class loader)
 
 == INSTALL:
 
-* sudo gem install ruby-plsql
+* [sudo] gem install ruby-plsql
+
+In addition install either ruby-oci8 (for MRI/YARV) or copy Oracle JDBC driver to $JRUBY_HOME/lib (for JRuby).
+
+== LINKS
+
+* Source code: http://github.com/rsim/ruby-plsql
+* Bug reports / Feature requests: http://github.com/rsim/ruby-plsql/issues
+* Discuss at oracle_enhanced adapter group: http://groups.google.com/group/oracle-enhanced
 
 == CONTRIBUTORS:
 

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ruby-plsql"
+    gem.summary = "Ruby API for calling Oracle PL/SQL procedures."
+    gem.description = <<-EOS
+ruby-plsql gem provides simple Ruby API for calling Oracle PL/SQL procedures.
+It could be used both for accessing Oracle PL/SQL API procedures in legacy applications
+as well as it could be used to create PL/SQL unit tests using Ruby testing libraries.
+EOS
+    gem.email = "raimonds.simanovskis@gmail.com"
+    gem.homepage = "http://github.com/rsim/ruby-plsql"
+    gem.authors = ["Raimonds Simanovskis"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.extra_rdoc_files = ['README.rdoc']
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title = "ruby-plsql #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.4.0

data/lib/plsql/connection.rb

@@ -3,13 +3,13 @@ module PLSQL
     attr_reader :raw_driver
     attr_reader :activerecord_class
 
-    def initialize(raw_drv, raw_conn, ar_class = nil)
+    def initialize(raw_drv, raw_conn, ar_class = nil) #:nodoc:
       @raw_driver = raw_drv
       @raw_connection = raw_conn
       @activerecord_class = ar_class
     end
     
-    def self.create(raw_conn, ar_class = nil)
+    def self.create(raw_conn, ar_class = nil) #:nodoc:
       if ar_class && !(defined?(::ActiveRecord) && [ar_class, ar_class.superclass].include?(::ActiveRecord::Base))
         raise ArgumentError, "Wrong ActiveRecord class"
       end
@@ -24,6 +24,7 @@ module PLSQL
       end
     end
     
+    # Returns OCI8 or JDBC connection
     def raw_connection
       if @activerecord_class
         @activerecord_class.connection.raw_connection
@@ -32,50 +33,123 @@ module PLSQL
       end
     end
     
+    # Is it OCI8 connection
     def oci?
       @raw_driver == :oci
     end
 
+    # Is it JDBC connection
     def jdbc?
       @raw_driver == :jdbc
     end
     
-    def logoff
+    def logoff #:nodoc:
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
-    def commit
+    def commit #:nodoc:
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
-    def rollback
+    def rollback #:nodoc:
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
+    # Current autocommit mode (true or false)
     def autocommit?
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
+    # Set autocommit mode (true or false)
     def autocommit=(value)
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
-    def select_first(sql, *bindvars)
-      raise NoMethodError, "Not implemented for this raw driver"
+    def select_first(sql, *bindvars) #:nodoc:
+      cursor = cursor_from_query(self, sql, *bindvars)
+      cursor.fetch
+    ensure
+      cursor.close rescue nil
     end
 
-    def select_all(sql, *bindvars, &block)
-      raise NoMethodError, "Not implemented for this raw driver"
+    def select_hash_first(sql, *bindvars) #:nodoc:
+      cursor = cursor_from_query(self, sql, *bindvars)
+      cursor.fetch_hash
+    ensure
+      cursor.close rescue nil
+    end
+
+    def select_all(sql, *bindvars, &block) #:nodoc:
+      cursor = cursor_from_query(self, sql, *bindvars)
+      results = []
+      row_count = 0
+      while row = cursor.fetch
+        if block_given?
+          yield(row)
+          row_count += 1
+        else
+          results << row
+        end
+      end
+      block_given? ? row_count : results
+    ensure
+      cursor.close rescue nil
     end
 
-    def exec(sql, *bindvars)
+    def select_hash_all(sql, *bindvars, &block) #:nodoc:
+      cursor = cursor_from_query(self, sql, *bindvars)
+      results = []
+      row_count = 0
+      while row = cursor.fetch_hash
+        if block_given?
+          yield(row)
+          row_count += 1
+        else
+          results << row
+        end
+      end
+      block_given? ? row_count : results
+    ensure
+      cursor.close rescue nil
+    end
+
+    def exec(sql, *bindvars) #:nodoc:
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
-    def parse(sql)
+    def parse(sql) #:nodoc:
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
+    def arrays_to_hash(keys, values) #:nodoc:
+      (0...keys.size).inject({}) { |hash, i| hash[keys[i]] = values[i]; hash }
+    end
+
+    module CursorCommon
+      # Fetch all rows from cursor, each row as array of values
+      def fetch_all
+        rows = []
+        while (row = fetch)
+          rows << row
+        end
+        rows
+      end
+
+      # Fetch all rows from cursor, each row as hash {:column => value, ...}
+      def fetch_hash_all
+        rows = []
+        while (row = fetch_hash)
+          rows << row
+        end
+        rows
+      end
+
+      # Fetch row from cursor as hash {:column => value, ...}
+      def fetch_hash
+        (row = fetch) && @connection.arrays_to_hash(fields, row)
+      end
+    end
+
   end
 
 end

data/lib/plsql/jdbc_connection.rb

@@ -1,5 +1,36 @@
+begin
+  require "java"
+  require "jruby"
+
+  # ojdbc14.jar file should be in JRUBY_HOME/lib or should be in ENV['PATH'] or load path
+
+  ojdbc_jar = "ojdbc14.jar"
+
+  unless ENV_JAVA['java.class.path'] =~ Regexp.new(ojdbc_jar)
+    # On Unix environment variable should be PATH, on Windows it is sometimes Path
+    env_path = ENV["PATH"] || ENV["Path"] || ''
+    if ojdbc_jar_path = env_path.split(/[:;]/).concat($LOAD_PATH).find{|d| File.exists?(File.join(d,ojdbc_jar))}
+      require File.join(ojdbc_jar_path,ojdbc_jar)
+    end
+  end
+
+  java.sql.DriverManager.registerDriver Java::oracle.jdbc.driver.OracleDriver.new
+
+  # set tns_admin property from TNS_ADMIN environment variable
+  if !java.lang.System.get_property("oracle.net.tns_admin") && ENV["TNS_ADMIN"]
+    java.lang.System.set_property("oracle.net.tns_admin", ENV["TNS_ADMIN"])
+  end
+
+rescue LoadError, NameError
+  # JDBC driver is unavailable.
+  error_message = "ERROR: ruby-plsql could not load Oracle JDBC driver. "+
+                  "Please install ojdbc14.jar library."
+  STDERR.puts error_message
+  raise LoadError
+end
+
 module PLSQL
-  class JDBCConnection < Connection
+  class JDBCConnection < Connection  #:nodoc:
     def logoff
       raw_connection.close
       true
@@ -23,47 +54,6 @@ module PLSQL
       raw_connection.setAutoCommit(value)
     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
@@ -72,9 +62,9 @@ module PLSQL
       cs.close rescue nil
     end
 
-    class Cursor
+    class CallableStatement #:nodoc:
 
-      def initialize(sql, conn)
+      def initialize(conn, sql)
         @sql = sql
         @connection = conn
         @params = sql.scan(/\:\w+/)
@@ -83,12 +73,19 @@ module PLSQL
         @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))
+      def bind_param(arg, value, metadata)
+        type, length = @connection.plsql_to_ruby_data_type(metadata)
+        ora_value = @connection.ruby_value_to_ora_value(value, type, metadata)
+        @connection.set_bind_variable(@statement, arg, ora_value, type, length, metadata)
+        if metadata[:in_out] =~ /OUT/
+          @out_types[arg] = type || ora_value.class
+          @out_index[arg] = bind_param_index(arg)
+          if ['TABLE','VARRAY','OBJECT','REF CURSOR'].include?(metadata[:data_type])
+            @statement.registerOutParameter(@out_index[arg], @connection.get_java_sql_type(ora_value,type), 
+              metadata[:sql_type_name])
+          else
+            @statement.registerOutParameter(@out_index[arg],@connection.get_java_sql_type(ora_value,type))
+          end
         end
       end
       
@@ -97,7 +94,7 @@ module PLSQL
       end
 
       def [](key)
-        @connection.get_bind_variable(@statement, @out_index[key], @out_types[key])
+        @connection.ora_value_to_ruby_value(@connection.get_bind_variable(@statement, @out_index[key], @out_types[key]))
       end
 
       def close
@@ -113,14 +110,68 @@ module PLSQL
       end
     end
 
+    class Cursor #:nodoc:
+      include Connection::CursorCommon
+
+      attr_reader :result_set
+      attr_accessor :statement
+
+      def initialize(conn, result_set)
+        @connection = conn
+        @result_set = result_set
+        @metadata = @result_set.getMetaData
+        @column_count = @metadata.getColumnCount
+        @column_type_names = [nil] # column numbering starts at 1
+        (1..@column_count).each do |i|
+          @column_type_names << {:type_name => @metadata.getColumnTypeName(i), :sql_type => @metadata.getColumnType(i)}
+        end
+      end
+
+      def self.new_from_query(conn, sql, *bindvars)
+        stmt = conn.prepare_statement(sql, *bindvars)
+        cursor = Cursor.new(conn, stmt.executeQuery)
+        cursor.statement = stmt
+        cursor
+      rescue
+        # in case of any error close statement
+        stmt.close rescue nil
+        raise
+      end
+
+      def fetch
+        if @result_set.next
+          (1..@column_count).map do |i|
+            @connection.get_ruby_value_from_result_set(@result_set, i, @column_type_names[i])
+          end
+        else
+          nil
+        end
+      end
+
+      def fields
+        @fields ||= (1..@column_count).map do |i|
+          @metadata.getColumnName(i).downcase.to_sym
+        end
+      end
+
+      def close
+        @result_set.close
+        @statement.close if @statement
+      end
+    end
+
     def parse(sql)
-      Cursor.new(sql, self)
+      CallableStatement.new(self, sql)
+    end
+
+    def cursor_from_query(sql, *bindvars)
+      Cursor.new_from_query(sql, *bindvars)
     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)
+        set_bind_variable(stmt, i+1, ruby_value_to_ora_value(bv))
       end
       stmt
     end
@@ -133,118 +184,129 @@ module PLSQL
       stmt
     end
 
+    RUBY_CLASS_TO_SQL_TYPE = {
+      Fixnum => java.sql.Types::INTEGER,
+      Bignum => java.sql.Types::INTEGER,
+      Integer => java.sql.Types::INTEGER,
+      Float => java.sql.Types::FLOAT,
+      BigDecimal => java.sql.Types::NUMERIC,
+      String => java.sql.Types::VARCHAR,
+      Java::OracleSql::CLOB => Java::oracle.jdbc.OracleTypes::CLOB,
+      Java::OracleSql::BLOB => Java::oracle.jdbc.OracleTypes::BLOB,
+      Date => java.sql.Types::DATE,
+      Time => java.sql.Types::DATE,
+      DateTime => java.sql.Types::DATE,
+      Java::OracleSql::ARRAY => Java::oracle.jdbc.OracleTypes::ARRAY,
+      Array => Java::oracle.jdbc.OracleTypes::ARRAY,
+      Java::OracleSql::STRUCT => Java::oracle.jdbc.OracleTypes::STRUCT,
+      Hash => Java::oracle.jdbc.OracleTypes::STRUCT,
+      java.sql.ResultSet => Java::oracle.jdbc.OracleTypes::CURSOR,
+    }
+    
+    SQL_TYPE_TO_RUBY_CLASS = {
+      java.sql.Types::CHAR => String,
+      java.sql.Types::VARCHAR => String,
+      java.sql.Types::NUMERIC => BigDecimal,
+      java.sql.Types::DATE => Time,
+      java.sql.Types::TIMESTAMP => Time,
+      Java::oracle.jdbc.OracleTypes::TIMESTAMPTZ => Time,
+      Java::oracle.jdbc.OracleTypes::TIMESTAMPLTZ => Time,
+      java.sql.Types::BLOB => String,
+      java.sql.Types::CLOB => String,
+      java.sql.Types::ARRAY => Java::OracleSql::ARRAY,
+      java.sql.Types::STRUCT => Java::OracleSql::STRUCT,
+      Java::oracle.jdbc.OracleTypes::CURSOR => java.sql.ResultSet
+    }
+
     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 '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'
-        java.sql.Types::DATE
-      when 'DateTime'
-        java.sql.Types::DATE
-      else
-        java.sql.Types::VARCHAR
-      end
+      RUBY_CLASS_TO_SQL_TYPE[type || value.class] || java.sql.Types::VARCHAR
     end
 
-    def set_bind_variable(stmt, i, value, type=nil, length=nil)
+    def set_bind_variable(stmt, i, value, type=nil, length=nil, metadata={})
       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'
+      type_symbol = (!value.nil? && type ? type : value.class).to_s.to_sym
+      case type_symbol
+      when :Fixnum, :Bignum, :Integer
         stmt.send("setInt#{key && "AtName"}", key || i, value)
-      when 'Float'
+      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'
+      when :BigDecimal, :'Java::JavaMath::BigDecimal'
+        stmt.send("setBigDecimal#{key && "AtName"}", key || i, value)
+      when :String
         stmt.send("setString#{key && "AtName"}", key || i, value)
-      when 'Java::OracleSql::CLOB'
+      when :'Java::OracleSql::CLOB'
         stmt.send("setClob#{key && "AtName"}", key || i, value)
-      when 'Java::OracleSql::BLOB'
+      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))
+      when :Date, :Time, :DateTime, :'Java::OracleSql::DATE'
+        stmt.send("setDATE#{key && "AtName"}", key || i, value)
+      when :NilClass
+        if ['TABLE', 'VARRAY', 'OBJECT'].include?(metadata[:data_type])
+          stmt.send("setNull#{key && "AtName"}", key || i, get_java_sql_type(value, type),
+            metadata[:sql_type_name])
+        elsif metadata[:data_type] == 'REF CURSOR'
+          # TODO: cannot bind NULL value to cursor parameter, getting error
+          # java.sql.SQLException: Unsupported feature: sqlType=-10
+          # Currently do nothing and assume that NULL values will not be passed to IN parameters
+          # If cursor is IN/OUT or OUT parameter then it should work
+        else
+          stmt.send("setNull#{key && "AtName"}", key || i, get_java_sql_type(value, type))
+        end
+      when :'Java::OracleSql::ARRAY'
+        stmt.send("setARRAY#{key && "AtName"}", key || i, value)
+      when :'Java::OracleSql::STRUCT'
+        stmt.send("setSTRUCT#{key && "AtName"}", key || i, value)
+      when :'Java::JavaSql::ResultSet'
+        # TODO: cannot find how to pass cursor parameter from JDBC
+        # setCursor is giving exception java.sql.SQLException: Unsupported feature
+        stmt.send("setCursor#{key && "AtName"}", key || i, value)
+      else
+        raise ArgumentError, "Don't know how to bind variable with type #{type_symbol}"
       end
     end
     
     def get_bind_variable(stmt, i, type)
-      case type.to_s
-      when 'Fixnum', 'Bignum', 'Integer'
+      case type.to_s.to_sym
+      when :Fixnum, :Bignum, :Integer
         stmt.getInt(i)
-      when 'Float'
+      when :Float
         stmt.getFloat(i)
-      when 'BigDecimal'
+      when :BigDecimal
         bd = stmt.getBigDecimal(i)
         bd && BigDecimal.new(bd.to_s)
-      when 'String'
+      when :String
         stmt.getString(i)
-      when 'Java::OracleSql::CLOB'
+      when :'Java::OracleSql::CLOB'
         stmt.getClob(i)
-      when 'Java::OracleSql::BLOB'
+      when :'Java::OracleSql::BLOB'
         stmt.getBlob(i)
-      when 'Date','Time','DateTime'
-        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
+      when :Date, :Time, :DateTime
+        stmt.getDATE(i)
+      when :'Java::OracleSql::ARRAY'
+        stmt.getArray(i)
+      when :'Java::OracleSql::STRUCT'
+        stmt.getSTRUCT(i)
+      when :'Java::JavaSql::ResultSet'
+        stmt.getCursor(i)
       end
     end
 
-    def get_ruby_value_from_result_set(rset, i, type_name)
-      case type_name
-      when "CHAR", "VARCHAR2"
-        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.toBigInteger+0
-        else
-          BigDecimal(d.toString)
-        end
-      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
+    def get_ruby_value_from_result_set(rset, i, metadata)
+      ruby_type = SQL_TYPE_TO_RUBY_CLASS[metadata[:sql_type]]
+      ora_value = get_bind_variable(rset, i, ruby_type)
+      result_new = ora_value_to_ruby_value(ora_value)
     end
-    
-    def plsql_to_ruby_data_type(data_type, data_length)
+
+    def result_set_to_ruby_data_type(column_type, column_type_name)
+      
+    end
+
+    def plsql_to_ruby_data_type(metadata)
+      data_type, data_length = metadata[:data_type], metadata[:data_length]
       case data_type
-      when "VARCHAR2"
+      when "VARCHAR2", "CHAR", "NVARCHAR2", "NCHAR"
         [String, data_length || 32767]
-      when "CLOB"
+      when "CLOB", "NCLOB"
         [Java::OracleSql::CLOB, nil]
       when "BLOB"
         [Java::OracleSql::BLOB, nil]
@@ -252,73 +314,163 @@ module PLSQL
         [BigDecimal, nil]
       when "DATE"
         [Time, nil]
-      when "TIMESTAMP"
+      when "TIMESTAMP", "TIMESTAMP WITH TIME ZONE", "TIMESTAMP WITH LOCAL TIME ZONE"
         [Time, nil]
+      when "TABLE", "VARRAY"
+        [Java::OracleSql::ARRAY, nil]
+      when "OBJECT"
+        [Java::OracleSql::STRUCT, nil]
+      when "REF CURSOR"
+        [java.sql.ResultSet, nil]
       else
         [String, 32767]
       end
     end
 
-    def ruby_value_to_ora_value(val, type)
-      if type == BigDecimal
-        val.nil? || val.is_a?(Fixnum) || val.is_a?(BigDecimal) ? val : BigDecimal(val.to_s)
-      elsif type == Time
-        case val
+    def ruby_value_to_ora_value(value, type=nil, metadata={})
+      type ||= value.class
+      case type.to_s.to_sym
+      when :Fixnum, :String
+        value
+      when :BigDecimal
+        case value
+        when TrueClass
+          java_bigdecimal(1)
+        when FalseClass
+          java_bigdecimal(0)
+        else
+          java_bigdecimal(value)
+        end
+      when :Time, :Date, :DateTime
+        case value
         when DateTime
-          Time.send(plsql.default_timezone, val.year, val.month, val.day, val.hour, val.min, val.sec)
+          java_date(Time.send(plsql.default_timezone, value.year, value.month, value.day, value.hour, value.min, value.sec))
         when Date
-          Time.send(plsql.default_timezone, val.year, val.month, val.day, 0, 0, 0)
+          java_date(Time.send(plsql.default_timezone, value.year, value.month, value.day, 0, 0, 0))
         else
-          val
+          java_date(value)
         end
-      elsif type == Java::OracleSql::CLOB
-        if val
+      when :'Java::OracleSql::CLOB'
+        if value
           clob = Java::OracleSql::CLOB.createTemporary(raw_connection, false, Java::OracleSql::CLOB::DURATION_SESSION)
-          clob.setString(1,val)
+          clob.setString(1, value)
           clob
         else
           Java::OracleSql::CLOB.getEmptyCLOB
         end
-      elsif type == Java::OracleSql::BLOB
-        if val
+      when :'Java::OracleSql::BLOB'
+        if value
           blob = Java::OracleSql::BLOB.createTemporary(raw_connection, false, Java::OracleSql::BLOB::DURATION_SESSION)
-          blob.setBytes(1, val.to_java_bytes)
+          blob.setBytes(1, value.to_java_bytes)
           blob
         else
           Java::OracleSql::BLOB.getEmptyBLOB
         end
+      when :'Java::OracleSql::ARRAY'
+        if value
+          raise ArgumentError, "You should pass Array value for collection type parameter" unless value.is_a?(Array)
+          descriptor = Java::OracleSql::ArrayDescriptor.createDescriptor(metadata[:sql_type_name], raw_connection)
+          elem_type = descriptor.getBaseType
+          elem_type_name = descriptor.getBaseName
+          elem_list = value.map do |elem|
+            case elem_type
+            when Java::oracle.jdbc.OracleTypes::ARRAY
+              ruby_value_to_ora_value(elem, Java::OracleSql::ARRAY, :sql_type_name => elem_type_name)
+            when Java::oracle.jdbc.OracleTypes::STRUCT
+              ruby_value_to_ora_value(elem, Java::OracleSql::STRUCT, :sql_type_name => elem_type_name)
+            else
+              ruby_value_to_ora_value(elem)
+            end
+          end
+          Java::OracleSql::ARRAY.new(descriptor, raw_connection, elem_list.to_java)
+        end
+      when :'Java::OracleSql::STRUCT'
+        if value
+          raise ArgumentError, "You should pass Hash value for object type parameter" unless value.is_a?(Hash)
+          descriptor = Java::OracleSql::StructDescriptor.createDescriptor(metadata[:sql_type_name], raw_connection)
+          struct_metadata = descriptor.getMetaData
+          struct_fields = (1..descriptor.getLength).inject({}) do |hash, i|
+            hash[struct_metadata.getColumnName(i).downcase.to_sym] =
+              {:type => struct_metadata.getColumnType(i), :type_name => struct_metadata.getColumnTypeName(i)}
+            hash
+          end
+          object_attrs = java.util.HashMap.new
+          value.each do |key, attr_value|
+            raise ArgumentError, "Wrong object type field passed to PL/SQL procedure" unless (field = struct_fields[key])
+            case field[:type]
+            when Java::oracle.jdbc.OracleTypes::ARRAY
+              # nested collection
+              object_attrs.put(key.to_s.upcase, ruby_value_to_ora_value(attr_value, Java::OracleSql::ARRAY, :sql_type_name => field[:type_name]))
+            when Java::oracle.jdbc.OracleTypes::STRUCT
+              # nested object type
+              object_attrs.put(key.to_s.upcase, ruby_value_to_ora_value(attr_value, Java::OracleSql::STRUCT, :sql_type_name => field[:type_name]))
+            else
+              object_attrs.put(key.to_s.upcase, ruby_value_to_ora_value(attr_value))
+            end
+          end
+          Java::OracleSql::STRUCT.new(descriptor, raw_connection, object_attrs)
+        end
+      when :'Java::JavaSql::ResultSet'
+        if value
+          value.result_set
+        end
       else
-        val
+        value
       end
     end
 
-    def ora_value_to_ruby_value(val)
-      case val
+    def ora_value_to_ruby_value(value)
+      case value
       when Float, BigDecimal
-        ora_number_to_ruby_number(val)
+        ora_number_to_ruby_number(value)
+      when Java::JavaMath::BigDecimal
+        value && ora_number_to_ruby_number(BigDecimal.new(value.to_s))
+      when Java::OracleSql::DATE
+        if value
+          d = value.dateValue
+          t = value.timeValue
+          Time.send(plsql.default_timezone, d.year + 1900, d.month + 1, d.date, t.hours, t.minutes, t.seconds)
+        end
       when Java::OracleSql::CLOB
-        if val.isEmptyLob
+        if value.isEmptyLob
           nil
         else
-          val.getSubString(1, val.length)
+          value.getSubString(1, value.length)
         end
       when Java::OracleSql::BLOB
-        if val.isEmptyLob
+        if value.isEmptyLob
           nil
         else
-          String.from_java_bytes(val.getBytes(1, val.length))
+          String.from_java_bytes(value.getBytes(1, value.length))
         end
+      when Java::OracleSql::ARRAY
+        value.getArray.map{|e| ora_value_to_ruby_value(e)}
+      when Java::OracleSql::STRUCT
+        descriptor = value.getDescriptor
+        struct_metadata = descriptor.getMetaData
+        field_names = (1..descriptor.getLength).map {|i| struct_metadata.getColumnName(i).downcase.to_sym}
+        field_values = value.getAttributes.map{|e| ora_value_to_ruby_value(e)}
+        arrays_to_hash(field_names, field_values)
+      when Java::java.sql.ResultSet
+        Cursor.new(self, value)
       else
-        val
+        value
       end
     end
 
     private
     
+    def java_date(value)
+      value && Java::oracle.sql.DATE.new(value.strftime("%Y-%m-%d %H:%M:%S"))
+    end
+
+    def java_bigdecimal(value)
+      value && java.math.BigDecimal.new(value.to_s)
+    end
+
     def ora_number_to_ruby_number(num)
       # 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)
+      num == (num_to_i = num.to_i) ? num_to_i : (num.is_a?(BigDecimal) ? num : BigDecimal.new(num.to_s))
     end
     
   end