ruby-oci8 2.2.10-x64-mingw-ucrt

data/test/test_bind_time.rb

@@ -0,0 +1,177 @@
+require 'oci8'
+require File.dirname(__FILE__) + '/config'
+
+class TestBindTime < Minitest::Test
+
+  YEAR_CHECK_TARGET = [1971, 1989, 2002, 2037]
+  MON_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]
+  MIN_CHECK_TARGET = [0, 15, 30, 45, 59]
+  SEC_CHECK_TARGET = [0, 15, 30, 45, 59]
+
+  def setup
+    @conn = get_oci8_connection
+  end
+
+  def test_set_year
+    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
+      cursor[:time] = Time.local(i, 1)
+      # check result
+      cursor.exec
+      assert_equal(i, cursor[:year])
+    end
+  end
+
+  def test_get_year
+    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.
+      cursor[:year] = i
+      cursor.exec
+      # check Time#year
+      assert_equal(i, cursor[:time].year)
+    end
+  end
+
+  def test_set_mon
+    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
+      cursor[:time] = Time.local(2001, i)
+      # check result via oracle.
+      cursor.exec
+      assert_equal(i, cursor[:mon])
+    end
+  end
+
+  def test_get_mon
+    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.
+      cursor[:mon] = i;
+      cursor.exec
+      # check Time#mon
+      assert_equal(i, cursor[:time].mon)
+    end
+  end
+
+  def test_set_day
+    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
+      cursor[:time] = Time.local(2001, 1, i)
+      # check result via oracle.
+      cursor.exec
+      assert_equal(i, cursor[:day])
+    end
+  end
+
+  def test_get_day
+    cursor = @conn.parse("BEGIN :time := TO_DATE('200101' || TO_CHAR(:day, 'FM00'), 'YYYYMMDD'); END;")
+    cursor.bind_param(:day, Fixnum)
+    cursor.bind_param(:time, Time)
+    DAY_CHECK_TARGET.each do |i|
+      # set time via oracle.
+      cursor[:day] = i;
+      cursor.exec
+      # check Time#day
+      assert_equal(i, cursor[:time].day)
+    end
+  end
+
+  def test_set_hour
+    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
+      cursor[:time] = Time.local(2001, 1, 1, i)
+      # check result via oracle.
+      cursor.exec
+      assert_equal(i, cursor[:hour])
+    end
+  end
+
+  def test_get_hour
+    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.
+      cursor[:hour] = i
+      cursor.exec
+      # check Time#hour
+      assert_equal(i, cursor[:time].hour)
+    end
+  end
+
+  def test_set_min
+    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
+      cursor[:time] = Time.local(2001, 1, 1, 0, i)
+      # check result via oracle.
+      cursor.exec
+      assert_equal(i, cursor[:min])
+    end
+  end
+
+  def test_get_min
+    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.
+      cursor[:min] = i;
+      cursor.exec
+      # check Time#min
+      assert_equal(i, cursor[:time].min)
+    end
+  end
+
+  def test_set_sec
+    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
+      cursor[:time] = Time.local(2001, 1, 1, 0, 0, i)
+      # check result via oracle.
+      cursor.exec
+      assert_equal(i, cursor[:sec])
+    end
+  end
+
+  def test_get_sec
+    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.
+      cursor[:sec] = i
+      cursor.exec
+      # check Time#sec
+      assert_equal(i, cursor[:time].sec)
+    end
+  end
+
+  def teardown
+    @conn.logoff
+  end
+end

data/test/test_break.rb

