ibruby 0.5.0-i586-linux

data/test/KeyTest.rb

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class KeyTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}key_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
+      
+      # Switch to the old way of keying.
+      $IBRubySettings[:ALIAS_KEYS] = false
+      
+      database     = Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      @connection  = database.connect(DB_USER_NAME, DB_PASSWORD)
+      @transaction = @connection.start_transaction
+      @results     = ResultSet.new(@connection, @transaction,
+                                   'SELECT * FROM RDB$FIELDS', 3, nil)
+      @empty       = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                      0, 0, 0, 0, 0, 0, 0, 0, 0]
+      
+      @connection.execute_immediate('create table keytest (COL01 integer, '\
+                                    'COL02 varchar(10), COL03 integer)')
+      @connection.execute_immediate("insert into keytest values (1, 'Two', 3)")
+   end
+   
+   def teardown
+      @results.close
+      @transaction.rollback
+      @connection.close
+      if File::exist?(DB_FILE)
+         Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      $IBRubySettings[:ALIAS_KEYS] = true
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+   
+   def test_01
+      sql  = 'select COL01 one, COL02 two, COL03 three from keytest'
+      rows = @connection.execute_immediate(sql)
+      data = rows.fetch
+      
+      count = 0
+      data.each do |name, value|
+         assert(['COL01', 'COL02', 'COL03'].include?(name))
+         assert([1, 'Two', 3].include?(value))
+         count += 1
+      end
+      assert(count == 3)
+      
+      count = 0
+      data.each_key do |name|
+         assert(['COL01', 'COL02', 'COL03'].include?(name))
+         count += 1
+      end
+      assert(count == 3)
+      
+      count = 0
+      data.each_value do |value|
+         assert([1, 'Two', 3].include?(value))
+         count += 1
+      end
+      assert(count == 3)
+      
+      assert(data.fetch('COL02') == 'Two')
+      assert(data.fetch('COL04', 'LALALA') == 'LALALA')
+      assert(data.fetch('COL00') {'NOT FOUND'} == 'NOT FOUND')
+      begin
+         data.fetch('COL05')
+         assert(false, 'Row#fetch succeeded for non-existent column name.')
+      rescue IndexError
+      end
+      
+      assert(data.has_key?('COL01'))
+      assert(data.has_key?('COL10') == false)
+      
+      assert(data.has_column?('COL02'))
+      assert(data.has_column?('COL22') == false)
+      
+      assert(data.has_alias?('TWO'))
+      assert(data.has_alias?('FOUR') == false)
+      
+      assert(data.has_value?(3))
+      assert(data.has_value?('LALALA') == false)
+      
+      assert(data.keys.size == 3)
+      data.keys.each do |name|
+         assert(['COL01', 'COL02', 'COL03'].include?(name))
+      end
+      
+      assert(data.names.size == 3)
+      data.names.each do |name|
+         assert(['COL01', 'COL02', 'COL03'].include?(name))
+      end
+
+      assert(data.aliases.size == 3)
+      data.aliases.each do |name|
+         assert(['ONE', 'TWO', 'THREE'].include?(name))
+      end
+      
+      assert(data.values.size == 3)
+      data.values.each do |value|
+         assert([1, 'Two', 3].include?(value))
+      end
+      
+      array = data.select {|name, value| name == 'COL02'}
+      assert(array.size == 1)
+      assert(array[0][0] == 'COL02')
+      assert(array[0][1] == 'Two')
+      
+      array = data.to_a
+      assert(array.size == 3)
+      assert(array.include?(['COL01', 1]))
+      assert(array.include?(['COL02', 'Two']))
+      assert(array.include?(['COL03', 3]))
+      
+      hash = data.to_hash
+      assert(hash.length == 3)
+      assert(hash['COL01'] == 1)
+      assert(hash['COL02'] == 'Two')
+      assert(hash['COL03'] == 3)
+      
+      array = data.values_at('COL10', 'COL02', 'COL03')
+      assert(array.size == 3)
+      assert(array.include?('Two'))
+      assert(array.include?(3))
+      assert(array.include?(nil))
+      
+      rows.close
+   end
+end

