rubyfb 0.5.2

data/rubyfb.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rubyfb}
+  s.version = "0.5.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["George Georgiev"]
+  s.date = %q{2010-08-12}
+  s.description = %q{Firebird SQL access library}
+  s.email = %q{georgiev@heatbs.com}
+  s.extensions = ["ext/extconf.rb"]
+  s.extra_rdoc_files = ["CHANGELOG", "LICENSE", "README", "examples/example01.rb", "ext/extconf.rb", "lib/SQLType.rb", "lib/rubyfb.rb", "lib/src.rb"]
+  s.files = ["CHANGELOG", "LICENSE", "Manifest", "README", "Rakefile", "examples/example01.rb", "ext/AddUser.c", "ext/AddUser.h", "ext/Backup.c", "ext/Backup.h", "ext/Blob.c", "ext/Blob.h", "ext/Common.c", "ext/Common.h", "ext/Connection.c", "ext/Connection.h", "ext/DataArea.c", "ext/DataArea.h", "ext/Database.c", "ext/Database.h", "ext/FireRuby.c", "ext/FireRuby.h", "ext/FireRubyException.c", "ext/FireRubyException.h", "ext/Generator.c", "ext/Generator.h", "ext/RemoveUser.c", "ext/RemoveUser.h", "ext/Restore.c", "ext/Restore.h", "ext/ResultSet.c", "ext/ResultSet.h", "ext/Row.c", "ext/Row.h", "ext/ServiceManager.c", "ext/ServiceManager.h", "ext/Services.c", "ext/Services.h", "ext/Statement.c", "ext/Statement.h", "ext/Transaction.c", "ext/Transaction.h", "ext/TypeMap.c", "ext/TypeMap.h", "ext/extconf.rb", "ext/mkmf.bat", "lib/SQLType.rb", "lib/active_record/connection_adapters/rubyfb_adapter.rb", "lib/mkdoc", "lib/rubyfb.rb", "lib/rubyfb_lib.so", "lib/src.rb", "test/AddRemoveUserTest.rb", "test/BackupRestoreTest.rb", "test/BlobTest.rb", "test/CharacterSetTest.rb", "test/ConnectionTest.rb", "test/DDLTest.rb", "test/DatabaseTest.rb", "test/GeneratorTest.rb", "test/KeyTest.rb", "test/ResultSetTest.rb", "test/RoleTest.rb", "test/RowCountTest.rb", "test/RowTest.rb", "test/SQLTest.rb", "test/SQLTypeTest.rb", "test/ServiceManagerTest.rb", "test/StatementTest.rb", "test/TestSetup.rb", "test/TransactionTest.rb", "test/TypeTest.rb", "test/UnitTest.rb", "rubyfb.gemspec"]
+  s.homepage = %q{http://rubyforge.org/projects/rubyfb}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Rubyfb", "--main", "README"]
+  s.require_paths = ["lib", "ext"]
+  s.rubyforge_project = %q{rubyfb}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Firebird SQL access library}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/AddRemoveUserTest.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class AddRemoveUserTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}add_remove_user_unit_test.fdb"
+
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      # Remove existing database files.
+      @database = Database.new(DB_FILE)
+      if File.exist?(DB_FILE)
+         @database.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+   end
+
+   def teardown
+      # Remove existing database files.
+      if File.exist?(DB_FILE)
+         @database.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+
+   def test01
+      sm = ServiceManager.new('localhost')
+      sm.connect(DB_USER_NAME, DB_PASSWORD)
+
+      au = AddUser.new('newuser', 'password', 'first', 'middle', 'last')
+      au.execute(sm)
+      sleep(3)
+
+      cxn = @database.connect('newuser', 'password')
+      cxn.close
+
+      ru = RemoveUser.new('newuser')
+      ru.execute(sm)
+      sleep(3)
+      
+      sm.disconnect
+
+      begin
+         cxn = @database.connect('newuser', 'password')
+         cxn.close
+         assert(false, "Able to connect as supposedly removed user.")
+      rescue FireRubyException
+      end
+   end
+end

