ruby-plsql 0.5.3 → 0.8.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,12 +31,19 @@ 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
+    plsql.connection = @conn
+    expected_current_schema = DATABASE_USERS_AND_PASSWORDS[1][0]
+    plsql.execute "ALTER SESSION set current_schema=#{expected_current_schema}"
+    expect(plsql.schema_name).to eq(expected_current_schema.upcase)
+  end
+
   it "should return new schema name after reconnection" do
     plsql.connection = @conn
     expect(plsql.schema_name).to eq(DATABASE_USERS_AND_PASSWORDS[0][0].upcase)
@@ -71,38 +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
-    }.to raise_error(/no listener|could not establish the connection/)
+      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 TZ environment variable" do
+  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['TZ'])
-  end
+    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
@@ -125,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
@@ -139,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
@@ -167,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
 
@@ -199,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
@@ -213,13 +220,30 @@ 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
+    if (plsql.connection.database_version <=> [18, 0, 0, 0]) >= 0
+      expect {
+        t1 = Thread.new { plsql.dbms_session.sleep(1) }.tap { |t| t.abort_on_exception = true }
+        t2 = Thread.new { plsql.dbms_session.sleep(2) }.tap { |t| t.abort_on_exception = true }
+        [t2, t1].each { |t| t.join }
+      }.not_to raise_error
+    else
+      expect {
+        t1 = Thread.new { plsql.dbms_lock.sleep(1) }.tap { |t| t.abort_on_exception = true }
+        t2 = Thread.new { plsql.dbms_lock.sleep(2) }.tap { |t| t.abort_on_exception = true }
+        [t2, t1].each { |t| t.join }
+      }.not_to raise_error
+    end
   end
+
 end if defined?(ActiveRecord)
 
 describe "DBMS_OUTPUT logging" 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
@@ -21,7 +21,7 @@ describe "SQL statements /" 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
@@ -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
@@ -8,7 +8,7 @@ describe "Table" do
       CREATE TABLE test_employees (
         employee_id   NUMBER(15) NOT NULL,
         first_name    VARCHAR2(50),
-        last_name     VARCHAR2(50),
+        last_name     VARCHAR(50),
         hire_date     DATE,
         created_at    TIMESTAMP,
         status        VARCHAR2(1) DEFAULT 'N'
@@ -35,7 +35,7 @@ describe "Table" do
       CREATE TABLE test_employees2 (
         employee_id   NUMBER(15) NOT NULL,
         first_name    VARCHAR2(50),
-        last_name     VARCHAR2(50),
+        last_name     VARCHAR(50),
         hire_date     DATE DEFAULT SYSDATE,
         address       t_address,
         phones        t_phones
@@ -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
@@ -215,6 +215,11 @@ describe "Table" do
       expect(plsql.test_employees2.all("ORDER BY employee_id")).to eq(@employees2)
     end
 
+    it "should insert with case-insensetive table name" do
+      plsql.test_employees.insert @employees.first.map { |k, v| [k.upcase.to_sym, v] }.to_h
+      expect(plsql.test_employees.all).to eq([@employees.first])
+    end
+
   end
 
   describe "insert values" do
@@ -245,7 +250,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 +268,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 +287,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 +295,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 +303,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 +322,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 +349,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 +361,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