data/test/ResultSetTest.rb

@@ -0,0 +1,164 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class ResultSetTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}result_set_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[0].start_transaction do |tx|
+         tx.execute("CREATE TABLE TEST_TABLE (TESTID INTEGER NOT NULL "\
+                    "primary KEY, TESTINFO VARCHAR(100))")
+         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
+      
+      @connections[0].start_transaction do |tx|
+         begin
+            tx.execute("INSERT INTO TEST_TABLE VALUES (10, 'Record One.')")
+            tx.execute("INSERT INTO TEST_TABLE VALUES (20, 'Record Two.')")
+            tx.execute("INSERT INTO TEST_TABLE VALUES (30, 'Record Three.')")
+            tx.execute("INSERT INTO TEST_TABLE VALUES (40, 'Record Four.')")
+            tx.execute("INSERT INTO TEST_TABLE VALUES (50, 'Record Five.')")
+         rescue Exception => error
+            puts error.message
+            error.backtrace.each {|step| puts "   #{step}"}
+            raise
+         end
+      end
+      
+      @transactions.push(@connections[0].start_transaction)
+   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
+      r = ResultSet.new(@connections[0], @transactions[0],
+                        "SELECT * FROM TEST_TABLE ORDER BY TESTID", 3, nil)
+      
+      assert(r.connection == @connections[0])
+      assert(r.transaction == @transactions[0])
+      assert(r.sql == "SELECT * FROM TEST_TABLE ORDER BY TESTID")
+      assert(r.dialect == 3)
+      
+      assert(r.fetch != nil)
+      assert(r.fetch.class == Row)
+      assert(r.fetch[0] == 30)
+      assert(r.fetch[1] == 'Record Four.')
+      r.fetch
+      assert(r.fetch == nil)
+      r.close
+      
+      r = ResultSet.new(@connections[0], @transactions[0],
+                        "SELECT * FROM TEST_TABLE ORDER BY TESTID", 3, nil)
+      assert(r.column_count == 2)
+      assert(r.column_name(0) == 'TESTID')
+      assert(r.column_name(1) == 'TESTINFO')
+      assert(r.column_name(3) == nil)
+      assert(r.column_name(-1) == nil)
+      assert(r.column_table(0) == 'TEST_TABLE')
+      assert(r.column_table(1) == 'TEST_TABLE')
+      assert(r.column_table(2) == nil)
+      assert(r.column_table(-1) == nil)
+      assert(r.column_alias(0) == 'TESTID')
+      assert(r.column_alias(1) == 'TESTINFO')
+      assert(r.column_alias(3) == nil)
+      assert(r.column_alias(-1) == nil)
+      r.close
+      
+      r = ResultSet.new(@connections[0], @transactions[0],
+                        "SELECT * FROM TEST_TABLE ORDER BY TESTID", 3, nil)
+      total = 0
+      r.each do |row|
+         total += 1
+      end
+      assert(total == 5)
+      assert(r.exhausted?)
+   end
+
+   def test02
+      r = ResultSet.new(@connections[0], @transactions[0],
+                        'select * from test_table where testid between ? and ?',
+                        3, [20, 40])
+      assert(r.exhausted? == false)
+      total = 0
+      r.each {|row| total += 1}
+      assert(total == 3)
+      assert(r.exhausted?)
+   end
+
+   def test03
+      begin
+         ResultSet.new(@connections[0], @transactions[0],
+                       "insert into test_table values(?, ?)", 3,
+                       [100, 'Should fail.'])
+         assert(false, "Created result set with non-query SQL statement.")
+      rescue IBRubyException
+      end
+
+      begin
+         ResultSet.new(@connections[0], @transactions[0],
+                       "select * from test_table where testid = ?", 3,
+                       [])
+         assert(false, 'Created result set with insufficient parameters.')
+      rescue IBRubyException
+      end
+   end
+   
+   def test04
+      results = nil
+      begin
+         results = @transactions[0].execute('select * from all_types')
+        
+         #assert(results.get_base_type(0) == SQLType::BIGINT)
+         puts "blob=#{results.get_base_type(0)}"
+         puts "blob=#{results.get_base_type(2)}"
+         assert(results.get_base_type(1) == SQLType::BLOB)
+         assert(results.get_base_type(2) == SQLType::CHAR)
+         assert(results.get_base_type(3) == SQLType::DATE)
+         assert(results.get_base_type(4) == SQLType::DECIMAL)
+         assert(results.get_base_type(5) == SQLType::DOUBLE)
+         assert(results.get_base_type(6) == SQLType::FLOAT)
+         assert(results.get_base_type(7) == SQLType::INTEGER)
+         assert(results.get_base_type(8) == SQLType::NUMERIC)
+         assert(results.get_base_type(9) == SQLType::SMALLINT)
+         assert(results.get_base_type(10) == SQLType::TIME)
+         assert(results.get_base_type(11) == SQLType::TIMESTAMP)
+         assert(results.get_base_type(12) == SQLType::VARCHAR)
+      ensure
+         results.close if results != nil
+      end
+   end
+end

