ruby-plsql 0.4.1 → 0.4.2

data/History.txt

@@ -1,3 +1,21 @@
+== 0.4.2 2010-02-26
+
+* New features
+  * Support default and custom constructors of object types, support member and static method calls on PL/SQL objects
+  * Support for PL/SQL record types defined inside packages
+  * Support for PL/SQL table and index-by table of records types defined inside packages
+  * plsql.savepoint and plsql.rollback_to methods
+  * plsql.connect! method for establishing new connection
+* Improvements
+  * Better support for detecting matching overloaded implementation of procedure by sequential argument types
+  * Check if database object is valid and raise exception with compilation error if not valid
+  * Store :nullable and :data_default in table and view columns metadata
+* Bug fixes
+  * accessing package variables with schema prefixed object types
+  * insert of TIMESTAMP values in table
+  * support package variables with VARCHAR2(n CHAR) and VARCHAR2(n BYTE) types
+  * table select :order_by option
+
 == 0.4.1 2010-01-04
 
 * New features

data/Rakefile

@@ -15,6 +15,8 @@ EOS
     gem.homepage = "http://github.com/rsim/ruby-plsql"
     gem.authors = ["Raimonds Simanovskis"]
     gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "activerecord", "= 2.3.5"
+    gem.add_development_dependency "activerecord-oracle_enhanced-adapter", ">= 1.2.4"
     gem.extra_rdoc_files = ['README.rdoc']
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.4.1
+0.4.2

data/lib/plsql/connection.rb

@@ -3,27 +3,49 @@ module PLSQL
     attr_reader :raw_driver
     attr_reader :activerecord_class
 
-    def initialize(raw_drv, raw_conn, ar_class = nil) #:nodoc:
-      @raw_driver = raw_drv
+    def initialize(raw_conn, ar_class = nil) #:nodoc:
+      @raw_driver = self.class.driver_type
       @raw_connection = raw_conn
       @activerecord_class = ar_class
     end
-    
+
     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
+      case driver_type
+      when :oci
+        OCIConnection.new(raw_conn, ar_class)
+      when :jdbc
+        JDBCConnection.new(raw_conn, ar_class)
+      else
+        raise ArgumentError, "Unknown raw driver"
+      end
+    end
+
+    def self.create_new(params) #:nodoc:
+      case driver_type
+      when :oci
+        OCIConnection.create_raw(params)
+      when :jdbc
+        JDBCConnection.create_raw(params)
+      else
+        raise ArgumentError, "Unknown raw driver"
+      end
+    end
+
+    def self.driver_type #:nodoc:
       # 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)
+      @driver_type ||= if (!defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby") && defined?(OCI8)
+        :oci
       # JRuby
       elsif (defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby")
-        JDBCConnection.new(:jdbc, raw_conn, ar_class)
+        :jdbc
       else
-        raise ArgumentError, "Unknown raw driver"
+        nil
       end
     end
-    
+
     # Returns OCI8 or JDBC connection
     def raw_connection
       if @activerecord_class
@@ -32,7 +54,7 @@ module PLSQL
         @raw_connection
       end
     end
-    
+
     # Is it OCI8 connection
     def oci?
       @raw_driver == :oci
@@ -44,7 +66,10 @@ module PLSQL
     end
     
     def logoff #:nodoc:
-      raise NoMethodError, "Not implemented for this raw driver"
+      # Rollback any uncommited transactions
+      rollback
+      # Common cleanup activities before logoff, should be called from particular driver method
+      drop_session_ruby_temporary_tables
     end
 
     def commit #:nodoc:
@@ -165,6 +190,31 @@ module PLSQL
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
+    # Returns session ID
+    def session_id
+      @session_id ||= select_first("SELECT TO_NUMBER(USERENV('SESSIONID')) FROM dual")[0]
+    end
+
+    RUBY_TEMP_TABLE_PREFIX = 'ruby_'
+
+    # Drop all ruby temporary tables that are used for calling packages with table parameter types defined in packages
+    def drop_all_ruby_temporary_tables
+      select_all("SELECT table_name FROM user_tables WHERE temporary='Y' AND table_name LIKE :table_name",
+                  RUBY_TEMP_TABLE_PREFIX.upcase+'%').each do |row|
+        exec "TRUNCATE TABLE #{row[0]}"
+        exec "DROP TABLE #{row[0]}"
+      end
+    end
+
+    # Drop ruby temporary tables created in current session that are used for calling packages with table parameter types defined in packages
+    def drop_session_ruby_temporary_tables
+      select_all("SELECT table_name FROM user_tables WHERE temporary='Y' AND table_name LIKE :table_name",
+                  RUBY_TEMP_TABLE_PREFIX.upcase+"#{session_id}_%").each do |row|
+        exec "TRUNCATE TABLE #{row[0]}"
+        exec "DROP TABLE #{row[0]}"
+      end
+    end
+
   end
 
 end

data/lib/plsql/jdbc_connection.rb

@@ -31,7 +31,18 @@ end
 
 module PLSQL
   class JDBCConnection < Connection  #:nodoc:
+
+    def self.create_raw(params)
+      url = if ENV['TNS_ADMIN'] && params[:database] && !params[:host] && !params[:url]
+        "jdbc:oracle:thin:@#{params[:database]}"
+      else
+        params[:url] || "jdbc:oracle:thin:@#{params[:host] || 'localhost'}:#{params[:port] || 1521}:#{params[:database]}"
+      end
+      new(java.sql.DriverManager.getConnection(url, params[:username], params[:password]))
+    end
+
     def logoff
+      super
       raw_connection.close
       true
     rescue
@@ -84,7 +95,7 @@ module PLSQL
         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])
+          if ['TABLE','VARRAY','OBJECT'].include?(metadata[:data_type])
             @statement.registerOutParameter(@out_index[arg], @connection.get_java_sql_type(ora_value,type), 
               metadata[:sql_type_name])
           else
