ruby-oci8 1.0.7-x86-mswin32-60 → 2.0.1-x86-mswin32-60

data/test/test_array_dml.rb

@@ -0,0 +1,333 @@
+require 'oci8'
+require 'test/unit'
+require File.dirname(__FILE__) + '/config'
+
+class TestArrayDML < Test::Unit::TestCase
+  def setup
+    @conn = get_oci8_connection
+  end
+
+  def teardown
+    @conn.logoff
+  end
+
+  # test inserting arrays with different data types
+  #   including char, varchar2, number, date and so on
+  def test_array_insert1
+    drop_table('test_table')
+    sql = <<-EOS
+CREATE TABLE test_table
+  (C CHAR(10) NOT NULL,
+   V VARCHAR2(20),
+   N NUMBER(10, 2),
+   D DATE,
+   INT NUMBER(30), 
+   BIGNUM NUMBER(30),
+   T TIMESTAMP)
+STORAGE (
+   INITIAL 4k
+   NEXT 4k
+   MINEXTENTS 1
+   MAXEXTENTS UNLIMITED
+   PCTINCREASE 0)
+EOS
+    @conn.exec(sql)
+    cursor = @conn.parse("INSERT INTO test_table VALUES (:C, :V, :N, :D, :INT, :BIGNUM, :T)")
+    max_array_size = 3
+    cursor.max_array_size= max_array_size
+    
+    cursor.bind_param_array(1, nil, String)
+    cursor.bind_param_array(2, nil ,String)
+    cursor.bind_param_array(3, nil, Fixnum)
+    cursor.bind_param_array(4, nil, OraDate)
+    cursor.bind_param_array(5, nil, Integer)
+    cursor.bind_param_array(6, nil, Bignum)
+    cursor.bind_param_array(7, nil, DateTime)
+
+    c_arr = Array.new
+    v_arr = Array.new
+    n_arr = Array.new
+    d_arr = Array.new
+    int_arr = Array.new
+    bignum_arr = Array.new
+    t_arr = Array.new
+    
+    1.upto(30) do |i|
+      c_arr << format("%10d", i * 10)
+      v_arr << i.to_s
+      n_arr << i
+      d_arr <<  OraDate.new(2000 + i, 12, 24, 23, 59, 59)
+      int_arr << i * 11111111111
+      bignum_arr << i * 10000000000
+      t_arr <<  DateTime.new(2000 + i, 12, 24, 23, 59, 59)
+      
+      if i%max_array_size == 0
+        cursor[1] = c_arr
+        cursor[2] = v_arr
+        cursor[3] = n_arr
+        cursor[4] = d_arr
+        cursor[5] = int_arr
+        cursor[6] = bignum_arr
+        cursor[7] = t_arr
+        
+        r = cursor.exec_array
+        assert_equal(max_array_size, r)
+        assert_equal(c_arr, cursor[1])
+        assert_equal(v_arr, cursor[2])
+        assert_equal(n_arr, cursor[3])
+        assert_equal(d_arr, cursor[4])
+        assert_equal(int_arr, cursor[5])
+        assert_equal(bignum_arr, cursor[6])
+        assert_equal(t_arr, cursor[7])
+        c_arr.clear
+        v_arr.clear
+        n_arr.clear
+        d_arr.clear
+        int_arr.clear
+        bignum_arr.clear
+        t_arr.clear
+      end
+    end
+    cursor.close
+    
+    cursor = @conn.parse("SELECT * FROM test_table ORDER BY c")
+    cursor.define(5, Integer)
+    cursor.define(6, Bignum)
+    cursor.exec
+    assert_equal(["C","V","N","D","INT","BIGNUM","T"], cursor.get_col_names)
+    1.upto(30) do |i|
+      rv = cursor.fetch
+      assert_equal(format("%10d", i * 10), rv[0])
+      assert_equal(i.to_s, rv[1])
+      assert_equal(i, rv[2])
+      tm = Time.local(2000 + i, 12, 24, 23, 59, 59)
+      assert_equal(tm, rv[3])
+      assert_equal(i * 11111111111, rv[4])
+      assert_equal(i * 10000000000, rv[5])
+      assert_equal(tm, rv[6])
+    end
+    assert_nil(cursor.fetch)
+    drop_table('test_table')
+  end
+
+  # Raise error when binding arrays are not the same size
+  def test_array_insert2
+    drop_table('test_table')
+    sql = <<-EOS
+CREATE TABLE test_table
+  (N NUMBER(10, 2) NOT NULL,
+   V VARCHAR(20))
+EOS
+    @conn.exec(sql)
+    cursor = @conn.parse("INSERT INTO test_table VALUES (:N, :V)")
+    max_array_size = 10
+    cursor.max_array_size = max_array_size
+    cursor.bind_param_array(1, nil, Fixnum)
+    cursor.bind_param_array(2, nil, String)
+    n_arr = Array.new
+    v_arr = Array.new
+    1.upto(max_array_size) do |i|
+      n_arr << i
+      v_arr << i.to_s if i != max_array_size
+    end
+    cursor[1] = n_arr
+    assert_raise(RuntimeError) { cursor[2] = v_arr }
+    cursor.close
+    
+    drop_table('test_table')
+  end  
+
+  # All binds are clear from cursor after calling "max_array_size=", 
+  #  in that case, you have to re-bind the array parameters 
+  #  otherwise, an error will be raised.
+  def test_array_insert3
+    drop_table('test_table')
+    sql = <<-EOS
+CREATE TABLE test_table
+  (N NUMBER(10, 2) NOT NULL,
+   V VARCHAR(20),
+   T TIMESTAMP)
+EOS
+    @conn.exec(sql)
+    cursor = @conn.parse("INSERT INTO test_table VALUES (:N, :V, :T)")
+    cursor.max_array_size = 3
+    cursor.bind_param_array(1, [1, 2, 3])
+    cursor.bind_param_array(2, ['happy', 'new', 'year'])
+    cursor.bind_param_array(3, [Time.gm(1990,1,1), Time.gm(2000,1,1), Time.gm(2010,1,1)])
+    assert_nothing_raised() { cursor.exec_array }
+    cursor.max_array_size = 2
+    assert_raise(RuntimeError) { cursor.exec_array }
+    drop_table('test_table')
+  end
+
+  # The size of binding arrays are not required to be same as max_array_size. The 
+  #   only requirement is that they should be the same size, and the size will be 
+  #   used as execution count for OCIStmtExecute.
+  def test_array_insert4
+    drop_table('test_table')
+    sql = <<-EOS
+CREATE TABLE test_table
+  (N NUMBER(10, 2) NOT NULL,
+   V VARCHAR(20))
+EOS
+    @conn.exec(sql)
+    cursor = @conn.parse("INSERT INTO test_table VALUES (:N, :V)")
+    max_array_size = 4
+    cursor.max_array_size = max_array_size
+    cursor.bind_param_array(1, nil, Fixnum)
+    cursor.bind_param_array(2, nil, String)
+    n_arr = Array.new
+    v_arr = Array.new
+    1.upto( max_array_size - 1 ) do |i|
+      n_arr << i
+      v_arr << i.to_s
+    end
+    cursor[1] = n_arr
+    cursor[2] = v_arr
+    assert_nothing_raised() { cursor.exec_array }
+    cursor.close
+
+    cursor = @conn.parse("SELECT * FROM test_table ORDER BY N")
+    cursor.exec
+    1.upto( max_array_size - 1 ) do |i|
+      rv = cursor.fetch
+      assert_equal(i, rv[0])
+      assert_equal(i.to_s, rv[1])
+    end  
+    assert_nil(cursor.fetch)
+    cursor.close
+    drop_table('test_table')    
+  end
+
+  # Inserting "nil" elements with array dml raises an error
+  def test_array_insert5
+    drop_table('test_table')
+    sql = <<-EOS
+CREATE TABLE test_table
+  (N NUMBER(10, 2),
+   V VARCHAR(20))
+EOS
+    @conn.exec(sql)
+    cursor = @conn.parse("INSERT INTO test_table VALUES (:N, :V)")
+    max_array_size = 3
+    cursor.max_array_size = max_array_size
+    cursor.bind_param_array(1, nil, Fixnum)
+    cursor.bind_param_array(2, nil, String)
+    assert_raise(RuntimeError) { cursor.exec_array }
+    cursor.close
+    drop_table('test_table')
+  end
+
+  # delete with array bindings
+  def test_array_delete
+    drop_table('test_table')
+    sql = <<-EOS
+CREATE TABLE test_table
+  (N NUMBER(10, 2),
+   V VARCHAR(20))
+EOS
+    @conn.exec(sql)    
+    cursor = @conn.parse("INSERT INTO test_table VALUES (:N, :V)")
+    max_array_size = 10
+    cursor.max_array_size = max_array_size
+    n_arr = Array.new
+    v_arr = Array.new
+    1.upto( max_array_size) do |i|
+      n_arr << i
+      v_arr << i.to_s
+    end    
+    cursor.bind_param_array(1, nil, Fixnum)
+    cursor.bind_param_array(2, nil, String)
+    cursor[1] = n_arr
+    cursor[2] = v_arr
+    cursor.exec_array
+    cursor.close
+
+    cursor = @conn.parse("DELETE FROM test_table WHERE N=:1")
+    cursor.max_array_size = max_array_size
+    delete_arr = Array.new
+    1.upto(max_array_size) do |i|
+      if i%2 == 0
+        delete_arr << i
+      end  
+    end
+    cursor.bind_param_array(1, nil, Fixnum)
+    cursor[1] = delete_arr
+    cursor.exec_array
+    cursor.close
+    
+    cursor = @conn.parse("SELECT * FROM test_table ORDER BY N")
+    cursor.exec
+    1.upto( max_array_size ) do |i|
+      if i%2 != 0
+        rv = cursor.fetch
+        assert_equal(rv[0], i)
+        assert_equal(rv[1], i.to_s)
+      end
+    end  
+    assert_nil(cursor.fetch)    
+    cursor.close
+    
+    drop_table('test_table')
+  end
+
+  # update with array bindings
+  def test_array_update
+    drop_table('test_table')
+    sql = <<-EOS
+CREATE TABLE test_table
+  (N NUMBER(10, 2),
+   V VARCHAR(20))
+EOS
+    @conn.exec(sql)    
+    cursor = @conn.parse("INSERT INTO test_table VALUES (:N, :V)")
+    max_array_size = 10
+    cursor.max_array_size = max_array_size
+    n_arr = Array.new
+    v_arr = Array.new
+    1.upto( max_array_size) do |i|
+      n_arr << i
+      v_arr << i.to_s
+    end    
+    cursor.bind_param_array(1, nil, Fixnum)
+    cursor.bind_param_array(2, nil, String)
+    cursor[1] = n_arr
+    cursor[2] = v_arr
+    cursor.exec_array
+    cursor.close
+
+    cursor = @conn.parse("UPDATE test_table SET V=:1 WHERE N=:2")
+    cursor.max_array_size = max_array_size
+    update_arr = Array.new
+    update_v_arr = Array.new
+    1.upto(max_array_size) do |i|
+      if i%2 == 0
+        update_arr << i
+        update_v_arr << (i * 10).to_s
+      end  
+    end
+    cursor.bind_param_array(1, nil, String)
+    cursor.bind_param_array(2, nil, Fixnum)
+    cursor[1] = update_v_arr
+    cursor[2] = update_arr
+    cursor.exec_array
+    cursor.close
+    
+    cursor = @conn.parse("SELECT * FROM test_table ORDER BY N")
+    cursor.exec
+    1.upto( max_array_size ) do |i|
+      rv = cursor.fetch      
+      if i%2 != 0
+        assert_equal(rv[0], i)
+        assert_equal(rv[1], i.to_s)
+      else
+        assert_equal(rv[0], i)
+        assert_equal(rv[1], (i * 10).to_s)
+      end
+    end  
+    assert_nil(cursor.fetch)    
+
+    cursor.close
+    drop_table('test_table')
+  end
+end

