ruby-plsql 0.6.0 → 0.7.0

data/spec/plsql/schema_spec.rb

@@ -1,15 +1,15 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe "Schema" do
-  
+
   it "should create Schema object" do
     expect(plsql.class).to eq(PLSQL::Schema)
   end
-  
+
 end
 
 describe "Schema connection" do
-  
+
   before(:each) do
     @conn = get_connection
   end
@@ -31,13 +31,13 @@ describe "Schema connection" do
     plsql(:hr).connection = @conn
     expect(plsql(:hr).connection.raw_connection).to eq(@conn)
   end
-  
+
   it "should return schema name" do
     plsql.connection = @conn
     expect(plsql.schema_name).to eq(DATABASE_USERS_AND_PASSWORDS[0][0].upcase)
   end
 
-  it 'should match altered current_schema in database session' do
+  it "should match altered current_schema in database session" do
     plsql.connection = @conn
     expected_current_schema = DATABASE_USERS_AND_PASSWORDS[1][0]
     plsql.execute "ALTER SESSION set current_schema=#{expected_current_schema}"
@@ -78,39 +78,38 @@ describe "Connection with connect!" do
   end
 
   it "should connect with username, password, host, port and database name" do
-    plsql.connect! @username, @password, :host => @host, :port => @port, :database => @database_service
+    plsql.connect! @username, @password, host: @host, port: @port, database: @database_service
     expect(plsql.connection).not_to be_nil
     expect(plsql.schema_name).to eq(@username.upcase)
   end
 
   it "should connect with username, password, host, database name and default port" do
     skip "Non-default port used for test database" unless @port == 1521
-    plsql.connect! @username, @password, :host => @host, :database => @database_service
+    plsql.connect! @username, @password, host: @host, database: @database_service
     expect(plsql.connection).not_to be_nil
     expect(plsql.schema_name).to eq(@username.upcase)
   end
 
   it "should not connect with wrong port number" do
     expect {
-      plsql.connect! @username, @password, :host => @host, :port => 9999, :database => @database
+      plsql.connect! @username, @password, host: @host, port: 9999, database: @database
     }.to raise_error(/ORA-12541|could not establish the connection/)
   end
 
   it "should connect with one Hash parameter" do
-    plsql.connect! :username => @username, :password => @password, :database => @database
+    plsql.connect! username: @username, password: @password, database: @database
     expect(plsql.connection).not_to be_nil
     expect(plsql.schema_name).to eq(@username.upcase)
   end
 
   it "should set session time zone from ORA_SDTZ environment variable" do
     plsql.connect! @username, @password, @database
-    expect(plsql.connection.time_zone).to eq(ENV['ORA_SDTZ'])
-  end if ENV['ORA_SDTZ']
-
+    expect(plsql.connection.time_zone).to eq(ENV["ORA_SDTZ"])
+  end if ENV["ORA_SDTZ"]
 
   it "should set session time zone from :time_zone parameter" do
-    plsql.connect! :username => @username, :password => @password, :database => @database, :time_zone => 'EET'
-    expect(plsql.connection.time_zone).to eq('EET')
+    plsql.connect! username: @username, password: @password, database: @database, time_zone: "EET"
+    expect(plsql.connection.time_zone).to eq("EET")
   end
 
 end
@@ -133,7 +132,7 @@ describe "Named Schema" do
   end
 
   it "should return schema name" do
-    expect(plsql.hr.schema_name).to eq('HR')
+    expect(plsql.hr.schema_name).to eq("HR")
   end
 
   it "should not find named schema if specified twice" do
@@ -147,8 +146,8 @@ describe "Schema commit and rollback" do
     plsql.connection = @conn = get_connection
     plsql.connection.autocommit = false
     plsql.execute "CREATE TABLE test_commit (dummy VARCHAR2(100))"
