ruby-oci8 1.0.7 → 2.0.0

data/test/test_dbi.rb

@@ -1,15 +1,18 @@
 require 'dbi'
 require 'oci8'
-require 'runit/testcase'
-require 'runit/cui/testrunner'
+require 'test/unit'
 require File.dirname(__FILE__) + '/config'
 
-class TestDBI < RUNIT::TestCase
+class TestDBI < Test::Unit::TestCase
 
   def setup
     @dbh = get_dbi_connection()
   end
 
+  def teardown
+    @dbh.disconnect
+  end
+
   def test_select
     drop_table('test_table')
     sql = <<-EOS
@@ -99,19 +102,34 @@ EOS
     sth = @dbh.prepare("INSERT INTO test_table VALUES (:C, :V, :N, :D1, :D2, :D3, :D4, :INT, :BIGNUM)")
     1.upto(10) do |i|
       if i == 1
-	dt = nil
-        v = ''
+        if OCI8::oracle_client_version >= OCI8::ORAVER_9_0
+          dt = nil
+          v = ''
+          sth.execute(format("%10d", i * 10), v, i, dt, dt, dt, dt, i, i)
+        else
+          # explicitly bind nil with datatype to avoid ORA-01475 when using Oracle 8i.
+          sth.bind_param(1, format("%10d", i * 10))
+          sth.bind_param(2, '')
+          sth.bind_param(3, i)
+          sth.bind_param(4, nil, {'type' => OraDate})
+          sth.bind_param(5, nil, {'type' => OraDate})
+          sth.bind_param(6, nil, {'type' => OraDate})
+          sth.bind_param(7, nil, {'type' => OraDate})
+          sth.bind_param(8, i)
+          sth.bind_param(9, i)
+          sth.execute
+        end
       else
-	dt = OraDate.new(2000 + i, 8, 3, 23, 59, 59)
+        dt = OraDate.new(2000 + i, 8, 3, 23, 59, 59)
         v = i.to_s
+        sth.execute(format("%10d", i * 10), v, i, dt, dt, dt, dt, i, i)
       end
-      sth.execute(format("%10d", i * 10), v, i, dt, dt, dt, dt, i, i)
     end
     sth.finish
     sth = @dbh.prepare("SELECT * FROM test_table ORDER BY c")
     sth.func(:define, 5, Time) # define 5th column as Time
     sth.func(:define, 6, Date) # define 6th column as Date
-    sth.func(:define, 7, DateTime) if defined? DateTime # define 7th column as DateTime
+    sth.func(:define, 7, DateTime) # define 7th column as DateTime
     sth.func(:define, 8, Integer) # define 8th column as Integer
     sth.func(:define, 9, Bignum) # define 9th column as Bignum
     sth.execute
@@ -128,14 +146,16 @@ EOS
 	assert_nil(rv[6])
       else
 	assert_equal(i.to_s, rv[1])
-	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])
 	assert_instance_of(Time, rv[4])
 	assert_instance_of(Date, rv[5])
-	assert_instance_of(DateTime, rv[6]) if defined? DateTime
+	assert_instance_of(DateTime, rv[6])
       end
       assert_equal(i, rv[7])
       assert_equal(i, rv[8])
@@ -170,47 +190,62 @@ EOS
   end
 
   def test_column_info
+    if $oracle_version < OCI8::ORAVER_8_1
+      begin
+        @dbh.columns('tab')
+      rescue RuntimeError
+        assert_equal("This feature is unavailable on Oracle 8.0", $!.to_s)
+      end
+      return
+    end
+
     # data_size factor for nchar charset_form.
-    sth = @dbh.execute("select CAST('1' AS NCHAR(1)) from dual")
+    sth = @dbh.execute("select N'1' from dual")
     cfrm = sth.column_info[0]['precision']
-    if $oracle_version >=  900
+    if $oracle_version >=  OCI8::ORAVER_9_0
       # data_size factor for char semantics.
       sth = @dbh.execute("select CAST('1' AS CHAR(1 char)) from dual")
       csem = sth.column_info[0]['precision']
+    else
+      csem = 1
     end
 
