ruby-oci8 1.0.6-x86-mswin32-60

data/test/test_oradate.rb

@@ -0,0 +1,263 @@
+# Low-level API
+require 'oci8'
+require 'runit/testcase'
+require 'runit/cui/testrunner'
+require File.dirname(__FILE__) + '/config'
+
+class TestOraDate < RUNIT::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]
+  DAY_CHECK_TARGET = [1, 10, 20, 31] # days of January.
+  HOUR_CHECK_TARGET = [0, 6, 12, 18, 23]
+  MINUTE_CHECK_TARGET = [0, 15, 30, 45, 59]
+  SECOND_CHECK_TARGET = [0, 15, 30, 45, 59]
+
+  def setup
+    @env, @svc, @stmt = setup_lowapi()
+  end
+
+  def check_oradate(target, year, month, day, hour, minute, second)
+    assert_equal(year, target.year)
+    assert_equal(month, target.month)
+    assert_equal(day, target.day)
+    assert_equal(hour, target.hour)
+    assert_equal(minute, target.minute)
+    assert_equal(second, target.second)
+  end
+
+  def test_new()
+    check_oradate(OraDate.new(), 1, 1, 1, 0, 0, 0)
+  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)
+    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())
+    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)
+    YEAR_CHECK_TARGET.each do |i|
+      # set date via oracle.
+      year_in.set(i)
+      @stmt.execute(@svc)
+      # check OraDate#year
+      assert_equal(i, date_out.get.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)
+    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())
+    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)
+    MONTH_CHECK_TARGET.each do |i|
+      # set date via oracle.
+      month_in.set(i)
+      @stmt.execute(@svc)
+      # check OraDate#month
+      assert_equal(i, date_out.get.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)
+    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())
+    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)
+    DAY_CHECK_TARGET.each do |i|
+      # set date via oracle.
+      day_in.set(i)
+      @stmt.execute(@svc)
+      # check OraDate#day
+      assert_equal(i, date_out.get.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)
+    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())
+    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)
+    HOUR_CHECK_TARGET.each do |i|
+      # set date via oracle.
+      hour_in.set(i)
+      @stmt.execute(@svc)
+      # check OraDate#hour
+      assert_equal(i, date_out.get.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)
+    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())
+    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)
+    MINUTE_CHECK_TARGET.each do |i|
+      # set date via oracle.
+      minute_in.set(i)
+      @stmt.execute(@svc)
+      # check OraDate#minute
+      assert_equal(i, date_out.get.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)
+    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())
+    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)
+    SECOND_CHECK_TARGET.each do |i|
+      # set date via oracle.
+      second_in.set(i)
+      @stmt.execute(@svc)
+      # check OraDate#second
+      assert_equal(i, date_out.get.second)
+    end
+  end
+
+  def test_compare
+    d1 = OraDate.new(2003,03,15,18,55,35)
+    d2 = OraDate.new(2003,03,15,18,55,35)
+    assert_equal(d1, d2)
+    assert_operator(d1, :<, OraDate.new(2004,03,15,18,55,35))
+    assert_operator(d1, :<, OraDate.new(2003,04,15,18,55,35))
+    assert_operator(d1, :<, OraDate.new(2003,03,16,18,55,35))
+    assert_operator(d1, :<, OraDate.new(2003,03,15,19,55,35))
+    assert_operator(d1, :<, OraDate.new(2003,03,15,18,56,35))
+    assert_operator(d1, :<, OraDate.new(2003,03,15,18,55,36))
+
+    assert_operator(OraDate.new(2002,03,15,18,55,35), :<, d1)
+    assert_operator(OraDate.new(2003,02,15,18,55,35), :<, d1)
+    assert_operator(OraDate.new(2003,03,14,18,55,35), :<, d1)
+    assert_operator(OraDate.new(2003,03,15,17,55,35), :<, d1)
+    assert_operator(OraDate.new(2003,03,15,18,54,35), :<, d1)
+    assert_operator(OraDate.new(2003,03,15,18,55,34), :<, d1)
+  end
+
+  def test_to_time
+    year, month, day, hour, minute, second = [2003,03,15,18,55,35]
+    dt = OraDate.new(year, month, day, hour, minute, second)
+    tm = Time.local(year, month, day, hour, minute, second)
+    assert_equal(tm, dt.to_time)
+
+    # year, month, day, hour, minute, second = [1900,1,1,0,0,0]
+    # dt = OraDate.new(year, month, day, hour, minute, second)
+    # assert_exception(RangeError) { dt.to_time }
+  end
+
+  def test_to_date
+    [[2003,03,15], [1900,1,1], [-4712, 1, 1]].each do |year, month, day|
+      odt = OraDate.new(year, month, day)
+      rdt = Date.new(year, month, day)
+      assert_equal(rdt, odt.to_date)
+    end
+  end
+
+  def test_dup
+    [[2003,03,15], [1900,1,1], [-4712, 1, 1]].each do |year, month, day|
+      dt = OraDate.new(year, month, day)
+      assert_equal(dt, dt.dup)
+      assert_equal(dt, dt.clone)
+    end
+  end
+
+  def test_marshal
+    [[2003,03,15], [1900,1,1], [-4712, 1, 1]].each do |year, month, day|
+      dt = OraDate.new(year, month, day)
+      assert_equal(dt, Marshal.load(Marshal.dump(dt)))
+    end
+  end
+
+  def teardown
+    @stmt.free()
+    @svc.logoff()
+    @env.free()
+  end
+end
+
+if $0 == __FILE__
+  RUNIT::CUI::TestRunner.run(TestOraDate.suite())
+end

