@@ -111,74 +111,118 @@ module PLSQL [DateTime, nil] when "TIMESTAMP" [Time, nil] - when "TABLE" + when "TABLE", "OBJECT" # create Ruby class for collection - klass = Class.new(OCI8::Object::Base) - klass.set_typename metadata[:sql_type_name] + klass = OCI8::Object::Base.get_class_by_typename(metadata[:sql_type_name]) + unless klass + klass = Class.new(OCI8::Object::Base) + klass.set_typename metadata[:sql_type_name] + end [klass, nil] else [String, 32767] end end - def ruby_value_to_ora_value(val, type) - if type == OraNumber + def ruby_value_to_ora_value(value, type=nil) + type ||= value.class + case type.to_s.to_sym + when :Fixnum, :BigDecimal, :String + value + when :OraNumber # pass parameters as OraNumber to avoid rounding errors - case val + case value when Bignum - OraNumber.new(val.to_s) + OraNumber.new(value.to_s) when BigDecimal - OraNumber.new(val.to_s('F')) + OraNumber.new(value.to_s('F')) when TrueClass OraNumber.new(1) when FalseClass OraNumber.new(0) else - val + value end - elsif type == DateTime - case val + when :DateTime + case value when Time - ::DateTime.civil(val.year, val.month, val.day, val.hour, val.min, val.sec, Rational(val.utc_offset, 86400)) + ::DateTime.civil(value.year, value.month, value.day, value.hour, value.min, value.sec, Rational(value.utc_offset, 86400)) when DateTime - val + value when Date - ::DateTime.civil(val.year, val.month, val.day, 0, 0, 0, 0) + ::DateTime.civil(value.year, value.month, value.day, 0, 0, 0, 0) else - val + value end - elsif type == OCI8::CLOB - # ruby-oci8 cannot create CLOB from '' - val = nil if val == '' - OCI8::CLOB.new(raw_oci_connection, val) - elsif type == OCI8::BLOB - # ruby-oci8 cannot create BLOB from '' - val = nil if val == '' - OCI8::BLOB.new(raw_oci_connection, val) + when :"OCI8::CLOB", :"OCI8::BLOB" + # ruby-oci8 cannot create CLOB/BLOB from '' + value = nil if value == '' + type.new(raw_oci_connection, value) else - val + # collections and object types + if type.superclass == OCI8::Object::Base + return nil if value.nil? + tdo = raw_oci_connection.get_tdo_by_class(type) + if tdo.is_collection? + raise ArgumentError, "You should pass Array value for collection type parameter" unless value.is_a?(Array) + elem_list = value.map do |elem| + if (attr_tdo = tdo.coll_attr.typeinfo) + attr_type, attr_length = plsql_to_ruby_data_type(:data_type => 'OBJECT', :sql_type_name => attr_tdo.typename) + else + attr_type = elem.class + end + ruby_value_to_ora_value(elem, attr_type) + end + # construct collection value + # TODO: change setting instance variable to appropriate ruby-oci8 method call when available + collection = type.new(raw_oci_connection) + collection.instance_variable_set('@attributes', elem_list) + collection + else # object type + raise ArgumentError, "You should pass Hash value for object type parameter" unless value.is_a?(Hash) + object_attrs = value.dup + object_attrs.keys.each do |key| + raise ArgumentError, "Wrong object type field passed to PL/SQL procedure" unless (attr = tdo.attr_getters[key]) + case attr.datatype + when OCI8::TDO::ATTR_NAMED_TYPE, OCI8::TDO::ATTR_NAMED_COLLECTION + # nested object type or collection + attr_type, attr_length = plsql_to_ruby_data_type(:data_type => 'OBJECT', :sql_type_name => attr.typeinfo.typename) + object_attrs[key] = ruby_value_to_ora_value(object_attrs[key], attr_type) + end + end + type.new(raw_oci_connection, object_attrs) + end + # all other cases + else + value + end end end - def ora_value_to_ruby_value(val) - case val + def ora_value_to_ruby_value(value) + case value when Float, OraNumber - ora_number_to_ruby_number(val) + ora_number_to_ruby_number(value) when DateTime, OraDate - ora_date_to_ruby_date(val) + ora_date_to_ruby_date(value) when OCI8::LOB - if val.available? - val.rewind - val.read + if value.available? + value.rewind + value.read 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)} + tdo = raw_oci_connection.get_tdo_by_class(value.class) + if tdo.is_collection? + value.to_ary.map{|e| ora_value_to_ruby_value(e)} + else # object type + Hash[tdo.attributes.map do |attr| + [attr.name, ora_value_to_ruby_value(value.instance_variable_get(:@attributes)[attr.name])] + end] end else - val + value end end lib/plsql/oci_connection.rb @@ -143,7 +143,7 @@ module PLSQL end end - PLSQL_COMPOSITE_TYPES = ['PL/SQL RECORD', 'TABLE', 'OBJECT', 'REF CURSOR'].freeze + PLSQL_COMPOSITE_TYPES = ['PL/SQL RECORD', 'TABLE'].freeze def composite_type?(data_type) PLSQL_COMPOSITE_TYPES.include? data_type end lib/plsql/procedure.rb @@ -72,11 +72,11 @@ module PLSQL # Named arguments if args.size == 1 && args[0].is_a?(Hash) && - # do not use named arguments if procedure has just one PL/SQL record argument - + # do not use named arguments if procedure has just one PL/SQL record or object type argument - # in that case passed Hash should be used as value for this PL/SQL record argument # (which will be processed in sequential arguments bracnh) !(argument_list.size == 1 && - arguments[(only_argument=argument_list[0])][:data_type] == 'PL/SQL RECORD' && + ['PL/SQL RECORD','OBJECT'].include?(arguments[(only_argument=argument_list[0])][:data_type]) && args[0].keys != [only_argument]) @call_sql << args[0].map do |arg, value| "#{arg} => " << add_argument(arg, value) lib/plsql/procedure_call.rb @@ -681,6 +681,113 @@ describe "Function with boolean parameters" do end +describe "Function with object type parameter" do + + before(:all) do + plsql.connection = get_connection + plsql.connection.exec "DROP TYPE t_employee" rescue nil + plsql.connection.exec "DROP TYPE t_phones" rescue nil + plsql.connection.exec <<-SQL + CREATE OR REPLACE TYPE t_address AS OBJECT ( + street VARCHAR2(50), + city VARCHAR2(50), + country VARCHAR2(50) + ) + SQL + plsql.connection.exec <<-SQL + CREATE OR REPLACE TYPE t_phone AS OBJECT ( + type VARCHAR2(10), + phone_number VARCHAR2(50) + ) + SQL + plsql.connection.exec <<-SQL + CREATE OR REPLACE TYPE t_phones AS TABLE OF T_PHONE + SQL + plsql.connection.exec <<-SQL + CREATE OR REPLACE TYPE t_employee AS OBJECT ( + employee_id NUMBER(15), + first_name VARCHAR2(50), + last_name VARCHAR2(50), + hire_date DATE, + address t_address, + phones t_phones + ) + SQL + plsql.connection.exec <<-SQL + CREATE OR REPLACE FUNCTION test_full_name (p_employee t_employee) + RETURN VARCHAR2 + IS + BEGIN + RETURN p_employee.first_name || ' ' || p_employee.last_name; + END; + SQL + plsql.connection.exec <<-SQL + CREATE OR REPLACE FUNCTION test_employee_object (p_employee t_employee) + RETURN t_employee + IS + BEGIN + RETURN p_employee; + END; + SQL + plsql.connection.exec <<-SQL + CREATE OR REPLACE FUNCTION test_employee_object2 (p_employee t_employee, x_employee OUT t_employee) + RETURN t_employee + IS + BEGIN + x_employee := p_employee; + RETURN p_employee; + END; + SQL + @p_employee = { + :employee_id => 1, + :first_name => 'First', + :last_name => 'Last', + :hire_date => Time.local(2000,01,31), + :address => {:street => 'Main street 1', :city => 'Riga', :country => 'Latvia'}, + :phones => [{:type => 'mobile', :phone_number => '123456'}, {:type => 'home', :phone_number => '654321'}] + } + end + + after(:all) do + plsql.connection.exec "DROP FUNCTION test_full_name" + plsql.connection.exec "DROP FUNCTION test_employee_object" + plsql.connection.exec "DROP FUNCTION test_employee_object2" + plsql.connection.exec "DROP TYPE t_employee" + plsql.connection.exec "DROP TYPE t_address" + plsql.connection.exec "DROP TYPE t_phones" + plsql.connection.exec "DROP TYPE t_phone" + plsql.logoff + end + + it "should find existing function" do + PLSQL::Procedure.find(plsql, :test_full_name).should_not be_nil + end + + it "should execute function with named parameter and return correct value" do + plsql.test_full_name(:p_employee => @p_employee).should == 'First Last' + end + + it "should execute function with sequential parameter and return correct value" do + plsql.test_full_name(@p_employee).should == 'First Last' + end + + it "should raise error if wrong field name is passed for record parameter" do + lambda do + plsql.test_full_name(@p_employee.merge :xxx => 'xxx') + end.should raise_error(ArgumentError) + end + + it "should return object type return value" do + plsql.test_employee_object(@p_employee).should == @p_employee + end + + it "should return object type return value and output object type parameter value" do + plsql.test_employee_object2(@p_employee, nil).should == [@p_employee, {:x_employee => @p_employee}] + end + +end + + describe "Function with table parameter" do before(:all) do @@ -773,6 +880,26 @@ describe "Function with table parameter" do END; END; SQL + + # Array of objects + plsql.connection.exec <<-SQL + CREATE OR REPLACE TYPE t_phone AS OBJECT ( + type VARCHAR2(10), + phone_number VARCHAR2(50) + ) + SQL + plsql.connection.exec <<-SQL + CREATE OR REPLACE TYPE t_phones AS TABLE OF T_PHONE + SQL + plsql.connection.exec <<-SQL + CREATE OR REPLACE FUNCTION test_copy_objects(p_phones IN t_phones, x_phones OUT t_phones) + RETURN t_phones + IS + BEGIN + x_phones := p_phones; + RETURN x_phones; + END; + SQL end after(:all) do @@ -782,6 +909,8 @@ describe "Function with table parameter" do plsql.connection.exec "DROP PACKAGE test_collections" plsql.connection.exec "DROP TYPE t_numbers" plsql.connection.exec "DROP TYPE t_strings" + plsql.connection.exec "DROP TYPE t_phones" + plsql.connection.exec "DROP TYPE t_phone" plsql.logoff end @@ -798,7 +927,6 @@ describe "Function with table parameter" do 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 @@ -809,6 +937,16 @@ describe "Function with table parameter" do end.should raise_error(ArgumentError) end + it "should execute function with object array and return object array output parameter" do + phones = [{:type => 'mobile', :phone_number => '123456'}, {:type => 'home', :phone_number => '654321'}] + plsql.test_copy_objects(phones).should == [phones, {:x_phones => phones}] + end + + it "should execute function with empty object array" do + phones = [] + plsql.test_copy_objects(phones).should == [phones, {:x_phones => phones}] + end + end describe "Synonym to function" do spec/plsql/procedure_spec.rb @@ -8,7 +8,7 @@ gem "activerecord-oracle_enhanced-adapter" if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby' # gem "ruby-oci8", "=2.0.2" - gem "ruby-oci8", "=2.0.3" + gem "ruby-oci8", ">=2.0.3" end $:.unshift(File.dirname(__FILE__) + '/../lib') spec/spec_helper.rb b9894be4a5aea44da568b0e4d7c3154591d804fe Raimonds Simanovskis raimonds.simanovskis@gmail.com http://github.com/rsim/ruby-plsql/commit/7c6fd0d7ae9a4f43a78d21931530bf2909cba706 7c6fd0d7ae9a4f43a78d21931530bf2909cba706 2009-11-04T08:36:23-08:00 2009-11-04T08:36:23-08:00 support for object type and collection of object type parameters when using MRI / ruby-oci8 47b1d8181e72142c354bda43c4b75b741c74444b Raimonds Simanovskis raimonds.simanovskis@gmail.com