rubyfb 0.5.2

data/ext/FireRuby.c

@@ -0,0 +1,240 @@
+/*------------------------------------------------------------------------------
+ * FireRuby.c
+ *----------------------------------------------------------------------------*/
+/**
+ * Copyright � Peter Wood, 2005
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with the
+ * License. You may obtain a copy of the License at
+ *
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
+ * the specificlanguage governing rights and  limitations under the License.
+ *
+ * The Original Code is the FireRuby extension for the Ruby language.
+ *
+ * The Initial Developer of the Original Code is Peter Wood. All Rights
+ * Reserved.
+ *
+ * @author  Peter Wood
+ * @version 1.0
+ */
+
+/* Includes. */
+#include "FireRuby.h"
+#include <string.h>
+#include "AddUser.h"
+#include "Blob.h"
+#include "Backup.h"
+#include "Database.h"
+#include "Connection.h"
+#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"
+
+
+/**
+ * This function provides an encapsulation of extracting a setting from the
+ * global FireRuby settings hash.
+ *
+ * @param  key  A string containing the name of the key to be retrieved.
+ *
+ */
+VALUE getFireRubySetting(const char *key)
+{
+   VALUE settings = rb_gv_get("$FireRubySettings");
+
+   return(rb_hash_aref(settings, toSymbol(key)));
+}
+
+
+/**
+ * This function provides a convenience mechanism to obtain the class name for
+ * an object, useful in debugging.
+ *
+ * @param  object  A reference to the objec to get the class name for.
+ * @param  name    A string that will be populated with the class name.
+ *
+ */
+void getClassName(VALUE object, char *name)
+{
+   VALUE klass  = rb_funcall(object, rb_intern("class"), 0),
+         string = rb_funcall(klass, rb_intern("name"), 0);
+
+   strcpy(name, STR2CSTR(string));
+}
+
+
+/**
+ * This method takes a string and generates a Symbol object from it.
+ *
+ * @param  name  A string containing the text to be made into a Symbol.
+ *
+ * @return  A Symbol object for the string passed in.
+ *
+ */
+VALUE toSymbol(const char *name)
+{
+   return(rb_funcall(rb_str_new2(name), rb_intern("intern"), 0));
+}
+
+
+/**
+ * This function attempts to deduce the type for a SQL field from the XSQLVAR
+ * structure that is used to describe it.
+ *
+ * @param  column  A pointer to the XSQLVAR structure for the column to work
+ *                 the type out for.
+ *
+ * @return  A symbol giving the base type for the column.
+ *
+ */
+VALUE getColumnType(const XSQLVAR *column)
+{
+   VALUE type = Qnil;
+   
+   switch((column->sqltype & ~1))
+   {
+      case SQL_BLOB:
+         type = toSymbol("BLOB");
+         break;
+
+      case SQL_TYPE_DATE:
+         type = toSymbol("DATE");
+         break;
+
+      case SQL_DOUBLE:
+         type = toSymbol("DOUBLE");
+         break;
+
+      case SQL_FLOAT:
+         type = toSymbol("FLOAT");
+         break;
+
+      case SQL_INT64:
+         if(column->sqlsubtype != 0)
+         {
+            if(column->sqlsubtype == 1)
+            {
+               type = toSymbol("NUMERIC");
+            }
+            else if(column->sqlsubtype == 2)
+            {
+               type = toSymbol("DECIMAL");
+            }
+         }
+         else
+         {
+            type = toSymbol("BIGINT");
+         }
+         break;
+
+      case SQL_LONG:
+         if(column->sqlsubtype != 0)
+         {
+            if(column->sqlsubtype == 1)
+            {
+               type = toSymbol("NUMERIC");
+            }
+            else if(column->sqlsubtype == 2)
+            {
+               type = toSymbol("DECIMAL");
+            }
+         }
+         else
+         {
+            type = toSymbol("INTEGER");
+         }
+         break;
+
+      case SQL_SHORT:
+         if(column->sqlsubtype != 0)
+         {
+            if(column->sqlsubtype == 1)
+            {
+               type = toSymbol("NUMERIC");
+            }
+            else if(column->sqlsubtype == 2)
+            {
+               type = toSymbol("DECIMAL");
+            }
+         }
+         else
+         {
+            type = toSymbol("SMALLINT");
+         }
+         break;
+
+      case SQL_TEXT:
+         type = toSymbol("CHAR");
+         break;
+
+      case SQL_TYPE_TIME:
+         type = toSymbol("TIME");
+         break;
+
+      case SQL_TIMESTAMP:
+         type = toSymbol("TIMESTAMP");
+         break;
+
+      case SQL_VARYING:
+         type = toSymbol("VARCHAR");
+         break;
+         
+      default:
+         type = toSymbol("UNKNOWN");
+   }
+   
+   return(type);
+}
+
+
+/**
+ * This function is required by the Ruby interpreter to load and initialize
+ * the extension details. The function creates a module called 'FireRuby'
+ * and then creates the various extension classes within this module.
+ *
+ */
+void Init_rubyfb_lib(void)
+{
+   VALUE module = rb_define_module("FireRuby"),
+         array  = rb_ary_new(),
+         hash   = rb_hash_new();
+
+   /* Initialise the configuration and make it available. */
+   rb_ary_push(array, INT2FIX(MAJOR_VERSION_NO));
+   rb_ary_push(array, INT2FIX(MINOR_VERSION_NO));
+   rb_ary_push(array, INT2FIX(BUILD_NO));
+   rb_hash_aset(hash, toSymbol("ALIAS_KEYS"), Qtrue);
+   rb_hash_aset(hash, toSymbol("DATE_AS_DATE"), Qtrue);
+   rb_gv_set("$FireRubyVersion", array);
+   rb_gv_set("$FireRubySettings", hash);
+
+   /* Require needed libraries. */
+   rb_require("date");
+
+   /* Initialise the library classes. */
+   Init_Database(module);
+   Init_Connection(module);
+   Init_Transaction(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);
+   Init_RemoveUser(module);
+   Init_Restore(module);
+}

