ibruby 0.5.0-i586-linux

data/test/SQLTest.rb

@@ -0,0 +1,182 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class SQLTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}sql_unit_test.ib"
+   ITERATIONS  = 100
+   
+   INSERT_SQL  = "INSERT INTO TEST_TABLE VALUES(?, ?, ?, ?, ?, ?)"
+   
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      @connections  = []
+      @transactions = []
+      
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.execute_immediate('CREATE TABLE TEST_TABLE (TESTID INTEGER '\
+                               'NOT NULL PRIMARY KEY, TESTTEXT VARCHAR(100), '\
+                               'TESTFLOAT NUMERIC(8,2), TESTDATE DATE, TESTTIME '\
+                               'TIME, TESTSTAMP TIMESTAMP)')
+      end
+   end
+   
+   def teardown
+      @transactions.each do |tx|
+         tx.rollback if tx.active?
+      end
+      
+      @connections.each do |cxn|
+         cxn.close if cxn.open?
+      end
+      
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+   
+   def test01
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.start_transaction do |tx|
+            s = Statement.new(cxn, tx, INSERT_SQL, 3)
+            f = 0.0
+            t = Time.new
+            
+            1.upto(ITERATIONS) do |i|
+               f += 0.321
+               t = Time.at(t.to_i + 5)
+               s.execute_for([i, i.to_s, f, t, nil, t])
+            end
+
+            s.close
+         end
+      end
+      
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+      @connections[0].start_transaction do |tx|
+         r = tx.execute("SELECT COUNT(*) FROM TEST_TABLE")
+         assert(r.fetch[0] == ITERATIONS)
+         r.close
+      end
+   end
+   
+   def test02
+      f = 0.0
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         1.upto(20) do |i|
+            f += i
+            sql = "INSERT INTO TEST_TABLE VALUES (#{i}, "\
+                  "#{f.to_s}, #{f}, NULL, NULL, 'NOW')"
+            cxn.execute_immediate(sql)
+         end
+      end
+      
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+      @transactions.push(@connections[0].start_transaction)
+      r = @transactions[0].execute("SELECT COUNT(*) FROM TEST_TABLE")
+      assert(r.fetch[0] == 20)
+      r.close
+      
+      r = @transactions[0].execute("SELECT * FROM TEST_TABLE WHERE TESTID IN "\
+                                   "(2, 4, 6, 8, 10) ORDER BY TESTID ASCENDING")
+      a = r.fetch
+      assert(a[0] == 2)
+      assert(a[1] == '3.0')
+      assert(a[2] == 3.0)
+      assert(a[3] == nil)
+      assert(a[4] == nil)
+
+      a = r.fetch
+      assert(a[0] == 4)
+      assert(a[1] == '10.0')
+      assert(a[2] == 10.0)
+      assert(a[3] == nil)
+      assert(a[4] == nil)
+
+      a = r.fetch
+      assert(a[0] == 6)
+      assert(a[1] == '21.0')
+      assert(a[2] == 21.0)
+      assert(a[3] == nil)
+      assert(a[4] == nil)
+
+      a = r.fetch
+      assert(a[0] == 8)
+      assert(a[1] == '36.0')
+      assert(a[2] == 36.0)
+      assert(a[3] == nil)
+      assert(a[4] == nil)
+
+      a = r.fetch
+      assert(a[0] == 10)
+      assert(a[1] == '55.0')
+      assert(a[2] == 55.0)
+      assert(a[3] == nil)
+      assert(a[4] == nil)
+      
+      r.close
+      
+      @transactions[0].commit
+      
+      @connections[0].start_transaction do |tx|
+         s = Statement.new(@connections[0], tx,
+                           "UPDATE TEST_TABLE SET TESTSTAMP = NULL", 3)
+         s.execute()
+         s.close
+         
+         r = tx.execute("SELECT TESTSTAMP FROM TEST_TABLE")
+         total = 0
+         r.each do |row|
+            assert(row[0] == nil)
+            total = total + 1
+         end
+         assert(total == 20)
+         r.close
+      end
+      
+      a = []
+      t = nil
+      @connections[0].start_transaction do |tx|
+         # Perform an insert via a parameterized statement.
+         s = Statement.new(@connections[0], tx,
+                           "INSERT INTO TEST_TABLE (TESTID, TESTTEXT, "\
+                           "TESTFLOAT, TESTSTAMP) VALUES(?, ?, ?, ?)", 3)
+         t = Time.new
+         s.execute_for([25000, 'La la la', 3.14, t])
+         s.close
+         
+         # Fetch the record and check the data.
+         r = tx.execute("SELECT TESTTEXT, TESTFLOAT, TESTSTAMP FROM "\
+                        "TEST_TABLE WHERE TESTID = 25000")
+         a = r.fetch
+         r.close
+      end
+      assert(a[0] == 'La la la')
+      assert(a[1] == 3.14)
+      assert(a[2].to_i == t.to_i)
+      
+      @connections[0].execute_immediate("DELETE FROM TEST_TABLE WHERE TESTID "\
+                                        "IN (1, 3, 5, 7, 9, 12, 14, 16, 18, 20)")
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         a = []
+         cxn.start_transaction do |tx|
+            r = tx.execute("SELECT COUNT(*) FROM TEST_TABLE")
+            a = r.fetch
+            r.close
+         end
+         assert(a[0] == 11)
+      end
+   end
+end
+