@@ -209,10 +220,11 @@ module PLSQL
       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::LONGVARCHAR => String,
       java.sql.Types::NUMERIC => BigDecimal,
       java.sql.Types::INTEGER => Fixnum,
       java.sql.Types::DATE => Time,

data/lib/plsql/oci_connection.rb

@@ -16,8 +16,18 @@ end
 
 module PLSQL
   class OCIConnection < Connection #:nodoc:
-    
+
+    def self.create_raw(params)
+      connection_string = if params[:host]
+        "//#{params[:host]}:#{params[:port]||1521}/#{params[:database]}"
+      else
+        params[:database]
+      end
+      new(OCI8.new(params[:username], params[:password], connection_string))
+    end
+
     def logoff
+      super
       raw_connection.logoff
     end
 

data/lib/plsql/procedure.rb

@@ -42,17 +42,31 @@ module PLSQL
     end
   end
 
-  class Procedure #:nodoc:
-    extend ProcedureClassMethods
-
+  module ProcedureCommon #:nodoc:
     attr_reader :arguments, :argument_list, :out_list, :return
     attr_reader :schema, :schema_name, :package, :procedure
 
-    def initialize(schema, procedure, package, override_schema_name, object_id)
-      @schema = schema
-      @schema_name = override_schema_name || schema.schema_name
-      @procedure = procedure.to_s.upcase
-      @package = package
+    # return type string from metadata that can be used in DECLARE block or table definition
+    def self.type_to_sql(metadata) #:nodoc:
+      case metadata[:data_type]
+      when 'NUMBER'
+        precision, scale = metadata[:data_precision], metadata[:data_scale]
+        "NUMBER#{precision ? "(#{precision}#{scale ? ",#{scale}": ""})" : ""}"
+      when 'VARCHAR2', 'CHAR', 'NVARCHAR2', 'NCHAR'
+        length = metadata[:data_length]
+        if length && (char_used = metadata[:char_used])
+          length = "#{length} #{char_used == 'C' ? 'CHAR' : 'BYTE'}"
+        end
+        "#{metadata[:data_type]}#{length ? "(#{length})": ""}"
+      when 'PL/SQL TABLE', 'TABLE', 'VARRAY', 'OBJECT'
+        metadata[:sql_type_name]
+      else
+        metadata[:data_type]
+      end
+    end
+
+    # get procedure argument metadata from data dictionary
+    def get_argument_metadata #:nodoc:
       @arguments = {}
       @argument_list = {}
       @out_list = {}
@@ -62,20 +76,27 @@ module PLSQL
       # store reference to previous level record or collection metadata
       previous_level_argument_metadata = {}
 
+      # store tmp tables for each overload for table parameters with types defined inside packages
+      @tmp_table_names = {}
+      # store if tmp tables are created for specific overload
+      @tmp_tables_created = {}
+
+      # subprogram_id column is available just from version 10g
+      subprogram_id_column = (@schema.connection.database_version <=> [10, 2]) >= 0 ? 'subprogram_id' : 'NULL'
+
       @schema.select_all(
-        "SELECT overload, argument_name, position, data_level,
+        "SELECT #{subprogram_id_column}, object_name, TO_NUMBER(overload), argument_name, position, data_level,
               data_type, in_out, data_length, data_precision, data_scale, char_used,
               type_owner, type_name, type_subname
         FROM all_arguments
         WHERE object_id = :object_id
         AND owner = :owner
         AND object_name = :procedure_name
-        AND NVL(package_name,'nil') = :package
         ORDER BY overload, sequence",
-        object_id, @schema_name, @procedure, @package ? @package : 'nil'
+        @object_id, @schema_name, @procedure
       ) do |r|
 
-        overload, argument_name, position, data_level,
+        subprogram_id, object_name, overload, argument_name, position, data_level,
             data_type, in_out, data_length, data_precision, data_scale, char_used,
             type_owner, type_name, type_subname = r
 
@@ -84,8 +105,26 @@ module PLSQL
         overload ||= 0
         @arguments[overload] ||= {}
         @return[overload] ||= nil
-
-        raise ArgumentError, "Parameter type definition inside package is not supported, use CREATE TYPE outside package" if type_subname
+        @tmp_table_names[overload] ||= []
+
+        sql_type_name = type_owner && "#{type_owner == 'PUBLIC' ? nil : "#{type_owner}."}#{type_name}#{type_subname ? ".#{type_subname}" : nil}"
+
+        tmp_table_name = nil
+        # type defined inside package
+        if type_subname
+          if collection_type?(data_type)
+            raise ArgumentError, "#{data_type} type #{sql_type_name} definition inside package is not supported as part of other type definition," <<
+              " use CREATE TYPE outside package" if data_level > 0
+            # if subprogram_id was not supported by all_arguments view
+            # then generate unique ID from object_name and overload
+            subprogram_id ||= "#{object_name.hash % 10000}#{overload}"
+            tmp_table_name = "#{Connection::RUBY_TEMP_TABLE_PREFIX}#{@schema.connection.session_id}_#{@object_id}_#{subprogram_id}_#{position}"
+          elsif data_type != 'PL/SQL RECORD'
+            # raise exception only when there are no overloaded procedure definitions
+            # (as probably this overload will not be used at all)
+            raise ArgumentError, "Parameter type #{sql_type_name} definition inside package is not supported, use CREATE TYPE outside package" if overload == 0
+          end
+        end
 
         argument_metadata = {
           :position => position && position.to_i,
@@ -98,8 +137,12 @@ module PLSQL
           :type_owner => type_owner,
           :type_name => type_name,
           :type_subname => type_subname,
-          :sql_type_name => "#{type_owner}.#{type_name}"
+          :sql_type_name => sql_type_name
         }
+        if tmp_table_name
+          @tmp_table_names[overload] << [(argument_metadata[:tmp_table_name] = tmp_table_name), argument_metadata]
+        end
+
         if composite_type?(data_type)
           case data_type
           when 'PL/SQL RECORD'
@@ -108,28 +151,33 @@ module PLSQL
           previous_level_argument_metadata[data_level] = argument_metadata
         end
 
+        # if function has return value
+        if argument_name.nil? && data_level == 0 && in_out == 'OUT'
+          @return[overload] = argument_metadata
         # if parameter
-        if argument_name
+        else
           # top level parameter
           if data_level == 0
-            @arguments[overload][argument_name.downcase.to_sym] = argument_metadata
+            # sometime there are empty IN arguments in all_arguments view for procedures without arguments (e.g. for DBMS_OUTPUT.DISABLE)
+            @arguments[overload][argument_name.downcase.to_sym] = argument_metadata if argument_name
           # or lower level part of composite type
           else
             case previous_level_argument_metadata[data_level - 1][:data_type]
             when 'PL/SQL RECORD'
               previous_level_argument_metadata[data_level - 1][:fields][argument_name.downcase.to_sym] = argument_metadata
-            when 'TABLE', 'VARRAY'
+            when 'PL/SQL TABLE', 'TABLE', 'VARRAY'
               previous_level_argument_metadata[data_level - 1][:element] = argument_metadata
             end
           end
-        # if function has return value
-        elsif argument_name.nil? && data_level == 0 && in_out == 'OUT'
-          @return[overload] = argument_metadata
         end
       end
       # if procedure is without arguments then create default empty argument list for default overload
       @arguments[0] = {} if @arguments.keys.empty?
-      
+
+      construct_argument_list_for_overloads
+    end
+
+    def construct_argument_list_for_overloads #:nodoc:
       @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]}