data/ext/FireRuby.h

@@ -0,0 +1,50 @@
+/*------------------------------------------------------------------------------
+ * FireRuby.h
+ *----------------------------------------------------------------------------*/
+/**
+ * Copyright � Peter Wood, 2005
+ * 
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with the
+ * License. You may obtain a copy of the License at 
+ *
+ * http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
+ * the specificlanguage governing rights and  limitations under the License.
+ * 
+ * The Original Code is the FireRuby extension for the Ruby language.
+ * 
+ * The Initial Developer of the Original Code is Peter Wood. All Rights 
+ * Reserved.
+ *
+ * @author  Peter Wood
+ * @version 1.0
+ */
+#ifndef FIRERUBY_FIRE_RUBY_H
+#define FIRERUBY_FIRE_RUBY_H
+
+   /* Includes. */
+   #ifndef RUBY_H_INCLUDED
+      #include "ruby.h"
+      #define RUBY_H_INCLUDED
+   #endif
+   
+   #ifndef IBASE_H_INCLUDED
+      #include "ibase.h"
+      #define IBASE_H_INCLUDED
+   #endif
+   
+   /* Definitions. */
+   #define MAJOR_VERSION_NO                      0
+   #define MINOR_VERSION_NO                      4
+   #define BUILD_NO                              3
+   
+   /* Function definitions. */
+   VALUE getFireRubySetting(const char *);
+   void getClassName(VALUE, char *);
+   VALUE toSymbol(const char *);
+   VALUE getColumnType(const XSQLVAR *);
+   
+#endif /* FIRERUBY_FIRE_RUBY_H */

data/ext/FireRubyException.c

