ruby-plsql 0.5.0 → 0.5.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ce8ef00f5273841d619be6cb08c25d09abd45078
+  data.tar.gz: f77984b605d43abeec8805ad021fc329cbc011a3
+SHA512:
+  metadata.gz: daceb0231b71f9f41e782d66f07327dea768c84be2925de9ef4ba8054d086be372ea19579a77399fcc03ef1cb67d85d8fecd5dd46b54bafaad4272c1d0b309f8
+  data.tar.gz: 6b300a47e477130f096af709b4c70b56f421981989d4b761c4559d02f1a975e32f57879639502f19d8aba6bc5d76a4589ac06862149d10746332c710e0ca19b9

data/Gemfile

@@ -1,14 +1,16 @@
 source 'http://rubygems.org'
 
 group :development do
-  gem 'jeweler', '~> 1.8.3'
-  gem 'rspec', '~> 2.9'
+  gem 'jeweler', '~> 2.0.1'
+  gem 'rspec', '~> 3.1'
 
   unless ENV['NO_ACTIVERECORD']
-    gem 'activerecord', '~> 3.2.3'
-    gem 'activerecord-oracle_enhanced-adapter', '~> 1.4.1'
+    gem 'activerecord', '>= 3.2.3', '< 4.2.0'
+    gem 'activerecord-oracle_enhanced-adapter', '>= 1.4.1', '< 1.6.0'
+    gem 'simplecov', '>= 0'
   end
 
-  # gem 'ruby-oci8', '~> 2.1.0'
-  gem 'ruby-oci8', :git => 'git://github.com/kubo/ruby-oci8.git', :platforms => :mri
+  platforms :ruby do
+    gem 'ruby-oci8', '~> 2.1.2'
+  end
 end

data/History.txt

@@ -1,3 +1,17 @@
+== 0.5.1 2014-10-12
+* Improvements
+  * Support for Oracle Ehnanced Adapter 1.5 and ActiveRecord 4.1, 4.2
+  * Oracle 12c support
+  * Better diagnostics output when ruby-oci8 initialization fails
+* Bug fixes
+  * Support for ruby-oci8 2.1.2+ preventing segfaults
+  * Multi-thread support (applies to oci8 connections)
+* Internal (development) improvements
+  * Tests database connection enhancements (eazy connect syntax, allow service name != db name)
+  * Tests migrated to rspec 3
+  * Tests coverage migrated from rcov to simplecov
+  * README update with how to run tests
+
 == 0.5.0 2012-04-16
 
 * Improvements

data/README.md

@@ -10,7 +10,7 @@ ruby-plsql gem provides simple Ruby API for calling Oracle PL/SQL procedures. It
 
 NUMBER, BINARY_INTEGER, PLS_INTEGER, VARCHAR2, NVARCHAR2, CHAR, NCHAR, DATE, TIMESTAMP, CLOB, BLOB, BOOLEAN, PL/SQL RECORD, TABLE, VARRAY, OBJECT and CURSOR types are supported for input and output parameters and return values of PL/SQL procedures and functions.
 
-ruby-plsql supports Ruby 1.8.7, 1.9.3 and JRuby 1.6.7 implementations.
+ruby-plsql supports Ruby 1.8.7, 1.9.3, 2.1.3 and JRuby 1.6.7, 1.7.16 implementations.
 
 USAGE
 -----
@@ -127,16 +127,38 @@ or include gem in Gemfile if using bundler.
 
 In addition install either ruby-oci8 (for MRI/YARV) or copy Oracle JDBC driver to $JRUBY_HOME/lib (for JRuby).
 