@@ -137,14 +185,61 @@ module PLSQL
       end
     end
 
-    PLSQL_COMPOSITE_TYPES = ['PL/SQL RECORD', 'TABLE', 'VARRAY'].freeze
-    def composite_type?(data_type)
+    def ensure_tmp_tables_created(overload) #:nodoc:
+      return if @tmp_tables_created.nil? || @tmp_tables_created[overload]
+      @tmp_table_names[overload] && @tmp_table_names[overload].each do |table_name, argument_metadata|
+        sql = "CREATE GLOBAL TEMPORARY TABLE #{table_name} (\n"
+          element_metadata = argument_metadata[:element]
+          case element_metadata[:data_type]
+          when 'PL/SQL RECORD'
+            fields_metadata = element_metadata[:fields]
+            fields_sorted_by_position = fields_metadata.keys.sort_by{|k| fields_metadata[k][:position]}
+            sql << fields_sorted_by_position.map do |field|
+              metadata = fields_metadata[field]
+              "#{field} #{ProcedureCommon.type_to_sql(metadata)}"
+            end.join(",\n")
+          else
+            sql << "element #{ProcedureCommon.type_to_sql(element_metadata)}"
+          end
+          sql << ",\ni__ NUMBER(38)\n"
+        sql << ") ON COMMIT PRESERVE ROWS\n"
+        sql_block = "DECLARE\nPRAGMA AUTONOMOUS_TRANSACTION;\nBEGIN\nEXECUTE IMMEDIATE :sql;\nEND;\n"
+        @schema.execute sql_block, sql
+      end
+      @tmp_tables_created[overload] = true
+    end
+
+    PLSQL_COMPOSITE_TYPES = ['PL/SQL RECORD', 'PL/SQL TABLE', 'TABLE', 'VARRAY'].freeze
+    def composite_type?(data_type) #:nodoc:
       PLSQL_COMPOSITE_TYPES.include? data_type
     end
 
-    def overloaded?
+    PLSQL_COLLECTION_TYPES = ['PL/SQL TABLE', 'TABLE', 'VARRAY'].freeze
+    def collection_type?(data_type) #:nodoc:
+      PLSQL_COLLECTION_TYPES.include? data_type
+    end
+
+    def overloaded? #:nodoc:
       @overloaded
     end
+  end
+
+  class Procedure #:nodoc:
+    extend ProcedureClassMethods
+    include ProcedureCommon
+
+    attr_reader :arguments, :argument_list, :out_list, :return
+    attr_reader :schema, :schema_name, :package, :procedure
+
+    def initialize(schema, procedure, package, override_schema_name, object_id)
+      @schema = schema
+      @schema_name = override_schema_name || schema.schema_name
+      @procedure = procedure.to_s.upcase
+      @package = package
+      @object_id = object_id
+
+      get_argument_metadata
+    end
 
     def exec(*args, &block)
       call = ProcedureCall.new(self, args)

data/lib/plsql/procedure_call.rb

@@ -1,15 +1,19 @@
 module PLSQL
   class ProcedureCall #:nodoc:
 
-    def initialize(procedure, args = [])
+    def initialize(procedure, args = [], options = {})
       @procedure = procedure
       @schema = @procedure.schema
       @dbms_output_stream = @schema.dbms_output_stream
+      @skip_self = options[:skip_self]
+      @self = options[:self]
       @overload = get_overload_from_arguments_list(args)
+      @procedure.ensure_tmp_tables_created(@overload) if @procedure.respond_to?(:ensure_tmp_tables_created)
       construct_sql(args)
     end
 
     def exec
+      # puts "DEBUG: sql = #{@sql.gsub("\n","<br/>\n")}"
       @cursor = @schema.connection.parse(@sql)
 
       @bind_values.each do |arg, value|
@@ -37,34 +41,106 @@ module PLSQL
     private
 
     def get_overload_from_arguments_list(args)
