ruby-oci8 2.0.2 → 2.0.3

data/lib/oci8/object.rb

@@ -84,7 +84,7 @@ EOS
           csr.bind_param(key, nil, :named_type_internal, tdo)
           csr[key].attributes = val
         else
-          csr.bind_param(key, val)
+          csr.bind_param(key, val ? val : '')
         end
       end
       csr.exec
@@ -425,6 +425,9 @@ EOS
       'INTERVAL DAY TO SECOND'  => :interval_ds,
     }
 
+    # for datetime_to_array and ocidate_to_datetime
+    extend OCI8::BindType::Util
+
     def self.check_metadata(con, metadata)
       case metadata.typecode
       when :char, :varchar, :varchar2
@@ -437,6 +440,11 @@ EOS
         [ATTR_INTEGER,   nil, SIZE_OF_OCINUMBER, 2, ALIGNMENT_OF_OCINUMBER]
       when :real, :double, :float
         [ATTR_FLOAT,     nil, SIZE_OF_OCINUMBER, 2, ALIGNMENT_OF_OCINUMBER]
+      when :date
+        [ATTR_OCIDATE,   nil, SIZE_OF_OCIDATE, 2, ALIGNMENT_OF_OCIDATE,
+         Proc.new do |val| datetime_to_array(val, false) end, # set_proc
+         Proc.new do |val| ocidate_to_datetime(val) end, # get_proc
+        ]
       when :binary_double
         [ATTR_BINARY_DOUBLE, nil, SIZE_OF_DOUBLE, 2, ALIGNMENT_OF_DOUBLE]
       when :binary_float
@@ -461,11 +469,13 @@ EOS
       attr_reader :alignment
       attr_reader :datatype
       attr_reader :typeinfo
+      attr_reader :set_proc
+      attr_reader :get_proc
       def initialize(con, metadata, val_offset, ind_offset)
         if metadata.respond_to? :name
           @name = metadata.name.downcase.intern
         end
-        @datatype, @typeinfo, @val_size, @ind_size, @alignment, = OCI8::TDO.check_metadata(con, metadata)
+        @datatype, @typeinfo, @val_size, @ind_size, @alignment, @set_proc, @get_proc, = OCI8::TDO.check_metadata(con, metadata)
         @val_offset = (val_offset + @alignment - 1) & ~(@alignment - 1)
         @ind_offset = ind_offset
       end
@@ -485,7 +495,9 @@ EOS
     def attributes
       attrs = {}
       tdo.attributes.each do |attr|
-        attrs[attr.name] = get_attribute(attr.datatype, attr.typeinfo, attr.val_offset, attr.ind_offset)
+        attr_val = get_attribute(attr.datatype, attr.typeinfo, attr.val_offset, attr.ind_offset)
+        attr_val = attr.get_proc.call(attr_val) if attr.get_proc
+        attrs[attr.name] = attr_val
       end
       attrs
     end
@@ -493,7 +505,9 @@ EOS
     def attributes=(obj)
       obj = obj.instance_variable_get(:@attributes) unless obj.is_a? Hash
       tdo.attributes.each do |attr|
-        set_attribute(attr.datatype, attr.typeinfo, attr.val_offset, attr.ind_offset, obj[attr.name])
+        attr_val = obj[attr.name]
+        attr_val = attr.set_proc.call(attr_val) if attr.set_proc
+        set_attribute(attr.datatype, attr.typeinfo, attr.val_offset, attr.ind_offset, attr_val)
       end
     end
   end

data/lib/oci8/oci8.rb

@@ -1,16 +1,28 @@
-#--
-# oci8.rb -- OCI8 and OCI8::Cursor
+# oci8.rb -- implements OCI8 and OCI8::Cursor
 #
 # Copyright (C) 2002-2009 KUBO Takehiro <kubo@jiubao.org>
 #
 # Original Copyright is:
 #   Oracle module for Ruby
 #   1998-2000 by yoshidam
-#++
+#
 
 require 'date'
 
-# The database connection class.
+# A connection to a Oracle database server.
+#
+# example:
+#   # output the emp table's content as CSV format.
+#   conn = OCI8.new(username, password)
+#   conn.exec('select * from emp') do |row|
+#     puts row.join(',')
+#   end
+#
+#   # execute PL/SQL block with bind variables.
+#   conn = OCI8.new(username, password)
+#   conn.exec('BEGIN procedure_name(:1, :2); END;',
+#              value_for_the_first_parameter,
+#              value_for_the_second_parameter)
 class OCI8
   # Executes the sql statement. The type of return value depends on
   # the type of sql statement: select; insert, update and delete;