-    @data = {:dummy => 'test'}
-    @data2 = {:dummy => 'test2'}
+    @data = { dummy: "test" }
+    @data2 = { dummy: "test2" }
   end
 
   after(:all) do
@@ -175,10 +174,10 @@ describe "Schema commit and rollback" do
 
   it "should create savepoint and rollback to savepoint" do
     plsql.test_commit.insert @data
-    plsql.savepoint 'test'
+    plsql.savepoint "test"
     plsql.test_commit.insert @data2
     expect(plsql.test_commit.all).to eq([@data, @data2])
-    plsql.rollback_to 'test'
+    plsql.rollback_to "test"
     expect(plsql.test_commit.all).to eq([@data])
   end
 
@@ -207,7 +206,7 @@ describe "ActiveRecord connection" do
   end
 
   it "should return schema name" do
-    expect(plsql.schema_name).to eq('HR')
+    expect(plsql.schema_name).to eq("HR")
   end
 
   it "should use ActiveRecord::Base.default_timezone as default" do
@@ -221,12 +220,12 @@ describe "ActiveRecord connection" do
 
   it "should accept inherited ActiveRecord class" do
     plsql.activerecord_class = TestBaseModel
-    expect(plsql.schema_name).to eq('HR')
+    expect(plsql.schema_name).to eq("HR")
   end
 
   it "should accept subclass of inherited ActiveRecord class" do
     plsql.activerecord_class = TestModel
-    expect(plsql.schema_name).to eq('HR')
+    expect(plsql.schema_name).to eq("HR")
   end
 
   it "should safely close cursors in threaded environment" do

data/spec/plsql/sequence_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe "Table" do
   before(:all) do
@@ -64,4 +64,4 @@ describe "Table" do
     end
   end
 
-end
+end

data/spec/plsql/sql_statements_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe "SQL statements /" do
   before(:all) do
@@ -35,10 +35,10 @@ describe "SQL statements /" 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
       plsql.connection.prefetch_rows = 100

data/spec/plsql/table_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe "Table" do
   before(:all) do
@@ -43,28 +43,28 @@ describe "Table" 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),
-        :created_at => Time.local(2000,01,i,9,15,30,i),
-        :status => 'A'
+        employee_id: i,
+        first_name: "First #{i}",
+        last_name: "Last #{i}",
+        hire_date: Time.local(2000, 01, i),
+        created_at: Time.local(2000, 01, i, 9, 15, 30, i),
+        status: "A"
       }
     end
     @employees_all_fields = [:employee_id, :first_name, :last_name, :hire_date, :created_at, :status]
-    @employees_all_values = @employees.map{|e| @employees_all_fields.map{|f| e[f]}}
+    @employees_all_values = @employees.map { |e| @employees_all_fields.map { |f| e[f] } }
     @employees_some_fields = [:employee_id, :first_name, :last_name]
-    @employees_some_values = @employees.map{|e| @employees_some_fields.map{|f| e[f]}}
-    @employee_default_values = {:hire_date => nil, :created_at => nil, :status => 'N'}
+    @employees_some_values = @employees.map { |e| @employees_some_fields.map { |f| e[f] } }
+    @employee_default_values = { hire_date: nil, created_at: nil, status: "N" }
 
     @employees2 = (1..10).map do |i|
       {
-        :employee_id => i,
-        :first_name => "First #{i}",
-        :last_name => "Last #{i}",
-        :hire_date => Time.local(2000,01,i),
-        :address => {:street => "Street #{i}", :city => "City #{i}", :country => "County #{i}"},
-        :phones => [{:type => "mobile", :phone_number => "Mobile#{i}"}, {:type => "fixed", :phone_number => "Fixed#{i}"}]
+        employee_id: i,
+        first_name: "First #{i}",
+        last_name: "Last #{i}",
+        hire_date: Time.local(2000, 01, i),
+        address: { street: "Street #{i}", city: "City #{i}", country: "County #{i}" },
+        phones: [{ type: "mobile", phone_number: "Mobile#{i}" }, { type: "fixed", phone_number: "Fixed#{i}" }]
       }
     end
   end
