ruby-plsql 0.8.0 → 0.9.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 786698aedb4dff545a44a91fda4b7529d392b6d3afaee1e5a4447ee3be81a9d6
-  data.tar.gz: fa71bb0ec3ad558ab6805b077069401225fb1d8e949f4dc00360ecd085bae81b
+  metadata.gz: 8ce42b7f40a83d55130a51e1acae222dbb1361a7d4a43b712873e2cddae24571
+  data.tar.gz: 7cd295463301ff322ed0312cabd73f08337068a8b3b3c57e724a5dae8efb51a0
 SHA512:
-  metadata.gz: f814a2f6b9b2b0784e41f861f0ed0965cb814aaf4e8687293f8285e4758810fd4979e1ef96d7f7b0a305e701f0426fb81d3be0ece725abdf1888270a91131691
-  data.tar.gz: c17b7330167301d53715b4d43441acb67697a53a0b0378ea51f65824b96215ece3730db3af01be4e7442a2c3c632dc9fc14109425cfda73cfa535997d77444ba
+  metadata.gz: '08dabe0856244a3b1e487df17664d996a204f026ce6c19c50dec721bcc42be7936ce41b90ddecfc7d2b798351e624df068602d8da4c1e091e1096f534d8b96c6'
+  data.tar.gz: 5b25be049a7575a74911028db9b82986a692af4aa895d1561e1de3600bcfd418429c969bb45832536782ef84c70cf60bb8549207470d0cac962203666f7c035d

data/History.txt

@@ -1,3 +1,5 @@
+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]

data/README.md

