ruby-oci8 1.0.7 → 2.0.0

data/test/test_oci8.rb

@@ -1,18 +1,79 @@
 require 'oci8'
-require 'runit/testcase'
-require 'runit/cui/testrunner'
+require 'test/unit'
 require File.dirname(__FILE__) + '/config'
 
-class TestOCI8 < RUNIT::TestCase
+class TestOCI8 < Test::Unit::TestCase
 
   def setup
-    @conn = get_oci_connection()
+    @conn = get_oci8_connection
   end
 
   def teardown
     @conn.logoff
   end
 
+  def test_rename
+    drop_table('test_table')
+    drop_table('test_rename_table')
+    sql = <<-EOS
+CREATE TABLE test_rename_table
+  (C CHAR(10) NOT NULL)
+EOS
+    @conn.exec(sql)
+    @conn.exec("RENAME test_rename_table TO test_table")
+    drop_table('test_rename_table')
+  end
+
+  # USE_DYNAMIC_FETCH doesn't work well...
+  # This test is disabled.
+  def _test_long_type
+    drop_table('test_table')
+    @conn.exec('CREATE TABLE test_table (id number(38), lng long)')
+    test_data1 = 'a' * 70000
+    test_data2 = 'b' * 3000
+    test_data3 = nil
+    test_data4 = 'c' * 70000
+    @conn.exec('insert into test_table values (:1, :2)', 1, test_data1)
+    @conn.exec('insert into test_table values (:1, :2)', 2, [test_data2, :long])
+    @conn.exec('insert into test_table values (:1, :2)', 3, [nil, :long])
+    @conn.exec('insert into test_table values (:1, :2)', 4, [test_data4, :long])
+
+    [8000, 65535, 65536, 80000].each do |read_len|
+      @conn.long_read_len = read_len
+      cursor = @conn.parse('SELECT lng from test_table order by id')
+      cursor.exec
+      assert_equal(test_data1, cursor.fetch[0])
+      assert_equal(test_data2, cursor.fetch[0])
+      assert_equal(test_data3, cursor.fetch[0])
+      assert_equal(test_data4, cursor.fetch[0])
+      cursor.close
+    end
+    drop_table('test_table')
+  end
+
+  def test_long_type
+    @conn.long_read_len = 80000
+    drop_table('test_table')
+    @conn.exec('CREATE TABLE test_table (id number(38), lng long)')
+    test_data1 = 'a' * 70000
+    test_data2 = 'b' * 3000
+    test_data3 = nil
+    test_data4 = 'c' * 70000
+    @conn.exec('insert into test_table values (:1, :2)', 1, test_data1)
+    @conn.exec('insert into test_table values (:1, :2)', 2, [test_data2, :long])
+    @conn.exec('insert into test_table values (:1, :2)', 3, [nil, :long])
+    @conn.exec('insert into test_table values (:1, :2)', 4, [test_data4, :long])
+
+    cursor = @conn.parse('SELECT lng from test_table order by id')
+    cursor.exec
+    assert_equal(test_data1, cursor.fetch[0])
+    assert_equal(test_data2, cursor.fetch[0])
+    assert_equal(test_data3, cursor.fetch[0])
+    assert_equal(test_data4, cursor.fetch[0])
+    cursor.close
+    drop_table('test_table')
+  end
+
   def test_select
     drop_table('test_table')
     sql = <<-EOS
@@ -43,7 +104,7 @@ EOS
     cursor = @conn.parse("SELECT * FROM test_table ORDER BY c")
     cursor.define(5, Time) # define 5th column as Time
     cursor.define(6, Date) # define 6th column as Date
-    cursor.define(7, DateTime) if defined? DateTime # define 7th column as DateTime
+    cursor.define(7, DateTime) # define 7th column as DateTime
     cursor.define(8, Integer) # define 8th column as Integer
     cursor.define(9, Bignum) # define 9th column as Bignum
     cursor.exec
