fb 0.5.5 → 0.5.9

data/test/DatabaseTestCases.rb

@@ -1,180 +1,180 @@
-require 'test/unit'
-require 'test/FbTestCases'
-require 'fb'
-include Fb
-
-class DatabaseTestCases < Test::Unit::TestCase
-  include FbTestCases
-  
-  def setup
-    super
-    @database = "localhost:#{@db_file}"
-    @reader = {
-      :database => "localhost:#{@db_file}",
-      :username => 'rubytest',
-      :password => 'rubytest',
-      :charset => 'NONE',
-      :role => 'READER' }
-    @writer = {
-      :database => "localhost:#{@db_file}",
-      :username => 'rubytest',
-      :password => 'rubytest',
-      :charset => 'NONE',
-      :role => 'WRITER' }
-  end
-  
-  def test_new
-    db = Database.new
-    assert_instance_of Database, db
-  end
-  
-  def test_properties_read
-    db = Database.new
-    assert_nil db.database
-    assert_nil db.username
-    assert_nil db.password
-    assert_nil db.charset
-    assert_nil db.role
-  end
-
-  def test_properties_write
-    db = Database.new
-    db.database = @database
-    assert_equal @database, db.database
-    db.username = 'sysdba'
-    assert_equal 'sysdba', db.username
-    db.password = 'masterkey'
-    assert_equal 'masterkey', db.password
-    db.charset = 'NONE'
-    assert_equal 'NONE', db.charset
-    db.role = 'READER'
-    assert_equal 'READER', db.role
-  end
-  
-  def test_initialize_hash
-    db = Database.new(@parms)
-    assert_equal @database, db.database
-    assert_equal 'sysdba', db.username
-    assert_equal 'masterkey', db.password
-    assert_equal 'NONE', db.charset
-    assert_equal 'READER', db.role
-  end
-  
-  def test_initialize_string
-    db = Database.new(@parms_s)
-    assert_equal @database, db.database
-    assert_equal 'sysdba', db.username
-    assert_equal 'masterkey', db.password
-    assert_equal 'NONE', db.charset
-    assert_equal 'READER', db.role
-  end
-  
-  def test_create_instance
-    db = Database.new(@parms)
-    db.create
-    assert File.exists?(@db_file)
-  end
-  
-  def test_create_instance_block
-    db = Database.new(@parms)
-    db.create do |connection|
-      connection.execute("select * from RDB$DATABASE") do |cursor|
-        row = cursor.fetch
-        assert_instance_of Array, row
-      end
-      assert_equal 3, connection.dialect
-      assert_equal 3, connection.db_dialect
-    end
-    assert File.exists?(@db_file)
-  end
-  
-  def test_create_singleton
-    db = Database.create(@parms);
-    assert File.exists?(@db_file)
-  end
-
-  def test_create_singleton_with_defaults
-    db = Database.create(:database => "localhost:#{@db_file}");
-    assert File.exists?(@db_file)
-  end
-
-  def test_create_singleton_block
-    db = Database.create(@parms) do |connection|
-      connection.execute("select * from RDB$DATABASE") do |cursor|
-        row = cursor.fetch
-        assert_instance_of Array, row
-      end
-    end
-    assert_instance_of Database, db
-    assert File.exists?(@db_file)
-  end
-  
-  def test_create_bad_param
-    assert_raise TypeError do
-      db = Database.create(1)
-    end
-  end
-
-  def test_create_bad_page_size
-    assert_raise Error do
-      db = Database.create(@parms.merge(:page_size => 1000))
-    end
-  end
-
-  def test_connect_instance
-    db = Database.create(@parms)
-    connection = db.connect
-    assert_instance_of Connection, connection
-    connection.close
-  end
-
-  def test_connect_singleton
-    db = Database.create(@parms)
-    connection = Database.connect(@parms)
-    assert_instance_of Connection, connection
-    connection.close
-  end
-  
-  def test_drop_instance
-    assert !File.exists?(@db_file)
-    db = Database.create(@parms)
-    assert File.exists?(@db_file)
-    db.drop
-    assert !File.exists?(@db_file)
-  end
-  
-  def test_drop_singleton
-    assert !File.exists?(@db_file)
-    Database.create(@parms)
-    assert File.exists?(@db_file)
-    Database.drop(@parms)
-    assert !File.exists?(@db_file)
-  end
-  
-  def test_role_support
-    Database.create(@parms) do |connection|
-      connection.execute("create table test (id int, test varchar(10))")
-      connection.execute("create role writer")
-      connection.execute("grant all on test to writer")
-      connection.execute("grant writer to rubytest")
-      connection.commit
-      connection.execute("insert into test values (1, 'test role')")
-    end
-    Database.connect(@reader) do |connection|
-      assert_raise Error do
-        connection.execute("select * from test") do |cursor|
-          flunk "Should not reach here."
-        end
-      end
-    end
-    Database.connect(@writer) do |connection|
-      connection.execute("select * from test") do |cursor|
-        row = cursor.fetch :hash
-        assert_equal 1, row["ID"]
-        assert_equal 'test role', row["TEST"]
-      end
-    end
-    Database.drop(@parms)
-  end
-end
-    
+require 'test/unit'
+require 'test/FbTestCases'
+# require 'fb'
+# include Fb
+
+class DatabaseTestCases < Test::Unit::TestCase
+  include FbTestCases
+  
+  def setup
+    super
+    @database = "localhost:#{@db_file}"
+    @reader = {
+      :database => "localhost:#{@db_file}",
+      :username => 'rubytest',
+      :password => 'rubytest',
+      :charset => 'NONE',
+      :role => 'READER' }
+    @writer = {
+      :database => "localhost:#{@db_file}",
+      :username => 'rubytest',
+      :password => 'rubytest',
+      :charset => 'NONE',
+      :role => 'WRITER' }
+  end
+  
+  def test_new
+    db = Database.new
+    assert_instance_of Database, db
+  end
+  
+  def test_properties_read
+    db = Database.new
+    assert_nil db.database
+    assert_nil db.username
+    assert_nil db.password
+    assert_nil db.charset
+    assert_nil db.role
+  end
+
+  def test_properties_write
+    db = Database.new
+    db.database = @database
+    assert_equal @database, db.database
+    db.username = 'sysdba'
+    assert_equal 'sysdba', db.username
+    db.password = 'masterkey'
+    assert_equal 'masterkey', db.password
+    db.charset = 'NONE'
+    assert_equal 'NONE', db.charset
+    db.role = 'READER'
+    assert_equal 'READER', db.role
+  end
+  
+  def test_initialize_hash
+    db = Database.new(@parms)
+    assert_equal @database, db.database
+    assert_equal @username, db.username
+    assert_equal @password, db.password
+    assert_equal 'NONE', db.charset
+    assert_equal 'READER', db.role
+  end
+  
+  def test_initialize_string
+    db = Database.new(@parms_s)
+    assert_equal @database, db.database
+    assert_equal @username, db.username
+    assert_equal @password, db.password
+    assert_equal 'NONE', db.charset
+    assert_equal 'READER', db.role
+  end
+  
+  def test_create_instance
+    db = Database.new(@parms)
+    db.create
+    assert File.exists?(@db_file)
+  end
+  
+  def test_create_instance_block
+    db = Database.new(@parms)
+    db.create do |connection|
+      connection.execute("select * from RDB$DATABASE") do |cursor|
+        row = cursor.fetch
+        assert_instance_of Array, row
+      end
+      assert_equal 3, connection.dialect
+      assert_equal 3, connection.db_dialect
+    end
+    assert File.exists?(@db_file)
+  end
+  
+  def test_create_singleton
+    db = Database.create(@parms);
+    assert File.exists?(@db_file)
+  end
+
+  def test_create_singleton_with_defaults
+    db = Database.create(:database => "localhost:#{@db_file}");
+    assert File.exists?(@db_file)
+  end
+
+  def test_create_singleton_block
+    db = Database.create(@parms) do |connection|
+      connection.execute("select * from RDB$DATABASE") do |cursor|
+        row = cursor.fetch
+        assert_instance_of Array, row
+      end
+    end
+    assert_instance_of Database, db
+    assert File.exists?(@db_file)
+  end
+  
+  def test_create_bad_param
+    assert_raise TypeError do
+      db = Database.create(1)
+    end
+  end
+
+  def test_create_bad_page_size
+    assert_raise Error do
+      db = Database.create(@parms.merge(:page_size => 1000))
+    end
+  end
+
+  def test_connect_instance
+    db = Database.create(@parms)
+    connection = db.connect
+    assert_instance_of Connection, connection
+    connection.close
+  end
+
+  def test_connect_singleton
+    db = Database.create(@parms)
+    connection = Database.connect(@parms)
+    assert_instance_of Connection, connection
+    connection.close
+  end
+  
+  def test_drop_instance
+    assert !File.exists?(@db_file)
+    db = Database.create(@parms)
+    assert File.exists?(@db_file)
+    db.drop
+    assert !File.exists?(@db_file)
+  end
+  
+  def test_drop_singleton
+    assert !File.exists?(@db_file)
+    Database.create(@parms)
+    assert File.exists?(@db_file)
+    Database.drop(@parms)
+    assert !File.exists?(@db_file)
+  end
+  
+  def test_role_support
+    Database.create(@parms) do |connection|
+      connection.execute("create table test (id int, test varchar(10))")
+      connection.execute("create role writer")
+      connection.execute("grant all on test to writer")
+      connection.execute("grant writer to rubytest")
+      connection.commit
+      connection.execute("insert into test values (1, 'test role')")
+    end
+    Database.connect(@reader) do |connection|
+      assert_raise Error do
+        connection.execute("select * from test") do |cursor|
+          flunk "Should not reach here."
+        end
+      end
+    end
+    Database.connect(@writer) do |connection|
+      connection.execute("select * from test") do |cursor|
+        row = cursor.fetch :hash
+        assert_equal 1, row["ID"]
+        assert_equal 'test role', row["TEST"]
+      end
+    end
+    Database.drop(@parms)
+  end
+end
+    

data/test/FbTestCases.rb

@@ -1,33 +1,36 @@
-require 'fileutils'
-include FileUtils
-
-module FbTestCases
-  def setup
-    @db_file = case RUBY_PLATFORM
-      when /win32/ then 'c:/var/fbdata/drivertest.fdb'
-      when /darwin/ then '/var/fbdata/drivertest.fdb'
-      else '/var/fbdata/drivertest.fdb'
-    end
-    @db_host = 'localhost'
-    @parms = {
-      :database => "#{@db_host}:#{@db_file}",
-      :username => 'sysdba',
-      :password => 'masterkey',
-      :charset => 'NONE',
-      :role => 'READER' }
-    @parms_s = "database = #{@db_host}:#{@db_file}; username = sysdba; password = masterkey; charset = NONE; role = READER;"
-    rm_rf @db_file
-  end
-end
-
-require 'fb'
-
-class Fb::Connection
-  def execute_script(sql_schema)
-    self.transaction do
-      sql_schema.strip.split(';').each do |stmt|
-        self.execute(stmt);
-      end
-    end
-  end
-end
+require 'fileutils'
+include FileUtils
+require 'fb'
+
+module FbTestCases
+  include Fb
+
+  def setup
+    @db_file = case RUBY_PLATFORM
+      when /win32/ then 'c:/var/fbdata/drivertest.fdb'
+      when /darwin/ then '/var/fbdata/drivertest.fdb'
+      else '/var/fbdata/drivertest.fdb'
+    end
+    @db_host = 'localhost'
+    @username = 'sysdba'
+    @password = 'masterkey'
+    @parms = {
+      :database => "#{@db_host}:#{@db_file}",
+      :username => @username,
+      :password => @password,
+      :charset => 'NONE',
+      :role => 'READER' }
+    @parms_s = "database = #{@db_host}:#{@db_file}; username = #{@username}; password = #{@password}; charset = NONE; role = READER;"
+    rm_rf @db_file
+  end
+end
+
+class Fb::Connection
+  def execute_script(sql_schema)
+    self.transaction do
+      sql_schema.strip.split(';').each do |stmt|
+        self.execute(stmt);
+      end
+    end
+  end
+end

data/test/TransactionTestCases.rb

@@ -1,259 +1,259 @@
-require 'test/unit'
-require 'test/FbTestCases'
-require 'fb'
-include Fb
-
-class TransactionTestCases < Test::Unit::TestCase
-  include FbTestCases
-  
-  def test_transaction
-    Database.create(@parms) do |connection|
-      n = 0
-      assert !connection.transaction_started
-      connection.transaction
-      assert connection.transaction_started
-      connection.commit
-      assert !connection.transaction_started
-      connection.transaction
-      assert connection.transaction_started
-      connection.rollback
-      assert !connection.transaction_started
-      connection.drop
-    end
-  end
-  
-  def test_transaction_block
-    Database.create(@parms) do |connection|
-      n = 0
-      assert !connection.transaction_started
-      connection.transaction do
-        assert connection.transaction_started
-      end
-      assert !connection.transaction_started
-      assert_raise RuntimeError do
-        connection.transaction do
-          assert connection.transaction_started
-          raise "generic exception"
-        end
-      end
-      assert !connection.transaction_started
-      connection.drop
-    end
-  end
-  
-  def test_auto_transaction_select_with_exception
-    sql_select = "SELECT * FROM RDB$DATABASE"
-    Database.create(@parms) do |connection|
-      assert !connection.transaction_started
-      assert_raise RuntimeError do
-        connection.execute(sql_select) do |cursor|
-          assert connection.transaction_started
-          raise "abort"
-        end
-      end
-      assert !connection.transaction_started
-      connection.drop
-    end
-  end
-  
-  def test_auto_transaction_insert_with_exception
-    sql_schema = "CREATE TABLE TEST (ID INT NOT NULL PRIMARY KEY, NAME VARCHAR(20))"
-    sql_insert = "INSERT INTO TEST (ID, NAME) VALUES (?, ?)"
-    Database.create(@parms) do |connection|
-      connection.execute(sql_schema)
-      assert !connection.transaction_started
-      connection.execute(sql_insert, 1, "one")
-      assert !connection.transaction_started
-      assert_raise Error do
-        connection.execute(sql_insert, 1, "two")
-      end
-      assert !connection.transaction_started, "transaction is active"
-      connection.drop
-    end
-  end
-  
-  def test_auto_transaction_query
-    Database.create(@parms) do |connection|
-      assert !connection.transaction_started
-      rs = connection.query("select * from rdb$database")
-      assert !connection.transaction_started
-      connection.drop
-    end
-  end
-  
-  def test_query_in_transaction
-    Database.create(@parms) do |connection|
-      assert !connection.transaction_started
-      connection.transaction do
-        assert connection.transaction_started
-        rs = connection.query("select * from rdb$database")
-        assert connection.transaction_started
-      end
-      assert !connection.transaction_started
-      connection.drop
-    end
-  end
-  
-  def test_insert_commit
-    sql_schema = "CREATE TABLE TEST (ID INT, NAME VARCHAR(20))"
-    sql_insert = "INSERT INTO TEST (ID, NAME) VALUES (?, ?)"
-    sql_select = "SELECT * FROM TEST ORDER BY ID"
-    Database.create(@parms) do |connection|
-      connection.execute(sql_schema);
-      connection.transaction
-      10.times do |i|
-        connection.execute(sql_insert, i, i.to_s);
-      end
-      connection.commit
-      connection.execute(sql_select) do |cursor|
-        rows = cursor.fetchall
-        assert_equal 10, rows.size
-        10.times do |i|
-          assert_equal i, rows[i][0]
-          assert_equal i.to_s, rows[i][1]
-        end
-      end
-      connection.drop
-    end
-  end
-  
-  def test_insert_rollback
-    sql_schema = "CREATE TABLE TEST (ID INT, NAME VARCHAR(20))"
-    sql_insert = "INSERT INTO TEST (ID, NAME) VALUES (?, ?)"
-    sql_select = "SELECT * FROM TEST ORDER BY ID"
-    Database.create(@parms) do |connection|
-      connection.execute(sql_schema)
-      connection.transaction
-      10.times do |i|
-        connection.execute(sql_insert, i, i.to_s);
-      end
-      connection.rollback
-      rows = connection.execute(sql_select) do |cursor| cursor.fetchall end
-      assert_equal 0, rows.size
-      connection.drop
-    end
-  end
-  
-  def test_transaction_block_insert_commit
-    sql_schema = "CREATE TABLE TEST (ID INT, NAME VARCHAR(20))"
-    sql_insert = "INSERT INTO TEST (ID, NAME) VALUES (?, ?)"
-    sql_select = "SELECT * FROM TEST ORDER BY ID"
-    Database.create(@parms) do |connection|
-      connection.execute(sql_schema);
-      assert !connection.transaction_started
-      result = connection.transaction do
-        assert connection.transaction_started
-        10.times do |i|
-          connection.execute(sql_insert, i, i.to_s);
-        end
-        assert connection.transaction_started
-        "transaction block result"
-      end
-      assert_equal "transaction block result", result
-      assert !connection.transaction_started
-      connection.execute(sql_select) do |cursor|
-        assert_equal 10, cursor.fetchall.size
-      end
-      connection.drop
-    end
-  end
-  
-  def test_transaction_block_insert_rollback
-    sql_schema = "CREATE TABLE TEST (ID INT, NAME VARCHAR(20))"
-    sql_insert = "INSERT INTO TEST (ID, NAME) VALUES (?, ?)"
-    sql_select = "SELECT * FROM TEST ORDER BY ID"
-    Database.create(@parms) do |connection|
-      connection.execute(sql_schema)
-      assert !connection.transaction_started
-      assert_raise RuntimeError do
-        connection.transaction do
-          10.times do |i|
-            connection.execute(sql_insert, i, i.to_s);
-          end
-          raise "Raise an exception, causing the transaction to be rolled back."
-        end
-      end
-      rows = connection.execute(sql_select) do |cursor| cursor.fetchall end
-      assert_equal 0, rows.size
-      connection.drop
-    end
-  end
-  
-  def test_simultaneous_transactions
-    db_file1 = "#{@db_file}1"
-    db_file2 = "#{@db_file}2"
-    rm_rf db_file1
-    rm_rf db_file2
-    parms1 = @parms.merge(:database => "#{@db_host}:#{db_file1}")
-    parms2 = @parms.merge(:database => "#{@db_host}:#{db_file2}")
-    Database.create(parms1) do |conn1|
-      Database.create(parms2) do |conn2|
-        assert !conn1.transaction_started, "conn1 transaction is started"
-        assert !conn2.transaction_started, "conn2 transaction is started"
-        conn1.transaction do
-          assert conn1.transaction_started, "conn1 transaction is not started"
-          assert !conn2.transaction_started, "conn2 transaction is started"
-          conn2.transaction do
-            assert conn2.transaction_started, "conn2 transaction is not started"
-            assert conn1.transaction_started, "conn1 transaction is not started"
-          end
-          assert !conn2.transaction_started, "conn2 transaction is still active"
-          assert conn1.transaction_started, "conn1 transaction is not still active"
-        end
-        assert !conn1.transaction_started, "conn1 transaction is still active"
-        conn2.drop
-      end
-      conn1.drop
-    end
-  end
-  
-  def test_transaction_options_snapshot
-    sql_schema = "CREATE TABLE TEST (ID INT, NAME VARCHAR(20))"
-    sql_insert = "INSERT INTO TEST (ID, NAME) VALUES (?, ?)"
-    sql_select = "SELECT * FROM TEST ORDER BY ID"
-    sql_delete = "DELETE FROM TEST WHERE ID < ?"
-    Database.create(@parms) do |conn1|
-      conn1.execute(sql_schema)
-      conn1.transaction do
-        10.times do |i|
-          conn1.execute(sql_insert, i, "NAME#{i}")
-        end
-      end
-      Database.connect(@parms) do |conn2|
-        conn2.transaction("SNAPSHOT") do
-          affected = conn1.execute(sql_delete, 5)
-          assert_equal 5, affected
-          rs1 = conn2.query(sql_select)
-          assert_equal 10, rs1.size
-        end
-        rs2 = conn2.query(sql_select)
-        assert_equal 5, rs2.size
-      end
-    end
-  end
-  
-  def test_transaction_options_read_committed
-    sql_schema = "CREATE TABLE TEST (ID INT, NAME VARCHAR(20))"
-    sql_insert = "INSERT INTO TEST (ID, NAME) VALUES (?, ?)"
-    sql_select = "SELECT * FROM TEST ORDER BY ID"
-    sql_delete = "DELETE FROM TEST WHERE ID < ?"
-    Database.create(@parms) do |conn1|
-      conn1.execute(sql_schema)
-      conn1.transaction do
-        10.times do |i|
-          conn1.execute(sql_insert, i, "NAME#{i}")
-        end
-      end
-      Database.connect(@parms) do |conn2|
-        conn2.transaction("READ COMMITTED") do
-          affected = conn1.execute(sql_delete, 5)
-          assert_equal 5, affected
-          rs1 = conn2.query(sql_select)
-          assert_equal 5, rs1.size
-        end
-        rs2 = conn2.query(sql_select)
-        assert_equal 5, rs2.size
-      end
-    end
-  end
-end
+require 'test/unit'
+require 'test/FbTestCases'
+# require 'fb'
+# include Fb
+
+class TransactionTestCases < Test::Unit::TestCase
+  include FbTestCases
+  
+  def test_transaction
+    Database.create(@parms) do |connection|
+      n = 0
+      assert !connection.transaction_started
+      connection.transaction
+      assert connection.transaction_started
+      connection.commit
+      assert !connection.transaction_started
+      connection.transaction
+      assert connection.transaction_started
+      connection.rollback
+      assert !connection.transaction_started
+      connection.drop
+    end
+  end
+
+  def test_transaction_block
+    Database.create(@parms) do |connection|
+      n = 0
+      assert !connection.transaction_started
+      connection.transaction do
+        assert connection.transaction_started
+      end
+      assert !connection.transaction_started
+      assert_raise RuntimeError do
+        connection.transaction do
+          assert connection.transaction_started
+          raise "generic exception"
+        end
+      end
+      assert !connection.transaction_started
+      connection.drop
+    end
+  end
+
+  def test_auto_transaction_select_with_exception
+    sql_select = "SELECT * FROM RDB$DATABASE"
+    Database.create(@parms) do |connection|
+      assert !connection.transaction_started
+      assert_raise RuntimeError do
+        connection.execute(sql_select) do |cursor|
+          assert connection.transaction_started
+          raise "abort"
+        end
+      end
+      assert !connection.transaction_started
+      connection.drop
+    end
+  end
+
+  def test_auto_transaction_insert_with_exception
+    sql_schema = "CREATE TABLE TEST (ID INT NOT NULL PRIMARY KEY, NAME VARCHAR(20))"
+    sql_insert = "INSERT INTO TEST (ID, NAME) VALUES (?, ?)"
+    Database.create(@parms) do |connection|
+      connection.execute(sql_schema)
+      assert !connection.transaction_started
+      connection.execute(sql_insert, 1, "one")
+      assert !connection.transaction_started
+      assert_raise Error do
+        connection.execute(sql_insert, 1, "two")
+      end
+      assert !connection.transaction_started, "transaction is active"
+      connection.drop
+    end
+  end
+
+  def test_auto_transaction_query
+    Database.create(@parms) do |connection|
+      assert !connection.transaction_started
+      rs = connection.query("select * from rdb$database")
+      assert !connection.transaction_started
+      connection.drop
+    end
+  end
+
+  def test_query_in_transaction
+    Database.create(@parms) do |connection|
+      assert !connection.transaction_started
+      connection.transaction do
+        assert connection.transaction_started
+        rs = connection.query("select * from rdb$database")
+        assert connection.transaction_started
+      end
+      assert !connection.transaction_started
+      connection.drop
+    end
+  end
+
+  def test_insert_commit
+    sql_schema = "CREATE TABLE TEST (ID INT, NAME VARCHAR(20))"
+    sql_insert = "INSERT INTO TEST (ID, NAME) VALUES (?, ?)"
+    sql_select = "SELECT * FROM TEST ORDER BY ID"
+    Database.create(@parms) do |connection|
+      connection.execute(sql_schema);
+      connection.transaction
+      10.times do |i|
+        connection.execute(sql_insert, i, i.to_s);
+      end
+      connection.commit
+      connection.execute(sql_select) do |cursor|
+        rows = cursor.fetchall
+        assert_equal 10, rows.size
+        10.times do |i|
+          assert_equal i, rows[i][0]
+          assert_equal i.to_s, rows[i][1]
+        end
+      end
+      connection.drop
+    end
+  end
+
+  def test_insert_rollback
+    sql_schema = "CREATE TABLE TEST (ID INT, NAME VARCHAR(20))"
+    sql_insert = "INSERT INTO TEST (ID, NAME) VALUES (?, ?)"
+    sql_select = "SELECT * FROM TEST ORDER BY ID"
+    Database.create(@parms) do |connection|
+      connection.execute(sql_schema)
+      connection.transaction
+      10.times do |i|
+        connection.execute(sql_insert, i, i.to_s);
+      end
+      connection.rollback
+      rows = connection.execute(sql_select) do |cursor| cursor.fetchall end
+      assert_equal 0, rows.size
+      connection.drop
+    end
+  end
+
+  def test_transaction_block_insert_commit
+    sql_schema = "CREATE TABLE TEST (ID INT, NAME VARCHAR(20))"
+    sql_insert = "INSERT INTO TEST (ID, NAME) VALUES (?, ?)"
+    sql_select = "SELECT * FROM TEST ORDER BY ID"
+    Database.create(@parms) do |connection|
+      connection.execute(sql_schema);
+      assert !connection.transaction_started
+      result = connection.transaction do
+        assert connection.transaction_started
+        10.times do |i|
+          connection.execute(sql_insert, i, i.to_s);
+        end
+        assert connection.transaction_started
+        "transaction block result"
+      end
+      assert_equal "transaction block result", result
+      assert !connection.transaction_started
+      connection.execute(sql_select) do |cursor|
+        assert_equal 10, cursor.fetchall.size
+      end
+      connection.drop
+    end
+  end
+
+  def test_transaction_block_insert_rollback
+    sql_schema = "CREATE TABLE TEST (ID INT, NAME VARCHAR(20))"
+    sql_insert = "INSERT INTO TEST (ID, NAME) VALUES (?, ?)"
+    sql_select = "SELECT * FROM TEST ORDER BY ID"
+    Database.create(@parms) do |connection|
+      connection.execute(sql_schema)
+      assert !connection.transaction_started
+      assert_raise RuntimeError do
+        connection.transaction do
+          10.times do |i|
+            connection.execute(sql_insert, i, i.to_s);
+          end
+          raise "Raise an exception, causing the transaction to be rolled back."
+        end
+      end
+      rows = connection.execute(sql_select) do |cursor| cursor.fetchall end
+      assert_equal 0, rows.size
+      connection.drop
+    end
+  end
+
+  def test_simultaneous_transactions
+    db_file1 = "#{@db_file}1"
+    db_file2 = "#{@db_file}2"
+    rm_rf db_file1
+    rm_rf db_file2
+    parms1 = @parms.merge(:database => "#{@db_host}:#{db_file1}")
+    parms2 = @parms.merge(:database => "#{@db_host}:#{db_file2}")
+    Database.create(parms1) do |conn1|
+      Database.create(parms2) do |conn2|
+        assert !conn1.transaction_started, "conn1 transaction is started"
+        assert !conn2.transaction_started, "conn2 transaction is started"
+        conn1.transaction do
+          assert conn1.transaction_started, "conn1 transaction is not started"
+          assert !conn2.transaction_started, "conn2 transaction is started"
+          conn2.transaction do
+            assert conn2.transaction_started, "conn2 transaction is not started"
+            assert conn1.transaction_started, "conn1 transaction is not started"
+          end
+          assert !conn2.transaction_started, "conn2 transaction is still active"
+          assert conn1.transaction_started, "conn1 transaction is not still active"
+        end
+        assert !conn1.transaction_started, "conn1 transaction is still active"
+        conn2.drop
+      end
+      conn1.drop
+    end
+  end
+
+  def test_transaction_options_snapshot
+    sql_schema = "CREATE TABLE TEST (ID INT, NAME VARCHAR(20))"
+    sql_insert = "INSERT INTO TEST (ID, NAME) VALUES (?, ?)"
+    sql_select = "SELECT * FROM TEST ORDER BY ID"
+    sql_delete = "DELETE FROM TEST WHERE ID < ?"
+    Database.create(@parms) do |conn1|
+      conn1.execute(sql_schema)
+      conn1.transaction do
+        10.times do |i|
+          conn1.execute(sql_insert, i, "NAME#{i}")
+        end
+      end
+      Database.connect(@parms) do |conn2|
+        conn2.transaction("SNAPSHOT") do
+          affected = conn1.execute(sql_delete, 5)
+          assert_equal 5, affected
+          rs1 = conn2.query(sql_select)
+          assert_equal 10, rs1.size
+        end
+        rs2 = conn2.query(sql_select)
+        assert_equal 5, rs2.size
+      end
+    end
+  end
+
+  def test_transaction_options_read_committed
+    sql_schema = "CREATE TABLE TEST (ID INT, NAME VARCHAR(20))"
+    sql_insert = "INSERT INTO TEST (ID, NAME) VALUES (?, ?)"
+    sql_select = "SELECT * FROM TEST ORDER BY ID"
+    sql_delete = "DELETE FROM TEST WHERE ID < ?"
+    Database.create(@parms) do |conn1|
+      conn1.execute(sql_schema)
+      conn1.transaction do
+        10.times do |i|
+          conn1.execute(sql_insert, i, "NAME#{i}")
+        end
+      end
+      Database.connect(@parms) do |conn2|
+        conn2.transaction("READ COMMITTED") do
+          affected = conn1.execute(sql_delete, 5)
+          assert_equal 5, affected
+          rs1 = conn2.query(sql_select)
+          assert_equal 5, rs1.size
+        end
+        rs2 = conn2.query(sql_select)
+        assert_equal 5, rs2.size
+      end
+    end
+  end
+end