rubyfb 0.6.4 → 0.6.7

data/CHANGELOG

@@ -1,3 +1,17 @@
+v0.6.7 ==
+Add test to ensure row numbering scheme
+Fix row numbering
+Minor AR adapter improvement
+
+v0.6.6 ==
+Include Enumerable in Row And ResultSet
+Update tests
+
+v0.6.5 ==
+Row: pure ruby implementation
+ResultSet: pure ruby implementation
+Use static vars fo rb_intern caches - this should fix os x linkage issues - https://github.com/georgiev/rubyfb/issues/11
+
 v0.6.4 ==
 Tyr to fix another Segmentation fault in Row class (GC integration issues)
 

data/Manifest

@@ -28,10 +28,6 @@ ext/RemoveUser.c
 ext/RemoveUser.h
 ext/Restore.c
 ext/Restore.h
-ext/ResultSet.c
-ext/ResultSet.h
-ext/Row.c
-ext/Row.h
 ext/ServiceManager.c
 ext/ServiceManager.h
 ext/Services.c
@@ -48,17 +44,20 @@ ext/rfbsleep.h
 ext/rfbstr.c
 ext/rfbstr.h
 ext/uncrustify.cfg
-lib/Connection.rb
-lib/ProcedureCall.rb
-lib/SQLType.rb
 lib/active_record/connection_adapters/rubyfb_adapter.rb
 lib/arel/visitors/fb15/rubyfb.rb
 lib/arel/visitors/rubyfb.rb
+lib/connection.rb
 lib/mkdoc
+lib/procedure_call.rb
+lib/result_set.rb
+lib/row.rb
 lib/rubyfb.rb
 lib/rubyfb_lib.so
 lib/rubyfb_options.rb
+lib/sql_type.rb
 lib/src.rb
+lib/statement.rb
 mswin32fb/fbclient_mingw.def
 mswin32fb/fbclient_mingw.lib
 mswin32fb/fbclient_ms.lib

data/Rakefile

@@ -1,5 +1,5 @@
 require 'echoe'
-e = Echoe.new('rubyfb', '0.6.4') do |p|
+e = Echoe.new('rubyfb', '0.6.7') do |p|
   p.description    = "Firebird SQL access library"
   p.url            = "http://rubyforge.org/projects/rubyfb"
   p.author         = "George Georgiev"

data/ext/Common.c

@@ -51,3 +51,77 @@ VALUE forbidObjectCopy(VALUE copy, VALUE original) {
 
   return(Qnil);
 }
+
+/**
+ * This method fetches a Ruby constant definition. If the module specified to
+ * the function is nil then the top level is assume
+ *
+ * @param  name    The name of the constant to be retrieved.
+ * @param  module  A reference to the Ruby module that should contain the
+ *                 constant.
+ *
+ * @return  A Ruby VALUE representing the constant.
+ *
+ */
+static VALUE getConstant(const char *name, VALUE module) {
+  VALUE owner = module,
+        constants,
+        exists,
+        entry = Qnil,
+        symbol = ID2SYM(rb_intern(name));
+
+  /* Check that we've got somewhere to look. */
+  if(owner == Qnil) {
+    owner = rb_cModule;
+  }
+
+  constants = rb_funcall(owner, rb_intern("constants"), 0),
+  exists = rb_funcall(constants, rb_intern("include?"), 1, symbol);
+  if(exists == Qfalse) {
+    /* 1.8 style lookup */
+    exists = rb_funcall(constants, rb_intern("include?"), 1, rb_str_new2(name));
+  }
+  if(exists != Qfalse) {
+    entry = rb_funcall(owner, rb_intern("const_get"), 1, symbol);
+  }
+  return(entry);
+}
+
+
+/**
+ * This method fetches a Ruby class definition object based on a class name.
+ * The class is assumed to have been defined at the top level.
+ *
+ * @return  A Ruby VALUE representing the requested class, or nil if the class
+ *          could not be found.
+ *
+ */
+VALUE getClass(const char *name) {
+  return getClassInModule(name, Qnil);
+}
+
+
+/**
+ * This function fetches a class from a specified module.
+ *
+ * @param  name   The name of the class to be retrieved.
+ * @param  owner  The module to search for the class in.
+ *
+ * @return  A Ruby VALUE representing the requested module, or nil if it could
+ *          not be located.
+ *
+ */
+VALUE getClassInModule(const char *name, VALUE owner) {
+  VALUE klass = getConstant(name, owner);
+
+  if(klass != Qnil) {
+    VALUE type = rb_funcall(klass, rb_intern("class"), 0);
+
+    if(type != rb_cClass) {
+      klass = Qnil;
+    }
+  }
+
+  return(klass);
+}
+