@@ -0,0 +1,125 @@
+# High-level API
+require 'oci8'
+require 'timeout'
+require File.dirname(__FILE__) + '/config'
+
+class TestBreak < Minitest::Test
+
+  def setup
+    @conn = get_oci8_connection
+    Thread.report_on_exception, @original_report_on_exception = false, Thread.report_on_exception if Thread.respond_to?(:report_on_exception)
+  end
+
+  def teardown
+    @conn.logoff
+    Thread.report_on_exception = @original_report_on_exception if Thread.respond_to?(:report_on_exception)
+  end
+
+  def report(str)
+    printf "%d: %s\n", (Time.now - $start_time), str
+  end
+
+  @@server_is_runing_on_windows = nil
+  def server_is_runing_on_windows?
+    if @@server_is_runing_on_windows.nil?
+      @conn.exec('select dbms_utility.port_string from dual') do |row|
+        @@server_is_runing_on_windows = row[0].include? '/WIN'
+      end
+    end
+    @@server_is_runing_on_windows
+  end
+
+  PLSQL_DONE = 1
+  OCIBREAK = 2
+  SEND_BREAK = 3
+
+  TIME_IN_PLSQL = 5
+  TIME_TO_BREAK = 2
+
+  def do_test_ocibreak(conn, expect)
+    $start_time = Time.now
+
+    th = Thread.start do 
+      begin
+        conn.exec("BEGIN DBMS_LOCK.SLEEP(#{TIME_IN_PLSQL}); END;")
+        assert_equal(expect[PLSQL_DONE], (Time.now - $start_time).round, 'PLSQL_DONE')
+      rescue OCIBreak
+        assert_equal(expect[OCIBREAK], (Time.now - $start_time).round, 'OCIBREAK')
+        assert_equal('Canceled by user request.', $!.to_s)
+      end
+    end
+
+    sleep(0.3) # Wait until DBMS_LOCK.SLEEP is running.
+    sleep(TIME_TO_BREAK - 0.3)
+    assert_equal(expect[SEND_BREAK], (Time.now - $start_time).round, 'SEND_BREAK')
+    conn.break()
+    th.join
+  end
+
+  def test_blocking_mode
+    @conn.non_blocking = false
+    assert_equal(false, @conn.non_blocking?)
+    expect = []
+    expect[PLSQL_DONE] = TIME_IN_PLSQL
+    expect[OCIBREAK]   = "Invalid status"
+    if (defined? Rubinius and Rubinius::VERSION >= "2.0") || (defined? RUBY_ENGINE and RUBY_ENGINE == "truffleruby")
+      # Rubinius 2.0.0.
+      # DBMS_LOCK.SLEEP blocks ruby threads which try to call C-API.
+      expect[SEND_BREAK] = TIME_TO_BREAK
+    else
+      # MRI and Rubinius 1.2.4.
+      # DBMS_LOCK.SLEEP blocks all ruby threads.
+      expect[SEND_BREAK] = TIME_IN_PLSQL + TIME_TO_BREAK
+    end
+    do_test_ocibreak(@conn, expect)
+  end
+
+  def test_non_blocking_mode
+    @conn.non_blocking = true
+    assert_equal(true, @conn.non_blocking?)
+    expect = []
+    if server_is_runing_on_windows?
+      if $oracle_server_version >= OCI8::ORAVER_9_0
+        # raise after sleeping #{TIME_IN_PLSQL} seconds.
+        expect[PLSQL_DONE] = "Invalid status"
+        expect[OCIBREAK] = TIME_IN_PLSQL
+      else
+        expect[PLSQL_DONE] = TIME_IN_PLSQL
+        expect[OCIBREAK] = "Invalid status"
+      end
+    else
+      # raise immediately by OCI8#break.
+      expect[PLSQL_DONE] = "Invalid status"
+      expect[OCIBREAK] = TIME_TO_BREAK
+    end
+    expect[SEND_BREAK]   = TIME_TO_BREAK
+    do_test_ocibreak(@conn, expect)
+  end
+
+  def test_timeout
+    @conn.non_blocking = true
+    start_time = Time.now
+    if server_is_runing_on_windows?
+      end_time = start_time + 5
+    else
+      end_time = start_time + 1
+    end
+
+    if defined? Rubinius and Rubinius::VERSION < "2.0"
+      # Rubinius 1.2.4
+      expected = OCIBreak
+    else
+      # MRI and Rubinius 2.0.0
+      expected = Timeout::Error
+    end
+    assert_raises(expected) do
+      Timeout.timeout(1) do
+        @conn.exec("BEGIN DBMS_LOCK.SLEEP(5); END;")
+      end
+    end
+    assert_in_delta(Time.now, end_time, 1)
+    sleep(0.01) # for truffleruby. Is truffleruby too fast?
+    @conn.exec("BEGIN NULL; END;")
+    assert_in_delta(Time.now, end_time, 1)
+  end
+end