-      # find which overloaded definition to use
-      # if definition is overloaded then match by number of arguments
-      if @procedure.overloaded?
-        # named arguments
-        if args.size == 1 && args[0].is_a?(Hash)
-          number_of_args = args[0].keys.size
-          overload = overload_argument_list.keys.detect do |ov|
-            overload_argument_list[ov].size == number_of_args &&
-            overload_arguments[ov].keys.sort_by{|k| k.to_s} == args[0].keys.sort_by{|k| k.to_s}
-          end
-        # sequential arguments
-        # TODO: should try to implement matching by types of arguments
-        else
-          number_of_args = args.size
-          overload = overload_argument_list.keys.detect do |ov|
-            overload_argument_list[ov].size == number_of_args
-          end
+      # if not overloaded then overload index 0 is used
+      return 0 unless @procedure.overloaded?
+      # If named arguments are used then
+      # there should be just one Hash argument with symbol keys
+      if args.size == 1 && args[0].is_a?(Hash) && args[0].keys.all?{|k| k.is_a?(Symbol)}
+        args_keys = args[0].keys
+        # implicit SELF argument for object instance procedures
+        args_keys << :self if @self && !args_keys.include?(:self)
+        args_keys = args_keys.sort_by{|k| k.to_s}
+        number_of_args = args_keys.size
+        overload = overload_argument_list.keys.detect do |ov|
+          overload_argument_list[ov].size == number_of_args &&
+          overload_arguments[ov].keys.sort_by{|k| k.to_s} == args_keys
         end
-        raise ArgumentError, "Wrong number of arguments passed to overloaded PL/SQL procedure" unless overload
-        overload
+      # otherwise try matching by sequential arguments count and types
       else
-        0
+        number_of_args = args.size
+        matching_types = []
+        # if implicit SELF argument for object instance procedures should be passed
+        # then it should be added as first argument to find matches
+        if @self
+          number_of_args += 1
+          matching_types << ['OBJECT']
+        end
+        args.each do |arg|
+          matching_types << matching_oracle_types_for_ruby_value(arg)
+        end
+        exact_overloads = [] # overloads with exact number of matching arguments
+        smaller_overloads = [] # overloads with exact number of matching arguments
+        # overload = overload_argument_list.keys.detect do |ov|
+        #   overload_argument_list[ov].size == number_of_args
+        # end
+        overload_argument_list.keys.each do |ov|
+          score = 0 # lower score is better match
+          ov_arg_list_size = overload_argument_list[ov].size
+          if (number_of_args <= ov_arg_list_size &&
+              (0..(number_of_args-1)).all? do |i|
+                ov_arg = overload_argument_list[ov][i]
+                matching_types[i] == :all || # either value matches any type
+                (ind = matching_types[i].index(overload_arguments[ov][ov_arg][:data_type])) &&
+                (score += ind) # or add index of matched type
+              end)
+            if number_of_args == ov_arg_list_size
+              exact_overloads << [ov, score]
+            else
+              smaller_overloads << [ov, score]
+            end
+          end
+        end
+        # pick either first exact matching overload of first matching with smaller argument count
+        # (hoping that missing arguments will be defaulted - cannot find default value from all_arguments)
+        overload = if !exact_overloads.empty?
+          exact_overloads.sort_by{|ov, score| score}[0][0]
+        elsif !smaller_overloads.empty?
+          smaller_overloads.sort_by{|ov, score| score}[0][0]
+        end
+      end
+      raise ArgumentError, "Wrong number or types of arguments passed to overloaded PL/SQL procedure" unless overload
+      overload
+    end
+
+    MATCHING_TYPES = {
+      :integer => ['NUMBER', 'PLS_INTEGER', 'BINARY_INTEGER'],
+      :decimal => ['NUMBER', 'BINARY_FLOAT', 'BINARY_DOUBLE'],
+      :string => ['VARCHAR2', 'NVARCHAR2', 'CHAR', 'NCHAR', 'CLOB', 'BLOB'],
+      :date => ['DATE'],
+      :time => ['DATE', 'TIMESTAMP', 'TIMESTAMP WITH TIME ZONE', 'TIMESTAMP WITH LOCAL TIME ZONE'],
+      :boolean => ['PL/SQL BOOLEAN'],
+      :hash => ['PL/SQL RECORD', 'OBJECT', 'PL/SQL TABLE'],
+      :array => ['TABLE', 'VARRAY'],
+      :cursor => ['REF CURSOR']
+    }
+    def matching_oracle_types_for_ruby_value(value)
+      case value
+      when NilClass
+        :all
+      when Fixnum, Bignum
+        MATCHING_TYPES[:integer]
+      when BigDecimal, Float
+        MATCHING_TYPES[:decimal]
+      when String
+        MATCHING_TYPES[:string]
+      when Date
+        MATCHING_TYPES[:date]
+      when Time
+        MATCHING_TYPES[:time]
+      when TrueClass, FalseClass
+        MATCHING_TYPES[:boolean]
+      when Hash
+        MATCHING_TYPES[:hash]
+      when Array
+        MATCHING_TYPES[:array]
+      when CursorCommon
+        MATCHING_TYPES[:cursor]
       end
     end
 
     def construct_sql(args)
-      @declare_sql = "DECLARE\n"
-      @assignment_sql = "BEGIN\n"
+      @declare_sql = ""
+      @assignment_sql = ""
       @call_sql = ""
       @return_sql = ""
       @return_vars = []
@@ -83,12 +159,13 @@ module PLSQL
       @bind_metadata = {}
 
       # Named arguments
-      if args.size == 1 && args[0].is_a?(Hash) &&
-            # do not use named arguments if procedure has just one PL/SQL record or object type argument -
+      # there should be just one Hash argument with symbol keys
+      if args.size == 1 && args[0].is_a?(Hash) && args[0].keys.all?{|k| k.is_a?(Symbol)} &&
+            # do not use named arguments if procedure has just one PL/SQL record PL/SQL table or object type argument -
             # in that case passed Hash should be used as value for this PL/SQL record argument
             # (which will be processed in sequential arguments bracnh)
             !(argument_list.size == 1 &&
-              ['PL/SQL RECORD','OBJECT'].include?(arguments[(only_argument=argument_list[0])][:data_type]) &&
+              ['PL/SQL RECORD','PL/SQL TABLE','OBJECT'].include?(arguments[(only_argument=argument_list[0])][:data_type]) &&
               args[0].keys != [only_argument])
         # Add missing output arguments with nil value
         arguments.each do |arg, metadata|