@@ -331,6 +343,10 @@ class OCI8
       end
       
       bindclass = OCI8::BindType::Mapping[type]
+      if bindclass.nil? and type.is_a? Class
+        bindclass = OCI8::BindType::Mapping[type.to_s]
+        OCI8::BindType::Mapping[type] = bindclass if bindclass
+      end
       raise "unsupported dataType: #{type}" if bindclass.nil?
       bindobj = bindclass.create(@con, var_array, param, @max_array_size)
       __bind(key, bindobj)
@@ -440,6 +456,10 @@ class OCI8
       end
 
       bindclass = OCI8::BindType::Mapping[key]
+      if bindclass.nil? and key.is_a? Class
+        bindclass = OCI8::BindType::Mapping[key.to_s]
+        OCI8::BindType::Mapping[key] = bindclass if bindclass
+      end
       raise "unsupported datatype: #{key}" if bindclass.nil?
       bindclass.create(@con, val, param, max_array_size)
     end

data/test/test_appinfo.rb

@@ -23,6 +23,40 @@ class TestAppInfo < Test::Unit::TestCase
     assert_nil(@conn.select_one("SELECT SYS_CONTEXT('USERENV', 'CLIENT_IDENTIFIER') FROM DUAL")[0]);
   end
 
+  def test_set_module
+    # FIXME: check again after upgrading Oracle 9.2 to 9.2.0.4.
+    return if @conn.oracle_server_version < OCI8::ORAVER_10_1
+
+    # set module
+    @conn.module = 'ruby-oci8'
+    assert_equal('ruby-oci8', @conn.select_one("SELECT SYS_CONTEXT('USERENV', 'MODULE') FROM DUAL")[0]);
+    # clear module
+    @conn.module = nil
+    assert_nil(@conn.select_one("SELECT SYS_CONTEXT('USERENV', 'MODULE') FROM DUAL")[0]);
+  end
+
+  def test_set_action
+    # FIXME: check again after upgrading Oracle 9.2 to 9.2.0.4.
+    return if @conn.oracle_server_version < OCI8::ORAVER_10_1
+
+    # set action
+    @conn.action = 'test_set_action'
+    assert_equal('test_set_action', @conn.select_one("SELECT SYS_CONTEXT('USERENV', 'ACTION') FROM DUAL")[0]);
+    # clear action
+    @conn.action = nil
+    assert_nil(@conn.select_one("SELECT SYS_CONTEXT('USERENV', 'ACTION') FROM DUAL")[0]);
+  end
+
+  def test_set_client_info
+    # set client_info
+    client_info = "ruby-oci8:#{Process.pid()}"
+    @conn.client_info = client_info
+    assert_equal(client_info, @conn.select_one("SELECT SYS_CONTEXT('USERENV', 'CLIENT_INFO') FROM DUAL")[0]);
+    # clear client_info
+    @conn.client_info = nil
+    assert_nil(@conn.select_one("SELECT SYS_CONTEXT('USERENV', 'CLIENT_INFO') FROM DUAL")[0]);
+  end
+
   def teardown
     @conn.logoff
   end

data/test/test_clob.rb

@@ -39,6 +39,19 @@ class TestCLob < Test::Unit::TestCase
     lob.close
   end
 
+  def test_insert_symbol
+    filename = 'test_symbol'
+    value = :foo_bar
+    @conn.exec("DELETE FROM test_clob WHERE filename = :1", filename)
+    @conn.exec("INSERT INTO test_clob(filename, content) VALUES (:1, EMPTY_CLOB())", filename)
+    cursor = @conn.exec("SELECT content FROM test_clob WHERE filename = :1 FOR UPDATE", filename)
+    lob = cursor.fetch[0]
+    lob.write(value)
+    lob.rewind
+    assert_equal(value.to_s, lob.read);
+    lob.close
+  end
+
   def test_read
     test_insert() # first insert data.
     filename = File.basename($lobfile)

data/test/test_datetime.rb

@@ -13,6 +13,31 @@ class TestDateTime < Test::Unit::TestCase
     end
   end
 
