ruby-plsql 0.5.3 → 0.8.0

data/spec/plsql/package_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe "Package" do
   before(:all) do
@@ -20,17 +20,16 @@ describe "Package" do
         END test_procedure;
       END;
     SQL
-
   end
-  
+
   after(:all) do
     plsql.execute "DROP PACKAGE test_package"
     plsql.logoff
   end
-  
+
   before(:each) do
   end
-  
+
   it "should find existing package" do
     expect(PLSQL::Package.find(plsql, :test_package)).not_to be_nil
   end
@@ -44,7 +43,7 @@ describe "Package" do
   end
 
   it "should execute package function and return correct value" do
-    expect(plsql.test_package.test_procedure('xxx')).to eq('XXX')
+    expect(plsql.test_package.test_procedure("xxx")).to eq("XXX")
   end
 
   it "should report an existing procedure as existing" do
@@ -55,6 +54,56 @@ describe "Package" do
     expect(plsql.test_package.procedure_defined?(:inexistent_procedure)).to be_falsey
   end
 
+  it "should search objects via []" do
+    package = PLSQL::Package.find(plsql, :test_package)
+
+    [:Test_Procedure, :test_procedure, "test_procedure", "TEST_PROCEDURE"].each do |name_variant|
+      expect(package[name_variant]).to be_a PLSQL::Procedure
+    end
+
+    [:Test_Variable, :test_variable, "test_variable", "TEST_VARIABLE"].each do |name_variant|
+      expect(package[name_variant]).to be_a PLSQL::Variable
+    end
+  end
+
+  context "with a user with execute privilege who is not the package owner" do
+    before(:all) do
+      plsql.execute("grant execute on TEST_PACKAGE to #{DATABASE_USERS_AND_PASSWORDS[1][0]}")
+      @original_connection = plsql.connection
+      @conn = get_connection(1)
+    end
+
+    before(:each) do
+      # resetting connection clears cached package objects and schema name
+      plsql.connection = @conn
+    end
+
+    after(:all) do
+      plsql.logoff
+      plsql.connection = @original_connection
+    end
+
+    it "should not find existing package" do
+      expect(PLSQL::Package.find(plsql, :test_package)).to be_nil
+    end
+
+    context "who sets current_schema to match the package owner" do
+      before(:all) do
+        plsql.execute "ALTER SESSION set current_schema=#{DATABASE_USERS_AND_PASSWORDS[0][0]}"
+      end
+
+      it "should find existing package" do
+        expect(PLSQL::Package.find(plsql, :test_package)).not_to be_nil
+      end
+
+      it "should report an existing procedure as existing" do
+        expect(plsql.test_package.procedure_defined?(:test_procedure)).to be_truthy
+      end
+
+    end
+
+  end
+
   describe "variables" do
     it "should set and get package variable value" do
       plsql.test_package.test_variable = 1
@@ -65,7 +114,7 @@ describe "Package" do
 end
 
 describe "Synonym to package" do
-  
+
   before(:all) do
     plsql.connection = get_connection
     plsql.execute <<-SQL
@@ -86,38 +135,38 @@ describe "Synonym to package" do
     SQL
     plsql.execute "CREATE SYNONYM test_pkg_synonym FOR hr.test_package"
   end
-  
+
   after(:all) do
     plsql.execute "DROP SYNONYM test_pkg_synonym" rescue nil
     plsql.logoff
   end
-  
+
   it "should find synonym to package" do
     expect(PLSQL::Package.find(plsql, :test_pkg_synonym)).not_to be_nil
   end
 
   it "should execute package function using synonym and return correct value" do
-    expect(plsql.test_pkg_synonym.test_procedure('xxx')).to eq('XXX')
+    expect(plsql.test_pkg_synonym.test_procedure("xxx")).to eq("XXX")
   end
 
 end
 
 describe "Public synonym to package" do
-  
+
   before(:all) do
     plsql.connection = get_connection
   end
-  
+
   after(:all) do
     plsql.logoff
   end
-  
+
   it "should find public synonym to package" do
     expect(PLSQL::Package.find(plsql, :utl_encode)).not_to be_nil
   end
 
   it "should execute package function using public synonym and return correct value" do
-    expect(plsql.utl_encode.base64_encode('abc')).to eq('4372773D')
+    expect(plsql.utl_encode.base64_encode("abc")).to eq("4372773D")
   end
 
 end

data/spec/plsql/procedure_spec.rb

@@ -1,27 +1,28 @@
 # encoding: utf-8
 
-require 'spec_helper'
+require "spec_helper"
 
 describe "Parameter type mapping /" do
-  describe "Function with string parameters" do
+
+  shared_examples "Function with string parameters" do |datatype|
     before(:all) do
       plsql.connect! CONNECTION_PARAMS
       plsql.execute <<-SQL
         CREATE OR REPLACE FUNCTION test_uppercase