data/test/SQLTypeTest.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class SQLTypeTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}sql_type_test.fdb"
+
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+
+      @database   = Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      @connection = @database.connect(DB_USER_NAME, DB_PASSWORD)
+
+      @connection.start_transaction do |tx|
+         tx.execute("create table all_types (col01 boolean, col02 blob, "\
+                    "col03 char(100), col04 date, col05 decimal(5,2), "\
+                    "col06 double precision, col07 float, col08 integer, "\
+                    "col09 numeric(10,3), col10 smallint, col11 time, "\
+                    "col12 timestamp, col13 varchar(23))")
+      end
+   end
+
+   def teardown
+      @connection.close if @connection != nil && @connection.open?
+
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+
+   def test01
+      types = []
+      types.push(SQLType.new(SQLType::BOOLEAN))
+      types.push(SQLType.new(SQLType::VARCHAR, 1000))
+      types.push(SQLType.new(SQLType::DECIMAL, nil, 10))
+      types.push(SQLType.new(SQLType::NUMERIC, nil, 5, 3))
+      types.push(SQLType.new(SQLType::BLOB, nil, nil, nil, 1))
+
+      assert(types[0] == types[0])
+      assert(!(types[0] == types[1]))
+      assert(types[1] == SQLType.new(SQLType::VARCHAR, 1000))
+
+      assert(types[0].type      == SQLType::BOOLEAN)
+      assert(types[0].length    == nil)
+      assert(types[0].precision == nil)
+      assert(types[0].scale     == nil)
+      assert(types[0].subtype   == nil)
+
+      assert(types[1].type      == SQLType::VARCHAR)
+      assert(types[1].length    == 1000)
+      assert(types[1].precision == nil)
+      assert(types[1].scale     == nil)
+      assert(types[1].subtype   == nil)
+
+      assert(types[2].type      == SQLType::DECIMAL)
+      assert(types[2].length    == nil)
+      assert(types[2].precision == 10)
+      assert(types[2].scale     == nil)
+      assert(types[2].subtype   == nil)
+
+      assert(types[3].type      == SQLType::NUMERIC)
+      assert(types[3].length    == nil)
+      assert(types[3].precision == 5)
+      assert(types[3].scale     == 3)
+      assert(types[3].subtype   == nil)
+
+      assert(types[4].type      == SQLType::BLOB)
+      assert(types[4].length    == nil)
+      assert(types[4].precision == nil)
+      assert(types[4].scale     == nil)
+      assert(types[4].subtype   == 1)
+   end
+
+   def test02
+      types = SQLType.for_table("all_types", @connection)
+
+      assert(types['COL01'] == SQLType.new(SQLType::BOOLEAN))
+      assert(types['COL02'] == SQLType.new(SQLType::BLOB, nil, nil, nil, 0))
+      assert(types['COL03'] == SQLType.new(SQLType::CHAR, 100))
+      assert(types['COL04'] == SQLType.new(SQLType::DATE))
+      assert(types['COL05'] == SQLType.new(SQLType::DECIMAL, nil, 5, 2))
+      assert(types['COL06'] == SQLType.new(SQLType::DOUBLE))
+      assert(types['COL07'] == SQLType.new(SQLType::FLOAT))
+      assert(types['COL08'] == SQLType.new(SQLType::INTEGER))
+      assert(types['COL09'] == SQLType.new(SQLType::NUMERIC, nil, 10, 3))
+      assert(types['COL10'] == SQLType.new(SQLType::SMALLINT))
+      assert(types['COL11'] == SQLType.new(SQLType::TIME))
+      assert(types['COL12'] == SQLType.new(SQLType::TIMESTAMP))
+      assert(types['COL13'] == SQLType.new(SQLType::VARCHAR, 23))
+   end
+end

