openbase 0.8.1

data/ext/depend

@@ -0,0 +1 @@
+openbase.o: openbase.c

data/ext/extconf.rb

@@ -0,0 +1,10 @@
+require "mkmf"
+
+$CFLAGS = '-ggdb -DMACOSX_UNIX -I./Headers'
+
+#$LDFLAGS = '-L./lib -lOpenBaseAPI'
+#find_library('OpenBaseAPI','OpenBaseAPI','./lib')
+
+#have_library('MallocDebug.a','malloc')
+
+create_makefile('openbase')

data/ext/longlong.c

@@ -0,0 +1 @@
+// ------------------------------------------------------------------------------

data/ext/openbase.c

@@ -0,0 +1,980 @@
+#include <ruby.h>
+#include <OpenBaseConnection.h>
+#include <CommAPI.h>
+#include <NetClient.h>
+#include <stdio.h>
+
+// Ruby Classes Declared by this Library
+static VALUE rb_cOpenBase;
+static VALUE rb_cOpenBaseResult;
+static VALUE rb_cOpenBaseColumnInfo;
+static VALUE rb_cOpenBaseError;
+
+// Ruby methods used by this Library
+static ID rb_gsub_bang_id;
+static VALUE rb_date_regex;
+static VALUE rb_replacement_str;
+
+// Other Ruby Classes used by this Library
+static VALUE rb_cDate;
+static VALUE rb_cBigDecimal;
+
+
+#define OB_CHAR_LENGTH      4096
+#define OB_MONEY_LENGTH     32
+#define OB_DATE_LENGTH      32
+#define OB_TIME_LENGTH      32
+#define OB_DATETIME_LENGTH  32
+#define OB_TIMESTAMP_LENGTH 32
+#define OB_BLOB_KEY_LENGTH  8
+#define OB_BOOLEAN_LENGTH   2
+
+
+/**** Macros ****/
+#define GET_OPENBASE(obj,var) Data_Get_Struct(obj, OpenBase, var)
+#define GET_OPENBASE_IF_CONNECTED(obj,var) \
+  Data_Get_Struct(obj, OpenBase, var); \
+  if (!ob_isConnected(var)) { \
+    rb_raise(rb_cOpenBaseError, "The database is not connected."); \
+  }
+
+#define GET_RESULT(obj,var) Data_Get_Struct(obj, OpenBaseResult, var)
+#define GET_INFO(obj,var) Data_Get_Struct(obj, OpenBaseColumnInfo, var)
+
+#define OPTIONAL_STRING(var,default_string) \
+  if (NIL_P(var)) { var = rb_str_new2(default_string); } \
+  else { Check_Type(var, T_STRING); }
+
+
+struct OpenBaseResultStruct {
+   OpenBasePtr openbase;
+   OpenBaseCursorPtr cursor;
+   VALUE infos;
+   VALUE col_names; // used to create hashes
+   long fetch_limit;
+   long fetch_offset;
+   int rows_fetched;
+   int has_been_offset;
+   long rows_affected;
+   int col_count;	// column count
+   int *types; // result column types
+   void **buf; // buffer to bind result columns
+};
+typedef struct OpenBaseResultStruct OpenBaseResult;
+
+struct OpenBaseColumnInfoStruct {
+    VALUE name;
+    VALUE type;
+    VALUE table;
+};
+typedef struct OpenBaseColumnInfoStruct OpenBaseColumnInfo;
+
+
+/**** Class Constructor Prototypes ****/
+static VALUE result_new _((VALUE self, VALUE obconn));
+static VALUE columninfo_new   _((VALUE self, VALUE name, VALUE type, VALUE table));
+
+	
+/*** OpenBase: Construction/Destruction							 ***/
+
+static void openbase_free( OpenBasePtr openbase ) 
+{
+	ob_deallocConnection(openbase);
+}
+
+static VALUE openbase_alloc( VALUE klass )
+{
+	OpenBasePtr openbase = ob_newConnection();
+	return Data_Wrap_Struct(klass, 0, openbase_free, openbase);
+}
+
+static VALUE openbase_initialize( int argc, VALUE *argv, VALUE self )
+{
+	OpenBasePtr openbase;
+
+	GET_OPENBASE(self, openbase);
+
+	if (argc >=3) rb_funcall2(self, rb_intern("connect"), argc, argv);
+
+	return Qnil;
+}
+
+/* END OpenBase Construction/Destruction */
+
+
+/*** OpenBase: Connection Methods										 ***/
+
+static VALUE openbase_connect( int argc, VALUE *argv, VALUE self )
+{
+	OpenBasePtr openbase;
+	VALUE database, host, login, password;
+	int return_code;
+
+	GET_OPENBASE(self, openbase);
+	rb_scan_args(argc, argv, "31", &database, &host, &login, &password);
+	
+	Check_Type(database, T_STRING);
+	OPTIONAL_STRING(host, "127.0.0.1");
+	OPTIONAL_STRING(login, "admin");
+	OPTIONAL_STRING(password, "");
+	
+	if (ob_isConnected(openbase)) {ob_invalidate(openbase);}
+	if ( !ob_connectToDatabase(openbase,StringValuePtr(database), StringValuePtr(host), StringValuePtr(login), StringValuePtr(password),"","", &return_code) ) {
+		rb_raise(rb_cOpenBaseError, ob_connectErrorMessage(openbase));
+	}
+
+	return Qnil;
+}
+
+static VALUE openbase_isConnected( VALUE self )
+{
+  OpenBasePtr openbase;
+  
+  GET_OPENBASE(self, openbase);
+  
+  if (ob_isConnected(openbase)) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+static VALUE openbase_invalidate( VALUE self )
+{
+  OpenBasePtr openbase;
+  
+  GET_OPENBASE(self, openbase);
+  ob_invalidate(openbase);
+  
+  return Qnil;
+}
+
+static VALUE openbase_database( VALUE self )
+{
+	OpenBasePtr openbase;
+	GET_OPENBASE_IF_CONNECTED(self, openbase);
+	
+	return rb_str_new2(ob_databaseName(openbase));
+}
+
+static VALUE openbase_host( VALUE self )
+{
+	OpenBasePtr openbase;
+	GET_OPENBASE_IF_CONNECTED(self, openbase);
+	
+	return rb_str_new2(ob_hostName(openbase));
+}
+
+static VALUE openbase_login( VALUE self )
+{
+	OpenBasePtr openbase;
+	GET_OPENBASE_IF_CONNECTED(self, openbase);
+	
+	return rb_str_new2(ob_loginName(openbase));
+}
+
+static VALUE openbase_password( VALUE self )
+{
+	OpenBasePtr openbase;
+	GET_OPENBASE_IF_CONNECTED(self, openbase);
+	
+	return	rb_str_new2(ob_password(openbase));
+}
+
+static VALUE openbase_encoding( VALUE self )
+{
+  OpenBasePtr openbase;
+  
+  GET_OPENBASE(self, openbase);
+  return rb_str_new2(ob_getEncodingName(ob_databaseEncoding(openbase)));
+}
+
+/* END OpenBase Connection Methods */
+
+
+/*** OpenBase: Schema Methods												 ***/
+
+static VALUE openbase_tables( VALUE self )
+{ 
+	OpenBasePtr openbase;
+	VALUE ary;
+	char table_name[100];
+
+	GET_OPENBASE_IF_CONNECTED(self, openbase);
+	
+	ary = rb_ary_new();
+	
+	ob_makeCommand(openbase,"select distinct tablename from _sys_tables");
+	if (ob_executeCommand(openbase)) {	
+	  ob_bindString(openbase,table_name);
+    while (ob_nextRow(openbase)) {
+	    rb_ary_push(ary, rb_str_new2(table_name));
+	  }
+	}
+	
+	return ary;
+}
+
+
+static VALUE openbase_columns( VALUE self, VALUE table )
+{
+	OpenBasePtr openbase;
+	VALUE ary;
+	char col_name[100];
+
+	GET_OPENBASE_IF_CONNECTED(self, openbase);
+	
+	ary = rb_ary_new();
+	
+	ob_makeCommand(openbase, "select fieldname, typename from _SYS_TABLES where tablename = '");
+  ob_makeCommand(openbase, RSTRING(table)->ptr);
+  ob_makeCommand(openbase, "' and fieldname not in('_timestamp', '_version') ");
+  if (ob_executeCommand(openbase)) {
+    ob_bindString(openbase,col_name);
+    while (ob_nextRow(openbase)) {
+      rb_ary_push(ary, rb_str_new2(col_name));
+    }
+  }
+	
+	return ary;
+}
+
+
+static VALUE openbase_relationships( VALUE self, VALUE table )
+{
+	OpenBasePtr openbase;
+	VALUE ary;
+	char relationship_name[100];
+
+	GET_OPENBASE_IF_CONNECTED(self, openbase);
+	
+	ary = rb_ary_new();
+	
+	ob_makeCommand(openbase, "select relationshipName from _SYS_RELATIONSHIP where source_table = '");
+  ob_makeCommand(openbase, RSTRING(table)->ptr);
+  ob_makeCommand(openbase,"' ");
+  
+  if ( ob_executeCommand(openbase)) {
+    ob_bindString(openbase, relationship_name);
+    while (ob_nextRow(openbase)) {
+      rb_ary_push(ary, rb_str_new2(relationship_name));
+    }
+  }
+  
+	return ary;
+}
+
+/* END OpenBase Schema Methods */
+
+
+/*** OpenBase: Query & Transaction Methods					 ***/
+
+static VALUE openbase_begin( VALUE self )
+{
+	OpenBasePtr openbase;
+
+	GET_OPENBASE_IF_CONNECTED(self, openbase);
+	
+	if ( !ob_beginTransaction(openbase) ) 
+		rb_raise(rb_cOpenBaseError, ob_serverMessage(openbase));
+
+	return Qnil;
+}
+
+static VALUE openbase_commit( VALUE self )
+{
+	OpenBasePtr openbase;
+
+	GET_OPENBASE_IF_CONNECTED(self, openbase);
+
+	if ( !ob_commitTransaction(openbase) ) 
+		rb_raise(rb_cOpenBaseError, ob_serverMessage(openbase));
+
+	return Qnil;
+}
+
+static VALUE openbase_rollback( VALUE self )
+{
+	OpenBasePtr openbase;
+
+	GET_OPENBASE_IF_CONNECTED(self, openbase);
+
+	if ( !ob_rollbackTransaction(openbase) ) 
+		rb_raise(rb_cOpenBaseError, ob_serverMessage(openbase));
+
+	return Qnil;
+}
+
+static VALUE openbase_transaction( VALUE self )
+{
+	OpenBasePtr openbase;
+	int error_code = 0; // default will rollback
+
+	GET_OPENBASE_IF_CONNECTED(self, openbase);
+
+	if ( !ob_beginTransaction(openbase) )
+	  rb_raise(rb_cOpenBaseError, ob_serverMessage(openbase));
+
+	rb_protect(rb_yield, self, &error_code);
+	if (error_code) {
+	  ob_rollbackTransaction(openbase);
+		rb_exc_raise(ruby_errinfo);
+	} else {
+		ob_commitTransaction(openbase);
+	}
+
+	return Qnil;
+}
+
+static VALUE openbase_transaction_in_progress( VALUE self )
+{
+  OpenBasePtr openbase;
+  
+  GET_OPENBASE_IF_CONNECTED(self, openbase);
+
+  if ( ob_isTransactionInProgress(openbase) ) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+static VALUE openbase_execute( VALUE self, VALUE statement )
+{
+	OpenBasePtr openbase;
+
+	Check_Type(statement, T_STRING);
+	GET_OPENBASE_IF_CONNECTED(self, openbase);
+
+	ob_makeCommand(openbase,RSTRING(statement)->ptr);
+	if ( !ob_executeCommand(openbase) )
+		rb_raise(rb_cOpenBaseError, ob_serverMessage(openbase));
+
+	return result_new(rb_cOpenBaseResult, self);
+}
+
+static VALUE openbase_unique_row_id( int argc, VALUE *argv, VALUE self )
+{
+  OpenBasePtr openbase;
+  VALUE table, column;
+  const char *row_id;
+
+  GET_OPENBASE_IF_CONNECTED(self, openbase);
+  rb_scan_args(argc, argv, "11", &table, &column);
+  
+  Check_Type(table, T_STRING);
+  if ( NIL_P(column) ) {
+    row_id = ob_uniqueRowIdForTable(openbase,StringValuePtr(table));
+  } else {
+    Check_Type(column, T_STRING);
+    row_id = ob_uniqueRowIdForTableColumn(openbase,StringValuePtr(table),StringValuePtr(column));
+  }
+  
+  return rb_cstr_to_inum(row_id, 10, Qfalse);
+}
+
+static VALUE openbase_insert_binary( VALUE self, VALUE data )
+{
+  OpenBasePtr openbase;
+  char blobKey[9]; // extra spot for the null character
+
+  Check_Type(data, T_STRING);
+
+  GET_OPENBASE_IF_CONNECTED(self, openbase);
+
+  strcpy(blobKey, ob_insertBinary(openbase,RSTRING(data)->ptr,RSTRING(data)->len) );
+  
+  return rb_str_new(blobKey, 8);
+}
+
+static VALUE openbase_fetch_blob( VALUE self, VALUE blob_key )
+{
+  OpenBasePtr openbase;
+  int blob_length;
+  
+  Check_Type(blob_key, T_STRING);
+  
+  GET_OPENBASE_IF_CONNECTED(self, openbase);
+  
+  return rb_str_new2(ob_retrieveBinary(openbase,(const char *)RSTRING(blob_key)->ptr,&blob_length));
+}
+/* End OpenBase Query & Transaction Methods */
+
+
+/*** OpenBaseResult: Construction/Destruction				 ***/
+
+static void result_mark( OpenBaseResult *result )
+{
+	rb_gc_mark(result->infos);
+	rb_gc_mark(result->col_names);
+}
+
+static void result_free( OpenBaseResult *result )
+{
+   int i;
+   for (i = 0; i < result->col_count; i++) {
+	  free(result->buf[i]);
+   }
+	free(result->types);
+	free(result->buf);
+	ob_deallocCursor(result->cursor);
+	ob_deallocConnection(result->openbase);
+   free(result);
+}
+
+static VALUE result_new( VALUE self, VALUE ob )
+{
+	OpenBasePtr openbase;
+	OpenBaseResult *result;
+	int count, col_type_code, return_code, has_blobs, i;
+	char msg[40];
+	VALUE info, value, data, result_data;
+	char *type;
+
+	openbase = (OpenBasePtr)(RDATA(ob)->data);
+	result = ALLOC(OpenBaseResult);
+   result->rows_affected = ob_rowsAffected(openbase);
+   result->col_names = rb_ary_new();
+   result->infos = rb_ary_new();
+	result->rows_fetched = 0;
+	result->has_been_offset = 0;
+	result->fetch_offset = 0;
+	result->fetch_limit = 0;
+
+   has_blobs = 0;
+  
+	result->col_count = ob_resultColumnCount(openbase);
+	result->types = ALLOC_N(int, result->col_count);
+	result->buf = ALLOC_N(void *, result->col_count);
+   VALUE col_names = rb_ary_new();
+   VALUE infos = rb_ary_new();
+	for (i = 0; i < result->col_count; i++) {
+	  col_type_code = ob_resultColumnType(openbase,i);
+		result->types[i] = col_type_code;
+		switch (col_type_code) {
+			case OBTYPE_CHAR:
+			  type = "char";
+				result->buf[i] = ALLOC_N(char, OB_CHAR_LENGTH);
+				ob_bindString(openbase,(char *)result->buf[i]);
+				break;
+			case OBTYPE_INT:
+				type = "int";
+				result->buf[i] = ALLOC(int);
+				ob_bindInt(openbase,(int *)result->buf[i]);
+				break;
+			case OBTYPE_FLOAT:
+				type = "float";
+				result->buf[i] = ALLOC(double);
+				ob_bindDouble(openbase,(double *)result->buf[i]);
+				break;
+			case OBTYPE_LONG:
+				type = "long";
+				result->buf[i] = ALLOC(long);
+				ob_bindLong(openbase,(long *)result->buf[i]);
+				break;
+			case OBTYPE_MONEY:
+				type = "money";
+				result->buf[i] = ALLOC_N(char, OB_MONEY_LENGTH);
+				ob_bindString(openbase,(char *)result->buf[i]);
+				break;
+			case OBTYPE_DATE:
+				type = "date";
+				result->buf[i] = ALLOC_N(char, OB_DATE_LENGTH);
+				ob_bindString(openbase,(char *)result->buf[i]);
+				break;
+			case OBTYPE_TIME:
+				type = "time";
+				result->buf[i] = ALLOC_N(char, OB_TIME_LENGTH);
+				ob_bindString(openbase,(char *)result->buf[i]);
+				break;
+			case OBTYPE_OBJECT:
+				type = "object";
+				has_blobs = 1;
+				result->buf[i] = ALLOC_N(char, OB_BLOB_KEY_LENGTH);
+				ob_bindString(openbase,(char *)result->buf[i]);
+				break;
+			case OBTYPE_DATETIME:
+				type = "datetime";
+				result->buf[i] = ALLOC_N(char, OB_DATETIME_LENGTH);
+				ob_bindString(openbase,(char *)result->buf[i]);
+				break;
+			case OBTYPE_LONGLONG:
+				type = "longlong";
+				result->buf[i] = ALLOC(long long);
+				ob_bindLongLong(openbase,(int *)result->buf[i]);
+				break;
+			case OBTYPE_BOOLEAN:
+				type = "boolean";
+				result->buf[i] = ALLOC_N(char, OB_BOOLEAN_LENGTH);
+				ob_bindString(openbase,(char *)result->buf[i]);
+				break;
+		  case OBTYPE_BINARY:
+				type = "binary";
+				has_blobs = 1;
+				result->buf[i] = ALLOC_N(char, OB_BLOB_KEY_LENGTH);
+				ob_bindString(openbase,(char *)result->buf[i]);
+				break;
+			case OBTYPE_OBJECT_TEXT:
+				type = "text";
+				has_blobs = 1;
+				result->buf[i] = ALLOC_N(char, OB_BLOB_KEY_LENGTH);
+				ob_bindString(openbase,(char *)result->buf[i]);
+				break;
+			case OBTYPE_TIMESTAMP:
+				type = "timestamp";
+				result->buf[i] = ALLOC_N(char, OB_TIMESTAMP_LENGTH);
+				ob_bindString(openbase,(char *)result->buf[i]);
+				break;
+			default:
+        break;
+		}
+      rb_ary_push(col_names,rb_str_new2(ob_resultColumnName(openbase,i)));
+		info = columninfo_new(rb_cOpenBaseColumnInfo, rb_str_new2(ob_resultColumnName(openbase,i)), \
+		        rb_str_new2(type), rb_str_new2(ob_resultTableName(openbase,i)));
+		rb_ary_push(infos, info);
+	}
+
+   result->col_names = col_names;
+   result->infos = infos;
+   result->cursor = ob_retrieveCursor(openbase);
+   result->openbase = ob_newConnection();
+   if (has_blobs) {
+      // Create a connection for retrieving blobs
+  	   ob_connectToDatabase( result->openbase, \
+  	      ob_databaseName(openbase), \
+  	      ob_hostName(openbase), \
+  	      ob_loginName(openbase), \
+  	      ob_password(openbase), \
+  	      "", "", \
+  	      &return_code);
+   }
+	return Data_Wrap_Struct(self, result_mark, result_free, result);
+}
+
+/* END OpenBaseResult Construction/Destruction */
+
+
+#define PUSH_COLUMN(row,col_name,col_value,returnAsHash) \
+  if (returnAsHash) { rb_hash_aset(row,col_name,col_value); } \
+  else { rb_ary_push(row,col_value); }
+
+#define PARSE(klass, value) rb_funcall(klass, rb_intern("parse"), 1, value)
+
+static VALUE result_retrieve_binary(OpenBasePtr conn, char *blob_key, int *returned_size);
+
+/*** OpenBaseResult: Fetching/Iteration ***/
+static VALUE result_fetch( VALUE self, int returnAsHash )
+{
+  OpenBaseResult *result;
+  int i;
+  VALUE row, col_name;
+  
+  if ( returnAsHash ) {
+    row = rb_hash_new();
+  } else {
+    row = rb_ary_new();
+  }
+  
+  GET_RESULT(self, result);
+  
+  if (!result->has_been_offset) {
+    result->has_been_offset = 1;
+    for(i=0; i<result->fetch_offset; i++) {ob_nextCursorRow(result->cursor);}
+  }
+  
+
+  if (result->fetch_limit && result->fetch_limit <= result->rows_fetched) {
+    return Qnil;
+    
+  } else if (ob_nextCursorRow(result->cursor)) {
+    result->rows_fetched++;
+    for (i = 0; i < result->col_count; i++) {
+      col_name = rb_ary_entry(result->col_names, i);
+      if (ob_isCursorColumnNULL(result->cursor, i)) {
+        PUSH_COLUMN(row, col_name, Qnil, returnAsHash);
+      } else {
+        switch (result->types[i]) {
+          case OBTYPE_CHAR:
+          {
+            if (strlen((char *)result->buf[i]) == 0) {
+              PUSH_COLUMN(row, col_name, Qnil, returnAsHash);
+            } else {
+              PUSH_COLUMN(row, col_name, rb_str_new2((char *)result->buf[i]), returnAsHash);
+            }
+            break;
+          }
+          case OBTYPE_MONEY: 
+          {
+            VALUE money_string = rb_tainted_str_new2((char *)result->buf[i]);
+            rb_funcall(money_string,rb_gsub_bang_id,2,rb_reg_new("[$,]",4,0),rb_str_new("",0));
+            VALUE money_value = rb_funcall(rb_cBigDecimal, rb_intern("new"), 1, money_string);
+            PUSH_COLUMN(row, col_name, money_value, returnAsHash);
+            break;
+          }
+          case OBTYPE_DATE: 
+          {
+            if (strlen((char *)result->buf[i]) == 0) {
+              PUSH_COLUMN(row, col_name, Qnil, returnAsHash);
+            } else {
+              VALUE date_string = rb_str_new2((char *)result->buf[i]);
+              rb_funcall(date_string,rb_gsub_bang_id,2,rb_reg_new("\\.",2,0),rb_str_new("-",1));
+              PUSH_COLUMN(row, col_name, PARSE(rb_cDate,date_string), returnAsHash);
+            }
+            break;
+          }
+          case OBTYPE_TIME:
+          case OBTYPE_DATETIME:
+          case OBTYPE_TIMESTAMP:
+          {
+            PUSH_COLUMN(row, col_name, PARSE(rb_cTime,rb_str_new2((char *)result->buf[i])), returnAsHash);
+            break;
+          }
+          case OBTYPE_BOOLEAN: 
+          {
+            VALUE boolVal;
+            char * boolS = (char *)result->buf[i];
+            if (strlen(boolS) == 0)
+              boolVal = Qnil;
+            else if (strcmp(boolS, "1") == 0)
+              boolVal = Qtrue;
+            else
+              boolVal = Qfalse;
+            PUSH_COLUMN(row, col_name, boolVal, returnAsHash);
+            break;
+          }
+          case OBTYPE_INT:
+          case OBTYPE_LONG: 
+          {
+            PUSH_COLUMN(row, col_name, LONG2NUM(*(long *)result->buf[i]), returnAsHash);
+            break;
+          }
+          case OBTYPE_LONGLONG:
+          {
+            PUSH_COLUMN(row, col_name, LL2NUM(*(long long *)result->buf[i]), returnAsHash);
+            break;
+          }
+          case OBTYPE_FLOAT: 
+          {
+            PUSH_COLUMN(row, col_name, rb_float_new(*(double *)result->buf[i]), returnAsHash);
+            break;
+          }
+          case OBTYPE_BINARY:
+          case OBTYPE_OBJECT:
+          case OBTYPE_OBJECT_TEXT: 
+          {
+            int data_size;
+            VALUE data = result_retrieve_binary(result->openbase,(char *)result->buf[i],&data_size);
+            PUSH_COLUMN(row, col_name, data, returnAsHash);
+            break;
+          }
+          default:
+            rb_raise(rb_cOpenBaseError, "Unknown result column type for column '%s'", ob_cursorColumnName(result->cursor,i));
+        }
+      }
+    }
+    return row;
+  
+  } else { // No More Rows
+    return Qnil;
+  }
+}
+
+
+void _setErrorMessage(OpenBasePtr conn, int errorCode);
+static VALUE result_retrieve_binary(OpenBasePtr conn, char *blob_key, int *returned_size)
+{
+  const char *blob_data;
+
+  prepareDictionary(conn->altConnection);
+  addDictionaryPair(conn->altConnection, "action", "call_getFile");
+  addDictionaryPair(conn->altConnection, "fileKey", blob_key);
+  if (!sendBuffer(conn->altConnection)){
+      _setErrorMessage(conn, ERR_NOSERVER);
+      return 0;
+  }
+//  YIELD_THREAD;
+  
+  if (readResult(conn->altConnection) == 0) {
+      *returned_size = 0;
+      ob_invalidate(conn);
+      return Qnil; // failure
+  }
+
+  blob_data = resultValueForKey(conn->altConnection, "data", returned_size);
+  if (!blob_data) {
+      *returned_size = 0;
+      ob_invalidate(conn);
+      return Qnil; // failure
+  }
+  return rb_str_new(blob_data,(long int)*returned_size);
+}
+
+#define AS_ARRAY NO
+#define AS_HASH YES
+static VALUE result_fetch_array( VALUE self)
+{
+  return result_fetch( self, AS_ARRAY );
+}
+
+static VALUE result_fetch_hash( VALUE self )
+{
+  return result_fetch( self, AS_HASH );
+}
+
+static VALUE result_each( VALUE self )
+{
+  VALUE row;
+
+  while ((row = result_fetch(self, AS_ARRAY)) != Qnil) {
+    rb_yield(row);
+  }
+
+  return self;
+}
+
+static VALUE result_each_hash( VALUE self )
+{
+  VALUE row;
+
+  while ((row = result_fetch(self, AS_HASH)) != Qnil) {
+    rb_yield(row);
+  }
+
+  return self;
+}
+
+static VALUE result_fetch_all( VALUE self )
+{
+  VALUE row;
+  VALUE all_rows = rb_ary_new();
+  
+  while ((row = result_fetch(self, AS_ARRAY)) != Qnil) {
+    rb_ary_push(all_rows, row);
+  }
+  
+  return all_rows;
+}
+#undef AS_ARRAY
+#undef AS_HASH
+
+static VALUE result_get_fetch_limit( VALUE self )
+{
+  OpenBaseResult *result;
+
+  GET_RESULT(self, result);
+  
+  return INT2FIX(result->fetch_limit);
+}
+static VALUE result_set_fetch_limit( VALUE self, VALUE limit )
+{
+  OpenBaseResult *result;
+
+  GET_RESULT(self, result);
+  
+  result->fetch_limit = FIX2INT(limit);
+  return Qtrue;
+}
+
+static VALUE result_get_fetch_offset( VALUE self )
+{
+  OpenBaseResult *result;
+
+  GET_RESULT(self, result);
+  
+  return INT2FIX(result->fetch_offset);
+}
+static VALUE result_set_fetch_offset( VALUE self, VALUE offset )
+{
+  OpenBaseResult *result;
+
+  GET_RESULT(self, result);
+  
+  result->fetch_offset = FIX2INT(offset);
+  return Qtrue;
+}
+/* END OpenBaseResult Fetching/Iteration */
+
+
+/*** OpenBaseResult: Column Information ***/
+static VALUE result_column_count( VALUE self )
+{
+  OpenBaseResult *result;
+  
+  GET_RESULT(self, result);
+  
+  return INT2FIX(result->col_count);
+}
+
+static VALUE result_rows_affected( VALUE self )
+{
+  OpenBaseResult *result;
+
+  GET_RESULT(self, result);
+  
+  return INT2FIX(result->rows_affected);
+}
+
+static VALUE result_column_infos( VALUE self )
+{
+  OpenBaseResult *result;
+  GET_RESULT(self, result);
+  return result->infos;
+}
+
+/* END OpenBaseResult Column Information */
+
+
+/*** OpenBaseColumnInfo Construction/Destruction ***/
+
+static void columninfo_mark( OpenBaseColumnInfo *info )
+{
+  rb_gc_mark(info->name);
+  rb_gc_mark(info->type);
+  rb_gc_mark(info->table);
+}
+
+static void columninfo_free( OpenBaseColumnInfo *info )
+{
+  free(info);
+}
+
+static VALUE columninfo_new( VALUE self, VALUE name, VALUE type, VALUE table )
+{
+  OpenBaseColumnInfo *info;
+  info = ALLOC(OpenBaseColumnInfo);
+
+  Check_Type(name, T_STRING);
+  Check_Type(type, T_STRING);
+  Check_Type(table, T_STRING);
+  info->name = name;
+  info->type = type;
+  info->table = table;
+
+  return Data_Wrap_Struct(self, columninfo_mark, columninfo_free, info);
+}
+
+/* END OpenBaseColumnInfo Construction/Destruction */
+
+
+/*** OpenBaseColumnInfo: Getter Methods ***/
+
+static VALUE columninfo_name( VALUE self )
+{
+  OpenBaseColumnInfo *info;
+  GET_INFO(self, info);
+  return info->name;
+}
+
+
+static VALUE columninfo_type( VALUE self )
+{
+  OpenBaseColumnInfo *info;
+  GET_INFO(self, info);
+  return info->type;
+}
+
+
+static VALUE columninfo_table( VALUE self )
+{
+  OpenBaseColumnInfo *info;
+  GET_INFO(self, info);
+  return info->table;
+}
+
+/* END OpenBaseColumInfo Getter Methods */
+
+
+
+/*********************** OpenBase Library Interface *************************/
+// This typedef and macro address a complaint by the compiler 
+// concerning the callbacks passed to rb_define_method.
+//typedef VALUE (ruby_method)(...);
+//#define CALLBACK(method_name) (ruby_method*)&method_name
+#define CALLBACK(method_name) method_name
+
+void Init_openbase() {
+	const int VARIABLE_C_ARRAY = -1;
+	const int VARIABLE_RB_ARRAY = -2;
+	
+	rb_gsub_bang_id = rb_intern("gsub!");
+	rb_date_regex = rb_reg_new("\\.",2,0);
+	rb_replacement_str = rb_str_new("-",1);
+	
+  rb_require("date");
+  rb_require("time");
+  rb_require("bigdecimal");
+  rb_cDate = rb_const_get(rb_cObject, rb_intern("Date"));
+  rb_cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
+	
+	// OpenBaseError: Simple Error Object
+	rb_cOpenBaseError = rb_define_class("OpenBaseError", rb_eStandardError);
+	
+	
+	// OpenBase: Class Definition, Construction, & Destruction
+	rb_cOpenBase = rb_define_class("OpenBase", rb_cObject);
+	rb_define_alloc_func(rb_cOpenBase, openbase_alloc);
+	rb_define_method(rb_cOpenBase, "initialize", CALLBACK(openbase_initialize), VARIABLE_C_ARRAY);
+	
+	// OpenBase: Connection Related Methods
+	rb_define_method(rb_cOpenBase, "connect", CALLBACK(openbase_connect), VARIABLE_C_ARRAY);
+	rb_define_method(rb_cOpenBase, "connected?", CALLBACK(openbase_isConnected), 0);
+	rb_define_alias(rb_cOpenBase, "connect?", "connected?");
+	rb_define_method(rb_cOpenBase, "invalidate", CALLBACK(openbase_invalidate), 0);
+	rb_define_alias(rb_cOpenBase, "disconnect", "invalidate");
+	rb_define_method(rb_cOpenBase, "database", CALLBACK(openbase_database), 0);
+	rb_define_method(rb_cOpenBase, "host", CALLBACK(openbase_host), 0);
+	rb_define_method(rb_cOpenBase, "login", CALLBACK(openbase_login), 0);
+	rb_define_method(rb_cOpenBase, "password", CALLBACK(openbase_password), 0);
+	rb_define_method(rb_cOpenBase, "encoding", CALLBACK(openbase_encoding), 0);
+	
+	// OpenBase: Schema Related Methods
+	rb_define_method(rb_cOpenBase, "tables", CALLBACK(openbase_tables), 0);
+	rb_define_method(rb_cOpenBase, "columns", CALLBACK(openbase_columns), 1);
+	rb_define_method(rb_cOpenBase, "relationships", CALLBACK(openbase_relationships), 1);
+	
+	// OpenBase: Query & Transaction Related Methods
+	rb_define_method(rb_cOpenBase, "begin", CALLBACK(openbase_begin), 0);
+	rb_define_method(rb_cOpenBase, "commit", CALLBACK(openbase_commit), 0);
+	rb_define_method(rb_cOpenBase, "rollback", CALLBACK(openbase_rollback), 0);
+	rb_define_method(rb_cOpenBase, "transaction?", CALLBACK(openbase_transaction_in_progress), 0);
+	rb_define_method(rb_cOpenBase, "transaction", CALLBACK(openbase_transaction), 0);
+	rb_define_method(rb_cOpenBase, "execute", CALLBACK(openbase_execute), 1);
+	rb_define_method(rb_cOpenBase, "unique_row_id", CALLBACK(openbase_unique_row_id), VARIABLE_C_ARRAY);
+	rb_define_method(rb_cOpenBase, "insert_binary", CALLBACK(openbase_insert_binary), 1);
+	rb_define_method(rb_cOpenBase, "fetch_blob", CALLBACK(openbase_fetch_blob),1);
+	
+	
+	// OpenBaseResult: Class Definition, Construction, & Destruction
+	rb_cOpenBaseResult = rb_define_class("OpenBaseResult", rb_cObject);
+	rb_define_singleton_method(rb_cOpenBaseResult, "new", CALLBACK(result_new), 1);
+	rb_include_module(rb_cOpenBaseResult, rb_mEnumerable); // Array behavior
+	
+	// OpenBaseResult: Attributes
+	rb_define_method(rb_cOpenBaseResult, "fetch_limit", CALLBACK(result_get_fetch_limit), 0);
+	rb_define_method(rb_cOpenBaseResult, "fetch_limit=", CALLBACK(result_set_fetch_limit), 1);
+	rb_define_method(rb_cOpenBaseResult, "fetch_offset", CALLBACK(result_get_fetch_offset), 0);
+	rb_define_method(rb_cOpenBaseResult, "fetch_offset=", CALLBACK(result_set_fetch_offset), 1);
+	
+	// OpenBaseResult: Fetching, Iteration
+	rb_define_method(rb_cOpenBaseResult, "fetch", CALLBACK(result_fetch_array), 0);
+	rb_define_method(rb_cOpenBaseResult, "fetch_hash", CALLBACK(result_fetch_hash), 0);
+  rb_define_method(rb_cOpenBaseResult, "each", CALLBACK(result_each), 0);
+  rb_define_method(rb_cOpenBaseResult, "each_hash", CALLBACK(result_each_hash), 0);
+  rb_define_method(rb_cOpenBaseResult, "fetch_all", CALLBACK(result_fetch_all), 0);
+  
+  // OpenBaseResult: Column Information 
+  rb_define_method(rb_cOpenBaseResult, "column_count", CALLBACK(result_column_count), 0);
+	rb_define_method(rb_cOpenBaseResult, "rows_affected", CALLBACK(result_rows_affected), 0);
+	rb_define_method(rb_cOpenBaseResult, "column_infos", CALLBACK(result_column_infos), 0);
+	
+	
+	// OpenBaseColumnInfo: Class Definition, Construction & Destruction
+	rb_cOpenBaseColumnInfo = rb_define_class("OpenBaseColumnInfo", rb_cObject);
+	rb_define_singleton_method(rb_cOpenBaseColumnInfo, "new", CALLBACK(columninfo_new), 3);
+	
+	// OpenBaseColumnInfo: Getter Methods
+	rb_define_method(rb_cOpenBaseColumnInfo, "name", CALLBACK(columninfo_name), 0);
+  rb_define_method(rb_cOpenBaseColumnInfo, "type", CALLBACK(columninfo_type), 0);
+  rb_define_method(rb_cOpenBaseColumnInfo, "table", CALLBACK(columninfo_table), 0);
+
+}