fb 0.5.5 → 0.5.9

data/README

@@ -216,3 +216,17 @@ Change Log
 2007-12-11
 
 * Properly scaled NUMERIC and DECIMAL types when inserting with parameters.
+
+2007-12-13
+
+* Rounded instead of flooring NUMERIC and DECIMAL types.
+* Replace deprecated isc_interprete method call for FB2.
+
+2008-04-22
+
+* Implement explicit end-of-data flag for cursors to avoid synchronization error in newer Firebird builds.
+* Allocated longer buffers to avoid memory access error reported by valgrind
+* Tightened up C syntax for stricter compilers.
+* Factored symbol and regex creation out to global scope for efficiency.
+* Removed global transaction functions that weren't exposed anyway.
+* Removed remaining global state. This should allow for better concurrency.

data/fb.c

@@ -21,6 +21,7 @@
   */
 
 #include "ruby.h"
+#include "re.h"
 #include <stdio.h>
 #include <string.h>
 #include <limits.h>
@@ -48,15 +49,20 @@ static VALUE rb_cFbDatabase;
 static VALUE rb_cFbConnection;
 static VALUE rb_cFbCursor;
 static VALUE rb_cFbSqlType;
-static VALUE rb_cFbGlobal;
+/* static VALUE rb_cFbGlobal; */
 static VALUE rb_eFbError;
 static VALUE rb_sFbField;
 static VALUE rb_sFbIndex;
 
 static VALUE rb_cDate;
 