data/test/BackupRestoreTest.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class BackupRestoreTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}backup_restore_unit_test.fdb"
+   BACKUP_FILE = "#{CURDIR}#{File::SEPARATOR}database.bak"
+
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      # Remove existing database files.
+      if File.exist?(DB_FILE)
+         db = Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+
+      if File.exist?(BACKUP_FILE)
+         File.delete(BACKUP_FILE)
+      end
+
+      # Create and populate the database files.
+      @database = Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.execute_immediate('create table test(id integer)')
+         cxn.execute_immediate('insert into test values (1000)')
+         cxn.execute_immediate('insert into test values (2000)')
+         cxn.execute_immediate('insert into test values (NULL)')
+         cxn.execute_immediate('insert into test values (3000)')
+         cxn.execute_immediate('insert into test values (4000)')
+      end
+   end
+
+   def teardown
+      # Remove existing database files.
+      if File.exist?(DB_FILE)
+         db = Database.new(DB_FILE).drop(DB_USER_NAME, DB_PASSWORD)
+      end
+
+      if File.exist?(BACKUP_FILE)
+         File.delete(BACKUP_FILE)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+
+   def test01
+      sm = ServiceManager.new('localhost')
+      sm.connect(DB_USER_NAME, DB_PASSWORD)
+
+      b = Backup.new(DB_FILE, BACKUP_FILE)
+      b.execute(sm)
+
+      assert(File.exist?(BACKUP_FILE))
+      @database.drop(DB_USER_NAME, DB_PASSWORD)
+      assert(File.exists?(DB_FILE) == false)
+
+      r = Restore.new(BACKUP_FILE, DB_FILE)
+      r.execute(sm)
+      sm.disconnect
+
+      assert(File.exist?(DB_FILE))
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         total = 0
+         cxn.execute_immediate('select * from test') do |row|
+            assert([1000, 2000, 3000, 4000, nil].include?(row[0]))
+            total += 1
+         end
+         assert(total == 5)
+      end
+   end
+
+   def test02
+      sm = ServiceManager.new('localhost')
+      sm.connect(DB_USER_NAME, DB_PASSWORD)
+
+      b = Backup.new(DB_FILE, BACKUP_FILE)
+      b.metadata_only = true
+      b.execute(sm)
+
+      assert(File.exist?(BACKUP_FILE))
+      @database.drop(DB_USER_NAME, DB_PASSWORD)
+      assert(File.exists?(DB_FILE) == false)
+
+      r = Restore.new(BACKUP_FILE, DB_FILE)
+      r.execute(sm)
+      sm.disconnect
+
+      assert(File.exist?(DB_FILE))
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.execute_immediate('select count(*) from test') do |row|
+            assert(row[0] == 0)
+         end
+      end
+   end
+end

data/test/BlobTest.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class BlobTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}blob_unit_test.fdb"
+   TXT_FILE    = "#{CURDIR}#{File::SEPARATOR}data.txt"
+   DATA        = "aasdfjakhdsfljkashdfslfhaslhasyhfawyufalwuhlhsdlkfhasljlkshflalksjhasjhalsjhdf\nasdflkajshdfjkahsdfjajdfalsdfasdf\nasdfasdfasdkljfhajdfhkjasdfagdsflalkjfgagsdflasdf\nasdfasdfasdf"
+
+   def setup
+      puts "#{self.class.name} started." if TEST_LOGGING
+      # Remove existing database files.
+      @database = Database.new(DB_FILE)
+      if File.exist?(DB_FILE)
+         @database.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      Database.create(DB_FILE, DB_USER_NAME, DB_PASSWORD)
+   end
+
+   def teardown
+      # Remove existing database files.
+      if File.exist?(DB_FILE)
+         @database.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+
+   def test01
+      d = nil
+      @database.connect(DB_USER_NAME, DB_PASSWORD) do |cxn|
+         cxn.execute_immediate('create table blob_test (data blob sub_type 0)')
+         cxn.start_transaction do |tx|
+
+            s = Statement.new(cxn, tx, 'INSERT INTO BLOB_TEST VALUES(?)', 3)
+            s.execute_for([DATA])
+            
+            # Perform a select of the value inserted.
+            r = cxn.execute('SELECT * FROM BLOB_TEST', tx)
+            d = r.fetch
+            
+            assert_equal(d[0].to_s, DATA)
+
+            # Clean up.
+            s.close
+            r.close
+         end
+         cxn.execute_immediate('DROP TABLE BLOB_TEST')
+      end
+   end
+end