@@ -137,49 +137,49 @@ describe "Table" do
     end
 
     it "should get columns metadata for table" do
-      expect(plsql.test_employees.columns).to eq({
-        :employee_id => {
-          :position=>1, :data_type=>"NUMBER", :data_length=>22, :data_precision=>15, :data_scale=>0, :char_used=>nil,
-          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => false, :data_default => nil},
-        :first_name => {
-          :position=>2, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :char_used=>"B",
-          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => nil},
-        :last_name => {
-          :position=>3, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :char_used=>"B",
-          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => nil},
-        :hire_date => {
-          :position=>4, :data_type=>"DATE", :data_length=>7, :data_precision=>nil, :data_scale=>nil, :char_used=>nil,
-          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => nil},
-        :created_at => {
-          :position=>5, :data_type=>"TIMESTAMP", :data_length=>11, :data_precision=>nil, :data_scale=>6, :char_used=>nil,
-          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => nil},
-        :status => {
-          :position=>6, :data_type=>"VARCHAR2", :data_length=>1, :data_precision=>nil, :data_scale=>nil, :char_used=>"B",
-          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => "'N'"}
-      })
+      expect(plsql.test_employees.columns).to eq(
+        employee_id: {
+          position: 1, data_type: "NUMBER", data_length: 22, data_precision: 15, data_scale: 0, char_used: nil,
+          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: false, data_default: nil },
+        first_name: {
+          position: 2, data_type: "VARCHAR2", data_length: 50, data_precision: nil, data_scale: nil, char_used: "B",
+          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: nil },
+        last_name: {
+          position: 3, data_type: "VARCHAR2", data_length: 50, data_precision: nil, data_scale: nil, char_used: "B",
+          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: nil },
+        hire_date: {
+          position: 4, data_type: "DATE", data_length: 7, data_precision: nil, data_scale: nil, char_used: nil,
+          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: nil },
+        created_at: {
+          position: 5, data_type: "TIMESTAMP", data_length: 11, data_precision: nil, data_scale: 6, char_used: nil,
+          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: nil },
+        status: {
+          position: 6, data_type: "VARCHAR2", data_length: 1, data_precision: nil, data_scale: nil, char_used: "B",
+          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: "'N'" }
+      )
     end
 
     it "should get columns metadata for table with object columns" do
-      expect(plsql.test_employees2.columns).to eq({
-        :employee_id => {
-          :position=>1, :data_type=>"NUMBER", :data_length=>22, :data_precision=>15, :data_scale=>0, :char_used=>nil,
-          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => false, :data_default => nil},
-        :first_name => {
-          :position=>2, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :char_used=>"B",
-          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => nil},
-        :last_name => {
-          :position=>3, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :char_used=>"B",
-          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => nil},
-        :hire_date => {
-          :position=>4, :data_type=>"DATE", :data_length=>7, :data_precision=>nil, :data_scale=>nil, :char_used=>nil,
-          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => "SYSDATE"},
-        :address => {
-          :position=>5, :data_type=>"OBJECT", :data_length=>nil, :data_precision=>nil, :data_scale=>nil,
-          :char_used=>nil, :type_owner=>"HR", :type_name=>"T_ADDRESS", :sql_type_name=>"HR.T_ADDRESS", :nullable => true, :data_default => nil},
-        :phones => {
-          :position=>6, :data_type=>"TABLE", :data_length=>nil, :data_precision=>nil, :data_scale=>nil, :char_used=>nil,
-          :type_owner=>"HR", :type_name=>"T_PHONES", :sql_type_name=>"HR.T_PHONES", :nullable => true, :data_default => nil}
-      })
+      expect(plsql.test_employees2.columns).to eq(
+        employee_id: {
+          position: 1, data_type: "NUMBER", data_length: 22, data_precision: 15, data_scale: 0, char_used: nil,
+          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: false, data_default: nil },
+        first_name: {
+          position: 2, data_type: "VARCHAR2", data_length: 50, data_precision: nil, data_scale: nil, char_used: "B",
+          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: nil },
+        last_name: {
+          position: 3, data_type: "VARCHAR2", data_length: 50, data_precision: nil, data_scale: nil, char_used: "B",
+          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: nil },
+        hire_date: {
+          position: 4, data_type: "DATE", data_length: 7, data_precision: nil, data_scale: nil, char_used: nil,
+          type_owner: nil, type_name: nil, sql_type_name: nil, nullable: true, data_default: "SYSDATE" },
+        address: {
+          position: 5, data_type: "OBJECT", data_length: nil, data_precision: nil, data_scale: nil,
+          char_used: nil, type_owner: "HR", type_name: "T_ADDRESS", sql_type_name: "HR.T_ADDRESS", nullable: true, data_default: nil },
+        phones: {
+          position: 6, data_type: "TABLE", data_length: nil, data_precision: nil, data_scale: nil, char_used: nil,
+          type_owner: "HR", type_name: "T_PHONES", sql_type_name: "HR.T_PHONES", nullable: true, data_default: nil }
+      )
     end
 
   end