data/test/test_bind_raw.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 TestBindRaw < RUNIT::TestCase
+class TestBindRaw < Test::Unit::TestCase
   CHECK_TARGET = [
     ["0123456789:;<=>?", "303132333435363738393A3B3C3D3E3F"],
     ["@ABCDEFGHIJKLMNO", "404142434445464748494A4B4C4D4E4F"],
@@ -14,40 +13,34 @@ class TestBindRaw < RUNIT::TestCase
   ]
 
   def setup
-    @env, @svc, @stmt = setup_lowapi()
+    @conn = get_oci8_connection()
   end
 
   def test_set_raw
-    @stmt.prepare("BEGIN :hex := RAWTOHEX(:raw); END;")
-    raw_in = @stmt.bindByName(":raw", OCI_TYPECODE_RAW, 16)
-    hex_out = @stmt.bindByName(":hex", String, 32)
-    
+    cursor = @conn.parse("BEGIN :hex := RAWTOHEX(:raw); END;")
+    cursor.bind_param(:raw, nil, OCI8::RAW, 16)
+    cursor.bind_param(:hex, nil, String, 32)
+
     CHECK_TARGET.each do |raw, hex|
-      raw_in.set(raw)
-      @stmt.execute(@svc)
-      assert_equal(hex, hex_out.get())
+      cursor[:raw] = raw
+      cursor.exec
+      assert_equal(hex, cursor[:hex])
     end
   end
 
   def test_get_raw