+    ora80 = OCI8::ORAVER_8_0
+    ora81 = OCI8::ORAVER_8_1
+    ora90 = OCI8::ORAVER_9_0
+    ora101 = OCI8::ORAVER_10_1
     coldef =
       [
        # oracle_version, definition,    sql_type,        type_name, nullable, precision,scale,indexed,primary,unique,default
-       [800, "CHAR(10) NOT NULL",        DBI::SQL_CHAR,    'CHAR',     false,        10, nil, true, true, true, nil],
-       [900, "CHAR(10 CHAR)",            DBI::SQL_CHAR,    'CHAR',     true,  10 * csem, nil, false,false,false,nil],
-       [800, "NCHAR(10)",                DBI::SQL_CHAR,    'NCHAR',    true,  10 * cfrm, nil, true, false,true, nil],
-       [800, "VARCHAR2(10) DEFAULT 'a''b'", DBI::SQL_VARCHAR, 'VARCHAR2', true,         10, nil, true, false,false, "a'b"],
-       [900, "VARCHAR2(10 CHAR)",        DBI::SQL_VARCHAR, 'VARCHAR2', true,  10 * csem, nil, false,false,false,nil],
-       [800, "NVARCHAR2(10)",            DBI::SQL_VARCHAR, 'NVARCHAR2',true,  10 * cfrm, nil, false,false,false,nil],
-       [800, "RAW(10)",                  DBI::SQL_VARBINARY, 'RAW',    true,         10, nil, false,false,false,nil],
-       [800, "CLOB",                     DBI::SQL_CLOB,    'CLOB',     true,       4000, nil, false,false,false,nil],
-       [800, "NCLOB",                    DBI::SQL_CLOB,    'NCLOB',    true,       4000, nil, false,false,false,nil],
-       [800, "BLOB",                     DBI::SQL_BLOB,    'BLOB',     true,       4000, nil, false,false,false,nil],
-       [800, "BFILE",                    DBI::SQL_BLOB,    'BFILE',    true,       4000, nil, false,false,false,nil],
-       [800, "NUMBER",                   DBI::SQL_NUMERIC, 'NUMBER',   true,         38, nil, false,false,false,nil],
-       [800, "NUMBER(10)",               DBI::SQL_NUMERIC, 'NUMBER',   true,         10,   0, false,false,false,nil],
-       [800, "NUMBER(10,2)",             DBI::SQL_NUMERIC, 'NUMBER',   true,         10,   2, false,false,false,nil],
-       [800, "FLOAT",                    DBI::SQL_FLOAT,   'FLOAT',    true, (126 * 0.30103).ceil, nil, false,false,false,nil],
-       [800, "FLOAT(10)",                DBI::SQL_FLOAT,   'FLOAT',    true, (10 * 0.30103).ceil, nil, false,false,false,nil],
-       [1000,"BINARY_FLOAT",             DBI::SQL_FLOAT,   'BINARY_FLOAT', true,      7, nil, false,false,false,nil],
-       [1000,"BINARY_DOUBLE",            DBI::SQL_DOUBLE,  'BINARY_DOUBLE', true,    16, nil, false,false,false,nil],
-       [800, "DATE",                     DBI::SQL_DATE,    'DATE',     true,         19, nil, false,false,false,nil],
-       [900, "TIMESTAMP",                DBI::SQL_TIMESTAMP, 'TIMESTAMP', true,  20 + 6, nil, false,false,false,nil],
-       [900, "TIMESTAMP(9)",             DBI::SQL_TIMESTAMP, 'TIMESTAMP', true,  20 + 9, nil, false,false,false,nil],
-       [900, "TIMESTAMP WITH TIME ZONE",          DBI::SQL_TIMESTAMP, 'TIMESTAMP WITH TIME ZONE', true,  27 + 6, nil, false,false,false,nil],
-       [900, "TIMESTAMP(9) WITH TIME ZONE",       DBI::SQL_TIMESTAMP, 'TIMESTAMP WITH TIME ZONE', true,  27 + 9, nil, false,false,false,nil],
-       [900, "TIMESTAMP WITH LOCAL TIME ZONE",    DBI::SQL_TIMESTAMP, 'TIMESTAMP WITH LOCAL TIME ZONE', true,  20 + 6, nil, false,false,false,nil],
-       [900, "TIMESTAMP(9) WITH LOCAL TIME ZONE", DBI::SQL_TIMESTAMP, 'TIMESTAMP WITH LOCAL TIME ZONE', true,  20 + 9, nil, false,false,false,nil],
-       [900, "INTERVAL YEAR TO MONTH",      DBI::SQL_OTHER, 'INTERVAL YEAR TO MONTH', true, 2 + 3, nil, false,false,false,nil],
-       [900, "INTERVAL YEAR(4) TO MONTH",   DBI::SQL_OTHER, 'INTERVAL YEAR TO MONTH', true, 4 + 3, nil, false,false,false,nil],
-       [900, "INTERVAL DAY TO SECOND",      DBI::SQL_OTHER, 'INTERVAL DAY TO SECOND', true, 2 + 10 + 6, nil, false,false,false,nil],
-       [900, "INTERVAL DAY(4) TO SECOND(9)",DBI::SQL_OTHER, 'INTERVAL DAY TO SECOND', true, 4 + 10 + 9, nil, false,false,false,nil],
+       [ora80, "CHAR(10) NOT NULL",        DBI::SQL_CHAR,    'CHAR',     false,        10, nil, true, true, true, nil],
+       [ora90, "CHAR(10 CHAR)",            DBI::SQL_CHAR,    'CHAR',     true,  10 * csem, nil, false,false,false,nil],
+       [ora80, "NCHAR(10)",                DBI::SQL_CHAR,    'NCHAR',    true,  10 * cfrm, nil, true, false,true, nil],
+       [ora80, "VARCHAR2(10) DEFAULT 'a''b'", DBI::SQL_VARCHAR, 'VARCHAR2', true,         10, nil, true, false,false, "a'b"],
+       [ora90, "VARCHAR2(10 CHAR)",        DBI::SQL_VARCHAR, 'VARCHAR2', true,  10 * csem, nil, false,false,false,nil],
+       [ora80, "NVARCHAR2(10)",            DBI::SQL_VARCHAR, 'NVARCHAR2',true,  10 * cfrm, nil, false,false,false,nil],
+       [ora80, "RAW(10)",                  DBI::SQL_VARBINARY, 'RAW',    true,         10, nil, false,false,false,nil],
+       [ora81, "CLOB",                     DBI::SQL_CLOB,    'CLOB',     true,       4000, nil, false,false,false,nil],
+       [ora81, "NCLOB",                    DBI::SQL_CLOB,    'NCLOB',    true,       4000, nil, false,false,false,nil],
+       [ora80, "BLOB",                     DBI::SQL_BLOB,    'BLOB',     true,       4000, nil, false,false,false,nil],
+       [ora80, "BFILE",                    DBI::SQL_BLOB,    'BFILE',    true,       4000, nil, false,false,false,nil],
+       [ora80, "NUMBER",                   DBI::SQL_NUMERIC, 'NUMBER',   true,         38, nil, false,false,false,nil],
+       [ora80, "NUMBER(10)",               DBI::SQL_NUMERIC, 'NUMBER',   true,         10,   0, false,false,false,nil],
+       [ora80, "NUMBER(10,2)",             DBI::SQL_NUMERIC, 'NUMBER',   true,         10,   2, false,false,false,nil],
+       [ora80, "FLOAT",                    DBI::SQL_FLOAT,   'FLOAT',    true, (126 * 0.30103).ceil, nil, false,false,false,nil],
+       [ora80, "FLOAT(10)",                DBI::SQL_FLOAT,   'FLOAT',    true, (10 * 0.30103).ceil, nil, false,false,false,nil],
+       [ora101,"BINARY_FLOAT",             DBI::SQL_FLOAT,   'BINARY_FLOAT', true,      7, nil, false,false,false,nil],
+       [ora101,"BINARY_DOUBLE",            DBI::SQL_DOUBLE,  'BINARY_DOUBLE', true,    16, nil, false,false,false,nil],
+       [ora80, "DATE",                     DBI::SQL_DATE,    'DATE',     true,         19, nil, false,false,false,nil],
+       [ora90, "TIMESTAMP",                DBI::SQL_TIMESTAMP, 'TIMESTAMP', true,  20 + 6, nil, false,false,false,nil],
+       [ora90, "TIMESTAMP(9)",             DBI::SQL_TIMESTAMP, 'TIMESTAMP', true,  20 + 9, nil, false,false,false,nil],
+       [ora90, "TIMESTAMP WITH TIME ZONE",          DBI::SQL_TIMESTAMP, 'TIMESTAMP WITH TIME ZONE', true,  27 + 6, nil, false,false,false,nil],
+       [ora90, "TIMESTAMP(9) WITH TIME ZONE",       DBI::SQL_TIMESTAMP, 'TIMESTAMP WITH TIME ZONE', true,  27 + 9, nil, false,false,false,nil],
+       [ora90, "TIMESTAMP WITH LOCAL TIME ZONE",    DBI::SQL_TIMESTAMP, 'TIMESTAMP WITH LOCAL TIME ZONE', true,  20 + 6, nil, false,false,false,nil],
+       [ora90, "TIMESTAMP(9) WITH LOCAL TIME ZONE", DBI::SQL_TIMESTAMP, 'TIMESTAMP WITH LOCAL TIME ZONE', true,  20 + 9, nil, false,false,false,nil],
+       [ora90, "INTERVAL YEAR TO MONTH",      DBI::SQL_OTHER, 'INTERVAL YEAR TO MONTH', true, 2 + 3, nil, false,false,false,nil],
+       [ora90, "INTERVAL YEAR(4) TO MONTH",   DBI::SQL_OTHER, 'INTERVAL YEAR TO MONTH', true, 4 + 3, nil, false,false,false,nil],
+       [ora90, "INTERVAL DAY TO SECOND",      DBI::SQL_OTHER, 'INTERVAL DAY TO SECOND', true, 2 + 10 + 6, nil, false,false,false,nil],
+       [ora90, "INTERVAL DAY(4) TO SECOND(9)",DBI::SQL_OTHER, 'INTERVAL DAY TO SECOND', true, 4 + 10 + 9, nil, false,false,false,nil],
       ]
 
     coldef.reject! do |c| c[0] > $oracle_version end