@@ -96,6 +173,8 @@ module PLSQL
             args[0][arg] = nil
           end
         end
+        # Add SELF argument if provided
+        args[0][:self] = @self if @self
         # Add passed parameters to procedure call with parameter names
         @call_sql << args[0].map do |arg, value|
           "#{arg} => " << add_argument(arg, value)
@@ -103,6 +182,8 @@ module PLSQL
 
       # Sequential arguments
       else
+        # add SELF as first argument if provided
+        args.unshift(@self) if @self
         argument_count = argument_list.size
         raise ArgumentError, "Too many arguments passed to PL/SQL procedure" if args.size > argument_count
         # Add missing output arguments with nil value
@@ -125,62 +206,20 @@ module PLSQL
       else
         @call_sql = @procedure.call_sql(@call_sql)
       end
-      add_out_vars
+      add_out_variables
 
       dbms_output_enable_sql, dbms_output_get_sql = dbms_output_sql
 
-      @sql = "" << @declare_sql << @assignment_sql << dbms_output_enable_sql << @call_sql << dbms_output_get_sql << @return_sql << "END;\n"
+      @sql = @declare_sql.empty? ? "" : "DECLARE\n" << @declare_sql
+      @sql << "BEGIN\n" << @assignment_sql << dbms_output_enable_sql << @call_sql << dbms_output_get_sql << @return_sql << "END;\n"
     end
 
-    def dbms_output_sql
-      if @dbms_output_stream
-        dbms_output_enable_sql = "DBMS_OUTPUT.ENABLE(#{@schema.dbms_output_buffer_size});\n"
-        # if database version is at least 10.2 then use DBMS_OUTPUT.GET_LINES with SYS.DBMSOUTPUT_LINESARRAY
-        if (@schema.connection.database_version <=> [10, 2]) >= 0
-          @declare_sql << "l_dbms_output_numlines INTEGER := #{Schema::DBMS_OUTPUT_MAX_LINES};\n"
-          dbms_output_get_sql = "DBMS_OUTPUT.GET_LINES(:dbms_output_lines, l_dbms_output_numlines);\n"
-          @bind_values[:dbms_output_lines] = nil
-          @bind_metadata[:dbms_output_lines] = {:data_type => 'TABLE', :data_length => nil,
-            :sql_type_name => "SYS.DBMSOUTPUT_LINESARRAY", :in_out => 'OUT'}
-        # if database version is less than 10.2 then use individual DBMS_OUTPUT.GET_LINE calls
-        else
-          dbms_output_get_sql = ""
-        end
-        [dbms_output_enable_sql, dbms_output_get_sql]
-      else
-        ["", ""]
-      end
-    end
-
-    def dbms_output_log
-      if @dbms_output_stream
-        # if database version is at least 10.2 then :dbms_output_lines output bind variable has dbms_output lines
-        if @bind_metadata[:dbms_output_lines]
-          @cursor[':dbms_output_lines'].each do |line|
-            @dbms_output_stream.puts "DBMS_OUTPUT: #{line}" if line
-          end
-        # if database version is less than 10.2 then use individual DBMS_OUTPUT.GET_LINE calls
-        else
-          cursor = @schema.connection.parse("BEGIN sys.dbms_output.get_line(:line, :status); END;")
-          while true do
-            cursor.bind_param(':line', nil, :data_type => 'VARCHAR2', :in_out => 'OUT')
-            cursor.bind_param(':status', nil, :data_type => 'NUMBER', :in_out => 'OUT')
-            cursor.exec
-            break unless cursor[':status'] == 0
-            @dbms_output_stream.puts "DBMS_OUTPUT: #{cursor[':line']}"
-          end
-          cursor.close
-        end
-        @dbms_output_stream.flush
-      end
-    end
-
-    def add_argument(argument, value)
-      argument_metadata = arguments[argument]
+    def add_argument(argument, value, argument_metadata=nil)
+      argument_metadata ||= arguments[argument]
       raise ArgumentError, "Wrong argument #{argument.inspect} passed to PL/SQL procedure" unless argument_metadata
       case argument_metadata[:data_type]
       when 'PL/SQL RECORD'
-        @declare_sql << record_declaration_sql(argument, argument_metadata)
+        add_record_declaration(argument, argument_metadata)
         record_assignment_sql, record_bind_values, record_bind_metadata =
           record_assignment_sql_values_metadata(argument, argument_metadata, value)
         @assignment_sql << record_assignment_sql
@@ -194,22 +233,94 @@ module PLSQL
         @bind_metadata[argument] = argument_metadata.merge(:data_type => "NUMBER", :data_precision => 1)
         "l_#{argument}"
       else