+  def string_to_time(str)
+    /(\d+)-(\d+)-(\d+) ?(?:(\d+):(\d+):(\d+))?(?:\.(\d+))? ?([+-]\d+:\d+)?/ =~ str
+    args = []
+    args << $1.to_i # year
+    args << $2.to_i # month
+    args << $3.to_i # day
+    args << $4.to_i if $4 # hour
+    args << $5.to_i if $5 # minute
+    if $8
+      args << $6.to_i + $7.to_i.to_r / ('1' + '0' * ($7.length)).to_i
+      args << $8
+      Time.new(*args)
+    else
+      if $6
+        args << $6.to_i
+      end
+      if $7
+        args << $7.to_i.to_r * 1000000 / ('1' + '0' * ($7.length)).to_i
+      end
+      # no time zone
+      Time.local(*args)
+    end
+    #Time.local(*str.split(/[- :\.]/).collect do |n| n.to_i; end)
+  end
+
   def setup
     @conn = get_oci8_connection
     @local_timezone = timezone_string(*((::Time.now.utc_offset / 60).divmod 60))
@@ -129,7 +154,12 @@ EOS
       @conn.exec(<<-EOS) do |row|
 SELECT TO_TIMESTAMP_TZ('#{date}', 'YYYY-MM-DD HH24:MI:SS.FF TZH:TZM') FROM dual
 EOS
-        assert_equal(DateTime.parse(date), row[0])
+        expected_val = begin
+                         string_to_time(date)
+                       rescue
+                         DateTime.parse(date)
+                       end
+        assert_equal(expected_val, row[0])
       end
     end
   end
@@ -274,6 +304,7 @@ EOS
               when Time
                 assert_equal(tz, timezone_string(*((dt.utc_offset / 60).divmod 60)))
               when DateTime
+                tz = tz.gsub(/:/, '') if RUBY_VERSION <= '1.8.5'
                 assert_equal(tz, dt.zone)
               else
                 flunk "unexpedted type #{dt.class}"
@@ -352,9 +383,14 @@ EOS
     cursor.bind_param(:out, nil, String, 36)
     cursor.bind_param(:in1, nil, String, 36)
     cursor.bind_param(:in2, nil, :interval_ym)
-    [['2006-01-01', -22],
-     ['2006-01-01', -10],
+    [['2006-01-01', -25],
+     ['2006-01-01', -24],
+     ['2006-01-01', -23],
+     ['2006-01-01', -13],
+     ['2006-01-01', -12],
+     ['2006-01-01', -11],
      ['2006-01-01',  +2],
+     ['2006-01-01',  -2],
      ['2006-01-01', +12]
     ].each do |date, interval|
       cursor[:in1] = date
@@ -388,7 +424,7 @@ SELECT (TO_TIMESTAMP('#{date1}', 'YYYY-MM-DD HH24:MI:SS.FF')
       - TO_TIMESTAMP('#{date2}', 'YYYY-MM-DD HH24:MI:SS.FF')) DAY(3) TO SECOND
   FROM dual
 EOS
-        assert_equal(DateTime.parse(date1) - DateTime.parse(date2), row[0])
+        assert_in_delta(string_to_time(date1) - string_to_time(date2), row[0], 0.0000000001)
       end
     end
   end
@@ -427,7 +463,7 @@ EOS
       cursor[:in1] = date1
       cursor[:in2] = date2
       cursor.exec
-      assert_equal(DateTime.parse(date1) - DateTime.parse(date2), cursor[:out])
+      assert_in_delta(string_to_time(date1) - string_to_time(date2), cursor[:out], 0.0000000001)
     end
     cursor.close
   end
@@ -440,7 +476,7 @@ DECLARE
   ts1 TIMESTAMP;
 BEGIN
   ts1 := TO_TIMESTAMP(:in1, 'YYYY-MM-DD HH24:MI:SS.FF');
-  :out := TO_CHAR(ts1 + :in2, 'YYYY-MM-DD HH24:MI:SS.FF');
+  :out := TO_CHAR(ts1 + :in2, 'YYYY-MM-DD HH24:MI:SS.FF6');
 END;
 EOS
     cursor.bind_param(:out, nil, String, 36)
@@ -459,11 +495,128 @@ EOS
      ['2006-01-01', +1.to_r / (24*60*60)], # one second
      ['2006-01-01', +999999.to_r / (24*60*60*1000000)] # 0.999999 seconds
     ].each do |date, interval|
+      interval *= 86400
       cursor[:in1] = date
       cursor[:in2] = interval
       cursor.exec