data/test/RoleTest.rb

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+# This test case isn't working as I cannot get the basic operation of roles to work under ISQL so I am unsure
+# how they are supposed to work.
+
+class DatabaseTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}role_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
+
+#connect "role_unit_test.ib" user "newuser" password "password" role sales;
+#insert into sales_test values(1);
+      Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      createUser
+      createRoleAndAllocate
+    end
+    
+    def createUser
+      #create the user we will use to grant permission to
+      sm = ServiceManager.new('localhost')
+      sm.connect(DB_USER_NAME, DB_PASSWORD)
+
+      au = AddUser.new('newuser', 'password', 'first', 'middle', 'last')
+      au.execute(sm)
+      sm.disconnect
+    end
+    
+    def createRoleAndAllocate
+      database = Database::new(DB_FILE)
+      @connection = database.connect(DB_USER_NAME, DB_PASSWORD)
+      @connection.execute_immediate( 'create role sales' )
+      @connection.execute_immediate( 'create table sales_test(sales_drone integer)' )
+      @connection.execute_immediate( 'grant insert on sales_test to sales' )
+      # no permission to this table (notsales)
+      @connection.execute_immediate( 'create table notsales(sales_drone integer)' )
+      # add 'newuser' into sales role
+      @connection.execute_immediate( 'grant sales to newuser' )
+      @connection.close
+    end
+    
+    def dropRole
+     database = Database::new(DB_FILE)
+     @connection = database.connect(DB_USER_NAME, DB_PASSWORD)
+     @connection.execute_immediate( 'drop role sales' )
+     @connection.close
+   end
+   
+   def dropUser
+      sm = ServiceManager.new('localhost')
+      sm.connect(DB_USER_NAME, DB_PASSWORD)
+
+      au = RemoveUser.new('newuser')
+      au.execute(sm)
+      sm.disconnect
+   end
+   
+   def teardown
+      dropRole
+      dropUser
+      
+      #~ if File::exist?(DB_FILE)
+         #~ db = Database.new(DB_FILE)
+         #~ db.drop(DB_USER_NAME, DB_PASSWORD)
+      #~ end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+      
+   #test we can connect with the role
+   def test02
+     database = Database::new(DB_FILE)
+     @connection = database.connect('newuser', 'password', Connection::ROLE => 'SALES' )
+     assert_nothing_raised() do
+     
+       assert(@connection.execute_immediate( 'insert into sales_test values(1)' ) == 1 )
+     
+     end
+     @connection.close
+   end
+   
+   def test01
+     database = Database::new(DB_FILE)
+     @connection = database.connect('newuser', 'password' )
+     assert_raise(IBRuby::IBRubyException) do
+       @connection.execute_immediate( 'insert into sales_test values(10)' )
+       
+       puts "No role passed but can insert into sales_test!" if TEST_LOGGING
+     end
+     @connection.close
+   end
+   
+end