data/test/test_oranumber.rb

@@ -0,0 +1,149 @@
+# Low-level API
+require 'oci8'
+require 'runit/testcase'
+require 'runit/cui/testrunner'
+require File.dirname(__FILE__) + '/config'
+
+class TestOraNumber < RUNIT::TestCase
+
+  NUMBER_CHECK_TARGET = [
+    "12345678901234567890123456789012345678",
+    "1234567890123456789012345678901234567",
+    "1234567890123456789012345678901234567.8",
+    "12.345678901234567890123456789012345678",
+    "1.2345678901234567890123456789012345678",
+    "1.234567890123456789012345678901234567",
+    "0.0000000000000000000000000000000000001",
+    "0.000000000000000000000000000000000001",
+    "0",
+    "2147483647", # max of 32 bit signed value
+    "2147483648", # max of 32 bit signed value + 1
+    "-2147483648", # min of 32 bit signed value
+    "-2147483649", # min of 32 bit signed value - 1
+    "9223372036854775807",  # max of 64 bit signed value
+    "9223372036854775808",  # max of 64 bit signed value + 1
+    "-9223372036854775808",  # min of 64 bit signed value
+    "-9223372036854775809",  # min of 64 bit signed value - 1
+    "-12345678901234567890123456789012345678",
+    "-1234567890123456789012345678901234567",
+    "-123456789012345678901234567890123456",
+    "-1234567890123456789012345678901234567.8",
+    "-12.345678901234567890123456789012345678",
+    "-1.2345678901234567890123456789012345678",
+    "-0.0000000000000000000000000000000000001",
+    "-0.000000000000000000000000000000000001",
+    "-0.00000000000000000000000000000000001",
+    "1",
+    "20",
+    "300",
+    "-1",
+    "-20",
+    "-300",
+    "1.123",
+    "12.123",
+    "123.123",
+    "1.1",
+    "1.12",
+    "1.123",
+    "-1.123",
+    "-12.123",
+    "-123.123",
+    "-1.1",
+    "-1.12",
+    "-1.123",
+  ]
+
+  def setup
+    @env, @svc, @stmt = setup_lowapi()
+  end
+
+  def test_to_s
+    @stmt.prepare("BEGIN :number := TO_NUMBER(:str); END;")
+    number = @stmt.bindByName(":number", OraNumber)
+    str = @stmt.bindByName(":str", String, 40)
+    NUMBER_CHECK_TARGET.each do |val|
+      str.set(val)
+      @stmt.execute(@svc)
+      assert_equal(val, number.get.to_s)
+    end
+  end
+
+  def test_to_i
+    @stmt.prepare("BEGIN :number := TO_NUMBER(:str); END;")
+    number = @stmt.bindByName(":number", OraNumber)
+    str = @stmt.bindByName(":str", String, 40)
+    NUMBER_CHECK_TARGET.each do |val|
+      str.set(val)
+      @stmt.execute(@svc)
+      assert_equal(val.to_i, number.get.to_i)
+    end
+  end
+
+  def test_to_f
+    @stmt.prepare("BEGIN :number := TO_NUMBER(:str); END;")
+    number = @stmt.bindByName(":number", OraNumber)
+    str = @stmt.bindByName(":str", String, 40)
+    NUMBER_CHECK_TARGET.each do |val|
+      str.set(val)
+      @stmt.execute(@svc)
+      assert_equal(val.to_f, number.get.to_f)
+    end
+  end
+
+  def test_uminus
+    @stmt.prepare("BEGIN :number := - TO_NUMBER(:str); END;")
+    number = @stmt.bindByName(":number", OraNumber)
+    str = @stmt.bindByName(":str", String, 40)
+    NUMBER_CHECK_TARGET.each do |val|
+      str.set(val)
+      @stmt.execute(@svc)
+      assert_equal(val, (- (number.get)).to_s)
+    end
+  end
+
+  def test_dup
+    @stmt.prepare("BEGIN :number := TO_NUMBER(:str); END;")
+    number = @stmt.bindByName(":number", OraNumber)
+    str = @stmt.bindByName(":str", String, 40)
+    NUMBER_CHECK_TARGET.each do |val|
+      str.set(val)
+      @stmt.execute(@svc)
+      n = number.get
+      assert_equal(n.to_s, n.dup.to_s)
+      assert_equal(n.to_s, n.clone.to_s)
+    end
+  end
+
+  def test_marshal
+    @stmt.prepare("BEGIN :number := TO_NUMBER(:str); END;")
+    number = @stmt.bindByName(":number", OraNumber)
+    str = @stmt.bindByName(":str", String, 40)
+    NUMBER_CHECK_TARGET.each do |val|
+      str.set(val)
+      @stmt.execute(@svc)
+      n = number.get
+      assert_equal(n.to_s, Marshal.load(Marshal.dump(n)).to_s)
+    end
+  end
+
+  def test_new_from_string
+    @stmt.prepare("BEGIN :number := TO_NUMBER(:str); END;")
+    number = @stmt.bindByName(":number", OraNumber)
+    str = @stmt.bindByName(":str", String, 40)
+    (NUMBER_CHECK_TARGET + ["1.230", "1.2300", "1.23000"]).each do |val|
+      str.set(val)
+      @stmt.execute(@svc)
+      assert_equal(number.get.to_s, OraNumber.new(val).to_s)
+    end
+  end
+
+  def teardown
+    @stmt.free()
+    @svc.logoff()
+    @env.free()
+  end
+end
+
+if $0 == __FILE__
+  RUNIT::CUI::TestRunner.run(TestOraNumber.suite())
+end

data/test/test_rowid.rb

@@ -0,0 +1,38 @@
+require 'oci8'
+require 'runit/testcase'
+require 'runit/cui/testrunner'
+require File.dirname(__FILE__) + '/config'
+
+class TestRowid < RUNIT::TestCase
+
+  def setup
+    @conn = get_oci_connection()
+  end
+
+  def teardown
+    @conn.logoff
+  end
+
+  def test_rowid
+    drop_table('test_table')
+    sql = <<-EOS
+CREATE TABLE test_table (N NUMBER(38))
+EOS
+    @conn.exec(sql)
+    cursor = @conn.parse("INSERT INTO test_table values(1)");
+    cursor.exec
+    rid1 = cursor.rowid
+    assert_instance_of(String, rid1)
+    cursor.close
+    rid2 = nil
+    @conn.exec('select rowid from test_table where rowid = :1', rid1) do |row|
+      rid2 = row[0]
+    end
+    assert_equal(rid2, rid1)
+    drop_table('test_table')
+  end
+end # TestRowid
+
+if $0 == __FILE__
+  RUNIT::CUI::TestRunner.run(TestRowid.suite())
+end