data/ext/Common.h

@@ -33,5 +33,7 @@
 
 /* Function prototypes. */
 VALUE forbidObjectCopy(VALUE, VALUE);
+VALUE getClass(const char *);
+VALUE getClassInModule(const char *, VALUE);
 
 #endif /* FIRERUBY_COMMON_H */

data/ext/Connection.c

@@ -26,7 +26,6 @@
 /* Includes. */
 #include "Connection.h"
 #include "Database.h"
-#include "ResultSet.h"
 #include "Statement.h"
 #include "Transaction.h"
 #include "Common.h"

data/ext/FireRuby.c

@@ -34,12 +34,10 @@
 #include "FireRubyException.h"
 #include "Generator.h"
 #include "RemoveUser.h"
-#include "ResultSet.h"
 #include "ServiceManager.h"
 #include "Statement.h"
 #include "Transaction.h"
 #include "Restore.h"
-#include "Row.h"
 
 
 /**
@@ -202,12 +200,11 @@ void Init_rubyfb_lib(void) {
   Init_Database(module);
   Init_Connection(module);
   Init_Transaction(module);
+  Init_TypeMap(module);
   Init_Statement(module);
-  Init_ResultSet(module);
   Init_Generator(module);
   Init_FireRubyException(module);
   Init_Blob(module);
-  Init_Row(module);
   Init_ServiceManager(module);
   Init_Backup(module);
   Init_AddUser(module);

data/ext/Generator.c

@@ -26,7 +26,6 @@
 /* Includes. */
 #include "Generator.h"
 #include "Common.h"
-#include "ResultSet.h"
 #include "Statement.h"
 #include "Transaction.h"
 #include "DataArea.h"

data/ext/Statement.c

@@ -30,7 +30,6 @@
 #include "Transaction.h"
 #include "DataArea.h"
 #include "TypeMap.h"
-#include "ResultSet.h"
 
 /* Function prototypes. */
 static VALUE allocateStatement(VALUE);
@@ -47,20 +46,46 @@ static VALUE getStatementPrepared(VALUE);
 static VALUE prepareStatement(int, VALUE*, VALUE);
 static VALUE getStatementPlan(VALUE);
 
-VALUE execAndManageTransaction(VALUE, VALUE, VALUE);
-VALUE execAndManageStatement(VALUE, VALUE, VALUE);
-VALUE rescueLocalTransaction(VALUE, VALUE);
-VALUE execStatementFromArray(VALUE);
-VALUE rescueStatement(VALUE, VALUE);
-VALUE execInTransactionFromArray(VALUE);
-VALUE execInTransaction(VALUE, VALUE, VALUE);
-void prepareInTransaction(VALUE, VALUE);
-VALUE prepareFromArray(VALUE);
-void statementFree(void *);
-StatementHandle* getPreparedHandle(VALUE self);
+static VALUE execAndManageTransaction(VALUE, VALUE, VALUE);
+static VALUE execAndManageStatement(VALUE, VALUE, VALUE);
+static VALUE rescueLocalTransaction(VALUE, VALUE);
+static VALUE execStatementFromArray(VALUE);
+static VALUE rescueStatement(VALUE, VALUE);
+static VALUE execInTransactionFromArray(VALUE);
+static VALUE execInTransaction(VALUE, VALUE, VALUE);
+static void prepareInTransaction(VALUE, VALUE);
+static VALUE prepareFromArray(VALUE);
+static void statementFree(void *);
+static StatementHandle* getPreparedHandle(VALUE self);
 
 /* Globals. */
