ruby-plsql 0.4.1 → 0.4.2

data/spec/plsql/procedure_spec.rb

@@ -344,13 +344,12 @@ describe "Parameter type mapping /" do
     end
 
     it "should raise exception if procedure cannot be found based on number of arguments" do
-      lambda { plsql.test_package2.test_procedure() }.should raise_error(ArgumentError)
+      lambda { plsql.test_package2.test_procedure() }.should raise_error(/wrong number or types of arguments/i)
     end
   
-    # TODO: should try to implement matching by types of arguments
-    # it "should find procedure based on types of arguments" do
-    #   plsql.test_package2.test_procedure(111, nil).should == {:p_result => '111'}
-    # end
+    it "should find procedure based on types of arguments" do
+      plsql.test_package2.test_procedure(111, nil).should == {:p_result => '111'}
+    end
 
     it "should find procedure based on names of named arguments" do
       plsql.test_package2.test_procedure(:p_number => 111, :p_result => nil).should == {:p_result => '111'}
@@ -559,6 +558,28 @@ describe "Parameter type mapping /" do
           RETURN p_employee.first_name || ' ' || p_employee.last_name;
         END test_full_name;
       SQL
+      plsql.execute <<-SQL
+        CREATE OR REPLACE PACKAGE test_record IS
+          TYPE t_employee IS RECORD(
+            employee_id   NUMBER(15),
+            first_name    VARCHAR2(50),
+            last_name     VARCHAR2(50),
+            hire_date     DATE
+          );
+          FUNCTION test_full_name (p_employee t_employee)
+            RETURN VARCHAR2;
+        END;
+      SQL
+      plsql.execute <<-SQL
+        CREATE OR REPLACE PACKAGE BODY test_record IS
+          FUNCTION test_full_name (p_employee t_employee)
+            RETURN VARCHAR2
+          IS
+          BEGIN
+            RETURN p_employee.first_name || ' ' || p_employee.last_name;
+          END;
+        END;
+      SQL
       plsql.execute <<-SQL
         CREATE OR REPLACE FUNCTION test_employee_record (p_employee test_employees%ROWTYPE)
           RETURN test_employees%ROWTYPE
@@ -568,7 +589,7 @@ describe "Parameter type mapping /" do
         END test_employee_record;
       SQL
       plsql.execute <<-SQL
-        CREATE OR REPLACE FUNCTION test_employee_record2 (p_employee test_employees%ROWTYPE, x_employee OUT test_employees%ROWTYPE)
+        CREATE OR REPLACE FUNCTION test_employee_record2 (p_employee test_employees%ROWTYPE, x_employee IN OUT test_employees%ROWTYPE)
           RETURN test_employees%ROWTYPE
         IS
         BEGIN
@@ -595,6 +616,7 @@ describe "Parameter type mapping /" do
 
     after(:all) do
       plsql.execute "DROP FUNCTION test_full_name"
+      plsql.execute "DROP PACKAGE test_record"
       plsql.execute "DROP FUNCTION test_employee_record"
       plsql.execute "DROP FUNCTION test_employee_record2"
       plsql.execute "DROP TABLE test_employees"
@@ -627,7 +649,11 @@ describe "Parameter type mapping /" do
     end
 
     it "should return record return value and output record parameter value" do
-      plsql.test_employee_record2(@p_employee, nil).should == [@p_employee, {:x_employee => @p_employee}]
+      plsql.test_employee_record2(@p_employee, @p_employee2).should == [@p_employee, {:x_employee => @p_employee}]
+    end
+
+    it "should execute package function with parameter with record type defined in package" do
+      plsql.test_record.test_full_name(@p_employee).should == 'First Last'
     end
 
   end
@@ -852,12 +878,36 @@ describe "Parameter type mapping /" do
         END;
       SQL
 
-      # Wrong type definition inside package
+      # Type definition inside package
       plsql.execute <<-SQL
         CREATE OR REPLACE PACKAGE test_collections IS
           TYPE t_numbers IS TABLE OF NUMBER(15);
           FUNCTION test_sum (p_numbers IN t_numbers)
             RETURN NUMBER;