@@ -59,11 +120,13 @@ EOS
 	assert_nil(rv[5])
 	assert_nil(rv[6])
       else
-	dt = OraDate.new(2000 + i, 8, 3, 23, 59, 59)
-	assert_equal(dt, rv[3])
-	assert_equal(dt.to_time, rv[4])
-	assert_equal(dt.to_date, rv[5])
-	assert_equal(dt.to_datetime, rv[6]) if defined? DateTime
+        tm = Time.local(2000 + i, 8, 3, 23, 59, 59)
+	dt = Date.civil(2000 + i, 8, 3)
+	dttm = DateTime.civil(2000 + i, 8, 3, 23, 59, 59, Time.now.utc_offset.to_r/86400)
+	assert_equal(tm, rv[3])
+	assert_equal(tm, rv[4])
+	assert_equal(dt, rv[5])
+	assert_equal(dttm, rv[6])
       end
       assert_equal(i * 11111111111, rv[7])
       assert_equal(i * 10000000000, rv[8])
@@ -83,17 +146,19 @@ EOS
 	assert_nil(row['D3'])
 	assert_nil(row['D4'])
       else
-	dt = OraDate.new(2000 + i, 8, 3, 23, 59, 59)
-	assert_equal(dt, row['D1'])
-	assert_equal(dt.to_time, row['D2'])
-	assert_equal(dt.to_date, row['D3'])
-	assert_equal(dt.to_datetime, row['D4']) if defined? DateTime
+        tm = Time.local(2000 + i, 8, 3, 23, 59, 59)
+	dt = Date.civil(2000 + i, 8, 3)
+	dttm = DateTime.civil(2000 + i, 8, 3, 23, 59, 59, Time.now.utc_offset.to_r/86400)
+	assert_equal(tm, row['D1'])
+	assert_equal(tm, row['D2'])
+	assert_equal(dt, row['D3'])
+	assert_equal(dttm, row['D4'])
       end
       assert_equal(i * 11111111111, row['INT'])
       assert_equal(i * 10000000000, row['BIGNUM'])
       i += 1
     end
-    assert_equal(i, 11)
+    assert_equal(11, i)
 
     cursor.close
     drop_table('test_table')
@@ -127,7 +192,7 @@ EOS
     end
     cursor.close
     plsql = @conn.parse("BEGIN OPEN :cursor FOR SELECT * FROM test_table ORDER BY c; END;")
-    plsql.bind_param(':cursor', OCI8::Cursor)
+    plsql.bind_param(':cursor', nil, OCI8::Cursor)
     plsql.exec
     cursor = plsql[':cursor']
     cursor.define(5, Time) # define 5th column as Time
@@ -145,10 +210,12 @@ EOS
 	assert_nil(rv[4])
 	assert_nil(rv[5])
       else
-	dt = OraDate.new(2000 + i, 8, 3, 23, 59, 59)
-	assert_equal(dt, rv[3])
-	assert_equal(dt.to_time, rv[4])
-	assert_equal(dt.to_date, rv[5])
+	dttm = DateTime.civil(2000 + i, 8, 3, 23, 59, 59, Time.now.utc_offset.to_r/86400)
+        tm = Time.local(2000 + i, 8, 3, 23, 59, 59)
+	dt = Date.civil(2000 + i, 8, 3)
+	assert_equal(tm, rv[3])
+	assert_equal(tm, rv[4])
+	assert_equal(dt, rv[5])
       end
       assert_equal(i, rv[6])
       assert_equal(i, rv[7])
@@ -197,42 +264,44 @@ EOS
     drop_table('test_table')
   end
 
-  if $oracle_version >= 1000
+  def test_binary_float
+    return if $oracle_version < OCI8::ORAVER_10_1
+
     # Oracle 10g or upper