-        @bind_values[argument] = value
-        @bind_metadata[argument] = argument_metadata
-        ":#{argument}"
+        # TABLE or PL/SQL TABLE type defined inside package
+        if argument_metadata[:tmp_table_name]
+          add_table_declaration_and_assignment(argument, argument_metadata)
+          insert_values_into_tmp_table(argument, argument_metadata, value)
+          "l_#{argument}"
+        else
+          @bind_values[argument] = value
+          @bind_metadata[argument] = argument_metadata
+          ":#{argument}"
+        end
+      end
+    end
+
+    def add_table_declaration_and_assignment(argument, argument_metadata)
+      is_index_by_table = argument_metadata[:data_type] == 'PL/SQL TABLE'
+      @declare_sql << "l_#{argument} #{argument_metadata[:sql_type_name]}#{is_index_by_table ? nil : " := #{argument_metadata[:sql_type_name]}()"};\n"
+      @assignment_sql << "FOR r_#{argument} IN c_#{argument} LOOP\n"
+      @assignment_sql << "l_#{argument}.EXTEND;\n" unless is_index_by_table
+      case argument_metadata[:element][:data_type]
+      when 'PL/SQL RECORD'
+        fields = record_fields_sorted_by_position(argument_metadata[:element][:fields])
+        fields_string = is_index_by_table ? "*" : fields.join(', ')
+        @declare_sql << "CURSOR c_#{argument} IS SELECT #{fields_string} FROM #{argument_metadata[:tmp_table_name]} ORDER BY i__;\n"
+        if is_index_by_table
+          fields.each do |field|
+            @assignment_sql << "l_#{argument}(r_#{argument}.i__).#{field} := r_#{argument}.#{field};\n"
+          end
+        else
+          @assignment_sql << "l_#{argument}(l_#{argument}.COUNT) := r_#{argument};\n"
+        end
+      else
+        @declare_sql << "CURSOR c_#{argument} IS SELECT * FROM #{argument_metadata[:tmp_table_name]} ORDER BY i__;\n"
+        @assignment_sql << "l_#{argument}(r_#{argument}.i__) := r_#{argument}.element;\n"
+      end
+      @assignment_sql << "END LOOP;\n"
+      @assignment_sql << "DELETE FROM #{argument_metadata[:tmp_table_name]};\n"
+    end
+
+    def insert_values_into_tmp_table(argument, argument_metadata, values)
+      return unless values && !values.empty?
+      is_index_by_table = argument_metadata[:data_type] == 'PL/SQL TABLE'
+      if is_index_by_table
+        raise ArgumentError, "Hash value should be passed for #{argument.inspect} argument" unless values.is_a?(Hash)
+      else
+        raise ArgumentError, "Array value should be passed for #{argument.inspect} argument" unless values.is_a?(Array)
+      end
+      tmp_table = @schema.root_schema.send(argument_metadata[:tmp_table_name])
+      # insert values without autocommit
+      old_autocommit = @schema.connection.autocommit?
+      @schema.connection.autocommit = false if old_autocommit
+      case argument_metadata[:element][:data_type]
+      when 'PL/SQL RECORD'
+        values_with_index = []
+        if is_index_by_table
+          values.each{|i,v| values_with_index << v.merge(:i__ => i)}
+        else
+          values.each_with_index{|v,i| values_with_index << v.merge(:i__ => i+1)}
+        end
+        tmp_table.insert values_with_index
+      else
+        values_with_index = []
+        if is_index_by_table
+          values.each{|i,v| values_with_index << [v, i]}
+        else
+          values.each_with_index{|v,i| values_with_index << [v, i+1]}
+        end
+        tmp_table.insert_values [:element, :i__], *values_with_index
+      end
+      @schema.connection.autocommit = true if old_autocommit
+    end
+
+    def add_record_declaration(argument, argument_metadata)
+      @declare_sql << if argument_metadata[:type_subname]
+        "l_#{argument} #{argument_metadata[:sql_type_name]};\n"
+      else
+        fields_metadata = argument_metadata[:fields]
+        sql = "TYPE t_#{argument} IS RECORD (\n"
+        sql << record_fields_sorted_by_position(fields_metadata).map do |field|
+          metadata = fields_metadata[field]
+          "#{field} #{type_to_sql(metadata)}"
+        end.join(",\n")
+        sql << ");\n"
+        sql << "l_#{argument} t_#{argument};\n"
       end
     end
 
-    def record_declaration_sql(argument, argument_metadata)
-      fields_metadata = argument_metadata[:fields]
-      sql = "TYPE t_#{argument} IS RECORD (\n"
-      fields_sorted_by_position = fields_metadata.keys.sort_by{|k| fields_metadata[k][:position]}
-      sql << fields_sorted_by_position.map do |field|
-        metadata = fields_metadata[field]
-        "#{field} #{type_to_sql(metadata)}"
-      end.join(",\n")
-      sql << ");\n"
-      sql << "l_#{argument} t_#{argument};\n"
+    def record_fields_sorted_by_position(fields_metadata)
+      fields_metadata.keys.sort_by{|k| fields_metadata[k][:position]}
     end
 
     def record_assignment_sql_values_metadata(argument, argument_metadata, record_value)
@@ -229,136 +340,165 @@ module PLSQL
     end
 
     def add_return
-      case return_metadata[:data_type]
+      add_return_variable(:return, return_metadata, true)
+    end
+
+    def add_out_variables
+      out_list.each do |argument|
+        add_return_variable(argument, arguments[argument])
+      end
+    end
+
+    def add_return_variable(argument, argument_metadata, is_return_value=false)
+      case argument_metadata[:data_type]
       when 'PL/SQL RECORD'
-        @declare_sql << record_declaration_sql('return', return_metadata)
-        return_metadata[:fields].each do |field, metadata|
-          bind_variable = :"return_f#{metadata[:position]}"
+        add_record_declaration(argument, argument_metadata) if is_return_value
+        argument_metadata[:fields].each do |field, metadata|
+          # should use different output bind variable as JDBC does not support
+          # if output bind variable appears in several places
+          bind_variable = :"#{argument}_o#{metadata[:position]}"
           @return_vars << bind_variable
           @return_vars_metadata[bind_variable] = metadata
-          @return_sql << ":#{bind_variable} := l_return.#{field};\n"
+          @return_sql << ":#{bind_variable} := l_#{argument}.#{field};\n"
         end
-        "l_return := "
+        "l_#{argument} := " if is_return_value
       when 'PL/SQL BOOLEAN'