@@ -293,17 +328,25 @@ EOS
        ["TABTYPE",  DBI::SQL_VARCHAR,'VARCHAR2',true,     7,       nil,  false,  false,  false, nil],
        ["CLUSTERID",DBI::SQL_NUMERIC,'NUMBER',  true,    38,       nil,  false,  false,  false, nil],
       ]
-    @dbh.columns('tab').each_with_index do |ci, i|
-      assert_equal(coldef[i][0], ci['name'],      "'#{coldef[i][0]}': name")
-      assert_equal(coldef[i][1], ci['sql_type'],  "'#{coldef[i][0]}': sql_type")
-      assert_equal(coldef[i][2], ci['type_name'], "'#{coldef[i][0]}': type_name")
-      assert_equal(coldef[i][3], ci['nullable'],  "'#{coldef[i][0]}': nullable")
-      assert_equal(coldef[i][4], ci['precision'], "'#{coldef[i][0]}': precision")
-      assert_equal(coldef[i][5], ci['scale'],     "'#{coldef[i][0]}': scale")
-      assert_equal(coldef[i][6], ci['indexed'],   "'#{coldef[i][0]}': indexed")
-      assert_equal(coldef[i][7], ci['primary'],   "'#{coldef[i][0]}': primary")
-      assert_equal(coldef[i][8], ci['unique'],    "'#{coldef[i][0]}': unique")
-      assert_equal(coldef[i][9], ci['default'],    "'#{coldef[i][0]}': default")
+    begin
+      @dbh.columns('tab').each_with_index do |ci, i|
+        assert_equal(coldef[i][0], ci['name'],      "'#{coldef[i][0]}': name")
+        assert_equal(coldef[i][1], ci['sql_type'],  "'#{coldef[i][0]}': sql_type")
+        assert_equal(coldef[i][2], ci['type_name'], "'#{coldef[i][0]}': type_name")
+        assert_equal(coldef[i][3], ci['nullable'],  "'#{coldef[i][0]}': nullable")
+        assert_equal(coldef[i][4], ci['precision'], "'#{coldef[i][0]}': precision")
+        assert_equal(coldef[i][5], ci['scale'],     "'#{coldef[i][0]}': scale")
+        assert_equal(coldef[i][6], ci['indexed'],   "'#{coldef[i][0]}': indexed")
+        assert_equal(coldef[i][7], ci['primary'],   "'#{coldef[i][0]}': primary")
+        assert_equal(coldef[i][8], ci['unique'],    "'#{coldef[i][0]}': unique")
+        assert_equal(coldef[i][9], ci['default'],    "'#{coldef[i][0]}': default")
+      end
+    rescue RuntimeError
+      if $oracle_version < OCI8::ORAVER_8_1
+        assert_equal("This feature is unavailable on Oracle 8.0", $!.to_s)
+      else
+        raise
+      end
     end
 
     @dbh.execute("SELECT * FROM tab").column_info.each_with_index do |ci, i|