data/test/RowCountTest.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class RowCountTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}row_count_test.ib"
+
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      # Create the database for use in testing.
+      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)
+      
+      # Create the test table.
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.execute_immediate('create table test(id integer)')
+      end
+   end
+   
+   
+   def teardown
+      if File.exist?(DB_FILE)
+         @database.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|
+            assert(cxn.execute_immediate('insert into test values (1000)') == 1)
+            assert(cxn.execute_immediate('insert into test values (1000)') == 1)
+            assert(cxn.execute('insert into test values (2000)', tx) == 1)
+            assert(cxn.execute('insert into test values (2000)', tx) == 1)
+            assert(tx.execute('insert into test values (3000)') == 1)
+            assert(tx.execute('insert into test values (3000)') == 1)
+            assert(tx.execute('insert into test values (4000)') == 1)
+            assert(tx.execute('insert into test values (4000)') == 1)
+            
+            assert(cxn.execute_immediate('update test set id = 10000 where '\
+                                         'id = 1000') == 2)
+            assert(cxn.execute('update test set id = 20000 where id = 2000',
+                               tx) == 2)
+            assert(tx.execute('update test set id = 30000 where id = 3000') == 2)
+            
+            s = Statement.new(cxn, tx, 'update test set id = 40000 where id = ?',
+                              3)
+            assert(s.execute_for([4000]) == 2)
+
+            
+            assert(cxn.execute_immediate('delete from test where id = 10000') == 2)
+            assert(cxn.execute('delete from test where id = 20000', tx) == 2)
+            assert(tx.execute('delete from test where id = 30000') == 2)
+         end
+      end
+   end
+end

data/test/RowTest.rb

