flash-gordons-ruby-plsql 0.5.0

data/lib/plsql/oci8_patches.rb

@@ -0,0 +1,25 @@
+# apply TIMESTAMP fractional seconds patch to ruby-oci8 2.0.3
+# see http://rubyforge.org/forum/forum.php?thread_id=46576&forum_id=1078
+if OCI8::VERSION == "2.0.3" &&
+  !OCI8::BindType::Util.method_defined?(:datetime_to_array_without_timestamp_patch)
+
+  OCI8::BindType::Util.module_eval do
+    alias :datetime_to_array_without_timestamp_patch :datetime_to_array
+    def datetime_to_array(val, full)
+      result = datetime_to_array_without_timestamp_patch(val, full)
+      if result && result[6] == 0
+        if val.respond_to? :nsec
+          fsec = val.nsec
+        elsif val.respond_to? :usec
+          fsec = val.usec * 1000
+        else
+          fsec = 0
+        end
+        result[6] = fsec
+      end
+      result
+    end
+    private :datetime_to_array_without_timestamp_patch, :datetime_to_array
+  end
+  
+end

data/lib/plsql/oci_connection.rb

@@ -0,0 +1,339 @@
+begin
+  require "oci8"
+rescue LoadError
+  # OCI8 driver is unavailable.
+  msg = $!.to_s
+  if /-- oci8$/ =~ msg
+    # ruby-oci8 is not installed.
+    # MRI <= 1.9.2, Rubinius, JRuby:
+    #   no such file to load -- oci8
+    # MRI >= 1.9.3:
+    #   cannot load such file -- oci8
+    msg = "Please install ruby-oci8 gem."
+  end
+  raise LoadError, "ERROR: ruby-plsql could not load ruby-oci8 library. #{msg}"
+end
+
+require "plsql/oci8_patches"
+
+# check ruby-oci8 version
+required_oci8_version = [2, 0, 3]
+oci8_version_ints = OCI8::VERSION.scan(/\d+/).map{|s| s.to_i}
+if (oci8_version_ints <=> required_oci8_version) < 0
+  raise LoadError, "ERROR: ruby-oci8 version #{OCI8::VERSION} is too old. Please install ruby-oci8 version #{required_oci8_version.join('.')} or later."
+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
+
+    def commit
+      raw_connection.commit
+    end
+
+    def rollback
+      raw_connection.rollback
+    end
+    
+    def autocommit?
+      raw_connection.autocommit?
+    end
+
+    def autocommit=(value)
+      raw_connection.autocommit = value
+    end
+
+    def prefetch_rows=(value)
+      raw_connection.prefetch_rows = value
+    end
+
+    def exec(sql, *bindvars)
+      raw_connection.exec(sql, *bindvars)
+      true
+    end
+
+    class Cursor #:nodoc:
+      include Connection::CursorCommon
+
+      # stack of open cursors
+      @@open_cursors = []
+      attr_reader :raw_cursor
+
+      def initialize(conn, raw_cursor)
+        @connection = conn
+        @raw_cursor = raw_cursor
+        @@open_cursors.push self
+      end
+
+      def self.new_from_parse(conn, sql)
+        raw_cursor = conn.raw_connection.parse(sql)
+        self.new(conn, raw_cursor)
+      end
+
+      def self.new_from_query(conn, sql, bindvars=[], options={})
+        cursor = new_from_parse(conn, sql)
+        if prefetch_rows = options[:prefetch_rows]
+          cursor.prefetch_rows = prefetch_rows
+        end
+        cursor.exec(*bindvars)
+        cursor
+      end
+
+      def prefetch_rows=(value)
+        @raw_cursor.prefetch_rows = value
+      end
+
+      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)
+        @raw_cursor.bind_param(arg, ora_value, type, length)
+      end
+      
+      def exec(*bindvars)
+        @raw_cursor.exec(*bindvars)
+      end
+
+      def [](key)
+        @connection.ora_value_to_ruby_value(@raw_cursor[key])
+      end
+
+      def fetch
+        row = @raw_cursor.fetch
+        row && row.map{|v| @connection.ora_value_to_ruby_value(v)}
+      end
+
+      def fields
+        @fields ||= @raw_cursor.get_col_names.map{|c| c.downcase.to_sym}
+      end
+
+      def close_raw_cursor
+        @raw_cursor.close
+      end
+
+      def close
+        # close all cursors that were created after this one
+        while (open_cursor = @@open_cursors.pop) && !open_cursor.equal?(self)
+          open_cursor.close_raw_cursor
+        end
+        close_raw_cursor
+      end
+
+    end
+
+    def parse(sql)
+      Cursor.new_from_parse(self, sql)
+    end
+
+    def cursor_from_query(sql, bindvars=[], options={})
+      Cursor.new_from_query(self, sql, bindvars, options)
+    end
+
+    def plsql_to_ruby_data_type(metadata)
+      data_type, data_length = metadata[:data_type], metadata[:data_length]
+      case data_type
+      when "VARCHAR2", "CHAR", "NVARCHAR2", "NCHAR"
+        [String, data_length || 32767]
+      when "CLOB", "NCLOB"
+        [OCI8::CLOB, nil]
+      when "BLOB"
+        [OCI8::BLOB, nil]
+      when "NUMBER", "PLS_INTEGER", "BINARY_INTEGER"
+        [OraNumber, nil]
+      when "DATE"
+        [DateTime, nil]
+      when "TIMESTAMP", "TIMESTAMP WITH TIME ZONE", "TIMESTAMP WITH LOCAL TIME ZONE"
+        [Time, nil]
+      when "TABLE", "VARRAY", "OBJECT"
+        # create Ruby class for collection
+        klass = OCI8::Object::Base.get_class_by_typename(metadata[:sql_type_name])
+        unless klass
+          klass = Class.new(OCI8::Object::Base)
+          klass.set_typename metadata[:sql_type_name]
+        end
+        [klass, nil]
+      when "REF CURSOR"
+        [OCI8::Cursor]
+      else
+        [String, 32767]
+      end
+    end
+
+    def ruby_value_to_ora_value(value, type=nil)
+      type ||= value.class
+      case type.to_s.to_sym
+      when :Fixnum, :BigDecimal, :String
+        value
+      when :OraNumber
+        # pass parameters as OraNumber to avoid rounding errors
+        case value
+        when Bignum
+          OraNumber.new(value.to_s)
+        when BigDecimal
+          OraNumber.new(value.to_s('F'))
+        when TrueClass
+          OraNumber.new(1)
+        when FalseClass
+          OraNumber.new(0)
+        else
+          value
+        end
+      when :DateTime
+        case value
+        when Time
+          ::DateTime.civil(value.year, value.month, value.day, value.hour, value.min, value.sec, Rational(value.utc_offset, 86400))
+        when DateTime
+          value
+        when Date
+          ::DateTime.civil(value.year, value.month, value.day, 0, 0, 0, 0)
+        else
+          value
+        end
+      when :"OCI8::CLOB", :"OCI8::BLOB"
+        # ruby-oci8 cannot create CLOB/BLOB from ''
+        value.to_s.length > 0 ? type.new(raw_oci_connection, value) : nil
+      when :"OCI8::Cursor"
+        value && value.raw_cursor
+      else
+        # collections and object types
+        if type.superclass == OCI8::Object::Base
+          return nil if value.nil?
+          tdo = raw_oci_connection.get_tdo_by_class(type)
+          if tdo.is_collection?
+            raise ArgumentError, "You should pass Array value for collection type parameter" unless value.is_a?(Array)
+            elem_list = value.map do |elem|
+              if (attr_tdo = tdo.coll_attr.typeinfo)
+                attr_type, attr_length = plsql_to_ruby_data_type(:data_type => 'OBJECT', :sql_type_name => attr_tdo.typename)
+              else
+                attr_type = elem.class
+              end
+              ruby_value_to_ora_value(elem, attr_type)
+            end
+            # construct collection value
+            # TODO: change setting instance variable to appropriate ruby-oci8 method call when available
+            collection = type.new(raw_oci_connection)
+            collection.instance_variable_set('@attributes', elem_list)
+            collection
+          else # object type
+            raise ArgumentError, "You should pass Hash value for object type parameter" unless value.is_a?(Hash)
+            object_attrs = value.dup
+            object_attrs.keys.each do |key|
+              raise ArgumentError, "Wrong object type field passed to PL/SQL procedure" unless (attr = tdo.attr_getters[key])
+              case attr.datatype
+              when OCI8::TDO::ATTR_NAMED_TYPE, OCI8::TDO::ATTR_NAMED_COLLECTION
+                # nested object type or collection
+                attr_type, attr_length = plsql_to_ruby_data_type(:data_type => 'OBJECT', :sql_type_name => attr.typeinfo.typename)
+                object_attrs[key] = ruby_value_to_ora_value(object_attrs[key], attr_type)
+              end
+            end
+            type.new(raw_oci_connection, object_attrs)
+          end
+        # all other cases
+        else
+          value
+        end
+      end
+    end
+
+    def ora_value_to_ruby_value(value)
+      case value
+      when Float, OraNumber, BigDecimal
+        ora_number_to_ruby_number(value)
+      when DateTime, OraDate
+        ora_date_to_ruby_date(value)
+      when OCI8::LOB
+        if value.available?
+          value.rewind
+          value.read
+        else
+          nil
+        end
+      when OCI8::Object::Base
+        tdo = raw_oci_connection.get_tdo_by_class(value.class)
+        if tdo.is_collection?
+          value.to_ary.map{|e| ora_value_to_ruby_value(e)}
+        else # object type
+          tdo.attributes.inject({}) do |hash, attr|
+            hash[attr.name] = ora_value_to_ruby_value(value.instance_variable_get(:@attributes)[attr.name])
+            hash
+          end
+        end
+      when OCI8::Cursor
+        Cursor.new(self, value)
+      else
+        value
+      end
+    end
+
+    def describe_synonym(schema_name, synonym_name)
+      if schema_name == 'PUBLIC'
+        full_name = synonym_name.to_s
+      else
+        full_name = "#{schema_name}.#{synonym_name}"
+      end
+      metadata = raw_connection.describe_synonym(full_name)
+      [metadata.schema_name, metadata.name]
+    rescue OCIError
+      nil
+    end
+
+    def database_version
+      @database_version ||= (version = raw_connection.oracle_server_version) && 
+        [version.major, version.minor, version.update, version.patch]
+    end
+
+    private
+    
+    def raw_oci_connection
+      if raw_connection.is_a? OCI8
+        raw_connection
+      # ActiveRecord Oracle enhanced adapter puts OCI8EnhancedAutoRecover wrapper around OCI8
+      # in this case we need to pass original OCI8 connection
+      else
+        raw_connection.instance_variable_get(:@connection)
+      end
+    end
+    
+    def ora_number_to_ruby_number(num)
+      # return BigDecimal instead of Float to avoid rounding errors
+      num == (num_to_i = num.to_i) ? num_to_i : (num.is_a?(BigDecimal) ? num : BigDecimal.new(num.to_s))
+    end
+    
+    def ora_date_to_ruby_date(val)
+      case val
+      when DateTime
+        # 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
+        # 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
+    end
+
+  end
+  
+end