-    def test_binary_float
-      cursor = @conn.parse("select CAST(:1 AS BINARY_FLOAT), CAST(:2 AS BINARY_DOUBLE) from dual")
-      bind_val = -1.0
-      cursor.bind_param(1, 10.0, OCI8::SQLT_IBDOUBLE)
-      cursor.bind_param(2, nil, OCI8::SQLT_IBDOUBLE)
-      while bind_val < 10.0
-        cursor[2] = bind_val
-        cursor.exec
-        rv = cursor.fetch
-        assert_equal(10.0, rv[0])
-        assert_equal(bind_val, rv[1])
-        bind_val += 1.234
-      end
-      [-1.0/0.0, # -Infinite
-       +1.0/0.0, # +Infinite
-       0.0/0.0   # NaN
-      ].each do |num|
-        cursor[1] = num
-        cursor[2] = num
-        cursor.exec
-        rv = cursor.fetch
-        if num.nan?
-          assert(rv[0].nan?)
-          assert(rv[1].nan?)
-        else
-          assert_equal(num, rv[0])
-          assert_equal(num, rv[1])
-        end
+    cursor = @conn.parse("select CAST(:1 AS BINARY_FLOAT), CAST(:2 AS BINARY_DOUBLE) from dual")
+    bind_val = -1.0
+    cursor.bind_param(1, 10.0, :binary_double)
+    cursor.bind_param(2, nil, :binary_double)
+    while bind_val < 10.0
+      cursor[2] = bind_val
+      cursor.exec
+      rv = cursor.fetch
+      assert_equal(10.0, rv[0])
+      assert_equal(bind_val, rv[1])
+      bind_val += 1.234
+    end
+    [-1.0/0.0, # -Infinite
+     +1.0/0.0, # +Infinite
+     0.0/0.0   # NaN
+    ].each do |num|
+      cursor[1] = num
+      cursor[2] = num
+      cursor.exec
+      rv = cursor.fetch
+      if num.nan?
+        assert(rv[0].nan?)
+        assert(rv[1].nan?)
+      else
+        assert_equal(num, rv[0])
+        assert_equal(num, rv[1])
       end
-      cursor.close
     end
+    cursor.close
   end
 
   def test_clob_nclob_and_blob
+    return if OCI8::oracle_client_version < OCI8::ORAVER_8_1
+
     drop_table('test_table')
     sql = <<-EOS
 CREATE TABLE test_table (id number(5), C CLOB, NC NCLOB, B BLOB)
@@ -259,6 +328,7 @@ EOS
       assert_instance_of(OCI8::NCLOB, rv[2])
       assert_instance_of(OCI8::BLOB, rv[3])
       assert_equal(val, rv[1].read)
+      assert_equal(val.length, rv[2].size)
       assert_equal(val, rv[2].read)
       assert_equal(val, rv[3].read)
     end
@@ -266,8 +336,34 @@ EOS
     cursor.close
     drop_table('test_table')
   end
-end # TestOCI8
 
-if $0 == __FILE__
-  RUNIT::CUI::TestRunner.run(TestOCI8.suite())
-end
+  def test_select_number
+    drop_table('test_table')
+    @conn.exec(<<EOS)
+CREATE TABLE test_table (n NUMBER, n20 NUMBER(20), n14_2 NUMBER(14,2), n15_2 NUMBER(15,2), flt FLOAT)
+STORAGE (
+   INITIAL 100k
+   NEXT 100k
+   MINEXTENTS 1
+   MAXEXTENTS UNLIMITED
+   PCTINCREASE 0)
+EOS
+    @conn.exec(<<EOS)
+INSERT INTO test_table values(12345678901234, 12345678901234567890, 123456789012.34, 1234567890123.45, 1234.5)
+EOS
+    @conn.exec("select * from test_table") do |row|
+      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[4], 1234.5)
+      assert_instance_of(OraNumber, row[0])
+      assert_instance_of(Bignum, row[1])
+      assert_instance_of(Float, row[2])
+      assert_instance_of(OraNumber, row[3])
+      assert_instance_of(Float, row[4])
+    end
+    drop_table('test_table')
+  end
+
+end # TestOCI8