-    @stmt.prepare("BEGIN :raw := HEXTORAW(:hex); END;")
-    hex_in = @stmt.bindByName(":hex", String, 32)
-    raw_out = @stmt.bindByName(":raw", OCI_TYPECODE_RAW, 16)
-    
+    cursor = @conn.parse("BEGIN :raw := HEXTORAW(:hex); END;")
+    cursor.bind_param(:hex, nil, String, 32)
+    cursor.bind_param(:raw, nil, OCI8::RAW, 16)
+
     CHECK_TARGET.each do |raw, hex|
-      hex_in.set(hex)
-      @stmt.execute(@svc)
-      assert_equal(raw, raw_out.get())
+      cursor[:hex] = hex
+      cursor.exec
+      assert_equal(raw, cursor[:raw])
     end
   end
 
   def teardown
-    @stmt.free()
-    @svc.logoff()
-    @env.free()
+    @conn.logoff
   end
 end
-
-if $0 == __FILE__
-  RUNIT::CUI::TestRunner.run(TestBindRaw.suite())
-end

data/test/test_bind_time.rb

@@ -1,10 +1,8 @@
-# Low-level API
 require 'oci8'
-require 'runit/testcase'
-require 'runit/cui/testrunner'
+require 'test/unit'
 require File.dirname(__FILE__) + '/config'
 