-VALUE cStatement;
+static VALUE cStatement, cResultSet;
+
+static ID
+  RB_INTERN_CREATE_COLUMN_METADATA,
+  RB_INTERN_AT_NAME,
+  RB_INTERN_AT_ALIAS,
+  RB_INTERN_AT_KEY,
+  RB_INTERN_AT_TYPE,
+  RB_INTERN_AT_SCALE,
+  RB_INTERN_AT_RELATION,
+  RB_INTERN_AT_METADATA,
+  RB_INTERN_AT_MANAGE_STATEMENT,
+  RB_INTERN_AT_MANAGE_TRANSACTION,
+  RB_INTERN_ACTIVE,
+  RB_INTERN_EACH,
+  RB_INTERN_COMMIT,
+  RB_INTERN_ROLLBACK,
+  RB_INTERN_SIZE,
+  RB_INTERN_CLOSE,
+  RB_INTERN_TO_S,
+  RB_INTERN_OPEN,
+  RB_INTERN_STRIP,
+  RB_INTERN_NEW;
+
+static const ISC_STATUS FETCH_MORE = 0;
+static const ISC_STATUS FETCH_COMPLETED = 100;
+static const ISC_STATUS FETCH_ONE = 101;
 
 /**
  * This function prepares a Firebird SQL statement for execution.
@@ -176,6 +201,20 @@ long fb_query_affected(StatementHandle *statement) {
   return (result);
 }
 
+static short isActiveResultSet(VALUE object) {
+  short result = 0;
+  if ((Qtrue == rb_obj_is_kind_of(object, cResultSet))) {
+    if(Qtrue == rb_funcall(object, RB_INTERN_ACTIVE, 0)) {
+      result = 1;
+    }
+  }
+  return (result);
+}
+
+VALUE getStatementMetadata(VALUE self) {
+  return rb_ivar_get(self, RB_INTERN_AT_METADATA);
+}
+
 /**
  * Prepare statement parsing arguments array
  *
@@ -205,7 +244,7 @@ void prepareInTransaction(VALUE self, VALUE transaction) {
   if(0 == hStatement->handle) {
     ConnectionHandle  *hConnection  = NULL;
     TransactionHandle *hTransaction = NULL;
-    VALUE sql = rb_iv_get(self, "@sql");
+    VALUE metadata, sql = rb_iv_get(self, "@sql");
     Data_Get_Struct(getStatementConnection(self), ConnectionHandle, hConnection);
     Data_Get_Struct(transaction, TransactionHandle, hTransaction);
 
@@ -214,12 +253,39 @@ void prepareInTransaction(VALUE self, VALUE transaction) {
             StringValuePtr(sql), &hStatement->handle,
             hStatement->dialect, &hStatement->type, &hStatement->inputs,
             &hStatement->outputs);
+
+    metadata = rb_ary_new2(hStatement->outputs);
+    rb_ivar_set(self, RB_INTERN_AT_METADATA, metadata);
+
     if(hStatement->outputs > 0) {
+      int index;
+      XSQLVAR *var;
+      VALUE column, name, alias, key_flag = getFireRubySetting("ALIAS_KEYS");
+
       /* Allocate the XSQLDA */
       hStatement->output = allocateOutXSQLDA(hStatement->outputs,
                                                &hStatement->handle,
                                                hStatement->dialect);
       prepareDataArea(hStatement->output);
