ruby-plsql 0.5.3 → 0.8.0

data/lib/plsql/oci_connection.rb

@@ -18,17 +18,16 @@ 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}
+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]}"
+        "//#{params[:host]}:#{params[:port] || 1521}/#{params[:database]}"
       else
         params[:database]
       end
@@ -47,7 +46,7 @@ module PLSQL
     def rollback
       raw_connection.rollback
     end
-    
+
     def autocommit?
       raw_connection.autocommit?
     end
@@ -68,14 +67,17 @@ module PLSQL
     class Cursor #:nodoc:
       include Connection::CursorCommon
 
-      # stack of open cursors
-      @@open_cursors = []
       attr_reader :raw_cursor
 
+      # stack of open cursors per thread
+      def self.open_cursors
+        Thread.current[:plsql_oci_cursor_stack] ||= []
+      end
+
       def initialize(conn, raw_cursor)
         @connection = conn
         @raw_cursor = raw_cursor
-        @@open_cursors.push self
+        self.class.open_cursors.push self
       end
 
       def self.new_from_parse(conn, sql)
@@ -83,7 +85,7 @@ module PLSQL
         self.new(conn, raw_cursor)
       end
 
-      def self.new_from_query(conn, sql, bindvars=[], options={})
+      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
@@ -101,7 +103,7 @@ module PLSQL
         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
@@ -112,11 +114,11 @@ module PLSQL
 
       def fetch
         row = @raw_cursor.fetch
-        row && row.map{|v| @connection.ora_value_to_ruby_value(v)}
+        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}
+        @fields ||= @raw_cursor.get_col_names.map { |c| c.downcase.to_sym }
       end
 
       def close_raw_cursor
@@ -125,38 +127,37 @@ module PLSQL
 
       def close
         # close all cursors that were created after this one
-        while (open_cursor = @@open_cursors.pop) && !open_cursor.equal?(self)
+        while (open_cursor = self.class.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={})
+    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"
+      when "VARCHAR", "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"
+      when "NUMBER", "NATURAL", "NATURALN", "POSITIVE", "POSITIVEN", "SIGNTYPE", "SIMPLE_INTEGER", "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"
+      when "TABLE", "VARRAY", "OBJECT", "XMLTYPE"
         # create Ruby class for collection
         klass = OCI8::Object::Base.get_class_by_typename(metadata[:sql_type_name])
         unless klass
@@ -171,18 +172,16 @@ module PLSQL
       end
     end
 
-    def ruby_value_to_ora_value(value, type=nil)
+    def ruby_value_to_ora_value(value, type = nil)
       type ||= value.class
       case type.to_s.to_sym
-      when :Fixnum, :BigDecimal, :String
+      when :Integer, :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'))
+          OraNumber.new(value.to_s("F"))
         when TrueClass
           OraNumber.new(1)
         when FalseClass
@@ -215,7 +214,7 @@ module PLSQL
             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)
+                attr_type, _ = plsql_to_ruby_data_type(data_type: "OBJECT", sql_type_name: attr_tdo.typename)
               else
                 attr_type = elem.class
               end
@@ -224,7 +223,7 @@ module PLSQL
             # 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.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)
@@ -234,7 +233,7 @@ module PLSQL
               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)
+                attr_type, _ = 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
@@ -263,7 +262,7 @@ module PLSQL
       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)}
+          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])
@@ -277,63 +276,49 @@ module PLSQL
       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) && 
+      @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)
+
+      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
-      else
-        val
       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(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
+end

data/lib/plsql/package.rb

@@ -1,29 +1,34 @@
 module PLSQL
-
   module PackageClassMethods #:nodoc:
     def find(schema, package)
-      if schema.select_first(
-            "SELECT object_name FROM all_objects
-            WHERE owner = :owner
-              AND object_name = :package
-              AND object_type = 'PACKAGE'",
-            schema.schema_name, package.to_s.upcase)
-        new(schema, package)
-      # search for synonym
-      elsif (row = schema.select_first(
-            "SELECT o.owner, o.object_name
-            FROM all_synonyms s, all_objects o
-            WHERE s.owner IN (:owner, 'PUBLIC')
-              AND s.synonym_name = :synonym_name
-              AND o.owner = s.table_owner
-              AND o.object_name = s.table_name
-              AND o.object_type = 'PACKAGE'
-            ORDER BY DECODE(s.owner, 'PUBLIC', 1, 0)",
-            schema.schema_name, package.to_s.upcase))
-        new(schema, row[1], row[0])
-      else
-        nil
-      end
+      package_name = package.to_s.upcase
+      find_in_schema(schema, package_name) || find_by_synonym(schema, package_name)
+    end
+
+    def find_in_schema(schema, package_name)
+      row = schema.select_first(<<-SQL, schema.schema_name, package_name)
+        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_by_synonym(schema, package_name)
+      row = schema.select_first(<<-SQL, schema.schema_name, package_name)
+        SELECT o.object_name, o.owner
+        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[0], row[1]) if row
     end
   end
 
@@ -41,32 +46,42 @@ module PLSQL
       PLSQL::Procedure.find(@schema, name, @package) ? true : false
     end
 
-    private
-    
-    def method_missing(method, *args, &block)
-      if assignment = (method.to_s[-1,1] == '=')
-        method = method.to_s.chop.to_sym
+    def [](object_name)
+      object_name = object_name.to_s.downcase
+      @package_objects[object_name] ||= [Procedure, Variable].inject(nil) do |res, object_type|
+        res || object_type.find(@schema, object_name, @package, @override_schema_name)
       end
-      object = (@package_objects[method] ||=
-        Procedure.find(@schema, method, @package, @override_schema_name) ||
-        Variable.find(@schema, method, @package, @override_schema_name))
-      case object
-      when Procedure
-        raise ArgumentError, "Cannot assign value to package procedure '#{method.to_s.upcase}'" if assignment
-        object.exec(*args, &block)
-      when Variable
-        if assignment
-          raise ArgumentError, "Just one value can be assigned to package variable '#{method.to_s.upcase}'" unless args.size == 1 && block == nil
-          object.value = args[0]
+    end
+
+    private
+
+      def method_missing(method, *args, &block)
+        method = method.to_s
+        method.chop! if (assignment = method[/=$/])
+
+        case (object = self[method])
+        when Procedure
+          if assignment
+            raise ArgumentError, "Cannot assign value to package procedure '#{method.upcase}'"
+          end
+          object.exec(*args, &block)
+        when Variable
+          if assignment
+            unless args.size == 1 && block.nil?
+              raise ArgumentError, "Just one value can be assigned " \
+                                   "to package variable '#{method.upcase}'"
+            end
+            object.value = args[0]
+          else
+            unless args.size == 0 && block.nil?
+              raise ArgumentError, "Cannot pass arguments when getting " \
+                                   "package variable '#{method.upcase}' value"
+            end
+            object.value
+          end
         else
-          raise ArgumentError, "Cannot pass arguments when getting package variable '#{method.to_s.upcase}' value" unless args.size == 0 && block == nil
-          object.value
+          raise ArgumentError, "No PL/SQL procedure or variable '#{method.upcase}' found"
         end
-      else
-        raise ArgumentError, "No PL/SQL procedure or variable '#{method.to_s.upcase}' found"
       end
-    end
-
   end
-
 end

data/lib/plsql/procedure.rb

@@ -1,45 +1,44 @@
 module PLSQL
-
   module ProcedureClassMethods #:nodoc:
     def find(schema, procedure, package = nil, override_schema_name = nil)
       if package.nil?
         if (row = schema.select_first(
-            "SELECT #{procedure_object_id_src(schema)}.object_id
-            FROM all_procedures p, all_objects o
-            WHERE p.owner = :owner
-              AND p.object_name = :object_name
-              AND o.owner = p.owner
-              AND o.object_name = p.object_name
-              AND o.object_type in ('PROCEDURE', 'FUNCTION')",
+          "SELECT #{procedure_object_id_src(schema)}.object_id
+          FROM all_procedures p, all_objects o
+          WHERE p.owner = :owner
+            AND p.object_name = :object_name
+            AND o.owner = p.owner
+            AND o.object_name = p.object_name
+            AND o.object_type in ('PROCEDURE', 'FUNCTION')",
             schema.schema_name, procedure.to_s.upcase))
           new(schema, procedure, nil, nil, row[0])
         # search for synonym
         elsif (row = schema.select_first(
-            "SELECT o.owner, o.object_name, #{procedure_object_id_src(schema)}.object_id
-            FROM all_synonyms s, all_objects o, all_procedures p
-            WHERE s.owner IN (:owner, 'PUBLIC')
-              AND s.synonym_name = :synonym_name
-              AND o.owner = s.table_owner
-              AND o.object_name = s.table_name
-              AND o.object_type IN ('PROCEDURE','FUNCTION')
-              AND o.owner = p.owner
-              AND o.object_name = p.object_name
-              ORDER BY DECODE(s.owner, 'PUBLIC', 1, 0)",
+          "SELECT o.owner, o.object_name, #{procedure_object_id_src(schema)}.object_id
+          FROM all_synonyms s, all_objects o, all_procedures p
+          WHERE s.owner IN (:owner, 'PUBLIC')
+            AND s.synonym_name = :synonym_name
+            AND o.owner = s.table_owner
+            AND o.object_name = s.table_name
+            AND o.object_type IN ('PROCEDURE','FUNCTION')
+            AND o.owner = p.owner
+            AND o.object_name = p.object_name
+            ORDER BY DECODE(s.owner, 'PUBLIC', 1, 0)",
             schema.schema_name, procedure.to_s.upcase))
           new(schema, row[1], nil, row[0], row[2])
         else
           nil
         end
       elsif package && (row = schema.select_first(
-            # older Oracle versions do not have object_id column in all_procedures
-            "SELECT #{procedure_object_id_src(schema)}.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 o.owner = p.owner
-              AND o.object_name = p.object_name
-              AND o.object_type = 'PACKAGE'",
+        # older Oracle versions do not have object_id column in all_procedures
+        "SELECT #{procedure_object_id_src(schema)}.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 o.owner = p.owner
+          AND o.object_name = p.object_name
+          AND o.object_type = 'PACKAGE'",
             override_schema_name || schema.schema_name, package, procedure.to_s.upcase))
         new(schema, procedure, package, override_schema_name, row[0])
       else
@@ -49,9 +48,9 @@ module PLSQL
 
     private
 
-    def procedure_object_id_src(schema)
-      (schema.connection.database_version <=> [11, 1, 0, 0]) >= 0 ? "p" : "o"
-    end
+      def procedure_object_id_src(schema)
+        (schema.connection.database_version <=> [11, 1, 0, 0]) >= 0 ? "p" : "o"
+      end
   end
 
   module ProcedureCommon #:nodoc:
@@ -61,21 +60,21 @@ module PLSQL
     # 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'
+      when "NUMBER"
         precision, scale = metadata[:data_precision], metadata[:data_scale]