data/test/ServiceManagerTest.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class ServiceManagerTest < Test::Unit::TestCase
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+   end
+   
+   def teardown
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+   
+   def test01
+      sm = ServiceManager.new('localhost')
+      assert(sm.connected? == false)
+
+      assert(sm.connect(DB_USER_NAME, DB_PASSWORD) == sm)
+      assert(sm.connected?)
+
+      assert(sm.disconnect == sm)
+      assert(sm.connected? == false)
+   end
+end

data/test/StatementTest.rb

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class StatementTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}stmt_unit_test.fdb"
+   
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      @database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      @connections  = []
+      @transactions = []
+   end
+   
+   def teardown
+      @transactions.each do |tx|
+         tx.rollback if tx.active?
+      end
+      @transactions.clear
+      @connections.each do |cxn|
+         cxn.close if cxn.open?
+      end
+      @connections.clear
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+   
+   def test01
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+      @transactions.push(@connections.last.start_transaction)
+      
+      s1 = Statement.new(@connections[0],
+                         @transactions[0],
+                         "SELECT RDB$FIELD_NAME FROM RDB$FIELDS", 3)
+      assert(s1 != nil)
+      assert(s1.sql == "SELECT RDB$FIELD_NAME FROM RDB$FIELDS")
+      assert(s1.connection == @connections[0])
+      assert(s1.transaction == @transactions[0])
+      assert(s1.dialect == 3)
+      assert(s1.type == Statement::SELECT_STATEMENT)
+      s1.close
+      
+      s2 = Statement.new(@connections[0],
+                         @transactions[0],
+                         "DELETE FROM RDB$EXCEPTIONS", 1)
+      assert(s2 != nil)
+      assert(s2.sql == "DELETE FROM RDB$EXCEPTIONS")
+      assert(s2.connection == @connections[0])
+      assert(s2.transaction == @transactions[0])
+      assert(s2.dialect == 1)
+      assert(s2.type == Statement::DELETE_STATEMENT)
+      s2.close
+   end
+   
+   def test02
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+      @transactions.push(@connections[0].start_transaction)
+      
+      s = Statement.new(@connections[0], @transactions[0],
+                        "SELECT RDB$FIELD_NAME FROM RDB$FIELDS "\
+                        "WHERE RDB$FIELD_NAME LIKE ?", 3)
+
+      begin
+         r = s.execute
+         r.close
+         assert(false,
+                "Executed statement that required parameter without the "\
+                "parameter being specified.")
+      rescue Exception => error
+      end
+      
+      begin
+         r = s.execute_for([])
+         r.close
+         assert(false,
+                "Executed statement that required a parameter with an empty "\
+                "parameter set.")
+      rescue Exception => error
+      end
+      
+      begin
+         r = s.execute_for(['LALALA', 25])
+         r.close
+         assert(false,
+                "Executed statement that required a parameter with too many "\
+                "parameters.")
+      rescue Exception => error
+      end
+      
+      r = s.execute_for(['LALALA'])
+      assert(r != nil)
+      assert(r.class == ResultSet)
+      r.close
+      
+      total = 0
+      s.execute_for(["%"]) do |row|
+         total = total + 1
+      end
+      assert(total = 88)
+      s.close
+   end
+   
+   def test03
+      d = nil
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.execute_immediate('CREATE TABLE STRING_TEST(TEXT VARCHAR(10))')
+         cxn.start_transaction do |tx|
+            # Perform an truncated insert.
+            s = Statement.new(cxn, tx, 'INSERT INTO STRING_TEST VALUES(?)', 3)
+            s.execute_for(['012345678901234'])
+            
+            # Perform a select of the value inserted.
+            r = cxn.execute('SELECT * FROM STRING_TEST', tx)
+            d = r.fetch
+            
+            # Clean up.
+            s.close
+            r.close
+         end
+         assert(d[0] == '0123456789')
+         cxn.execute_immediate('DROP TABLE STRING_TEST')
+      end
+   end
+end

