do_sqlite3 0.10.10 → 0.10.11

data/ChangeLog.markdown

@@ -1,3 +1,7 @@
+## 0.10.11 2012-12-29
+
+* Rename C symbols to prevent name collitions
+
 ## 0.10.10 2012-10-11
 
 * Add support to C driver for busy\_timeout

data/ext/do_sqlite3/do_common.c

@@ -11,13 +11,13 @@
  */
 
 // To store rb_intern values
-ID ID_NEW;
-ID ID_NEW_DATE;
-ID ID_CONST_GET;
-ID ID_RATIONAL;
-ID ID_ESCAPE;
-ID ID_STRFTIME;
-ID ID_LOG;
+ID DO_ID_NEW;
+ID DO_ID_NEW_DATE;
+ID DO_ID_CONST_GET;
+ID DO_ID_RATIONAL;
+ID DO_ID_ESCAPE;
+ID DO_ID_STRFTIME;
+ID DO_ID_LOG;
 
 // Reference to Extlib module
 VALUE mExtlib;
@@ -33,8 +33,8 @@ VALUE cDO_Reader;
 VALUE cDO_Logger;
 VALUE cDO_Logger_Message;
 VALUE cDO_Extension;
-VALUE eConnectionError;
-VALUE eDataError;
+VALUE eDO_ConnectionError;
+VALUE eDO_DataError;
 
 // References to Ruby classes that we'll need
 VALUE rb_cDate;
@@ -47,7 +47,7 @@ VALUE rb_cBigDecimal;
 
 
 VALUE data_objects_const_get(VALUE scope, const char *constant) {
-  return rb_funcall(scope, ID_CONST_GET, 1, rb_str_new2(constant));
+  return rb_funcall(scope, DO_ID_CONST_GET, 1, rb_str_new2(constant));
 }
 
 void data_objects_debug(VALUE connection, VALUE string, struct timeval *start) {
@@ -58,9 +58,9 @@ void data_objects_debug(VALUE connection, VALUE string, struct timeval *start) {
   gettimeofday(&stop, NULL);
   duration = (stop.tv_sec - start->tv_sec) * 1000000 + stop.tv_usec - start->tv_usec;
 
-  message = rb_funcall(cDO_Logger_Message, ID_NEW, 3, string, rb_time_new(start->tv_sec, start->tv_usec), INT2NUM(duration));
+  message = rb_funcall(cDO_Logger_Message, DO_ID_NEW, 3, string, rb_time_new(start->tv_sec, start->tv_usec), INT2NUM(duration));
 
-  rb_funcall(connection, ID_LOG, 1, message);
+  rb_funcall(connection, DO_ID_LOG, 1, message);
 }
 
 void data_objects_raise_error(VALUE self, const struct errcodes *errors, int errnum, const char *message, VALUE query, VALUE state) {
@@ -80,7 +80,7 @@ void data_objects_raise_error(VALUE self, const struct errcodes *errors, int err
 
   exception = rb_funcall(
     data_objects_const_get(mDO, exception_type),
-    ID_NEW,
+    DO_ID_NEW,
     5,
     rb_str_new2(message),
     INT2NUM(errnum),
@@ -125,7 +125,7 @@ VALUE data_objects_build_query_from_args(VALUE klass, int count, VALUE *args) {
     rb_ary_push(array, args[i]);
   }
 
-  return rb_funcall(klass, ID_ESCAPE, 1, array);
+  return rb_funcall(klass, DO_ID_ESCAPE, 1, array);
 }
 
 // Find the greatest common denominator and reduce the provided numerator and denominator.
@@ -163,7 +163,7 @@ VALUE data_objects_seconds_to_offset(long seconds_offset) {
   do_int64 den = 86400;
 
   data_objects_reduce(&num, &den);
-  return rb_funcall(rb_mKernel, ID_RATIONAL, 2, rb_ll2inum(num), rb_ll2inum(den));
+  return rb_funcall(rb_mKernel, DO_ID_RATIONAL, 2, rb_ll2inum(num), rb_ll2inum(den));
 }
 
 VALUE data_objects_timezone_to_offset(int hour_offset, int minute_offset) {
@@ -189,7 +189,7 @@ VALUE data_objects_parse_date(const char *date) {
     return Qnil;
   }
 
-  return rb_funcall(rb_cDate, ID_NEW, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day));
+  return rb_funcall(rb_cDate, DO_ID_NEW, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day));
 }
 
 VALUE data_objects_parse_time(const char *date) {
@@ -299,11 +299,11 @@ VALUE data_objects_parse_date_time(const char *date) {
       break;
 
     default: /* Any other combo of missing tokens and we can't do anything */
-      rb_raise(eDataError, "Couldn't parse date: %s", date);
+      rb_raise(eDO_DataError, "Couldn't parse date: %s", date);
   }
 
   offset = data_objects_timezone_to_offset(hour_offset, minute_offset);
-  return rb_funcall(rb_cDateTime, ID_NEW, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day),
+  return rb_funcall(rb_cDateTime, DO_ID_NEW, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day),
                                              INT2NUM(hour), INT2NUM(min), INT2NUM(sec), offset);
 }
 
