sedna 0.2.0 → 0.3.0

data/CHANGES

@@ -1,3 +1,14 @@
+=== 0.3.0
+
+* Released on December 21st, 2008.
+* Compatible with the latest build of \Sedna (3.1.126).
+* Fully tested in Ruby 1.8.5, 1.8.6, 1.8.7, and 1.9.1-preview2. (1.9.0.x does not work.)
+* Sedna#execute no longer blocks other threads in Ruby 1.9. Use Sedna.blocking?
+  to discover if support for non-blocking queries is enabled.
+* Strings in the result Array of Sedna#execute are now properly tainted.
+* Thread-safe in both Ruby 1.8 and Ruby 1.9.
+* Added Sedna.version, which returns the current client protocol version.
+
 === 0.2.0
 
 * Released on December 15th, 2008.

data/README

@@ -32,9 +32,9 @@ limitations under the License.
 
 === Current version
 
-The current version of this library is 0.2.0. This version is a <b>development
-preview</b>. The API may change significantly between minor versions.
-For a complete overview all recent and previous changes, see CHANGES.
+The current version of this library is 0.3.0. This release is a <b>beta version</b>.
+The API may change significantly between minor versions. For a complete overview
+all recent and previous changes, see CHANGES.
 
 === Requirements
 
@@ -43,6 +43,9 @@ header files of the C driver. They are shipped and installed as part of the bina
 distribution of \Sedna. When installing, choose either <tt>/usr/local/sedna</tt> or
 <tt>/opt/sedna</tt> as target locations.
 
+The library has been tested with Ruby 1.8.5 and above, including Ruby 1.9.1
+(preview 2), but excluding Ruby 1.9.0.
+
 === Installation
 
 After installing the \Sedna C driver (see above), simply install the Ruby client

data/Rakefile

@@ -0,0 +1,91 @@
+# Copyright 2008 Voormedia B.V.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Ruby extension library providing a client API to the Sedna native XML
+# database management system, based on the official Sedna C driver.
+
+# This file defines how to build a Rubygem for the Sedna client library.
+
+require 'rubygems'
+require 'rdoc' # Use latest RDoc version.
+require 'rake'
+require 'rake/testtask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+RDOC_TITLE = "Sedna XML DBMS client library for Ruby"
+RDOC_FILES = FileList["[A-Z][A-Z]*", "ext/**/*.c"].to_a
+
+task :default => [:rebuild, :test]
+
+task :multi do
+  exec "export EXCLUDED_VERSIONS=v1_9_0 && multiruby -S rake"
+end
+
+desc "Build the Ruby extension"
+task :build do
+  Dir.chdir "ext"
+  ruby "extconf.rb"
+  sh "make"
+  Dir.chdir ".."
+end
+
+desc "Remove build products"
+task :clobber_build do
+  sh "rm -f ext/*.{so,o,log}"
+  sh "rm -f ext/Makefile"
+end
+
+desc "Force a rebuild of the Ruby extension"
+task :rebuild => [:clobber_build, :build]
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList["test/*_test.rb"]
+  t.verbose = true
+end
+
+gem_spec = Gem::Specification.new do |s|
+  s.name = "sedna"
+  s.version = "0.3.0"
+
+  s.summary = "Sedna XML DBMS client library."
+  s.description = %{Ruby extension that provides a client library for the Sedna XML DBMS, making use of the official C driver of the Sedna project.}
+  s.requirements = %{Sedna XML DBMS C driver (library and headers).}
+  s.author = "Rolf Timmermans"
+  s.email = "r.timmermans@voormedia.com"
+  s.homepage = "http://sedna.rubyforge.org/"
+  s.rubyforge_project = "sedna"
+
+  s.extensions << "ext/extconf.rb"
+  s.files = FileList["Rakefile", "ext/extconf.rb", "ext/**/*.c", "test/**/*.rb"].to_a
+  s.require_path = "lib"
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = RDOC_FILES
+  s.rdoc_options << "--title" << RDOC_TITLE << "--main" << "README"
+  
+  s.test_files = FileList["test/**/*_test.rb"].to_a
+end
+
+Rake::GemPackageTask.new gem_spec do |p|
+  p.gem_spec = gem_spec
+  p.need_tar_gz = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title = RDOC_TITLE
+  rdoc.rdoc_files.include *RDOC_FILES
+}

data/ext/extconf.rb

@@ -68,4 +68,13 @@ passing the -fPIC option to gcc.
   end
 end
 
+if have_func("rb_thread_blocking_region") and !have_func("rb_mutex_synchronize")
+  $stderr.write %{==============================================================================
+This Ruby version incorrectly defines Mutex#synchronize. Please upgrade to a
+newer version of Ruby (1.9.1+).
+==============================================================================
+}
+  exit 5
+end
+
 create_makefile "sedna"

data/ext/sedna.c

@@ -13,33 +13,65 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
+ * ========================================================================
+ *
  * Ruby extension library providing a client API to the Sedna native XML
  * database management system, based on the official Sedna C driver.
  *
  * This file contains the Ruby C-extension.
+ *
+ * ========================================================================
  */
 
 #include <string.h>
 #include "ruby.h"
 #include "libsedna.h"
 
-// Size of the read buffer.
+// Size of the query result read buffer.
 #define RESULT_BUF_LEN 8192
+
+// Size of the load_document buffer.
 #define LOAD_BUF_LEN 8192
 
-// Use macros to fool RDoc and hide some of our methods/aliases.
+// Use this macro to fool RDoc and hide some aliases.
 #define rb_define_undocumented_alias(kl, new, old) rb_define_alias(kl, new, old)
 
 // Macro for verification of return values of the Sedna API + error handling.
-#define verify_res(expected, real, conn) if(real != expected) sedna_err(conn, real)
+#define VERIFY_RES(expected, real, conn) if(real != expected) sedna_err(conn, real)
 
 // Macro for setting autocommit values on connection conn.