+          FUNCTION test_numbers (p_numbers IN t_numbers, x_numbers OUT t_numbers)
+            RETURN t_numbers;
+          TYPE t_employee IS RECORD(
+            employee_id   NUMBER(15),
+            first_name    VARCHAR2(50),
+            last_name     VARCHAR2(50),
+            hire_date     DATE
+          );
+          TYPE t_employees IS TABLE OF 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),
+            hire_date     DATE,
+            numbers       t_numbers
+          );
+          FUNCTION test_employee2 (p_employee IN OUT t_employee2)
+            RETURN t_employee2;
+          TYPE t_employees2 IS TABLE OF t_employee2;
+          FUNCTION test_employees2 (p_employees IN OUT t_employees2)
+            RETURN t_employees2;
         END;
       SQL
       plsql.execute <<-SQL
@@ -878,8 +928,41 @@ describe "Parameter type mapping /" do
               RETURN NULL;
             END IF;
           END;
+          FUNCTION test_numbers (p_numbers IN t_numbers, x_numbers OUT t_numbers)
+          RETURN t_numbers
+          IS
+          BEGIN
+            x_numbers := p_numbers;
+            RETURN p_numbers;
+          END;
+          FUNCTION test_employees (p_employees IN OUT t_employees)
+            RETURN t_employees
+          IS
+          BEGIN
+            RETURN p_employees;
+          END;
+          FUNCTION test_employee2 (p_employee IN OUT t_employee2)
+            RETURN t_employee2
+          IS
+          BEGIN
+            RETURN p_employee;
+          END;
+          FUNCTION test_employees2 (p_employees IN OUT t_employees2)
+            RETURN t_employees2
+          IS
+          BEGIN
+            RETURN p_employees;
+          END;
         END;
       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),
+        }
+      end
 
       # Array of objects
       plsql.execute <<-SQL
@@ -912,6 +995,7 @@ describe "Parameter type mapping /" do
       plsql.execute "DROP TYPE t_strings"
       plsql.execute "DROP TYPE t_phones"
       plsql.execute "DROP TYPE t_phone"
+      plsql.connection.drop_session_ruby_temporary_tables
     end
 
     it "should find existing function" do
@@ -931,10 +1015,32 @@ describe "Parameter type mapping /" do
       plsql.test_copy_strings(strings).should == [strings, {:x_strings => strings}]
     end
 