-          ( p_string VARCHAR2 )
-          RETURN VARCHAR2
+          ( p_string #{datatype} )
+          RETURN #{datatype}
         IS
         BEGIN
           RETURN UPPER(p_string);
         END test_uppercase;
       SQL
     end
-  
+
     after(:all) do
       plsql.execute "DROP FUNCTION test_uppercase"
       plsql.logoff
     end
-  
+
     it "should find existing procedure" do
       expect(PLSQL::Procedure.find(plsql, :test_uppercase)).not_to be_nil
     end
@@ -31,23 +32,23 @@ describe "Parameter type mapping /" do
     end
 
     it "should execute function and return correct value" do
-      expect(plsql.test_uppercase('xxx')).to eq('XXX')
+      expect(plsql.test_uppercase("xxx")).to eq("XXX")
     end
 
     it "should execute function with named parameters and return correct value" do
-      expect(plsql.test_uppercase(:p_string => 'xxx')).to eq('XXX')
+      expect(plsql.test_uppercase(p_string: "xxx")).to eq("XXX")
     end
 
     it "should raise error if wrong number of arguments is passed" do
-      expect { plsql.test_uppercase('xxx','yyy') }.to raise_error(ArgumentError)
+      expect { plsql.test_uppercase("xxx", "yyy") }.to raise_error(ArgumentError)
     end
 
     it "should raise error if wrong named argument is passed" do
-      expect { plsql.test_uppercase(:p_string2 => 'xxx') }.to raise_error(ArgumentError)
+      expect { plsql.test_uppercase(p_string2: "xxx") }.to raise_error(ArgumentError)
     end
-  
+
     it "should execute function with schema name specified" do
-      expect(plsql.hr.test_uppercase('xxx')).to eq('XXX')
+      expect(plsql.hr.test_uppercase("xxx")).to eq("XXX")
     end
 
     it "should process nil parameter as NULL" do
@@ -56,88 +57,90 @@ describe "Parameter type mapping /" do
 
   end
 
-  describe "Function with numeric parameters" do
+  ["VARCHAR", "VARCHAR2"].each do |datatype|
+    describe "Function with #{datatype} parameters" do
+      it_should_behave_like "Function with string parameters", datatype
+    end
+  end
+
+  shared_examples "Function with numeric" do |ora_data_type, class_, num1, num2, expected, mandatory|
     before(:all) do
       plsql.connect! CONNECTION_PARAMS
       plsql.execute <<-SQL
         CREATE OR REPLACE FUNCTION test_sum
-          ( p_num1 NUMBER, p_num2 NUMBER )
-          RETURN NUMBER
+          ( p_num1 #{ora_data_type}, p_num2 #{ora_data_type} )
+          RETURN #{ora_data_type}
         IS
         BEGIN
           RETURN p_num1 + p_num2;
         END test_sum;
       SQL
-      plsql.execute <<-SQL
-        CREATE OR REPLACE FUNCTION test_number_1
-          ( p_num NUMBER )
-          RETURN VARCHAR2
-        IS
-        BEGIN
-          IF p_num = 1 THEN
-            RETURN 'Y';
-          ELSIF p_num = 0 THEN
-            RETURN 'N';
-          ELSIF p_num IS NULL THEN
-            RETURN NULL;
-          ELSE
-            RETURN 'UNKNOWN';
-          END IF;
-        END test_number_1;
-      SQL
-      plsql.execute <<-SQL
-        CREATE OR REPLACE PROCEDURE test_integers
-          ( p_pls_int PLS_INTEGER, p_bin_int BINARY_INTEGER, x_pls_int OUT PLS_INTEGER, x_bin_int OUT BINARY_INTEGER )
-        IS
-        BEGIN
-          x_pls_int := p_pls_int;
-          x_bin_int := p_bin_int;
-        END;
-      SQL
     end
-  
+
     after(:all) do
       plsql.execute "DROP FUNCTION test_sum"
-      plsql.execute "DROP FUNCTION test_number_1"
-      plsql.execute "DROP PROCEDURE test_integers"
       plsql.logoff
     end
-  
-    it "should process integer parameters" do
-      expect(plsql.test_sum(123,456)).to eq(579)
-    end
 
-    it "should process big integer parameters" do
-      expect(plsql.test_sum(123123123123,456456456456)).to eq(579579579579)
+    it "should get #{ora_data_type} variable type mapped to #{class_.to_s}" do
+      expect(plsql.test_sum(num1, num2)).to be_a class_
     end
-
-    it "should process float parameters and return BigDecimal" do
-      expect(plsql.test_sum(123.123,456.456)).to eq(BigDecimal("579.579"))
+    it "should process input parameters and return correct result" do
+      expect(plsql.test_sum(num1, num2)).to eq(expected)
     end
 
-    it "should process BigDecimal parameters and return BigDecimal" do
-      expect(plsql.test_sum(:p_num1 => BigDecimal("123.123"), :p_num2 => BigDecimal("456.456"))).to eq(BigDecimal("579.579"))
+    it "should process nil parameter as NULL" do
+      expect(plsql.test_sum(num1, nil)).to be_nil
+    end unless mandatory
+
+  end
+
+  @big_number = ("1234567890" * 3).to_i
+  [
+      { ora_data_type: "INTEGER",       class: Integer,    num1: @big_number, num2: @big_number, expected: @big_number * 2 },
+      { ora_data_type: "NUMBER",        class: BigDecimal, num1: 12345.12345, num2: 12345.12345, expected: 24690.2469   },
+      { ora_data_type: "PLS_INTEGER",   class: Integer,    num1: 123456789,   num2: 123456789,   expected: 246913578    },
+      { ora_data_type: "BINARY_INTEGER", class: Integer,    num1: 123456789,   num2: 123456789,   expected: 246913578    },
+      { ora_data_type: "SIMPLE_INTEGER", class: Integer,    num1: 123456789,   num2: 123456789,   expected: 246913578, mandatory: true },
+      { ora_data_type: "NATURAL",       class: Integer,    num1: 123456789,   num2: 123456789,   expected: 246913578    },
+      { ora_data_type: "NATURALN",      class: Integer,    num1: 123456789,   num2: 123456789,   expected: 246913578, mandatory: true },
+      { ora_data_type: "POSITIVE",      class: Integer,    num1: 123456789,   num2: 123456789,   expected: 246913578    },
+      { ora_data_type: "POSITIVEN",     class: Integer,    num1: 123456789,   num2: 123456789,   expected: 246913578, mandatory: true },
+      { ora_data_type: "SIGNTYPE",      class: Integer,    num1: 1,           num2: -1,          expected: 0            },
+  ].each do |row|
+    ora_data_type, class_, num1, num2, expected, mandatory = row.values
+    describe ora_data_type do
+      include_examples "Function with numeric", ora_data_type, class_, num1, num2, expected, mandatory
     end
+  end
 
-    it "should process nil parameter as NULL" do
-      expect(plsql.test_sum(123,nil)).to be_nil
+  describe "Boolean to NUMBER conversion" do
+    before(:all) do
+      plsql.connect! CONNECTION_PARAMS
+      plsql.execute <<-SQL
+        CREATE OR REPLACE FUNCTION test_num ( p_num NUMBER) RETURN NUMBER
+        IS
+        BEGIN
+          RETURN p_num;
+        END test_num;
+      SQL
     end
 
+    after(:all) do
+      plsql.execute "DROP FUNCTION test_num"
+      plsql.logoff
+    end
     it "should convert true value to 1 for NUMBER parameter" do
-      expect(plsql.test_number_1(true)).to eq('Y')
+      expect(plsql.test_num(true)).to eq(1)
     end
 
     it "should convert false value to 0 for NUMBER parameter" do
-      expect(plsql.test_number_1(false)).to eq('N')
-    end
-
-    it "should process binary integer parameters" do
-      expect(plsql.test_integers(123, 456)).to eq({:x_pls_int => 123, :x_bin_int => 456})
+      expect(plsql.test_num(false)).to eq(0)
     end
   end
 
   describe "Function with date parameters" do
-  
+
     before(:all) do
       plsql.connect! CONNECTION_PARAMS
       plsql.execute <<-SQL
@@ -150,7 +153,7 @@ describe "Parameter type mapping /" do
         END test_date;
       SQL
     end
-  
+
     before(:each) do
       plsql.default_timezone = :local
     end
@@ -159,46 +162,46 @@ describe "Parameter type mapping /" do
       plsql.execute "DROP FUNCTION test_date"
       plsql.logoff
     end
-  
+
     it "should process Time parameters" do
-      now = Time.local(2008,8,12,14,28,0)
-      expect(plsql.test_date(now)).to eq(now + 60*60*24)
+      now = Time.local(2008, 8, 12, 14, 28, 0)
+      expect(plsql.test_date(now)).to eq(now + 60 * 60 * 24)
     end
 
     it "should process UTC Time parameters" do
       plsql.default_timezone = :utc
-      now = Time.utc(2008,8,12,14,28,0)
-      expect(plsql.test_date(now)).to eq(now + 60*60*24)
+      now = Time.utc(2008, 8, 12, 14, 28, 0)
+      expect(plsql.test_date(now)).to eq(now + 60 * 60 * 24)
     end
 
     it "should process DateTime parameters" do
-      now = DateTime.parse(Time.local(2008,8,12,14,28,0).iso8601)
+      now = DateTime.parse(Time.local(2008, 8, 12, 14, 28, 0).iso8601)
       result = plsql.test_date(now)
       expect(result.class).to eq(Time)
       expect(result).to eq(Time.parse((now + 1).strftime("%c")))
     end
-  
+
     it "should process old DateTime parameters" do
-      now = DateTime.civil(1901,1,1,12,0,0,plsql.local_timezone_offset)
+      now = DateTime.civil(1901, 1, 1, 12, 0, 0, plsql.local_timezone_offset)
       result = plsql.test_date(now)
       expect(result.class).to eq(Time)
       expect(result).to eq(Time.parse((now + 1).strftime("%c")))
     end
 
     it "should process Date parameters" do
-      now = Date.new(2008,8,12)
+      now = Date.new(2008, 8, 12)
       result = plsql.test_date(now)
       expect(result.class).to eq(Time)
       expect(result).to eq(Time.parse((now + 1).strftime("%c")))
     end
-  
+
     it "should process old Date parameters" do
-      now = Date.new(1901,1,1)
+      now = Date.new(1901, 1, 1)
       result = plsql.test_date(now)
       expect(result.class).to eq(Time)
       expect(result).to eq(Time.parse((now + 1).strftime("%c")))
     end
-  
+
     it "should process nil date parameter as NULL" do
       expect(plsql.test_date(nil)).to be_nil
     end
@@ -218,18 +221,67 @@ describe "Parameter type mapping /" do
         END test_timestamp;
       SQL
     end
-  
+
     after(:all) do
       plsql.execute "DROP FUNCTION test_timestamp"
       plsql.logoff
     end
-  
+
     it "should process timestamp parameters" do
       # now = Time.now
-      now = Time.local(2008,8,12,14,28,0)
-      expect(plsql.test_timestamp(now)).to eq(now + 60*60*24)
+      now = Time.local(2008, 8, 12, 14, 28, 0)
+      expect(plsql.test_timestamp(now)).to eq(now + 60 * 60 * 24)
+    end
+
+  end
+
+  describe "Function or procedure with XMLType parameters" do
+    before(:all) do
+      plsql.connect! CONNECTION_PARAMS
+      @oracle12c_or_higher = !! plsql.connection.select_all(
+        "select * from product_component_version where product like 'Oracle%' and to_number(substr(version,1,2)) >= 12")
+      skip "Skip until furtuer investigation for #114" if @oracle12c_or_higher
+      plsql.execute <<-SQL
+        CREATE OR REPLACE FUNCTION test_xmltype
+          ( p_xml XMLTYPE )
+          RETURN XMLTYPE
+        IS
+        BEGIN
+          RETURN p_xml;
+        END test_xmltype;
+      SQL
+      plsql.execute <<-SQL
+        CREATE OR REPLACE PROCEDURE test_xmltype2
+          ( p_xml XMLTYPE, po_xml OUT XMLTYPE )
+        IS
+        BEGIN
+          po_xml := p_xml;
+        END test_xmltype2;
+      SQL
+    end
+
+    after(:all) do
+      plsql.execute "DROP FUNCTION test_xmltype" unless @oracle12c_or_higher
+      plsql.execute "DROP PROCEDURE test_xmltype2" unless @oracle12c_or_higher
+      plsql.logoff
+    end
+
+    it "should process XMLType parameters" do
+      xml = "<DUMMY>value</DUMMY>"
+      result = plsql.test_xmltype(xml)
+      expect(result).to eq("<DUMMY>value</DUMMY>")
+    end
+
+    it "should work when passing a NULL value" do
+      result = plsql.test_xmltype(nil)
+      expect(result).to be_nil
     end
 
+    it "should assign input parameter to putput parameter" do
+      xml = "<DUMMY>value</DUMMY>"
+      result = plsql.test_xmltype2(xml)
+      expect(result[:po_xml]).to eq("<DUMMY>value</DUMMY>")
+    end
   end
 
   describe "Procedure with output parameters" do
@@ -245,26 +297,26 @@ describe "Parameter type mapping /" do
         END test_copy;
       SQL
     end
-  
+
     after(:all) do
       plsql.execute "DROP PROCEDURE test_copy"
       plsql.logoff
     end
-  
+
     it "should return hash with output parameters" do
-      expect(plsql.test_copy("abc", nil, nil)).to eq({ :p_to => "abc", :p_to_double => "abcabc" })
+      expect(plsql.test_copy("abc", nil, nil)).to eq(p_to: "abc", p_to_double: "abcabc")
     end
 
     it "should return hash with output parameters when called with named parameters" do
-      expect(plsql.test_copy(:p_from => "abc", :p_to => nil, :p_to_double => nil)).to eq({ :p_to => "abc", :p_to_double => "abcabc" })
+      expect(plsql.test_copy(p_from: "abc", p_to: nil, p_to_double: nil)).to eq(p_to: "abc", p_to_double: "abcabc")
     end
 
     it "should substitute output parameters with nil if they are not specified" do
-      expect(plsql.test_copy("abc")).to eq({ :p_to => "abc", :p_to_double => "abcabc" })
+      expect(plsql.test_copy("abc")).to eq(p_to: "abc", p_to_double: "abcabc")
     end
 
     it "should substitute named output parameters with nil if they are not specified" do
-      expect(plsql.test_copy(:p_from => "abc")).to eq({ :p_to => "abc", :p_to_double => "abcabc" })
+      expect(plsql.test_copy(p_from: "abc")).to eq(p_to: "abc", p_to_double: "abcabc")
     end
 
   end
@@ -328,12 +380,12 @@ describe "Parameter type mapping /" do
       SQL
 
     end
-  
+
     after(:all) do
       plsql.execute "DROP PACKAGE test_package2"
       plsql.logoff
     end
-    
+
     it "should find existing package" do
       expect(PLSQL::Package.find(plsql, :test_package2)).not_to be_nil
     end
@@ -351,30 +403,30 @@ describe "Parameter type mapping /" do
     end
 
     it "should execute correct procedures based on number of arguments and return correct value" do
-      expect(plsql.test_package2.test_procedure('xxx')).to eq('XXX')
-      expect(plsql.test_package2.test_procedure('xxx', nil)).to eq({:p_result => 'XXX'})
+      expect(plsql.test_package2.test_procedure("xxx")).to eq("XXX")
+      expect(plsql.test_package2.test_procedure("xxx", nil)).to eq(p_result: "XXX")
     end
 
     it "should execute correct procedures based on number of named arguments and return correct value" do
-      expect(plsql.test_package2.test_procedure(:p_string => 'xxx')).to eq('XXX')
-      expect(plsql.test_package2.test_procedure(:p_string => 'xxx', :p_result => nil)).to eq({:p_result => 'XXX'})
+      expect(plsql.test_package2.test_procedure(p_string: "xxx")).to eq("XXX")
+      expect(plsql.test_package2.test_procedure(p_string: "xxx", p_result: nil)).to eq(p_result: "XXX")
     end
 
     it "should raise exception if procedure cannot be found based on number of arguments" do
       expect { plsql.test_package2.test_procedure() }.to raise_error(/wrong number or types of arguments/i)
     end
-  
+
     it "should find procedure based on types of arguments" do
-      expect(plsql.test_package2.test_procedure(111, nil)).to eq({:p_result => '111'})
+      expect(plsql.test_package2.test_procedure(111, nil)).to eq(p_result: "111")
     end
 
     it "should find procedure based on names of named arguments" do
-      expect(plsql.test_package2.test_procedure(:p_number => 111, :p_result => nil)).to eq({:p_result => '111'})
+      expect(plsql.test_package2.test_procedure(p_number: 111, p_result: nil)).to eq(p_result: "111")
     end
 
     it "should find matching procedure based on partial list of named arguments" do
-      expect(plsql.test_package2.test_function(:p_string => 'xxx')).to eq('xxx ')
-      expect(plsql.test_package2.test_function(:p_number => 1)).to eq(2)
+      expect(plsql.test_package2.test_function(p_string: "xxx")).to eq("xxx ")
+      expect(plsql.test_package2.test_function(p_number: 1)).to eq(2)
     end
 
   end
@@ -394,24 +446,24 @@ describe "Parameter type mapping /" do
         END test_copy_function;
       SQL
     end
-  
+
     after(:all) do
       plsql.execute "DROP FUNCTION test_copy_function"
       plsql.logoff
     end
-  
+
     it "should return array with return value and hash of output parameters" do
-      expect(plsql.test_copy_function("abc", nil, nil)).to eq([3, { :p_to => "abc", :p_to_double => "abcabc" }])
+      expect(plsql.test_copy_function("abc", nil, nil)).to eq([3, { p_to: "abc", p_to_double: "abcabc" }])
     end
 
     it "should return array with return value and hash of output parameters when called with named parameters" do
-      expect(plsql.test_copy_function(:p_from => "abc", :p_to => nil, :p_to_double => nil)).to eq(
-        [3, { :p_to => "abc", :p_to_double => "abcabc" }]
+      expect(plsql.test_copy_function(p_from: "abc", p_to: nil, p_to_double: nil)).to eq(
+        [3, { p_to: "abc", p_to_double: "abcabc" }]
       )
     end
 
     it "should substitute output parameters with nil if they are not specified" do
-      expect(plsql.test_copy_function("abc")).to eq([3, { :p_to => "abc", :p_to_double => "abcabc" }])
+      expect(plsql.test_copy_function("abc")).to eq([3, { p_to: "abc", p_to_double: "abcabc" }])
     end
 
   end
@@ -435,7 +487,7 @@ describe "Parameter type mapping /" do
         END test_proc_no_params;
       SQL
     end
-  
+
     after(:all) do
       plsql.execute "DROP FUNCTION test_no_params"
       plsql.execute "DROP PROCEDURE test_proc_no_params"
@@ -481,7 +533,7 @@ describe "Parameter type mapping /" do
           CURSOR clob_cur IS
           SELECT clob_col
           FROM test_clob_table;
-          
+
           v_dummy  CLOB;
         BEGIN
           DELETE FROM test_clob_table;
@@ -490,47 +542,47 @@ describe "Parameter type mapping /" do
           OPEN clob_cur;
           FETCH clob_cur INTO v_dummy;
           CLOSE clob_cur;
-          
+
           RETURN v_dummy;
         END test_clob_insert;
       SQL
     end
-  
+
     after(:all) do
       plsql.execute "DROP FUNCTION test_clob"
       plsql.execute "DROP FUNCTION test_clob_insert"
       plsql.execute "DROP TABLE test_clob_table"
       plsql.logoff
     end
-  
+
     it "should find existing procedure" do
       expect(PLSQL::Procedure.find(plsql, :test_clob)).not_to be_nil
     end
 
     it "should execute function and return correct value" do
-      large_text = 'ābčdēfghij' * 10_000
+      large_text = "ābčdēfghij" * 10_000
       expect(plsql.test_clob(large_text)).to eq(large_text)
     end
 
     unless defined?(JRUBY_VERSION)
 
       it "should execute function with empty string and return nil (oci8 cannot pass empty CLOB parameter)" do
-        text = ''
+        text = ""
         expect(plsql.test_clob(text)).to be_nil
       end
 
       it "should execute function which inserts the CLOB parameter into a table with empty string and return nil" do
-        text = ''
+        text = ""
         expect(plsql.test_clob_insert(text)).to be_nil
       end
-    
+
     else
 
       it "should execute function with empty string and return empty string" do
-        text = ''
+        text = ""
         expect(plsql.test_clob(text)).to eq(text)
       end
-    
+
     end
 
     it "should execute function with nil and return nil" do
@@ -540,7 +592,7 @@ describe "Parameter type mapping /" do
     it "should execute function which inserts the CLOB parameter into a table with nil and return nil" do
       expect(plsql.test_clob_insert(nil)).to be_nil
     end
-    
+
   end
 
   describe "Procedrue with CLOB parameter and return value" do
@@ -556,18 +608,18 @@ describe "Parameter type mapping /" do
         END test_clob_proc;
       SQL
     end
-  
+
     after(:all) do
       plsql.execute "DROP PROCEDURE test_clob_proc"
       plsql.logoff
     end
-  
+
     it "should find existing procedure" do
       expect(PLSQL::Procedure.find(plsql, :test_clob_proc)).not_to be_nil
     end
 
     it "should execute function and return correct value" do
-      large_text = 'ābčdēfghij' * 10_000
+      large_text = "ābčdēfghij" * 10_000
       expect(plsql.test_clob_proc(large_text)[:p_return]).to eq(large_text)
     end
   end
@@ -585,12 +637,12 @@ describe "Parameter type mapping /" do
         END test_blob_proc;
       SQL
     end
-  
+
     after(:all) do
       plsql.execute "DROP PROCEDURE test_blob_proc"
       plsql.logoff
     end
-  
+
     it "should find existing procedure" do
       expect(PLSQL::Procedure.find(plsql, :test_blob_proc)).not_to be_nil
     end
@@ -609,7 +661,7 @@ describe "Parameter type mapping /" do
         CREATE TABLE test_employees (
           employee_id   NUMBER(15),
           first_name    VARCHAR2(50),
-          last_name     VARCHAR2(50),
+          last_name     VARCHAR(50),
           hire_date     DATE
         )
       SQL
@@ -626,17 +678,30 @@ describe "Parameter type mapping /" do
           TYPE t_employee IS RECORD(
             employee_id   NUMBER(15),
             first_name    VARCHAR2(50),
-            last_name     VARCHAR2(50),
+            last_name     VARCHAR(50),
             hire_date     DATE
           );
 
-          TYPE table_of_records IS TABLE OF t_employee;
+          TYPE t_candidate IS RECORD(
+            candidate_id NUMBER(5),
+            is_approved  BOOLEAN
+          );
+
+          TYPE table_of_records IS TABLE OF test_record.t_employee;
 
           FUNCTION test_full_name(p_employee t_employee)
             RETURN VARCHAR2;
 
           FUNCTION test_empty_records
             RETURN table_of_records;
+
+          FUNCTION is_approved(p_candidate t_candidate)
+            RETURN BOOLEAN;
+
+          FUNCTION f_set_candidate_status(p_candidate t_candidate, p_status boolean)
+            RETURN t_candidate;
+
+          PROCEDURE p_set_candidate_status(p_candidate t_candidate, p_status boolean, p_result OUT t_candidate);
         END;
       SQL
       plsql.execute <<-SQL
@@ -653,7 +718,7 @@ describe "Parameter type mapping /" do
           IS
             CURSOR employees_cur
             IS
-              SELECT 
+              SELECT
                 null employee_id,
                 null first_name,
                 null last_name,
@@ -667,6 +732,29 @@ describe "Parameter type mapping /" do
             CLOSE employees_cur;
             RETURN employees_tab;
           END;
+
+          FUNCTION is_approved(p_candidate t_candidate)
+            RETURN BOOLEAN
+          IS
+          BEGIN
+            RETURN p_candidate.is_approved;
+          END;
+
+          FUNCTION f_set_candidate_status(p_candidate t_candidate, p_status boolean)
+            RETURN t_candidate
+          IS
+            result t_candidate := p_candidate;
+          BEGIN
+            result.is_approved := p_status;
+            return result;
+          END;
+
+          PROCEDURE p_set_candidate_status(p_candidate t_candidate, p_status boolean, p_result OUT t_candidate)
+          IS
+          BEGIN
+            p_result := p_candidate;
+            p_result.is_approved := p_status;
+          END;
         END;
       SQL
       plsql.execute <<-SQL
@@ -690,16 +778,16 @@ describe "Parameter type mapping /" do
         END test_employee_record2;
       SQL
       @p_employee = {
-        :employee_id => 1,
-        :first_name => 'First',
-        :last_name => 'Last',
-        :hire_date => Time.local(2000,01,31)
+        employee_id: 1,
+        first_name: "First",
+        last_name: "Last",
+        hire_date: Time.local(2000, 01, 31)
       }
       @p_employee2 = {
-        'employee_id' => 1,
-        'FIRST_NAME' => 'Second',
-        'last_name' => 'Last',
-        'hire_date' => Time.local(2000,01,31)
+        "employee_id" => 1,
+        "FIRST_NAME" => "Second",
+        "last_name" => "Last",
+        "hire_date" => Time.local(2000, 01, 31)
       }
     end
 
@@ -717,23 +805,23 @@ describe "Parameter type mapping /" do
     end
 
     it "should execute function with named parameter and return correct value" do
-      expect(plsql.test_full_name(:p_employee => @p_employee)).to eq('First Last')
+      expect(plsql.test_full_name(p_employee: @p_employee)).to eq("First Last")
     end
 
     it "should execute function with sequential parameter and return correct value" do
-      expect(plsql.test_full_name(@p_employee)).to eq('First Last')
+      expect(plsql.test_full_name(@p_employee)).to eq("First Last")
     end
 
     it "should execute function with Hash parameter using strings as keys" do
-      expect(plsql.test_full_name(@p_employee2)).to eq('Second Last')
+      expect(plsql.test_full_name(@p_employee2)).to eq("Second Last")
     end
 
     it "should raise error if wrong field name is passed for record parameter" do
       expect do
-        expect(plsql.test_full_name(@p_employee.merge :xxx => 'xxx')).to eq('Second Last')
+        expect(plsql.test_full_name(@p_employee.merge xxx: "xxx")).to eq("Second Last")
       end.to raise_error(ArgumentError)
     end
-    
+
     it "should return empty table of records" do
       expect(plsql.test_record.test_empty_records()).to eq([])
     end
@@ -743,11 +831,31 @@ describe "Parameter type mapping /" do
     end
 
     it "should return record return value and output record parameter value" do
-      expect(plsql.test_employee_record2(@p_employee, @p_employee2)).to eq([@p_employee, {:x_employee => @p_employee}])
+      expect(plsql.test_employee_record2(@p_employee, @p_employee2)).to eq([@p_employee, { x_employee: @p_employee }])
     end
 
     it "should execute package function with parameter with record type defined in package" do
-      expect(plsql.test_record.test_full_name(@p_employee)).to eq('First Last')
+      expect(plsql.test_record.test_full_name(@p_employee)).to eq("First Last")
+    end
+
+    context "functions with record parameters having boolean attributes" do
+      def new_candidate(status)
+        { candidate_id: 1, is_approved: status }
+      end
+
+      [true, false, nil].each do |status|
+        it "should execute function with record having boolean attribute (#{status})" do
+          expect(plsql.test_record.is_approved(new_candidate(status))).to eq status
+        end
+
+        it "procedure should return record with boolean attribute as output parameter (#{status})" do
+          expect(plsql.test_record.p_set_candidate_status(new_candidate(nil), status)[:p_result]).to eq new_candidate(status)
+        end
+
+        it "function should return record with boolean attribute (#{status})" do
+          expect(plsql.test_record.f_set_candidate_status(new_candidate(nil), status)).to eq new_candidate(status)
+        end
+      end
     end
 
   end
@@ -793,15 +901,15 @@ describe "Parameter type mapping /" do
     end
 
     it "should accept true value and assign true value to output parameter" do
-      expect(plsql.test_boolean2(true, nil)).to eq({:x_boolean => true})
+      expect(plsql.test_boolean2(true, nil)).to eq(x_boolean: true)
     end
 
     it "should accept false value and assign false value to output parameter" do
-      expect(plsql.test_boolean2(false, nil)).to eq({:x_boolean => false})
+      expect(plsql.test_boolean2(false, nil)).to eq(x_boolean: false)
     end
 
     it "should accept nil value and assign nil value to output parameter" do
-      expect(plsql.test_boolean2(nil, nil)).to eq({:x_boolean => nil})
+      expect(plsql.test_boolean2(nil, nil)).to eq(x_boolean: nil)
     end
 
   end
@@ -831,7 +939,7 @@ describe "Parameter type mapping /" do
         CREATE OR REPLACE TYPE t_employee AS OBJECT (
           employee_id   NUMBER(15),
           first_name    VARCHAR2(50),
-          last_name     VARCHAR2(50),
+          last_name     VARCHAR(50),
           hire_date     DATE,
           address       t_address,
           phones        t_phones
@@ -863,12 +971,12 @@ describe "Parameter type mapping /" do
         END;
       SQL
       @p_employee = {
-        :employee_id => 1,
-        :first_name => 'First',
-        :last_name => 'Last',
-        :hire_date => Time.local(2000,01,31),
-        :address => {:street => 'Main street 1', :city => 'Riga', :country => 'Latvia'},
-        :phones => [{:type => 'mobile', :phone_number => '123456'}, {:type => 'home', :phone_number => '654321'}]
+        employee_id: 1,
+        first_name: "First",
+        last_name: "Last",
+        hire_date: Time.local(2000, 01, 31),
+        address: { street: "Main street 1", city: "Riga", country: "Latvia" },
+        phones: [{ type: "mobile", phone_number: "123456" }, { type: "home", phone_number: "654321" }]
       }
     end
 
@@ -888,16 +996,16 @@ describe "Parameter type mapping /" do
     end
 
     it "should execute function with named parameter and return correct value" do
-      expect(plsql.test_full_name(:p_employee => @p_employee)).to eq('First Last')
+      expect(plsql.test_full_name(p_employee: @p_employee)).to eq("First Last")
     end
 
     it "should execute function with sequential parameter and return correct value" do
-      expect(plsql.test_full_name(@p_employee)).to eq('First Last')
+      expect(plsql.test_full_name(@p_employee)).to eq("First Last")
     end
 
     it "should raise error if wrong field name is passed for record parameter" do
       expect do
-        plsql.test_full_name(@p_employee.merge :xxx => 'xxx')
+        plsql.test_full_name(@p_employee.merge xxx: "xxx")
       end.to raise_error(ArgumentError)
     end
 
@@ -906,7 +1014,7 @@ describe "Parameter type mapping /" do
     end
 
     it "should return object type return value and output object type parameter value" do
-      expect(plsql.test_employee_object2(@p_employee, nil)).to eq([@p_employee, {:x_employee => @p_employee}])
+      expect(plsql.test_employee_object2(@p_employee, nil)).to eq([@p_employee, { x_employee: @p_employee }])
     end
 
     it "should accept NULL as input parameter" do
@@ -915,7 +1023,6 @@ describe "Parameter type mapping /" do
 
   end
 
-
   describe "Function with table parameter" do
     before(:all) do
       plsql.connect! CONNECTION_PARAMS
@@ -941,7 +1048,7 @@ describe "Parameter type mapping /" do
           END IF;
         END;
       SQL
-      
+
       plsql.execute <<-SQL
         CREATE OR REPLACE FUNCTION test_increment(p_numbers IN t_numbers, p_increment_by IN NUMBER DEFAULT 1)
           RETURN t_numbers
@@ -991,19 +1098,19 @@ describe "Parameter type mapping /" do
           TYPE t_employee IS RECORD(
             employee_id   NUMBER(15),
             first_name    VARCHAR2(50),
-            last_name     VARCHAR2(50),
+            last_name     VARCHAR(50),
             hire_date     DATE
           );
-          TYPE t_employees IS TABLE OF t_employee;
+          TYPE t_employees IS TABLE OF test_collections.t_employee;
           FUNCTION test_employees (p_employees IN OUT t_employees)
             RETURN t_employees;
           -- these types with tables in lower level are not yet supported
           TYPE t_employee2 IS RECORD(
             employee_id   NUMBER(15),
             first_name    VARCHAR2(50),
-            last_name     VARCHAR2(50),
+            last_name     VARCHAR(50),
             hire_date     DATE,
-            numbers       t_numbers
+            numbers       test_collections.t_numbers
           );
           FUNCTION test_employee2 (p_employee IN OUT t_employee2)
             RETURN t_employee2;
@@ -1097,20 +1204,20 @@ describe "Parameter type mapping /" do
       SQL
       @employees = (1..10).map do |i|
         {
-          :employee_id => i,
-          :first_name => "First #{i}",
-          :last_name => "Last #{i}",
-          :hire_date => Time.local(2000,01,i),
+          employee_id: i,
+          first_name: "First #{i}",
+          last_name: "Last #{i}",
+          hire_date: Time.local(2000, 01, i),
         }
       end
       @nstrings = (1..5).map do |i|
         {
-          :ch_10bytes => "Ch #{i}B     ",
-          :ch_10chars => "Ch #{i}C     ",
-          :nch_10chars => "NCh #{i}     ",
-          :str_10bytes => "Str #{i}C",
-          :str_10chars => "Str #{i}B",
-          :nstr_10chars => "NStr #{i}",
+          ch_10bytes: "Ch #{i}B     ",
+          ch_10chars: "Ch #{i}C     ",
+          nch_10chars: "NCh #{i}     ",
+          str_10bytes: "Str #{i}C",
+          str_10chars: "Str #{i}B",
+          nstr_10chars: "NStr #{i}",
         }
       end
 
@@ -1154,78 +1261,78 @@ describe "Parameter type mapping /" do
     end
 
     it "should execute function with number array parameter" do
-      expect(plsql.test_sum([1,2,3,4])).to eq(10)
+      expect(plsql.test_sum([1, 2, 3, 4])).to eq(10)
     end
-    
+
     it "should return number array return value" do
-      expect(plsql.test_increment([1,2,3,4], 1)).to eq([2,3,4,5])
+      expect(plsql.test_increment([1, 2, 3, 4], 1)).to eq([2, 3, 4, 5])
     end
 
     it "should execute function with string array and return string array output parameter" do
-      strings = ['1','2','3','4']
-      expect(plsql.test_copy_strings(strings)).to eq([strings, {:x_strings => strings}])
+      strings = ["1", "2", "3", "4"]
+      expect(plsql.test_copy_strings(strings)).to eq([strings, { x_strings: strings }])
     end
 
     it "should execute function with table of numbers type (defined inside package) parameter" do
-      expect(plsql.test_collections.test_sum([1,2,3,4])).to eq(10)
+      expect(plsql.test_collections.test_sum([1, 2, 3, 4])).to eq(10)
     end
 
     it "should clear temporary tables after executing function with table of numbers type even if an error occurs in the package" do
       # this should work fine
-      expect(plsql.test_collections.test_function_failure([1,2,3,4], 'N')).to eq(4)
+      expect(plsql.test_collections.test_function_failure([1, 2, 3, 4], "N")).to eq(4)
       # we will force a package error here to see if things get cleaned up before the next call
-      expect { plsql.test_collections.test_function_failure([1,2,3,4], 'Y') }.to raise_error(/Simulate business error to test clearing of temp table/)
+      expect { plsql.test_collections.test_function_failure([1, 2, 3, 4], "Y") }.to raise_error(/Simulate business error to test clearing of temp table/)
       # after the error in the first call temporary tables should be cleared
-      expect(plsql.test_collections.test_function_failure([5,6,7], 'N')).to eq(3)
+      expect(plsql.test_collections.test_function_failure([5, 6, 7], "N")).to eq(3)
     end
 
     it "should return table of numbers type (defined inside package)" do
-      expect(plsql.test_collections.test_numbers([1,2,3,4])).to eq([[1,2,3,4], {:x_numbers => [1,2,3,4]}])
+      expect(plsql.test_collections.test_numbers([1, 2, 3, 4])).to eq([[1, 2, 3, 4], { x_numbers: [1, 2, 3, 4] }])
     end
 
     it "should clear temporary tables after executing function with table of numbers type (defined inside package) parameter" do
-      expect(plsql.test_collections.test_numbers([1,2,3,4])).to eq([[1,2,3,4], {:x_numbers => [1,2,3,4]}])
+      expect(plsql.test_collections.test_numbers([1, 2, 3, 4])).to eq([[1, 2, 3, 4], { x_numbers: [1, 2, 3, 4] }])
       # after first call temporary tables should be cleared
-      expect(plsql.test_collections.test_numbers([1,2,3,4])).to eq([[1,2,3,4], {:x_numbers => [1,2,3,4]}])
+      expect(plsql.test_collections.test_numbers([1, 2, 3, 4])).to eq([[1, 2, 3, 4], { x_numbers: [1, 2, 3, 4] }])
     end
 
     it "should clear temporary tables when autocommit with table of numbers type (defined inside package) parameter" do
       old_autocommit = plsql.connection.autocommit?
       plsql.connection.autocommit = true
       numbers_array = (1..400).to_a
-      expect(plsql.test_collections.test_numbers(numbers_array)).to eq([numbers_array, {:x_numbers => numbers_array}])
+      expect(plsql.test_collections.test_numbers(numbers_array)).to eq([numbers_array, { x_numbers: numbers_array }])
       # after first call temporary tables should be cleared
-      expect(plsql.test_collections.test_numbers(numbers_array)).to eq([numbers_array, {:x_numbers => numbers_array}])
+      expect(plsql.test_collections.test_numbers(numbers_array)).to eq([numbers_array, { x_numbers: numbers_array }])
       plsql.connection.autocommit = old_autocommit
     end
 
     it "should execute function with table of records type (defined inside package) parameter" do
-      expect(plsql.test_collections.test_employees(@employees)).to eq([@employees, {:p_employees => @employees}])
+      expect(plsql.test_collections.test_employees(@employees)).to eq([@employees, { p_employees: @employees }])
     end
 
     it "should execute function with table of records type (defined inside package and includes NVARCHAR columns) parameter" do
-      expect(plsql.test_collections.test_nstring(@nstrings)).to eq([(1..5).map{|i| "NCh #{i}NStr #{i},"}.join, {:p_out => @nstrings}])
+      expect(plsql.test_collections.test_nstring(@nstrings)).to eq([(1..5).map { |i| "NCh #{i}NStr #{i}," }.join, { p_out: @nstrings }])
     end
 
     it "should execute function with object array and return object array output parameter" do
-      phones = [{:type => 'mobile', :phone_number => '123456'}, {:type => 'home', :phone_number => '654321'}]
-      expect(plsql.test_copy_objects(phones)).to eq([phones, {:x_phones => phones}])
+      phones = [{ type: "mobile", phone_number: "123456" }, { type: "home", phone_number: "654321" }]
+      expect(plsql.test_copy_objects(phones)).to eq([phones, { x_phones: phones }])
     end
 
     it "should execute function with empty object array" do
       phones = []
-      expect(plsql.test_copy_objects(phones)).to eq([phones, {:x_phones => phones}])
+      expect(plsql.test_copy_objects(phones)).to eq([phones, { x_phones: phones }])
     end
 
     it "should raise error with record parameter that has table as element" do
       expect {
-        expect(plsql.test_collections.test_employee2(@employees[0])).to eq([@employees[0], {:p_employee => @employees[0]}])
+        expect(plsql.test_collections.test_employee2(@employees[0])).to eq([@employees[0], { p_employee: @employees[0] }])
       }.to raise_error(ArgumentError, /TEST_COLLECTIONS\.T_NUMBERS definition inside package is not supported/)
     end
 
     it "should raise error with table of records parameter when record has table as element" do
       expect {
-        expect(plsql.test_collections.test_employees2(@employees)).to eq([@employees, {:p_employees => @employees}])
+        expect(plsql.test_collections.test_employees2(@employees)).to eq([@employees, { p_employees: @employees }])
       }.to raise_error(ArgumentError, /TEST_COLLECTIONS\.T_NUMBERS definition inside package is not supported/)
     end
 
@@ -1238,7 +1345,7 @@ describe "Parameter type mapping /" do
         CREATE TABLE test_employees (
           employee_id   NUMBER(15),
           first_name    VARCHAR2(50),
-          last_name     VARCHAR2(50),
+          last_name     VARCHAR(50),
           hire_date     DATE
         )
       SQL
@@ -1256,10 +1363,10 @@ describe "Parameter type mapping /" do
           TYPE t_employee IS RECORD(
             employee_id   NUMBER(15),
             first_name    VARCHAR2(50),
-            last_name     VARCHAR2(50),
+            last_name     VARCHAR(50),
             hire_date     DATE
           );
-          TYPE t_employees IS TABLE OF t_employee
+          TYPE t_employees IS TABLE OF test_collections.t_employee
             INDEX BY BINARY_INTEGER;
           FUNCTION test_employees (p_employees IN OUT t_employees)
             RETURN t_employees;
@@ -1334,15 +1441,15 @@ describe "Parameter type mapping /" do
         END;
       SQL
       # test with negative PL/SQL table indexes
-      @numbers = Hash[*(1..4).map{|i|[-i,i]}.flatten]
-      @numbers2 = Hash[*(5..7).map{|i|[-i,i]}.flatten]
+      @numbers = Hash[*(1..4).map { |i|[-i, i] }.flatten]
+      @numbers2 = Hash[*(5..7).map { |i|[-i, i] }.flatten]
       # test with reversed PL/SQL table indexes
       @employees = Hash[*(1..10).map do |i|
-          [11-i, {
-              :employee_id => i,
-              :first_name => "First #{i}",
-              :last_name => "Last #{i}",
-              :hire_date => Time.local(2000,01,i)
+          [11 - i, {
+              employee_id: i,
+              first_name: "First #{i}",
+              last_name: "Last #{i}",
+              hire_date: Time.local(2000, 01, i)
             }]
         end.flatten]
     end
@@ -1356,11 +1463,11 @@ describe "Parameter type mapping /" do
 
     it "should clear temporary tables after executing function with index-by table of numbers type even if an error occurs in the package" do
       # this should work fine
-      expect(plsql.test_collections.test_function_failure(@numbers, 'N')).to eq(10)
+      expect(plsql.test_collections.test_function_failure(@numbers, "N")).to eq(10)
       # we will force a package error here to see if things get cleaned up before the next call
-      expect { plsql.test_collections.test_function_failure(@numbers, 'Y') }.to raise_error(/Simulate business error to test clearing of temp table/)
+      expect { plsql.test_collections.test_function_failure(@numbers, "Y") }.to raise_error(/Simulate business error to test clearing of temp table/)
       # after the error in the first call temporary tables should be cleared
-      expect(plsql.test_collections.test_function_failure(@numbers2, 'N')).to eq(18)
+      expect(plsql.test_collections.test_function_failure(@numbers2, "N")).to eq(18)
     end
 
     it "should execute function with index-by table of numbers type (defined inside package) parameter" do
@@ -1368,25 +1475,25 @@ describe "Parameter type mapping /" do
     end
 
     it "should return index-by table of numbers type (defined inside package)" do
-      expect(plsql.test_collections.test_numbers(@numbers)).to eq([@numbers, {:x_numbers => @numbers}])
+      expect(plsql.test_collections.test_numbers(@numbers)).to eq([@numbers, { x_numbers: @numbers }])
     end
 
     it "should clear temporary tables when autocommit with index-by table of numbers type (defined inside package) parameter" do
       old_autocommit = plsql.connection.autocommit?
       plsql.connection.autocommit = true
-      numbers_hash = Hash[*(1..400).map{|i|[i,i]}.flatten]
-      expect(plsql.test_collections.test_numbers(numbers_hash)).to eq([numbers_hash, {:x_numbers => numbers_hash}])
+      numbers_hash = Hash[*(1..400).map { |i|[i, i] }.flatten]
+      expect(plsql.test_collections.test_numbers(numbers_hash)).to eq([numbers_hash, { x_numbers: numbers_hash }])
       # after first call temporary tables should be cleared
-      expect(plsql.test_collections.test_numbers(numbers_hash)).to eq([numbers_hash, {:x_numbers => numbers_hash}])
+      expect(plsql.test_collections.test_numbers(numbers_hash)).to eq([numbers_hash, { x_numbers: numbers_hash }])
       plsql.connection.autocommit = old_autocommit
     end
 
     it "should execute function with index-by table of records type (defined inside package) parameter" do
-      expect(plsql.test_collections.test_employees(@employees)).to eq([@employees, {:p_employees => @employees}])
+      expect(plsql.test_collections.test_employees(@employees)).to eq([@employees, { p_employees: @employees }])
     end
 
     it "should execute procedure with index-by table of records type (defined inside package) parameter" do
-      expect(plsql.test_collections.test_employees_prc(@employees)).to eq({:p_employees => @employees})
+      expect(plsql.test_collections.test_employees_prc(@employees)).to eq(p_employees: @employees)
     end
 
     it "should create temporary tables in autonomous transaction" do
@@ -1394,13 +1501,19 @@ describe "Parameter type mapping /" do
       plsql.connection.autocommit = false
       plsql.test_employees.insert @employees[1]
       # procedure call should not commit initial insert
-      plsql.test_collections.insert_employees(2=>@employees[2], 3=>@employees[3])
+      plsql.test_collections.insert_employees(2 => @employees[2], 3 => @employees[3])
       plsql.rollback
       expect(plsql.test_employees.all).to be_empty
       plsql.connection.autocommit = old_autocommit
     end
 
     describe "using Oracle 9.2" do
+      before(:all) do
+        # get actual database_version
+        plsql.connect! CONNECTION_PARAMS
+        skip "Skip if the actual database version is 18c or higher" if (plsql.connection.database_version <=> [18, 0, 0, 0]) >= 0
+      end
+
       before do
         # simulate Oracle 9.2 connection
         plsql(:oracle_9).connection = get_connection
@@ -1412,14 +1525,13 @@ describe "Parameter type mapping /" do
       end
 
       it "should create temporary tables when using Oracle 9.2" do
-        expect(plsql(:oracle_9).test_collections.test_numbers(@numbers)).to eq([@numbers, {:x_numbers => @numbers}])
+        expect(plsql(:oracle_9).test_collections.test_numbers(@numbers)).to eq([@numbers, { x_numbers: @numbers }])
       end
 
     end
 
   end
 
-
   describe "Function with VARRAY parameter" do
     before(:all) do
       plsql.connect! CONNECTION_PARAMS
@@ -1515,26 +1627,26 @@ describe "Parameter type mapping /" do
     end
 
     it "should execute function with number array parameter" do
-      expect(plsql.test_sum([1,2,3,4])).to eq(10)
+      expect(plsql.test_sum([1, 2, 3, 4])).to eq(10)
     end
 
     it "should return number array return value" do
-      expect(plsql.test_increment([1,2,3,4], 1)).to eq([2,3,4,5])
+      expect(plsql.test_increment([1, 2, 3, 4], 1)).to eq([2, 3, 4, 5])
     end
 
     it "should execute function with string array and return string array output parameter" do
-      strings = ['1','2','3','4']
-      expect(plsql.test_copy_strings(strings)).to eq([strings, {:x_strings => strings}])
+      strings = ["1", "2", "3", "4"]
+      expect(plsql.test_copy_strings(strings)).to eq([strings, { x_strings: strings }])
     end
 
     it "should execute function with object array and return object array output parameter" do
-      phones = [{:type => 'mobile', :phone_number => '123456'}, {:type => 'home', :phone_number => '654321'}]
-      expect(plsql.test_copy_objects(phones)).to eq([phones, {:x_phones => phones}])
+      phones = [{ type: "mobile", phone_number: "123456" }, { type: "home", phone_number: "654321" }]
+      expect(plsql.test_copy_objects(phones)).to eq([phones, { x_phones: phones }])
     end
 
     it "should execute function with empty object array" do
       phones = []
-      expect(plsql.test_copy_objects(phones)).to eq([phones, {:x_phones => phones}])
+      expect(plsql.test_copy_objects(phones)).to eq([phones, { x_phones: phones }])
     end
 
   end
@@ -1644,30 +1756,30 @@ describe "Parameter type mapping /" do
     end
 
     it "should execute function with number array parameter" do
-      expect(plsql.test_collections.test_sum([1,2,3,4])).to eq(10)
+      expect(plsql.test_collections.test_sum([1, 2, 3, 4])).to eq(10)
     end
 
     it "should clear temporary tables after executing function with varray of numbers type even if an error occurs in the package" do
       # this should work fine
-      expect(plsql.test_collections.test_function_failure([1,2,3,4], 'N')).to eq(10)
+      expect(plsql.test_collections.test_function_failure([1, 2, 3, 4], "N")).to eq(10)
       # we will force a package error here to see if things get cleaned up before the next call
-      expect { plsql.test_collections.test_function_failure([5,6,7], 'Y') }.to raise_error(/Simulate business error to test clearing of temp table/)
+      expect { plsql.test_collections.test_function_failure([5, 6, 7], "Y") }.to raise_error(/Simulate business error to test clearing of temp table/)
       # after the error in the first call temporary tables should be cleared
-      expect(plsql.test_collections.test_function_failure([3,4,5,6], 'N')).to eq(18)
+      expect(plsql.test_collections.test_function_failure([3, 4, 5, 6], "N")).to eq(18)
     end
 
     it "should return number array return value" do
-      expect(plsql.test_collections.test_increment([1,2,3,4], 1)).to eq([2,3,4,5])
+      expect(plsql.test_collections.test_increment([1, 2, 3, 4], 1)).to eq([2, 3, 4, 5])
     end
 
     it "should execute function with string array and return string array output parameter" do
-      strings = ['1','2','3','4']
-      expect(plsql.test_collections.test_copy_strings(strings)).to eq([strings, {:x_strings => strings}])
+      strings = ["1", "2", "3", "4"]
+      expect(plsql.test_collections.test_copy_strings(strings)).to eq([strings, { x_strings: strings }])
     end
 
     it "should execute function with object array and return object array output parameter" do
-      phones = [{:type => 'mobile', :phone_number => '123456'}, {:type => 'home', :phone_number => '654321'}]
-      expect(plsql.test_collections.test_copy_objects(phones)).to eq([phones, {:x_phones => phones}])
+      phones = [{ type: "mobile", phone_number: "123456" }, { type: "home", phone_number: "654321" }]
+      expect(plsql.test_collections.test_copy_objects(phones)).to eq([phones, { x_phones: phones }])
     end
 
     # This test fails without wcmatthysen's "Procedure-call Fix." pull request.
@@ -1686,7 +1798,7 @@ describe "Parameter type mapping /" do
         CREATE TABLE test_employees (
           employee_id   NUMBER(15),
           first_name    VARCHAR2(50),
-          last_name     VARCHAR2(50),
+          last_name     VARCHAR(50),
           hire_date     DATE
         )
       SQL
@@ -1730,10 +1842,10 @@ describe "Parameter type mapping /" do
       @fields = [:employee_id, :first_name, :last_name, :hire_date]
       @employees = (1..10).map do |i|
         {
-          :employee_id => i,
-          :first_name => "First #{i}",
-          :last_name => "Last #{i}",
-          :hire_date => Time.local(2000,01,i)
+          employee_id: i,
+          first_name: "First #{i}",
+          last_name: "Last #{i}",
+          hire_date: Time.local(2000, 01, i)
         }
       end
       @employees.each do |e|
@@ -1757,7 +1869,7 @@ describe "Parameter type mapping /" do
 
     it "should return cursor and fetch first row" do
       expect(plsql.test_cursor do |cursor|
-        expect(cursor.fetch).to eq(@fields.map{|f| @employees[0][f]})
+        expect(cursor.fetch).to eq(@fields.map { |f| @employees[0][f] })
       end).to be_nil
     end
 
@@ -1766,7 +1878,7 @@ describe "Parameter type mapping /" do
       expect(plsql.test_cursor do |cursor|
         cursor2 = cursor
       end).to be_nil
-      expect { cursor2.fetch }.to raise_error
+      expect { cursor2.fetch }.to raise_error(/Cursor was already closed|Closed Statement/)
     end
 
     it "should not raise error if cursor is closed inside block" do
@@ -1785,7 +1897,7 @@ describe "Parameter type mapping /" do
 
     it "should fetch all rows from returned cursor" do
       plsql.test_cursor do |cursor|
-        expect(cursor.fetch_all).to eq(@employees.map{|e| @fields.map{|f| e[f]}})
+        expect(cursor.fetch_all).to eq(@employees.map { |e| @fields.map { |f| e[f] } })
       end
     end
 
@@ -1803,7 +1915,7 @@ describe "Parameter type mapping /" do
 
     it "should return output parameter with cursor and fetch first row" do
       expect(plsql.test_cursor_out do |result|
-        expect(result[:x_cursor].fetch).to eq(@fields.map{|f| @employees[0][f]})
+        expect(result[:x_cursor].fetch).to eq(@fields.map { |f| @employees[0][f] })
       end).to be_nil
     end
 
@@ -1853,7 +1965,7 @@ describe "Parameter type mapping /" do
       SQL
 
       @fields = [:col1, :col2 ]
-      @rows = (1..3).map{|i| ["row #{i}", i]}
+      @rows = (1..3).map { |i| ["row #{i}", i] }
       plsql.typed_ref_cursor_table.insert_values *@rows
       plsql.commit
 
@@ -1897,7 +2009,7 @@ describe "Synonyms /" do
   end
 
   describe "Local synonym to function" do
-  
+
     before(:all) do
       plsql.execute <<-SQL
         CREATE OR REPLACE FUNCTION hr.test_uppercase
@@ -1910,24 +2022,24 @@ describe "Synonyms /" do
       SQL
       plsql.execute "CREATE SYNONYM test_synonym FOR hr.test_uppercase"
     end
-  
+
     after(:all) do
       plsql.execute "DROP SYNONYM test_synonym"
       plsql.execute "DROP FUNCTION hr.test_uppercase"
     end
-  
+
     it "should find synonym to function" do
       expect(PLSQL::Procedure.find(plsql, :test_synonym)).not_to be_nil
     end
 
     it "should execute function using synonym and return correct value" do
-      expect(plsql.test_synonym('xxx')).to eq('XXX')
+      expect(plsql.test_synonym("xxx")).to eq("XXX")
     end
 
   end
 
   describe "Public synonym to function" do
-  
+
     before(:all) do
       plsql.execute <<-SQL
         CREATE OR REPLACE FUNCTION hr.test_ora_login_user
@@ -1938,17 +2050,17 @@ describe "Synonyms /" do
         END test_ora_login_user;
       SQL
     end
-  
+
     after(:all) do
       plsql.execute "DROP FUNCTION hr.test_ora_login_user"
     end
-  
+
     it "should find public synonym to function" do
       expect(PLSQL::Procedure.find(plsql, :ora_login_user)).not_to be_nil
     end
 
     it "should execute function using public synonym and return correct value" do
-      expect(plsql.ora_login_user).to eq('HR')
+      expect(plsql.ora_login_user).to eq("HR")
     end
 
     it "should not find public synonym if schema prefix is used" do
@@ -1960,10 +2072,10 @@ describe "Synonyms /" do
       plsql.connection = get_connection
       plsql.execute "DROP SYNONYM ora_login_user" rescue nil
       plsql.execute "CREATE SYNONYM ora_login_user FOR hr.test_ora_login_user"
-      expect(plsql.ora_login_user).to eq('XXX')
+      expect(plsql.ora_login_user).to eq("XXX")
       plsql.execute "DROP SYNONYM ora_login_user"
       plsql.connection = get_connection
-      expect(plsql.ora_login_user).to eq('HR')
+      expect(plsql.ora_login_user).to eq("HR")
     end
 
   end
@@ -2001,14 +2113,67 @@ describe "Synonyms /" do
 
     it "should raise error when invalid function is called" do
       expect {
-        plsql.test_invalid_function('test')
+        plsql.test_invalid_function("test")
       }.to raise_error(ArgumentError, /is not in valid status/)
     end
 
     it "should raise error when function from invalid package body is called" do
       expect {
-        plsql.test_invalid_package.test_invalid_function('test')
-      }.to raise_error(ArgumentError, /body is not in valid status/)
+        plsql.test_invalid_package.test_invalid_function("test")
+      }.to raise_error(oracle_error_class, /ORA-04063/)
+    end
+  end
+
+  describe "invalid objects that can be automatically recompiled" do
+    before(:all) do
+      plsql.execute "DROP TABLE test_recompilable_table" rescue nil
+      plsql.execute "CREATE TABLE test_recompilable_table (dummy VARCHAR2(10))"
+      plsql.execute <<-SQL
+        CREATE OR REPLACE FUNCTION test_recompilable_function(p_dummy VARCHAR2) RETURN VARCHAR2 IS
+          l_dummy test_recompilable_table.dummy%TYPE;
+        BEGIN
+          RETURN p_dummy;
+        END;
+      SQL
+      plsql.execute <<-SQL
+        CREATE OR REPLACE PACKAGE test_recompilable_package IS
+          FUNCTION test_recompilable_function(p_dummy VARCHAR2) RETURN VARCHAR2;
+        END;
+      SQL
+      plsql.execute <<-SQL
+        CREATE OR REPLACE PACKAGE BODY test_recompilable_package IS
+          FUNCTION test_recompilable_function(p_dummy VARCHAR2) RETURN VARCHAR2 IS
+            l_dummy test_recompilable_table.dummy%TYPE;
+          BEGIN
+            RETURN p_dummy;
+          END;
+        END;
+      SQL
+    end
+
+    before(:each) do
+      # Cause the dependent function and package to go into INVALID status
+      plsql.execute "ALTER TABLE test_recompilable_table MODIFY (dummy VARCHAR2(10))"
+    end
+
+    after(:all) do
+      plsql.execute "DROP TABLE test_recompilable_table"
+      plsql.execute "DROP FUNCTION test_recompilable_function"
+      plsql.execute "DROP PACKAGE test_recompilable_package"
+    end
+
+    it "should successfully call invalid function that can be recompiled" do
+      expect {
+        result = plsql.test_recompilable_function("test")
+        expect(result).to eq("test")
+      }.not_to raise_error
+    end
+
+    it "should successfully call invalid package body that can be recompiled" do
+      expect {
+        result = plsql.test_recompilable_package.test_recompilable_function("test")
+        expect(result).to eq("test")
+      }.not_to raise_error
     end
   end
 
@@ -2025,7 +2190,7 @@ describe "SYS.STANDARD procedures /" do
   end
 
   it "should execute function from SYS.STANDARD package" do
-    expect(plsql.upper('abc')).to eq('ABC')
+    expect(plsql.upper("abc")).to eq("ABC")
   end
 
   it "should find function overload based on types of sequential arguments" do
@@ -2033,16 +2198,193 @@ describe "SYS.STANDARD procedures /" do
     expect(plsql.nvl(nil, 2)).to eq(2)
     expect(plsql.nvl(1.1, 2.2)).to eq(1.1)
     expect(plsql.nvl(nil, 2.2)).to eq(2.2)
-    expect(plsql.nvl(BigDecimal('1.1'), BigDecimal('2.2'))).to eq(BigDecimal('1.1'))
-    expect(plsql.nvl(nil, BigDecimal('2.2'))).to eq(BigDecimal('2.2'))
-    expect(plsql.nvl('a', 'b')).to eq('a')
-    expect(plsql.nvl(nil, 'b')).to eq('b')
-    expect(plsql.nvl(Date.new(2010,1,13), Date.new(2010,1,19))).to eq(Time.local(2010,1,13))
-    expect(plsql.nvl(nil, Date.new(2010,1,19))).to eq(Time.local(2010,1,19))
-    expect(plsql.nvl(Time.local(2010,1,13), Time.local(2010,1,19))).to eq(Time.local(2010,1,13))
-    expect(plsql.nvl(nil, Time.local(2010,1,19))).to eq(Time.local(2010,1,19))
+    expect(plsql.nvl(BigDecimal("1.1"), BigDecimal("2.2"))).to eq(BigDecimal("1.1"))
+    expect(plsql.nvl(nil, BigDecimal("2.2"))).to eq(BigDecimal("2.2"))
+    expect(plsql.nvl("a", "b")).to eq("a")
+    expect(plsql.nvl(nil, "b")).to eq("b")
+    expect(plsql.nvl(Date.new(2010, 1, 13), Date.new(2010, 1, 19))).to eq(Time.local(2010, 1, 13))
+    expect(plsql.nvl(nil, Date.new(2010, 1, 19))).to eq(Time.local(2010, 1, 19))
+    expect(plsql.nvl(Time.local(2010, 1, 13), Time.local(2010, 1, 19))).to eq(Time.local(2010, 1, 13))
+    expect(plsql.nvl(nil, Time.local(2010, 1, 19))).to eq(Time.local(2010, 1, 19))
     expect(plsql.nvl(true, false)).to eq(true)
     expect(plsql.nvl(nil, false)).to eq(false)
   end
 
 end
+
+describe "PLS_INTEGER/SIMPLE_INTEGER should be nullable" do
+
+  before(:all) do
+    plsql.connect! CONNECTION_PARAMS
+    plsql.execute <<-SQL
+        CREATE OR REPLACE FUNCTION test_pls_f ( p_num PLS_INTEGER ) RETURN PLS_INTEGER IS
+        BEGIN
+          RETURN p_num;
+        END;
+    SQL
+    plsql.execute <<-SQL
+        CREATE OR REPLACE FUNCTION test_bin_f ( p_num BINARY_INTEGER ) RETURN BINARY_INTEGER IS
+        BEGIN
+          RETURN p_num;
+        END;
+    SQL
+    plsql.execute <<-SQL
+        CREATE OR REPLACE FUNCTION test_int_f ( p_num INTEGER ) RETURN INTEGER IS
+        BEGIN
+          RETURN p_num;
+        END;
+    SQL
+    plsql.execute <<-SQL
+        CREATE OR REPLACE PROCEDURE test_pls_p ( p_num IN OUT PLS_INTEGER ) IS
+        BEGIN
+          NULL;
+        END;
+    SQL
+    plsql.execute <<-SQL
+        CREATE OR REPLACE PROCEDURE test_bin_p ( p_num IN OUT BINARY_INTEGER ) IS
+        BEGIN
+          NULL;
+        END;
+    SQL
+    plsql.execute <<-SQL
+        CREATE OR REPLACE PROCEDURE test_int_p ( p_num IN OUT INTEGER ) IS
+        BEGIN
+          NULL;
+        END;
+    SQL
+    plsql.execute <<-SQL
+        CREATE OR REPLACE PROCEDURE test_flt_p ( p_num IN OUT BINARY_FLOAT ) IS
+        BEGIN
+          NULL;
+        END;
+    SQL
+    plsql.execute <<-SQL
+        CREATE OR REPLACE PROCEDURE test_dbl_p ( p_num IN OUT BINARY_DOUBLE ) IS
+        BEGIN
+          NULL;
+        END;
+    SQL
+  end
+
+  after(:all) do
+    plsql.execute "DROP FUNCTION test_pls_f"
+    plsql.execute "DROP FUNCTION test_bin_f"
+    plsql.execute "DROP FUNCTION test_int_f"
+    plsql.execute "DROP PROCEDURE test_pls_p"
+    plsql.execute "DROP PROCEDURE test_int_p"
+    plsql.execute "DROP PROCEDURE test_flt_p"
+    plsql.execute "DROP PROCEDURE test_dbl_p"
+    plsql.logoff
+  end
+
+  it "should return null for a function call with NULL PLS_INTEGER param" do
+    expect(plsql.test_pls_f(nil)).to be_nil
+  end
+
+  it "should return null for a function call with NULL BINARY_INTEGER param" do
+    expect(plsql.test_bin_f(nil)).to be_nil
+  end
+
+  it "should return null for a function call with NULL INTEGER param" do
+    expect(plsql.test_int_f(nil)).to be_nil
+  end
+
+  it "should return null for a procedure call with NULL PLS_INTEGER param" do
+    expect(plsql.test_pls_p(nil)[:p_num]).to be_nil
+  end
+
+  it "should return null for a procedure call with NULL BINARY_INTEGER param" do
+    expect(plsql.test_bin_p(nil)[:p_num]).to be_nil
+  end
+
+  it "should return null for a procedure call with NULL INTEGER param" do
+    expect(plsql.test_int_p(nil)[:p_num]).to be_nil
+  end
+
+  it "should return null for a procedure call with NULL BINARY_FLOAT param" do
+    expect(plsql.test_flt_p(nil)[:p_num]).to be_nil
+  end
+
+  it "should return null for a procedure call with NULL BINARY_DOUBLE param" do
+    expect(plsql.test_dbl_p(nil)[:p_num]).to be_nil
+  end
+
+end
+
+describe "#get_argument_metadata" do
+  before(:all) do
+    plsql.connect! CONNECTION_PARAMS
+  end
+
+  after(:all) do
+    plsql.logoff
+  end
+
+  before(:each) do
+    plsql.execute <<-SQL
+      CREATE OR REPLACE FUNCTION magic_number(p_num INTEGER #{defaulted_clause})
+        RETURN INTEGER
+      IS
+      BEGIN
+        RETURN p_num * 2;
+      END magic_number;
+    SQL
+  end
+
+  after(:each) do
+    plsql.execute "DROP FUNCTION magic_number"
+  end
+
+  context "on procedure with defaulted field" do
+    let(:defaulted_clause) { "DEFAULT 21" }
+
+    it 'field\'s metadata attribute "defaulted" is Y' do
+      procedure = PLSQL::Procedure.find(plsql, :magic_number)
+      expect(procedure.arguments[0][:p_num][:defaulted]).to eq("Y")
+    end
+  end
+
+  context "procedure without defaulted field" do
+    let(:defaulted_clause) { "" }
+
+    it 'field\'s metadata attribute "defaulted" is N' do
+      procedure = PLSQL::Procedure.find(plsql, :magic_number)
+      expect(procedure.arguments[0][:p_num][:defaulted]).to eq("N")
+    end
+  end
+
+  context "oracle <= 10g without defaulted functionality" do
+    let(:defaulted_clause) { "" }
+
+    it 'field\'s metadata attribute "defaulted" is nil' do
+      allow(plsql.connection).to receive(:database_version).and_return([10, 2, 0, 2])
+
+      procedure = PLSQL::Procedure.find(plsql, :magic_number)
+      expect(procedure.arguments[0][:p_num][:defaulted]).to be_nil
+    end
+  end
+end
+
+describe "case-insensitive params" do
+  before(:all) do
+    plsql.connect! CONNECTION_PARAMS
+    plsql.execute <<-SQL
+      CREATE OR REPLACE FUNCTION test_func
+        ( p_string VARCHAR2 )
+        RETURN VARCHAR2
+      IS
+      BEGIN
+        RETURN UPPER(p_string);
+      END test_func;
+    SQL
+  end
+
+  after(:all) do
+    plsql.execute "DROP FUNCTION test_func"
+    plsql.logoff
+  end
+
+  it "should call procedure/function with case-insensitive param names" do
+    expect { plsql.test_func(p_STRING: "xxx") }.not_to raise_error
+  end
+end