ruby-plsql 0.1.2 → 0.1.3

data/History.txt

@@ -1,3 +1,12 @@
+== 0.1.3 2008-04-15
+
+* Improvements
+  * Support for overloaded procedure definitions (named parameter calls compared by number of arguments and by argument names,
+    sequential parameters compared by number of arguments)
+* Bug fixes
+  * Fixed BigDecimal support for procedure parameters (all number types except from Fixnum are converted to Float)
+  * Fixed Date parameters support (always will convert to DateTime)
+
 == 0.1.2 2008-04-02
 
 * Improvements

data/lib/plsql/procedure.rb

@@ -30,9 +30,12 @@ module PLSQL
       @procedure = procedure.to_s.upcase
       @package = package
       @arguments = {}
-      @return = nil
+      @argument_list = {}
+      @out_list = {}
+      @return = {}
+      @overloaded = false
       num_rows = @schema.connection.exec("
-        SELECT a.argument_name, a.position, a.data_type, a.in_out, a.data_length, a.data_precision, a.data_scale
+        SELECT a.argument_name, a.position, a.data_type, a.in_out, a.data_length, a.data_precision, a.data_scale, a.overload
         FROM all_arguments a, all_objects o
         WHERE o.owner = :owner
         AND o.object_name = :object_name
@@ -42,9 +45,17 @@ module PLSQL
         AND NVL(a.package_name,'nil') = :package
         ", @schema.schema_name, @package ? @package : @procedure, @procedure, @package ? @package : 'nil'
       ) do |r|
-        argument_name, position, data_type, in_out, data_length, data_precision, data_scale = r
+
+        argument_name, position, data_type, in_out, data_length, data_precision, data_scale, overload = r
+
+        @overloaded ||= !overload.nil?
+        # if not overloaded then store arguments at key 0
+        overload ||= 0
+        @arguments[overload] ||= {}
+        @return[overload] ||= nil
+        
         if argument_name