data/test/test_oracle_version.rb

@@ -0,0 +1,70 @@
+require 'oci8'
+require 'test/unit'
+require File.dirname(__FILE__) + '/config'
+
+class TestOracleVersion < Test::Unit::TestCase
+
+  def test_init
+    oraver = OCI8::OracleVersion.new('8.1.6.2.3')
+    assert_equal(8, oraver.major)
+    assert_equal(1, oraver.minor)
+    assert_equal(6, oraver.update)
+    assert_equal(2, oraver.patch)
+    assert_equal(3, oraver.port_update)
+
+    oraver = OCI8::OracleVersion.new('8.1.6')
+    assert_equal(8, oraver.major)
+    assert_equal(1, oraver.minor)
+    assert_equal(6, oraver.update)
+    assert_equal(0, oraver.patch)
+    assert_equal(0, oraver.port_update)
+
+    oraver = OCI8::OracleVersion.new('10')
+    assert_equal(10, oraver.major)
+    assert_equal(0, oraver.minor)
+    assert_equal(0, oraver.update)
+    assert_equal(0, oraver.patch)
+    assert_equal(0, oraver.port_update)
+
+    oraver = OCI8::OracleVersion.new(0x08106203)
+    assert_equal(8, oraver.major)
+    assert_equal(1, oraver.minor)
+    assert_equal(6, oraver.update)
+    assert_equal(2, oraver.patch)
+    assert_equal(3, oraver.port_update)
+  end
+
+  def test_compare
+    oraver = OCI8::OracleVersion.new('8.1.6.2.3')
+    assert_operator(oraver, :==, OCI8::OracleVersion.new('8.1.6.2.3'))
+    assert_operator(oraver, :<, OCI8::OracleVersion.new('9.1.6.2.3'))
+    assert_operator(oraver, :<, OCI8::OracleVersion.new('8.2.6.2.3'))
+    assert_operator(oraver, :<, OCI8::OracleVersion.new('8.1.7.2.3'))
+    assert_operator(oraver, :<, OCI8::OracleVersion.new('8.1.6.3.3'))
+    assert_operator(oraver, :<, OCI8::OracleVersion.new('8.1.6.2.4'))
+    assert_operator(oraver, :>, OCI8::OracleVersion.new('7.1.6.2.3'))
+    assert_operator(oraver, :>, OCI8::OracleVersion.new('8.0.6.2.3'))
+    assert_operator(oraver, :>, OCI8::OracleVersion.new('8.1.5.2.3'))
+    assert_operator(oraver, :>, OCI8::OracleVersion.new('8.1.6.1.3'))
+    assert_operator(oraver, :>, OCI8::OracleVersion.new('8.1.6.2.2'))
+  end
+
+  def test_to_s
+    oraver = OCI8::OracleVersion.new('8.1.6.2.3')
+    assert_equal('8.1.6.2.3', oraver.to_s)
+  end
+
+  def test_to_i
+    oraver = OCI8::OracleVersion.new('8.1.6.2.3')
+    assert_equal(0x08106203, oraver.to_i)
+  end
+
+  def test_eql
+    oraver = OCI8::OracleVersion.new('8.1.6.2.3')
+    assert_equal(true, oraver.eql?(OCI8::OracleVersion.new('8.1.6.2.3')))
+    assert_equal(false, oraver.eql?(OCI8::OracleVersion.new('8.2.6.2.3')))
+    assert_equal(false, oraver.eql?('8.1.6.2.3'))
+  end
+end
+
+Test::Unit::AutoRunner.run() if $0 == __FILE__

data/test/test_oradate.rb

@@ -1,10 +1,9 @@
 # Low-level API
 require 'oci8'
-require 'runit/testcase'
-require 'runit/cui/testrunner'
+require 'test/unit'
 require File.dirname(__FILE__) + '/config'
 