@@ -192,12 +192,12 @@ describe "Table" do
 
     it "should insert a record in table using partial list of columns" do
       plsql.test_employees.insert @employees.first.except(:hire_date)
-      expect(plsql.test_employees.all).to eq([@employees.first.merge(:hire_date => nil)])
+      expect(plsql.test_employees.all).to eq([@employees.first.merge(hire_date: nil)])
     end
 
     it "should insert default value from table definition if value not provided" do
       plsql.test_employees.insert @employees.first.except(:status)
-      expect(plsql.test_employees.all).to eq([@employees.first.merge(:status => 'N')])
+      expect(plsql.test_employees.all).to eq([@employees.first.merge(status: "N")])
     end
 
     it "should insert array of records in table" do
@@ -245,7 +245,7 @@ describe "Table" do
 
     it "should insert many records with list of some fields and array of values" do
       plsql.test_employees.insert_values @employees_some_fields, *@employees_some_values
-      expect(plsql.test_employees.all).to eq(@employees.map{|e| e.merge(@employee_default_values)})
+      expect(plsql.test_employees.all).to eq(@employees.map { |e| e.merge(@employee_default_values) })
     end
 
   end
@@ -263,17 +263,17 @@ describe "Table" do
     it "should select all records in table" do
       expect(plsql.test_employees.select(:all, "ORDER BY employee_id")).to eq(@employees)
       expect(plsql.test_employees.all("ORDER BY employee_id")).to eq(@employees)
-      expect(plsql.test_employees.all(:order_by => :employee_id)).to eq(@employees)
+      expect(plsql.test_employees.all(order_by: :employee_id)).to eq(@employees)
     end
 
     it "should select record in table using WHERE condition" do
       expect(plsql.test_employees.select(:first, "WHERE employee_id = :1", @employees.first[:employee_id])).to eq(@employees.first)
       expect(plsql.test_employees.first("WHERE employee_id = :1", @employees.first[:employee_id])).to eq(@employees.first)
-      expect(plsql.test_employees.first(:employee_id => @employees.first[:employee_id])).to eq(@employees.first)
+      expect(plsql.test_employees.first(employee_id: @employees.first[:employee_id])).to eq(@employees.first)
     end
 
     it "should select records in table using WHERE condition and ORDER BY sorting" do
-      expect(plsql.test_employees.all(:employee_id => @employees.first[:employee_id], :order_by => :employee_id)).to eq([@employees.first])
+      expect(plsql.test_employees.all(employee_id: @employees.first[:employee_id], order_by: :employee_id)).to eq([@employees.first])
     end
 
     it "should select record in table using :column => nil condition" do