@@ -0,0 +1,205 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+#require 'rubygems'
+require 'ibruby'
+
+include IBRuby
+
+class RowTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}row_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)
+      @connection  = database.connect(DB_USER_NAME, DB_PASSWORD)
+      @transaction = @connection.start_transaction
+      @results     = ResultSet.new(@connection, @transaction,
+                                   'SELECT * FROM RDB$FIELDS', 3, nil)
+      @empty       = [[0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER],
+                      [0, SQLType::INTEGER], [0, SQLType::INTEGER]]
+      
+      @connection.start_transaction do |tx|
+         tx.execute('create table rowtest (COL01 integer, COL02 varchar(10), '\
+                    'COL03 integer)')
+         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
+      @connection.start_transaction do |tx|
+         tx.execute("insert into rowtest values (1, 'Two', 3)")
+         
+         stmt = Statement.new(@connection, tx,
+                              "insert into all_types values(?, ?, ?, ?, ?, ?, "\
+                              "?, ?, ?, ?, ?, ?, ?)",
+                              3)
+         #stmt.execute_for([nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil])
+         stmt.execute_for([false, nil, 'La la la', Date.new(2005, 10, 29),
+                           10.23, 100.751, 56.25, 12345, 19863.21, 123,
+                           Time.new, Time.new, 'The End!'])
+      end
+   end
+   
+   def teardown
+      @results.close
+      @transaction.rollback
+      @connection.close
+      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
+      row = Row.new(@results, @empty, 100)
+      
+      assert(row.column_count == 28)
+      assert(row.number == 100)
+      assert(row.column_name(0) == 'RDB$FIELD_NAME')
+      assert(row.column_alias(10) == 'RDB$FIELD_TYPE')
+      assert(row[0] == 0)
+      assert(row['RDB$FIELD_TYPE'] == 0)
+   end
+   
+   def test02
+      sql  = 'select COL01 one, COL02 two, COL03 three from rowtest'
+      rows = @connection.execute_immediate(sql)
+      data = rows.fetch
+      
+      count = 0
+      data.each do |name, value|
+         assert(['ONE', 'TWO', 'THREE'].include?(name))
+         assert([1, 'Two', 3].include?(value))
+         count += 1
+      end
+      assert(count == 3)
+      
+      count = 0
+      data.each_key do |name|
+         assert(['ONE', 'TWO', 'THREE'].include?(name))
+         count += 1
+      end
+      assert(count == 3)
+      
+      count = 0
+      data.each_value do |value|
+         assert([1, 'Two', 3].include?(value))
+         count += 1
+      end
+      assert(count == 3)
+      
+      assert(data.fetch('TWO') == 'Two')
+      assert(data.fetch('FOUR', 'LALALA') == 'LALALA')
+      assert(data.fetch('ZERO') {'NOT FOUND'} == 'NOT FOUND')
+      begin
+         data.fetch('FIVE')
+         assert(false, 'Row#fetch succeeded for non-existent column name.')
+      rescue IndexError
+      end
+      
+      assert(data.has_key?('ONE'))
+      assert(data.has_key?('TEN') == false)
+      
+      assert(data.has_column?('COL02'))
+      assert(data.has_column?('COL22') == false)
+      
+      assert(data.has_alias?('TWO'))
+      assert(data.has_alias?('FOUR') == false)
+      
+      assert(data.has_value?(3))
+      assert(data.has_value?('LALALA') == false)
+      
+      assert(data.keys.size == 3)
+      data.keys.each do |name|
+         assert(['ONE', 'TWO', 'THREE'].include?(name))
+      end
+      
+      assert(data.names.size == 3)
+      data.names.each do |name|
+         assert(['COL01', 'COL02', 'COL03'].include?(name))
+      end
+
+      assert(data.aliases.size == 3)
+      data.aliases.each do |name|
+         assert(['ONE', 'TWO', 'THREE'].include?(name))
+      end
+      
+      assert(data.values.size == 3)
+      data.values.each do |value|
+         assert([1, 'Two', 3].include?(value))
+      end
+      
+      array = data.select {|name, value| name == 'TWO'}
+      assert(array.size == 1)
+      assert(array[0][0] == 'TWO')
+      assert(array[0][1] == 'Two')
+      
+      array = data.to_a
+      assert(array.size == 3)
+      assert(array.include?(['ONE', 1]))
+      assert(array.include?(['TWO', 'Two']))
+      assert(array.include?(['THREE', 3]))
+      
+      hash = data.to_hash
+      assert(hash.length == 3)
+      assert(hash['ONE'] == 1)
+      assert(hash['TWO'] == 'Two')
+      assert(hash['THREE'] == 3)
+      
+      array = data.values_at('TEN', 'TWO', 'THREE')
+      assert(array.size == 3)
+      assert(array.include?('Two'))
+      assert(array.include?(3))
+      assert(array.include?(nil))
+      
+      rows.close
+   end
+   
+   def test03
+      results = nil
+      row     = nil
+      
+      begin
+         results = @connection.execute_immediate('select * from all_types')
+         
+         row     = results.fetch
+         
+         assert(row.get_base_type(0) == SQLType::BOOLEAN)
+         assert(row.get_base_type(1) == SQLType::BLOB)
+         assert(row.get_base_type(2) == SQLType::CHAR)
+         assert(row.get_base_type(3) == SQLType::DATE)
+         assert(row.get_base_type(4) == SQLType::DECIMAL)
+         assert(row.get_base_type(5) == SQLType::DOUBLE)
+         assert(row.get_base_type(6) == SQLType::FLOAT)
+         assert(row.get_base_type(7) == SQLType::INTEGER)
+         assert(row.get_base_type(8) == SQLType::NUMERIC)
+         assert(row.get_base_type(9) == SQLType::SMALLINT)
+         assert(row.get_base_type(10) == SQLType::TIME)
+         assert(row.get_base_type(11) == SQLType::TIMESTAMP)
+         assert(row.get_base_type(12) == SQLType::VARCHAR)
+         
+      ensure
+         results.close if results != nil
+      end
+   end
+end