-        @declare_sql << "l_return BOOLEAN;\n"
-        @declare_sql << "x_return NUMBER(1);\n"
-        @return_vars << :return
-        @return_vars_metadata[:return] = return_metadata.merge(:data_type => "NUMBER", :data_precision => 1)
-        @return_sql << "IF l_return IS NULL THEN\nx_return := NULL;\nELSIF l_return THEN\nx_return := 1;\nELSE\nx_return := 0;\nEND IF;\n" <<
-                        ":return := x_return;\n"
-        "l_return := "
+        @declare_sql << "l_#{argument} BOOLEAN;\n" if is_return_value
+        @declare_sql << "o_#{argument} NUMBER(1);\n"
+        # should use different output bind variable as JDBC does not support
+        # if output bind variable appears in several places
+        bind_variable = :"o_#{argument}"
+        @return_vars << bind_variable
+        @return_vars_metadata[bind_variable] = argument_metadata.merge(:data_type => "NUMBER", :data_precision => 1)
+        @return_sql << "IF l_#{argument} IS NULL THEN\no_#{argument} := NULL;\n" <<
+                      "ELSIF l_#{argument} THEN\no_#{argument} := 1;\nELSE\no_#{argument} := 0;\nEND IF;\n" <<
+                      ":#{bind_variable} := o_#{argument};\n"
+        "l_#{argument} := " if is_return_value
       else
-        @return_vars << :return
-        @return_vars_metadata[:return] = return_metadata
-        ':return := '
+        if argument_metadata[:tmp_table_name]
+          add_return_table(argument, argument_metadata, is_return_value)
+        elsif is_return_value
+          @return_vars << argument
+          @return_vars_metadata[argument] = argument_metadata
+          ":#{argument} := "
+        end
       end
     end
 
-    def add_out_vars
-      out_list.each do |argument|
-        argument_metadata = arguments[argument]
-        case argument_metadata[:data_type]
-        when 'PL/SQL RECORD'
-          argument_metadata[:fields].each do |field, metadata|
-            bind_variable = :"#{argument}_o#{metadata[:position]}"
-            @return_vars << bind_variable
-            @return_vars_metadata[bind_variable] = metadata
-            @return_sql << ":#{bind_variable} := l_#{argument}.#{field};\n"
-          end
-        when 'PL/SQL BOOLEAN'
-          @declare_sql << "x_#{argument} NUMBER(1);\n"
-          bind_variable = :"o_#{argument}"
-          @return_vars << bind_variable
-          @return_vars_metadata[bind_variable] = argument_metadata.merge(:data_type => "NUMBER", :data_precision => 1)
-          @return_sql << "IF l_#{argument} IS NULL THEN\nx_#{argument} := NULL;\n" <<
-                        "ELSIF l_#{argument} THEN\nx_#{argument} := 1;\nELSE\nx_#{argument} := 0;\nEND IF;\n" <<
-                        ":#{bind_variable} := x_#{argument};\n"
-        end
+    def add_return_table(argument, argument_metadata, is_return_value=false)
+      is_index_by_table = argument_metadata[:data_type] == 'PL/SQL TABLE'
+      declare_i__
+      @declare_sql << "l_return #{return_metadata[:sql_type_name]};\n" if is_return_value
+      @return_vars << argument
+      @return_vars_metadata[argument] = argument_metadata.merge(:data_type => "REF CURSOR")
+      @return_sql << if is_index_by_table
+        "i__ := l_#{argument}.FIRST;\nLOOP\nEXIT WHEN i__ IS NULL;\n"
+      else
+        "FOR i__ IN l_#{argument}.FIRST..l_#{argument}.LAST LOOP\n"
+      end
+      case argument_metadata[:element][:data_type]
+      when 'PL/SQL RECORD'
+        field_names = record_fields_sorted_by_position(argument_metadata[:element][:fields])
+        values_string = field_names.map{|f| "l_return(i__).#{f}"}.join(', ')
+        @return_sql << "INSERT INTO #{argument_metadata[:tmp_table_name]} VALUES (#{values_string}, i__);\n"
+        return_fields_string = is_index_by_table ? '*' : field_names.join(', ')
+      else
+        @return_sql << "INSERT INTO #{argument_metadata[:tmp_table_name]} VALUES (l_#{argument}(i__), i__);\n"
+        return_fields_string = '*'
       end
+      @return_sql << "i__ := l_#{argument}.NEXT(i__);\n" if is_index_by_table
+      @return_sql << "END LOOP;\n"
+      @return_sql << "OPEN :#{argument} FOR SELECT #{return_fields_string} FROM #{argument_metadata[:tmp_table_name]} ORDER BY i__;\n"
+      @return_sql << "DELETE FROM #{argument_metadata[:tmp_table_name]};\n"
+      "l_#{argument} := " if is_return_value
     end
 