@@ -282,7 +282,7 @@ describe "Table" do
       employee[:hire_date] = nil
       plsql.test_employees.insert employee
       expect(plsql.test_employees.first("WHERE hire_date IS NULL")).to eq(employee)
-      expect(plsql.test_employees.first(:hire_date => nil)).to eq(employee)
+      expect(plsql.test_employees.first(hire_date: nil)).to eq(employee)
     end
 
     it "should select record in table using :column => :is_null condition" do
@@ -290,7 +290,7 @@ describe "Table" do
       employee[:employee_id] = employee[:employee_id] + 1
       employee[:hire_date] = nil
       plsql.test_employees.insert employee
-      expect(plsql.test_employees.first(:hire_date => :is_null)).to eq(employee)
+      expect(plsql.test_employees.first(hire_date: :is_null)).to eq(employee)
     end
 
     it "should select record in table using :column => :is_not_null condition" do
@@ -298,7 +298,7 @@ describe "Table" do
       employee[:employee_id] = employee[:employee_id] + 1
       employee[:hire_date] = nil
       plsql.test_employees.insert employee
-      expect(plsql.test_employees.all(:hire_date => :is_not_null, :order_by => :employee_id)).to eq(@employees)
+      expect(plsql.test_employees.all(hire_date: :is_not_null, order_by: :employee_id)).to eq(@employees)
     end
 
     it "should count records in table" do
@@ -317,26 +317,26 @@ describe "Table" do
     it "should update a record in table" do
       employee_id = @employees.first[:employee_id]
       plsql.test_employees.insert @employees.first
-      plsql.test_employees.update :first_name => 'Test', :where => {:employee_id => employee_id}
-      expect(plsql.test_employees.first(:employee_id => employee_id)[:first_name]).to eq('Test')
+      plsql.test_employees.update first_name: "Test", where: { employee_id: employee_id }
+      expect(plsql.test_employees.first(employee_id: employee_id)[:first_name]).to eq("Test")
     end
 
     it "should update a record in table using String WHERE condition" do
       employee_id = @employees.first[:employee_id]
       plsql.test_employees.insert @employees
-      plsql.test_employees.update :first_name => 'Test', :where => "employee_id = #{employee_id}"
-      expect(plsql.test_employees.first(:employee_id => employee_id)[:first_name]).to eq('Test')
+      plsql.test_employees.update first_name: "Test", where: "employee_id = #{employee_id}"
+      expect(plsql.test_employees.first(employee_id: employee_id)[:first_name]).to eq("Test")
       # all other records should not be changed
       plsql.test_employees.all("WHERE employee_id > :1", employee_id) do |employee|
-        expect(employee[:first_name]).not_to eq('Test')
+        expect(employee[:first_name]).not_to eq("Test")
       end
     end
 
     it "should update all records in table" do
       plsql.test_employees.insert @employees
-      plsql.test_employees.update :first_name => 'Test'
+      plsql.test_employees.update first_name: "Test"
       plsql.test_employees.all do |employee|
-        expect(employee[:first_name]).to eq('Test')
+        expect(employee[:first_name]).to eq("Test")
       end
     end
 
@@ -344,8 +344,8 @@ describe "Table" do
       employee = @employees2[0]
       employee2 = @employees2[1]
       plsql.test_employees2.insert employee
-      plsql.test_employees2.update :address => employee2[:address], :phones => employee2[:phones], :where => {:employee_id => employee[:employee_id]}
-      updated_employee = plsql.test_employees2.first(:employee_id => employee[:employee_id])
+      plsql.test_employees2.update address: employee2[:address], phones: employee2[:phones], where: { employee_id: employee[:employee_id] }
+      updated_employee = plsql.test_employees2.first(employee_id: employee[:employee_id])
       expect(updated_employee[:address]).to eq(employee2[:address])
       expect(updated_employee[:phones]).to eq(employee2[:phones])
     end