-    it "should raise error if parameter type is defined inside package" do
-      lambda do
-        plsql.test_collections.test_sum([1,2,3,4])
-      end.should raise_error(ArgumentError)
+    it "should execute function with table of numbers type (defined inside package) parameter" do
+      plsql.test_collections.test_sum([1,2,3,4]).should == 10
+    end
+
+    it "should return table of numbers type (defined inside package)" do
+      plsql.test_collections.test_numbers([1,2,3,4]).should == [[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
+      plsql.test_collections.test_numbers([1,2,3,4]).should == [[1,2,3,4], {:x_numbers => [1,2,3,4]}]
+      # after first call temporary tables should be cleared
+      plsql.test_collections.test_numbers([1,2,3,4]).should == [[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
+      plsql.test_collections.test_numbers(numbers_array).should == [numbers_array, {:x_numbers => numbers_array}]
+      # after first call temporary tables should be cleared
+      plsql.test_collections.test_numbers(numbers_array).should == [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
+      plsql.test_collections.test_employees(@employees).should == [@employees, {:p_employees => @employees}]
     end
 
     it "should execute function with object array and return object array output parameter" do
@@ -947,8 +1053,165 @@ describe "Parameter type mapping /" do
       plsql.test_copy_objects(phones).should == [phones, {:x_phones => phones}]
     end
 
+    it "should raise error with record parameter that has table as element" do
+      lambda {
+        plsql.test_collections.test_employee2(@employees[0]).should == [@employees[0], {:p_employee => @employees[0]}]
+      }.should 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
+      lambda {
+        plsql.test_collections.test_employees2(@employees).should == [@employees, {:p_employees => @employees}]
+      }.should raise_error(ArgumentError, /TEST_COLLECTIONS\.T_NUMBERS definition inside package is not supported/)
+    end
+
   end
 
+  describe "Function with table indexed by bynary integer parameter" do
+
+    before(:all) do
+      plsql.execute <<-SQL
+        CREATE TABLE test_employees (
+          employee_id   NUMBER(15),
+          first_name    VARCHAR2(50),
+          last_name     VARCHAR2(50),
+          hire_date     DATE
+        )
+      SQL
+      # Type definition inside package
+      plsql.execute <<-SQL
+        CREATE OR REPLACE PACKAGE test_collections IS
+          TYPE t_numbers IS TABLE OF NUMBER(15)
+            INDEX BY BINARY_INTEGER;
+          FUNCTION test_sum (p_numbers IN t_numbers)
+            RETURN NUMBER;
+          FUNCTION test_numbers (p_numbers IN t_numbers, x_numbers OUT t_numbers)
+            RETURN t_numbers;
+          TYPE t_employee IS RECORD(
+            employee_id   NUMBER(15),
+            first_name    VARCHAR2(50),
+            last_name     VARCHAR2(50),
+            hire_date     DATE
+          );
+          TYPE t_employees IS TABLE OF t_employee
+            INDEX BY BINARY_INTEGER;
+          FUNCTION test_employees (p_employees IN OUT t_employees)
+            RETURN t_employees;
+          PROCEDURE insert_employees(p_employees IN t_employees);
+        END;
+      SQL
+      plsql.execute <<-SQL
+        CREATE OR REPLACE PACKAGE BODY test_collections IS
+          FUNCTION test_sum (p_numbers IN t_numbers)
+          RETURN NUMBER
+          IS
+            l_sum   NUMBER(15) := 0;
+            i BINARY_INTEGER;
+          BEGIN
+            IF p_numbers.COUNT > 0 THEN
+              i := p_numbers.FIRST;
+              LOOP
+                EXIT WHEN i IS NULL;
+                l_sum := l_sum + p_numbers(i);
+                i := p_numbers.NEXT(i);
+              END LOOP;
+              RETURN l_sum;
+            ELSE
+              RETURN NULL;
+            END IF;
+          END;
+          FUNCTION test_numbers (p_numbers IN t_numbers, x_numbers OUT t_numbers)
+          RETURN t_numbers
+          IS
+          BEGIN
+            x_numbers := p_numbers;
+            RETURN p_numbers;
+          END;
+          FUNCTION test_employees (p_employees IN OUT t_employees)
+            RETURN t_employees
+          IS
+          BEGIN
+            RETURN p_employees;
+          END;
+          PROCEDURE insert_employees(p_employees IN t_employees) IS
+          BEGIN
+            FORALL i IN p_employees.FIRST..p_employees.LAST
+              INSERT INTO test_employees VALUES p_employees(i);
+          END;
+        END;
+      SQL
+      # test with negative PL/SQL table indexes
+      @numbers = Hash[*(1..4).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)
+        }]
+      end.flatten]
+    end
+
+    after(:all) do
+      plsql.execute "DROP PACKAGE test_collections"
+      plsql.execute "DROP TABLE test_employees"
+      plsql.connection.drop_session_ruby_temporary_tables
+    end
+
+    it "should execute function with index-by table of numbers type (defined inside package) parameter" do
+      plsql.test_collections.test_sum(@numbers).should == 10
+    end
+
+    it "should return index-by table of numbers type (defined inside package)" do
+      plsql.test_collections.test_numbers(@numbers).should == [@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]
+      plsql.test_collections.test_numbers(numbers_hash).should == [numbers_hash, {:x_numbers => numbers_hash}]
+      # after first call temporary tables should be cleared
+      plsql.test_collections.test_numbers(numbers_hash).should == [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
+      plsql.test_collections.test_employees(@employees).should == [@employees, {:p_employees => @employees}]
+    end
+
+    it "should create temporary tables in autonomous transaction" do
+      old_autocommit = plsql.connection.autocommit?
+      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.rollback
+      plsql.test_employees.all.should be_empty
+      plsql.connection.autocommit = old_autocommit
+    end
+
+    describe "using Oracle 9.2" do
+      before(:all) do
+        # simulate Oracle 9.2 connection
+        plsql(:oracle_9).connection = get_connection
+        plsql(:oracle_9).connection.stub!(:database_version).and_return([9, 2])
+      end
+
+      after(:all) do
+        plsql(:oracle_9).logoff
+      end
+
+      it "should create temporary tables when using Oracle 9.2" do
+        plsql(:oracle_9).test_collections.test_numbers(@numbers).should == [@numbers, {:x_numbers => @numbers}]
+      end
+
+    end
+
+  end
+
+
   describe "Function with VARRAY parameter" do
 
     before(:all) do
@@ -1293,6 +1556,50 @@ describe "Synonyms /" do
 
   end
 
+  describe "invalid objects" do
+    before(:all) do
+      plsql.execute <<-SQL
+        CREATE OR REPLACE FUNCTION test_invalid_function(p_dummy VARCHAR2) RETURN VARCHAR2 IS
+          l_dummy invalid_table.invalid_column%TYPE;
+        BEGIN
+          RETURN p_dummy;
+        END;
+      SQL
+      plsql.execute <<-SQL
+        CREATE OR REPLACE PACKAGE test_invalid_package IS
+          FUNCTION test_invalid_function(p_dummy VARCHAR2) RETURN VARCHAR2;
+        END;
+      SQL
+      plsql.execute <<-SQL
+        CREATE OR REPLACE PACKAGE BODY test_invalid_package IS
+          FUNCTION test_invalid_function(p_dummy VARCHAR2) RETURN VARCHAR2 IS
+            l_dummy1 invalid_table.invalid_column%TYPE;
+            l_dummy2 invalid_table.invalid_column%TYPE;
+          BEGIN
+            RETURN p_dummy;
+          END;
+        END;
+      SQL
+    end
+
+    after(:all) do
+      plsql.execute "DROP FUNCTION test_invalid_function"
+      plsql.execute "DROP PACKAGE test_invalid_package"
+    end
+
+    it "should raise error when invalid function is called" do
+      lambda {
+        plsql.test_invalid_function('test')
+      }.should raise_error(ArgumentError, /is not in valid status/)
+    end
+
+    it "should raise error when function from invalid package body is called" do
+      lambda {
+        plsql.test_invalid_package.test_invalid_function('test')
+      }.should raise_error(ArgumentError, /body is not in valid status/)
+    end
+  end
+
 end
 
 describe "SYS.STANDARD procedures /" do
@@ -1309,4 +1616,21 @@ describe "SYS.STANDARD procedures /" do
     plsql.upper('abc').should == 'ABC'
   end
 
+  it "should find function overload based on types of sequential arguments" do
+    plsql.nvl(1, 2).should == 1
+    plsql.nvl(nil, 2).should == 2
+    plsql.nvl(1.1, 2.2).should == 1.1
+    plsql.nvl(nil, 2.2).should == 2.2
+    plsql.nvl(BigDecimal('1.1'), BigDecimal('2.2')).should == BigDecimal('1.1')
+    plsql.nvl(nil, BigDecimal('2.2')).should == BigDecimal('2.2')
+    plsql.nvl('a', 'b').should == 'a'
+    plsql.nvl(nil, 'b').should == 'b'
+    plsql.nvl(Date.new(2010,1,13), Date.new(2010,1,19)).should == Time.local(2010,1,13)
+    plsql.nvl(nil, Date.new(2010,1,19)).should == Time.local(2010,1,19)
+    plsql.nvl(Time.local(2010,1,13), Time.local(2010,1,19)).should == Time.local(2010,1,13)
+    plsql.nvl(nil, Time.local(2010,1,19)).should == Time.local(2010,1,19)
+    plsql.nvl(true, false).should == true
+    plsql.nvl(nil, false).should == false
+  end
+
 end

data/spec/plsql/schema_spec.rb

@@ -50,6 +50,52 @@ describe "Schema connection" do
 
 end
 
+describe "Connection with connect!" do
+
+  before(:all) do
+    @username, @password = DATABASE_USERS_AND_PASSWORDS[0]
+    @database = DATABASE_NAME
+    @host = DATABASE_HOST
+    @port = DATABASE_PORT
+  end
+
+  after(:each) do
+    plsql.logoff if plsql.connection
+  end
+
+  it "should connect with username, password and database alias" do
+    plsql.connect! @username, @password, @database
+    plsql.connection.should_not be_nil
+    plsql.schema_name.should == @username.upcase
+  end
+
+  it "should connect with username, password, host, port and database name" do
+    plsql.connect! @username, @password, :host => @host, :port => @port, :database => @database
+    plsql.connection.should_not be_nil
+    plsql.schema_name.should == @username.upcase
+  end
+
+  it "should connect with username, password, host, database name and default port" do
+    pending "Non-default port used for test database" unless @port == 1521
+    plsql.connect! @username, @password, :host => @host, :database => @database
+    plsql.connection.should_not be_nil
+    plsql.schema_name.should == @username.upcase
+  end
+
+  it "should not connect with wrong port number" do
+    lambda {
+      plsql.connect! @username, @password, :host => @host, :port => 9999, :database => @database
+    }.should raise_error(/no listener|could not establish the connection/)
+  end
+
+  it "should connect with one Hash parameter" do
+    plsql.connect! :username => @username, :password => @password, :database => @database
+    plsql.connection.should_not be_nil
+    plsql.schema_name.should == @username.upcase
+  end
+
+end
+
 describe "Named Schema" do
   before(:all) do
     plsql.connection = @conn = get_connection
@@ -80,30 +126,54 @@ end
 describe "Schema commit and rollback" do
   before(:all) 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'}
   end
 
   after(:all) do
-    plsql.connection.logoff
+    plsql.execute "DROP TABLE test_commit"
+    plsql.logoff
+  end
+
+  after(:each) do
+    plsql.test_commit.delete
+    plsql.commit
   end
 
   it "should do commit" do
+    plsql.test_commit.insert @data
     plsql.commit
+    plsql.test_commit.first.should == @data
   end
-  
+
   it "should do rollback" do
+    plsql.test_commit.insert @data
     plsql.rollback
+    plsql.test_commit.first.should be_nil
   end
+
+  it "should create savepoint and rollback to savepoint" do
+    plsql.test_commit.insert @data
+    plsql.savepoint 'test'
+    plsql.test_commit.insert @data2
+    plsql.test_commit.all.should == [@data, @data2]
+    plsql.rollback_to 'test'
+    plsql.test_commit.all.should == [@data]
+  end
+
 end
 
 describe "ActiveRecord connection" do
   before(:all) do
     ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
   end
-  
+
   before(:each) do
     plsql.activerecord_class = ActiveRecord::Base
   end
-  
+
   it "should connect to test database" do
     unless defined?(JRUBY_VERSION)
       plsql.connection.is_a?(PLSQL::OCIConnection).should be_true
@@ -111,20 +181,20 @@ describe "ActiveRecord connection" do
       plsql.connection.is_a?(PLSQL::JDBCConnection).should be_true
     end
   end
-  
+
   it "should return schema name" do
     plsql.schema_name.should == 'HR'
   end
-  
+
   it "should use ActiveRecord::Base.default_timezone as default" do
     ActiveRecord::Base.default_timezone = :utc
     plsql.default_timezone.should == :utc
   end
-  
+
   it "should have the same connection as default schema" do
     plsql.hr.connection.should == plsql.connection
   end
-end
+end if defined?(ActiveRecord)
 
 describe "DBMS_OUTPUT logging" do
 
@@ -158,6 +228,7 @@ describe "DBMS_OUTPUT logging" do
   after(:all) do
     plsql.dbms_output_stream = nil
     plsql.execute "DROP PROCEDURE test_dbms_output"
+    plsql.execute "DROP PROCEDURE test_dbms_output_large"
     plsql.logoff
   end
 
@@ -230,6 +301,6 @@ describe "DBMS_OUTPUT logging" do
       @buffer.string.should == "DBMS_OUTPUT: after reconnection\n"
     end
 
-  end
+  end if defined?(ActiveRecord)
 
 end