@@ -115,13 +115,18 @@ module PLSQL end def bind_param(arg, value, metadata) - type, length = @connection.plsql_to_ruby_data_type(metadata[:data_type], metadata[:data_length]) - ora_value = @connection.ruby_value_to_ora_value(value, type) - @connection.set_bind_variable(@statement, arg, ora_value, type, length) + type, length = @connection.plsql_to_ruby_data_type(metadata) + ora_value = @connection.ruby_value_to_ora_value(value, type, metadata) + @connection.set_bind_variable(@statement, arg, ora_value, type, length, metadata) if metadata[:in_out] =~ /OUT/ @out_types[arg] = type || ora_value.class @out_index[arg] = bind_param_index(arg) - @statement.registerOutParameter(@out_index[arg],@connection.get_java_sql_type(ora_value,type)) + if metadata[:data_type] == 'TABLE' + @statement.registerOutParameter(@out_index[arg], @connection.get_java_sql_type(ora_value,type), + metadata[:sql_type_name]) + else + @statement.registerOutParameter(@out_index[arg],@connection.get_java_sql_type(ora_value,type)) + end end end @@ -186,12 +191,14 @@ module PLSQL java.sql.Types::DATE when 'DateTime' java.sql.Types::DATE + when 'Java::OracleSql::ARRAY' + Java::oracle.jdbc.OracleTypes::ARRAY else java.sql.Types::VARCHAR end end - def set_bind_variable(stmt, i, value, type=nil, length=nil) + def set_bind_variable(stmt, i, value, type=nil, length=nil, metadata={}) key = i.kind_of?(Integer) ? nil : i.to_s.gsub(':','') case !value.nil? && type ? type.to_s : value.class.to_s when 'Fixnum', 'Bignum', 'Integer' @@ -209,7 +216,14 @@ module PLSQL when 'Date', 'Time', 'DateTime' stmt.send("setDATE#{key && "AtName"}", key || i, Java::oracle.sql.DATE.new(value.strftime("%Y-%m-%d %H:%M:%S"))) when 'NilClass' - stmt.send("setNull#{key && "AtName"}", key || i, get_java_sql_type(value, type)) + if metadata[:data_type] == 'TABLE' + stmt.send("setNull#{key && "AtName"}", key || i, get_java_sql_type(value, type), + metadata[:sql_type_name]) + else + stmt.send("setNull#{key && "AtName"}", key || i, get_java_sql_type(value, type)) + end + when 'Java::OracleSql::ARRAY' + stmt.send("setARRAY#{key && "AtName"}", key || i, value) end end @@ -236,6 +250,8 @@ module PLSQL else nil end + when 'Java::OracleSql::ARRAY' + stmt.getArray(i) end end @@ -273,7 +289,8 @@ module PLSQL end end - def plsql_to_ruby_data_type(data_type, data_length) + def plsql_to_ruby_data_type(metadata) + data_type, data_length = metadata[:data_type], metadata[:data_length] case data_type when "VARCHAR2" [String, data_length || 32767] @@ -287,12 +304,14 @@ module PLSQL [Time, nil] when "TIMESTAMP" [Time, nil] + when "TABLE" + [Java::OracleSql::ARRAY, nil] else [String, 32767] end end - def ruby_value_to_ora_value(val, type) + def ruby_value_to_ora_value(val, type, metadata={}) if type == BigDecimal case val when NilClass, Fixnum, BigDecimal @@ -329,6 +348,11 @@ module PLSQL else Java::OracleSql::BLOB.getEmptyBLOB end + elsif type == Java::OracleSql::ARRAY + if val + descriptor = Java::OracleSql::ArrayDescriptor.createDescriptor(metadata[:sql_type_name], raw_connection) + Java::OracleSql::ARRAY.new(descriptor, raw_connection, val.to_java) + end else val end @@ -338,6 +362,8 @@ module PLSQL case val when Float, BigDecimal ora_number_to_ruby_number(val) + when Java::JavaMath::BigDecimal + val && ora_number_to_ruby_number(BigDecimal.new(val.to_s)) when Java::OracleSql::CLOB if val.isEmptyLob nil @@ -350,6 +376,8 @@ module PLSQL else String.from_java_bytes(val.getBytes(1, val.length)) end + when Java::OracleSql::ARRAY + val.getArray.map{|e| ora_value_to_ruby_value(e)} else val end lib/plsql/jdbc_connection.rb @@ -73,7 +73,7 @@ module PLSQL end def bind_param(arg, value, metadata) - type, length = @connection.plsql_to_ruby_data_type(metadata[:data_type], metadata[:data_length]) + type, length = @connection.plsql_to_ruby_data_type(metadata) ora_value = @connection.ruby_value_to_ora_value(value, type) @raw_cursor.bind_param(arg, ora_value, type, length) end @@ -96,7 +96,8 @@ module PLSQL Cursor.new(sql, self) end - def plsql_to_ruby_data_type(data_type, data_length) + def plsql_to_ruby_data_type(metadata) + data_type, data_length = metadata[:data_type], metadata[:data_length] case data_type when "VARCHAR2" [String, data_length || 32767] @@ -110,8 +111,11 @@ module PLSQL [DateTime, nil] when "TIMESTAMP" [Time, nil] - # CLOB - # BLOB + when "TABLE" + # create Ruby class for collection + klass = Class.new(OCI8::Object::Base) + klass.set_typename metadata[:sql_type_name] + [klass, nil] else [String, 32767] end @@ -169,6 +173,10 @@ module PLSQL else nil end + when OCI8::Object::Base + if val.instance_variable_get(:@attributes).is_a? Array + val.to_ary.map{|e| ora_value_to_ruby_value(e)} + end else val end lib/plsql/oci_connection.rb @@ -69,26 +69,30 @@ module PLSQL ", @schema_name, @package ? @package : @procedure )[0] rescue nil num_rows = @schema.connection.select_all(" - SELECT a.argument_name, a.position, a.sequence, a.data_level, - a.data_type, a.in_out, a.data_length, a.data_precision, a.data_scale, a.char_used, a.overload - FROM all_arguments a - WHERE a.object_id = :object_id - AND a.owner = :owner - AND a.object_name = :procedure_name - AND NVL(a.package_name,'nil') = :package - ORDER BY a.overload, a.sequence + SELECT overload, argument_name, position, data_level, + data_type, in_out, data_length, data_precision, data_scale, char_used, + type_owner, type_name, type_subname + FROM all_arguments + WHERE object_id = :object_id + AND owner = :owner + AND object_name = :procedure_name + AND NVL(package_name,'nil') = :package + ORDER BY overload, sequence ", object_id, @schema_name, @procedure, @package ? @package : 'nil' ) do |r| - argument_name, position, sequence, data_level, - data_type, in_out, data_length, data_precision, data_scale, char_used, overload = r + overload, argument_name, position, data_level, + data_type, in_out, data_length, data_precision, data_scale, char_used, + type_owner, type_name, type_subname = r @overloaded ||= !overload.nil? # if not overloaded then store arguments at key 0 overload ||= 0 @arguments[overload] ||= {} @return[overload] ||= nil - + + raise ArgumentError, "Parameter type definition inside package is not supported, use CREATE TYPE outside package" if type_subname + argument_metadata = { :position => position && position.to_i, :data_type => data_type, @@ -96,7 +100,11 @@ module PLSQL :data_length => data_length && data_length.to_i, :data_precision => data_precision && data_precision.to_i, :data_scale => data_scale && data_scale.to_i, - :char_used => char_used + :char_used => char_used, + :type_owner => type_owner, + :type_name => type_name, + :type_subname => type_subname, + :sql_type_name => "#{type_owner}.#{type_name}" } if composite_type?(data_type) case data_type @@ -116,6 +124,8 @@ module PLSQL case previous_level_argument_metadata[data_level - 1][:data_type] when 'PL/SQL RECORD' previous_level_argument_metadata[data_level - 1][:fields][argument_name.downcase.to_sym] = argument_metadata + when 'TABLE' + previous_level_argument_metadata[data_level - 1][:element] = argument_metadata end end # if function has return value lib/plsql/procedure.rb @@ -44,25 +44,25 @@ describe "Connection" do if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby' describe "OCI data type conversions" do it "should translate PL/SQL VARCHAR2 to Ruby String" do - @conn.plsql_to_ruby_data_type("VARCHAR2", 100).should == [String, 100] - @conn.plsql_to_ruby_data_type("VARCHAR2", nil).should == [String, 32767] + @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] end it "should translate PL/SQL CLOB to Ruby String" do - @conn.plsql_to_ruby_data_type("CLOB", 100_000).should == [OCI8::CLOB, nil] - @conn.plsql_to_ruby_data_type("CLOB", nil).should == [OCI8::CLOB, nil] + @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] end it "should translate PL/SQL NUMBER to Ruby OraNumber" do - @conn.plsql_to_ruby_data_type("NUMBER", 15).should == [OraNumber, nil] + @conn.plsql_to_ruby_data_type(:data_type => "NUMBER", :data_length => 15).should == [OraNumber, nil] end it "should translate PL/SQL DATE to Ruby DateTime" do - @conn.plsql_to_ruby_data_type("DATE", nil).should == [DateTime, nil] + @conn.plsql_to_ruby_data_type(:data_type => "DATE", :data_length => nil).should == [DateTime, nil] end it "should translate PL/SQL TIMESTAMP to Ruby Time" do - @conn.plsql_to_ruby_data_type("TIMESTAMP", nil).should == [Time, nil] + @conn.plsql_to_ruby_data_type(:data_type => "TIMESTAMP", :data_length => nil).should == [Time, nil] end it "should not translate Ruby Fixnum when OraNumber type specified" do @@ -114,20 +114,20 @@ 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("VARCHAR2", 100).should == [String, 100] - @conn.plsql_to_ruby_data_type("VARCHAR2", nil).should == [String, 32767] + @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] end it "should translate PL/SQL NUMBER to Ruby BigDecimal" do - @conn.plsql_to_ruby_data_type("NUMBER", 15).should == [BigDecimal, nil] + @conn.plsql_to_ruby_data_type(:data_type => "NUMBER", :data_length => 15).should == [BigDecimal, nil] end it "should translate PL/SQL DATE to Ruby DateTime" do - @conn.plsql_to_ruby_data_type("DATE", nil).should == [Time, nil] + @conn.plsql_to_ruby_data_type(:data_type => "DATE", :data_length => nil).should == [Time, nil] end it "should translate PL/SQL TIMESTAMP to Ruby Time" do - @conn.plsql_to_ruby_data_type("TIMESTAMP", nil).should == [Time, nil] + @conn.plsql_to_ruby_data_type(:data_type => "TIMESTAMP", :data_length => nil).should == [Time, nil] end it "should not translate Ruby Fixnum when BigDecimal type specified" do spec/plsql/connection_spec.rb @@ -681,6 +681,136 @@ describe "Function with boolean parameters" do end +describe "Function with table parameter" do + + before(:all) do + plsql.connection = get_connection + + # Array of numbers + plsql.connection.exec <<-SQL + CREATE OR REPLACE TYPE t_numbers AS TABLE OF NUMBER(15) + SQL + plsql.connection.exec <<-SQL + CREATE OR REPLACE FUNCTION test_sum (p_numbers IN t_numbers) + RETURN NUMBER + IS + l_sum NUMBER(15) := 0; + BEGIN + IF p_numbers.COUNT > 0 THEN + FOR i IN p_numbers.FIRST..p_numbers.LAST LOOP + IF p_numbers.EXISTS(i) THEN + l_sum := l_sum + p_numbers(i); + END IF; + END LOOP; + RETURN l_sum; + ELSE + RETURN NULL; + END IF; + END; + SQL + + plsql.connection.exec <<-SQL + CREATE OR REPLACE FUNCTION test_increment(p_numbers IN t_numbers, p_increment_by IN NUMBER DEFAULT 1) + RETURN t_numbers + IS + l_numbers t_numbers := t_numbers(); + BEGIN + FOR i IN p_numbers.FIRST..p_numbers.LAST LOOP + IF p_numbers.EXISTS(i) THEN + l_numbers.EXTEND; + l_numbers(i) := p_numbers(i) + p_increment_by; + END IF; + END LOOP; + RETURN l_numbers; + END; + SQL + + # Array of strings + plsql.connection.exec <<-SQL + CREATE OR REPLACE TYPE t_strings AS TABLE OF VARCHAR2(4000) + SQL + plsql.connection.exec <<-SQL + CREATE OR REPLACE FUNCTION test_copy_strings(p_strings IN t_strings, x_strings OUT t_strings) + RETURN t_strings + IS + BEGIN + x_strings := t_strings(); + FOR i IN p_strings.FIRST..p_strings.LAST LOOP + IF p_strings.EXISTS(i) THEN + x_strings.EXTEND; + x_strings(i) := p_strings(i); + END IF; + END LOOP; + RETURN x_strings; + END; + SQL + + # Wrong type definition inside package + plsql.connection.exec <<-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; + END; + SQL + plsql.connection.exec <<-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; + BEGIN + IF p_numbers.COUNT > 0 THEN + FOR i IN p_numbers.FIRST..p_numbers.LAST LOOP + IF p_numbers.EXISTS(i) THEN + l_sum := l_sum + p_numbers(i); + END IF; + END LOOP; + RETURN l_sum; + ELSE + RETURN NULL; + END IF; + END; + END; + SQL + end + + after(:all) do + plsql.connection.exec "DROP FUNCTION test_sum" + plsql.connection.exec "DROP FUNCTION test_increment" + plsql.connection.exec "DROP FUNCTION test_copy_strings" + plsql.connection.exec "DROP PACKAGE test_collections" + plsql.connection.exec "DROP TYPE t_numbers" + plsql.connection.exec "DROP TYPE t_strings" + plsql.logoff + end + + it "should find existing function" do + PLSQL::Procedure.find(plsql, :test_sum).should_not be_nil + end + + it "should execute function with number array parameter" do + plsql.test_sum([1,2,3,4]).should == 10 + end + + it "should return number array return value" do + plsql.test_increment([1,2,3,4], 1).should == [2,3,4,5] + end + + it "should execute function with string array and return string array output parameter" do + pending "ruby-oci8 gives segmentation fault" if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby' + strings = ['1','2','3','4'] + 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) + end + +end + describe "Synonym to function" do before(:all) do spec/plsql/procedure_spec.rb @@ -6,6 +6,11 @@ gem "activerecord" require "activerecord" gem "activerecord-oracle_enhanced-adapter" +if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby' + # gem "ruby-oci8", "=2.0.2" + gem "ruby-oci8", "=2.0.3" +end + $:.unshift(File.dirname(__FILE__) + '/../lib') require "ruby_plsql" spec/spec_helper.rb 5205dca79cd277eb74c9f58d49d3a6052ede91ae Raimonds Simanovskis raimonds.simanovskis@gmail.com http://github.com/rsim/ruby-plsql/commit/b9894be4a5aea44da568b0e4d7c3154591d804fe b9894be4a5aea44da568b0e4d7c3154591d804fe 2009-11-01T15:00:02-08:00 2009-11-01T15:00:02-08:00 initial implementation of PL/SQL collection type (TABLE OF) parameters 38874fc77c275a7bbdcc7a9be2c51800c622c3c8 Raimonds Simanovskis raimonds.simanovskis@gmail.com