data/test/TestSetup.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+# Add extra search paths.
+basedir = File::dirname(Dir.getwd)
+$:.push(basedir)
+$:.push("#{basedir}#{File::SEPARATOR}test")
+$:.push("#{basedir}#{File::SEPARATOR}lib")
+
+DB_USER_NAME = 'sysdba'
+DB_PASSWORD  = 'masterkey'
+TEST_LOGGING = true

data/test/TransactionTest.rb

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class TransactionTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}tx_unit_test.ib"
+   
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      
+      @database     = Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      @connections  = []
+      @transactions = []
+
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+   end
+   
+   def teardown
+      @transactions.each do |tx|
+         tx.rollback if tx.active?
+      end
+      @transactions.clear
+      @connections.each do |cxn|
+         cxn.close if cxn.open?
+      end
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+   
+   def test01
+      @transactions.push(@connections[0].start_transaction)
+      assert(@transactions[0].active?)
+      
+      @transactions.push(Transaction.new(@connections[1]))
+      assert(@transactions[1].active?)
+      
+      assert(@transactions[0].connections == [@connections[0]])
+      assert(@transactions[1].connections == [@connections[1]])
+      
+      assert(@transactions[0].for_connection?(@connections[1]) == false)
+      assert(@transactions[1].for_connection?(@connections[0]) == false)
+      assert(@transactions[0].for_connection?(@connections[0]))
+      assert(@transactions[1].for_connection?(@connections[1]))
+      
+      @transactions[0].commit
+      assert(@transactions[0].active? == false)
+      assert(@transactions[0].connections == [])
+      assert(@transactions[0].for_connection?(@connections[0]) == false)
+      assert(@transactions[0].for_connection?(@connections[1]) == false)
+      
+      @transactions[1].rollback
+      assert(@transactions[1].active? == false)
+      assert(@transactions[1].connections == [])
+      assert(@transactions[1].for_connection?(@connections[0]) == false)
+      assert(@transactions[1].for_connection?(@connections[1]) == false)
+      
+      @transactions[0] = Transaction.new([@connections[0], @connections[1]])
+      assert(@transactions[0].active? == true)
+      assert(@transactions[0].for_connection?(@connections[0]))
+      assert(@transactions[0].for_connection?(@connections[1]))
+      assert(@transactions[0].for_connection?(@connections[2]) == false)
+      
+      @transactions[0].commit
+      assert(@transactions[0].active? == false)
+      assert(@transactions[0].connections == [])
+      assert(@transactions[0].for_connection?(@connections[0]) == false)
+      assert(@transactions[0].for_connection?(@connections[1]) == false)
+      assert(@transactions[0].for_connection?(@connections[2]) == false)
+      
+      @transactions[0] = Transaction.new([@connections[0], @connections[2]])
+      assert(@transactions[0].active?)
+      @transactions[0].rollback
+      assert(@transactions[0].active? == false)
+      assert(@transactions[0].connections == [])
+      assert(@transactions[0].for_connection?(@connections[0]) == false)
+      assert(@transactions[0].for_connection?(@connections[1]) == false)
+      assert(@transactions[0].for_connection?(@connections[2]) == false)
+   end
+   
+   def test02
+      sql = []
+      sql.push("UPDATE RDB$EXCEPTIONS SET RDB$MESSAGE = 'WoooHooo'"\
+               "WHERE RDB$EXCEPTION_NAME = 'Lalala'")
+      sql.push("SELECT RDB$FIELD_NAME FROM RDB$FIELDS")
+      @transactions.push(Transaction.new(@connections[0]))
+      
+      assert(@transactions[0].execute(sql[0]) == 0)
+      r = @transactions[0].execute(sql[1])
+      assert(r != nil)
+      assert(r.class == ResultSet)
+      r.close
+      
+      total = 0
+      @transactions[0].execute(sql[1]) do |row|
+         total += 1
+      end
+      assert(total == 113)
+   end
+end