@@ -320,17 +320,17 @@ VALUE data_objects_cConnection_ssl_cipher(VALUE self) {
 }
 
 VALUE data_objects_cConnection_quote_time(VALUE self, VALUE value) {
-  return rb_funcall(value, ID_STRFTIME, 1, rb_str_new2("'%Y-%m-%d %H:%M:%S'"));
+  return rb_funcall(value, DO_ID_STRFTIME, 1, rb_str_new2("'%Y-%m-%d %H:%M:%S'"));
 }
 
 VALUE data_objects_cConnection_quote_date_time(VALUE self, VALUE value) {
   // TODO: Support non-local dates. we need to call #new_offset on the date to be
   // quoted and pass in the current locale's date offset (self.new_offset((hours * 3600).to_r / 86400)
-  return rb_funcall(value, ID_STRFTIME, 1, rb_str_new2("'%Y-%m-%d %H:%M:%S'"));
+  return rb_funcall(value, DO_ID_STRFTIME, 1, rb_str_new2("'%Y-%m-%d %H:%M:%S'"));
 }
 
 VALUE data_objects_cConnection_quote_date(VALUE self, VALUE value) {
-  return rb_funcall(value, ID_STRFTIME, 1, rb_str_new2("'%Y-%m-%d'"));
+  return rb_funcall(value, DO_ID_STRFTIME, 1, rb_str_new2("'%Y-%m-%d'"));
 }
 
 /*
@@ -379,7 +379,7 @@ VALUE data_objects_cReader_values(VALUE self) {
   VALUE values = rb_iv_get(self, "@values");
 
   if (state == Qnil || state == Qfalse || values == Qnil) {
-    rb_raise(eDataError, "Reader is not initialized");
+    rb_raise(eDO_DataError, "Reader is not initialized");
   }
 
   return rb_iv_get(self, "@values");
@@ -400,24 +400,24 @@ void data_objects_common_init(void) {
   rb_require("data_objects");
 
   // Needed by data_objects_const_get
-  ID_CONST_GET = rb_intern("const_get");
+  DO_ID_CONST_GET = rb_intern("const_get");
 
   // Get references classes needed for Date/Time parsing
   rb_cDate = data_objects_const_get(rb_mKernel, "Date");
   rb_cDateTime = data_objects_const_get(rb_mKernel, "DateTime");
   rb_cBigDecimal = data_objects_const_get(rb_mKernel, "BigDecimal");
 
-  ID_NEW = rb_intern("new");
+  DO_ID_NEW = rb_intern("new");
 #ifdef RUBY_LESS_THAN_186
-  ID_NEW_DATE = rb_intern("new0");
+  DO_ID_NEW_DATE = rb_intern("new0");
 #else
-  ID_NEW_DATE = rb_intern("new!");
+  DO_ID_NEW_DATE = rb_intern("new!");
 #endif
-  ID_CONST_GET = rb_intern("const_get");
-  ID_RATIONAL = rb_intern("Rational");
-  ID_ESCAPE = rb_intern("escape_sql");
-  ID_STRFTIME = rb_intern("strftime");
-  ID_LOG = rb_intern("log");
+  DO_ID_CONST_GET = rb_intern("const_get");
+  DO_ID_RATIONAL = rb_intern("Rational");
+  DO_ID_ESCAPE = rb_intern("escape_sql");
+  DO_ID_STRFTIME = rb_intern("strftime");
+  DO_ID_LOG = rb_intern("log");
 
   // Get references to the Extlib module
   mExtlib = data_objects_const_get(rb_mKernel, "Extlib");
@@ -434,15 +434,15 @@ void data_objects_common_init(void) {
   cDO_Logger_Message = data_objects_const_get(cDO_Logger, "Message");
   cDO_Extension = data_objects_const_get(mDO, "Extension");
 
-  eConnectionError = data_objects_const_get(mDO, "ConnectionError");
-  eDataError = data_objects_const_get(mDO, "DataError");
+  eDO_ConnectionError = data_objects_const_get(mDO, "ConnectionError");
+  eDO_DataError = data_objects_const_get(mDO, "DataError");
 
-  rb_global_variable(&ID_NEW_DATE);
-  rb_global_variable(&ID_RATIONAL);
-  rb_global_variable(&ID_CONST_GET);
-  rb_global_variable(&ID_ESCAPE);
-  rb_global_variable(&ID_LOG);
-  rb_global_variable(&ID_NEW);
+  rb_global_variable(&DO_ID_NEW_DATE);
+  rb_global_variable(&DO_ID_RATIONAL);
+  rb_global_variable(&DO_ID_CONST_GET);
+  rb_global_variable(&DO_ID_ESCAPE);
+  rb_global_variable(&DO_ID_LOG);
+  rb_global_variable(&DO_ID_NEW);
 
   rb_global_variable(&rb_cDate);
   rb_global_variable(&rb_cDateTime);
@@ -452,8 +452,8 @@ void data_objects_common_init(void) {
   rb_global_variable(&mDO);
   rb_global_variable(&cDO_Logger_Message);
 
-  rb_global_variable(&eConnectionError);
-  rb_global_variable(&eDataError);
+  rb_global_variable(&eDO_ConnectionError);
+  rb_global_variable(&eDO_DataError);
 
   tzset();
 }
@@ -478,7 +478,7 @@ extern VALUE data_objects_typecast(const char *value, long length, const VALUE t
     return rb_float_new(rb_cstr_to_dbl(value, Qfalse));
   }
   else if (type == rb_cBigDecimal) {
-    return rb_funcall(rb_cBigDecimal, ID_NEW, 1, rb_str_new(value, length));
+    return rb_funcall(rb_cBigDecimal, DO_ID_NEW, 1, rb_str_new(value, length));
   }
   else if (type == rb_cDate) {
     return data_objects_parse_date(value);
@@ -493,7 +493,7 @@ extern VALUE data_objects_typecast(const char *value, long length, const VALUE t
     return (!value || strcmp("0", value) == 0) ? Qfalse : Qtrue;
   }
   else if (type == rb_cByteArray) {
-    return rb_funcall(rb_cByteArray, ID_NEW, 1, rb_str_new(value, length));
+    return rb_funcall(rb_cByteArray, DO_ID_NEW, 1, rb_str_new(value, length));
   }
   else if (type == rb_cClass) {
     return rb_funcall(mDO, rb_intern("full_const_get"), 1, rb_str_new(value, length));

data/ext/do_sqlite3/do_common.h

@@ -54,13 +54,13 @@ typedef signed long long int do_int64;
 #endif
 
 // To store rb_intern values
-extern ID ID_NEW;
-extern ID ID_NEW_DATE;
-extern ID ID_CONST_GET;
-extern ID ID_RATIONAL;
-extern ID ID_ESCAPE;
-extern ID ID_STRFTIME;
-extern ID ID_LOG;
+extern ID DO_ID_NEW;
+extern ID DO_ID_NEW_DATE;
+extern ID DO_ID_CONST_GET;
+extern ID DO_ID_RATIONAL;
+extern ID DO_ID_ESCAPE;
+extern ID DO_ID_STRFTIME;
+extern ID DO_ID_LOG;
 
 // Reference to Extlib module
 extern VALUE mExtlib;
@@ -68,7 +68,6 @@ extern VALUE rb_cByteArray;
 
 // References to DataObjects base classes
 extern VALUE mDO;
-extern VALUE mEncoding;
 extern VALUE cDO_Quoting;
 extern VALUE cDO_Connection;
 extern VALUE cDO_Command;
@@ -77,8 +76,8 @@ extern VALUE cDO_Reader;
 extern VALUE cDO_Logger;
 extern VALUE cDO_Logger_Message;
 extern VALUE cDO_Extension;
-extern VALUE eConnectionError;
-extern VALUE eDataError;
+extern VALUE eDO_ConnectionError;
+extern VALUE eDO_DataError;
 
 // References to Ruby classes that we'll need
 extern VALUE rb_cDate;

data/ext/do_sqlite3/do_sqlite3.c

@@ -3,17 +3,17 @@
 
 #include "do_common.h"
 
-VALUE mSqlite3;
-VALUE cSqlite3Connection;
-VALUE cSqlite3Command;
-VALUE cSqlite3Result;
-VALUE cSqlite3Reader;
-
-VALUE OPEN_FLAG_READONLY;
-VALUE OPEN_FLAG_READWRITE;
-VALUE OPEN_FLAG_CREATE;
-VALUE OPEN_FLAG_NO_MUTEX;
-VALUE OPEN_FLAG_FULL_MUTEX;
+VALUE mDO_Sqlite3;
+VALUE cDO_Sqlite3Connection;
+VALUE cDO_Sqlite3Command;
+VALUE cDO_Sqlite3Result;
+VALUE cDO_Sqlite3Reader;
+
+VALUE DO_OPEN_FLAG_READONLY;
+VALUE DO_OPEN_FLAG_READWRITE;
+VALUE DO_OPEN_FLAG_CREATE;
+VALUE DO_OPEN_FLAG_NO_MUTEX;
+VALUE DO_OPEN_FLAG_FULL_MUTEX;
 
 void do_sqlite3_raise_error(VALUE self, sqlite3 *result, VALUE query) {
   int errnum = sqlite3_errcode(result);
@@ -67,7 +67,7 @@ VALUE do_sqlite3_typecast(sqlite3_stmt *stmt, int i, VALUE type, int encoding) {
     return rb_float_new(sqlite3_column_double(stmt, i));
   }
   else if (type == rb_cBigDecimal) {
-    return rb_funcall(rb_cBigDecimal, ID_NEW, 1, rb_str_new((char*)sqlite3_column_text(stmt, i), length));
+    return rb_funcall(rb_cBigDecimal, DO_ID_NEW, 1, rb_str_new((char*)sqlite3_column_text(stmt, i), length));
   }
   else if (type == rb_cDate) {
     return data_objects_parse_date((char*)sqlite3_column_text(stmt, i));
@@ -82,7 +82,7 @@ VALUE do_sqlite3_typecast(sqlite3_stmt *stmt, int i, VALUE type, int encoding) {
     return strcmp((char*)sqlite3_column_text(stmt, i), "t") == 0 ? Qtrue : Qfalse;
   }
   else if (type == rb_cByteArray) {
-    return rb_funcall(rb_cByteArray, ID_NEW, 1, rb_str_new((char*)sqlite3_column_blob(stmt, i), length));
+    return rb_funcall(rb_cByteArray, DO_ID_NEW, 1, rb_str_new((char*)sqlite3_column_blob(stmt, i), length));
   }
   else if (type == rb_cClass) {
     return rb_funcall(mDO, rb_intern("full_const_get"), 1, rb_str_new((char*)sqlite3_column_text(stmt, i), length));
@@ -106,7 +106,7 @@ int do_sqlite3_flags_from_uri(VALUE uri) {
   if (!NIL_P(query_values) && TYPE(query_values) == T_HASH) {
     /// scan for flags
 #ifdef SQLITE_OPEN_READONLY
-    if (FLAG_PRESENT(query_values, OPEN_FLAG_READONLY)) {
+    if (FLAG_PRESENT(query_values, DO_OPEN_FLAG_READONLY)) {
       flags |= SQLITE_OPEN_READONLY;
     }
     else {
@@ -115,13 +115,13 @@ int do_sqlite3_flags_from_uri(VALUE uri) {
 #endif
 
 #ifdef SQLITE_OPEN_NOMUTEX
-    if (FLAG_PRESENT(query_values, OPEN_FLAG_NO_MUTEX)) {
+    if (FLAG_PRESENT(query_values, DO_OPEN_FLAG_NO_MUTEX)) {
       flags |= SQLITE_OPEN_NOMUTEX;
     }
 #endif
 
 #ifdef SQLITE_OPEN_FULLMUTEX
-    if (FLAG_PRESENT(query_values, OPEN_FLAG_FULL_MUTEX)) {
+    if (FLAG_PRESENT(query_values, DO_OPEN_FLAG_FULL_MUTEX)) {
       flags |= SQLITE_OPEN_FULLMUTEX;
     }
 #endif
@@ -241,7 +241,7 @@ VALUE do_sqlite3_cCommand_execute_non_query(int argc, VALUE *argv, VALUE self) {
   VALUE sqlite3_connection = rb_iv_get(connection, "@connection");
 
   if (sqlite3_connection == Qnil) {
-    rb_raise(eConnectionError, "This connection has already been closed.");
+    rb_raise(eDO_ConnectionError, "This connection has already been closed.");
   }
 
   sqlite3 *db = NULL;
@@ -264,7 +264,7 @@ VALUE do_sqlite3_cCommand_execute_non_query(int argc, VALUE *argv, VALUE self) {
   int affected_rows = sqlite3_changes(db);
   do_int64 insert_id = sqlite3_last_insert_rowid(db);
 
-  return rb_funcall(cSqlite3Result, ID_NEW, 3, self, INT2NUM(affected_rows), INT2NUM(insert_id));
+  return rb_funcall(cDO_Sqlite3Result, DO_ID_NEW, 3, self, INT2NUM(affected_rows), INT2NUM(insert_id));
 }
 
 VALUE do_sqlite3_cCommand_execute_reader(int argc, VALUE *argv, VALUE self) {
@@ -273,7 +273,7 @@ VALUE do_sqlite3_cCommand_execute_reader(int argc, VALUE *argv, VALUE self) {
   VALUE sqlite3_connection = rb_iv_get(connection, "@connection");
 
   if (sqlite3_connection == Qnil) {
-    rb_raise(eConnectionError, "This connection has already been closed.");
+    rb_raise(eDO_ConnectionError, "This connection has already been closed.");
   }
 
   sqlite3 *db = NULL;
@@ -293,7 +293,7 @@ VALUE do_sqlite3_cCommand_execute_reader(int argc, VALUE *argv, VALUE self) {
   }
 
   int field_count = sqlite3_column_count(sqlite3_reader);
-  VALUE reader = rb_funcall(cSqlite3Reader, ID_NEW, 0);
+  VALUE reader = rb_funcall(cDO_Sqlite3Reader, DO_ID_NEW, 0);
 
   rb_iv_set(reader, "@reader", Data_Wrap_Struct(rb_cObject, 0, 0, sqlite3_reader));
   rb_iv_set(reader, "@field_count", INT2NUM(field_count));
@@ -343,7 +343,7 @@ VALUE do_sqlite3_cReader_next(VALUE self) {
   VALUE reader = rb_iv_get(self, "@reader");
 
   if(reader == Qnil) {
-    rb_raise(eConnectionError, "This result set has already been closed.");
+    rb_raise(eDO_ConnectionError, "This result set has already been closed.");
   }
 
   if (rb_iv_get(self, "@done") == Qtrue) {
@@ -394,7 +394,7 @@ VALUE do_sqlite3_cReader_values(VALUE self) {
   VALUE state = rb_iv_get(self, "@state");
 
   if (state == Qnil || NUM2INT(state) != SQLITE_ROW) {
-    rb_raise(eDataError, "Reader is not initialized");
+    rb_raise(eDO_DataError, "Reader is not initialized");
     return Qnil;
   }
 
@@ -404,45 +404,45 @@ VALUE do_sqlite3_cReader_values(VALUE self) {
 void Init_do_sqlite3() {
   data_objects_common_init();
 
-  mSqlite3 = rb_define_module_under(mDO, "Sqlite3");
-
-  cSqlite3Connection = rb_define_class_under(mSqlite3, "Connection", cDO_Connection);
-  rb_define_method(cSqlite3Connection, "initialize", do_sqlite3_cConnection_initialize, 1);
-  rb_define_method(cSqlite3Connection, "dispose", do_sqlite3_cConnection_dispose, 0);
-  rb_define_method(cSqlite3Connection, "quote_boolean", do_sqlite3_cConnection_quote_boolean, 1);
-  rb_define_method(cSqlite3Connection, "quote_string", do_sqlite3_cConnection_quote_string, 1);
-  rb_define_method(cSqlite3Connection, "quote_byte_array", do_sqlite3_cConnection_quote_byte_array, 1);
-  rb_define_method(cSqlite3Connection, "character_set", data_objects_cConnection_character_set, 0);
-
-  cSqlite3Command = rb_define_class_under(mSqlite3, "Command", cDO_Command);
-  rb_define_method(cSqlite3Command, "set_types", data_objects_cCommand_set_types, -1);
-  rb_define_method(cSqlite3Command, "execute_non_query", do_sqlite3_cCommand_execute_non_query, -1);
-  rb_define_method(cSqlite3Command, "execute_reader", do_sqlite3_cCommand_execute_reader, -1);
-
-  cSqlite3Result = rb_define_class_under(mSqlite3, "Result", cDO_Result);
-
-  cSqlite3Reader = rb_define_class_under(mSqlite3, "Reader", cDO_Reader);
-  rb_define_method(cSqlite3Reader, "close", do_sqlite3_cReader_close, 0);
-  rb_define_method(cSqlite3Reader, "next!", do_sqlite3_cReader_next, 0);
-  rb_define_method(cSqlite3Reader, "values", do_sqlite3_cReader_values, 0); // TODO: DRY?
-  rb_define_method(cSqlite3Reader, "fields", data_objects_cReader_fields, 0);
-  rb_define_method(cSqlite3Reader, "field_count", data_objects_cReader_field_count, 0);
-
-  rb_global_variable(&cSqlite3Result);
-  rb_global_variable(&cSqlite3Reader);
-
-  OPEN_FLAG_READONLY = rb_str_new2("read_only");
-  rb_global_variable(&OPEN_FLAG_READONLY);
-  OPEN_FLAG_READWRITE = rb_str_new2("read_write");
-  rb_global_variable(&OPEN_FLAG_READWRITE);
-  OPEN_FLAG_CREATE = rb_str_new2("create");
-  rb_global_variable(&OPEN_FLAG_CREATE);
-  OPEN_FLAG_NO_MUTEX = rb_str_new2("no_mutex");
-  rb_global_variable(&OPEN_FLAG_NO_MUTEX);
-  OPEN_FLAG_FULL_MUTEX = rb_str_new2("full_mutex");
-  rb_global_variable(&OPEN_FLAG_FULL_MUTEX);
+  mDO_Sqlite3 = rb_define_module_under(mDO, "Sqlite3");
+
+  cDO_Sqlite3Connection = rb_define_class_under(mDO_Sqlite3, "Connection", cDO_Connection);
+  rb_define_method(cDO_Sqlite3Connection, "initialize", do_sqlite3_cConnection_initialize, 1);
+  rb_define_method(cDO_Sqlite3Connection, "dispose", do_sqlite3_cConnection_dispose, 0);
+  rb_define_method(cDO_Sqlite3Connection, "quote_boolean", do_sqlite3_cConnection_quote_boolean, 1);
+  rb_define_method(cDO_Sqlite3Connection, "quote_string", do_sqlite3_cConnection_quote_string, 1);
+  rb_define_method(cDO_Sqlite3Connection, "quote_byte_array", do_sqlite3_cConnection_quote_byte_array, 1);
+  rb_define_method(cDO_Sqlite3Connection, "character_set", data_objects_cConnection_character_set, 0);
+
+  cDO_Sqlite3Command = rb_define_class_under(mDO_Sqlite3, "Command", cDO_Command);
+  rb_define_method(cDO_Sqlite3Command, "set_types", data_objects_cCommand_set_types, -1);
+  rb_define_method(cDO_Sqlite3Command, "execute_non_query", do_sqlite3_cCommand_execute_non_query, -1);
+  rb_define_method(cDO_Sqlite3Command, "execute_reader", do_sqlite3_cCommand_execute_reader, -1);
+
+  cDO_Sqlite3Result = rb_define_class_under(mDO_Sqlite3, "Result", cDO_Result);
+
+  cDO_Sqlite3Reader = rb_define_class_under(mDO_Sqlite3, "Reader", cDO_Reader);
+  rb_define_method(cDO_Sqlite3Reader, "close", do_sqlite3_cReader_close, 0);
+  rb_define_method(cDO_Sqlite3Reader, "next!", do_sqlite3_cReader_next, 0);
+  rb_define_method(cDO_Sqlite3Reader, "values", do_sqlite3_cReader_values, 0); // TODO: DRY?
+  rb_define_method(cDO_Sqlite3Reader, "fields", data_objects_cReader_fields, 0);
+  rb_define_method(cDO_Sqlite3Reader, "field_count", data_objects_cReader_field_count, 0);
+
+  rb_global_variable(&cDO_Sqlite3Result);
+  rb_global_variable(&cDO_Sqlite3Reader);
+
+  DO_OPEN_FLAG_READONLY = rb_str_new2("read_only");
+  rb_global_variable(&DO_OPEN_FLAG_READONLY);
+  DO_OPEN_FLAG_READWRITE = rb_str_new2("read_write");
+  rb_global_variable(&DO_OPEN_FLAG_READWRITE);
+  DO_OPEN_FLAG_CREATE = rb_str_new2("create");
+  rb_global_variable(&DO_OPEN_FLAG_CREATE);
+  DO_OPEN_FLAG_NO_MUTEX = rb_str_new2("no_mutex");
+  rb_global_variable(&DO_OPEN_FLAG_NO_MUTEX);
+  DO_OPEN_FLAG_FULL_MUTEX = rb_str_new2("full_mutex");
+  rb_global_variable(&DO_OPEN_FLAG_FULL_MUTEX);
 
   Init_do_sqlite3_extension();
 
-  data_objects_define_errors(mSqlite3, do_sqlite3_errors);
+  data_objects_define_errors(mDO_Sqlite3, do_sqlite3_errors);
 }

data/ext/do_sqlite3/do_sqlite3.h

@@ -13,7 +13,7 @@
 #define sqlite3_prepare_v2 sqlite3_prepare
 #endif
 
-extern VALUE mSqlite3;
+extern VALUE mDO_Sqlite3;
 extern void Init_do_sqlite3_extension();
 
 #endif

data/ext/do_sqlite3/do_sqlite3_extension.c

@@ -2,7 +2,7 @@
 #include "do_common.h"
 #include "do_sqlite3.h"
 
-VALUE cSqlite3Extension;
+VALUE cDO_Sqlite3Extension;
 
 /*****************************************************/
 /* File used for providing extensions on the default */