-class TestOraDate < RUNIT::TestCase
+class TestOraDate < Test::Unit::TestCase
 
   YEAR_CHECK_TARGET = [-4712, -1, 1, 1192, 1868, 2002, 9999]
   MONTH_CHECK_TARGET = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
@@ -14,7 +13,7 @@ class TestOraDate < RUNIT::TestCase
   SECOND_CHECK_TARGET = [0, 15, 30, 45, 59]
 
   def setup
-    @env, @svc, @stmt = setup_lowapi()
+    @conn = get_oci8_connection
   end
 
   def check_oradate(target, year, month, day, hour, minute, second)
@@ -31,170 +30,170 @@ class TestOraDate < RUNIT::TestCase
   end
 
   def test_set_year
-    @stmt.prepare("BEGIN :year := TO_NUMBER(TO_CHAR(:date, 'SYYYY'), '9999'); END;")
-    date_in = @stmt.bindByName(":date", OraDate)
-    year_out = @stmt.bindByName(":year", Fixnum)
+    cursor = @conn.parse("BEGIN :year := TO_NUMBER(TO_CHAR(:date, 'SYYYY'), '9999'); END;")
+    cursor.bind_param(:date, OraDate)
+    cursor.bind_param(:year, Fixnum)
     date = OraDate.new()
     YEAR_CHECK_TARGET.each do |i|
       # set year
       date.year = i
       # check result via oracle.
-      date_in.set(date)
-      @stmt.execute(@svc)
-      assert_equal(i, year_out.get())
+      cursor[:date] = date
+      cursor.exec
+      assert_equal(i, cursor[:year])
     end
   end
 
   def test_get_year
-    @stmt.prepare("BEGIN :date := TO_DATE(TO_CHAR(:year, '0999'), 'SYYYY'); END;")
-    year_in = @stmt.bindByName(":year", Fixnum)
-    date_out = @stmt.bindByName(":date", OraDate)
+    cursor = @conn.parse("BEGIN :date := TO_DATE(TO_CHAR(:year, '0999'), 'SYYYY'); END;")
+    cursor.bind_param(:year, Fixnum)
+    cursor.bind_param(:date, OraDate)
     YEAR_CHECK_TARGET.each do |i|
       # set date via oracle.
-      year_in.set(i)
-      @stmt.execute(@svc)
+      cursor[:year] = i
+      cursor.exec
       # check OraDate#year
-      assert_equal(i, date_out.get.year)
+      assert_equal(i, cursor[:date].year)
     end
   end
 
   def test_set_month
-    @stmt.prepare("BEGIN :month := TO_NUMBER(TO_CHAR(:date, 'MM'), '99'); END;")
-    date_in = @stmt.bindByName(":date", OraDate)
-    month_out = @stmt.bindByName(":month", Fixnum)
+    cursor = @conn.parse("BEGIN :month := TO_NUMBER(TO_CHAR(:date, 'MM'), '99'); END;")
+    cursor.bind_param(:date, OraDate)
+    cursor.bind_param(:month, Fixnum)
     date = OraDate.new()
     MONTH_CHECK_TARGET.each do |i|
       # set month
       date.month = i
       # check result via oracle.
-      date_in.set(date)
-      @stmt.execute(@svc)
-      assert_equal(i, month_out.get())
+      cursor[:date] = date
+      cursor.exec
+      assert_equal(i, cursor[:month])
     end
   end
 
   def test_get_month
-    @stmt.prepare("BEGIN :date := TO_DATE(TO_CHAR(:month, '99'), 'MM'); END;")
-    month_in = @stmt.bindByName(":month", Fixnum)
-    date_out = @stmt.bindByName(":date", OraDate)
+    cursor = @conn.parse("BEGIN :date := TO_DATE(TO_CHAR(:month, '99'), 'MM'); END;")
+    cursor.bind_param(:month, Fixnum)
+    cursor.bind_param(:date, OraDate)
     MONTH_CHECK_TARGET.each do |i|
       # set date via oracle.
-      month_in.set(i)
-      @stmt.execute(@svc)
+      cursor[:month] = i
+      cursor.exec
       # check OraDate#month
-      assert_equal(i, date_out.get.month)
+      assert_equal(i, cursor[:date].month)
     end
   end
 
   def test_set_day
-    @stmt.prepare("BEGIN :day := TO_NUMBER(TO_CHAR(:date, 'DD'), '99'); END;")
-    date_in = @stmt.bindByName(":date", OraDate)
-    day_out = @stmt.bindByName(":day", Fixnum)
+    cursor = @conn.parse("BEGIN :day := TO_NUMBER(TO_CHAR(:date, 'DD'), '99'); END;")
+    cursor.bind_param(:date, OraDate)
+    cursor.bind_param(:day, Fixnum)
     date = OraDate.new()
     DAY_CHECK_TARGET.each do |i|
       # set day
       date.day = i
       # check result via oracle.
-      date_in.set(date)
-      @stmt.execute(@svc)
-      assert_equal(i, day_out.get())
+      cursor[:date] = date
+      cursor.exec
+      assert_equal(i, cursor[:day])
     end
   end
 
   def test_get_day
-    @stmt.prepare("BEGIN :date := TO_DATE('200101' || TO_CHAR(:day, 'FM00'), 'YYYYMMDD'); END;")
-    day_in = @stmt.bindByName(":day", Fixnum)
-    date_out = @stmt.bindByName(":date", OraDate)
+    cursor = @conn.parse("BEGIN :date := TO_DATE('200101' || TO_CHAR(:day, 'FM00'), 'YYYYMMDD'); END;")
+    cursor.bind_param(:day, Fixnum)
+    cursor.bind_param(:date, OraDate)
     DAY_CHECK_TARGET.each do |i|
       # set date via oracle.
-      day_in.set(i)
-      @stmt.execute(@svc)
+      cursor[:day] = i
+      cursor.exec
       # check OraDate#day
-      assert_equal(i, date_out.get.day)
+      assert_equal(i, cursor[:date].day)
     end
   end
 
   def test_set_hour
-    @stmt.prepare("BEGIN :hour := TO_NUMBER(TO_CHAR(:date, 'HH24'), '99'); END;")
-    date_in = @stmt.bindByName(":date", OraDate)
-    hour_out = @stmt.bindByName(":hour", Fixnum)
+    cursor = @conn.parse("BEGIN :hour := TO_NUMBER(TO_CHAR(:date, 'HH24'), '99'); END;")
+    cursor.bind_param(:date, OraDate)
+    cursor.bind_param(:hour, Fixnum)
     date = OraDate.new()
     HOUR_CHECK_TARGET.each do |i|
       # set hour
       date.hour = i
       # check result via oracle.
-      date_in.set(date)
-      @stmt.execute(@svc)
-      assert_equal(i, hour_out.get())
+      cursor[:date] = date
+      cursor.exec
+      assert_equal(i, cursor[:hour])
     end
   end
 
   def test_get_hour
-    @stmt.prepare("BEGIN :date := TO_DATE(TO_CHAR(:hour, '99'), 'HH24'); END;")
-    hour_in = @stmt.bindByName(":hour", Fixnum)
-    date_out = @stmt.bindByName(":date", OraDate)
+    cursor = @conn.parse("BEGIN :date := TO_DATE(TO_CHAR(:hour, '99'), 'HH24'); END;")
+    cursor.bind_param(:hour, Fixnum)
+    cursor.bind_param(:date, OraDate)
     HOUR_CHECK_TARGET.each do |i|
       # set date via oracle.
-      hour_in.set(i)
-      @stmt.execute(@svc)
+      cursor[:hour] = i
+      cursor.exec
       # check OraDate#hour
-      assert_equal(i, date_out.get.hour)
+      assert_equal(i, cursor[:date].hour)
     end
   end
 
   def test_set_minute
-    @stmt.prepare("BEGIN :minute := TO_NUMBER(TO_CHAR(:date, 'MI'), '99'); END;")
-    date_in = @stmt.bindByName(":date", OraDate)
-    minute_out = @stmt.bindByName(":minute", Fixnum)
+    cursor = @conn.parse("BEGIN :minute := TO_NUMBER(TO_CHAR(:date, 'MI'), '99'); END;")
+    cursor.bind_param(:date, OraDate)
+    cursor.bind_param(:minute, Fixnum)
     date = OraDate.new()
     MINUTE_CHECK_TARGET.each do |i|
       # set minute
       date.minute = i
       # check result via oracle.
-      date_in.set(date)
-      @stmt.execute(@svc)
-      assert_equal(i, minute_out.get())
+      cursor[:date] = date
+      cursor.exec
+      assert_equal(i, cursor[:minute])
     end
   end
 
   def test_get_minute
-    @stmt.prepare("BEGIN :date := TO_DATE(TO_CHAR(:minute, '99'), 'MI'); END;")
-    minute_in = @stmt.bindByName(":minute", Fixnum)
-    date_out = @stmt.bindByName(":date", OraDate)
+    cursor = @conn.parse("BEGIN :date := TO_DATE(TO_CHAR(:minute, '99'), 'MI'); END;")
+    cursor.bind_param(:minute, Fixnum)
+    cursor.bind_param(:date, OraDate)
     MINUTE_CHECK_TARGET.each do |i|
       # set date via oracle.
-      minute_in.set(i)
-      @stmt.execute(@svc)
+      cursor[:minute] = i
+      cursor.exec
       # check OraDate#minute
-      assert_equal(i, date_out.get.minute)
+      assert_equal(i, cursor[:date].minute)
     end
   end
 
   def test_set_second
-    @stmt.prepare("BEGIN :second := TO_NUMBER(TO_CHAR(:date, 'SS'), '99'); END;")
-    date_in = @stmt.bindByName(":date", OraDate)
-    second_out = @stmt.bindByName(":second", Fixnum)
+    cursor = @conn.parse("BEGIN :second := TO_NUMBER(TO_CHAR(:date, 'SS'), '99'); END;")
+    cursor.bind_param(:date, OraDate)
+    cursor.bind_param(:second, Fixnum)
     date = OraDate.new()
     SECOND_CHECK_TARGET.each do |i|
       # set second
       date.second = i
       # check result via oracle.
-      date_in.set(date)
-      @stmt.execute(@svc)
-      assert_equal(i, second_out.get())
+      cursor[:date] = date
+      cursor.exec
+      assert_equal(i, cursor[:second])
     end
   end
 
   def test_get_second
-    @stmt.prepare("BEGIN :date := TO_DATE(TO_CHAR(:second, '99'), 'SS'); END;")
-    second_in = @stmt.bindByName(":second", Fixnum)
-    date_out = @stmt.bindByName(":date", OraDate)
+    cursor = @conn.parse("BEGIN :date := TO_DATE(TO_CHAR(:second, '99'), 'SS'); END;")
+    cursor.bind_param(:second, Fixnum)
+    cursor.bind_param(:date, OraDate)
     SECOND_CHECK_TARGET.each do |i|
       # set date via oracle.
-      second_in.set(i)
-      @stmt.execute(@svc)
+      cursor[:second] = i
+      cursor.exec
       # check OraDate#second
-      assert_equal(i, date_out.get.second)
+      assert_equal(i, cursor[:date].second)
     end
   end
 
@@ -252,12 +251,6 @@ class TestOraDate < RUNIT::TestCase
   end
 
   def teardown
-    @stmt.free()
-    @svc.logoff()
-    @env.free()
+    @conn.logoff
   end
 end
-
-if $0 == __FILE__
-  RUNIT::CUI::TestRunner.run(TestOraDate.suite())
-end