@@ -321,7 +364,3 @@ EOS
   end
 
 end # TestDBI
-
-if $0 == __FILE__
-  RUNIT::CUI::TestRunner.run(TestDBI.suite())
-end

data/test/test_dbi_clob.rb

@@ -1,10 +1,9 @@
 require 'dbi'
 require 'oci8'
-require 'runit/testcase'
-require 'runit/cui/testrunner'
+require 'test/unit'
 require File.dirname(__FILE__) + '/config'
 
-class TestDbiCLob < RUNIT::TestCase
+class TestDbiCLob < Test::Unit::TestCase
 
   def setup
     @dbh = get_dbi_connection()
@@ -49,10 +48,6 @@ class TestDbiCLob < RUNIT::TestCase
   end
 
   def teardown
-    @dbh.disconnect()
+    @dbh.disconnect
   end
 end
-
-if $0 == __FILE__
-  RUNIT::CUI::TestRunner.run(TestDbiCLob.suite())
-end

data/test/test_metadata.rb

@@ -1,12 +1,11 @@
 require 'oci8'
-require 'runit/testcase'
-require 'runit/cui/testrunner'
+require 'test/unit'
 require File.dirname(__FILE__) + '/config'
 
-class TestMetadata < RUNIT::TestCase
+class TestMetadata < Test::Unit::TestCase
 
   def setup