-If you are using MRI 1.8 or 1.9 Ruby implementation then you need to install ruby-oci8 gem (version 2.0.x or 2.1.x)
+If you are using MRI 1.8, 1.9 or 2.x Ruby implementation then you need to install ruby-oci8 gem (version 2.0.x or 2.1.x)
 as well as Oracle client, e.g. [Oracle Instant Client](http://www.oracle.com/technetwork/database/features/instant-client/index-097480.html).
 
-If you are using JRuby then you need to download latest [Oracle JDBC driver](http://www.oracle.com/technetwork/database/enterprise-edition/jdbc-112010-090769.html) - either ojdbc6.jar for Java 6 or ojdbc5.jar for Java 5. And copy this file to one of these locations:
+If you are using JRuby then you need to download latest [Oracle JDBC driver](http://www.oracle.com/technetwork/database/enterprise-edition/jdbc-112010-090769.html) - either ojdbc6.jar for Java 6, 7, 8 or ojdbc5.jar for Java 5. And copy this file to one of these locations:
 
 * in `./lib` directory of Rails application and require it manually
 * in some directory which is in `PATH`
 * in `JRUBY_HOME/lib` directory
 * or include path to JDBC driver jar file in Java `CLASSPATH`
 
+TESTS
+-----
+
+* Create Oracle database schema for test purposes. Review `spec/spec_helper.rb` to see default schema/user names and database names (use environment variables to override defaults)
+
+        SQL> CREATE USER hr IDENTIFIED BY hr;
+        SQL> GRANT unlimited tablespace, create session, create table, create sequence, create procedure, create type, create view, create synonym TO hr;
+
+        SQL> CREATE USER arunit IDENTIFIED BY arunit;
+        SQL> GRANT create session TO arunit;
+
+* Install bundler with
+
+        gem install bundler
+
+* Install necessary gems with
+
+        bundle install
+
+* Run tests with
+
+        rake spec
 
 LINKS
 -----
@@ -154,13 +176,14 @@ CONTRIBUTORS
 * Wiehann Matthysen
 * Dayle Larson
 * Yasuo Honda
+* Yavor Nikolov
 
 LICENSE
 -------
 
 (The MIT License)
 
-Copyright (c) 2008-2012 Raimonds Simanovskis
+Copyright (c) 2008-2014 Raimonds Simanovskis
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -179,4 +202,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -29,9 +29,10 @@ Jeweler::RubygemsDotOrgTasks.new
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
-RSpec::Core::RakeTask.new(:rcov) do |t|
-  t.rcov = true
-  t.rcov_opts =  ['--exclude', '/Library,spec/']
+desc "Code coverage detail"
+task :simplecov do
+  ENV['COVERAGE'] = "true"
+  Rake::Task['spec'].execute
 end
 
 task :default => :spec

data/VERSION

@@ -1 +1 @@
-0.5.0
+0.5.1

data/lib/plsql/jdbc_connection.rb

@@ -39,10 +39,12 @@ module PLSQL
   class JDBCConnection < Connection  #:nodoc:
 
     def self.create_raw(params)
-      url = if ENV['TNS_ADMIN'] && params[:database] && !params[:host] && !params[:url]
-        "jdbc:oracle:thin:@#{params[:database]}"
+      database = params[:database]
+      url = if ENV['TNS_ADMIN'] && database && !params[:host] && !params[:url]
+        "jdbc:oracle:thin:@#{database}"
       else
-        params[:url] || "jdbc:oracle:thin:@#{params[:host] || 'localhost'}:#{params[:port] || 1521}:#{params[:database]}"
+        database = ":#{database}" unless database.match(/^(\:|\/)/)
+        params[:url] || "jdbc:oracle:thin:@#{params[:host] || 'localhost'}:#{params[:port] || 1521}#{database}"
       end
       new(java.sql.DriverManager.getConnection(url, params[:username], params[:password]))
     end
@@ -539,4 +541,4 @@ module PLSQL
     
   end
   
-end
+end

data/lib/plsql/oci_connection.rb

@@ -2,7 +2,16 @@ begin
   require "oci8"
 rescue LoadError
   # OCI8 driver is unavailable.
-  raise LoadError, "ERROR: ruby-plsql could not load ruby-oci8 library. Please install ruby-oci8 gem."
+  msg = $!.to_s
+  if /-- oci8$/ =~ msg
+    # ruby-oci8 is not installed.
+    # MRI <= 1.9.2, Rubinius, JRuby:
+    #   no such file to load -- oci8
+    # MRI >= 1.9.3:
+    #   cannot load such file -- oci8
+    msg = "Please install ruby-oci8 gem."
+  end
+  raise LoadError, "ERROR: ruby-plsql could not load ruby-oci8 library. #{msg}"
 end
 
 require "plsql/oci8_patches"

data/lib/plsql/procedure.rb

@@ -4,21 +4,28 @@ module PLSQL
     def find(schema, procedure, package = nil, override_schema_name = nil)
       if package.nil?
         if (row = schema.select_first(
-            "SELECT object_id FROM all_objects
-            WHERE owner = :owner
-              AND object_name = :object_name
-              AND object_type IN ('PROCEDURE','FUNCTION')",
+            "SELECT #{procedure_object_id_src(schema)}.object_id
+            FROM all_procedures p, all_objects o
+            WHERE p.owner = :owner
+              AND p.object_name = :object_name
+              AND o.owner = p.owner
+              AND o.object_name = p.object_name
+              AND o.object_type = p.object_type
+              AND o.object_type in ('PROCEDURE', 'FUNCTION')",
             schema.schema_name, procedure.to_s.upcase))
           new(schema, procedure, nil, nil, row[0])
         # search for synonym
         elsif (row = schema.select_first(
-            "SELECT o.owner, o.object_name, o.object_id
-            FROM all_synonyms s, all_objects o
+            "SELECT o.owner, o.object_name, #{procedure_object_id_src(schema)}.object_id
+            FROM all_synonyms s, all_objects o, all_procedures p
             WHERE s.owner IN (:owner, 'PUBLIC')
               AND s.synonym_name = :synonym_name
               AND o.owner = s.table_owner
               AND o.object_name = s.table_name
               AND o.object_type IN ('PROCEDURE','FUNCTION')
+              AND o.owner = p.owner
+              AND o.object_name = p.object_name
+              AND o.object_type = p.object_type
               ORDER BY DECODE(s.owner, 'PUBLIC', 1, 0)",
             schema.schema_name, procedure.to_s.upcase))
           new(schema, row[1], nil, row[0], row[2])
@@ -27,12 +34,14 @@ module PLSQL
         end
       elsif package && (row = schema.select_first(
             # older Oracle versions do not have object_id column in all_procedures
-            "SELECT o.object_id FROM all_procedures p, all_objects o
+            "SELECT #{procedure_object_id_src(schema)}.object_id
+            FROM all_procedures p, all_objects o
             WHERE p.owner = :owner
               AND p.object_name = :object_name
               AND p.procedure_name = :procedure_name
               AND o.owner = p.owner
               AND o.object_name = p.object_name
+              AND o.object_type = p.object_type
               AND o.object_type = 'PACKAGE'",
             override_schema_name || schema.schema_name, package, procedure.to_s.upcase))
         new(schema, procedure, package, override_schema_name, row[0])
@@ -40,6 +49,12 @@ module PLSQL
         nil
       end
     end
+
+    private
+
+    def procedure_object_id_src(schema)
+      (schema.connection.database_version <=> [11, 1, 0, 0]) >= 0 ? "p" : "o"
+    end
   end
 
   module ProcedureCommon #:nodoc:
@@ -254,4 +269,4 @@ module PLSQL
 
   end
 
-end
+end

data/lib/plsql/schema.rb

@@ -41,7 +41,7 @@ module PLSQL
     # or
     #
     #   plsql.connection = java.sql.DriverManager.getConnection(
-    #     "jdbc:oracle:thin:@#{database_host}:#{database_port}:#{database_name}",
+    #     "jdbc:oracle:thin:@#{database_host}:#{database_port}/#{database_service_name}",
     #     database_user, database_password)
     #
     def connection=(conn)
@@ -210,6 +210,15 @@ module PLSQL
           _errors(object_schema_name, object_name, 'PACKAGE BODY')}" if body_status == 'INVALID'
         case object_type
         when 'PROCEDURE', 'FUNCTION'
+          if (connection.database_version <=> [11, 1, 0, 0]) >= 0
+            row = select_first(
+              "SELECT p.object_id FROM all_procedures p
+               WHERE p.owner = :owner
+                 AND p.object_name = :object_name
+                 AND p.object_type = :object_type",
+               object_schema_name, object_name, object_type)
+            object_id = row[0]
+          end
           Procedure.new(self, name, nil, override_schema_name, object_id)
         when 'PACKAGE'
           Package.new(self, name, override_schema_name)

data/ruby-plsql.gemspec

@@ -2,14 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+# stub: ruby-plsql 0.5.1 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "ruby-plsql"
-  s.version = "0.5.0"
+  s.version = "0.5.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
   s.authors = ["Raimonds Simanovskis"]
-  s.date = "2012-04-16"
+  s.date = "2014-10-12"
   s.description = "ruby-plsql gem provides simple Ruby API for calling Oracle PL/SQL procedures.\nIt could be used both for accessing Oracle PL/SQL API procedures in legacy applications\nas well as it could be used to create PL/SQL unit tests using Ruby testing libraries.\n"
   s.email = "raimonds.simanovskis@gmail.com"
   s.extra_rdoc_files = [
@@ -56,32 +58,34 @@ Gem::Specification.new do |s|
     "spec/spec_helper.rb"
   ]
   s.homepage = "http://github.com/rsim/ruby-plsql"
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.11"
+  s.rubygems_version = "2.2.2"
   s.summary = "Ruby API for calling Oracle PL/SQL procedures."
 
   if s.respond_to? :specification_version then
-    s.specification_version = 3
+    s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
-      s.add_development_dependency(%q<rspec>, ["~> 2.9"])
-      s.add_development_dependency(%q<activerecord>, ["~> 3.2.3"])
-      s.add_development_dependency(%q<activerecord-oracle_enhanced-adapter>, ["~> 1.4.1"])
-      s.add_development_dependency(%q<ruby-oci8>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 2.0.1"])
+      s.add_development_dependency(%q<rspec>, ["~> 3.1"])
+      s.add_development_dependency(%q<activerecord>, ["< 4.2.0", ">= 3.2.3"])
+      s.add_development_dependency(%q<activerecord-oracle_enhanced-adapter>, ["< 1.6.0", ">= 1.4.1"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+      s.add_development_dependency(%q<ruby-oci8>, ["~> 2.1.2"])
     else
-      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
-      s.add_dependency(%q<rspec>, ["~> 2.9"])
-      s.add_dependency(%q<activerecord>, ["~> 3.2.3"])
-      s.add_dependency(%q<activerecord-oracle_enhanced-adapter>, ["~> 1.4.1"])
-      s.add_dependency(%q<ruby-oci8>, [">= 0"])
+      s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
+      s.add_dependency(%q<rspec>, ["~> 3.1"])
+      s.add_dependency(%q<activerecord>, ["< 4.2.0", ">= 3.2.3"])
+      s.add_dependency(%q<activerecord-oracle_enhanced-adapter>, ["< 1.6.0", ">= 1.4.1"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+      s.add_dependency(%q<ruby-oci8>, ["~> 2.1.2"])
     end
   else
-    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
-    s.add_dependency(%q<rspec>, ["~> 2.9"])
-    s.add_dependency(%q<activerecord>, ["~> 3.2.3"])
-    s.add_dependency(%q<activerecord-oracle_enhanced-adapter>, ["~> 1.4.1"])
-    s.add_dependency(%q<ruby-oci8>, [">= 0"])
+    s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
+    s.add_dependency(%q<rspec>, ["~> 3.1"])
+    s.add_dependency(%q<activerecord>, ["< 4.2.0", ">= 3.2.3"])
+    s.add_dependency(%q<activerecord-oracle_enhanced-adapter>, ["< 1.6.0", ">= 1.4.1"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+    s.add_dependency(%q<ruby-oci8>, ["~> 2.1.2"])
   end
 end
 

data/spec/plsql/connection_spec.rb

@@ -29,23 +29,23 @@ describe "Connection" do
     end
 
     it "should create connection" do
-      @conn1.raw_connection.should == @raw_conn1
+      expect(@conn1.raw_connection).to eq @raw_conn1
     end
 
     unless defined?(JRuby)
       it "should be oci connection" do
-        @conn1.should be_oci
-        @conn1.raw_driver.should == :oci
+        expect(@conn1).to be_oci
+        expect(@conn1.raw_driver).to eq :oci
       end
     else
       it "should be jdbc connection" do
-        @conn1.should be_jdbc
-        @conn1.raw_driver.should == :jdbc
+        expect(@conn1).to be_jdbc
+        expect(@conn1.raw_driver).to eq :jdbc
       end
     end
 
     it "should logoff connection" do
-      @conn1.logoff.should be_true
+      expect(@conn1.logoff).to be true
     end
 
   end
@@ -54,68 +54,68 @@ describe "Connection" do
   unless defined?(JRuby)
     describe "OCI data type conversions" do
       it "should translate PL/SQL VARCHAR2 to Ruby String" do
-        @conn.plsql_to_ruby_data_type(:data_type => "VARCHAR2", :data_length => 100).should == [String, 100]
-        @conn.plsql_to_ruby_data_type(:data_type => "VARCHAR2", :data_length => nil).should == [String, 32767]
+        expect(@conn.plsql_to_ruby_data_type(:data_type => "VARCHAR2", :data_length => 100)).to eq [String, 100]
+        expect(@conn.plsql_to_ruby_data_type(:data_type => "VARCHAR2", :data_length => nil)).to eq [String, 32767]
       end
 
       it "should translate PL/SQL CLOB to Ruby String" do
-        @conn.plsql_to_ruby_data_type(:data_type => "CLOB", :data_length => 100_000).should == [OCI8::CLOB, nil]
-        @conn.plsql_to_ruby_data_type(:data_type => "CLOB", :data_length => nil).should == [OCI8::CLOB, nil]
+        expect(@conn.plsql_to_ruby_data_type(:data_type => "CLOB", :data_length => 100_000)).to eq [OCI8::CLOB, nil]
+        expect(@conn.plsql_to_ruby_data_type(:data_type => "CLOB", :data_length => nil)).to eq [OCI8::CLOB, nil]
       end
 
       it "should translate PL/SQL NUMBER to Ruby OraNumber" do
-        @conn.plsql_to_ruby_data_type(:data_type => "NUMBER", :data_length => 15).should == [OraNumber, nil]
+        expect(@conn.plsql_to_ruby_data_type(:data_type => "NUMBER", :data_length => 15)).to eq [OraNumber, nil]
       end
 
       it "should translate PL/SQL DATE to Ruby DateTime" do
-        @conn.plsql_to_ruby_data_type(:data_type => "DATE", :data_length => nil).should == [DateTime, nil]
+        expect(@conn.plsql_to_ruby_data_type(:data_type => "DATE", :data_length => nil)).to eq [DateTime, nil]
       end
 
       it "should translate PL/SQL TIMESTAMP to Ruby Time" do
-        @conn.plsql_to_ruby_data_type(:data_type => "TIMESTAMP", :data_length => nil).should == [Time, nil]
+        expect(@conn.plsql_to_ruby_data_type(:data_type => "TIMESTAMP", :data_length => nil)).to eq [Time, nil]
       end
 
       it "should not translate Ruby Fixnum when OraNumber type specified" do
-        @conn.ruby_value_to_ora_value(100, OraNumber).should eql(100)
+        expect(@conn.ruby_value_to_ora_value(100, OraNumber)).to eql(100)
       end
 
       it "should translate Ruby Bignum value to OraNumber when OraNumber type specified" do
         ora_number = @conn.ruby_value_to_ora_value(12345678901234567890, OraNumber)
-        ora_number.class.should == OraNumber
-        ora_number.to_s.should == "12345678901234567890"
+        expect(ora_number.class).to eq OraNumber
+        expect(ora_number.to_s).to eq "12345678901234567890"
         # OraNumber has more numeric comparison methods in ruby-oci8 2.0
-        ora_number.should == OraNumber.new("12345678901234567890") if OCI8::VERSION >= '2.0.0'
+        expect(ora_number).to eq OraNumber.new("12345678901234567890") if OCI8::VERSION >= '2.0.0'
       end
 
       it "should translate Ruby String value to OCI8::CLOB when OCI8::CLOB type specified" do
         large_text = "x" * 100_000
         ora_value = @conn.ruby_value_to_ora_value(large_text, OCI8::CLOB)
-        ora_value.class.should == OCI8::CLOB
-        ora_value.size.should == 100_000
+        expect(ora_value.class).to eq OCI8::CLOB
+        expect(ora_value.size).to eq 100_000
         ora_value.rewind
-        ora_value.read.should == large_text
+        expect(ora_value.read).to eq large_text
       end
 
       it "should translate Oracle OraNumber integer value to Fixnum" do
-        @conn.ora_value_to_ruby_value(OraNumber.new(100)).should eql(100)
+        expect(@conn.ora_value_to_ruby_value(OraNumber.new(100))).to eql(100)
       end
 
       it "should translate Oracle OraNumber float value to BigDecimal" do
-        @conn.ora_value_to_ruby_value(OraNumber.new(100.11)).should eql(BigDecimal("100.11"))
+        expect(@conn.ora_value_to_ruby_value(OraNumber.new(100.11))).to eql(BigDecimal("100.11"))
       end
 
       # ruby-oci8 2.0 returns DATE as Time or DateTime
       if OCI8::VERSION < '2.0.0'
         it "should translate Oracle OraDate value to Time" do
           now = OraDate.now
-          @conn.ora_value_to_ruby_value(now).should eql(now.to_time)
+          expect(@conn.ora_value_to_ruby_value(now)).to eql(now.to_time)
         end
       end
 
       it "should translate Oracle CLOB value to String" do
         large_text = "x" * 100_000
         clob = OCI8::CLOB.new(@raw_conn, large_text)
-        @conn.ora_value_to_ruby_value(clob).should == large_text
+        expect(@conn.ora_value_to_ruby_value(clob)).to eq large_text
       end
       
     end
@@ -125,63 +125,63 @@ describe "Connection" do
 
     describe "JDBC data type conversions" do
       it "should translate PL/SQL VARCHAR2 to Ruby String" do
-        @conn.plsql_to_ruby_data_type(:data_type => "VARCHAR2", :data_length => 100).should == [String, 100]
-        @conn.plsql_to_ruby_data_type(:data_type => "VARCHAR2", :data_length => nil).should == [String, 32767]
+        expect(@conn.plsql_to_ruby_data_type(:data_type => "VARCHAR2", :data_length => 100)).to eq [String, 100]
+        expect(@conn.plsql_to_ruby_data_type(:data_type => "VARCHAR2", :data_length => nil)).to eq [String, 32767]
       end
 
       it "should translate PL/SQL NUMBER to Ruby BigDecimal" do
-        @conn.plsql_to_ruby_data_type(:data_type => "NUMBER", :data_length => 15).should == [BigDecimal, nil]
+        expect(@conn.plsql_to_ruby_data_type(:data_type => "NUMBER", :data_length => 15)).to eq [BigDecimal, nil]
       end
       
       it "should translate PL/SQL DATE to Ruby DateTime" do
-        @conn.plsql_to_ruby_data_type(:data_type => "DATE", :data_length => nil).should == [DateTime, nil]
+        expect(@conn.plsql_to_ruby_data_type(:data_type => "DATE", :data_length => nil)).to eq [DateTime, nil]
       end
       
       it "should translate PL/SQL TIMESTAMP to Ruby Time" do
-        @conn.plsql_to_ruby_data_type(:data_type => "TIMESTAMP", :data_length => nil).should == [Time, nil]
+        expect(@conn.plsql_to_ruby_data_type(:data_type => "TIMESTAMP", :data_length => nil)).to eq [Time, nil]
       end
       
       it "should not translate Ruby Fixnum when BigDecimal type specified" do
-        @conn.ruby_value_to_ora_value(100, BigDecimal).should == java.math.BigDecimal.new(100)
+        expect(@conn.ruby_value_to_ora_value(100, BigDecimal)).to eq java.math.BigDecimal.new(100)
       end
       
       it "should translate Ruby Bignum value to BigDecimal when BigDecimal type specified" do
         big_decimal = @conn.ruby_value_to_ora_value(12345678901234567890, BigDecimal)
-        big_decimal.should == java.math.BigDecimal.new("12345678901234567890")
+        expect(big_decimal).to eq java.math.BigDecimal.new("12345678901234567890")
       end
 
       it "should translate Ruby String value to Java::OracleSql::CLOB when Java::OracleSql::CLOB type specified" do
         large_text = "x" * 100_000
         ora_value = @conn.ruby_value_to_ora_value(large_text, Java::OracleSql::CLOB)
-        ora_value.class.should == Java::OracleSql::CLOB
-        ora_value.length.should == 100_000
-        ora_value.getSubString(1, ora_value.length) == large_text
+        expect(ora_value.class).to eq Java::OracleSql::CLOB
+        expect(ora_value.length).to eq 100_000
+        expect(ora_value.getSubString(1, ora_value.length)).to eq large_text
         ora_value.freeTemporary
       end
 
       it "should translate Ruby nil value to nil when Java::OracleSql::CLOB type specified" do
         ora_value = @conn.ruby_value_to_ora_value(nil, Java::OracleSql::CLOB)
-        ora_value.should be_nil
+        expect(ora_value).to be_nil
       end
 
       it "should translate Oracle BigDecimal integer value to Fixnum" do
-        @conn.ora_value_to_ruby_value(BigDecimal("100")).should eql(100)
+        expect(@conn.ora_value_to_ruby_value(BigDecimal("100"))).to eql(100)
       end
       
       it "should translate Oracle BigDecimal float value to BigDecimal" do
-        @conn.ora_value_to_ruby_value(BigDecimal("100.11")).should eql(BigDecimal("100.11"))
+        expect(@conn.ora_value_to_ruby_value(BigDecimal("100.11"))).to eql(BigDecimal("100.11"))
       end
 
       it "should translate Oracle CLOB value to String" do
         large_text = "āčē" * 100_000
         clob = @conn.ruby_value_to_ora_value(large_text, Java::OracleSql::CLOB)
-        @conn.ora_value_to_ruby_value(clob).should == large_text
+        expect(@conn.ora_value_to_ruby_value(clob)).to eq large_text
         clob.freeTemporary
       end
 
       it "should translate empty Oracle CLOB value to nil" do
         clob = @conn.ruby_value_to_ora_value(nil, Java::OracleSql::CLOB)
-        @conn.ora_value_to_ruby_value(clob).should be_nil
+        expect(@conn.ora_value_to_ruby_value(clob)).to be_nil
       end
 
     end
@@ -192,30 +192,30 @@ describe "Connection" do
 
     it "should execute SQL statement and return first result" do
       @now = Time.local(2008,05,31,23,22,11)
-      @conn.select_first("SELECT 'abc',123,123.456,
+      expect(@conn.select_first("SELECT 'abc',123,123.456,
         TO_DATE('#{@now.strftime("%Y-%m-%d %H:%M:%S")}','YYYY-MM-DD HH24:MI:SS')
-        FROM dual").should == ["abc",123,123.456,@now]
+        FROM dual")).to eq ["abc",123,123.456,@now]
     end
 
     it "should execute SQL statement and return first result as hash" do
       @now = Time.local(2008,05,31,23,22,11)
-      @conn.select_hash_first("SELECT 'abc' a, 123 b, 123.456 c,
+      expect(@conn.select_hash_first("SELECT 'abc' a, 123 b, 123.456 c,
         TO_DATE('#{@now.strftime("%Y-%m-%d %H:%M:%S")}', 'YYYY-MM-DD HH24:MI:SS') d
-        FROM dual").should == {:a => "abc", :b => 123, :c => 123.456, :d => @now}
+        FROM dual")).to eq({:a => "abc", :b => 123, :c => 123.456, :d => @now})
     end
 
     it "should execute SQL statement with bind parameters and return first result" do
       @today = Date.parse("2008-05-31")
       @now = Time.local(2008,05,31,23,22,11)
-      @conn.select_first("SELECT :1,:2,:3,:4,:5 FROM dual",
-        'abc',123,123.456,@now,@today).should == ["abc",123,123.456,@now,Time.parse(@today.to_s)]
+      expect(@conn.select_first("SELECT :1,:2,:3,:4,:5 FROM dual",
+        'abc',123,123.456,@now,@today)).to eq ["abc",123,123.456,@now,Time.parse(@today.to_s)]
     end
     
     it "should execute SQL statement with NULL values and return first result" do
       @now = Time.local(2008,05,31,23,22,11)
-      @conn.select_first("SELECT NULL,123,123.456,
+      expect(@conn.select_first("SELECT NULL,123,123.456,
         TO_DATE('#{@now.strftime("%Y-%m-%d %H:%M:%S")}','YYYY-MM-DD HH24:MI:SS')
-        FROM dual").should == [nil,123,123.456,@now]
+        FROM dual")).to eq [nil,123,123.456,@now]
     end
 
     if defined?(JRuby)
@@ -223,56 +223,56 @@ describe "Connection" do
       it "should execute SQL statement with NULL values as bind parameters and return first result" do
         @today = Date.parse("2008-05-31")
         @now = Time.local(2008,05,31,23,22,11)
-        @conn.select_first("SELECT :1,:2,:3,:4,:5 FROM dual",
-          nil,123,123.456,@now,@today).should == [nil,123,123.456,@now,Time.parse(@today.to_s)]
+        expect(@conn.select_first("SELECT :1,:2,:3,:4,:5 FROM dual",
+          nil,123,123.456,@now,@today)).to eq [nil,123,123.456,@now,Time.parse(@today.to_s)]
       end
     
     end
 
     it "should execute SQL statement and return all results" do
       @now = Time.local(2008,05,31,23,22,11)
-      @conn.select_all("SELECT 'abc',123,123.456,
+      expect(@conn.select_all("SELECT 'abc',123,123.456,
           TO_DATE('#{@now.strftime("%Y-%m-%d %H:%M:%S")}','YYYY-MM-DD HH24:MI:SS')
           FROM dual
           UNION ALL SELECT 'abc',123,123.456,
           TO_DATE('#{@now.strftime("%Y-%m-%d %H:%M:%S")}','YYYY-MM-DD HH24:MI:SS')
-          FROM dual").should == [["abc",123,123.456,@now],["abc",123,123.456,@now]]
+          FROM dual")).to eq [["abc",123,123.456,@now],["abc",123,123.456,@now]]
     end
 
     it "should execute SQL statement and return all results as hash" do
       @now = Time.local(2008,05,31,23,22,11)
-      @conn.select_hash_all("SELECT 'abc' a, 123 b, 123.456 c,
+      expect(@conn.select_hash_all("SELECT 'abc' a, 123 b, 123.456 c,
           TO_DATE('#{@now.strftime("%Y-%m-%d %H:%M:%S")}','YYYY-MM-DD HH24:MI:SS') d
           FROM dual
           UNION ALL SELECT 'def' a, 123 b, 123.456 c,
           TO_DATE('#{@now.strftime("%Y-%m-%d %H:%M:%S")}','YYYY-MM-DD HH24:MI:SS') d
-          FROM dual").should == [{:a=>"abc",:b=>123,:c=>123.456,:d=>@now},{:a=>"def",:b=>123,:c=>123.456,:d=>@now}]
+          FROM dual")).to eq [{:a=>"abc",:b=>123,:c=>123.456,:d=>@now},{:a=>"def",:b=>123,:c=>123.456,:d=>@now}]
     end
 
     it "should execute SQL statement with bind parameters and return all results" do
       @now = Time.local(2008,05,31,23,22,11)
-      @conn.select_all("SELECT :1,:2,:3,:4 FROM dual UNION ALL SELECT :1,:2,:3,:4 FROM dual",
-        'abc',123,123.456,@now,'abc',123,123.456,@now).should == [["abc",123,123.456,@now],["abc",123,123.456,@now]]
+      expect(@conn.select_all("SELECT :1,:2,:3,:4 FROM dual UNION ALL SELECT :1,:2,:3,:4 FROM dual",
+        'abc',123,123.456,@now,'abc',123,123.456,@now)).to eq [["abc",123,123.456,@now],["abc",123,123.456,@now]]
     end
     
     it "should execute SQL statement and yield all results in block" do
       @now = Time.local(2008,05,31,23,22,11)
-      @conn.select_all("SELECT 'abc',123,123.456,
+      expect(@conn.select_all("SELECT 'abc',123,123.456,
           TO_DATE('#{@now.strftime("%Y-%m-%d %H:%M:%S")}','YYYY-MM-DD HH24:MI:SS')
           FROM dual
           UNION ALL SELECT 'abc',123,123.456,
           TO_DATE('#{@now.strftime("%Y-%m-%d %H:%M:%S")}','YYYY-MM-DD HH24:MI:SS')
           FROM dual") do |r|
-        r.should == ["abc",123,123.456,@now]
-      end.should == 2
+        expect(r).to eq ["abc",123,123.456,@now]
+      end).to eq 2
     end
     
     it "should execute SQL statement with bind parameters and yield all results in block" do
       @now = Time.local(2008,05,31,23,22,11)
-      @conn.select_all("SELECT :1,:2,:3,:4 FROM dual UNION ALL SELECT :1,:2,:3,:4 FROM dual",
+      expect(@conn.select_all("SELECT :1,:2,:3,:4 FROM dual UNION ALL SELECT :1,:2,:3,:4 FROM dual",
         'abc',123,123.456,@now,'abc',123,123.456,@now) do |r|
-        r.should == ["abc",123,123.456,@now]
-      end.should == 2
+        expect(r).to eq ["abc",123,123.456,@now]
+      end).to eq 2
     end
 
   end
@@ -289,7 +289,7 @@ describe "Connection" do
           RETURN p_number + #{@random};
         END test_add_random;
       SQL
-      @conn.exec(sql).should be_true
+      expect(@conn.exec(sql)).to be true
     end
 
     after(:all) do
@@ -308,19 +308,19 @@ describe "Connection" do
       cursor.bind_param(":p_varchar", "abc", :data_type => 'VARCHAR2', :in_out => 'IN/OUT')
       cursor.bind_param(":p_date", @now, :data_type => 'DATE', :in_out => 'IN/OUT')
       cursor.exec
-      cursor[":result"].should == @random + 100
-      cursor[":p_varchar"].should == "abc"
-      cursor[":p_date"].should == @now
-      cursor.close.should be_nil
+      expect(cursor[":result"]).to eq @random + 100
+      expect(cursor[":p_varchar"]).to eq "abc"
+      expect(cursor[":p_date"]).to eq @now
+      expect(cursor.close).to be_nil
     end
   
   end
   
   describe "commit and rollback" do
     before(:all) do
-      @conn.exec("CREATE TABLE test_commit (dummy VARCHAR2(100))").should be_true
+      expect(@conn.exec("CREATE TABLE test_commit (dummy VARCHAR2(100))")).to be true
       @conn.autocommit = false
-      @conn.should_not be_autocommit
+      expect(@conn).not_to be_autocommit
     end
 
     after(:all) do
@@ -335,20 +335,20 @@ describe "Connection" do
     it "should do commit" do
       @conn.exec("INSERT INTO test_commit VALUES ('test')")
       @conn.commit
-      @conn.select_first("SELECT COUNT(*) FROM test_commit")[0].should == 1
+      expect(@conn.select_first("SELECT COUNT(*) FROM test_commit")[0]).to eq 1
     end
 
     it "should do rollback" do
       @conn.exec("INSERT INTO test_commit VALUES ('test')")
       @conn.rollback
-      @conn.select_first("SELECT COUNT(*) FROM test_commit")[0].should == 0
+      expect(@conn.select_first("SELECT COUNT(*) FROM test_commit")[0]).to eq 0
     end
 
     it "should do commit and rollback should not undo commited transaction" do
       @conn.exec("INSERT INTO test_commit VALUES ('test')")
       @conn.commit
       @conn.rollback
-      @conn.select_first("SELECT COUNT(*) FROM test_commit")[0].should == 1
+      expect(@conn.select_first("SELECT COUNT(*) FROM test_commit")[0]).to eq 1
     end
 
   end
@@ -361,21 +361,21 @@ describe "Connection" do
     it "should set prefetch rows for connection" do
       sql = "SELECT 1 FROM dual UNION ALL SELECT 1/0 FROM dual"
       @conn.prefetch_rows = 2
-      lambda {
+      expect {
         @conn.cursor_from_query(sql)
-      }.should raise_error(/divisor is equal to zero/)
+      }.to raise_error(/divisor is equal to zero/)
       @conn.prefetch_rows = 1
-      lambda {
+      expect {
         @conn.cursor_from_query(sql)
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     it "should fetch just one row when using select_first" do
       sql = "SELECT 1 FROM dual UNION ALL SELECT 1/0 FROM dual"
       @conn.prefetch_rows = 2
-      lambda {
+      expect {
         @conn.select_first(sql)
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
   end
@@ -390,21 +390,21 @@ describe "Connection" do
     end
 
     it "should describe local synonym" do
-      @conn.describe_synonym('HR','SYNONYM_FOR_DUAL').should == ['SYS', 'DUAL']
-      @conn.describe_synonym('hr','synonym_for_dual').should == ['SYS', 'DUAL']
-      @conn.describe_synonym(:hr,:synonym_for_dual).should == ['SYS', 'DUAL']
+      expect(@conn.describe_synonym('HR','SYNONYM_FOR_DUAL')).to eq ['SYS', 'DUAL']
+      expect(@conn.describe_synonym('hr','synonym_for_dual')).to eq ['SYS', 'DUAL']
+      expect(@conn.describe_synonym(:hr,:synonym_for_dual)).to eq ['SYS', 'DUAL']
     end
 
     it "should return nil on non-existing synonym" do
-      @conn.describe_synonym('HR','SYNONYM_FOR_XXX').should be_nil
-      @conn.describe_synonym('hr','synonym_for_xxx').should be_nil
-      @conn.describe_synonym(:hr,:synonym_for_xxx).should be_nil
+      expect(@conn.describe_synonym('HR','SYNONYM_FOR_XXX')).to be_nil
+      expect(@conn.describe_synonym('hr','synonym_for_xxx')).to be_nil
+      expect(@conn.describe_synonym(:hr,:synonym_for_xxx)).to be_nil
     end
 
     it "should describe public synonym" do
-      @conn.describe_synonym('PUBLIC','DUAL').should == ['SYS', 'DUAL']
-      @conn.describe_synonym('PUBLIC','dual').should == ['SYS', 'DUAL']
-      @conn.describe_synonym('PUBLIC',:dual).should == ['SYS', 'DUAL']
+      expect(@conn.describe_synonym('PUBLIC','DUAL')).to eq ['SYS', 'DUAL']
+      expect(@conn.describe_synonym('PUBLIC','dual')).to eq ['SYS', 'DUAL']
+      expect(@conn.describe_synonym('PUBLIC',:dual)).to eq ['SYS', 'DUAL']
     end
 
   end
@@ -412,11 +412,11 @@ describe "Connection" do
   describe "session information" do
     it "should get database version" do
       # using Oracle version 10.2.0.4 for unit tests
-      @conn.database_version.should == DATABASE_VERSION.split('.').map{|n| n.to_i}
+      expect(@conn.database_version).to eq DATABASE_VERSION.split('.').map{|n| n.to_i}
     end
 
     it "should get session ID" do
-      @conn.session_id.should == @conn.select_first("SELECT USERENV('SESSIONID') FROM dual")[0].to_i
+      expect(@conn.session_id).to eq @conn.select_first("SELECT USERENV('SESSIONID') FROM dual")[0].to_i
     end
   end
 
@@ -428,25 +428,25 @@ describe "Connection" do
     it "should drop all ruby temporary tables" do
       tmp_table = "ruby_111_222_333"
       @conn.exec "CREATE GLOBAL TEMPORARY TABLE #{tmp_table} (dummy CHAR(1))"
-      lambda { @conn.select_first("SELECT * FROM #{tmp_table}") }.should_not raise_error
+      expect { @conn.select_first("SELECT * FROM #{tmp_table}") }.not_to raise_error
       @conn.drop_all_ruby_temporary_tables
-      lambda { @conn.select_first("SELECT * FROM #{tmp_table}") }.should raise_error(/table or view does not exist/)
+      expect { @conn.select_first("SELECT * FROM #{tmp_table}") }.to raise_error(/table or view does not exist/)
     end
 
     it "should drop current session ruby temporary tables" do
       tmp_table = "ruby_#{@conn.session_id}_222_333"
       @conn.exec "CREATE GLOBAL TEMPORARY TABLE #{tmp_table} (dummy CHAR(1))"
-      lambda { @conn.select_first("SELECT * FROM #{tmp_table}") }.should_not raise_error
+      expect { @conn.select_first("SELECT * FROM #{tmp_table}") }.not_to raise_error
       @conn.drop_session_ruby_temporary_tables
-      lambda { @conn.select_first("SELECT * FROM #{tmp_table}") }.should raise_error(/table or view does not exist/)
+      expect { @conn.select_first("SELECT * FROM #{tmp_table}") }.to raise_error(/table or view does not exist/)
     end
 
     it "should not drop other session ruby temporary tables" do
       tmp_table = "ruby_#{@conn.session_id+1}_222_333"
       @conn.exec "CREATE GLOBAL TEMPORARY TABLE #{tmp_table} (dummy CHAR(1))"
-      lambda { @conn.select_first("SELECT * FROM #{tmp_table}") }.should_not raise_error
+      expect { @conn.select_first("SELECT * FROM #{tmp_table}") }.not_to raise_error
       @conn.drop_session_ruby_temporary_tables
-      lambda { @conn.select_first("SELECT * FROM #{tmp_table}") }.should_not raise_error
+      expect { @conn.select_first("SELECT * FROM #{tmp_table}") }.not_to raise_error
     end
 
   end
@@ -470,10 +470,10 @@ describe "Connection" do
     it "should drop current session ruby temporary tables" do
       tmp_table = "ruby_#{@conn.session_id}_222_333"
       @conn.exec "CREATE GLOBAL TEMPORARY TABLE #{tmp_table} (dummy CHAR(1))"
-      lambda { @conn.select_first("SELECT * FROM #{tmp_table}") }.should_not raise_error
+      expect { @conn.select_first("SELECT * FROM #{tmp_table}") }.not_to raise_error
       @conn.logoff
       reconnect_connection
-      lambda { @conn.select_first("SELECT * FROM #{tmp_table}") }.should raise_error(/table or view does not exist/)
+      expect { @conn.select_first("SELECT * FROM #{tmp_table}") }.to raise_error(/table or view does not exist/)
     end
 
     it "should rollback any uncommited transactions" do
@@ -486,7 +486,7 @@ describe "Connection" do
       # logoff will drop ruby temporary tables, it should do rollback before drop table
       @conn.logoff
       reconnect_connection
-      @conn.select_first("SELECT * FROM test_dummy_table").should == nil
+      expect(@conn.select_first("SELECT * FROM test_dummy_table")).to eq nil
       @conn.autocommit = old_autocommit
     end