data/test/CharacterSetTest.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class CharacterSetTest < Test::Unit::TestCase
+   CURDIR   = "#{Dir.getwd}"
+   DB_FILE  = "#{CURDIR}#{File::SEPARATOR}cxnarset_unit_test.fdb"
+   CHAR_SET = 'WIN1251'
+   
+   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, 1024,
+                                  CHAR_SET)
+   end
+   
+   def teardown
+      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
+      db = Database.new(DB_FILE, CHAR_SET)
+
+      assert(db.character_set = CHAR_SET)
+
+      db.character_set = 'ASCII'
+      assert(db.character_set == 'ASCII')
+   end
+
+   def test02
+      text = "�?����"
+      db   = Database.new(DB_FILE, CHAR_SET)
+
+      begin
+         db.connect("SYSDBA", "masterkey") do |cxn|
+            cxn.start_transaction do |tr|
+               cxn.execute("CREATE TABLE SAMPLE_TABLE(SAMPLE_FIELD VARCHAR(100))",tr)
+            end  
+            cxn.start_transaction do |tr|
+               cxn.execute("INSERT INTO SAMPLE_TABLE VALUES ('#{win1251_str}')",tr)
+               cxn.execute("SELECT * FROM SAMPLE_TABLE WHERE SAMPLE_FIELD = "\
+                           "'#{win1251_str}'",tr) do |row|
+                  # here we have an exception:
+                  some_var = row['SAMPLE_FIELD']
+               end
+            end
+         end
+      rescue => error
+         assert("Character set unit test failure.", false)
+      end
+   end
+end

data/test/ConnectionTest.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class ConnectionTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}con_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 = []
+   end
+   
+   def teardown
+      @connections.each {|connection| connection.close}
+      @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))
+      
+      assert(@connections[0].user == DB_USER_NAME)
+      assert(@connections[0].open?)
+      assert(@connections[0].closed? == false)
+      assert(@connections[0].database == @database)
+      assert(@connections[0].to_s == "#{DB_USER_NAME}@#{DB_FILE} (OPEN)")
+      
+      @connections[0].close
+      assert(@connections[0].user == DB_USER_NAME)
+      assert(@connections[0].open? == false)
+      assert(@connections[0].closed?)
+      assert(@connections[0].database == @database)
+      assert(@connections[0].to_s == "(CLOSED)")
+      
+      @connections[0] = @database.connect(DB_USER_NAME, DB_PASSWORD)
+      assert(@connections[0].open?)
+      @connections.push(Connection.new(@database, DB_USER_NAME, DB_PASSWORD))
+      assert(@connections[0].open?)
+      assert(@connections[1].open?)
+   end
+   
+   def test02
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+      
+      tx = @connections[0].start_transaction
+      assert(tx != nil)
+      assert(tx.class == Transaction)
+      assert(tx.active?)
+      tx.rollback
+      
+      tx = nil
+      @connections[0].start_transaction do |transaction|
+         assert(transaction != nil)
+         assert(transaction.class == Transaction)
+         assert(transaction.active?)
+         tx = transaction
+      end
+      assert(tx != nil)
+      assert(tx.class == Transaction)
+      assert(tx.active? == false)
+   end
+   
+   def test03
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+      tx    = @connections[0].start_transaction
+      total = 0
+      @connections[0].execute("SELECT RDB$FIELD_NAME FROM RDB$FIELDS", tx) do |row|
+         total = total + 1
+      end
+      assert(total == 88)
+      tx.commit
+
+      total = 0      
+      @connections[0].execute_immediate("SELECT RDB$FIELD_NAME FROM RDB$FIELDS") do |row|
+         total = total + 1
+      end
+      assert(total == 88)
+   end
+
+   def test04
+      connection = @database.connect(DB_USER_NAME, DB_PASSWORD)
+
+      tx1 = connection.start_transaction
+      tx2 = connection.start_transaction
+      tx3 = connection.start_transaction
+
+      tx2.rollback
+      assert(tx2.active? == false)
+
+      connection.close
+
+      assert(connection.closed?)
+      assert(tx1.active? == false)
+      assert(tx3.active? == false)
+   end
+end