@@ -0,0 +1,268 @@
+/*------------------------------------------------------------------------------
+ * FireRubyException.c
+ *----------------------------------------------------------------------------*/
+/**
+ * Copyright � Peter Wood, 2005
+ * 
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with the
+ * License. You may obtain a copy of the License at 
+ *
+ * http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
+ * the specificlanguage governing rights and  limitations under the License.
+ * 
+ * The Original Code is the FireRuby extension for the Ruby language.
+ * 
+ * The Initial Developer of the Original Code is Peter Wood. All Rights 
+ * Reserved.
+ *
+ * @author  Peter Wood
+ * @version 1.0
+ */
+
+/* Includes. */
+#include "FireRubyException.h"
+#include "time.h"
+
+/* Function prototypes. */
+static VALUE allocateFireRubyException(VALUE);
+static VALUE initializeFireRubyException(VALUE, VALUE);
+static VALUE getFireRubyExceptionSQLCode(VALUE);
+static VALUE getFireRubyExceptionDBCode(VALUE);
+static VALUE getFireRubyExceptionMessage(VALUE);
+VALUE decodeError(ISC_STATUS *, const char *, VALUE);
+
+/* Globals. */
+VALUE cFireRubyException;
+
+
+/**
+ * This function integrates with the Ruby language to allow for the allocation
+ * of new FireRubyException objects.
+ *
+ * @param  klass  A reference to the FireRubyException Class object.
+ *
+ * @return  An instance of the FireRubyException class.
+ *
+ */
+static VALUE allocateFireRubyException(VALUE klass)
+{
+   VALUE           instance;
+   ExceptionHandle *exception = ALLOC(ExceptionHandle);
+   
+   if(exception != NULL)
+   {
+      exception->when = (long)time(NULL);
+      instance = Data_Wrap_Struct(klass, NULL, firerubyExceptionFree,
+                                  exception);
+   }
+   else
+   {
+      rb_raise(rb_eNoMemError,
+               "Memory allocation failure creating a FireRubyException object.");
+   }
+   
+   return(instance);
+}
+
+
+/**
+ * This function provides the initialize method for the FireRubyException
+ * class.
+ *
+ * @param  self     A reference to the exception object being initialized.
+ * @param  message  A string containing an error message for the exception.
+ *
+ * @return  A reference to the initialized exception object.
+ *
+ */
+static VALUE initializeFireRubyException(VALUE self, VALUE message)
+{
+   /* Check the input type. */
+   if(TYPE(message) != T_STRING)
+   {
+      rb_raise(rb_eException,
+               "Invalid message parameter specified for exception.");
+   }
+   
+   rb_iv_set(self, "@message", message);
+   rb_iv_set(self, "@sql_code", 0);
+   rb_iv_set(self, "@db_code", 0);
+   
+   return(self);
+}
+
+
+/**
+ * This function provides the accessor for the SQL code attribute of the
+ * FireRubyException class.
+ *
+ * @param  self  A reference to the exception to fetch the code from.
+ *
+ * @return  A reference to the requested code value.
+ *
+ */
+static VALUE getFireRubyExceptionSQLCode(VALUE self)
+{
+   return(rb_iv_get(self, "@sql_code"));
+}
+
+
+/**
+ * This function provides the accessor for the database code attribute of the
+ * FireRubyException class.
+ *
+ * @param  self  A reference to the exception to fetch the code from.
+ *
+ * @return  A reference to the requested code value.
+ *
+ */
+static VALUE getFireRubyExceptionDBCode(VALUE self)
+{
+   return(rb_iv_get(self, "@db_code"));
+}
+
+
+/**
+ * This function provides the message method for the FireRubyException class.
+ *
+ * @param  self  A reference to the exception object to fetch the message from.
+ *
+ * @return  A reference to the message for the exception.
+ *
+ */
+static VALUE getFireRubyExceptionMessage(VALUE self)
+{
+   return(rb_iv_get(self, "@message"));
+}
+
+
+/**
+ * This function decodes the contents of a Firebird ISC_STATUS array into a
+ * String object.
+ *
+ * @param  status     A pointer to the status array to be decoded.
+ * @param  prefix     An initial message that may be added to the exception as
+ *                    part of the decoding. Ignored if it is NULL or has zero
+ *                    length.
+ *
+ * @return  A reference to the full decode error message string.
+ *
+ */
+VALUE decodeException(ISC_STATUS *status, const char *prefix)
+{
+   VALUE      message = rb_str_new2(""),
+              eol     = rb_str_new2("\n");
+   char       text[512];
+   int        sqlCode = isc_sqlcode(status),
+              dbCode  = 0;
+   ISC_STATUS **ptr   = &status;
+
+   /* Add the prefix message if it exists. */
+   if(prefix != NULL && strlen(prefix) > 0)
+   {
+      rb_str_concat(message, rb_str_new2(prefix));
+      rb_str_concat(message, eol);
+   }
+   
+   if(status != NULL)
+   {
+      /* Decode the status array. */
+      dbCode = status[1];
+      while(fb_interpret(text, 512, ptr) != 0)
+      {
+         rb_str_concat(message, rb_str_new2(text));
+         rb_str_concat(message, eol);
+         memset(text, 0, 512);
+      }
+      
+      isc_sql_interprete(sqlCode, text, 512);
+      if(strlen(text) > 0)
+      {
+         rb_str_concat(message, rb_str_new2(text));
+      }
+      
+      sprintf(text, "\nSQL Code = %d\n", sqlCode);
+      rb_str_concat(message, rb_str_new2(text));
+      sprintf(text, "Firebird Code = %d\n", dbCode);
+      rb_str_concat(message, rb_str_new2(text));
+   }
+   
+   return(message);
+}
+
+
+/**
+ * This function provides a means to programmatically create a new instance of
+ * the FireRubyException class.
+ *
+ * @param  message  A string containing the error message for the exception.
+ *
+ * @return  A reference to a newly created FireRubyException object.
+ *
+ */
+VALUE rb_fireruby_exception_new(const char *message)
+{
+   VALUE exception = allocateFireRubyException(cFireRubyException);
+   
+   initializeFireRubyException(exception, rb_str_new2(message));
+   
+   return(exception);
+}
+
+
+/**
+ * This function raises a new FireRuby exception.
+ *
+ * @param  status   A pointer to the Firebird status vector containing the error
+ *                  details.
+ * @param  message  A string containing a message to be prefixed to the error
+ *                  text generated by the decoding.
+ *
+ */
+void rb_fireruby_raise(ISC_STATUS *status, const char *message)
+{
+   VALUE text = decodeException(status, message);
+   
+   rb_raise(cFireRubyException, STR2CSTR(text));
+}
+
+
+/**
+ * This function integrates with the Ruby garbage collector to insure that the
+ * resources associated with a FireRubyException object are completely released
+ * when an object of this type is collected.
+ *
+ * @param  exception  A pointer to the ExceptionHandle structure associated
+ *                    with a FireRubyException object that is being collected.
+ *
+ */
+void firerubyExceptionFree(void *exception)
+{
+   if(exception != NULL)
+   {
+      free((ExceptionHandle *)exception);
+   }
+}
+
+
+/**
+ * This function creates the FireRubyException class within the Ruby environment
+ * under the module specified as a parameter.
+ *
+ * @param  module  The module to create the class under.
+ *
+ */
+void Init_FireRubyException(VALUE module)
+{
+   cFireRubyException = rb_define_class_under(module, "FireRubyException",
+                                              rb_eStandardError);
+   rb_define_alloc_func(cFireRubyException, allocateFireRubyException);
+   rb_define_method(cFireRubyException, "initialize", initializeFireRubyException, 1);
+   rb_define_method(cFireRubyException, "sql_code", getFireRubyExceptionSQLCode, 0);
+   rb_define_method(cFireRubyException, "db_code", getFireRubyExceptionDBCode, 0);
+   rb_define_method(cFireRubyException, "message", getFireRubyExceptionMessage, 0);
+}