-class TestBindTime < RUNIT::TestCase
+class TestBindTime < Test::Unit::TestCase
 
   YEAR_CHECK_TARGET = [1971, 1989, 2002, 2037]
   MON_CHECK_TARGET = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
@@ -14,178 +12,167 @@ class TestBindTime < RUNIT::TestCase
   SEC_CHECK_TARGET = [0, 15, 30, 45, 59]
 
   def setup
-    @env, @svc, @stmt = setup_lowapi()
+    @conn = get_oci8_connection
   end
 
   def test_set_year
-    @stmt.prepare("BEGIN :year := TO_NUMBER(TO_CHAR(:time, 'SYYYY'), '9999'); END;")
-    time_in = @stmt.bindByName(":time", Time)
-    year_out = @stmt.bindByName(":year", Fixnum)
+    cursor = @conn.parse("BEGIN :year := TO_NUMBER(TO_CHAR(:time, 'SYYYY'), '9999'); END;")
+    cursor.bind_param(:time, Time)
+    cursor.bind_param(:year, Fixnum)
+
     YEAR_CHECK_TARGET.each do |i|
       # set year
-      time = Time.local(i, 1)
-      # check result via oracle.
-      time_in.set(time)
-      @stmt.execute(@svc)
-      assert_equal(i, year_out.get())
+      cursor[:time] = Time.local(i, 1)
+      # check result
+      cursor.exec
+      assert_equal(i, cursor[:year])
     end
   end
 
   def test_get_year
-    @stmt.prepare("BEGIN :time := TO_DATE(TO_CHAR(:year, '0999'), 'SYYYY'); END;")
-    year_in = @stmt.bindByName(":year", Fixnum)
-    time_out = @stmt.bindByName(":time", Time)
+    cursor = @conn.parse("BEGIN :time := TO_DATE(TO_CHAR(:year, '0999'), 'SYYYY'); END;")
+    cursor.bind_param(:year, Fixnum)
+    cursor.bind_param(:time, Time)
     YEAR_CHECK_TARGET.each do |i|
       # set time via oracle.
-      year_in.set(i)
-      @stmt.execute(@svc)
+      cursor[:year] = i
+      cursor.exec
       # check Time#year
-      assert_equal(i, time_out.get.year)
+      assert_equal(i, cursor[:time].year)
     end
   end
 
   def test_set_mon
-    @stmt.prepare("BEGIN :mon := TO_NUMBER(TO_CHAR(:time, 'MM'), '99'); END;")
-    time_in = @stmt.bindByName(":time", Time)
-    mon_out = @stmt.bindByName(":mon", Fixnum)
+    cursor = @conn.parse("BEGIN :mon := TO_NUMBER(TO_CHAR(:time, 'MM'), '99'); END;")
+    cursor.bind_param(:time, Time)
+    cursor.bind_param(:mon, Fixnum)
     MON_CHECK_TARGET.each do |i|
       # set mon