-          @arguments[argument_name.downcase.to_sym] = {
+          @arguments[overload][argument_name.downcase.to_sym] = {
             :position => position,
             :data_type => data_type,
             :in_out => in_out,
@@ -53,7 +64,7 @@ module PLSQL
             :data_scale => data_scale
           }
         else
-          @return = {
+          @return[overload] = {
             :data_type => data_type,
             :in_out => in_out,
             :data_length => data_length,
@@ -62,34 +73,65 @@ module PLSQL
           }
         end
       end
-      @argument_list = @arguments.keys.sort {|k1, k2| @arguments[k1][:position] <=> @arguments[k2][:position]}
-      @out_list = @argument_list.select {|k| @arguments[k][:in_out] == 'OUT'}
+      @overloads = @arguments.keys.sort
+      @overloads.each do |overload|
+        @argument_list[overload] = @arguments[overload].keys.sort {|k1, k2| @arguments[overload][k1][:position] <=> @arguments[overload][k2][:position]}
+        @out_list[overload] = @argument_list[overload].select {|k| @arguments[overload][k][:in_out] == 'OUT'}
+      end
+    end
+    
+    def overloaded?
+      @overloaded
     end
 
     def exec(*args)
+      # find which overloaded definition to use
+      # if definition is overloaded then match by number of arguments
+      if @overloaded
+        # named arguments
+        if args.size == 1 && args[0].is_a?(Hash)
+          number_of_args = args[0].keys.size
+          overload = @argument_list.keys.detect do |ov|
+            @argument_list[ov].size == number_of_args &&
+            @arguments[ov].keys.sort_by{|k| k.to_s} == args[0].keys.sort_by{|k| k.to_s}
+          end
+        # sequential arguments
+        # TODO: should try to implement matching by types of arguments
+        else
+          number_of_args = args.size
+          overload = @argument_list.keys.detect do |ov|
+            @argument_list[ov].size == number_of_args
+          end
+        end
+        raise ArgumentError, "Wrong number of arguments passed to overloaded PL/SQL procedure" unless overload
+      else
+        overload = 0
+      end
+
       sql = "BEGIN\n"
-      sql << ":return := " if @return
+      sql << ":return := " if @return[overload]
       sql << "#{@schema.schema_name}." if @schema
       sql << "#{@package}." if @package
       sql << "#{@procedure}("
+
       # Named arguments
       args_list = []
       args_hash = {}
       if args.size == 1 and args[0].is_a?(Hash)
         sql << args[0].map do |k,v|
-          raise ArgumentError, "Wrong argument passed to PL/SQL procedure" unless @arguments[k]
+          raise ArgumentError, "Wrong argument passed to PL/SQL procedure" unless @arguments[overload][k]
           args_list << k
           args_hash[k] = v
           "#{k.to_s} => :#{k.to_s}"
         end.join(', ')
-      # Sequential arguments      
+      # Sequential arguments
       else
-        raise ArgumentError, "Too many arguments passed to PL/SQL procedure" if args.size > @argument_list.size
+        raise ArgumentError, "Too many arguments passed to PL/SQL procedure" if args.size > @argument_list[overload].size
         # Add missing arguments with nil value
-        args = args + [nil]*(@argument_list.size-args.size) if args.size < @argument_list.size
+        args = args + [nil]*(@argument_list[overload].size-args.size) if args.size < @argument_list[overload].size
         i = 0
         sql << args.map do |v|
-          k = @argument_list[i]
+          k = @argument_list[overload][i]
           i += 1
           args_list << k
           args_hash[k] = v
@@ -102,24 +144,24 @@ module PLSQL
       cursor = @schema.connection.parse(sql)
       
       args_list.each do |k|
-        data_type, data_length = plsql_to_ruby_data_type(@arguments[k])
+        data_type, data_length = plsql_to_ruby_data_type(@arguments[overload][k])
         cursor.bind_param(":#{k.to_s}", ruby_value_to_ora_value(args_hash[k], data_type), data_type, data_length)
       end
       
-      if @return
-        data_type, data_length = plsql_to_ruby_data_type(@return)
+      if @return[overload]
+        data_type, data_length = plsql_to_ruby_data_type(@return[overload])
         cursor.bind_param(":return", nil, data_type, data_length)
       end
       
       cursor.exec
 
       # if function
-      if @return
+      if @return[overload]
         result = ora_value_to_ruby_value(cursor[':return'])
       # if procedure with output parameters
-      elsif @out_list.size > 0
+      elsif @out_list[overload].size > 0
         result = {}
-        @out_list.each do |k|
+        @out_list[overload].each do |k|
           result[k] = ora_value_to_ruby_value(cursor[":#{k}"])
         end
       # if procedure without output parameters
@@ -151,7 +193,9 @@ module PLSQL
     
     def ruby_value_to_ora_value(val, type)
       if type == OraNumber
-        val.is_a?(Bignum) ? val.to_f : val
+        val.is_a?(Fixnum) ? val : val.to_f
+      elsif type == DateTime
+        val ? val.to_datetime : nil
       else
         val
       end

data/lib/ruby_plsql/version.rb

@@ -2,7 +2,7 @@ module RubyPlsql #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 1
-    TINY  = 2
+    TINY  = 3
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/spec/plsql/procedure_spec.rb

@@ -1,5 +1,8 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
+require "rubygems"
+require "activerecord"
+
 describe "Procedure with string parameters" do
   
   before(:all) do
@@ -80,6 +83,12 @@ describe "Procedure with numeric parameters" do
     plsql.test_sum(123.123,456.456).should == 579.579
   end
 
+  it "should process BigDecimal parameters" do
+    plsql.test_sum(:p_num1 => BigDecimal.new("123.123"), :p_num2 => BigDecimal.new("456.456")).should == 579.579
+  end
+
+
+
 end
 
 describe "Procedure with date parameters" do
@@ -101,16 +110,30 @@ describe "Procedure with date parameters" do
     plsql.logoff
   end
   
-  it "should process date parameters" do
+  it "should process DateTime parameters" do
     now = DateTime.new(2008,8,12,14,28,0)
     plsql.test_date(now).should == now + 1
   end
 
-  it "should process old date parameters" do
+  it "should process old DateTime parameters" do
     now = DateTime.new(1900,1,1,12,0,0)
     plsql.test_date(now).should == now + 1
   end
 
+  it "should process Date parameters" do
+    now = Date.new(2008,8,12)
+    plsql.test_date(now).should == now + 1
+  end
+
+  it "should process old Date parameters" do
+    now = Date.new(1900,1,1)
+    plsql.test_date(now).should == now + 1
+  end
+
+  it "should process nil date parameters" do
+    plsql.test_date(nil).should be_nil
+  end
+
 end
 
 describe "Procedure with timestamp parameters" do
@@ -173,4 +196,93 @@ describe "Procedure with output parameters" do
     plsql.test_copy.should == { :p_to => nil, :p_to_double => nil }
   end
 
-end
+end
+
+describe "Package with procedures with same name but different argument lists" do
+  before(:all) do
+    plsql.connection = conn = OCI8.new("hr","hr","xe")
+    plsql.connection.exec <<-EOS
+      CREATE OR REPLACE PACKAGE test_package2 IS
+        FUNCTION test_procedure ( p_string VARCHAR2 )
+          RETURN VARCHAR2;
+        PROCEDURE test_procedure ( p_string VARCHAR2, p_result OUT VARCHAR2 )
+          ;
+        PROCEDURE test_procedure ( p_number NUMBER, p_result OUT VARCHAR2 )
+          ;
+        FUNCTION test_procedure2 ( p_string VARCHAR2 )
+          RETURN VARCHAR2;
+      END;
+    EOS
+    plsql.connection.exec <<-EOS
+      CREATE OR REPLACE PACKAGE BODY test_package2 IS
+        FUNCTION test_procedure ( p_string VARCHAR2 )
+          RETURN VARCHAR2
+        IS
+        BEGIN
+          RETURN UPPER(p_string);
+        END test_procedure;
+        PROCEDURE test_procedure ( p_string VARCHAR2, p_result OUT VARCHAR2 )
+        IS
+        BEGIN
+          p_result := UPPER(p_string);
+        END test_procedure;
+        PROCEDURE test_procedure ( p_number NUMBER, p_result OUT VARCHAR2 )
+        IS
+        BEGIN
+          p_result := LOWER(TO_CHAR(p_number));
+        END test_procedure;
+        FUNCTION test_procedure2 ( p_string VARCHAR2 )
+          RETURN VARCHAR2
+        IS
+        BEGIN
+          RETURN UPPER(p_string);
+        END test_procedure2;
+      END;
+    EOS
+
+  end
+  
+  after(:all) do
+    plsql.logoff
+  end
+    
+  it "should find existing package" do
+    PLSQL::Package.find(plsql, :test_package2).should_not be_nil
+  end
+
+  it "should identify overloaded procedure definition" do
+    @procedure = PLSQL::Procedure.find(plsql, :test_procedure, "TEST_PACKAGE2")
+    @procedure.should_not be_nil
+    @procedure.should be_overloaded
+  end
+
+  it "should identify non-overloaded procedure definition" do
+    @procedure = PLSQL::Procedure.find(plsql, :test_procedure2, "TEST_PACKAGE2")
+    @procedure.should_not be_nil
+    @procedure.should_not be_overloaded
+  end
+
+  it "should execute correct procedures based on number of arguments and return correct value" do
+    plsql.test_package2.test_procedure('xxx').should == 'XXX'
+    plsql.test_package2.test_procedure('xxx', nil).should == {:p_result => 'XXX'}
+  end
+
+  it "should execute correct procedures based on number of named arguments and return correct value" do
+    plsql.test_package2.test_procedure(:p_string => 'xxx').should == 'XXX'
+    plsql.test_package2.test_procedure(:p_string => 'xxx', :p_result => nil).should == {:p_result => 'XXX'}
+  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)
+  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 names of named arguments" do
+    plsql.test_package2.test_procedure(:p_number => 111, :p_result => nil).should == {:p_result => '111'}
+  end
+
+end

data/website/index.html

@@ -33,7 +33,7 @@
     <h1>Ruby API for PL/SQL</h1>
     <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/ruby-plsql"; return false'>
       <p>Get Version</p>
-      <a href="http://rubyforge.org/projects/ruby-plsql" class="numbers">0.1.2</a>
+      <a href="http://rubyforge.org/projects/ruby-plsql" class="numbers">0.1.3</a>
     </div>
     <h1>&#x2192; &#8216;ruby-plsql&#8217;</h1>
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-plsql
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors: 
 - Raimonds Simanovskis
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-04-02 00:00:00 +03:00
+date: 2008-04-16 00:00:00 +03:00
 default_executable: 
 dependencies: []