data/ext/FireRubyException.h

@@ -0,0 +1,51 @@
+/*------------------------------------------------------------------------------
+ * FireRubyException.h
+ *----------------------------------------------------------------------------*/
+/**
+ * Copyright � Peter Wood, 2005
+ * 
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with the
+ * License. You may obtain a copy of the License at 
+ *
+ * http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
+ * the specificlanguage governing rights and  limitations under the License.
+ * 
+ * The Original Code is the FireRuby extension for the Ruby language.
+ * 
+ * The Initial Developer of the Original Code is Peter Wood. All Rights 
+ * Reserved.
+ *
+ * @author  Peter Wood
+ * @version 1.0
+ */
+#ifndef FIRERUBY_FIRE_RUBY_EXCEPTION_H
+#define FIRERUBY_FIRE_RUBY_EXCEPTION_H
+
+   /* Includes. */
+   #ifndef RUBY_H_INCLUDED
+      #include "ruby.h"
+      #define RUBY_H_INCLUDED
+   #endif
+   
+   #ifndef IBASE_H_INCLUDED
+      #include "ibase.h"
+      #define IBASE_H_INCLUDED
+   #endif
+   
+   /* Type definitions. */
+   typedef struct
+   {
+      long when;
+   } ExceptionHandle;
+   
+   /* Function prototypes. */
+   void Init_FireRubyException(VALUE);
+   VALUE rb_fireruby_exception_new(const char *);
+   void rb_fireruby_raise(ISC_STATUS *, const char *);
+   void firerubyExceptionFree(void *);
+   
+#endif /* FIRERUBY_FIRE_RUBY_EXCEPTION_H */