data/lib/plsql/package.rb

@@ -0,0 +1,80 @@
+module PLSQL
+  module PackageClassMethods #:nodoc:
+    def find(schema, package_name)
+      find_package_in_schema(schema, package_name) || find_package_by_synonym(schema, package_name)
+    end
+
+    def find_by_db_object(db_object)
+      find(db_object.schema, db_object.name)
+    end
+
+    def find_package_in_schema(schema, package_name)
+      row = schema.select_first(<<-SQL, schema.schema_name, package_name.to_s.upcase)
+        SELECT object_name
+        FROM   all_objects
+        WHERE  owner = :owner
+        AND    object_name = :package
+        AND    object_type = 'PACKAGE'
+      SQL
+      new(schema, package_name) if row
+    end
+
+    def find_package_by_synonym(schema, package_name)
+      row = schema.select_first(<<-SQL, schema.schema_name, package_name.to_s.upcase)
+        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)
+      SQL
+      new(schema, row[1], row[0]) if row
+    end
+  end
+
+  class Package #:nodoc:
+    extend PackageClassMethods
+
+    def initialize(schema, package, override_schema_name = nil)
+      @schema = schema
+      @override_schema_name = override_schema_name
+      @package = package.to_s.upcase
+      @package_objects = {}
+    end
+
+    def [](object_name)
+      object_name = object_name.to_s
+      @package_objects[object_name] ||= [Procedure, Variable, PipelinedFunction].inject(nil) do |res, object_type|
+        res || object_type.find(@schema, object_name, @package, @override_schema_name)
+      end
+    end
+
+    private
+    
+    def method_missing(method, *args, &block)
+      method = method.to_s
+      method.chop! if (assignment = method[/=$/])
+
+      case (object = self[method])
+      when Procedure, PipelinedFunction
+        raise ArgumentError, "Cannot assign value to package procedure '#{method.upcase}'" if assignment
+        object.exec(*args, &block)
+      when Variable
+        if assignment
+          raise ArgumentError, "Just one value can be assigned to package variable '#{method.upcase}'" unless args.size == 1 && block.nil?
+          object.value = args[0]
+        else
+          raise ArgumentError, "Cannot pass arguments when getting package variable '#{method.upcase}' value" unless args.size == 0 && block.nil?
+          object.value
+        end
+      else
+        raise ArgumentError, "No PL/SQL procedure or variable '#{method.upcase}' found"
+      end
+    end
+
+  end
+
+end