-      assert_equal(DateTime.parse(date) + interval, DateTime.parse(cursor[:out]))
+      assert_equal(string_to_time(date) + interval, string_to_time(cursor[:out]))
+    end
+    cursor.close
+  end
+
+  def test_days_interval_ds_select
+    return if $oracle_version < OCI8::ORAVER_9_0
+
+    [['2006-01-01', '2004-03-01'],
+     ['2006-01-01', '2005-03-01'],
+     ['2006-01-01', '2006-03-01'],
+     ['2006-01-01', '2007-03-01'],
+     ['2006-01-01', '2006-01-01 23:00:00'],
+     ['2006-01-01', '2006-01-01 00:59:00'],
+     ['2006-01-01', '2006-01-01 00:00:59'],
+     ['2006-01-01', '2006-01-01 00:00:00.999999'],
+     ['2006-01-01', '2006-01-01 23:59:59.999999'],
+     ['2006-01-01', '2005-12-31 23:00:00'],
+     ['2006-01-01', '2005-12-31 00:59:00'],
+     ['2006-01-01', '2005-12-31 00:00:59'],
+     ['2006-01-01', '2005-12-31 00:00:00.999999'],
+     ['2006-01-01', '2005-12-31 23:59:59.999999']
+    ].each do |date1, date2|
+      begin
+        OCI8::BindType::IntervalDS.unit = :day
+        @conn.exec(<<-EOS) do |row|
+SELECT (TO_TIMESTAMP('#{date1}', 'YYYY-MM-DD HH24:MI:SS.FF')
+      - TO_TIMESTAMP('#{date2}', 'YYYY-MM-DD HH24:MI:SS.FF')) DAY(3) TO SECOND
+  FROM dual
+EOS
+          assert_equal(DateTime.parse(date1) - DateTime.parse(date2), row[0])
+        end
+      ensure
+        OCI8::BindType::IntervalDS.unit = :second
+      end
+    end
+  end
+
+  def test_days_interval_ds_out_bind
+    return if $oracle_version < OCI8::ORAVER_9_0
+
+    cursor = @conn.parse(<<-EOS)
+DECLARE
+  ts1 TIMESTAMP;
+  ts2 TIMESTAMP;
+BEGIN
+  ts1 := TO_TIMESTAMP(:in1, 'YYYY-MM-DD HH24:MI:SS.FF');
+  ts2 := TO_TIMESTAMP(:in2, 'YYYY-MM-DD HH24:MI:SS.FF');
+  :out := (ts1 - ts2) DAY TO SECOND(9);
+END;
+EOS
+    cursor.bind_param(:out, nil, :interval_ds)
+    cursor.bind_param(:in1, nil, String, 36)
+    cursor.bind_param(:in2, nil, String, 36)
+    [['2006-01-01', '2004-03-01'],
+     ['2006-01-01', '2005-03-01'],
+     ['2006-01-01', '2006-03-01'],
+     ['2006-01-01', '2007-03-01'],
+     ['2006-01-01', '2006-01-01 23:00:00'],
+     ['2006-01-01', '2006-01-01 00:59:00'],
+     ['2006-01-01', '2006-01-01 00:00:59'],
+     ['2006-01-01', '2006-01-01 00:00:00.999999'],
+     ['2006-01-01', '2006-01-01 23:59:59.999999'],
+     ['2006-01-01', '2005-12-31 23:00:00'],
+     ['2006-01-01', '2005-12-31 00:59:00'],
+     ['2006-01-01', '2005-12-31 00:00:59'],
+     ['2006-01-01', '2005-12-31 00:00:00.999999'],
+     ['2006-01-01', '2005-12-31 23:59:59.999999']
+    ].each do |date1, date2|
+      begin
+        OCI8::BindType::IntervalDS.unit = :day
+        cursor[:in1] = date1
+        cursor[:in2] = date2
+        cursor.exec
+        assert_equal(DateTime.parse(date1) - DateTime.parse(date2), cursor[:out])
+      ensure
+        OCI8::BindType::IntervalDS.unit = :second
+      end
     end
     cursor.close
   end