+
+      var = hStatement->output->sqlvar;
+      for(index = 0; index < hStatement->output->sqld; index++, var++) {
+        column = rb_funcall(self, RB_INTERN_CREATE_COLUMN_METADATA, 0);
+        rb_ary_store(metadata, index, column);
+        name = rb_str_new(var->sqlname, var->sqlname_length);
+        alias = rb_str_new(var->aliasname, var->aliasname_length);
+        rb_ivar_set(column, RB_INTERN_AT_NAME, name);
+        rb_ivar_set(column, RB_INTERN_AT_ALIAS, alias);
+        if(key_flag == Qtrue) {
+          rb_ivar_set(column, RB_INTERN_AT_KEY, alias);
+        } else {
+          rb_ivar_set(column, RB_INTERN_AT_KEY, name);
+        }
+        rb_ivar_set(column, RB_INTERN_AT_TYPE, getColumnType(var));
+        rb_ivar_set(column, RB_INTERN_AT_SCALE, INT2FIX(var->sqlscale));
+        rb_ivar_set(column, RB_INTERN_AT_RELATION, rb_str_new(var->relname, var->relname_length));
+      }
+      rb_obj_freeze(metadata);
     }
   }
 }
@@ -268,12 +334,12 @@ VALUE initializeStatement(VALUE self, VALUE connection, VALUE sql) {
   StatementHandle *hStatement = NULL;
   short setting    = 0;
 
-  sql = rb_funcall(sql, rb_intern("to_s"), 0);
+  sql = rb_funcall(sql, RB_INTERN_TO_S, 0);
   
   /* Validate the inputs. */
   if(TYPE(connection) == T_DATA &&
      RDATA(connection)->dfree == (RUBY_DATA_FUNC)connectionFree) {
-    if(rb_funcall(connection, rb_intern("open?"), 0) == Qfalse) {
+    if(rb_funcall(connection, RB_INTERN_OPEN, 0) == Qfalse) {
       rb_fireruby_raise(NULL, "Closed connection specified for statement.");
     }
   } else {
@@ -389,9 +455,9 @@ VALUE execAndManageTransaction(VALUE self, VALUE parameters, VALUE transaction)
     
     result = rb_rescue(execInTransactionFromArray, args, rescueLocalTransaction, transaction);
     if(isActiveResultSet(result)) {
-      resultSetManageTransaction(result);
+      rb_ivar_set(result, RB_INTERN_AT_MANAGE_TRANSACTION, Qtrue);
     } else {
-      rb_funcall(transaction, rb_intern("commit"), 0);
+      rb_funcall(transaction, RB_INTERN_COMMIT, 0);
     }
   } else {
     result = execInTransaction(self, transaction, parameters);
@@ -422,7 +488,7 @@ VALUE execAndManageStatement(VALUE self, VALUE parameters, VALUE transaction) {
   rb_ary_push(args, transaction);
   result = rb_rescue(execStatementFromArray, args, rescueStatement, self);
   if(isActiveResultSet(result)) {
-    resultSetManageStatement(result);
+    rb_ivar_set(result, RB_INTERN_AT_MANAGE_STATEMENT, Qtrue);
   } else {
     closeStatement(self);
   }
@@ -440,7 +506,7 @@ VALUE execAndManageStatement(VALUE self, VALUE parameters, VALUE transaction) {
  *
  */
 VALUE rescueLocalTransaction(VALUE transaction, VALUE error) {
-  rb_funcall(transaction, rb_intern("rollback"), 0);
+  rb_funcall(transaction, RB_INTERN_ROLLBACK, 0);
   rb_exc_raise(error);
   return(Qnil);
 }
@@ -456,7 +522,7 @@ VALUE rescueLocalTransaction(VALUE transaction, VALUE error) {
  *
  */
 VALUE rescueStatement(VALUE statement, VALUE error) {
-  rb_funcall(statement, rb_intern("close"), 0);
+  rb_funcall(statement, RB_INTERN_CLOSE, 0);
   rb_exc_raise(error);
   return(Qnil);
 }
@@ -494,6 +560,10 @@ short isCursorStatement(StatementHandle *hStatement) {
   }
 }
 
+static VALUE resultSetEach(VALUE resultSet) {
+  return rb_funcall(resultSet, RB_INTERN_EACH, 0);
+}
+
 /**
  * Execute a statement within a transaction context
  *
@@ -526,7 +596,7 @@ VALUE execInTransaction(VALUE self, VALUE transaction, VALUE parameters) {
                         "Empty parameter list specified for statement.");
     }
 
-    value = rb_funcall(parameters, rb_intern("size"), 0);
+    value = rb_funcall(parameters, RB_INTERN_SIZE, 0);
     size  = TYPE(value) == T_FIXNUM ? FIX2INT(value) : NUM2INT(value);
     if(size < hStatement->inputs) {
       rb_fireruby_raise(NULL,
@@ -554,9 +624,9 @@ VALUE execInTransaction(VALUE self, VALUE transaction, VALUE parameters) {
     rb_fireruby_raise(status, "Error executing SQL statement.");
   }
   if (hStatement->output) {
-    result = rb_result_set_new(self, transaction);
+    result = rb_funcall(cResultSet, RB_INTERN_NEW, 2, self, transaction);
     if(rb_block_given_p()) {
-      result = yieldResultsRows(result);
+      result = rb_iterate(resultSetEach, result, rb_yield, 0);
     }
   } else {
     result = INT2NUM(fb_query_affected(hStatement));
@@ -717,7 +787,7 @@ VALUE getStatementPlan(VALUE self) {
         case isc_info_sql_get_plan:
           dataLength = isc_vax_integer(&buffer[1], 2);
           result = rb_str_new(&buffer[3], dataLength);
-          rb_funcall(result, rb_intern("strip!"), 0);
+          rb_funcall(result, RB_INTERN_STRIP, 0);
         default:
           retry = 0;
       }
@@ -798,7 +868,7 @@ StatementHandle* getPreparedHandle(VALUE self) {
     rb_ary_push(args, transaction);
     
     rb_rescue(prepareFromArray, args, rescueLocalTransaction, transaction);
-    rb_funcall(transaction, rb_intern("commit"), 0);
+    rb_funcall(transaction, RB_INTERN_COMMIT, 0);
   }
   return (hStatement);
 }
@@ -818,6 +888,64 @@ void statementFree(void *handle) {
   }
 }
 
+static VALUE fetch(VALUE self) {
+  StatementHandle   *hStatement;
+  ISC_STATUS        status[ISC_STATUS_LENGTH],
+                    fetch_result;
+
+  Data_Get_Struct(self, StatementHandle, hStatement);
+  if (hStatement->outputs == 0) {
+    return Qnil;
+  }
+
+  if (isCursorStatement(hStatement)) {
+    fetch_result = isc_dsql_fetch(status, &hStatement->handle, hStatement->dialect,
+                           hStatement->output);
+    if(fetch_result != FETCH_MORE && fetch_result != FETCH_COMPLETED) {
+      rb_fireruby_raise(status, "Error fetching query row.");
+    }
+  } else {
+    fetch_result = FETCH_ONE;
+  }
+  
+  return INT2FIX(fetch_result);
+}
+
+static VALUE closeCursor(VALUE self) {
+  StatementHandle   *hStatement;
+  ISC_STATUS        status[ISC_STATUS_LENGTH],
+                    close_result;
+
+  Data_Get_Struct(self, StatementHandle, hStatement);
+  if (hStatement->outputs == 0) {
+    rb_fireruby_raise(status, "Not a cursor statement.");
+  }
+  if(close_result = isc_dsql_free_statement(status, &hStatement->handle, DSQL_close)) {
+    rb_fireruby_raise(status, "Error closing cursor.");
+  }
+  return INT2FIX(close_result);
+}
+
+static VALUE currentRow(VALUE self, VALUE transaction) {
+  int i;
+  XSQLVAR *entry;
+  StatementHandle *hStatement;
+  VALUE array, connection;
+
+  Data_Get_Struct(self, StatementHandle, hStatement);
+  if (hStatement->outputs == 0) {
+    rb_fireruby_raise(NULL, "Statement has no output.");
+  }
+
+  connection  = getStatementConnection(self);
+  array       = rb_ary_new2(hStatement->output->sqln);
+  entry       = hStatement->output->sqlvar;
+  for(i = 0; i < hStatement->output->sqln; i++, entry++) {
+    rb_ary_store(array, i, toValue(entry, connection, transaction));
+  }
+  return(array);
+}
+
 /**
  * This function initializes the Statement class within the Ruby environment.
  * The class is established under the module specified to the function.
@@ -826,7 +954,30 @@ void statementFree(void *handle) {
  *
  */
 void Init_Statement(VALUE module) {
+  RB_INTERN_CREATE_COLUMN_METADATA = rb_intern("create_column_metadata");
+  RB_INTERN_AT_NAME = rb_intern("@name");
+  RB_INTERN_AT_ALIAS = rb_intern("@alias");
+  RB_INTERN_AT_KEY = rb_intern("@key");
+  RB_INTERN_AT_TYPE = rb_intern("@type");
+  RB_INTERN_AT_SCALE = rb_intern("@scale");
+  RB_INTERN_AT_RELATION = rb_intern("@relation");
+  RB_INTERN_AT_METADATA = rb_intern("@metadata");
+  RB_INTERN_AT_MANAGE_STATEMENT = rb_intern("@manage_statement");
+  RB_INTERN_AT_MANAGE_TRANSACTION = rb_intern("@manage_transaction");
+  RB_INTERN_ACTIVE = rb_intern("active?");
+  RB_INTERN_EACH = rb_intern("each");
+  RB_INTERN_COMMIT = rb_intern("commit");
+  RB_INTERN_ROLLBACK = rb_intern("rollback");
+  RB_INTERN_SIZE = rb_intern("size");
+  RB_INTERN_CLOSE = rb_intern("close");
+  RB_INTERN_NEW = rb_intern("new");
+  RB_INTERN_TO_S = rb_intern("to_s");
+  RB_INTERN_OPEN = rb_intern("open?");
+  RB_INTERN_STRIP = rb_intern("strip!");
+
+  cResultSet =  getClassInModule("ResultSet", module);
   cStatement = rb_define_class_under(module, "Statement", rb_cObject);
+  
   rb_define_alloc_func(cStatement, allocateStatement);
   rb_define_method(cStatement, "initialize", initializeStatement, 2);
   rb_define_method(cStatement, "initialize_copy", forbidObjectCopy, 1);
@@ -841,6 +992,9 @@ void Init_Statement(VALUE module) {
   rb_define_method(cStatement, "prepare", prepareStatement, -1);
   rb_define_method(cStatement, "prepared?", getStatementPrepared, 0);
   rb_define_method(cStatement, "plan", getStatementPlan, 0);
+  rb_define_method(cStatement, "fetch", fetch, 0);
+  rb_define_method(cStatement, "close_cursor", closeCursor, 0);
+  rb_define_method(cStatement, "current_row", currentRow, 1);
 
   rb_define_const(cStatement, "SELECT_STATEMENT",
                   INT2FIX(isc_info_sql_stmt_select));
@@ -870,4 +1024,10 @@ void Init_Statement(VALUE module) {
                   INT2FIX(isc_info_sql_stmt_set_generator));
   rb_define_const(cStatement, "SAVE_POINT_STATEMENT",
                   INT2FIX(isc_info_sql_stmt_savepoint));
+  rb_define_const(cStatement, "FETCH_MORE",
+                  INT2FIX(FETCH_MORE));
+  rb_define_const(cStatement, "FETCH_COMPLETED",
+                  INT2FIX(FETCH_COMPLETED));
+  rb_define_const(cStatement, "FETCH_ONE",
+                  INT2FIX(FETCH_ONE));
 }