data/test/test_clob.rb

@@ -0,0 +1,85 @@
+# Low-level API
+require 'oci8'
+require File.dirname(__FILE__) + '/config'
+
+class TestCLob < Minitest::Test
+
+  def setup
+    @conn = get_oci8_connection
+    drop_table('test_table')
+    @conn.exec('CREATE TABLE test_table (filename VARCHAR2(40), content CLOB)')
+  end
+
+  def test_insert
+    filename = File.basename($lobfile)
+    @conn.exec("DELETE FROM test_table WHERE filename = :1", filename)
+    @conn.exec("INSERT INTO test_table(filename, content) VALUES (:1, EMPTY_CLOB())", filename)
+    cursor = @conn.exec("SELECT content FROM test_table WHERE filename = :1 FOR UPDATE", filename)
+    lob = cursor.fetch[0]
+    open($lobfile) do |f|
+      while s = f.read(1000)
+        lob.write(s)
+      end
+    end
+    lob.close
+  end
+
+  def test_insert_symbol
+    filename = 'test_symbol'
+    value = :foo_bar
+    @conn.exec("DELETE FROM test_table WHERE filename = :1", filename)
+    @conn.exec("INSERT INTO test_table(filename, content) VALUES (:1, EMPTY_CLOB())", filename)
+    cursor = @conn.exec("SELECT content FROM test_table 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)
+    cursor = @conn.exec("SELECT content FROM test_table WHERE filename = :1 FOR UPDATE", filename)
+    lob = cursor.fetch[0]
+
+    open($lobfile) do |f|
+      while buf = lob.read($lobreadnum)
+        fbuf = f.read(buf.size)
+        assert_equal(fbuf, buf)
+        # offset += buf.size will not work fine,
+        # Though buf.size counts in byte,
+        # offset and $lobreadnum count in character.
+      end
+      assert_nil(buf)
+      assert(f.eof?)
+      assert(lob.eof?)
+    end
+    lob.close
+  end
+
+  # https://github.com/kubo/ruby-oci8/issues/20
+  def test_github_issue_20
+    # Skip this test if FULLTEST isn't set because it takes 4 minutes in my Linux box.
+    return if ENV['FULLTEST']
+
+    lob1 = OCI8::CLOB.new(@conn, ' '  * (1024 * 1024))
+    lob1.read(1) # to suppress `warning: assigned but unused variable - lob1`
+    begin
+      lob2 = OCI8::CLOB.new(@conn, ' '  * (128 * 1024 * 1024))
+    rescue OCIError
+      raise if $!.code != 24817
+      # ORA-24817: Unable to allocate the given chunk for current lob operation
+      GC.start
+      # allocate smaller size
+      lob2 = OCI8::CLOB.new(@conn, ' '  * (16 * 1024 * 1024))
+    end
+    lob1 = nil  # lob1's value will be freed in GC.
+    lob2.read   # GC must run here to reproduce the issue.
+  end
+
+  def teardown
+    drop_table('test_table')
+    @conn.logoff
+  end
+end

data/test/test_connection_pool.rb

@@ -0,0 +1,124 @@
+require 'oci8'
+require File.dirname(__FILE__) + '/config'
+
+class TestConnectionPool < Minitest::Test
+
+  def create_pool(min, max, incr)
+    OCI8::ConnectionPool.new(min, max, incr, $dbuser, $dbpass, $dbname)
+  rescue OCIError
+    raise if $!.code != 12516 && $!.code != 12520
+    sleep(5)
+    OCI8::ConnectionPool.new(min, max, incr, $dbuser, $dbpass, $dbname)
+  end
+
+  def test_connect
+    pool = create_pool(1, 5, 3)
+    assert_equal(1, pool.min)
+    assert_equal(5, pool.max)
+    assert_equal(3, pool.incr)
+  end
+
+  def test_reinitialize
+    pool = create_pool(1, 5, 3)
+    pool.reinitialize(2, 6, 4)
+    assert_equal(2, pool.min)
+    assert_equal(6, pool.max)
+    assert_equal(4, pool.incr)
+  end
+
+  def test_busy_and_open_count
+    check_busy_and_open_count(1, 5, 3)
+    check_busy_and_open_count(2, 4, 1)
+  end
+
+  def check_busy_and_open_count(min_cnt, max_cnt, incr_cnt)
+    msg = "create_pool(#{min_cnt}, #{max_cnt}, #{incr_cnt})"
+    # Create a connection pool.
+    pool = create_pool(min_cnt, max_cnt, incr_cnt)
+    assert_equal(min_cnt, pool.open_count, msg)
+    assert_equal(0, pool.busy_count, msg)
+
+    non_blocking = true
+
+    # Create connections from the pool.
+    conns = []
+    max_cnt.times do |cnt|
+      conn = OCI8.new($dbuser, $dbpass, pool)
+      if cnt == 0
+        unless conn.non_blocking?
+          non_blocking = false
+          assert_raises(RuntimeError) do
+            # This should raise "Could not set non-blocking mode to a connection allocated from OCI8::ConnectionPool."
+            conn.non_blocking = true
+          end
+        end
+      end
+      conns << conn
+    end
+    assert_equal(min_cnt, pool.open_count, msg)
+    assert_equal(0, pool.busy_count, msg)
+
+    # Execute blocking SQL statements sequentially.
+    max_cnt.times do |n|
+      thread = Thread.start do
+        conns[n].exec "BEGIN DBMS_LOCK.SLEEP(1); END;"
+      end
+      sleep(0.5)
+      assert_equal(min_cnt, pool.open_count, msg)
+      assert_equal(non_blocking ? 1 : 0, pool.busy_count, msg)
+      thread.join
+    end
+    assert_equal(min_cnt, pool.open_count, msg)
+    assert_equal(0, pool.busy_count, msg)
+
+    # Execute blocking SQL statements parallel to increment open_count.
+    threads = []
+    (min_cnt + 1).times do |n|
+      threads << Thread.start do
+        conns[n].exec "BEGIN DBMS_LOCK.SLEEP(5); END;"
+      end
+    end
+    sleep(0.5)
+    assert_equal(non_blocking ? (min_cnt + incr_cnt) : min_cnt, pool.open_count, msg)
+    assert_equal(non_blocking ? (min_cnt + 1) : 0, pool.busy_count, msg)
+
+    # Execute blocking SQL statements parallel up to maximum.
+    (min_cnt + 1).upto(max_cnt - 1) do |n|
+      threads << Thread.start do
+        conns[n].exec "BEGIN DBMS_LOCK.SLEEP(4); END;"
+      end
+    end
+    sleep(0.5)
+    assert_equal(non_blocking ? max_cnt : min_cnt, pool.open_count, msg)
+    assert_equal(non_blocking ? max_cnt : 0, pool.busy_count, msg)
+
+    # 
+    threads.each do |thr|
+      thr.join
+    end
+    assert_equal(non_blocking ? max_cnt : min_cnt, pool.open_count, msg)
+    assert_equal(0, pool.busy_count, msg)
+
+    # Set timeout
+    pool.timeout = 1
+    sleep(1.5)
+    assert_equal(non_blocking ? max_cnt : min_cnt, pool.open_count, msg) # open_count doesn't shrink.
+    assert_equal(0, pool.busy_count, msg)
+    conns[0].ping # make a network roundtrip.
+    sleep(0.5)
+    # open_count shrinks.
+    # The decrement count depends on Oracle version.
+    assert_operator(pool.open_count, :<, max_cnt, msg)
+    assert_equal(0, pool.busy_count, msg)
+
+    # Close all conections.
+    conns.each do | conn |
+      conn.logoff
+    end
+    assert_equal(min_cnt, pool.open_count, msg)
+    assert_equal(0, pool.busy_count, msg)
+  end
+
+  def test_nowait
+  end
+end