-static char isc_info_stmt[] = { isc_info_sql_stmt_type };
-static char isc_info_buff[16];
+static ID id_matches;
+static ID id_downcase_bang;
+static VALUE re_lowercase;
+static ID id_rstrip_bang;
+
+/* static char isc_info_stmt[] = { isc_info_sql_stmt_type }; */
+/* static char isc_info_buff[16]; */
 static char isc_tpb_0[] = {
     isc_tpb_version1,		isc_tpb_write,
     isc_tpb_concurrency,	isc_tpb_nowait
@@ -87,13 +93,15 @@ struct FbConnection {
 	unsigned short db_dialect;
 	short downcase_names;
 	int dropped;
-	struct FbConnection *next;
+	ISC_STATUS isc_status[20];
+	/* struct FbConnection *next; */
 };
 
-static struct FbConnection *fb_connection_list;
+/* static struct FbConnection *fb_connection_list; */
 
 struct FbCursor {
 	int open;
+	int eof;
 	isc_tr_handle auto_transact;
 	isc_stmt_handle stmt;
 	XSQLDA *i_sqlda;
@@ -117,28 +125,33 @@ typedef struct trans_opts
 } trans_opts;
 
 /* global data */
-static isc_tr_handle global_transact = 0;	/* transaction handle */
-static int connection_count = 0;
+/* static isc_tr_handle global_transact = 0; */	/* transaction handle */
+/* static int connection_count = 0; */
 
 /* global utilities */
 
 #define	ALIGN(n, b)	((n + b - 1) & ~(b - 1))
+#define	FB_ALIGN(n, b)	((n + b - 1) & ~(b - 1))
+/* #define FB_ALIGN(n,b)          ((n+1) & ~1) */
 #define	UPPER(c)	(((c) >= 'a' && (c)<= 'z') ? (c) - 'a' + 'A' : (c))
 #define	FREE(p)		if (p)	{ xfree(p); p = 0; }
 #define	SETNULL(p)	if (p && strlen(p) == 0)	{ p = 0; }
+/* #define HERE(s) printf("%s\n", s) */
+#define HERE(s)
 
 static long calculate_buffsize(XSQLDA *sqlda)
 {
 	XSQLVAR *var;
 	long cols;
 	short dtp;
-	long offset;
+	long offset = 0;
 	long alignment;
 	long length;
 	long count;
 
 	cols = sqlda->sqld;
-	for (var = sqlda->sqlvar, offset = 0,count = 0; count < cols; var++,count++) {
+	var = sqlda->sqlvar;
+	for (count = 0; count < cols; var++,count++) {
 		length = alignment = var->sqllen;
 		dtp = var->sqltype & ~1;
 
@@ -149,21 +162,21 @@ static long calculate_buffsize(XSQLDA *sqlda)
 			alignment = sizeof(short);
 		}
 
-		offset = ALIGN(offset, alignment);
+		offset = FB_ALIGN(offset, alignment);
 		offset += length;
-		offset = ALIGN(offset, sizeof(short));
+		offset = FB_ALIGN(offset, sizeof(short));
 		offset += sizeof(short);
 	}
 
-	return offset;
+	return offset + sizeof(short);
 }
 
 #if (FB_API_VER >= 20)
 static VALUE fb_error_msg(const ISC_STATUS *isc_status)
 {
-	char msg[512];
+	char msg[1024];
 	VALUE result = rb_str_new(NULL, 0);
-	while (fb_interpret(msg, 512, &isc_status))
+	while (fb_interpret(msg, 1024, &isc_status))
 	{
 		result = rb_str_cat(result, msg, strlen(msg));
 		result = rb_str_cat(result, "\n", strlen("\n"));
@@ -173,7 +186,7 @@ static VALUE fb_error_msg(const ISC_STATUS *isc_status)
 #else
 static VALUE fb_error_msg(ISC_STATUS *isc_status)
 {
-	char msg[512];
+	char msg[1024];
 	VALUE result = rb_str_new(NULL, 0);
 	while (isc_interprete(msg, &isc_status))
 	{
@@ -360,11 +373,11 @@ static VALUE fb_sql_type_from_code(int code, int subtype)
 
 static void fb_error_check(long *isc_status)
 {
-	short code = isc_sqlcode(isc_status);
-
-	if (code != 0) {
+	HERE("fb_error_check");
+	if (isc_status[0] == 1 && isc_status[1]) {
 		char buf[1024];
 		VALUE exc, msg, msg1, msg2;
+		short code = isc_sqlcode(isc_status);
 
 		isc_sql_interprete(code, buf, 1024);
 		msg1 = rb_str_new2(buf);
@@ -374,8 +387,10 @@ static void fb_error_check(long *isc_status)
 
 		exc = rb_exc_new3(rb_eFbError, msg);
 		rb_iv_set(exc, "error_code", INT2FIX(code));
+		HERE("fb_error_check 1");
 		rb_exc_raise(exc);
 	}
+	HERE("fb_error_check 2");
 }
 
 static void fb_error_check_warn(long *isc_status)
@@ -414,11 +429,13 @@ static void fb_cursor_free();
 /* connection utilities */
 static void fb_connection_check(struct FbConnection *fb_connection)
 {
+	HERE("fb_connection_check");
 	if (fb_connection->db == 0) {
 		rb_raise(rb_eFbError, "closed db connection");
 	}
 }
 
+/*
 static void global_close_cursors()
 {
 	struct FbConnection *list = fb_connection_list;
@@ -431,6 +448,7 @@ static void global_close_cursors()
 		list = list->next;
 	}
 }
+*/
 
 static void fb_connection_close_cursors(struct FbConnection *fb_connection)
 {
@@ -451,6 +469,7 @@ static void fb_connection_drop_cursors(struct FbConnection *fb_connection)
 	RARRAY(fb_connection->cursor)->len = 0;
 }
 
+/*
 static void fb_connection_remove(struct FbConnection *fb_connection)
 {
 	if (fb_connection_list != NULL) {
@@ -470,35 +489,32 @@ static void fb_connection_remove(struct FbConnection *fb_connection)
 		connection_count--;
 	}
 }
+*/
 
 static void fb_connection_disconnect(struct FbConnection *fb_connection)
 {
-	long isc_status[20];
-
 	if (fb_connection->transact) {
-		isc_commit_transaction(isc_status, &fb_connection->transact);
-		fb_error_check(isc_status);
+		isc_commit_transaction(fb_connection->isc_status, &fb_connection->transact);
+		fb_error_check(fb_connection->isc_status);
 	}
 	if (fb_connection->dropped) {
-		isc_drop_database(isc_status, &fb_connection->db);
+		isc_drop_database(fb_connection->isc_status, &fb_connection->db);
 	} else {
-		isc_detach_database(isc_status, &fb_connection->db);
+		isc_detach_database(fb_connection->isc_status, &fb_connection->db);
 	}
-	fb_error_check(isc_status);
-	fb_connection_remove(fb_connection);
+	fb_error_check(fb_connection->isc_status);
+	/* fb_connection_remove(fb_connection); */
 }
 
 static void fb_connection_disconnect_warn(struct FbConnection *fb_connection)
 {
-	long isc_status[20];
-
 	if (fb_connection->transact) {
-		isc_commit_transaction(isc_status, &fb_connection->transact);
-		fb_error_check_warn(isc_status);
+		isc_commit_transaction(fb_connection->isc_status, &fb_connection->transact);
+		fb_error_check_warn(fb_connection->isc_status);
 	}
-	isc_detach_database(isc_status, &fb_connection->db);
-	fb_error_check_warn(isc_status);
-	fb_connection_remove(fb_connection);
+	isc_detach_database(fb_connection->isc_status, &fb_connection->db);
+	fb_error_check_warn(fb_connection->isc_status);
+	/* fb_connection_remove(fb_connection); */
 }
 
 static void fb_connection_mark(struct FbConnection *fb_connection)
@@ -514,6 +530,7 @@ static void fb_connection_free(struct FbConnection *fb_connection)
 	xfree(fb_connection);
 }
 
+/*
 static struct FbConnection* fb_connection_check_retrieve(VALUE data)
 {
 	if (TYPE(data) != T_DATA || RDATA(data)->dfree != (void *)fb_connection_free) {
@@ -523,19 +540,20 @@ static struct FbConnection* fb_connection_check_retrieve(VALUE data)
 	}
 	return (struct FbConnection*)RDATA(data)->data;
 }
+*/
 
 static unsigned short fb_connection_db_SQL_Dialect(struct FbConnection *fb_connection)
 {
-	long isc_status[20];
 	long dialect;
 	long length;
 	char db_info_command = isc_info_db_SQL_dialect;
+	char isc_info_buff[16];
 
 	/* Get the db SQL Dialect */
-	isc_database_info(isc_status, &fb_connection->db,
+	isc_database_info(fb_connection->isc_status, &fb_connection->db,
 			1, &db_info_command,
 			sizeof(isc_info_buff), isc_info_buff);
-	fb_error_check(isc_status);
+	fb_error_check(fb_connection->isc_status);
 
 	if (isc_info_buff[0] == isc_info_db_SQL_dialect) {
 		length = isc_vax_integer(&isc_info_buff[1], 2);
@@ -551,56 +569,58 @@ static unsigned short fb_connection_dialect(struct FbConnection *fb_connection)
 	return fb_connection->dialect;
 }
 
+/*
 static unsigned short fb_connection_db_dialect(struct FbConnection *fb_connection)
 {
 	return fb_connection->db_dialect;
 }
+*/
 
 /* Transaction option list */
 
 static trans_opts	rcom_opt_S[] =
 {
-	"NO",			"RECORD_VERSION",	isc_tpb_no_rec_version,	-1,	0,
-	"RECORD_VERSION",	0,			isc_tpb_rec_version,	-1,	0,
-	"*",			0,			isc_tpb_no_rec_version,	-1,	0,
-	0,			0,			0,			0,	0
+	{"NO",			"RECORD_VERSION",	isc_tpb_no_rec_version,	-1,	0},
+	{"RECORD_VERSION",	0,			isc_tpb_rec_version,	-1,	0},
+	{"*",			0,			isc_tpb_no_rec_version,	-1,	0},
+	{0,			0,			0,			0,	0}
 };
 
 
 static trans_opts	read_opt_S[] =
 {
-	"WRITE",	0,	isc_tpb_write,		1,	0,
-	"ONLY",		0,	isc_tpb_read,		1,	0,
-	"COMMITTED",	0,	isc_tpb_read_committed,	2,	rcom_opt_S,
-	0,		0,	0,			0,	0
+	{"WRITE",	0,	isc_tpb_write,		1,	0},
+	{"ONLY",		0,	isc_tpb_read,		1,	0},
+	{"COMMITTED",	0,	isc_tpb_read_committed,	2,	rcom_opt_S},
+	{0,		0,	0,			0,	0}
 };
 
 
 static trans_opts	snap_opt_S[] =
 {
-	"TABLE",	"STABILITY",	isc_tpb_consistency,	2,	0,
-	"*",		0,		isc_tpb_concurrency,	2,	0,
-	0,			0,	0,			0,	0
+	{"TABLE",	"STABILITY",	isc_tpb_consistency,	2,	0},
+	{"*",		0,		isc_tpb_concurrency,	2,	0},
+	{0,			0,	0,			0,	0}
 };
 
 
 static trans_opts	isol_opt_S[] =
 {
-	"SNAPSHOT",	0,		0,			0,	snap_opt_S,
-	"READ",		"COMMITTED",	isc_tpb_read_committed,	2,	rcom_opt_S,
-	0,		0,		0,			0,	0
+	{"SNAPSHOT",	0,		0,			0,	snap_opt_S},
+	{"READ",		"COMMITTED",	isc_tpb_read_committed,	2,	rcom_opt_S},
+	{0,		0,		0,			0,	0}
 };
 
 
 static trans_opts	trans_opt_S[] =
 {
-	"READ",		0,		0,		0,	read_opt_S,
-	"WAIT",		0,		isc_tpb_wait,	3,	0,
-	"NO",		"WAIT",		isc_tpb_nowait,	3,	0,
-	"ISOLATION",	"LEVEL",	0,		0,	isol_opt_S,
-	"SNAPSHOT",	0,		0,		0,	snap_opt_S,
-	"RESERVING",	0,		-1,		0,	0,
-	0,		0,		0,		0,	0
+	{"READ",		0,		0,		0,	read_opt_S},
+	{"WAIT",		0,		isc_tpb_wait,	3,	0},
+	{"NO",		"WAIT",		isc_tpb_nowait,	3,	0},
+	{"ISOLATION",	"LEVEL",	0,		0,	isol_opt_S},
+	{"SNAPSHOT",	0,		0,		0,	snap_opt_S},
+	{"RESERVING",	0,		-1,		0,	0},
+	{0,		0,		0,		0,	0}
 };
 
 /* Name1	Name2		Option value	    Position	Sub-option */
@@ -627,7 +647,7 @@ static char* trans_parseopts(VALUE opt, int *tpb_len)
 	char check_f[4];
 	char *resv_p;
 	char *resend_p;
-	char *tblend_p;
+	char *tblend_p = 0;
 	int tbl_len;
 	int res_first;
 	int res_count;
@@ -865,6 +885,7 @@ error:
 	rb_raise(rb_eFbError, desc);
 }
 
+/*
 static void set_teb_vec(ISC_TEB *vec, struct FbConnection *fb_connection, char *tpb, int len)
 {
 	vec->dbb_ptr = &fb_connection->db;
@@ -876,10 +897,12 @@ static void set_teb_vec(ISC_TEB *vec, struct FbConnection *fb_connection, char *
 		vec->tpb_len = 0;
 	}
 }
+*/
 
+/*
 static void global_transaction_start(VALUE opt, int argc, VALUE *argv)
 {
-	long isc_status[20];
+	ISC_STATUS isc_status[20];
 	struct FbConnection *fb_connection;
 	ISC_TEB *teb_vec = ALLOCA_N(ISC_TEB, connection_count);
 	ISC_TEB *vec = teb_vec;
@@ -916,15 +939,17 @@ static void global_transaction_start(VALUE opt, int argc, VALUE *argv)
 	xfree(tpb);
 	fb_error_check(isc_status);
 }
+*/
 
 /* call-seq:
  *   commit() -> nil
  *
  * Commit the current (global) transaction.
  */
+/*
 static VALUE global_commit()
 {
-	long isc_status[20];
+	ISC_STATUS isc_status[20];
 
 	if (global_transact) {
 		global_close_cursors();
@@ -933,15 +958,17 @@ static VALUE global_commit()
 	}
 	return Qnil;
 }
+*/
 
 /* call-seq:
  *   rollback() -> nil
  *
  * Rollback the current (global) transaction.
  */
+/*
 static VALUE global_rollback()
 {
-	long isc_status[20];
+	ISC_STATUS isc_status[20];
 
 	if (global_transact) {
 		global_close_cursors();
@@ -950,6 +977,7 @@ static VALUE global_rollback()
 	}
 	return Qnil;
 }
+*/
 
 /* call-seq:
  *   transaction(options, *connections) -> true
@@ -957,6 +985,7 @@ static VALUE global_rollback()
  *
  * Start a (global) transaction.
  */
+/*
 static VALUE global_transaction(int argc, VALUE *argv, VALUE self)
 {
 	VALUE opt = Qnil;
@@ -981,23 +1010,26 @@ static VALUE global_transaction(int argc, VALUE *argv, VALUE self)
 		return Qtrue;
    	}
 }
+*/
 
 /* call-seq:
  *   transaction_started()? -> true or false
  *
  * Returns true if a transaction is currently active.
  */
+/*
 static VALUE global_transaction_started()
 {
 	return global_transact ? Qtrue : Qfalse;
 }
+*/
 
 static void fb_connection_transaction_start(struct FbConnection *fb_connection, VALUE opt)
 {
-	long isc_status[20];
 	char *tpb = 0;
 	int tpb_len;
 
+	HERE("fb_connection_transaction_start");
 	if (fb_connection->transact) {
 		rb_raise(rb_eFbError, "A transaction has been already started");
 	}
@@ -1009,31 +1041,34 @@ static void fb_connection_transaction_start(struct FbConnection *fb_connection,
 		tpb = NULL;
 	}
 
-	isc_start_transaction(isc_status, &fb_connection->transact, 1, &fb_connection->db, tpb_len, tpb);
+	isc_start_transaction(fb_connection->isc_status, &fb_connection->transact, 1, &fb_connection->db, tpb_len, tpb);
 	xfree(tpb);
-	fb_error_check(isc_status);
+	fb_error_check(fb_connection->isc_status);
+	HERE("fb_connection_transaction_start Z");
 }
 
 static void fb_connection_commit(struct FbConnection *fb_connection)
 {
-	long isc_status[20];
+	HERE("fb_connection_commit");
 
 	if (fb_connection->transact) {
 		fb_connection_close_cursors(fb_connection);
-		isc_commit_transaction(isc_status, &fb_connection->transact);
-		fb_error_check(isc_status);
+		isc_commit_transaction(fb_connection->isc_status, &fb_connection->transact);
+		fb_error_check(fb_connection->isc_status);
 	}
+	HERE("fb_connection_commit Z");
 }
 
 static void fb_connection_rollback(struct FbConnection *fb_connection)
 {
-	long isc_status[20];
+	HERE("fb_connection_rollback");
 
 	if (fb_connection->transact) {
 		fb_connection_close_cursors(fb_connection);
-		isc_rollback_transaction(isc_status, &fb_connection->transact);
-		fb_error_check(isc_status);
+		isc_rollback_transaction(fb_connection->isc_status, &fb_connection->transact);
+		fb_error_check(fb_connection->isc_status);
 	}
+	HERE("fb_connection_rollback Z");
 }
 
 /* call-seq:
@@ -1145,11 +1180,11 @@ static VALUE connection_to_s(VALUE self)
  */
 static VALUE connection_cursor(VALUE self)
 {
-	long isc_status[20];
 	VALUE c;
 	struct FbConnection *fb_connection;
 	struct FbCursor *fb_cursor;
 
+	HERE("connection_cursor");
 	Data_Get_Struct(self, struct FbConnection, fb_connection);
 	fb_connection_check(fb_connection);
 
@@ -1158,6 +1193,7 @@ static VALUE connection_cursor(VALUE self)
 	fb_cursor->fields_ary = Qnil;
 	fb_cursor->fields_hash = Qnil;
 	fb_cursor->open = Qfalse;
+	fb_cursor->eof = Qfalse;
 	fb_cursor->stmt = 0;
 	fb_cursor->i_sqlda = sqlda_alloc(SQLDA_COLSINIT);
 	fb_cursor->o_sqlda = sqlda_alloc(SQLDA_COLSINIT);
@@ -1165,8 +1201,9 @@ static VALUE connection_cursor(VALUE self)
 	fb_cursor->i_buffer_size = 0;
 	fb_cursor->o_buffer = NULL;
 	fb_cursor->o_buffer_size = 0;
-	isc_dsql_alloc_statement2(isc_status, &fb_connection->db, &fb_cursor->stmt);
-	fb_error_check(isc_status);
+	isc_dsql_alloc_statement2(fb_connection->isc_status, &fb_connection->db, &fb_cursor->stmt);
+	fb_error_check(fb_connection->isc_status);
+	HERE("connection_cursor Z");
 
 	return c;
 }
@@ -1197,6 +1234,7 @@ static VALUE connection_cursor(VALUE self)
  */
 static VALUE connection_execute(int argc, VALUE *argv, VALUE self)
 {
+	HERE("connection_execute");
 	VALUE cursor = connection_cursor(self);
 	VALUE val = cursor_execute(argc, argv, cursor);
 
@@ -1204,11 +1242,13 @@ static VALUE connection_execute(int argc, VALUE *argv, VALUE self)
 		if (rb_block_given_p()) {
 			return rb_ensure(rb_yield,cursor,cursor_close,cursor);
    		} else {
-			return cursor;
+				HERE("connection_execute Y");
+				return cursor;
    		}
 	} else {
 		cursor_drop(cursor);
 	}
+	HERE("connection_execute Z");
 	return val;
 }
 
@@ -1233,6 +1273,7 @@ static VALUE connection_query(int argc, VALUE *argv, VALUE self)
 	VALUE cursor;
 	VALUE result;
 
+	HERE("connection_query");
 	if (argc >= 1 && TYPE(argv[0]) == T_SYMBOL) {
 		format = argv[0];
 		argc--; argv++;
@@ -1245,6 +1286,7 @@ static VALUE connection_query(int argc, VALUE *argv, VALUE self)
 		result = cursor_fetchall(1, &format, cursor);
 		cursor_close(cursor);
 	}
+	HERE("connection_query Z");
 
 	return result;
 }
@@ -1328,7 +1370,7 @@ static void fb_cursor_check(struct FbCursor *fb_cursor)
 
 static void fb_cursor_drop(struct FbCursor *fb_cursor)
 {
-	long isc_status[20];
+	ISC_STATUS isc_status[20];
 	if (fb_cursor->open) {
 		isc_dsql_free_statement(isc_status, &fb_cursor->stmt, DSQL_close);
 		fb_error_check(isc_status);
@@ -1339,7 +1381,7 @@ static void fb_cursor_drop(struct FbCursor *fb_cursor)
 
 static void fb_cursor_drop_warn(struct FbCursor *fb_cursor)
 {
-	long isc_status[20];
+	ISC_STATUS isc_status[20];
 	if (fb_cursor->open) {
 		isc_dsql_free_statement(isc_status, &fb_cursor->stmt, DSQL_close);
 		fb_error_check_warn(isc_status);
@@ -1386,15 +1428,13 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, int argc, VALU
 
 	isc_blob_handle blob_handle;
 	ISC_QUAD blob_id;
-	static char blob_items[] = { isc_info_blob_max_segment };
-	char blob_info[16];
+	/* static char blob_items[] = { isc_info_blob_max_segment }; */
+	/* char blob_info[16]; */
 	char *p;
 	long length;
-	struct time_object *tobj;
+	/* struct time_object *tobj; */
 	struct tm tms;
 
-	long isc_status[20];
-
 	Data_Get_Struct(fb_cursor->connection, struct FbConnection, fb_connection);
 
 	/* Check the number of parameters */
@@ -1417,7 +1457,7 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, int argc, VALU
 			switch (dtp) {
 				case SQL_TEXT :
 					alignment = 1;
-					offset = ALIGN(offset, alignment);
+					offset = FB_ALIGN(offset, alignment);
 					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					obj = rb_obj_as_string(obj);
 					if (RSTRING(obj)->len > var->sqllen) {
@@ -1431,7 +1471,7 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, int argc, VALU
 
 				case SQL_VARYING :
 					alignment = sizeof(short);
-					offset = ALIGN(offset, alignment);
+					offset = FB_ALIGN(offset, alignment);
 					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					vary = (VARY *)var->sqldata;
 					obj = rb_obj_as_string(obj);
@@ -1445,7 +1485,7 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, int argc, VALU
 					break;
 
 				case SQL_SHORT :
-					offset = ALIGN(offset, alignment);
+					offset = FB_ALIGN(offset, alignment);
 					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					if (var->sqlscale < 0) {
 						ratio = 1;
@@ -1466,7 +1506,7 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, int argc, VALU
 					break;
 
 				case SQL_LONG :
-					offset = ALIGN(offset, alignment);
+					offset = FB_ALIGN(offset, alignment);
 					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					if (var->sqlscale < 0) {
 						ratio = 1;
@@ -1484,7 +1524,7 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, int argc, VALU
 					break;
 
 				case SQL_FLOAT :
-					offset = ALIGN(offset, alignment);
+					offset = FB_ALIGN(offset, alignment);
 					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					obj = double_from_obj(obj);
 					dvalue = NUM2DBL(obj);
@@ -1501,7 +1541,7 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, int argc, VALU
 					break;
 
 				case SQL_DOUBLE :
-					offset = ALIGN(offset, alignment);
+					offset = FB_ALIGN(offset, alignment);
 					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					obj = double_from_obj(obj);
 					dvalue = NUM2DBL(obj);
@@ -1510,7 +1550,7 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, int argc, VALU
 					break;
 #if HAVE_LONG_LONG
 				case SQL_INT64 :
-					offset = ALIGN(offset, alignment);
+					offset = FB_ALIGN(offset, alignment);
 					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					obj = ll_from_obj(obj);
 					*(ISC_INT64 *)var->sqldata = NUM2LL(obj);
@@ -1518,36 +1558,36 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, int argc, VALU
 					break;
 #endif
 				case SQL_BLOB :
-					offset = ALIGN(offset, alignment);
+					offset = FB_ALIGN(offset, alignment);
 					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					obj = rb_obj_as_string(obj);
 
 					blob_handle = NULL;
 					isc_create_blob2(
-						isc_status,&fb_connection->db,&fb_connection->transact,
+						fb_connection->isc_status,&fb_connection->db,&fb_connection->transact,
 						&blob_handle,&blob_id,0,NULL);
-					fb_error_check(isc_status);
+					fb_error_check(fb_connection->isc_status);
 					length = RSTRING(obj)->len;
 					p = RSTRING(obj)->ptr;
 					while (length >= 4096) {
-						isc_put_segment(isc_status,&blob_handle,4096,p);
-						fb_error_check(isc_status);
+						isc_put_segment(fb_connection->isc_status,&blob_handle,4096,p);
+						fb_error_check(fb_connection->isc_status);
 						p += 4096;
 						length -= 4096;
 					}
 					if (length) {
-						isc_put_segment(isc_status,&blob_handle,length,p);
-						fb_error_check(isc_status);
+						isc_put_segment(fb_connection->isc_status,&blob_handle,length,p);
+						fb_error_check(fb_connection->isc_status);
 					}
-					isc_close_blob(isc_status,&blob_handle);
-					fb_error_check(isc_status);
+					isc_close_blob(fb_connection->isc_status,&blob_handle);
+					fb_error_check(fb_connection->isc_status);
 
 					*(ISC_QUAD *)var->sqldata = blob_id;
 					offset += alignment;
 					break;
 
 				case SQL_TIMESTAMP :
-					offset = ALIGN(offset, alignment);
+					offset = FB_ALIGN(offset, alignment);
 					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					tm_from_timestamp(&tms, obj);
 					isc_encode_timestamp(&tms, (ISC_TIMESTAMP *)var->sqldata);
@@ -1555,7 +1595,7 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, int argc, VALU
 					break;
 
 				case SQL_TYPE_TIME :
-					offset = ALIGN(offset, alignment);
+					offset = FB_ALIGN(offset, alignment);
 					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					tm_from_timestamp(&tms, obj);
 					isc_encode_sql_time(&tms, (ISC_TIME *)var->sqldata);
@@ -1563,7 +1603,7 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, int argc, VALU
 					break;
 
 				case SQL_TYPE_DATE :
-					offset = ALIGN(offset, alignment);
+					offset = FB_ALIGN(offset, alignment);
 					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					tm_from_date(&tms, obj);
 					isc_encode_sql_date(&tms, (ISC_DATE *)var->sqldata);
@@ -1573,7 +1613,7 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, int argc, VALU
 #if 0
 				case SQL_ARRAY :
 					/* Not supported now
-					offset = ALIGN(offset, alignment);
+					offset = FB_ALIGN(offset, alignment);
 					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					if (get_arrayvalue(self, type, obj, var))
 						return(STATUS_ABNORMAL);
@@ -1589,14 +1629,14 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, int argc, VALU
 			}
 
 			if (var->sqltype & 1) {
-				offset = ALIGN(offset, sizeof(short));
+				offset = FB_ALIGN(offset, sizeof(short));
 				var->sqlind = (short *)(fb_cursor->i_buffer + offset);
 				*var->sqlind = 0;
 				offset += sizeof(short);
 			}
 		} else if (var->sqltype & 1) {
 			var->sqldata = 0;
-			offset = ALIGN(offset, sizeof(short));
+			offset = FB_ALIGN(offset, sizeof(short));
 			var->sqlind = (short *)(fb_cursor->i_buffer + offset);
 			*var->sqlind = -1;
 			offset += sizeof(short);
@@ -1609,7 +1649,6 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, int argc, VALU
 static void fb_cursor_execute_withparams(struct FbCursor *fb_cursor, int argc, VALUE *argv)
 {
 	struct FbConnection *fb_connection;
-	long isc_status[20];
 
 	Data_Get_Struct(fb_cursor->connection, struct FbConnection, fb_connection);
 	/* Check the first object type of the parameters */
@@ -1631,8 +1670,8 @@ static void fb_cursor_execute_withparams(struct FbCursor *fb_cursor, int argc, V
 				fb_cursor_set_inputparams(fb_cursor, RARRAY(obj)->len, RARRAY(obj)->ptr);
 
 				/* Execute SQL statement */
-				isc_dsql_execute2(isc_status, &fb_connection->transact, &fb_cursor->stmt, SQLDA_VERSION1, fb_cursor->i_sqlda, NULL);
-				fb_error_check(isc_status);
+				isc_dsql_execute2(fb_connection->isc_status, &fb_connection->transact, &fb_cursor->stmt, SQLDA_VERSION1, fb_cursor->i_sqlda, NULL);
+				fb_error_check(fb_connection->isc_status);
 			}
 		}
 	} else {
@@ -1640,8 +1679,8 @@ static void fb_cursor_execute_withparams(struct FbCursor *fb_cursor, int argc, V
 		fb_cursor_set_inputparams(fb_cursor, argc, argv);
 
 		/* Execute SQL statement */
-		isc_dsql_execute2(isc_status, &fb_connection->transact, &fb_cursor->stmt, SQLDA_VERSION1, fb_cursor->i_sqlda, NULL);
-		fb_error_check(isc_status);
+		isc_dsql_execute2(fb_connection->isc_status, &fb_connection->transact, &fb_cursor->stmt, SQLDA_VERSION1, fb_cursor->i_sqlda, NULL);
+		fb_error_check(fb_connection->isc_status);
 	}
 }
 
@@ -1690,27 +1729,29 @@ static VALUE precision_from_sqlvar(XSQLVAR *sqlvar)
 	return Qnil;
 }
 
+static int no_lowercase(VALUE value)
+{
+	HERE("no_lowercase");
+	value = StringValue(value);
+	int result = rb_funcall(re_lowercase, id_matches, 1, value) == Qnil;
+	HERE("no_lowercase Z");
+	return result;
+}
+
 static VALUE fb_cursor_fields_ary(XSQLDA *sqlda, short downcase_names)
 {
+	HERE("fb_cursor_fields_ary");
 	long cols;
 	long count;
 	XSQLVAR *var;
 	short dtp;
 	VALUE ary;
-	VALUE re_lowercase;
-	ID id_matches, id_downcase_bang;
 
 	cols = sqlda->sqld;
 	if (cols == 0) {
 		return Qnil;
 	}
 
-	if (downcase_names) {
-		re_lowercase = rb_reg_regcomp(rb_str_new2("[[:lower:]]"));
-		id_matches = rb_intern("=~");
-		id_downcase_bang = rb_intern("downcase!");
-	}
-
 	ary = rb_ary_new();
 	for (count = 0; count < cols; count++) {
 		VALUE field;
@@ -1724,7 +1765,7 @@ static VALUE fb_cursor_fields_ary(XSQLDA *sqlda, short downcase_names)
 		} else {
 			name = rb_tainted_str_new(var->sqlname, var->sqlname_length);
 		}
-		if (downcase_names && rb_funcall(re_lowercase, id_matches, 1, name) == Qnil) {
+		if (downcase_names && no_lowercase(name)) {
 			rb_funcall(name, id_downcase_bang, 0);
 		}
 		rb_str_freeze(name);
@@ -1745,11 +1786,13 @@ static VALUE fb_cursor_fields_ary(XSQLDA *sqlda, short downcase_names)
 		rb_ary_push(ary, field);
 	}
 	rb_ary_freeze(ary);
+	HERE("fb_cursor_fields_ary Z");
 	return ary;
 }
 
 static VALUE fb_cursor_fields_hash(VALUE fields_ary)
 {
+	HERE("fb_cursor_fields_hash");
 	int i;
 	VALUE hash = rb_hash_new();
 
@@ -1759,6 +1802,7 @@ static VALUE fb_cursor_fields_hash(VALUE fields_ary)
 		rb_hash_aset(hash, name, field);
 	}
 
+	HERE("fb_cursor_fields_hash Z");
 	return hash;
 }
 
@@ -1772,7 +1816,6 @@ static void fb_cursor_fetch_prep(struct FbCursor *fb_cursor)
 	long length;
 	long alignment;
 	long offset;
-	long isc_status[20];
 
 	fb_cursor_check(fb_cursor);
 
@@ -1781,11 +1824,11 @@ static void fb_cursor_fetch_prep(struct FbCursor *fb_cursor)
 
 	/* Check if open cursor */
 	if (!fb_cursor->open) {
-		rb_raise(rb_eFbError, "The cursor has not been open. Use execute(query)");
+		rb_raise(rb_eFbError, "The cursor has not been opened. Use execute(query)");
 	}
 	/* Describe output SQLDA */
-	isc_dsql_describe(isc_status, &fb_cursor->stmt, 1, fb_cursor->o_sqlda);
-	fb_error_check(isc_status);
+	isc_dsql_describe(fb_connection->isc_status, &fb_cursor->stmt, 1, fb_cursor->o_sqlda);
+	fb_error_check(fb_connection->isc_status);
 
 	/* Set the output SQLDA */
 	cols = fb_cursor->o_sqlda->sqld;
@@ -1799,10 +1842,10 @@ static void fb_cursor_fetch_prep(struct FbCursor *fb_cursor)
 			length += sizeof(short);
 			alignment = sizeof(short);
 		}
-		offset = ALIGN(offset, alignment);
+		offset = FB_ALIGN(offset, alignment);
 		var->sqldata = (char*)(fb_cursor->o_buffer + offset);
 		offset += length;
-		offset = ALIGN(offset, sizeof(short));
+		offset = FB_ALIGN(offset, sizeof(short));
 		var->sqlind = (short*)(fb_cursor->o_buffer + offset);
 		offset += sizeof(short);
 	}
@@ -1835,20 +1878,22 @@ static VALUE fb_cursor_fetch(struct FbCursor *fb_cursor)
 	char blob_info[32];
 	char *p, item;
 	short length;
-	unsigned short max_segment;
-	ISC_LONG num_segments;
-	ISC_LONG total_length;
-
-	long isc_status[20];
+	unsigned short max_segment = 0;
+	ISC_LONG num_segments = 0;
+	ISC_LONG total_length = 0;
 
 	Data_Get_Struct(fb_cursor->connection, struct FbConnection, fb_connection);
 	fb_connection_check(fb_connection);
 
+	if (fb_cursor->eof) {
+		rb_raise(rb_eFbError, "Cursor is past end of data.");
+	}
 	/* Fetch one row */
-	if (isc_dsql_fetch(isc_status, &fb_cursor->stmt, 1, fb_cursor->o_sqlda) == SQLCODE_NOMORE) {
+	if (isc_dsql_fetch(fb_connection->isc_status, &fb_cursor->stmt, 1, fb_cursor->o_sqlda) == SQLCODE_NOMORE) {
+		fb_cursor->eof = Qtrue;
 		return Qnil;
 	}
-	fb_error_check(isc_status);
+	fb_error_check(fb_connection->isc_status);
 
 	/* Create the result tuple object */
 	cols = fb_cursor->o_sqlda->sqld;
@@ -1915,8 +1960,9 @@ static VALUE fb_cursor_fetch(struct FbCursor *fb_cursor)
 				case SQL_TIMESTAMP:
 					isc_decode_timestamp((ISC_TIMESTAMP *)var->sqldata, &tms);
 					t = mktime(&tms);
-					if (t < 0) t = 0;
-					val = rb_time_new(t, 0);
+                    if (t < 0) t = 0;
+                    val = rb_time_new(t, 0);
+                    rb_funcall(val, rb_intern("localtime"), 0);
 					break;
 
 				case SQL_TYPE_TIME:
@@ -1940,13 +1986,13 @@ static VALUE fb_cursor_fetch(struct FbCursor *fb_cursor)
 				case SQL_BLOB:
 					blob_handle = NULL;
 					blob_id = *(ISC_QUAD *)var->sqldata;
-					isc_open_blob2(isc_status, &fb_connection->db, &fb_connection->transact, &blob_handle, &blob_id, 0, NULL);
-					fb_error_check(isc_status);
+					isc_open_blob2(fb_connection->isc_status, &fb_connection->db, &fb_connection->transact, &blob_handle, &blob_id, 0, NULL);
+					fb_error_check(fb_connection->isc_status);
 					isc_blob_info(
-						isc_status, &blob_handle,
+						fb_connection->isc_status, &blob_handle,
 						sizeof(blob_items), blob_items,
 						sizeof(blob_info), blob_info);
-					fb_error_check(isc_status);
+					fb_error_check(fb_connection->isc_status);
 					for (p = blob_info; *p != isc_info_end; p += length) {
 						item = *p++;
 						length = (short) isc_vax_integer(p,2);
@@ -1965,11 +2011,11 @@ static VALUE fb_cursor_fetch(struct FbCursor *fb_cursor)
 					}
 					val = rb_tainted_str_new(NULL,total_length);
 					for (p = RSTRING(val)->ptr; num_segments > 0; num_segments--, p += actual_seg_len) {
-						isc_get_segment(isc_status, &blob_handle, &actual_seg_len, max_segment, p);
-						fb_error_check(isc_status);
+						isc_get_segment(fb_connection->isc_status, &blob_handle, &actual_seg_len, max_segment, p);
+						fb_error_check(fb_connection->isc_status);
 					}
-					isc_close_blob(isc_status, &blob_handle);
-					fb_error_check(isc_status);
+					isc_close_blob(fb_connection->isc_status, &blob_handle);
+					fb_error_check(fb_connection->isc_status);
 					break;
 
 				case SQL_ARRAY:
@@ -1993,7 +2039,7 @@ static long cursor_rows_affected(struct FbCursor *fb_cursor, long statement_type
 	long inserted = 0, selected = 0, updated = 0, deleted = 0;
 	char request[] = { isc_info_sql_records };
 	char response[64], *r;
-	long isc_status[20];
+	ISC_STATUS isc_status[20];
 
 	isc_dsql_sql_info(isc_status, &fb_cursor->stmt, sizeof(request), request, sizeof(response), response);
 	fb_error_check(isc_status);
@@ -2036,6 +2082,7 @@ static long cursor_rows_affected(struct FbCursor *fb_cursor, long statement_type
  */
 static VALUE cursor_execute2(VALUE args)
 {
+	HERE("cursor_execute2");
 	struct FbCursor *fb_cursor;
 	struct FbConnection *fb_connection;
 	char *sql;
@@ -2045,7 +2092,8 @@ static VALUE cursor_execute2(VALUE args)
 	long cols;
 	long rows_affected;
 	VALUE result = Qnil;
-	long isc_status[20];
+	char isc_info_buff[16];
+	char isc_info_stmt[] = { isc_info_sql_stmt_type };
 
 	VALUE self = rb_ary_pop(args);
 	Data_Get_Struct(self, struct FbCursor, fb_cursor);
@@ -2054,14 +2102,14 @@ static VALUE cursor_execute2(VALUE args)
 	sql = STR2CSTR(rb_ary_shift(args));
 
 	/* Prepare query */
-	isc_dsql_prepare(isc_status, &fb_connection->transact, &fb_cursor->stmt, 0, sql, fb_connection_dialect(fb_connection), fb_cursor->o_sqlda);
-	fb_error_check(isc_status);
+	isc_dsql_prepare(fb_connection->isc_status, &fb_connection->transact, &fb_cursor->stmt, 0, sql, fb_connection_dialect(fb_connection), fb_cursor->o_sqlda);
+	fb_error_check(fb_connection->isc_status);
 
 	/* Get the statement type */
-	isc_dsql_sql_info(isc_status, &fb_cursor->stmt,
+	isc_dsql_sql_info(fb_connection->isc_status, &fb_cursor->stmt,
 			sizeof(isc_info_stmt), isc_info_stmt,
 			sizeof(isc_info_buff), isc_info_buff);
-	fb_error_check(isc_status);
+	fb_error_check(fb_connection->isc_status);
 
 	if (isc_info_buff[0] == isc_info_sql_stmt_type) {
 		length = isc_vax_integer(&isc_info_buff[1], 2);
@@ -2070,11 +2118,11 @@ static VALUE cursor_execute2(VALUE args)
 		statement = 0;
 	}
 	/* Describe the parameters */
-	isc_dsql_describe_bind(isc_status, &fb_cursor->stmt, 1, fb_cursor->i_sqlda);
-	fb_error_check(isc_status);
+	isc_dsql_describe_bind(fb_connection->isc_status, &fb_cursor->stmt, 1, fb_cursor->i_sqlda);
+	fb_error_check(fb_connection->isc_status);
 
-	isc_dsql_describe(isc_status, &fb_cursor->stmt, 1, fb_cursor->o_sqlda);
-	fb_error_check(isc_status);
+	isc_dsql_describe(fb_connection->isc_status, &fb_cursor->stmt, 1, fb_cursor->o_sqlda);
+	fb_error_check(fb_connection->isc_status);
 
 	/* Get the number of parameters and reallocate the SQLDA */
 	in_params = fb_cursor->i_sqlda->sqld;
@@ -2082,8 +2130,8 @@ static VALUE cursor_execute2(VALUE args)
 		xfree(fb_cursor->i_sqlda);
 		fb_cursor->i_sqlda = sqlda_alloc(in_params);
 		/* Describe again */
-		isc_dsql_describe_bind(isc_status, &fb_cursor->stmt, 1, fb_cursor->i_sqlda);
-		fb_error_check(isc_status);
+		isc_dsql_describe_bind(fb_connection->isc_status, &fb_cursor->stmt, 1, fb_cursor->i_sqlda);
+		fb_error_check(fb_connection->isc_status);
 	}
 
     /* Get the size of parameters buffer and reallocate it */
@@ -2106,8 +2154,8 @@ static VALUE cursor_execute2(VALUE args)
 		} else if (in_params) {
 			fb_cursor_execute_withparams(fb_cursor, RARRAY(args)->len, RARRAY(args)->ptr);
 		} else {
-			isc_dsql_execute2(isc_status, &fb_connection->transact, &fb_cursor->stmt, SQLDA_VERSION1, NULL, NULL);
-			fb_error_check(isc_status);
+			isc_dsql_execute2(fb_connection->isc_status, &fb_connection->transact, &fb_cursor->stmt, SQLDA_VERSION1, NULL, NULL);
+			fb_error_check(fb_connection->isc_status);
 		}
 		rows_affected = cursor_rows_affected(fb_cursor, statement);
 		result = INT2NUM(rows_affected);
@@ -2119,8 +2167,8 @@ static VALUE cursor_execute2(VALUE args)
 			xfree(fb_cursor->o_sqlda);
 			fb_cursor->o_sqlda = sqlda_alloc(cols);
 			/* Describe again */
-			isc_dsql_describe(isc_status, &fb_cursor->stmt, 1, fb_cursor->o_sqlda);
-			fb_error_check(isc_status);
+			isc_dsql_describe(fb_connection->isc_status, &fb_cursor->stmt, 1, fb_cursor->o_sqlda);
+			fb_error_check(fb_connection->isc_status);
 		}
 
 		if (in_params) {
@@ -2128,8 +2176,8 @@ static VALUE cursor_execute2(VALUE args)
 		}
 
 		/* Open cursor */
-		isc_dsql_execute2(isc_status, &fb_connection->transact, &fb_cursor->stmt, SQLDA_VERSION1, in_params ? fb_cursor->i_sqlda : NULL, NULL);
-		fb_error_check(isc_status);
+		isc_dsql_execute2(fb_connection->isc_status, &fb_connection->transact, &fb_cursor->stmt, SQLDA_VERSION1, in_params ? fb_cursor->i_sqlda : NULL, NULL);
+		fb_error_check(fb_connection->isc_status);
 		fb_cursor->open = Qtrue;
 
 		/* Get the size of results buffer and reallocate it */
@@ -2142,7 +2190,9 @@ static VALUE cursor_execute2(VALUE args)
 		/* Set the description attributes */
 		fb_cursor->fields_ary = fb_cursor_fields_ary(fb_cursor->o_sqlda, fb_connection->downcase_names);
 		fb_cursor->fields_hash = fb_cursor_fields_hash(fb_cursor->fields_ary);
+		HERE("cursor_execute2 Z");
 	}
+	HERE("cursor_execute2 Z");
 	return result;
 }
 
@@ -2153,9 +2203,9 @@ static VALUE cursor_execute2(VALUE args)
  */
 static VALUE cursor_execute(int argc, VALUE* argv, VALUE self)
 {
+	HERE("cursor_execute");
 	struct FbCursor *fb_cursor;
 	struct FbConnection *fb_connection;
-	long isc_status[20];
 	VALUE args;
 
 	if (argc < 1) {
@@ -2170,8 +2220,8 @@ static VALUE cursor_execute(int argc, VALUE* argv, VALUE self)
 	fb_connection_check(fb_connection);
 
 	if (fb_cursor->open) {
-		isc_dsql_free_statement(isc_status, &fb_cursor->stmt, DSQL_close);
-		fb_error_check(isc_status);
+		isc_dsql_free_statement(fb_connection->isc_status, &fb_cursor->stmt, DSQL_close);
+		fb_error_check(fb_connection->isc_status);
 		fb_cursor->open = Qfalse;
 	}
 
@@ -2188,11 +2238,14 @@ static VALUE cursor_execute(int argc, VALUE* argv, VALUE self)
 			return rb_funcall(rb_mKernel, rb_intern("raise"), 0);
 		} else if (result != Qnil) {
 			fb_connection_commit(fb_connection);
+			HERE("cursor_execute X");
 			return result;
 		} else {
+			HERE("cursor_execute Y");
 			return result;
 		}
 	} else {
+		HERE("cursor_execute Z");
 		return cursor_execute2(args);
 	}
 }
@@ -2291,7 +2344,7 @@ static VALUE cursor_fetchall(int argc, VALUE* argv, VALUE self)
  */
 static VALUE cursor_each(int argc, VALUE* argv, VALUE self)
 {
-	VALUE ary, row;
+	VALUE row;
 	struct FbCursor *fb_cursor;
 
 	int hash_rows = hash_format(argc, argv);
@@ -2321,7 +2374,6 @@ static VALUE cursor_close(VALUE self)
 {
 	struct FbCursor *fb_cursor;
 	struct FbConnection *fb_connection;
-	long isc_status[20];
 
 	Data_Get_Struct(self, struct FbCursor, fb_cursor);
 	Data_Get_Struct(fb_cursor->connection, struct FbConnection, fb_connection);
@@ -2329,15 +2381,15 @@ static VALUE cursor_close(VALUE self)
 
 	/* Close the cursor */
 	if (fb_cursor->stmt) {
-		isc_dsql_free_statement(isc_status, &fb_cursor->stmt, DSQL_close);
-		fb_error_check_warn(isc_status);
-		isc_dsql_free_statement(isc_status, &fb_cursor->stmt, DSQL_drop);
-		fb_error_check(isc_status);
+		isc_dsql_free_statement(fb_connection->isc_status, &fb_cursor->stmt, DSQL_close);
+		fb_error_check_warn(fb_connection->isc_status);
+		isc_dsql_free_statement(fb_connection->isc_status, &fb_cursor->stmt, DSQL_drop);
+		fb_error_check(fb_connection->isc_status);
 		fb_cursor->open = Qfalse;
 		if (fb_connection->transact == fb_cursor->auto_transact) {
-			isc_commit_transaction(isc_status, &fb_connection->transact);
-			fb_error_check(isc_status);
+			isc_commit_transaction(fb_connection->isc_status, &fb_connection->transact);
 			fb_cursor->auto_transact = fb_connection->transact;
+			fb_error_check(fb_connection->isc_status);
 		}
 	}
 	fb_cursor->fields_ary = Qnil;
@@ -2476,10 +2528,11 @@ static VALUE connection_create(isc_db_handle handle, VALUE db)
 	fb_connection->db = handle;
 	fb_connection->transact = 0;
 	fb_connection->cursor = rb_ary_new();
+/*
 	connection_count++;
 	fb_connection->next = fb_connection_list;
 	fb_connection_list = fb_connection;
-
+*/
 	dialect = SQL_DIALECT_CURRENT;
 	db_dialect = fb_connection_db_SQL_Dialect(fb_connection);
 
@@ -2493,7 +2546,7 @@ static VALUE connection_create(isc_db_handle handle, VALUE db)
 	downcase_names = rb_iv_get(db, "@downcase_names");
 	fb_connection->downcase_names = RTEST(downcase_names);
 
-	for (i = 0; parm = CONNECTION_PARMS[i]; i++) {
+	for (i = 0; (parm = CONNECTION_PARMS[i]); i++) {
 		rb_iv_set(connection, parm, rb_iv_get(db, parm));
 	}
 
@@ -2506,21 +2559,12 @@ static VALUE connection_names(VALUE self, char *sql)
 	VALUE query = rb_str_new2(sql);
 	VALUE cursor = connection_execute(1, &query, self);
 	VALUE names = rb_ary_new();
-	ID id_rstrip_bang = rb_intern("rstrip!");
 	struct FbConnection *fb_connection;
-	VALUE re_lowercase;
-	ID id_matches, id_downcase_bang;
 	Data_Get_Struct(self, struct FbConnection, fb_connection);
 
-	if (fb_connection->downcase_names) {
-		re_lowercase = rb_reg_regcomp(rb_str_new2("[[:lower:]]"));
-		id_matches = rb_intern("=~");
-		id_downcase_bang = rb_intern("downcase!");
-	}
-
 	while ((row = cursor_fetch(0, NULL, cursor)) != Qnil) {
 		VALUE name = rb_ary_entry(row, 0);
-		if (fb_connection->downcase_names && rb_funcall(re_lowercase, id_matches, 1, name) == Qnil) {
+		if (fb_connection->downcase_names && no_lowercase(name)) {
 			rb_funcall(name, id_downcase_bang, 0);
 		}
 		rb_funcall(name, id_rstrip_bang, 0);
@@ -2610,28 +2654,19 @@ static VALUE connection_index_columns(VALUE self, VALUE index_name)
 						"FROM RDB$INDEX_SEGMENTS "
 						"WHERE RDB$INDEX_SEGMENTS.RDB$INDEX_NAME = ? "
 						"ORDER BY RDB$INDEX_SEGMENTS.RDB$FIELD_POSITION";
-	ID id_rstrip_bang = rb_intern("rstrip!");
 	VALUE query_columns = rb_str_new2(sql_columns);
 	VALUE query_parms[] = { query_columns, index_name };
 	VALUE result = connection_query(2, query_parms, self);
 	VALUE columns = rb_ary_new();
-	VALUE re_lowercase;
-	ID id_matches, id_downcase_bang;
 	int i;
 	struct FbConnection *fb_connection;
 	Data_Get_Struct(self, struct FbConnection, fb_connection);
 
-	if (fb_connection->downcase_names) {
-		re_lowercase = rb_reg_regcomp(rb_str_new2("[[:lower:]]"));
-		id_matches = rb_intern("=~");
-		id_downcase_bang = rb_intern("downcase!");
-	}
-
 	for (i = 0; i < RARRAY(result)->len; i++) {
 		VALUE row = rb_ary_entry(result, i);
 		VALUE name = rb_ary_entry(row, 1);
 		rb_funcall(name, id_rstrip_bang, 0);
-		if (fb_connection->downcase_names && rb_funcall(re_lowercase, id_matches, 1, name) == Qnil) {
+		if (fb_connection->downcase_names && no_lowercase(name)) {
 			rb_funcall(name, id_downcase_bang, 0);
 		}
 		rb_ary_push(columns, name);
@@ -2650,22 +2685,13 @@ static VALUE connection_indexes(VALUE self)
 						"FROM RDB$INDICES "
 						"  JOIN RDB$RELATIONS ON RDB$INDICES.RDB$RELATION_NAME = RDB$RELATIONS.RDB$RELATION_NAME "
 						"WHERE (RDB$RELATIONS.RDB$SYSTEM_FLAG <> 1 OR RDB$RELATIONS.RDB$SYSTEM_FLAG IS NULL) ";
-	ID id_rstrip_bang = rb_intern("rstrip!");
 	VALUE query_indexes = rb_str_new2(sql_indexes);
 	VALUE ary_indexes = connection_query(1, &query_indexes, self);
 	VALUE indexes = rb_hash_new();
-	VALUE re_lowercase;
-	ID id_matches, id_downcase_bang;
 	int i;
 	struct FbConnection *fb_connection;
 	Data_Get_Struct(self, struct FbConnection, fb_connection);
 
-	if (fb_connection->downcase_names) {
-		re_lowercase = rb_reg_regcomp(rb_str_new2("[[:lower:]]"));
-		id_matches = rb_intern("=~");
-		id_downcase_bang = rb_intern("downcase!");
-	}
-
 	for (i = 0; i < RARRAY(ary_indexes)->len; i++) {
 		VALUE index_struct;
 		VALUE row = rb_ary_entry(ary_indexes, i);
@@ -2679,10 +2705,10 @@ static VALUE connection_indexes(VALUE self)
 		rb_funcall(index_name, id_rstrip_bang, 0);
 
 		if (fb_connection->downcase_names) {
-			if (rb_funcall(re_lowercase, id_matches, 1, table_name) == Qnil) {
+			if (no_lowercase(table_name)) {
 				rb_funcall(table_name, id_downcase_bang, 0);
 			}
-			if (rb_funcall(re_lowercase, id_matches, 1, index_name) == Qnil) {
+			if (no_lowercase(index_name)) {
 				rb_funcall(index_name, id_downcase_bang, 0);
 			}
 		}
@@ -2709,15 +2735,17 @@ static VALUE sql_type_from_code(VALUE self, VALUE code, VALUE subtype)
 	return fb_sql_type_from_code(NUM2INT(code), NUM2INT(subtype));
 }
 
+/*
 static void define_attrs(VALUE klass, char **attrs)
 {
 	char *parm;
-	while (parm = *attrs)
+	while ((parm = *attrs))
 	{
 		rb_define_attr(klass, parm+1, 1, 1);
 		attrs++;
 	}
 }
+*/
 
 static VALUE default_string(VALUE hash, char *key, char *def)
 {
@@ -2813,7 +2841,7 @@ static VALUE database_initialize(int argc, VALUE *argv, VALUE self)
  */
 static VALUE database_create(VALUE self)
 {
-	long isc_status[20];
+	ISC_STATUS isc_status[20];
 	isc_db_handle handle = 0;
 	isc_tr_handle local_transact = 0;
 	VALUE parms, fmt, stmt;
@@ -2880,6 +2908,7 @@ static VALUE database_connect(VALUE self)
 	int length;
 	isc_db_handle handle = NULL;
 	VALUE database = rb_iv_get(self, "@database");
+
 	Check_Type(database, T_STRING);
 	dbp = connection_create_dbp(self, &length);
 	isc_attach_database(isc_status, 0, STR2CSTR(database), &handle, length, dbp);
@@ -2919,14 +2948,13 @@ static VALUE database_s_connect(int argc, VALUE *argv, VALUE klass)
  */
 static VALUE database_drop(VALUE self)
 {
-	long isc_status[20];
 	struct FbConnection *fb_connection;
 
 	VALUE connection = database_connect(self);
 	Data_Get_Struct(connection, struct FbConnection, fb_connection);
-	isc_drop_database(isc_status, &fb_connection->db);
-	fb_error_check(isc_status);
-	fb_connection_remove(fb_connection);
+	isc_drop_database(fb_connection->isc_status, &fb_connection->db);
+	fb_error_check(fb_connection->isc_status);
+	/* fb_connection_remove(fb_connection); */
 	return Qnil;
 }
 
@@ -2944,6 +2972,7 @@ static VALUE database_s_drop(int argc, VALUE *argv, VALUE klass)
 
 void Init_fb()
 {
+	HERE("Init_fb");
 	rb_mFb = rb_define_module("Fb");
 
 	rb_cFbDatabase = rb_define_class_under(rb_mFb, "Database", rb_cData);
@@ -2988,10 +3017,10 @@ void Init_fb()
 	rb_define_method(rb_cFbConnection, "role_names", connection_role_names, 0);
 	rb_define_method(rb_cFbConnection, "procedure_names", connection_procedure_names, 0);
 	rb_define_method(rb_cFbConnection, "indexes", connection_indexes, 0);
-	//rb_define_method(rb_cFbConnection, "cursor", connection_cursor, 0);
+	/* rb_define_method(rb_cFbConnection, "cursor", connection_cursor, 0); */
 
 	rb_cFbCursor = rb_define_class_under(rb_mFb, "Cursor", rb_cData);
-	//rb_define_method(rb_cFbCursor, "execute", cursor_execute, -1);
+	/* rb_define_method(rb_cFbCursor, "execute", cursor_execute, -1); */
 	rb_define_method(rb_cFbCursor, "fields", cursor_fields, -1);
 	rb_define_method(rb_cFbCursor, "fetch", cursor_fetch, -1);
 	rb_define_method(rb_cFbCursor, "fetchall", cursor_fetchall, -1);
@@ -3019,4 +3048,10 @@ void Init_fb()
 	rb_require("date");
 	rb_require("time"); /* Needed as of Ruby 1.8.5 */
 	rb_cDate = rb_const_get(rb_cObject, rb_intern("Date"));
+
+	id_matches = rb_intern("=~");
+	id_downcase_bang = rb_intern("downcase!");
+	re_lowercase = rb_reg_regcomp(rb_str_new2("[[:lower:]]"));
+	rb_global_variable(&re_lowercase);
+	id_rstrip_bang = rb_intern("rstrip!");
 }