@@ -32,7 +32,7 @@ VALUE do_sqlite3_cExtension_enable_load_extension(VALUE self, VALUE on) {
   int status = sqlite3_enable_load_extension(db, on == Qtrue ? 1 : 0);
 
   if (status != SQLITE_OK) {
-    rb_raise(eConnectionError, "Couldn't enable extension loading");
+    rb_raise(eDO_ConnectionError, "Couldn't enable extension loading");
   }
 
   return Qtrue;
@@ -66,7 +66,7 @@ VALUE do_sqlite3_cExtension_load_extension(VALUE self, VALUE path) {
   int status = sqlite3_load_extension(db, extension_path, 0, &errmsg);
 
   if (status != SQLITE_OK) {
-    VALUE errexp = rb_exc_new2(eConnectionError, errmsg);
+    VALUE errexp = rb_exc_new2(eDO_ConnectionError, errmsg);
 
     sqlite3_free(errmsg);
     rb_exc_raise(errexp);
@@ -80,7 +80,8 @@ VALUE do_sqlite3_cExtension_load_extension(VALUE self, VALUE path) {
 }
 
 void Init_do_sqlite3_extension() {
-  cSqlite3Extension = rb_define_class_under(mSqlite3, "Extension", cDO_Extension);
-  rb_define_method(cSqlite3Extension, "load_extension", do_sqlite3_cExtension_load_extension, 1);
-  rb_define_method(cSqlite3Extension, "enable_load_extension", do_sqlite3_cExtension_enable_load_extension, 1);
+  cDO_Sqlite3Extension = rb_define_class_under(mDO_Sqlite3, "Extension", cDO_Extension);
+  rb_global_variable(&cDO_Sqlite3Extension);
+  rb_define_method(cDO_Sqlite3Extension, "load_extension", do_sqlite3_cExtension_load_extension, 1);
+  rb_define_method(cDO_Sqlite3Extension, "enable_load_extension", do_sqlite3_cExtension_enable_load_extension, 1);
 }

data/lib/do_sqlite3/version.rb

@@ -1,5 +1,5 @@
 module DataObjects
   module Sqlite3
-    VERSION = '0.10.10'
+    VERSION = '0.10.11'
   end
 end

data/tasks/compile.rake

@@ -55,7 +55,7 @@ begin
     ext.classpath = '../do_jdbc/lib/do_jdbc_internal.jar'
     ext.java_compiling do |gem|
       gem.add_dependency 'jdbc-sqlite3', '>=3.5.8'
-      gem.add_dependency 'do_jdbc',      '0.10.10'
+      gem.add_dependency 'do_jdbc',      '0.10.11'
     end
   end
 rescue LoadError

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 10
-  - 10
-  version: 0.10.10
+  - 11
+  version: 0.10.11
 platform: ruby
 authors: 
 - Dirkjan Bussink
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-29 00:00:00 +02:00
+date: 2012-12-29 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -27,8 +27,8 @@ dependencies:
         segments: 
         - 0
         - 10
-        - 10
-        version: 0.10.10
+        - 11
+        version: 0.10.11
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency