ruby-plsql 0.7.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 561e2fcdfa5b528f42ebe473058e1d1c68a47876e3142ebce4c78df2f9583f16
-  data.tar.gz: 76bc35318e85ca4fc0f08bde88ce9dab706a94130138cac61872105b79c66ba1
+  metadata.gz: e240a454b5016fb465baaff47830601ea5f06f9a0f4ed7f2e032e2e8027c8841
+  data.tar.gz: 8209b0f8b037838e7be37578a396b8652855540abd6a0c2cbf226adfaf7a598e
 SHA512:
-  metadata.gz: 8e15cd8d687a56e1a60846a9cd7943e3d6b2969195b5e4876aa3aba1a4fc6a13f10090c028936bf57527ddcf351f5f6b7bec4f44f55592fd40199d1364c74cea
-  data.tar.gz: da24e51d1ac39afcdf49025c721c30a503fb84b77f946be96e58466c06fc56236c51ba0fb132f0dbf8582cbd21f20927eb26cb185bf1bd61ac2d6e69da1e17b8
+  metadata.gz: af3ba3c7a782369e6e4f94afe467194f155fc961dc80e946ebbbaec07f48244169d33f1c0c387d6710752b7590f70c9cc5fb84bc21f8687b8c520d32ed09f557
+  data.tar.gz: 2fe1c1fa55a48cc547a3f34f371aba37147c4d3c8efc2c34d104b42b8e250251f6d233d65c6fedba42855774ccf559d6aed4164f341823b5c6fbbbb605acb047

data/History.txt

@@ -1,3 +1,29 @@
+This file is no longer being updated. For the latest updates and release information, please see: https://github.com/rsim/ruby-plsql/releases
+
+== 0.8.0 2021-08-10
+* Improvements and fixes
+  * Support Rails 6.1 [#193]
+  * Support Rails 6.0 [#178]
+  * Support Oracle Database 18c or higher [#196]
+  * case-insensitive table names and proc params [#185]
+  * Use OCI driver type for RUBY_ENGINE TruffleRuby [#190]
+  * Replace NativeException with Java::JavaSql::SQLException [#192]
+  * Fixnum and Bignum are deprecated in Ruby 2.4 [#191]
+
+* CI
+  * Run CI with GitHub Actions [#198]
+  * CI against Rails 6.1 [#193]
+  * CI against Rails 6.0 [#178]
+  * CI against Ruby 3.0.2, 2.7.4 and 2.6.8 [#197]
+  * Exclude jruby-head with Rails main [#194]
+  * Exclude jruby-head with Rails main [#194]
+  * Bump RuboCop version to 0.81.0 [#186]
+  * Run RuboCop using GitHub Actions [#180, #182]
+  * Remove .codeclimate.yml [#181]
+  * Fallback to bundler 1.7.13 [#171]
+  * Terminate CI against Ruby 2.2.x [#172]
+  * Use Ubuntu Xenial at Travis CI [#176]
+
 == 0.7.1 2018-09-03
 * Fix
   * Address incorrect versions in Gemfile 

data/README.md

@@ -1,4 +1,4 @@
-[![Build Status](https://travis-ci.org/rsim/ruby-plsql.svg?branch=master)](https://travis-ci.org/rsim/ruby-plsql)
+[![Build Status](https://travis-ci.com/rsim/ruby-plsql.svg?branch=master)](https://travis-ci.com/rsim/ruby-plsql)
 
 ruby-plsql
 ==========

data/VERSION

@@ -1 +1 @@
-0.7.1
+0.9.0

data/lib/plsql/connection.rb

@@ -3,13 +3,13 @@ module PLSQL
     attr_reader :raw_driver
     attr_reader :activerecord_class
 
-    def initialize(raw_conn, ar_class = nil) #:nodoc:
+    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:
+    def self.create(raw_conn, ar_class = nil) # :nodoc:
       if ar_class && !(defined?(::ActiveRecord) && ar_class.ancestors.include?(::ActiveRecord::Base))
         raise ArgumentError, "Wrong ActiveRecord class"
       end
@@ -23,7 +23,7 @@ module PLSQL
       end
     end
 
-    def self.create_new(params) #:nodoc:
+    def self.create_new(params) # :nodoc:
       conn = case driver_type
              when :oci
                OCIConnection.create_raw(params)
@@ -36,9 +36,9 @@ module PLSQL
       conn
     end
 
-    def self.driver_type #:nodoc:
-      # MRI 1.8.6 or YARV 1.9.1
-      @driver_type ||= if (!defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby") && defined?(OCI8)
+    def self.driver_type # :nodoc:
+      # MRI 1.8.6 or YARV 1.9.1 or TruffleRuby
+      @driver_type ||= if (!defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby" || RUBY_ENGINE == "truffleruby") && defined?(OCI8)
         :oci
       # JRuby
       elsif (defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby")
@@ -67,18 +67,18 @@ module PLSQL
       @raw_driver == :jdbc
     end
 
-    def logoff #:nodoc:
+    def logoff # :nodoc:
       # 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:
+    def commit # :nodoc:
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
-    def rollback #:nodoc:
+    def rollback # :nodoc:
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
@@ -98,21 +98,21 @@ module PLSQL
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
-    def select_first(sql, *bindvars) #:nodoc:
+    def select_first(sql, *bindvars) # :nodoc:
       cursor = cursor_from_query(sql, bindvars, prefetch_rows: 1)
       cursor.fetch
     ensure
       cursor.close rescue nil
     end
 
-    def select_hash_first(sql, *bindvars) #:nodoc:
+    def select_hash_first(sql, *bindvars) # :nodoc:
       cursor = cursor_from_query(sql, bindvars, prefetch_rows: 1)
       cursor.fetch_hash
     ensure
       cursor.close rescue nil
     end
 
-    def select_all(sql, *bindvars, &block) #:nodoc:
+    def select_all(sql, *bindvars, &block) # :nodoc:
       cursor = cursor_from_query(sql, bindvars)
       results = []
       row_count = 0
@@ -129,7 +129,7 @@ module PLSQL
       cursor.close rescue nil
     end
 
-    def select_hash_all(sql, *bindvars, &block) #:nodoc:
+    def select_hash_all(sql, *bindvars, &block) # :nodoc:
       cursor = cursor_from_query(sql, bindvars)
       results = []
       row_count = 0
@@ -146,11 +146,11 @@ module PLSQL
       cursor.close rescue nil
     end
 
-    def exec(sql, *bindvars) #:nodoc:
+    def exec(sql, *bindvars) # :nodoc:
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
-    def parse(sql) #:nodoc:
+    def parse(sql) # :nodoc:
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
@@ -181,7 +181,7 @@ module PLSQL
 
     # all_synonyms view is quite slow therefore
     # this implementation is overriden in OCI connection with faster native OCI method
-    def describe_synonym(schema_name, synonym_name) #:nodoc:
+    def describe_synonym(schema_name, synonym_name) # :nodoc:
       select_first(
         "SELECT table_owner, table_name FROM all_synonyms WHERE owner = :owner AND synonym_name = :synonym_name",
         schema_name.to_s.upcase, synonym_name.to_s.upcase)

data/lib/plsql/helpers.rb

@@ -1,6 +1,6 @@
-module PLSQL #:nodoc:
-  module ArrayHelpers #:nodoc:
-    def self.to_hash(keys, values) #:nodoc:
+module PLSQL # :nodoc:
+  module ArrayHelpers # :nodoc:
+    def self.to_hash(keys, values) # :nodoc:
       (0...keys.size).inject({}) { |hash, i| hash[keys[i]] = values[i]; hash }
     end
   end

data/lib/plsql/jdbc_connection.rb

@@ -46,7 +46,7 @@ rescue LoadError, NameError
 end
 
 module PLSQL
-  class JDBCConnection < Connection  #:nodoc:
+  class JDBCConnection < Connection  # :nodoc:
     def self.create_raw(params)
       database = params[:database]
       url = if ENV["TNS_ADMIN"] && database && !params[:host] && !params[:url]
@@ -98,7 +98,7 @@ module PLSQL
       cs.close rescue nil
     end
 
-    class CallableStatement #:nodoc:
+    class CallableStatement # :nodoc:
       def initialize(conn, sql)
         @sql = sql
         @connection = conn
@@ -145,7 +145,7 @@ module PLSQL
         end
     end
 
-    class Cursor #:nodoc:
+    class Cursor # :nodoc:
       include Connection::CursorCommon
 
       attr_reader :result_set
@@ -223,8 +223,6 @@ module PLSQL
     end
 
     RUBY_CLASS_TO_SQL_TYPE = {
-      Fixnum => java.sql.Types::INTEGER,
-      Bignum => java.sql.Types::INTEGER,
       Integer => java.sql.Types::INTEGER,
       Float => java.sql.Types::FLOAT,
       BigDecimal => java.sql.Types::NUMERIC,

data/lib/plsql/oci_connection.rb

@@ -24,7 +24,7 @@ if (oci8_version_ints <=> required_oci8_version) < 0
 end
 
 module PLSQL
-  class OCIConnection < Connection #:nodoc:
+  class OCIConnection < Connection # :nodoc:
     def self.create_raw(params)
       connection_string = if params[:host]
         "//#{params[:host]}:#{params[:port] || 1521}/#{params[:database]}"
@@ -64,7 +64,7 @@ module PLSQL
       true
     end
 
-    class Cursor #:nodoc:
+    class Cursor # :nodoc:
       include Connection::CursorCommon
 
       attr_reader :raw_cursor
@@ -157,7 +157,7 @@ module PLSQL
         [DateTime, nil]
       when "TIMESTAMP", "TIMESTAMP WITH TIME ZONE", "TIMESTAMP WITH LOCAL TIME ZONE"
         [Time, nil]
-      when "TABLE", "VARRAY", "OBJECT", "XMLTYPE"
+      when "TABLE", "VARRAY", "OBJECT", "XMLTYPE", "OPAQUE/XMLTYPE"
         # create Ruby class for collection
         klass = OCI8::Object::Base.get_class_by_typename(metadata[:sql_type_name])
         unless klass
@@ -289,7 +289,11 @@ module PLSQL
         # 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)
+          if raw_connection.instance_variable_defined?(:@raw_connection)
+            raw_connection.instance_variable_get(:@raw_connection)
+          else
+            raw_connection.instance_variable_get(:@connection)
+          end
         end
       end
 

data/lib/plsql/package.rb

@@ -1,5 +1,5 @@
 module PLSQL
-  module PackageClassMethods #:nodoc:
+  module PackageClassMethods # :nodoc:
     def find(schema, package)
       package_name = package.to_s.upcase
       find_in_schema(schema, package_name) || find_by_synonym(schema, package_name)
@@ -32,7 +32,7 @@ module PLSQL
     end
   end
 
-  class Package #:nodoc:
+  class Package # :nodoc:
     extend PackageClassMethods
 
     def initialize(schema, package, override_schema_name = nil)
@@ -56,7 +56,7 @@ module PLSQL
     private
 
       def method_missing(method, *args, &block)
-        method = method.to_s
+        method = +method.to_s
         method.chop! if (assignment = method[/=$/])
 
         case (object = self[method])

data/lib/plsql/procedure.rb

@@ -1,5 +1,5 @@
 module PLSQL
-  module ProcedureClassMethods #:nodoc:
+  module ProcedureClassMethods # :nodoc:
     def find(schema, procedure, package = nil, override_schema_name = nil)
       if package.nil?
         if (row = schema.select_first(
@@ -53,12 +53,12 @@ module PLSQL
       end
   end
 
-  module ProcedureCommon #:nodoc:
+  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:
+    def self.type_to_sql(metadata) # :nodoc:
       case metadata[:data_type]
       when "NUMBER"
         precision, scale = metadata[:data_precision], metadata[:data_scale]
@@ -82,7 +82,15 @@ module PLSQL
     end
 
     # get procedure argument metadata from data dictionary
-    def get_argument_metadata #:nodoc:
+    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 = {}
@@ -118,6 +126,9 @@ module PLSQL
             data_type, in_out, data_length, data_precision, data_scale, char_used,
             char_length, type_owner, type_name, type_subname, defaulted = r
 
+        # Oracle 23c reports BOOLEAN as "BOOLEAN" instead of "PL/SQL BOOLEAN"
+        data_type = "PL/SQL BOOLEAN" if data_type == "BOOLEAN"
+
         @overloaded ||= !overload.nil?
         # if not overloaded then store arguments at key 0
         overload ||= 0
@@ -197,7 +208,103 @@ module PLSQL
       construct_argument_list_for_overloads
     end
 
-    def construct_argument_list_for_overloads #:nodoc:
+    # 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
+
+        # Oracle 23c reports BOOLEAN as "BOOLEAN" instead of "PL/SQL BOOLEAN"
+        data_type = "PL/SQL BOOLEAN" if data_type == "BOOLEAN"
+
+        @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] }
@@ -205,10 +312,10 @@ module PLSQL
       end
     end
 
-    def ensure_tmp_tables_created(overload) #:nodoc:
+    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"
+        sql = +"CREATE GLOBAL TEMPORARY TABLE #{table_name} (\n"
         element_metadata = argument_metadata[:element]
         case element_metadata[:data_type]
         when "PL/SQL RECORD"
@@ -229,22 +336,210 @@ module PLSQL
       @tmp_tables_created[overload] = true
     end
 
+    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
+
+          # Oracle 23c reports BOOLEAN as "BOOLEAN" instead of "PL/SQL BOOLEAN"
+          attr_type_name = "PL/SQL BOOLEAN" if attr_type_name == "BOOLEAN"
+
+          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
+
+          # Oracle 23c reports BOOLEAN as "BOOLEAN" instead of "PL/SQL BOOLEAN"
+          elem_type_name = "PL/SQL BOOLEAN" if elem_type_name == "BOOLEAN"
+
+          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
+
+          # Oracle 23c reports BOOLEAN as "BOOLEAN" instead of "PL/SQL BOOLEAN"
+          elem_type_name = "PL/SQL BOOLEAN" if elem_type_name == "BOOLEAN"
+
+          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:
+    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:
+    def collection_type?(data_type) # :nodoc:
       PLSQL_COLLECTION_TYPES.include? data_type
     end
 
-    def overloaded? #:nodoc:
+    def overloaded? # :nodoc:
       @overloaded
     end
   end
 
-  class Procedure #:nodoc:
+  class Procedure # :nodoc:
     extend ProcedureClassMethods
     include ProcedureCommon