@@ -356,9 +356,9 @@ describe "Table" do
     it "should delete record from table" do
       employee_id = @employees.first[:employee_id]
       plsql.test_employees.insert @employees
-      plsql.test_employees.delete :employee_id => employee_id
-      expect(plsql.test_employees.first(:employee_id => employee_id)).to be_nil
-      expect(plsql.test_employees.all(:order_by => :employee_id)).to eq(@employees[1, @employees.size-1])
+      plsql.test_employees.delete employee_id: employee_id
+      expect(plsql.test_employees.first(employee_id: employee_id)).to be_nil
+      expect(plsql.test_employees.all(order_by: :employee_id)).to eq(@employees[1, @employees.size - 1])
     end
 
     it "should delete all records from table" do

data/spec/plsql/type_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe "Type" do
   before(:all) do
@@ -167,28 +167,22 @@ describe "Type" do
     end
 
     it "should get attributes metadata" do
-      expect(plsql.t_employee.attributes).to eq({
-        :employee_id =>
-          {:position=>1, :data_type=>"NUMBER", :data_length=>nil, :data_precision=>15, :data_scale=>0, :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil},
-        :first_name =>
-          {:position=>2, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil},
-        :last_name =>
-          {:position=>3, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil},
-        :hire_date => 
-          {:position=>4, :data_type=>"DATE", :data_length=>nil, :data_precision=>nil, :data_scale=>nil, :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil},
-        :address => 
-          {:position=>5, :data_type=>"OBJECT", :data_length=>nil, :data_precision=>nil, :data_scale=>nil, :type_owner=>"HR", :type_name=>"T_ADDRESS", :sql_type_name=>"HR.T_ADDRESS"},
-        :phones => 
-          {:position=>6, :data_type=>"TABLE", :data_length=>nil, :data_precision=>nil, :data_scale=>nil, :type_owner=>"HR", :type_name=>"T_PHONES", :sql_type_name=>"HR.T_PHONES"}
-      })
+      expect(plsql.t_employee.attributes).to eq(
+        employee_id:           { position: 1, data_type: "NUMBER", data_length: nil, data_precision: 15, data_scale: 0, type_owner: nil, type_name: nil, sql_type_name: nil },
+        first_name:           { position: 2, data_type: "VARCHAR2", data_length: 50, data_precision: nil, data_scale: nil, type_owner: nil, type_name: nil, sql_type_name: nil },
+        last_name:           { position: 3, data_type: "VARCHAR2", data_length: 50, data_precision: nil, data_scale: nil, type_owner: nil, type_name: nil, sql_type_name: nil },
+        hire_date:           { position: 4, data_type: "DATE", data_length: nil, data_precision: nil, data_scale: nil, type_owner: nil, type_name: nil, sql_type_name: nil },
+        address:           { position: 5, data_type: "OBJECT", data_length: nil, data_precision: nil, data_scale: nil, type_owner: "HR", type_name: "T_ADDRESS", sql_type_name: "HR.T_ADDRESS" },
+        phones:           { position: 6, data_type: "TABLE", data_length: nil, data_precision: nil, data_scale: nil, type_owner: "HR", type_name: "T_PHONES", sql_type_name: "HR.T_PHONES" }
+      )
     end
 
   end
 
   describe "object instance" do
     before(:all) do
-      @phone_attributes = {:type => 'mobile', :phone_number => '123456'}
-      @address_attributes = {:street => 'Street', :city => 'City', :country => 'Country'}
+      @phone_attributes = { type: "mobile", phone_number: "123456" }
+      @address_attributes = { street: "Street", city: "City", country: "Country" }
       @full_address = "#{@address_attributes[:street]}, #{@address_attributes[:city]}, #{@address_attributes[:country]}"
     end
 
@@ -206,7 +200,7 @@ describe "Type" do
 
     it "should get new object instance using custom constructor" do
       expect(plsql.t_address(@full_address)).to eq(@address_attributes)