@@ -1,4 +1,4 @@
-[![Build Status](https://travis-ci.com/rsim/ruby-plsql.svg?branch=master)](https://travis-ci.com/rsim/ruby-plsql)
+[![Test](https://github.com/rsim/ruby-plsql/actions/workflows/test.yml/badge.svg)](https://github.com/rsim/ruby-plsql/actions/workflows/test.yml)
 
 ruby-plsql
 ==========
@@ -120,6 +120,22 @@ plsql.activerecord_class = ActiveRecord::Base
 and then you do not need to specify plsql.connection (this is also safer when ActiveRecord reestablishes connection to database).
 
 
+### JRuby JDBC connection:
+
+When using JRuby, the `connect!` method with `:host` and `:database` options uses the thin-style service name syntax by default:
+
+```ruby
+# Connects using service name syntax: jdbc:oracle:thin:@//localhost:1521/MYSERVICENAME
+plsql.connect! username: "hr", password: "hr", host: "localhost", database: "MYSERVICENAME"
+```
+
+If you need to connect using the legacy SID syntax (for Oracle databases older than 12c), prefix the database name with a colon:
+
+```ruby
+# Connects using SID syntax: jdbc:oracle:thin:@localhost:1521:MYSID
+plsql.connect! username: "hr", password: "hr", host: "localhost", database: ":MYSID"
+```
+
 ### Cheat Sheet:
 
 You may have a look at this [Cheat Sheet](http://cheatography.com/jgebal/cheat-sheets/ruby-plsql-cheat-sheet/) for instructions on how to use ruby-plsql
@@ -135,10 +151,10 @@ or include gem in Gemfile if using bundler.
 
 In addition install either ruby-oci8 (for MRI/YARV) or copy Oracle JDBC driver to $JRUBY_HOME/lib (for JRuby).
 
-If you are using MRI Ruby implementation then you need to install ruby-oci8 gem (version 2.0.x or 2.1.x)
+If you are using MRI Ruby implementation then you need to install ruby-oci8 gem (version 2.1 or higher)
 as well as Oracle client, e.g. [Oracle Instant Client](http://www.oracle.com/technetwork/database/features/instant-client/index-097480.html).
 
-If you are using JRuby then you need to download latest [Oracle JDBC driver](http://www.oracle.com/technetwork/database/enterprise-edition/jdbc-112010-090769.html) - either ojdbc7.jar for Java 8 and 7, ojdbc6.jar for Java 6, 7, 8 or ojdbc5.jar for Java 5. You can refer [the support matrix](http://www.oracle.com/technetwork/database/enterprise-edition/jdbc-faq-090281.html#01_03) for details.
+If you are using JRuby then you need to download the appropriate [Oracle JDBC driver](https://www.oracle.com/database/technologies/appdev/jdbc-downloads.html) for your Java version - ojdbc17.jar for Java 17+, ojdbc11.jar for Java 11+, ojdbc8.jar for Java 8+, ojdbc7.jar for Java 7, ojdbc6.jar for Java 6, or ojdbc5.jar for Java 5.
 
 And copy this file to one of these locations. JDBC driver will be searched in this order:
 

data/VERSION

@@ -1 +1 @@
-0.8.0
+0.9.9

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,7 +36,7 @@ module PLSQL
       conn
     end
 
-    def self.driver_type #:nodoc:
+    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
@@ -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

@@ -1,23 +1,26 @@
+ojdbc_jars = []
+
 begin
   require "java"
   require "jruby"
 
-  # ojdbc6.jar or ojdbc5.jar file should be in JRUBY_HOME/lib or should be in ENV['PATH'] or load path
+  # Oracle JDBC driver jar should be in JRUBY_HOME/lib or should be in ENV['PATH'] or load path
 
   java_version = java.lang.System.getProperty("java.version")
-  ojdbc_jars = if java_version =~ /^1.5/
-    %w(ojdbc5.jar)
-  elsif java_version =~ /^1.6/
-    %w(ojdbc6.jar)
-  elsif java_version >= "1.7"
-    # Oracle 11g client ojdbc6.jar is also compatible with Java 1.7
-    # Oracle 12c client provides new ojdbc7.jar
-    %w(ojdbc7.jar ojdbc6.jar)
+  java_major = if java_version =~ /^1\.(\d+)/
+    $1.to_i
   else
-    []
+    java_version.to_i
   end
 
-  if ENV_JAVA["java.class.path"] !~ Regexp.new(ojdbc_jars.join("|"))
+  ojdbc_jars << "ojdbc17.jar" if java_major >= 17
+  ojdbc_jars << "ojdbc11.jar" if java_major >= 11
+  ojdbc_jars << "ojdbc8.jar"  if java_major >= 8
+  ojdbc_jars << "ojdbc7.jar"  if java_major >= 7
+  ojdbc_jars << "ojdbc6.jar"  if java_major >= 6
+  ojdbc_jars << "ojdbc5.jar"  if java_major == 5
+
+  if ENV_JAVA["java.class.path"] !~ Regexp.union(ojdbc_jars)
     # On Unix environment variable should be PATH, on Windows it is sometimes Path
     env_path = (ENV["PATH"] || ENV["Path"] || "").split(File::PATH_SEPARATOR)
     # Look for JDBC driver at first in lib subdirectory (application specific JDBC file version)
@@ -25,7 +28,7 @@ begin
     ["./lib"].concat($LOAD_PATH).concat(env_path).detect do |dir|
       # check any compatible JDBC driver in the priority order
       ojdbc_jars.any? do |ojdbc_jar|
-        if File.exists?(file_path = File.join(dir, ojdbc_jar))
+        if File.exist?(file_path = File.join(dir, ojdbc_jar))
           require file_path
           true
         end
@@ -33,29 +36,66 @@ begin
     end
   end
 
-  java.sql.DriverManager.registerDriver Java::oracle.jdbc.OracleDriver.new
-
   # set tns_admin property from TNS_ADMIN environment variable
   if !java.lang.System.get_property("oracle.net.tns_admin") && ENV["TNS_ADMIN"]
     java.lang.System.set_property("oracle.net.tns_admin", ENV["TNS_ADMIN"])
   end
 
-rescue LoadError, NameError
+rescue LoadError
   # JDBC driver is unavailable.
   raise LoadError, "ERROR: ruby-plsql could not load Oracle JDBC driver. Please install #{ojdbc_jars.empty? ? "Oracle JDBC" : ojdbc_jars.join(' or ') } library."
 end
 
 module PLSQL
-  class JDBCConnection < Connection  #:nodoc:
+  class JDBCConnection < Connection  # :nodoc:
+    begin
+      ORACLE_DRIVER = Java::oracle.jdbc.OracleDriver.new
+      java.sql.DriverManager.registerDriver ORACLE_DRIVER
+    rescue NameError
+      raise LoadError, "ERROR: ruby-plsql could not load Oracle JDBC driver. " \
+        "Please install the appropriate Oracle JDBC driver. " \
+        "See https://www.oracle.com/database/technologies/appdev/jdbc-downloads.html"
+    end
+
     def self.create_raw(params)
+      url = jdbc_connection_url(params)
+      conn = begin
+        java.sql.DriverManager.getConnection(url, params[:username], params[:password])
+      rescue Java::JavaSql::SQLException => e
+        raise unless e.message =~ /no suitable driver/i
+        # bypass DriverManager to work in cases where ojdbc*.jar
+        # is added to the load path at runtime and not on the
+        # system classpath
+        ORACLE_DRIVER.connect(url, java.util.Properties.new.tap do |props|
+          props.setProperty("user", params[:username])
+          props.setProperty("password", params[:password])
+        end)
+      end
+      conn.setAutoCommit(false)
+      new(conn)
+    end
+
+    def self.jdbc_connection_url(params)
       database = params[:database]
-      url = if ENV["TNS_ADMIN"] && database && !params[:host] && !params[:url]
+      if ENV["TNS_ADMIN"] && database && database !~ %r{\A[:/]} && !params[:host] && !params[:url]
         "jdbc:oracle:thin:@#{database}"
       else
-        database = ":#{database}" unless database.match(/^(\:|\/)/)
-        params[:url] || "jdbc:oracle:thin:@#{params[:host] || 'localhost'}:#{params[:port] || 1521}#{database}"
+        return params[:url] if params[:url]
+
+        raise ArgumentError, "database or url option is required" if database.nil? || database.empty?
+
+        host = params[:host] || "localhost"
+        port = params[:port] || 1521
+
+        if database =~ /^:/
+          # SID syntax: jdbc:oracle:thin:@host:port:SID
+          "jdbc:oracle:thin:@#{host}:#{port}#{database}"
+        else
+          # service name syntax: jdbc:oracle:thin:@//host:port/service_name
+          database = "/#{database}" unless database =~ /^\//
+          "jdbc:oracle:thin:@//#{host}:#{port}#{database}"
+        end
       end
-      new(java.sql.DriverManager.getConnection(url, params[:username], params[:password]))
     end
 
     def set_time_zone(time_zone = nil)
@@ -98,7 +138,7 @@ module PLSQL
       cs.close rescue nil
     end
 
-    class CallableStatement #:nodoc:
+    class CallableStatement # :nodoc:
       def initialize(conn, sql)
         @sql = sql
         @connection = conn
@@ -145,7 +185,7 @@ module PLSQL
         end
     end
 
-    class Cursor #:nodoc:
+    class Cursor # :nodoc:
       include Connection::CursorCommon
 
       attr_reader :result_set

data/lib/plsql/oci_connection.rb

@@ -14,17 +14,13 @@ rescue LoadError
   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."
+if Gem::Version.new(OCI8::VERSION) < Gem::Version.new("2.1.0")
+  raise LoadError, "ERROR: ruby-oci8 version #{OCI8::VERSION} is too old. Please install ruby-oci8 version 2.1.0 or later."
 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 +60,7 @@ module PLSQL
       true
     end
 
-    class Cursor #:nodoc:
+    class Cursor # :nodoc:
       include Connection::CursorCommon
 
       attr_reader :raw_cursor
@@ -157,7 +153,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 +285,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,7 @@ 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
@@ -90,7 +90,7 @@ module PLSQL
       end
     end
 
-    def get_argument_metadata_below_18c #:nodoc:
+    def get_argument_metadata_below_18c # :nodoc:
       @arguments = {}
       @argument_list = {}
       @out_list = {}
@@ -126,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
@@ -206,7 +209,7 @@ module PLSQL
     end
 
     # get procedure argument metadata from data dictionary
-    def get_argument_metadata_from_18c #:nodoc:
+    def get_argument_metadata_from_18c # :nodoc:
       @arguments = {}
       @argument_list = {}
       @out_list = {}
@@ -231,10 +234,13 @@ module PLSQL
         @object_id, @schema_name, @procedure
       ) do |r|
 
-        subprogram_id, object_name, overload, argument_name, position,
+        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
@@ -298,7 +304,7 @@ module PLSQL
       construct_argument_list_for_overloads
     end
 
-    def construct_argument_list_for_overloads #:nodoc:
+    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] }
@@ -306,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"
@@ -330,7 +336,7 @@ module PLSQL
       @tmp_tables_created[overload] = true
     end
 
-    def build_sql_type_name(type_owner, type_package, type_name) #:nodoc:
+    def build_sql_type_name(type_owner, type_package, type_name) # :nodoc:
       if type_owner == nil || type_owner == "PUBLIC"
         type_owner_res = ""
       else
@@ -345,7 +351,7 @@ module PLSQL
       type_name_res && "#{type_owner_res}#{type_name_res}"
     end
 
-    def get_field_definitions(argument_metadata) #:nodoc:
+    def get_field_definitions(argument_metadata) # :nodoc:
       fields = {}
       case argument_metadata[:type_object_type]
       when "PACKAGE"
@@ -355,10 +361,13 @@ module PLSQL
           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|
+          argument_metadata[:type_owner], 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),
@@ -382,12 +391,15 @@ module PLSQL
       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
+           FROM ALL_TAB_COLUMNS WHERE OWNER = :owner AND TABLE_NAME = :type_name
            ORDER BY column_id",
-          @schema_name, argument_metadata[:type_name]) do |r|
+          argument_metadata[:type_owner], 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
 
+          # remove precision (n) from data_type (returned for TIMESTAMPs and INTERVALs)
+          col_type_name = col_type_name.sub(/\(\d+\)/, "")
+
           fields[col_name.downcase.to_sym] = {
             position: col_no.to_i,
             data_type: col_type_name,
@@ -408,7 +420,7 @@ module PLSQL
       fields
     end
 
-    def get_element_definition(argument_metadata) #:nodoc:
+    def get_element_definition(argument_metadata) # :nodoc:
       element_metadata = {}
       if collection_type?(argument_metadata[:data_type])
         case argument_metadata[:type_object_type]
@@ -417,10 +429,13 @@ module PLSQL
             "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])
+            argument_metadata[:type_owner], 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
@@ -448,16 +463,36 @@ module PLSQL
 
           if elem_type_package != nil
             element_metadata[:fields] = get_field_definitions(element_metadata)
+          elsif elem_type_name && elem_type_name =~ /\A(.+)%ROWTYPE\z/
+            # TABLE OF table%ROWTYPE: Oracle stores elem_type_name as "TABLE_NAME%ROWTYPE"
+            rowtype_table_name = $1
+            check_owner = elem_type_owner || @schema_name
+            object_type_row = @schema.select_first(
+              "SELECT object_type FROM ALL_OBJECTS WHERE owner = :owner AND object_name = :name AND object_type IN ('TABLE', 'VIEW')",
+              check_owner, rowtype_table_name)
+            if object_type_row
+              element_metadata[:type_owner] ||= check_owner
+              element_metadata[:type_name] = rowtype_table_name
+              element_metadata[:sql_type_name] = build_sql_type_name(check_owner, nil, rowtype_table_name)
+              element_metadata[:data_type] = "PL/SQL RECORD"
+              element_metadata[:type_object_type] = object_type_row[0]
+              element_metadata[:fields] = get_field_definitions(element_metadata)
+            else
+              raise ArgumentError, "Could not resolve #{check_owner}.#{rowtype_table_name} to a table or view for #{elem_type_name}"
+            end
           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]
+            argument_metadata[:type_owner], 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",
@@ -510,21 +545,21 @@ module PLSQL
     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