data/lib/plsql/procedure.rb

@@ -0,0 +1,269 @@
+module PLSQL
+
+  module ProcedureClassMethods #:nodoc:
+    def find(schema, procedure_name, package_name = nil, override_schema_name = nil)
+      if package_name
+        find_procedure_in_package(schema, package_name, procedure_name, override_schema_name)
+      else
+        find_procedure_in_schema(schema, procedure_name) || find_procedure_by_synonym(schema, procedure_name)
+      end
+    end
+
+    def find_procedure_in_schema(schema, procedure_name)
+      row = schema.select_first(<<-SQL, schema.schema_name, procedure_name.to_s.upcase)
+        SELECT object_id
+        FROM   all_procedures
+        WHERE  owner = :owner
+        AND    object_name = :object_name
+        AND    object_type IN ('PROCEDURE', 'FUNCTION')
+        AND    pipelined = 'NO'
+      SQL
+      new(schema, procedure_name, nil, nil, row[0]) if row
+    end
+
+    def find_procedure_by_synonym(schema, procedure_name)
+      row = schema.select_first(<<-SQL, schema.schema_name, procedure_name.to_s.upcase)
+        SELECT p.owner, p.object_name, p.object_id
+        FROM   all_synonyms s,
+               all_procedures p
+        WHERE  s.owner IN (:owner, 'PUBLIC')
+        AND    s.synonym_name = :synonym_name
+        AND    p.owner        = s.table_owner
+        AND    p.object_name  = s.table_name
+        AND    p.object_type IN ('PROCEDURE','FUNCTION')
+        AND    p.pipelined    = 'NO'
+        ORDER BY DECODE(s.owner, 'PUBLIC', 1, 0)
+      SQL
+      new(schema, row[1], nil, row[0], row[2]) if row
+    end
+
+    def find_procedure_in_package(schema, package_name, procedure_name, override_schema_name = nil)
+      schema_name = override_schema_name || schema.schema_name
+      row = schema.select_first(<<-SQL, schema_name, package_name, procedure_name.to_s.upcase)
+        SELECT o.object_id
+        FROM   all_procedures p,
+               all_objects o
+        WHERE  p.owner       = :owner
+        AND    p.object_name = :object_name
+        AND    p.procedure_name = :procedure_name
+        AND    p.pipelined   = 'NO'
+        AND    o.owner       = p.owner
+        AND    o.object_name = p.object_name
+        AND    o.object_type = 'PACKAGE'
+      SQL
+      new(schema, procedure_name, package_name, override_schema_name, row[0]) if row
+    end
+  end
+
+  module ProcedureCommon #:nodoc:
+    attr_reader :arguments, :argument_list, :out_list, :return
+    attr_reader :schema, :schema_name, :package, :procedure
+
+    # 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'
+        length = case metadata[:char_used]
+        when 'C' then "#{metadata[:char_length]} CHAR"
+        when 'B' then "#{metadata[:data_length]} BYTE"
+        else
+          metadata[:data_length]
+        end
+        "#{metadata[:data_type]}#{length && "(#{length})"}"
+      when 'NVARCHAR2', 'NCHAR'
+        length = metadata[:char_length]
+        "#{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 = {}
+      @return = {}
+      @overloaded = false
+
+      # 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, 2]) >= 0 ? 'subprogram_id' : 'NULL'
+
+      @schema.select_all(
+        "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,
+              char_length, type_owner, type_name, type_subname
+        FROM all_arguments
+        WHERE object_id = :object_id
+        AND owner = :owner
+        AND object_name = :procedure_name
+        ORDER BY overload, sequence",
+        @object_id, @schema_name, @procedure
+      ) do |r|
+
+        subprogram_id, object_name, overload, argument_name, position, data_level,
+            data_type, in_out, data_length, data_precision, data_scale, char_used,
+            char_length, type_owner, type_name, type_subname = r
+
+        @overloaded ||= !overload.nil?
+        # if not overloaded then store arguments at key 0
+        overload ||= 0
+        @arguments[overload] ||= {}
+        @return[overload] ||= nil
+        @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,
+          :data_type => data_type,
+          :in_out => in_out,
+          :data_length => data_length && data_length.to_i,
+          :data_precision => data_precision && data_precision.to_i,
+          :data_scale => data_scale && data_scale.to_i,
+          :char_used => char_used,
+          :char_length => char_length && char_length.to_i,
+          :type_owner => type_owner,
+          :type_name => type_name,
+          :type_subname => type_subname,
+          :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'
+            argument_metadata[:fields] = {}
+          end
+          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
+        else
+          # top level parameter
+          if data_level == 0
+            # 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 'PL/SQL TABLE', 'TABLE', 'VARRAY', 'REF CURSOR'
+              previous_level_argument_metadata[data_level - 1][:element] = argument_metadata
+            end
+          end
+        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]}
+        @out_list[overload] = @argument_list[overload].select {|k| @arguments[overload][k][:in_out] =~ /OUT/}
+      end
+    end
+
+    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', 'REF CURSOR'].freeze
+    def composite_type?(data_type) #:nodoc:
+      PLSQL_COMPOSITE_TYPES.include? data_type
+    end
+
+    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)
+      call.exec(&block)
+    end
+
+  end
+end