-      time = Time.local(2001, i)
+      cursor[:time] = Time.local(2001, i)
       # check result via oracle.
-      time_in.set(time)
-      @stmt.execute(@svc)
-      assert_equal(i, mon_out.get())
+      cursor.exec
+      assert_equal(i, cursor[:mon])
     end
   end
 
   def test_get_mon
-    @stmt.prepare("BEGIN :time := TO_DATE(TO_CHAR(:mon, '99'), 'MM'); END;")
-    mon_in = @stmt.bindByName(":mon", Fixnum)
-    time_out = @stmt.bindByName(":time", Time)
+    cursor = @conn.parse("BEGIN :time := TO_DATE(TO_CHAR(:mon, '99'), 'MM'); END;")
+    cursor.bind_param(:mon, Fixnum)
+    cursor.bind_param(:time, Time)
     MON_CHECK_TARGET.each do |i|
       # set time via oracle.
-      mon_in.set(i)
-      @stmt.execute(@svc)
+      cursor[:mon] = i;
+      cursor.exec
       # check Time#mon
-      assert_equal(i, time_out.get.mon)
+      assert_equal(i, cursor[:time].mon)
     end
   end
 
   def test_set_day
-    @stmt.prepare("BEGIN :day := TO_NUMBER(TO_CHAR(:time, 'DD'), '99'); END;")
-    time_in = @stmt.bindByName(":time", Time)
-    day_out = @stmt.bindByName(":day", Fixnum)
+    cursor = @conn.parse("BEGIN :day := TO_NUMBER(TO_CHAR(:time, 'DD'), '99'); END;")
+    cursor.bind_param(:time, Time)
+    cursor.bind_param(:day, Fixnum)
     DAY_CHECK_TARGET.each do |i|
       # set day
-      time = Time.local(2001, 1, i)
+      cursor[:time] = Time.local(2001, 1, i)
       # check result via oracle.
-      time_in.set(time)
-      @stmt.execute(@svc)
-      assert_equal(i, day_out.get())
+      cursor.exec
+      assert_equal(i, cursor[:day])
     end
   end
 
   def test_get_day
-    @stmt.prepare("BEGIN :time := TO_DATE('200101' || TO_CHAR(:day, 'FM00'), 'YYYYMMDD'); END;")
-    day_in = @stmt.bindByName(":day", Fixnum)
-    time_out = @stmt.bindByName(":time", Time)
+    cursor = @conn.parse("BEGIN :time := TO_DATE('200101' || TO_CHAR(:day, 'FM00'), 'YYYYMMDD'); END;")
+    day_in = cursor.bind_param(:day, Fixnum)
+    time_out = cursor.bind_param(:time, Time)
     DAY_CHECK_TARGET.each do |i|
       # set time via oracle.
-      day_in.set(i)
-      @stmt.execute(@svc)
+      cursor[:day] = i;
+      cursor.exec
       # check Time#day
-      assert_equal(i, time_out.get.day)
+      assert_equal(i, cursor[:time].day)
     end
   end
 
   def test_set_hour
-    @stmt.prepare("BEGIN :hour := TO_NUMBER(TO_CHAR(:time, 'HH24'), '99'); END;")
-    time_in = @stmt.bindByName(":time", Time)
-    hour_out = @stmt.bindByName(":hour", Fixnum)
+    cursor = @conn.parse("BEGIN :hour := TO_NUMBER(TO_CHAR(:time, 'HH24'), '99'); END;")
+    cursor.bind_param(:time, Time)
+    cursor.bind_param(:hour, Fixnum)
     HOUR_CHECK_TARGET.each do |i|
       # set hour
-      time = Time.local(2001, 1, 1, i)
+      cursor[:time] = Time.local(2001, 1, 1, i)
       # check result via oracle.
-      time_in.set(time)
-      @stmt.execute(@svc)
-      assert_equal(i, hour_out.get())
+      cursor.exec
+      assert_equal(i, cursor[:hour])
     end
   end
 
   def test_get_hour