-        "NUMBER#{precision ? "(#{precision}#{scale ? ",#{scale}": ""})" : ""}"
-      when 'VARCHAR2', 'CHAR'
+        "NUMBER#{precision ? "(#{precision}#{scale ? ",#{scale}" : ""})" : ""}"
+      when "VARCHAR", "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]
+                 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'
+      when "NVARCHAR2", "NCHAR"
         length = metadata[:char_length]
         "#{metadata[:data_type]}#{length && "(#{length})"}"
-      when 'PL/SQL TABLE', 'TABLE', 'VARRAY', 'OBJECT'
+      when "PL/SQL TABLE", "TABLE", "VARRAY", "OBJECT", "XMLTYPE"
         metadata[:sql_type_name]
       else
         metadata[:data_type]
@@ -84,6 +83,14 @@ module PLSQL
 
     # get procedure argument metadata from data dictionary
     def get_argument_metadata #:nodoc:
+      if (@schema.connection.database_version <=> [18, 0, 0, 0]) >= 0
+        get_argument_metadata_from_18c
+      else
+        get_argument_metadata_below_18c
+      end
+    end
+
+    def get_argument_metadata_below_18c #:nodoc:
       @arguments = {}
       @argument_list = {}
       @out_list = {}
@@ -99,12 +106,14 @@ module PLSQL
       @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'
+      subprogram_id_column = (@schema.connection.database_version <=> [10, 2, 0, 2]) >= 0 ? "subprogram_id" : "NULL"
+      # defaulted is available just from version 11g
+      defaulted_column = (@schema.connection.database_version <=> [11, 0, 0, 0]) >= 0 ? "defaulted" : "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
+              char_length, type_owner, type_name, type_subname, #{defaulted_column}
         FROM all_arguments
         WHERE object_id = :object_id
         AND owner = :owner
@@ -115,7 +124,7 @@ module PLSQL
 
         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
+            char_length, type_owner, type_name, type_subname, defaulted = r
 
         @overloaded ||= !overload.nil?
         # if not overloaded then store arguments at key 0
@@ -136,7 +145,7 @@ module PLSQL
             # 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'
+          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
@@ -144,18 +153,19 @@ module PLSQL
         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
+          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,
+          defaulted: defaulted
         }
         if tmp_table_name
           @tmp_table_names[overload] << [(argument_metadata[:tmp_table_name] = tmp_table_name), argument_metadata]
@@ -163,14 +173,14 @@ module PLSQL
 
         if composite_type?(data_type)
           case data_type
-          when 'PL/SQL RECORD'
+          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'
+        if argument_name.nil? && data_level == 0 && in_out == "OUT"
           @return[overload] = argument_metadata
         # if parameter
         else
@@ -181,9 +191,9 @@ module PLSQL
           # or lower level part of composite type
           else
             case previous_level_argument_metadata[data_level - 1][:data_type]
-            when 'PL/SQL RECORD'
+            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'
+            when "PL/SQL TABLE", "TABLE", "VARRAY", "REF CURSOR"
               previous_level_argument_metadata[data_level - 1][:element] = argument_metadata
             end
           end
@@ -195,11 +205,104 @@ module PLSQL
       construct_argument_list_for_overloads
     end
 
+    # get procedure argument metadata from data dictionary
+    def get_argument_metadata_from_18c #:nodoc:
+      @arguments = {}
+      @argument_list = {}
+      @out_list = {}
+      @return = {}
+      @overloaded = false
+
+      # 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 = {}
+
+      @schema.select_all(
+        "SELECT subprogram_id, object_name, TO_NUMBER(overload), argument_name, position,
+              data_type, in_out, data_length, data_precision, data_scale, char_used,
+              char_length, type_owner, nvl(type_subname, type_name),
+              decode(type_object_type, 'PACKAGE', type_name, null), type_object_type, defaulted
+        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_type, in_out, data_length, data_precision, data_scale, char_used,
+          char_length, type_owner, type_name, type_package, type_object_type, defaulted = 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 = build_sql_type_name(type_owner, type_package, type_name)
+
+        tmp_table_name = nil
+        # type defined inside package
+        if type_package
+          if collection_type?(data_type)
+            tmp_table_name = "#{Connection::RUBY_TEMP_TABLE_PREFIX}#{@schema.connection.session_id}_#{@object_id}_#{subprogram_id}_#{position}"
+          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,
+          # TODO: should be renamed to type_package, when support for legacy database versions is dropped
+          # due to the explicit change declaration of types in oracle plsql_type-catalogs (type_package + type_name),
+          # the assignment of type + subtype was switched here for 18c and beyond
+          type_subname: type_package,
+          sql_type_name: sql_type_name,
+          defaulted: defaulted,
+          type_object_type: type_object_type
+        }
+        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", "REF CURSOR"
+            argument_metadata[:fields] = get_field_definitions(argument_metadata)
+          when "PL/SQL TABLE", "TABLE", "VARRAY"
+            argument_metadata[:element] = get_element_definition(argument_metadata)
+          end
+        end
+
+        # if function has return value
+        if argument_name.nil? && in_out == "OUT"
+          @return[overload] = argument_metadata
+        else
+          # 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
+        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/}
+        @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
 
@@ -207,19 +310,19 @@ module PLSQL
       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"
+        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
@@ -227,12 +330,191 @@ module PLSQL
       @tmp_tables_created[overload] = true
     end
 
-    PLSQL_COMPOSITE_TYPES = ['PL/SQL RECORD', 'PL/SQL TABLE', 'TABLE', 'VARRAY', 'REF CURSOR'].freeze
+    def build_sql_type_name(type_owner, type_package, type_name) #:nodoc:
+      if type_owner == nil || type_owner == "PUBLIC"
+        type_owner_res = ""
+      else
+        type_owner_res = "#{type_owner}."
+      end
+
+      if type_package == nil
+        type_name_res = type_name
+      else
+        type_name_res = "#{type_package}.#{type_name}"
+      end
+      type_name_res && "#{type_owner_res}#{type_name_res}"
+    end
+
+    def get_field_definitions(argument_metadata) #:nodoc:
+      fields = {}
+      case argument_metadata[:type_object_type]
+      when "PACKAGE"
+        @schema.select_all(
+          "SELECT attr_no, attr_name, attr_type_owner, attr_type_name, attr_type_package, length, precision, scale, char_used
+          FROM ALL_PLSQL_TYPES t, ALL_PLSQL_TYPE_ATTRS ta
+          WHERE t.OWNER = :owner AND t.type_name = :type_name AND t.package_name = :package_name
+          AND ta.OWNER = t.owner AND ta.TYPE_NAME = t.TYPE_NAME AND ta.PACKAGE_NAME = t.PACKAGE_NAME
+          ORDER BY attr_no",
+          @schema_name, argument_metadata[:type_name], argument_metadata[:type_subname]) do |r|
+
+          attr_no, attr_name, attr_type_owner, attr_type_name, attr_type_package, attr_length, attr_precision, attr_scale, attr_char_used = r
+
+          fields[attr_name.downcase.to_sym] = {
+            position: attr_no.to_i,
+            data_type: attr_type_owner == nil ? attr_type_name : get_composite_type(attr_type_owner, attr_type_name, attr_type_package),
+            in_out: argument_metadata[:in_out],
+            data_length: attr_length && attr_length.to_i,
+            data_precision: attr_precision && attr_precision.to_i,
+            data_scale: attr_scale && attr_scale.to_i,
+            char_used: attr_char_used == nil ? "0" : attr_char_used,
+            char_length: attr_char_used && attr_length && attr_length.to_i,
+            type_owner: attr_type_owner,
+            type_name: attr_type_owner && attr_type_name,
+            type_subname: attr_type_package,
+            sql_type_name: attr_type_owner && build_sql_type_name(attr_type_owner, attr_type_package, attr_type_name),
+            defaulted: argument_metadata[:defaulted]
+          }
+
+          if fields[attr_name.downcase.to_sym][:data_type] == "TABLE" && fields[attr_name.downcase.to_sym][:type_subname] != nil
+            fields[attr_name.downcase.to_sym][:fields] = get_field_definitions(fields[attr_name.downcase.to_sym])
+          end
+        end
+      when "TABLE", "VIEW"
+        @schema.select_all(
+          "SELECT column_id, column_name, data_type, data_length, data_precision, data_scale, char_length, char_used
+           FROM ALL_TAB_COLS WHERE OWNER = :owner AND TABLE_NAME = :type_name
+           ORDER BY column_id",
+          @schema_name, argument_metadata[:type_name]) do |r|
+
+          col_no, col_name, col_type_name, col_length, col_precision, col_scale, col_char_length, col_char_used = r
+
+          fields[col_name.downcase.to_sym] = {
+            position: col_no.to_i,
+            data_type: col_type_name,
+            in_out: argument_metadata[:in_out],
+            data_length: col_length && col_length.to_i,
+            data_precision: col_precision && col_precision.to_i,
+            data_scale: col_scale && col_scale.to_i,
+            char_used: col_char_used == nil ? "0" : col_char_used,
+            char_length: col_char_length && col_char_length.to_i,
+            type_owner: nil,
+            type_name: nil,
+            type_subname: nil,
+            sql_type_name: nil,
+            defaulted: argument_metadata[:defaulted]
+          }
+        end
+      end
+      fields
+    end
+
+    def get_element_definition(argument_metadata) #:nodoc:
+      element_metadata = {}
+      if collection_type?(argument_metadata[:data_type])
+        case argument_metadata[:type_object_type]
+        when "PACKAGE"
+          r = @schema.select_first(
+            "SELECT elem_type_owner, elem_type_name, elem_type_package, length, precision, scale, char_used, index_by
+             FROM ALL_PLSQL_COLL_TYPES t
+             WHERE t.OWNER = :owner AND t.TYPE_NAME = :type_name AND t.PACKAGE_NAME = :package_name",
+            @schema_name, argument_metadata[:type_name], argument_metadata[:type_subname])
+
+          elem_type_owner, elem_type_name, elem_type_package, elem_length, elem_precision, elem_scale, elem_char_used, index_by = r
+
+          if index_by == "VARCHAR2"
+            raise ArgumentError, "Index-by Varchar-Table (associative array) #{argument_metadata[:type_name]} is not supported"
+          end
+
+          element_metadata = {
+            position: 1,
+            data_type: if elem_type_owner == nil
+                         elem_type_name
+                       else
+                         elem_type_package != nil ? "PL/SQL RECORD" : "OBJECT"
+                       end,
+            in_out: argument_metadata[:in_out],
+            data_length: elem_length && elem_length.to_i,
+            data_precision: elem_precision && elem_precision.to_i,
+            data_scale: elem_scale && elem_scale.to_i,
+            char_used: elem_char_used,
+            char_length: elem_char_used && elem_length && elem_length.to_i,
+            type_owner: elem_type_owner,
+            type_name: elem_type_name,
+            type_subname: elem_type_package,
+            sql_type_name: elem_type_owner && build_sql_type_name(elem_type_owner, elem_type_package, elem_type_name),
+            type_object_type: elem_type_package != nil ? "PACKAGE" : nil,
+            defaulted: argument_metadata[:defaulted]
+          }
+
+          if elem_type_package != nil
+            element_metadata[:fields] = get_field_definitions(element_metadata)
+          end
+        when "TYPE"
+          r = @schema.select_first(
+            "SELECT elem_type_owner, elem_type_name, length, precision, scale, char_used
+             FROM ALL_COLL_TYPES t
+             WHERE t.owner = :owner AND t.TYPE_NAME = :type_name",
+            @schema_name, argument_metadata[:type_name]
+          )
+          elem_type_owner, elem_type_name, elem_length, elem_precision, elem_scale, elem_char_used = r
+
+          element_metadata = {
+            position: 1,
+            data_type: elem_type_owner == nil ? elem_type_name : "OBJECT",
+            in_out: argument_metadata[:in_out],
+            data_length: elem_length && elem_length.to_i,
+            data_precision: elem_precision && elem_precision.to_i,
+            data_scale: elem_scale && elem_scale.to_i,
+            char_used: elem_char_used,
+            char_length: elem_char_used && elem_length && elem_length.to_i,
+            type_owner: elem_type_owner,
+            type_name: elem_type_name,
+            type_subname: nil,
+            sql_type_name: elem_type_owner && build_sql_type_name(elem_type_owner, nil, elem_type_name),
+            defaulted: argument_metadata[:defaulted]
+          }
+        end
+      else
+        element_metadata = {
+          position: 1,
+          data_type: "PL/SQL RECORD",
+          in_out: argument_metadata[:in_out],
+          data_length: nil,
+          data_precision: nil,
+          data_scale: nil,
+          char_used: "B",
+          char_length: 0,
+          type_owner: argument_metadata[:type_owner],
+          type_name: argument_metadata[:type_name],
+          type_subname: argument_metadata[:type_subname],
+          sql_type_name: build_sql_type_name(argument_metadata[:type_owner], argument_metadata[:type_subname], argument_metadata[:type_name]),
+          defaulted: argument_metadata[:defaulted]
+        }
+
+        if element_metadata[:type_subname] != nil
+          element_metadata[:fields] = get_field_definitions(element_metadata)
+        end
+      end
+      element_metadata
+    end
+
+    def get_composite_type(type_owner, type_name, type_package)
+      r = @schema.select_first("SELECT typecode FROM all_plsql_types WHERE owner = :owner AND type_name = :type_name AND package_name = :type_package
+                                UNION ALL
+                                SELECT typecode FROM all_types WHERE owner = :owner AND type_name = :type_name",
+                                type_owner, type_name, type_package, type_owner, type_name)
+      typecode = r[0]
+      raise ArgumentError, "#{type_name} type #{build_sql_type_name(type_owner, type_package, type_name)} definition inside package is not supported as part of other type definition," <<
+        " use CREATE TYPE outside package" if typecode == "COLLECTION"
+      typecode
+    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
+    PLSQL_COLLECTION_TYPES = ["PL/SQL TABLE", "TABLE", "VARRAY"].freeze
     def collection_type?(data_type) #:nodoc:
       PLSQL_COLLECTION_TYPES.include? data_type
     end
@@ -263,7 +545,5 @@ module PLSQL
       call = ProcedureCall.new(self, args)
       call.exec(&block)
     end
-
   end
-
 end