data/test/DDLTest.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class DDLTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}ddl_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)
+   end
+   
+   def teardown
+      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.execute_immediate('CREATE TABLE DDL_TABLE_01 (TABLEID '\
+                               'INTEGER NOT NULL, '\
+                               'FIELD01 FLOAT, FIELD02 CHAR(50), '\
+                               'FIELD03 BIGINT, FIELD04 TIMESTAMP '\
+                               'NOT NULL, FIELD05 VARCHAR(600))')
+
+         cxn.start_transaction do |tx|
+            r = tx.execute('SELECT COUNT(*) FROM DDL_TABLE_01')
+            assert(r.fetch[0] == 0)
+            r.close
+         end
+         
+         cxn.execute_immediate('ALTER TABLE DDL_TABLE_01 ADD PRIMARY KEY '\
+                               '(TABLEID)')
+                            
+         cxn.execute_immediate('CREATE UNIQUE INDEX DDL_TABLE_IDX ON '\
+                            'DDL_TABLE_01 (TABLEID)')
+                            
+         cxn.execute_immediate('DROP INDEX DDL_TABLE_IDX')
+      
+         cxn.execute_immediate('DROP TABLE DDL_TABLE_01')
+      end
+   end
+end

data/test/DatabaseTest.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class DatabaseTest < Test::Unit::TestCase
+   CURDIR      = "#{Dir.getwd}"
+   DB_FILE     = "#{CURDIR}#{File::SEPARATOR}db_unit_test.fdb"
+   CREATE_FILE = "#{CURDIR}#{File::SEPARATOR}db_create_test.fdb"
+   
+   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
+      if File.exist?(CREATE_FILE)
+         db = Database.new(CREATE_FILE)
+         db.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      
+      Database::create(DB_FILE, DB_USER_NAME, DB_PASSWORD, 1024, 'ASCII')
+   end
+   
+   def teardown
+      if File::exist?(DB_FILE)
+         db = Database.new(DB_FILE)
+         db.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      if File::exist?(CREATE_FILE)
+         db = Database.new(CREATE_FILE)
+         db.drop(DB_USER_NAME, DB_PASSWORD)
+      end
+      puts "#{self.class.name} finished." if TEST_LOGGING
+   end
+   
+   
+   def test01
+      db = Database.create(CREATE_FILE, DB_USER_NAME, DB_PASSWORD, 2048, 'ASCII')
+      
+      assert(File.exist?(CREATE_FILE))
+      assert(db.file == CREATE_FILE)
+      
+      begin
+         Database.create(CREATE_FILE, DB_USER_NAME, DB_PASSWORD, 2048, 'ASCII')
+         assert(false,
+                "Successfully created a database file that already exists.")
+      rescue Exception
+      end
+      
+      db.drop(DB_USER_NAME, DB_PASSWORD)
+      assert(File.exist?(CREATE_FILE) == false)
+   end
+   
+   def test02
+      db = Database.new(DB_FILE);
+      
+      assert(db.file == DB_FILE)
+      
+      c = db.connect(DB_USER_NAME, DB_PASSWORD)
+      assert(c != nil)
+      c.close
+   end
+   
+   def test03
+      db = Database.new(DB_FILE);
+      c  = nil
+
+      db.connect(DB_USER_NAME, DB_PASSWORD) do |connection|
+         assert(connection != nil)
+         assert(connection.class == Connection)
+         assert(connection.open?)
+         c = connection
+      end
+      assert(c != nil)
+      assert(c.class == Connection)
+      assert(c.closed?)
+   end
+end

data/test/GeneratorTest.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require 'TestSetup'
+require 'test/unit'
+require 'rubygems'
+require 'fireruby'
+
+include FireRuby
+
+class GeneratorTest < Test::Unit::TestCase
+   CURDIR  = "#{Dir.getwd}"
+   DB_FILE = "#{CURDIR}#{File::SEPARATOR}generator_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  = []
+      
+      @connections.push(@database.connect(DB_USER_NAME, DB_PASSWORD))
+   end
+   
+   def teardown
+      @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
+      assert(Generator::exists?('TEST_GEN', @connections[0]) == false)
+      g = Generator::create('TEST_GEN', @connections[0])
+      assert(Generator::exists?('TEST_GEN', @connections[0]))
+      assert(g.last == 0)
+      assert(g.next(1) == 1)
+      assert(g.last == 1)
+      assert(g.next(10) == 11)
+      assert(g.connection == @connections[0])
+      assert(g.name == 'TEST_GEN')
+      
+      g.drop
+      assert(Generator::exists?('TEST_GEN', @connections[0]) == false)
+   end
+end