-      expect(plsql.t_address(:p_full_address => @full_address)).to eq(@address_attributes)
+      expect(plsql.t_address(p_full_address: @full_address)).to eq(@address_attributes)
     end
 
     it "should get new object instance using default constructor when custom constructor exists" do
@@ -230,7 +224,7 @@ describe "Type" do
 
   describe "member procedures" do
     before(:all) do
-      @address_attributes = {:street => 'Street', :city => 'City', :country => 'Country'}
+      @address_attributes = { street: "Street", city: "City", country: "Country" }
       @full_address = "#{@address_attributes[:street]}, #{@address_attributes[:city]}, #{@address_attributes[:country]}"
     end
 
@@ -239,36 +233,36 @@ describe "Type" do
     end
 
     it "should call object instance member function with parameters" do
-      expect(plsql.t_address(@address_attributes).display_address(',')).to eq(@full_address)
+      expect(plsql.t_address(@address_attributes).display_address(",")).to eq(@full_address)
     end
 
     it "should call object instance member function with named parameters" do
-      expect(plsql.t_address(@address_attributes).display_address(:p_separator => ',')).to eq(@full_address)
+      expect(plsql.t_address(@address_attributes).display_address(p_separator: ",")).to eq(@full_address)
     end
 
     it "should call object overloaded instance member function" do
       expect(plsql.t_address(@address_attributes).display_address(true)).to eq(@full_address.upcase)
-      expect(plsql.t_address(@address_attributes).display_address(true, ',')).to eq(@full_address.upcase)
+      expect(plsql.t_address(@address_attributes).display_address(true, ",")).to eq(@full_address.upcase)
     end
 
     it "should call object instance member function with explicit first SELF parameter" do
-      expect(plsql.t_address.display_address(@address_attributes, ',')).to eq(@full_address)
+      expect(plsql.t_address.display_address(@address_attributes, ",")).to eq(@full_address)
     end
 
     it "should call object instance member function with explicit named SELF parameter" do
-      expect(plsql.t_address.display_address(:self => @address_attributes, :p_separator => ',')).to eq(@full_address)
+      expect(plsql.t_address.display_address(self: @address_attributes, p_separator: ",")).to eq(@full_address)
     end
 
     it "should call object instance member procedure" do
       other_country = "Other"
-      expect(plsql.t_address(@address_attributes).set_country(other_country)).to eq(@address_attributes.merge(:country => other_country))
+      expect(plsql.t_address(@address_attributes).set_country(other_country)).to eq(@address_attributes.merge(country: other_country))
     end
 
     it "should call object instance member procedure with output parameters" do
       other_country = "Other"
       expect(plsql.t_address(@address_attributes).set_country2(other_country)).to eq(
-        [@address_attributes.merge(:country => other_country),
-        {:x_display_address => "#{@address_attributes[:street]}, #{@address_attributes[:city]}, #{other_country}"}]
+        [@address_attributes.merge(country: other_country),
+        { x_display_address: "#{@address_attributes[:street]}, #{@address_attributes[:city]}, #{other_country}" }]
       )
     end
 
@@ -282,7 +276,7 @@ describe "Type" do
 
   describe "static procedures" do
     before(:all) do
-      @address_attributes = {:street => 'Street', :city => 'City', :country => 'Country'}
+      @address_attributes = { street: "Street", city: "City", country: "Country" }
       @full_address = "#{@address_attributes[:street]}, #{@address_attributes[:city]}, #{@address_attributes[:country]}"
     end
 
@@ -291,7 +285,7 @@ describe "Type" do
     end
 
     it "should call object type static function with named parameters" do
-      expect(plsql.t_address.create_address(:p_full_address => @full_address)).to eq(@address_attributes)
+      expect(plsql.t_address.create_address(p_full_address: @full_address)).to eq(@address_attributes)
     end
 
     it "should raise error if invalid static procedure is called" do