data/test/TypeTest.rb

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+require 'date'
+
+include IBRuby
+
+class TypeTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}types_unit_test.ib"
+   
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      if File.exist?(DB_FILE)
+         db = Database.new(DB_FILE)
+         db.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      @db  = Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      cxn = @db.connect(DB_USER_NAME, DB_PASSWORD)
+      cxn.start_transaction do |tx|
+         tx.execute("create table types_table (COL01 integer, "\
+                    "COL02 float, COL03 decimal(10,2), "\
+                    "COL04 numeric(5,3), COL05 date, COL06 timestamp, "\
+                    "COL07 char(10), COL08 time, COL09 varchar(30))")
+      end
+         
+      cxn.start_transaction do |tx|
+         stmt = Statement.new(cxn, tx, "insert into types_table values "\
+                                       "(?, ?, ?, ?, ?, ?, ?, ?, ?)", 3)
+         stmt.execute_for([10, 100.2, 2378.65, 192.345,
+                           Date.new(2005, 10, 21), Time.new, 'La la la',
+                           Time.new, "Oobly Joobly"])
+         stmt.close
+      end
+      cxn.close
+   end
+   
+   def teardown
+      if File::exist?(DB_FILE)
+         @db.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+
+   def test01
+      rows = cxn = nil
+      begin
+         cxn = @db.connect(DB_USER_NAME, DB_PASSWORD)
+         rows = cxn.execute_immediate('select * from types_table')
+         row  = rows.fetch
+         assert(row[0].kind_of?(Integer))
+         assert(row[1].instance_of?(Float))
+         assert(row[2].instance_of?(Float))
+         assert(row[3].instance_of?(Float))
+         assert(row[4].instance_of?(Date))
+         assert(row[5].instance_of?(Time))
+         assert(row[6].instance_of?(String))
+         assert(row[7].instance_of?(Time))
+         assert(row[8].instance_of?(String))
+      ensure
+         rows.close if rows != nil
+         cxn.close if cxn != nil
+      end
+   end
+
+   def test02
+      $IBRubySettings[:DATE_AS_DATE] = false
+      rows = cxn = nil
+      begin
+         cxn = @db.connect(DB_USER_NAME, DB_PASSWORD)
+         rows = cxn.execute_immediate('select * from types_table')
+         row  = rows.fetch
+         assert(row[0].kind_of?(Integer))
+         assert(row[1].instance_of?(Float))
+         assert(row[2].instance_of?(Float))
+         assert(row[3].instance_of?(Float))
+         assert(row[4].instance_of?(Time))
+         assert(row[5].instance_of?(Time))
+         assert(row[6].instance_of?(String))
+         assert(row[7].instance_of?(Time))
+         assert(row[8].instance_of?(String))
+         rows.close
+      ensure
+         rows.close if rows != nil
+         cxn.close if cxn != nil
+      end
+      $IBRubySettings[:DATE_AS_DATE] = true
+   end
+end