-    @conn = get_oci_connection()
+    @conn = get_oci8_connection
   end
 
   def teardown
@@ -14,25 +13,40 @@ class TestMetadata < RUNIT::TestCase
   end
 
   def test_metadata
+    if $oracle_version < OCI8::ORAVER_8_1
+      begin
+        @conn.describe_table('tab').columns
+      rescue RuntimeError
+        assert_equal("This feature is unavailable on Oracle 8.0", $!.to_s)
+      end
+      return
+    end
+
     # data_size factor for nchar charset_form.
-    cursor = @conn.exec("select CAST('1' AS NCHAR(1)) from dual")
+    cursor = @conn.exec("select N'1' from dual")
     cfrm = cursor.column_metadata[0].data_size
-    if $oracle_version >=  900
+    if $oracle_version >=  OCI8::ORAVER_9_0
       # data_size factor for char semantics.
       cursor = @conn.exec("select CAST('1' AS CHAR(1 char)) from dual")
       csem = cursor.column_metadata[0].data_size
+    else
+      csem = 1
     end
 
+    ora80 = OCI8::ORAVER_8_0
+    ora81 = OCI8::ORAVER_8_1
+    ora90 = OCI8::ORAVER_9_0
+    ora101 = OCI8::ORAVER_10_1
     coldef =
       [
-       # oracle_version, definition,    data_type,  csfrm,     null,csem?,csize, data_size,prec,scale,fsprec,lfprec
-       [800, "CHAR(10) NOT NULL",       :char,      :implicit, false, false, 10,        10,   0,    0,    0,    0],
-       [900, "CHAR(10 CHAR)",           :char,      :implicit, true,  true,  10, 10 * csem,   0,    0,    0,    0],
-       [800, "NCHAR(10)",               :char,      :nchar,    true,  true,  10, 10 * cfrm,   0,    0,    0,    0],
-       [800, "VARCHAR2(10)",            :varchar2,  :implicit, true,  false, 10,        10,   0,    0,    0,    0],
-       [900, "VARCHAR2(10 CHAR)",       :varchar2,  :implicit, true,  true,  10, 10 * csem,   0,    0,    0,    0],
-       [800, "NVARCHAR2(10)",           :varchar2,  :nchar,    true,  true,  10, 10 * cfrm,   0,    0,    0,    0],
-       [800, "RAW(10)",                 :raw,       nil,       true,  false,  0,        10,   0,    0,    0,    0],
+       # oracle_version, definition,    data_type,  csfrm,    null?,csem?,csize, data_size,prec,scale,fsprec,lfprec
+       [ora80, "CHAR(10) NOT NULL",       :char,      :implicit, false, false, 10,        10,   0,    0,    0,    0],
+       [ora90, "CHAR(10 CHAR)",           :char,      :implicit, true,  true,  10, 10 * csem,   0,    0,    0,    0],
+       [ora80, "NCHAR(10)",               :char,      :nchar,    true,  true,  10, 10 * cfrm,   0,    0,    0,    0],
+       [ora80, "VARCHAR2(10)",            :varchar2,  :implicit, true,  false, 10,        10,   0,    0,    0,    0],
+       [ora90, "VARCHAR2(10 CHAR)",       :varchar2,  :implicit, true,  true,  10, 10 * csem,   0,    0,    0,    0],
+       [ora80, "NVARCHAR2(10)",           :varchar2,  :nchar,    true,  true,  10, 10 * cfrm,   0,    0,    0,    0],
+       [ora80, "RAW(10)",                 :raw,       nil,       true,  false,  0,        10,   0,    0,    0,    0],
 
        # Don't check data_size of CLOB, NCLOB and BLOB.
        #
@@ -43,11 +57,11 @@ class TestMetadata < RUNIT::TestCase
        #   | implicit |   4000    |  <= OCI8::Cursor#column_metadata
        #   | explicit |     86    |  <= OCI8.describe_table('table_name').columns
        #   +----------+-----------+
-       [800, "CLOB",                    :clob,      :implicit, true,  false,  0,       :nc,   0,    0,    0,    0],
-       [800, "NCLOB",                   :clob,      :nchar,    true,  false,  0,       :nc,   0,    0,    0,    0],
-       [800, "BLOB",                    :blob,      nil,       true,  false,  0,       :nc,   0,    0,    0,    0],
+       [ora81, "CLOB",                    :clob,      :implicit, true,  false,  0,       :nc,   0,    0,    0,    0],
+       [ora81, "NCLOB",                   :clob,      :nchar,    true,  false,  0,       :nc,   0,    0,    0,    0],
+       [ora80, "BLOB",                    :blob,      nil,       true,  false,  0,       :nc,   0,    0,    0,    0],
 
-       [800, "BFILE",                   :bfile,     nil,       true,  false,  0,       530,   0,    0,    0,    0],
+       [ora80, "BFILE",                   :bfile,     nil,       true,  false,  0,       530,   0,    0,    0,    0],
 
        # Don't check fsprecision and lfprecision for NUMBER and FLOAT
        #
@@ -70,15 +84,15 @@ class TestMetadata < RUNIT::TestCase
        #   | FLOAT(10)      | implicit |     129     |     10      |
        #   |                | explicit |      10     |    129      |
        #   +----------------+----------+-------------+-------------+
-       [800, "NUMBER",                  :number,    nil,       true,  false,  0,        22,   0, -127,  :nc,  :nc],
-       [800, "NUMBER(10)",              :number,    nil,       true,  false,  0,        22,  10,    0,  :nc,  :nc],
-       [800, "NUMBER(10,2)",            :number,    nil,       true,  false,  0,        22,  10,    2,  :nc,  :nc],
-       [800, "FLOAT",                   :number,    nil,       true,  false,  0,        22, 126, -127,  :nc,  :nc],
-       [800, "FLOAT(10)",               :number,    nil,       true,  false,  0,        22,  10, -127,  :nc,  :nc],
+       [ora80, "NUMBER",                  :number,    nil,       true,  false,  0,        22,   0, $oracle_version >= ora90 ? -127 : 0,  :nc,  :nc],
+       [ora80, "NUMBER(10)",              :number,    nil,       true,  false,  0,        22,  10,    0,  :nc,  :nc],
+       [ora80, "NUMBER(10,2)",            :number,    nil,       true,  false,  0,        22,  10,    2,  :nc,  :nc],
+       [ora80, "FLOAT",                   :number,    nil,       true,  false,  0,        22, 126, -127,  :nc,  :nc],
+       [ora80, "FLOAT(10)",               :number,    nil,       true,  false,  0,        22,  10, -127,  :nc,  :nc],
 
-       [1000,"BINARY_FLOAT",            :binary_float,  nil,   true,  false,  0,         4,   0,    0,    0,    0],
-       [1000,"BINARY_DOUBLE",           :binary_double, nil,   true,  false,  0,         8,   0,    0,    0,    0],
-       [800, "DATE",                    :date,      nil,       true,  false,  0,         7,   0,    0,    0,    0],
+       [ora101,"BINARY_FLOAT",            :binary_float,  nil,   true,  false,  0,         4,   0,    0,    0,    0],
+       [ora101,"BINARY_DOUBLE",           :binary_double, nil,   true,  false,  0,         8,   0,    0,    0,    0],
+       [ora80, "DATE",                    :date,      nil,       true,  false,  0,         7,   0,    0,    0,    0],
 
        # Don't check precision and lfprecision for TIMESTAMP
        #
@@ -104,12 +118,12 @@ class TestMetadata < RUNIT::TestCase
        #   | TIMESTAMP(9) WITH LOCAL TIME ZONE | implicit |     0     |      0      |
        #   |                                   | explicit |     9     |      9      |
        #   +-----------------------------------+----------+-----------+-------------+
-       [900, "TIMESTAMP",                         :timestamp,     nil, true, false, 0,  11, :nc,    6,    6,  :nc],
-       [900, "TIMESTAMP(9)",                      :timestamp,     nil, true, false, 0,  11, :nc,    9,    9,  :nc],
-       [900, "TIMESTAMP WITH TIME ZONE",          :timestamp_tz,  nil, true, false, 0,  13, :nc,    6,    6,  :nc],
-       [900, "TIMESTAMP(9) WITH TIME ZONE",       :timestamp_tz,  nil, true, false, 0,  13, :nc,    9,    9,  :nc],
-       [900, "TIMESTAMP WITH LOCAL TIME ZONE",    :timestamp_ltz, nil, true, false, 0,  11, :nc,    6,    6,  :nc],
-       [900, "TIMESTAMP(9) WITH LOCAL TIME ZONE", :timestamp_ltz, nil, true, false, 0,  11, :nc,    9,    9,  :nc],
+       [ora90, "TIMESTAMP",                         :timestamp,     nil, true, false, 0,  11, :nc,    6,    6,  :nc],
+       [ora90, "TIMESTAMP(9)",                      :timestamp,     nil, true, false, 0,  11, :nc,    9,    9,  :nc],
+       [ora90, "TIMESTAMP WITH TIME ZONE",          :timestamp_tz,  nil, true, false, 0,  13, :nc,    6,    6,  :nc],
+       [ora90, "TIMESTAMP(9) WITH TIME ZONE",       :timestamp_tz,  nil, true, false, 0,  13, :nc,    9,    9,  :nc],
+       [ora90, "TIMESTAMP WITH LOCAL TIME ZONE",    :timestamp_ltz, nil, true, false, 0,  11, :nc,    6,    6,  :nc],
+       [ora90, "TIMESTAMP(9) WITH LOCAL TIME ZONE", :timestamp_ltz, nil, true, false, 0,  11, :nc,    9,    9,  :nc],
 
        # Don't check scale and fsprecision for INTERVAL YEAR TO MONTH
        #
@@ -123,8 +137,8 @@ class TestMetadata < RUNIT::TestCase
        #   | INTERVAL YEAR(4) TO MONTH    | implicit |     0     |      0      |
        #   |                              | explicit |     4     |      4      |
        #   +------------------------------+----------+-----------+-------------+
-       [900, "INTERVAL YEAR TO MONTH",      :interval_ym, nil, true,  false,  0,         5,   2,  :nc,  :nc,    2],
-       [900, "INTERVAL YEAR(4) TO MONTH",   :interval_ym, nil, true,  false,  0,         5,   4,  :nc,  :nc,    4],
+       [ora90, "INTERVAL YEAR TO MONTH",      :interval_ym, nil, true,  false,  0,         5,   2,  :nc,  :nc,    2],
+       [ora90, "INTERVAL YEAR(4) TO MONTH",   :interval_ym, nil, true,  false,  0,         5,   4,  :nc,  :nc,    4],
 
        # Don't check precision and scale for INTERVAL DAY TO SECOND
        #
@@ -138,15 +152,15 @@ class TestMetadata < RUNIT::TestCase
        #   | INTERVAL DAY(4) TO SECOND(9) | implicit |     4     |     9     |
        #   |                              | explicit |     9     |     4     |
        #   +------------------------------+----------+-----------+-----------+
-       [900, "INTERVAL DAY TO SECOND",      :interval_ds, nil, true,  false,  0,        11, :nc,  :nc,    6,    2],
-       [900, "INTERVAL DAY(4) TO SECOND(9)",:interval_ds, nil, true,  false,  0,        11, :nc,  :nc,    9,    4],
+       [ora90, "INTERVAL DAY TO SECOND",      :interval_ds, nil, true,  false,  0,        11, :nc,  :nc,    6,    2],
+       [ora90, "INTERVAL DAY(4) TO SECOND(9)",:interval_ds, nil, true,  false,  0,        11, :nc,  :nc,    9,    4],
       ]
 
     coldef.reject! do |c| c[0] > $oracle_version end
 
     drop_table('test_table')
     sql = <<-EOS