-    def type_to_sql(metadata)
-      case metadata[:data_type]
-      when 'NUMBER'
-        precision, scale = metadata[:data_precision], metadata[:data_scale]
-        "NUMBER#{precision ? "(#{precision}#{scale ? ",#{scale}": ""})" : ""}"
-      when 'VARCHAR2', 'CHAR', 'NVARCHAR2', 'NCHAR'
-        length = metadata[:data_length]
-        if length && (char_used = metadata[:char_used])
-          length = "#{length} #{char_used == 'C' ? 'CHAR' : 'BYTE'}"
-        end
-        "#{metadata[:data_type]}#{length ? "(#{length})": ""}"
-      when 'TABLE', 'VARRAY', 'OBJECT'
-        metadata[:sql_type_name]
-      else
-        metadata[:data_type]
+    # declare once temp variable i__ that is used as itertor
+    def declare_i__
+      unless @declared_i__
+        @declare_sql << "i__ PLS_INTEGER;\n"
+        @declared_i__ = true
       end
     end
 
+    def type_to_sql(metadata)
+      ProcedureCommon.type_to_sql(metadata)
+    end
+
     def get_return_value
       # if function with output parameters
       if return_metadata && out_list.size > 0
         result = [function_return_value, {}]
         out_list.each do |k|
-          result[1][k] = out_var_value(k)
+          result[1][k] = out_variable_value(k)
         end
+        result
       # if function without output parameters
       elsif return_metadata
-        result = function_return_value
+        function_return_value
       # if procedure with output parameters
       elsif out_list.size > 0
         result = {}
         out_list.each do |k|
-          result[k] = out_var_value(k)
+          result[k] = out_variable_value(k)
         end
+        result
       # if procedure without output parameters
       else
-        result = nil
+        nil
       end
-      result
     end
 
     def function_return_value
-      case return_metadata[:data_type]
-      when 'PL/SQL RECORD'
-        return_value = {}
-        return_metadata[:fields].each do |field, metadata|
-          bind_variable = :"return_f#{metadata[:position]}"
-          return_value[field] = @cursor[":#{bind_variable}"]
-        end
-        return_value
-      when 'PL/SQL BOOLEAN'
-        numeric_value = @cursor[':return']
-        numeric_value.nil? ? nil : numeric_value == 1
-      else
-        @cursor[':return']
-      end
+      return_variable_value(:return, return_metadata)
+    end
+
+    def out_variable_value(argument)
+      return_variable_value(argument, arguments[argument])
     end
 
-    def out_var_value(argument)
-      argument_metadata = arguments[argument]
+    def return_variable_value(argument, argument_metadata)
       case argument_metadata[:data_type]
       when 'PL/SQL RECORD'
         return_value = {}
         argument_metadata[:fields].each do |field, metadata|
-          bind_variable = :"#{argument}_o#{metadata[:position]}"
-          return_value[field] = @cursor[":#{bind_variable}"]
+          return_value[field] = @cursor[":#{argument}_o#{metadata[:position]}"]
         end
         return_value
       when 'PL/SQL BOOLEAN'
         numeric_value = @cursor[":o_#{argument}"]
         numeric_value.nil? ? nil : numeric_value == 1
       else
-        @cursor[":#{argument}"]
+        if argument_metadata[:tmp_table_name]
+          is_index_by_table = argument_metadata[:data_type] == 'PL/SQL TABLE'
+          case argument_metadata[:element][:data_type]
+          when 'PL/SQL RECORD'
+            if is_index_by_table
+              Hash[*@cursor[":#{argument}"].fetch_hash_all.map{|row| [row.delete(:i__), row]}.flatten]
+            else
+              @cursor[":#{argument}"].fetch_hash_all
+            end
+          else
+            if is_index_by_table
+              Hash[*@cursor[":#{argument}"].fetch_all.map{|row| [row[1], row[0]]}.flatten]
+            else
+              @cursor[":#{argument}"].fetch_all.map{|row| row[0]}
+            end
+          end
+        else
+          @cursor[":#{argument}"]
+        end
       end
     end
 
     def overload_argument_list
-      @overload_argument_list ||= @procedure.argument_list
+      @overload_argument_list ||=
+        @skip_self ? @procedure.argument_list_without_self : @procedure.argument_list
     end
 
     def overload_arguments
-      @overload_arguments ||= @procedure.arguments
+      @overload_arguments ||=
+        @skip_self ? @procedure.arguments_without_self : @procedure.arguments
     end
 
     def argument_list
@@ -374,7 +514,8 @@ module PLSQL
     end
 
     def out_list
-      @out_list ||= @procedure.out_list[@overload]
+      @out_list ||=
+        @skip_self ? @procedure.out_list_without_self[@overload] : @procedure.out_list[@overload]
     end
 
     def schema_name
@@ -389,6 +530,49 @@ module PLSQL
       @procedure_name ||= @procedure.procedure
     end
 
+    def dbms_output_sql
+      if @dbms_output_stream
+        dbms_output_enable_sql = "DBMS_OUTPUT.ENABLE(#{@schema.dbms_output_buffer_size});\n"
+        # if database version is at least 10.2 then use DBMS_OUTPUT.GET_LINES with SYS.DBMSOUTPUT_LINESARRAY
+        if (@schema.connection.database_version <=> [10, 2]) >= 0
+          @declare_sql << "l_dbms_output_numlines INTEGER := #{Schema::DBMS_OUTPUT_MAX_LINES};\n"
+          dbms_output_get_sql = "DBMS_OUTPUT.GET_LINES(:dbms_output_lines, l_dbms_output_numlines);\n"
+          @bind_values[:dbms_output_lines] = nil
+          @bind_metadata[:dbms_output_lines] = {:data_type => 'TABLE', :data_length => nil,
+            :sql_type_name => "SYS.DBMSOUTPUT_LINESARRAY", :in_out => 'OUT'}
+        # if database version is less than 10.2 then use individual DBMS_OUTPUT.GET_LINE calls
+        else
+          dbms_output_get_sql = ""
+        end
+        [dbms_output_enable_sql, dbms_output_get_sql]
+      else
+        ["", ""]
+      end
+    end
+
+    def dbms_output_log
+      if @dbms_output_stream
+        # if database version is at least 10.2 then :dbms_output_lines output bind variable has dbms_output lines
+        if @bind_metadata[:dbms_output_lines]
+          @cursor[':dbms_output_lines'].each do |line|
+            @dbms_output_stream.puts "DBMS_OUTPUT: #{line}" if line
+          end
+        # if database version is less than 10.2 then use individual DBMS_OUTPUT.GET_LINE calls
+        else
+          cursor = @schema.connection.parse("BEGIN sys.dbms_output.get_line(:line, :status); END;")
+          while true do
+            cursor.bind_param(':line', nil, :data_type => 'VARCHAR2', :in_out => 'OUT')
+            cursor.bind_param(':status', nil, :data_type => 'NUMBER', :in_out => 'OUT')
+            cursor.exec
+            break unless cursor[':status'] == 0
+            @dbms_output_stream.puts "DBMS_OUTPUT: #{cursor[':line']}"
+          end
+          cursor.close
+        end
+        @dbms_output_stream.flush
+      end
+    end
+
   end
 
 end