-#define sedna_autocommit_on(conn) sedna_autocommit(conn, SEDNA_AUTOCOMMIT_ON)
-#define sedna_autocommit_off(conn) sedna_autocommit(conn, SEDNA_AUTOCOMMIT_OFF)
-#define switch_sedna_autocommit(conn, val) if(val) sedna_autocommit_on(conn); else sedna_autocommit_off(conn)
+#define SEDNA_AUTOCOMMIT_ENABLE(conn) sedna_autocommit(conn, SEDNA_AUTOCOMMIT_ON)
+#define SEDNA_AUTOCOMMIT_DISABLE(conn) sedna_autocommit(conn, SEDNA_AUTOCOMMIT_OFF)
+#define SWITCH_SEDNA_AUTOCOMMIT(conn, val) if(val) SEDNA_AUTOCOMMIT_ENABLE(conn); else SEDNA_AUTOCOMMIT_DISABLE(conn)
+
+// Define the protocol version number as string.
+#define PROTO_STRINGIFY(s) #s
+#define PROTO_TO_STRING(s) PROTO_STRINGIFY(s)
+#define PROTOCOL_VERSION PROTO_TO_STRING(SE_CURRENT_SOCKET_PROTOCOL_VERSION_MAJOR) "." PROTO_TO_STRING(SE_CURRENT_SOCKET_PROTOCOL_VERSION_MINOR)
+
+// Default connection arguments
+#define DEFAULT_HOST "localhost"
+#define DEFAULT_DATABASE "test"
+#define DEFAULT_USER "SYSTEM"
+#define DEFAULT_PASSWORD "MANAGER"
 
+// Define a shorthand for the common SednaConnection structure.
+typedef struct SednaConnection SC;
+
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+	#define NON_BLOCKING
+	#define SEDNA_BLOCKING Qfalse
+
+	struct SednaQuery {
+		void *conn;
+		void *query;
+	};
+	typedef struct SednaQuery SQ;
+#else
+	#define SEDNA_BLOCKING Qtrue
+#endif
 
-// Our classes.
+// Ruby classes.
 static VALUE cSedna;
 //static VALUE cSednaSet; //Unused so far.
 static VALUE cSednaException;
@@ -47,9 +79,8 @@ static VALUE cSednaAuthError;
 static VALUE cSednaConnError;
 static VALUE cSednaTrnError;
 
-// Define a shorthand for the common SednaConnection structure.
-typedef struct SednaConnection SC;
 
+// Common functions =======================================================
 
 // Test the last error message for conn, and raise an exception if there is one.
 // The type of the exception is based on the result of the function that was
@@ -59,6 +90,7 @@ static void sedna_err(SC *conn, int res)
 	VALUE exception;
 	const char *msg;
 	char *err, *details, *p;
+
 	switch(res) {
 		case SEDNA_AUTHENTICATION_FAILED:
 			exception = cSednaAuthError; break;
@@ -73,15 +105,18 @@ static void sedna_err(SC *conn, int res)
 		default:
 			exception = cSednaException;
 	}
+
 	msg = SEgetLastErrorMsg(conn);
 	err = strstr(msg, "\n");
 	details = strstr(err, "\nDetails: ");
+
 	if(err != NULL) {
 		err++;
 		if((p = strstr(err, "\n")) != NULL) strncpy(p, "\0", 1);
 	} else {
 		err = "Unknown error.";
 	}
+
 	if(details != NULL) {
 		details += 10;
 		while((p = strstr(details, "\n")) != NULL) strncpy(p, " ", 1);
@@ -111,12 +146,26 @@ static void sedna_free(SC *conn)
 static void sedna_mark(SC *conn)
 { /* Unused. */ }
 
+#ifdef NON_BLOCKING
+static int sedna_blocking_execute(SQ *q)
+{
+	return SEexecute(q->conn, q->query);
+}
+
+static int sedna_execute(SQ *q)
+{
+	return rb_thread_blocking_region((void*)sedna_blocking_execute, q, RUBY_UBF_IO, NULL);
+}
+#endif
+
 // Read one record completely and return it as a Ruby String object.
 static VALUE sedna_read(SC *conn, int strip_n)
 {
 	int bytes_read = 0;
 	char buffer[RESULT_BUF_LEN];
 	VALUE str = rb_str_buf_new(0);
+	OBJ_TAINT(str);
+
 	do {
 		bytes_read = SEgetData(conn, buffer, RESULT_BUF_LEN - 1);
 		if(bytes_read == SEDNA_ERROR) {
@@ -137,6 +186,7 @@ static VALUE sedna_read(SC *conn, int strip_n)
 			}
 		}
 	} while(bytes_read > 0);
+
 	return str;
 }
 
@@ -145,6 +195,7 @@ static VALUE sedna_get_results(SC *conn)
 {
 	int res, strip_n = 0;
 	VALUE set = rb_ary_new();
+
 	while((res = SEnext(conn)) != SEDNA_RESULT_END) {
 		if(res == SEDNA_ERROR) sedna_err(conn, res);
 		// Set strip_n to 1 for all results except the first. This will cause
@@ -152,6 +203,7 @@ static VALUE sedna_get_results(SC *conn)
 		rb_ary_push(set, sedna_read(conn, strip_n));
 		if(!strip_n) strip_n = 1;
 	};
+
 	return set;
 }
 
@@ -159,37 +211,41 @@ static VALUE sedna_get_results(SC *conn)
 static void sedna_autocommit(SC *conn, int value)
 {
 	int res = SEsetConnectionAttr(conn, SEDNA_ATTR_AUTOCOMMIT, (void *)&value, sizeof(int));
-	verify_res(SEDNA_SET_ATTRIBUTE_SUCCEEDED, res, conn);
+	VERIFY_RES(SEDNA_SET_ATTRIBUTE_SUCCEEDED, res, conn);
 }
 
 // Begin a transaction.
 static void sedna_tr_begin(SC *conn)
 {
 	int res = SEbegin(conn);
-	verify_res(SEDNA_BEGIN_TRANSACTION_SUCCEEDED, res, conn);
+	VERIFY_RES(SEDNA_BEGIN_TRANSACTION_SUCCEEDED, res, conn);
 }
 
 // Commit a transaction.
 static void sedna_tr_commit(SC *conn)
 {
 	int res = SEcommit(conn);
-	verify_res(SEDNA_COMMIT_TRANSACTION_SUCCEEDED, res, conn);
+	VERIFY_RES(SEDNA_COMMIT_TRANSACTION_SUCCEEDED, res, conn);
 }
 
 // Rollback a transaction.
 static void sedna_tr_rollback(SC *conn)
 {
 	int res = SErollback(conn);
-	verify_res(SEDNA_ROLLBACK_TRANSACTION_SUCCEEDED, res, conn);
+	VERIFY_RES(SEDNA_ROLLBACK_TRANSACTION_SUCCEEDED, res, conn);
 }
 
+
+// Functions available from Ruby ==========================================
+
 // Alocates memory for a SednaConnection struct.
 static VALUE cSedna_s_new(VALUE klass)
 {
 	SC *conn, init = SEDNA_CONNECTION_INITIALIZER;
-	conn = (SC *)malloc(sizeof(SC));
+	conn = ALLOC(SC);
 	if(conn == NULL) rb_raise(rb_eNoMemError, "Could not allocate memory.");
 	memcpy(conn, &init, sizeof(init));
+
 	return Data_Wrap_Struct(klass, sedna_mark, sedna_free, conn);
 }
 
@@ -210,10 +266,10 @@ static VALUE cSedna_initialize(VALUE self, VALUE options)
 	user_k = ID2SYM(rb_intern("username"));
 	pw_k = ID2SYM(rb_intern("password"));
 
-	if(NIL_P(host_v = rb_hash_aref(options, host_k))) host = "localhost"; else host = STR2CSTR(host_v);
-	if(NIL_P(db_v = rb_hash_aref(options, db_k))) db = "test"; else db = STR2CSTR(db_v);
-	if(NIL_P(user_v = rb_hash_aref(options, user_k))) user = "SYSTEM"; else user = STR2CSTR(user_v);
-	if(NIL_P(pw_v = rb_hash_aref(options, pw_k))) pw = "MANAGER"; else pw = STR2CSTR(pw_v);
+	if(NIL_P(host_v = rb_hash_aref(options, host_k))) host = DEFAULT_HOST; else host = STR2CSTR(host_v);
+	if(NIL_P(db_v = rb_hash_aref(options, db_k))) db = DEFAULT_DATABASE; else db = STR2CSTR(db_v);
+	if(NIL_P(user_v = rb_hash_aref(options, user_k))) user = DEFAULT_USER; else user = STR2CSTR(user_v);
+	if(NIL_P(pw_v = rb_hash_aref(options, pw_k))) pw = DEFAULT_PASSWORD; else pw = STR2CSTR(pw_v);
 
 	res = SEconnect(conn, host, db, user, pw);
 	if(res != SEDNA_SESSION_OPEN) {
@@ -230,6 +286,10 @@ static VALUE cSedna_initialize(VALUE self, VALUE options)
 	// Initialize @autocommit to true (default argument).
 	rb_iv_set(self, "@autocommit", Qtrue);
 
+#ifdef NON_BLOCKING
+	rb_iv_set(self, "@mutex", rb_mutex_new());
+#endif
+
 	return self;
 }
 
@@ -245,10 +305,12 @@ static VALUE cSedna_close(VALUE self)
 {
 	int res;
 	SC *conn = sedna_struct(self);
+
 	if(SEconnectionStatus(conn) != SEDNA_CONNECTION_CLOSED) {
 		res = SEclose(conn);
-		verify_res(SEDNA_SESSION_CLOSED, res, conn);
+		VERIFY_RES(SEDNA_SESSION_CLOSED, res, conn);
 	}
+
 	return Qnil;
 }
 
@@ -292,16 +354,43 @@ static VALUE cSedna_s_connect(VALUE klass, VALUE options)
 {
 	int status;
 	VALUE obj = rb_funcall(klass, rb_intern("new"), 1, options);
+
 	if(rb_block_given_p()) {
 		rb_protect(rb_yield, obj, &status);
 		cSedna_close(obj);
 		if(status != 0) rb_jump_tag(status); // Re-raise any exception.
+
 		return Qnil;
 	} else {
 		return obj;
 	}
 }
 
+/*
+ * call-seq:
+ *   Sedna.version -> string
+ *
+ * Returns the current version of the Sedna client protocol.
+ */
+static VALUE cSedna_s_version(VALUE klass)
+{
+	return rb_str_new2(PROTOCOL_VERSION);
+}
+
+/*
+ * call-seq:
+ *   Sedna.blocking? -> true or false
+ *
+ * Returns +true+ if querying the database with Sedna#execute will block other
+ * threads. Returns +false+ if multiple queries can be run in different threads
+ * simultaneously. \Sedna will not block other threads when compiled against
+ * Ruby 1.9.
+ */
+static VALUE cSedna_s_blocking(VALUE klass)
+{
+	return SEDNA_BLOCKING;
+}
+
 /*
  * call-seq:
  *   sedna.execute(query) -> array or nil
@@ -314,6 +403,12 @@ static VALUE cSedna_s_connect(VALUE klass, VALUE options)
  * query on a closed connection, a Sedna::ConnectionError will be raised. A
  * Sedna::Exception is raised if the query fails or is invalid.
  *
+ * This method does not block other threads in Ruby 1.9 -- database queries that
+ * are run in different threads with different connections will run concurrently.
+ * You can use Sedna.blocking? to verify if the extension supports non-blocking
+ * behaviour. Database queries run from different threads, but on the same
+ * connection will still block and be executed serially.
+ *
  * ==== Examples
  *
  * Create a new document.
@@ -336,8 +431,18 @@ static VALUE cSedna_execute(VALUE self, VALUE query)
 {
 	int res;
 	SC *conn = sedna_struct(self);
+
 	if(SEconnectionStatus(conn) != SEDNA_CONNECTION_OK) rb_raise(cSednaConnError, "Connection is closed.");
+
+#ifdef NON_BLOCKING
+	// Non-blocking variant for >= 1.9.
+	SQ q = { conn, STR2CSTR(query) };
+	res = rb_mutex_synchronize(rb_iv_get(self, "@mutex"), (void*)sedna_execute, (VALUE)&q);
+#else
+	// Blocking variant for < 1.9.
 	res = SEexecute(conn, STR2CSTR(query));
+#endif
+
 	switch(res) {
 		case SEDNA_QUERY_SUCCEEDED:
 			return sedna_get_results(conn);
@@ -384,23 +489,30 @@ static VALUE cSedna_load_document(int argc, VALUE *argv, VALUE self)
 	SC *conn = sedna_struct(self);
 	VALUE document, doc_name, col_name, buf;
 	char *doc_name_c, *col_name_c;
+
 	if(SEconnectionStatus(conn) != SEDNA_CONNECTION_OK) rb_raise(cSednaConnError, "Connection is closed.");
+
 	rb_scan_args(argc, argv, "21", &document, &doc_name, &col_name); // 2 mandatory args, 1 optional.
 	doc_name_c = STR2CSTR(doc_name);
 	col_name_c = NIL_P(col_name) ? NULL : STR2CSTR(col_name);
+
 	if(TYPE(document) == T_FILE) {
 		while(!NIL_P(buf = rb_funcall(document, rb_intern("read"), 1, INT2NUM(LOAD_BUF_LEN)))) {
 			res = SEloadData(conn, STR2CSTR(buf), RSTRING_LEN(buf), doc_name_c, col_name_c);
-			verify_res(SEDNA_DATA_CHUNK_LOADED, res, conn);
+			VERIFY_RES(SEDNA_DATA_CHUNK_LOADED, res, conn);
 		}
 		if(res == 0) rb_raise(cSednaException, "Document is empty.");
 	} else {
+		Check_Type(document, T_STRING);
 		if(RSTRING_LEN(document) == 0) rb_raise(cSednaException, "Document is empty.");
+
 		res = SEloadData(conn, STR2CSTR(document), RSTRING_LEN(document), doc_name_c, col_name_c);
-		verify_res(SEDNA_DATA_CHUNK_LOADED, res, conn);
+		VERIFY_RES(SEDNA_DATA_CHUNK_LOADED, res, conn);
 	}
+
 	res = SEendLoadData(conn);
-	verify_res(SEDNA_BULK_LOAD_SUCCEEDED, res, conn);
+	VERIFY_RES(SEDNA_BULK_LOAD_SUCCEEDED, res, conn);
+
 	return Qnil;
 }
 
@@ -412,8 +524,10 @@ static VALUE cSedna_autocommit_set(VALUE self, VALUE auto_commit)
 {
 	int val = (RTEST(auto_commit) ? Qtrue : Qfalse);
 	SC *conn = sedna_struct(self);
-	switch_sedna_autocommit(conn, val);
+
+	SWITCH_SEDNA_AUTOCOMMIT(conn, val);
 	rb_iv_set(self, "@autocommit", val);
+
 	return Qnil;
 }
 
@@ -442,6 +556,11 @@ static VALUE cSedna_autocommit_get(VALUE self)
  * \transaction fails to be committed, a Sedna::TransactionError will
  * be raised. 
  *
+ * Transactions cannot be nested or executed simultaneously with the same connection.
+ * Calling this method inside a block that is passed to another transaction, or
+ * with the same connection in two concurrent threads will raise a
+ * Sedna::TransactionError on the second invocation.
+ *
  * ==== Examples
  *
  *   sedna.transaction do
@@ -462,23 +581,33 @@ static VALUE cSedna_transaction(VALUE self)
 {
 	int status;
 	SC *conn = sedna_struct(self);
-	sedna_autocommit_off(conn);
+
+	SEDNA_AUTOCOMMIT_DISABLE(conn);
 	sedna_tr_begin(conn);
+
 	rb_protect(rb_yield, Qnil, &status);
+
 	if(status == 0) {
 		// Attempt to commit.
 		if(SEtransactionStatus(conn) == SEDNA_TRANSACTION_ACTIVE) sedna_tr_commit(conn);
 		else rb_raise(cSednaTrnError, "The transaction was prematurely ended, but no error was encountered. Did you rescue an exception inside the transaction?");
-		switch_sedna_autocommit(conn, rb_iv_get(self, "@autocommit"));
+
+		SWITCH_SEDNA_AUTOCOMMIT(conn, rb_iv_get(self, "@autocommit"));
 	} else {
 		// Stack has unwinded, attempt to roll back.
 		if(SEtransactionStatus(conn) == SEDNA_TRANSACTION_ACTIVE) sedna_tr_rollback(conn);
-		switch_sedna_autocommit(conn, rb_iv_get(self, "@autocommit"));
+
+		SWITCH_SEDNA_AUTOCOMMIT(conn, rb_iv_get(self, "@autocommit"));
+
 		rb_jump_tag(status); // Re-raise exception.
 	}
+
 	return Qnil;
 }
 
+
+// Initialize the extension ==============================================
+
 void Init_sedna()
 {
 	/*
@@ -500,13 +629,19 @@ void Init_sedna()
 	 * See the README for a high-level overview of how to use this library.
 	 */
 	cSedna = rb_define_class("Sedna", rb_cObject);
+
 	rb_define_alloc_func(cSedna, cSedna_s_new);
 	rb_define_singleton_method(cSedna, "connect", cSedna_s_connect, 1);
+	rb_define_singleton_method(cSedna, "version", cSedna_s_version, 0);
+	rb_define_singleton_method(cSedna, "blocking?", cSedna_s_blocking, 0);
+
 	rb_define_method(cSedna, "initialize", cSedna_initialize, 1);
 	rb_define_method(cSedna, "execute", cSedna_execute, 1);
 	rb_define_method(cSedna, "load_document", cSedna_load_document, -1);
-	rb_define_undocumented_alias(cSedna, "query", "execute");
 	rb_define_method(cSedna, "close", cSedna_close, 0);
+	rb_define_method(cSedna, "transaction", cSedna_transaction, 0);
+
+	rb_define_undocumented_alias(cSedna, "query", "execute");
 
 	/*
 	 * Document-attr: autocommit
@@ -527,7 +662,6 @@ void Init_sedna()
 	 */
 	rb_define_method(cSedna, "autocommit=", cSedna_autocommit_set, 1);
 	rb_define_method(cSedna, "autocommit", cSedna_autocommit_get, 0);
-	rb_define_method(cSedna, "transaction", cSedna_transaction, 0);
 
 	/*
 	 * The result set of a database query.

data/test/sedna_test.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# encoding: utf-8
 
 # Copyright 2008 Voormedia B.V.
 # 
@@ -27,6 +28,23 @@ require 'sedna'
 require 'socket'
 
 class SednaTest < Test::Unit::TestCase
+  # Support declarative specification of test methods.
+  def self.test name, &block
+    test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+    defined = instance_method(test_name) rescue false
+    raise "#{test_name} is already defined in #{self}" if defined
+    if block_given?
+      define_method test_name, &block
+    else
+      define_method test_name do
+        flunk "No implementation provided for #{test_name}"
+      end
+    end
+  end
+
+  alias :__method__ :method_name if method_defined? :method_name
+  
+  # Setup.
   def setup
     @connection = {
       :database => "test",
@@ -35,13 +53,10 @@ class SednaTest < Test::Unit::TestCase
       :password => "MANAGER",
     }
   end
-  
-  def teardown
-  end
 
   # Faux test that just checks if we can connect, otherwise the test
   # suite is aborted.
-  def test_aaa_connection
+  test "aaa connection" do
     port = 5050
     begin
       s = TCPSocket.new @connection[:host], port
@@ -54,26 +69,46 @@ class SednaTest < Test::Unit::TestCase
     s.close
   end
   
+  # Test Sedna.version.
+  test "version should return 3 0" do
+    assert_equal "3.0", Sedna.version
+  end
+  
+  # Test Sedna.blocking?
+  test "blocking should return true if ruby 18 and false if ruby 19" do
+    if RUBY_VERSION < "1.9"
+      assert Sedna.blocking?
+    else
+      assert !Sedna.blocking?
+    end
+  end
+  
   # Test Sedna.connect.
-  def test_connect_should_return_sedna_object
+  test "connect should return Sedna object" do
     sedna = Sedna.connect @connection
     assert_kind_of Sedna, sedna
     sedna.close
   end
+  
+  test "connect should raise TypeError if argument is not a Hash" do
+    assert_raises TypeError do
+      sedna = Sedna.connect Object.new
+    end
+  end
 
-  def test_connect_should_raise_exception_when_host_not_found
+  test "connect should raise exception when host not found" do
     assert_raises Sedna::ConnectionError do
       Sedna.connect @connection.merge(:host => "non-existent-host")
     end
   end
 
-  def test_connect_should_raise_exception_when_credentials_are_incorrect
+  test "connect should raise exception when credentials are incorrect" do
     assert_raises Sedna::AuthenticationError do
       Sedna.connect @connection.merge(:username => "non-existent-user")
     end
   end
   
-  def test_connect_should_return_nil_on_error
+  test "connect should return nil on error" do
     begin
       sedna = Sedna.connect @connection.merge(:username => "non-existent-user")
     rescue
@@ -81,12 +116,12 @@ class SednaTest < Test::Unit::TestCase
     assert_nil sedna
   end
   
-  def test_connect_should_return_nil_if_block_given
+  test "connect should return nil if block given" do
     sedna = Sedna.connect @connection do |s| end
     assert_nil sedna
   end
   
-  def test_connect_should_close_connection_after_block
+  test "connect should close connection after block" do
     sedna = nil
     Sedna.connect @connection do |s|
       sedna = s
@@ -96,7 +131,7 @@ class SednaTest < Test::Unit::TestCase
     end
   end
   
-  def test_connect_should_close_connection_if_exception_is_raised_inside_block
+  test "connect should close connection if exception is raised inside block" do
     sedna = nil
     begin
       Sedna.connect @connection do |s|
@@ -110,7 +145,7 @@ class SednaTest < Test::Unit::TestCase
     end
   end
   
-  def test_connect_should_close_connection_if_something_is_thrown_inside_block
+  test "connect should close connection if something is thrown inside block" do
     sedna = nil
     catch :ball do
       Sedna.connect @connection do |s|
@@ -123,7 +158,7 @@ class SednaTest < Test::Unit::TestCase
     end
   end
   
-  def test_connect_should_reraise_exceptions_from_inside_block
+  test "connect should re-raise exceptions from inside block" do
     assert_raises Exception do
       Sedna.connect @connection do
         raise Exception
@@ -132,12 +167,12 @@ class SednaTest < Test::Unit::TestCase
   end
   
   # Test sedna.close.
-  def test_close_should_return_nil
+  test "close should return nil" do
     sedna = Sedna.connect @connection
     assert_nil sedna.close
   end
 
-  def test_close_should_fail_silently_if_connection_is_already_closed
+  test "close should fail silently if connection is already closed" do
     sedna = Sedna.connect @connection
     assert_nothing_raised do
       sedna.close
@@ -146,34 +181,47 @@ class SednaTest < Test::Unit::TestCase
   end
   
   # Test sedna.execute / sedna.query.
-  def test_execute_should_return_nil_for_data_structure_query
+  test "execute should raise TypeError if argument cannot be converted to String" do
+    Sedna.connect @connection do |sedna|
+      assert_raises TypeError do
+        sedna.execute Object.new
+      end
+    end
+  end
+  
+  test "execute should return nil for data structure query" do
     Sedna.connect @connection do |sedna|
-      name = "test_execute_should_return_nil_for_create_document_query"
-      sedna.execute("drop document '#{name}'") rescue Sedna::Exception
-      assert_nil sedna.execute("create document '#{name}'")
-      sedna.execute("drop document '#{name}'") rescue Sedna::Exception
+      sedna.execute("drop document '#{__method__}'") rescue Sedna::Exception
+      assert_nil sedna.execute("create document '#{__method__}'")
+      sedna.execute("drop document '#{__method__}'") rescue Sedna::Exception
     end
   end
   
-  def test_execute_should_return_array_for_select_query
+  test "execute should return array for select query" do
     Sedna.connect @connection do |sedna|
       assert_kind_of Array, sedna.execute("<test/>")
     end
   end
   
-  def test_execute_should_return_array_with_single_string_for_single_select_query
+  test "execute should return array with single string for single select query" do
     Sedna.connect @connection do |sedna|
       assert_equal ["<test/>"], sedna.execute("<test/>")
     end
   end
   
-  def test_execute_should_return_array_with_strings_for_select_query
+  test "execute should return array with strings for select query" do
     Sedna.connect @connection do |sedna|
       assert_equal ["<test/>", "<test/>", "<test/>"], sedna.execute("<test/>, <test/>, <test/>")
     end
   end
+  
+  test "execute should return tainted strings" do
+    Sedna.connect @connection do |sedna|
+      assert sedna.execute("<test/>").first.tainted?
+    end
+  end
 
-  def test_execute_should_fail_if_autocommit_is_false
+  test "execute should fail if autocommit is false" do
     Sedna.connect @connection do |sedna|
       sedna.autocommit = false
       assert_raises Sedna::Exception do
@@ -182,7 +230,7 @@ class SednaTest < Test::Unit::TestCase
     end
   end
   
-  def test_execute_should_fail_with_sedna_exception_for_invalid_statments
+  test "execute should fail with Sedna::Exception for invalid statements" do
     Sedna.connect @connection do |sedna|
       assert_raises Sedna::Exception do
         sedna.execute "INVALID"
@@ -190,7 +238,7 @@ class SednaTest < Test::Unit::TestCase
     end
   end
   
-  def test_execute_should_fail_with_sedna_connection_error_if_connection_is_closed
+  test "execute should fail with Sedna::ConnectionError if connection is closed" do
     Sedna.connect @connection do |sedna|
       sedna.close
       assert_raises Sedna::ConnectionError do
@@ -199,73 +247,165 @@ class SednaTest < Test::Unit::TestCase
     end
   end
   
-  def test_execute_should_strip_first_newline_of_all_but_first_results
+  test "execute should strip first newline of all but first results" do
+    Sedna.connect @connection do |sedna|
+      sedna.execute("drop document '#{__method__}'") rescue Sedna::Exception
+      sedna.execute("create document '#{__method__}'")
+      sedna.execute("update insert <test><a>\n\nt</a><a>\n\nt</a><a>\n\nt</a></test> into doc('#{__method__}')")
+      assert_equal ["\n\nt", "\n\nt", "\n\nt"], sedna.execute("doc('#{__method__}')/test/a/text()")
+      sedna.execute("drop document '#{__method__}'") rescue Sedna::Exception
+    end
+  end
+
+  test "execute should block other threads for ruby 18 and not block for ruby 19" do
+    n = 5 # Amount of threads to be run. Increase for more accuracy.
+    i = 10000 # Times to loop in query. Increase for more accuracy.
+    threads = []
+    start_times = {}
+    end_times = {}
+    n.times do |number|
+      threads << Thread.new do
+        Sedna.connect @connection do |sedna|
+          start_times[number] = Time.now
+          sedna.execute "for $x in 1 to #{i} where $x = 1 return <node/>"
+          end_times[number] = Time.now
+        end
+      end
+    end
+    threads.each do |thread| thread.join end
+    # Count the amount of time that is overlapped between threads. If the execute
+    # method blocks, there should be hardly any overlap.
+    time_diff = 0
+    (n - 1).times do |number|
+      time_diff += start_times[number + 1] - end_times[number]
+    end
+    if RUBY_VERSION < "1.9"
+      # Blocking behaviour. The start/end times of two threads should not overlap.
+      assert time_diff > 0
+    else
+      # We have concurrency, the execute method in the threads should have been
+      # run in parallel and there should be considerable overlap in the start/end
+      # times of the executed threads.
+      assert time_diff < 0
+    end
+  end
+  
+  test "execute should be run in serially if called from different threads on same connection" do
+    Sedna.connect @connection do |sedna|
+      i = 1000
+      threads = []
+      exceptions = []
+      Thread.abort_on_exception = true
+      5.times do
+        threads << Thread.new do
+          begin
+            sedna.execute "for $x in #{i} where $x = 1 return <node/>"
+          rescue StandardError => e
+            exceptions << e
+          end
+        end
+      end
+      threads.each do |thread| thread.join end
+      assert_equal [], exceptions
+    end
+  end
+  
+  test "execute should quit if exception is raised in it by another thread in ruby 19" do
     Sedna.connect @connection do |sedna|
-      name = "test_execute_should_strip_first_newline_of_all_but_first_results"
-      sedna.execute("drop document '#{name}'") rescue Sedna::Exception
-      sedna.execute("create document '#{name}'")
-      sedna.execute("update insert <test><a>\n\nt</a><a>\n\nt</a><a>\n\nt</a></test> into doc('#{name}')")
-      assert_equal ["\n\nt", "\n\nt", "\n\nt"], sedna.execute("doc('#{name}')/test/a/text()")
-      sedna.execute("drop document '#{name}'") rescue Sedna::Exception
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
+      begin
+        thread = Thread.new do
+          sedna.execute "create document '#{__method__}'"
+        end
+        thread.raise
+        thread.join
+      rescue
+      end
+      count = sedna.execute("count(doc('$documents')//*[@name='#{__method__}'])").first.to_i
+      if RUBY_VERSION < "1.9"
+        assert_equal 1, count
+      else
+        assert_equal 0, count
+      end
     end
   end
   
-  def test_query_should_be_alias_of_execute
+  test "query should be alias of execute" do
     Sedna.connect @connection do |sedna|
       assert_equal ["<test/>"], sedna.query("<test/>")
     end
   end
 
   # Test sedna.load_document.
-  def test_load_document_should_create_document_in_given_collection
+  test "load_document should raise TypeError if document argument cannot be converted to String" do
+    Sedna.connect @connection do |sedna|
+      assert_raises TypeError do
+        sedna.load_document Object.new, __method__.to_s
+      end
+    end
+  end
+
+  test "load_document should raise TypeError if doc_name argument cannot be converted to String" do
+    Sedna.connect @connection do |sedna|
+      assert_raises TypeError do
+        sedna.load_document "<doc/>", Object.new
+      end
+    end
+  end
+
+  test "load_document should raise TypeError if col_name argument cannot be converted to String" do
+    Sedna.connect @connection do |sedna|
+      assert_raises TypeError do
+        sedna.load_document "<doc/>", __method__.to_s, Object.new
+      end
+    end
+  end
+
+  test "load_document should create document in given collection" do
     Sedna.connect @connection do |sedna|
-      name = "test_load_document_should_create_document_in_given_collection"
       col = "test_collection"
       doc = "<?xml version=\"1.0\" standalone=\"yes\"?><document>\n <node/>\n</document>"
 
       sedna.execute "create collection '#{col}'" rescue Sedna::Exception
-      sedna.execute "drop document '#{name}' in collection '#{col}'" rescue Sedna::Exception
-      sedna.load_document doc, name, col
-      assert_equal doc, sedna.execute("doc('#{name}', '#{col}')").first
-      sedna.execute "drop document '#{name}' in collection '#{col}'" rescue Sedna::Exception
+      sedna.execute "drop document '#{__method__}' in collection '#{col}'" rescue Sedna::Exception
+      sedna.load_document doc, __method__.to_s, col
+      assert_equal doc, sedna.execute("doc('#{__method__}', '#{col}')").first
+      sedna.execute "drop document '#{__method__}' in collection '#{col}'" rescue Sedna::Exception
       sedna.execute "drop collection '#{col}'" rescue Sedna::Exception
     end
   end
 
-  def test_load_document_should_create_standalone_document_if_collection_is_unspecified
+  test "load_document should create standalone document if collection is unspecified" do
     Sedna.connect @connection do |sedna|
-      name = "test_load_document_should_create_standalone_document_if_collection_is_unspecified"
       doc = "<?xml version=\"1.0\" standalone=\"yes\"?><document>\n <node/>\n</document>"
 
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
-      sedna.load_document doc, name
-      assert_equal doc, sedna.execute("doc('#{name}')").first
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
+      sedna.load_document doc, __method__.to_s
+      assert_equal doc, sedna.execute("doc('#{__method__}')").first
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
     end
   end
   
-  def test_load_document_should_create_standalone_document_if_collection_is_nil
+  test "load_document should create standalone document if collection is nil" do
     Sedna.connect @connection do |sedna|
-      name = "test_load_document_should_create_standalone_document_if_collection_is_unspecified"
       doc = "<?xml version=\"1.0\" standalone=\"yes\"?><document>\n <node/>\n</document>"
 
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
-      sedna.load_document doc, name, nil
-      assert_equal doc, sedna.execute("doc('#{name}')").first
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
+      sedna.load_document doc, __method__.to_s, nil
+      assert_equal doc, sedna.execute("doc('#{__method__}')").first
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
     end
   end
   
-  def test_load_document_should_return_nil_if_standalone_document_loaded_successfully
+  test "load_document should return nil if standalone document loaded successfully" do
     Sedna.connect @connection do |sedna|
-      name = "test_load_document_should_return_nil_if_document_loaded_successfully"
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
-      assert_nil sedna.load_document("<document><node/></document>", name)
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
+      assert_nil sedna.load_document("<document><node/></document>", __method__.to_s)
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
     end
   end
 
-  def test_load_document_should_fail_if_autocommit_is_false
+  test "load_document should fail if autocommit is false" do
     Sedna.connect @connection do |sedna|
       sedna.autocommit = false
       assert_raises Sedna::Exception do
@@ -274,7 +414,7 @@ class SednaTest < Test::Unit::TestCase
     end
   end
   
-  def test_load_document_should_fail_with_sedna_exception_for_invalid_documents
+  test "load_document should fail with Sedna::Exception for invalid documents" do
     Sedna.connect @connection do |sedna|
       assert_raises Sedna::Exception do
         sedna.load_document "<doc/> this is an invalid document", "some_doc"
@@ -282,7 +422,7 @@ class SednaTest < Test::Unit::TestCase
     end
   end
   
-  def test_load_document_should_raise_exception_with_complete_details_for_invalid_documents
+  test "load_document should raise exception with complete details for invalid documents" do
     Sedna.connect @connection do |sedna|
       e = nil
       begin
@@ -293,7 +433,7 @@ class SednaTest < Test::Unit::TestCase
     end
   end
   
-  def test_load_document_should_fail_with_sedna_connection_error_if_connection_is_closed
+  test "load_document should fail with Sedna::ConnectionError if connection is closed" do
     Sedna.connect @connection do |sedna|
       sedna.close
       assert_raises Sedna::ConnectionError do
@@ -302,74 +442,71 @@ class SednaTest < Test::Unit::TestCase
     end
   end
 
-  def test_load_document_should_create_document_if_given_document_is_io_object
+  test "load_document should create document if given document is IO object" do
     Sedna.connect @connection do |sedna|
-      name = "test_load_document_should_create_document_if_given_document_is_io_object"
       doc = "<?xml version=\"1.0\" standalone=\"yes\"?><document>" << ("\n <some_very_often_repeated_node/>" * 800) << "\n</document>"
       p_out, p_in = IO.pipe
       p_in.write doc
       p_in.close
 
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
-      sedna.load_document p_out, name, nil
-      assert_equal doc.length, sedna.execute("doc('#{name}')").first.length
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
+      sedna.load_document p_out, __method__.to_s, nil
+      assert_equal doc.length, sedna.execute("doc('#{__method__}')").first.length
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
     end
   end
 
-  def test_load_document_should_raise_sedna_exception_if_given_document_is_empty_io_object
+  test "load_document should raise Sedna::Exception if given document is empty IO object" do
     Sedna.connect @connection do |sedna|
-      name = "test_load_document_should_raise_sedna_exception_if_given_document_is_empty_io_object"
       p_out, p_in = IO.pipe
       p_in.close
 
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
       e = nil
       begin
-        sedna.load_document p_out, name, nil
+        sedna.load_document p_out, __method__.to_s, nil
       rescue Sedna::Exception => e
       end
       assert_equal "Document is empty.", e.message
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
     end
   end
 
-  def test_load_document_should_raise_sedna_exception_if_given_document_is_empty_string
+  test "load_document should raise Sedna::Exception if given document is empty string" do
     Sedna.connect @connection do |sedna|
-      name = "test_load_document_should_raise_sedna_exception_if_given_document_is_empty_string"
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
       e = nil
       begin
-        sedna.load_document "", name, nil
+        sedna.load_document "", __method__.to_s, nil
       rescue Sedna::Exception => e
       end
       assert_equal "Document is empty.", e.message
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
     end
   end
   
   # Test sedna.autocommit= / sedna.autocommit.
-  def test_autocommit_should_return_true_by_default
+  test "autocommit should return true by default" do
     Sedna.connect @connection do |sedna|
       assert_equal true, sedna.autocommit
     end
   end
   
-  def test_autocommit_should_return_true_if_set_to_true
+  test "autocommit should return true if set to true" do
     Sedna.connect @connection do |sedna|
       sedna.autocommit = true
       assert_equal true, sedna.autocommit
     end
   end
   
-  def test_autocommit_should_return_false_if_set_to_false
+  test "autocommit should return false if set to false" do
     Sedna.connect @connection do |sedna|
       sedna.autocommit = false
       assert_equal false, sedna.autocommit
     end
   end
   
-  def test_autocommit_should_return_true_if_set_to_true_after_being_set_to_false
+  test "autocommit should return true if set to true after being set to false" do
     Sedna.connect @connection do |sedna|
       sedna.autocommit = false
       sedna.autocommit = true
@@ -377,21 +514,21 @@ class SednaTest < Test::Unit::TestCase
     end
   end
   
-  def test_autocommit_should_return_true_if_argument_evaluates_to_true
+  test "autocommit should return true if argument evaluates to true" do
     Sedna.connect @connection do |sedna|
       sedna.autocommit = "string evaluates to true"
       assert_equal true, sedna.autocommit
     end
   end
   
-  def test_autocommit_should_return_false_if_argument_evaluates_to_false
+  test "autocommit should return false if argument evaluates to false" do
     Sedna.connect @connection do |sedna|
       sedna.autocommit = nil
       assert_equal false, sedna.autocommit
     end
   end
   
-  def test_autocommit_should_be_reenabled_after_transactions
+  test "autocommit should be re-enabled after transactions" do
     Sedna.connect @connection do |sedna|
       sedna.autocommit = true
       sedna.transaction do end
@@ -402,13 +539,13 @@ class SednaTest < Test::Unit::TestCase
   end
   
   # Test sedna.transaction.
-  def test_transaction_should_return_nil_if_committed
+  test "transaction should return nil if committed" do
     Sedna.connect @connection do |sedna|
       assert_nil sedna.transaction(){}
     end
   end
   
-  def test_transaction_should_raise_localjumperror_if_no_block_is_given
+  test "transaction should raise LocalJumpError if no block is given" do
     assert_raises LocalJumpError do
       Sedna.connect @connection do |sedna|
         sedna.transaction
@@ -416,7 +553,7 @@ class SednaTest < Test::Unit::TestCase
     end
   end
   
-  def test_transaction_should_be_possible_with_autocommit
+  test "transaction should be possible with autocommit" do
     Sedna.connect @connection do |sedna|
       sedna.autocommit = true
       assert_nothing_raised do
@@ -425,9 +562,9 @@ class SednaTest < Test::Unit::TestCase
     end
   end
   
-  def test_transaction_should_fail_with_transaction_error_if_another_transaction_is_started_inside_it
-    assert_raises Sedna::TransactionError do
-      Sedna.connect @connection do |sedna|
+  test "transaction should fail with Sedna::TransactionError if another transaction is started inside it" do
+    Sedna.connect @connection do |sedna|
+      assert_raises Sedna::TransactionError do
         sedna.transaction do
           sedna.transaction do end
         end
@@ -435,52 +572,52 @@ class SednaTest < Test::Unit::TestCase
     end
   end
   
-  def test_transaction_should_commit_if_block_given
+  test "transaction should commit if block given" do
     Sedna.connect @connection do |sedna|
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
-      sedna.execute "create document '#{name}'"
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
+      sedna.execute "create document '#{__method__}'"
       sedna.transaction do
-        sedna.execute "update insert <test>test</test> into doc('#{name}')"
+        sedna.execute "update insert <test>test</test> into doc('#{__method__}')"
       end
-      assert_equal 1, sedna.execute("count(doc('#{name}')/test)").first.to_i
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
+      assert_equal 1, sedna.execute("count(doc('#{__method__}')/test)").first.to_i
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
     end
   end
 
-  def test_transaction_should_rollback_if_exception_is_raised_inside_block
+  test "transaction should rollback if exception is raised inside block" do
     Sedna.connect @connection do |sedna|
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
-      sedna.execute "create document '#{name}'"
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
+      sedna.execute "create document '#{__method__}'"
       begin
         sedna.transaction do
-          sedna.execute "update insert <test>test</test> into doc('#{name}')"
+          sedna.execute "update insert <test>test</test> into doc('#{__method__}')"
           raise Exception
         end
       rescue Exception
       end
-      assert_equal 0, sedna.execute("count(doc('#{name}')/test)").first.to_i
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
+      assert_equal 0, sedna.execute("count(doc('#{__method__}')/test)").first.to_i
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
     end
   end
 
-  def test_transaction_should_rollback_if_something_is_thrown_inside_block
+  test "transaction should rollback if something is thrown inside block" do
     Sedna.connect @connection do |sedna|
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
-      sedna.execute "create document '#{name}'"
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
+      sedna.execute "create document '#{__method__}'"
       catch :ball do
         sedna.transaction do
-          sedna.execute "update insert <test>test</test> into doc('#{name}')"
+          sedna.execute "update insert <test>test</test> into doc('#{__method__}')"
           throw :ball
         end
       end
-      assert_equal 0, sedna.execute("count(doc('#{name}')/test)").first.to_i
-      sedna.execute "drop document '#{name}'" rescue Sedna::Exception
+      assert_equal 0, sedna.execute("count(doc('#{__method__}')/test)").first.to_i
+      sedna.execute "drop document '#{__method__}'" rescue Sedna::Exception
     end
   end
 
-  def test_transaction_should_raise_transaction_error_if_invalid_statement_caused_exception_but_it_was_rescued
-    assert_raises Sedna::TransactionError do
-      Sedna.connect @connection do |sedna|
+  test "transaction should raise Sedna::TransactionError if invalid statement caused exception but it was rescued" do
+    Sedna.connect @connection do |sedna|
+      assert_raises Sedna::TransactionError do
         sedna.transaction do
           sedna.execute "FAILS" rescue Sedna::Exception
         end
@@ -488,7 +625,7 @@ class SednaTest < Test::Unit::TestCase
     end
   end
   
-  def test_transaction_should_reraise_exceptions_from_inside_block
+  test "transaction should re-raise exceptions from inside block" do
     Sedna.connect @connection do |sedna|
       assert_raises Exception do
         sedna.transaction do
@@ -498,7 +635,7 @@ class SednaTest < Test::Unit::TestCase
     end
   end
 
-  def test_transaction_with_invalid_statements_should_cause_transaction_to_roll_back_once
+  test "transaction with invalid statements should cause transaction to roll back once" do
     exc = nil
     begin
       Sedna.connect @connection do |sedna|
@@ -510,4 +647,25 @@ class SednaTest < Test::Unit::TestCase
     end
     assert_equal "It is a dynamic error if evaluation of an expression relies on some part of the dynamic context that has not been assigned a value.", exc.message
   end
+  
+  test "transaction should raise Sedna::TransactionError if called from different threads on same connection" do
+    Sedna.connect @connection do |sedna|
+      threads = []
+      exceptions = []
+      Thread.abort_on_exception = true
+      5.times do
+        threads << Thread.new do
+          begin
+            sedna.transaction do
+              sleep 0.1
+            end
+          rescue StandardError => e
+            exceptions << e.class
+          end
+        end
+      end
+      threads.each do |thread| thread.join end
+      assert_equal [Sedna::TransactionError] * 4, exceptions
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sedna
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Rolf Timmermans
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-15 00:00:00 +01:00
+date: 2008-12-21 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -24,6 +24,7 @@ extra_rdoc_files:
 - README
 - ext/sedna.c
 files: 
+- Rakefile
 - ext/extconf.rb
 - ext/sedna.c
 - test/sedna_test.rb