+
+  def test_days_interval_ds_in_bind
+    return if $oracle_version < OCI8::ORAVER_9_0
+
+    cursor = @conn.parse(<<-EOS)
+DECLARE
+  ts1 TIMESTAMP;
+BEGIN
+  ts1 := TO_TIMESTAMP(:in1, 'YYYY-MM-DD');
+  :out := TO_CHAR(ts1 + :in2, 'YYYY-MM-DD HH24:MI:SS.FF');
+END;
+EOS
+    cursor.bind_param(:out, nil, String, 36)
+    cursor.bind_param(:in1, nil, String, 36)
+    cursor.bind_param(:in2, nil, :interval_ds)
+    [['2006-01-01', -22],
+     ['2006-01-01', -10],
+     ['2006-01-01',  +2],
+     ['2006-01-01', +12],
+     ['2006-01-01', -1.to_r / 24], # one hour
+     ['2006-01-01', -1.to_r / (24*60)], # one minute
+     ['2006-01-01', -1.to_r / (24*60*60)], # one second
+     ['2006-01-01', -999999.to_r / (24*60*60*1000000)], # 0.999999 seconds
+     ['2006-01-01', +1.to_r / 24], # one hour
+     ['2006-01-01', +1.to_r / (24*60)], # one minute
+     ['2006-01-01', +1.to_r / (24*60*60)], # one second
+     ['2006-01-01', +999999.to_r / (24*60*60*1000000)] # 0.999999 seconds
+    ].each do |date, interval|
+      begin
+        OCI8::BindType::IntervalDS.unit = :day
+        cursor[:in1] = date
+        cursor[:in2] = interval
+        cursor.exec
+        assert_equal(DateTime.parse(date) + interval, DateTime.parse(cursor[:out]))
+      ensure
+        OCI8::BindType::IntervalDS.unit = :second
+      end
+    end
+  end
 end # TestOCI8

data/test/test_oci8.rb

@@ -167,6 +167,9 @@ EOS
   end
 
   def test_bind_cursor
+    # FIXME: check again after upgrading Oracle 9.2 to 9.2.0.4.
+    return if $oracle_version < OCI8::ORAVER_10_1
+
     drop_table('test_table')
     sql = <<-EOS
 CREATE TABLE test_table
@@ -357,12 +360,12 @@ EOS
       assert_equal(row[0], 12345678901234)
       assert_equal(row[1], 12345678901234567890)
       assert_equal(row[2], 123456789012.34)
-      assert_equal(row[3], 1234567890123.45)
+      assert_equal(row[3], BigDecimal("1234567890123.45"))
       assert_equal(row[4], 1234.5)
-      assert_instance_of(OraNumber, row[0])
+      assert_instance_of(BigDecimal, row[0])
       assert_instance_of(Bignum, row[1])
       assert_instance_of(Float, row[2])
-      assert_instance_of(OraNumber, row[3])
+      assert_instance_of(BigDecimal, row[3])
       assert_instance_of(Float, row[4])
     end
     drop_table('test_table')
@@ -372,6 +375,8 @@ EOS
     src = [1, 1.2, BigDecimal("1.2"), Rational(12, 10)]
     int = [1, 1, 1, 1]
     flt = [1, 1.2, 1.2, 1.2]
+    dec = [BigDecimal("1"), BigDecimal("1.2"), BigDecimal("1.2"), BigDecimal("1.2")]
+    rat = [Rational(1), Rational(12, 10), Rational(12, 10), Rational(12, 10)]
 
     cursor = @conn.parse("begin :1 := :2; end;")
 
@@ -382,6 +387,7 @@ EOS
       cursor[2] = s
       cursor.exec
       assert_equal(cursor[1], flt[idx])
+      assert_kind_of(Float, cursor[1])
     end
 
     # Fixnum
@@ -391,6 +397,7 @@ EOS
       cursor[2] = s
       cursor.exec
       assert_equal(cursor[1], int[idx])
+      assert_kind_of(Fixnum, cursor[1])
     end
 
     # Integer
@@ -400,6 +407,27 @@ EOS
       cursor[2] = s
       cursor.exec
       assert_equal(cursor[1], int[idx])
+      assert_kind_of(Integer, cursor[1])
+    end
+
+    # BigDecimal
+    cursor.bind_param(1, nil, BigDecimal)
+    cursor.bind_param(2, nil, BigDecimal)
+    src.each_with_index do |s, idx|
+      cursor[2] = s
+      cursor.exec
+      assert_equal(cursor[1], dec[idx])
+      assert_kind_of(BigDecimal, cursor[1])
+    end
+
+    # Rational
+    cursor.bind_param(1, nil, Rational)
+    cursor.bind_param(2, nil, Rational)
+    src.each_with_index do |s, idx|
+      cursor[2] = s
+      cursor.exec
+      assert_equal(cursor[1], rat[idx])
+      assert_kind_of(Rational, cursor[1])
     end
   end