-CREATE TABLE test_table (#{i = 0; coldef.collect do |c| i += 1; "C#{i} " + c[1]; end.join(',')})
+CREATE TABLE test_table (#{idx = 0; coldef.collect do |c| idx += 1; "C#{idx} " + c[1]; end.join(',')})
 STORAGE (
    INITIAL 100k
    NEXT 100k
@@ -164,7 +178,7 @@ EOS
       assert_equal(coldef[i][3], md.charset_form, "'#{coldef[i][1]}': charset_form")
       assert_equal(coldef[i][4], md.nullable?, "'#{coldef[i][1]}': nullable? ")
       # string type
-      if $oracle_version >=  900
+      if $oracle_version >= OCI8::ORAVER_9_0
         assert_equal(coldef[i][5], md.char_used?, "'#{coldef[i][1]}': char_used? ")
         assert_equal(coldef[i][6], md.char_size, "'#{coldef[i][1]}': char_size")
       end
@@ -172,8 +186,10 @@ EOS
       # number, timestamp and interval type
       assert_equal(coldef[i][8], md.precision, "'#{coldef[i][1]}': precision") if coldef[i][8] != :nc
       assert_equal(coldef[i][9], md.scale, "'#{coldef[i][1]}': scale") if coldef[i][9] != :nc
-      assert_equal(coldef[i][10], md.fsprecision, "'#{coldef[i][1]}': fsprecision") if coldef[i][10] != :nc
-      assert_equal(coldef[i][11], md.lfprecision, "'#{coldef[i][1]}': lfprecision") if coldef[i][11] != :nc
+      if $oracle_version >= OCI8::ORAVER_9_0
+        assert_equal(coldef[i][10], md.fsprecision, "'#{coldef[i][1]}': fsprecision") if coldef[i][10] != :nc
+        assert_equal(coldef[i][11], md.lfprecision, "'#{coldef[i][1]}': lfprecision") if coldef[i][11] != :nc
+      end
     end
 
     # temporarily change OCI8::BindType::Mapping.
@@ -200,7 +216,7 @@ EOS
       assert_equal(coldef[i][3], md.charset_form, "'#{coldef[i][1]}': charset_form")
       assert_equal(coldef[i][4], md.nullable?, "'#{coldef[i][1]}': nullable? ")
       # string type
-      if $oracle_version >=  900
+      if $oracle_version >=  OCI8::ORAVER_9_0
         assert_equal(coldef[i][5], md.char_used?, "'#{coldef[i][1]}': char_used? ")
         assert_equal(coldef[i][6], md.char_size, "'#{coldef[i][1]}': char_size")
       end
@@ -208,8 +224,10 @@ EOS
       # number, timestamp and interval type
       assert_equal(coldef[i][8], md.precision, "'#{coldef[i][1]}': precision") if coldef[i][8] != :nc
       assert_equal(coldef[i][9], md.scale, "'#{coldef[i][1]}': scale") if coldef[i][9] != :nc
-      assert_equal(coldef[i][10], md.fsprecision, "'#{coldef[i][1]}': fsprecision") if coldef[i][10] != :nc
-      assert_equal(coldef[i][11], md.lfprecision, "'#{coldef[i][1]}': lfprecision") if coldef[i][11] != :nc
+      if $oracle_version >= OCI8::ORAVER_9_0
+        assert_equal(coldef[i][10], md.fsprecision, "'#{coldef[i][1]}': fsprecision") if coldef[i][10] != :nc
+        assert_equal(coldef[i][11], md.lfprecision, "'#{coldef[i][1]}': lfprecision") if coldef[i][11] != :nc
+      end
     end
 
     drop_table('test_table')
@@ -219,17 +237,17 @@ EOS
     drop_table('test_table')
     begin
       @conn.describe_table('test_table')
-      assert_fail("expects ORA-4043 but no error")
+      flunk("expects ORA-4043 but no error")
     rescue OCIError
-      assert_fail("expects ORA-4043 but ORA-#{$!.code}") if $!.code != 4043
+      flunk("expects ORA-4043 but ORA-#{$!.code}") if $!.code != 4043
     end
     @conn.exec('create sequence test_table')
     begin
       begin
         @conn.describe_table('test_table')
-        assert_fail('expects ORA-4043 but no error')
+        flunk('expects ORA-4043 but no error')
       rescue OCIError
-        assert_fail("expects ORA-4043 but ORA-#{$!.code}") if $!.code != 4043
+        flunk("expects ORA-4043 but ORA-#{$!.code}") if $!.code != 4043
       end
     ensure
       @conn.exec('drop sequence test_table')
@@ -237,7 +255,3 @@ EOS
   end
 
 end # TestMetadata
-
-if $0 == __FILE__
-  RUNIT::CUI::TestRunner.run(TestMetadata.suite())
-end