-    @stmt.prepare("BEGIN :time := TO_DATE(TO_CHAR(:hour, '99'), 'HH24'); END;")
-    hour_in = @stmt.bindByName(":hour", Fixnum)
-    time_out = @stmt.bindByName(":time", Time)
+    cursor = @conn.parse("BEGIN :time := TO_DATE(TO_CHAR(:hour, '99'), 'HH24'); END;")
+    cursor.bind_param(:hour, Fixnum)
+    cursor.bind_param(:time, Time)
     HOUR_CHECK_TARGET.each do |i|
       # set time via oracle.
-      hour_in.set(i)
-      @stmt.execute(@svc)
+      cursor[:hour] = i
+      cursor.exec
       # check Time#hour
-      assert_equal(i, time_out.get.hour)
+      assert_equal(i, cursor[:time].hour)
     end
   end
 
   def test_set_min
-    @stmt.prepare("BEGIN :min := TO_NUMBER(TO_CHAR(:time, 'MI'), '99'); END;")
-    time_in = @stmt.bindByName(":time", Time)
-    min_out = @stmt.bindByName(":min", Fixnum)
+    cursor = @conn.parse("BEGIN :min := TO_NUMBER(TO_CHAR(:time, 'MI'), '99'); END;")
+    cursor.bind_param(:time, Time)
+    cursor.bind_param(:min, Fixnum)
     MIN_CHECK_TARGET.each do |i|
       # set min
-      time = Time.local(2001, 1, 1, 0, i)
+      cursor[:time] = Time.local(2001, 1, 1, 0, i)
       # check result via oracle.
-      time_in.set(time)
-      @stmt.execute(@svc)
-      assert_equal(i, min_out.get())
+      cursor.exec
+      assert_equal(i, cursor[:min])
     end
   end
 
   def test_get_min
-    @stmt.prepare("BEGIN :time := TO_DATE(TO_CHAR(:min, '99'), 'MI'); END;")
-    min_in = @stmt.bindByName(":min", Fixnum)
-    time_out = @stmt.bindByName(":time", Time)
+    cursor = @conn.parse("BEGIN :time := TO_DATE(TO_CHAR(:min, '99'), 'MI'); END;")
+    cursor.bind_param(:min, Fixnum)
+    cursor.bind_param(:time, Time)
     MIN_CHECK_TARGET.each do |i|
       # set time via oracle.
-      min_in.set(i)
-      @stmt.execute(@svc)
+      cursor[:min] = i;
+      cursor.exec
       # check Time#min
-      assert_equal(i, time_out.get.min)
+      assert_equal(i, cursor[:time].min)
     end
   end
 
   def test_set_sec
-    @stmt.prepare("BEGIN :sec := TO_NUMBER(TO_CHAR(:time, 'SS'), '99'); END;")
-    time_in = @stmt.bindByName(":time", Time)
-    sec_out = @stmt.bindByName(":sec", Fixnum)
+    cursor = @conn.parse("BEGIN :sec := TO_NUMBER(TO_CHAR(:time, 'SS'), '99'); END;")
+    cursor.bind_param(:time, Time)
+    cursor.bind_param(:sec, Fixnum)
     SEC_CHECK_TARGET.each do |i|
       # set sec
-      time = Time.local(2001, 1, 1, 0, 0, i)
+      cursor[:time] = Time.local(2001, 1, 1, 0, 0, i)
       # check result via oracle.
-      time_in.set(time)
-      @stmt.execute(@svc)
-      assert_equal(i, sec_out.get())
+      cursor.exec
+      assert_equal(i, cursor[:sec])
     end
   end
 
   def test_get_sec
-    @stmt.prepare("BEGIN :time := TO_DATE(TO_CHAR(:sec, '99'), 'SS'); END;")
-    sec_in = @stmt.bindByName(":sec", Fixnum)
-    time_out = @stmt.bindByName(":time", Time)
+    cursor = @conn.parse("BEGIN :time := TO_DATE(TO_CHAR(:sec, '99'), 'SS'); END;")
+    cursor.bind_param(:sec, Fixnum)
+    cursor.bind_param(:time, Time)
     SEC_CHECK_TARGET.each do |i|
       # set time via oracle.
-      sec_in.set(i)
-      @stmt.execute(@svc)
+      cursor[:sec] = i
+      cursor.exec
       # check Time#sec
-      assert_equal(i, time_out.get.sec)
+      assert_equal(i, cursor[:time].sec)
     end
   end
 
   def teardown
-    @stmt.free()
-    @svc.logoff()
-    @env.free()
+    @conn.logoff
   end
 end
-
-if $0 == __FILE__
-  RUNIT::CUI::TestRunner.run(TestBindTime.suite())
-end