rubyfb 0.5.2-x86-mswin32-60

data/ext/Connection.h

@@ -0,0 +1,50 @@
+/*------------------------------------------------------------------------------
+ * Connection.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_CONNECTION_H
+#define FIRERUBY_CONNECTION_H
+
+   /* Includes. */
+   #ifndef FIRERUBY_FIRE_RUBY_H
+      #include "FireRuby.h"
+   #endif
+
+   #ifndef FIRERUBY_FIRE_RUBY_EXCEPTION_H
+      #include "FireRubyException.h"
+   #endif
+
+   /* Structure definitions. */
+   typedef struct
+   {
+      isc_db_handle handle;
+   } ConnectionHandle;
+   
+   /* Function prototypes. */
+   void Init_Connection(VALUE);
+   VALUE rb_connection_new(VALUE, VALUE, VALUE, VALUE);
+   void rb_tx_started(VALUE, VALUE);
+   void rb_tx_released(VALUE, VALUE);
+   void connectionFree(void *);
+
+#endif /* FIRERUBY_CONNECTION_H */

data/ext/DataArea.c

@@ -0,0 +1,274 @@
+/*------------------------------------------------------------------------------
+ * DataArea.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 "DataArea.h"
+#include "FireRubyException.h"
+
+#ifdef OS_UNIX
+   #include <inttypes.h>
+#else
+   typedef short     int16_t;
+   typedef long      int32_t;
+   typedef long long int64_t;
+#endif
+
+
+/**
+ * This function allocates the memory for a output XSQLDA based on a specified
+ * XSQLDA providing base details.
+ *
+ * @param  size       A count of the number of entries needed in the XSQLDA.
+ * @param  statement  A pointer to the statement handle that will be used in
+ *                    preparing the data area.
+ * @param  dialect    The SQL dialect to be used in preparing the data area.
+ *
+ * @return  A pointer to the newly allocated XSQLDA.
+ *
+ */
+XSQLDA *allocateOutXSQLDA(int size, isc_stmt_handle *statement, short dialect)
+{
+   XSQLDA *area = (XSQLDA *)ALLOC_N(char, XSQLDA_LENGTH(size));
+
+   if(area != NULL)
+   {
+      ISC_STATUS status[20];
+
+      area->sqln    = size;
+      area->version = SQLDA_VERSION1;
+      if(isc_dsql_describe(status, statement, dialect, area) != 0)
+      {
+         /* Release the memory and generate an error. */
+         free(area);
+         rb_fireruby_raise(status, "Error allocating output storage space.");
+      }
+   }
+   else
+   {
+      /* Generate an error. */
+      rb_raise(rb_eNoMemError,
+               "Memory allocation failure preparing output SQL data "\
+               "definition area.");
+   }
+
+   return(area);
+}
+
+
+/**
+ * This function allocates the memory for a input XSQLDA based on a specified
+ * XSQLDA providing base details.
+ *
+ * @param  size       A count of the number of entries needed in the XSQLDA.
+ * @param  statement  A pointer to the statement handle that will be used in
+ *                    preparing the data area.
+ * @param  dialect    The SQL dialect to be used in preparing the data area.
+ *
+ * @return  A pointer to the newly allocated XSQLDA.
+ *
+ */
+XSQLDA *allocateInXSQLDA(int size, isc_stmt_handle *statement, short dialect)
+{
+   XSQLDA *area  = NULL;
+
+   area = (XSQLDA *)ALLOC_N(char, XSQLDA_LENGTH(size));
+
+   if(area != NULL)
+   {
+      ISC_STATUS status[20];
+
+      area->sqln    = size;
+      area->version = SQLDA_VERSION1;
+      if(isc_dsql_describe_bind(status, statement, dialect, area) != 0)
+      {
+         /* Release the memory and generate an error. */
+         free(area);
+         rb_fireruby_raise(status, "Error allocating input storage space.");
+      }
+   }
+   else
+   {
+      /* Generate an error. */
+      rb_raise(rb_eNoMemError,
+               "Memory allocation failure preparing input SQL data "\
+               "definition area.");
+   }
+
+   return(area);
+}
+
+
+/**
+ * This function initializes a previously allocated XSQLDA with space for the
+ * data it will contain.
+ *
+ * @param  da  A pointer to the XSQLDA to have data space allocated for.
+ *
+ */
+void prepareDataArea(XSQLDA *da)
+{
+   XSQLVAR *field = da->sqlvar;
+   int     index;
+
+   for(index = 0; index < da->sqld; index++, field++)
+   {
+      int type  = (field->sqltype & ~1),
+          total = (field->sqllen / 2) + 2;
+
+      field->sqldata = NULL;
+      field->sqlind  = NULL;
+      switch(type)
+      {
+         case SQL_ARRAY :
+            fprintf(stderr, "Allocating for an array (NOT).\n");
+            break;
+
+         case SQL_BLOB :
+            field->sqldata = (char *)ALLOC(ISC_QUAD);
+            break;
+
+         case SQL_DOUBLE :
+            field->sqldata = (char *)ALLOC(double);
+            break;
+
+         case SQL_FLOAT :
+            field->sqldata = (char *)ALLOC(float);
+            break;
+
+         case SQL_INT64 :
+            field->sqldata = (char *)ALLOC(int64_t);
+            break;
+
+         case SQL_LONG :
+            field->sqldata = (char *)ALLOC(int32_t);
+            break;
+
+         case SQL_SHORT :
+            field->sqldata = (char *)ALLOC(int16_t);
+            break;
+
+         case SQL_TEXT :
+            field->sqldata = ALLOC_N(char, field->sqllen + 1);
+            break;
+
+         case SQL_TIMESTAMP :
+            field->sqldata = (char *)ALLOC(ISC_TIMESTAMP);
+            break;
+
+         case SQL_TYPE_DATE :
+            field->sqldata = (char *)ALLOC(ISC_DATE);
+            break;
+
+         case SQL_TYPE_TIME:
+            field->sqldata = (char *)ALLOC(ISC_TIME);
+            break;
+
+         case SQL_VARYING :
+            field->sqldata = (char *)ALLOC_N(short, total);
+            break;
+
+         default :
+            rb_fireruby_raise(NULL, "Unknown SQL data type encountered.");
+      }
+      field->sqlind  = ALLOC(short);
+      *field->sqlind = 0;
+   }
+}
+
+
+/**
+ * This method cleans up all the internal memory associated with a XSQLDA.
+ *
+ * @param  da  A reference to the XSQLDA to be cleared up.
+ *
+ */
+void releaseDataArea(XSQLDA *da)
+{
+   XSQLVAR *field = da->sqlvar;
+   int     index;
+
+   for(index = 0; index < da->sqld; index++, field++)
+   {
+      int type  = (field->sqltype & ~1);
+
+      switch(type)
+      {
+         case SQL_ARRAY :
+            fprintf(stderr, "Releasing an array (NOT).\n");
+            break;
+
+         case SQL_BLOB :
+            free((ISC_QUAD *)field->sqldata);
+            break;
+
+         case SQL_DOUBLE :
+            free((double *)field->sqldata);
+            break;
+
+         case SQL_FLOAT :
+            free((float *)field->sqldata);
+            break;
+
+         case SQL_INT64 :
+            free((int64_t *)field->sqldata);
+            break;
+
+         case SQL_LONG :
+            free((int32_t *)field->sqldata);
+            break;
+
+         case SQL_SHORT :
+            free((int16_t *)field->sqldata);
+            break;
+
+         case SQL_TEXT :
+            free(field->sqldata);
+            break;
+
+         case SQL_TIMESTAMP :
+            free((ISC_TIMESTAMP *)field->sqldata);
+            break;
+
+         case SQL_TYPE_DATE :
+            free((ISC_DATE *)field->sqldata);
+            break;
+
+         case SQL_TYPE_TIME:
+            free((ISC_TIME *)field->sqldata);
+            break;
+
+         case SQL_VARYING :
+            free((short *)field->sqldata);
+            break;
+      }
+      if(field->sqlind != NULL)
+      {
+         free(field->sqlind);
+      }
+
+      field->sqldata = NULL;
+      field->sqlind  = NULL;
+   }
+}

data/ext/DataArea.h

@@ -0,0 +1,38 @@
+/*------------------------------------------------------------------------------
+ * DataArea.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_DATA_AREA_H
+#define FIRERUBY_DATA_AREA_H
+
+   #ifndef IBASE_H_INCLUDED
+      #include "ibase.h"
+      #define IBASE_H_INCLUDED
+   #endif
+   
+   XSQLDA *allocateOutXSQLDA(int, isc_stmt_handle *, short);
+   XSQLDA *allocateInXSQLDA(int, isc_stmt_handle *, short);
+   void prepareDataArea(XSQLDA *);
+   void releaseDataArea(XSQLDA *);
+
+#endif /* FIRERUBY_DATA_AREA_H */

data/ext/Database.c

@@ -0,0 +1,449 @@
+/*------------------------------------------------------------------------------
+ * Database.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 "Database.h"
+#include "FireRubyException.h"
+#include "Connection.h"
+#include "ruby.h"
+
+/* Function prototypes. */
+static VALUE allocateDatabase(VALUE);
+static VALUE initializeDatabase(int, VALUE *, VALUE);
+static VALUE getDatabaseFile(VALUE);
+static VALUE connectToDatabase(int, VALUE *, VALUE);
+static VALUE createDatabase(int, VALUE *, VALUE);
+static VALUE dropDatabase(VALUE, VALUE, VALUE);
+static VALUE getDatabaseCharacterSet(VALUE);
+static VALUE setDatabaseCharacterSet(VALUE, VALUE);
+VALUE connectBlock(VALUE);
+VALUE connectEnsure(VALUE);
+
+/* Globals. */
+VALUE cDatabase;
+
+
+/**
+ * This function provides the functionality to allow for the allocation of
+ * new Database objects.
+ *
+ * @param  klass  A reference to the Database Class object.
+ *
+ * @return  A reference to the new Database class instance.
+ *
+ */
+static VALUE allocateDatabase(VALUE klass)
+{
+   VALUE          instance  = Qnil;
+   DatabaseHandle *database = ALLOC(DatabaseHandle);
+   
+   if(database != NULL)
+   {
+      /* Wrap the structure in a class. */
+      instance = Data_Wrap_Struct(klass, NULL, databaseFree, database);
+   }
+   else
+   {
+      rb_raise(rb_eNoMemError,
+               "Memory allocation failure creating a Database object.");
+   }
+   
+   return(instance);
+}
+
+
+/**
+ * This function provides the initialize method for the Database class.
+ *
+ * @param  argc  A count of the total number of parameters passed to the
+ *               function.
+ * @param  argv  A pointer to an array containing the parameters passed to the
+ *               function.
+ * @param  self  A reference to the object that the method call is being made
+ *               to.
+ *
+ * @return  A reference to the new initialized object instance.
+ *
+ */
+VALUE initializeDatabase(int argc, VALUE *argv, VALUE self)
+{
+   VALUE options = rb_hash_new();
+   
+   /* Check the number of parameters. */
+   if(argc < 1)
+   {
+      rb_raise(rb_eArgError, "Wrong number of arguments (%d for %d).", argc, 1);
+   }
+   
+   /* Perform type checks on the input parameters. */
+   Check_Type(argv[0], T_STRING);
+   if(argc > 1)
+   {
+      Check_Type(argv[1], T_STRING);
+      rb_hash_aset(options, INT2FIX(isc_dpb_lc_ctype), argv[1]);
+   }
+   
+   /* Store the database details. */
+   rb_iv_set(self, "@file", argv[0]);
+   rb_iv_set(self, "@options", options);
+   
+   return(self);
+}
+
+
+/**
+ * This function provides the file attribute accessor for the Database class.
+ *
+ * @param  self  A reference to the object that the method is being called on.
+ *
+ * @return  A reference to the database file name associated with the Database
+ *          object
+ *
+ */
+static VALUE getDatabaseFile(VALUE self)
+{
+   return(rb_iv_get(self, "@file"));
+}
+
+
+/**
+ * This method attempts to open a connection to a database using the details
+ * in a Database object.
+ *
+ * @param  argc  A count of the number of parameters passed to the function.
+ * @param  argv  A pointer to the start of an array containing the function
+ *               parameter values.
+ * @param  self  A reference to the object that the call is being made on.
+ *
+ * @return  A reference to a Connection object or nil if an error occurs.
+ *
+ */
+static VALUE connectToDatabase(int argc, VALUE *argv, VALUE self)
+{
+   VALUE result     = Qnil,
+         user       = Qnil,
+         password   = Qnil,
+         options    = rb_iv_get(self, "@options"),
+         connection = Qnil;
+
+   if(argc > 0)
+   {
+      user = argv[0];
+   }
+   if(argc > 1)
+   {
+      password = argv[1];
+   }
+   if(argc > 2)
+   {
+      rb_funcall(options, rb_intern("update"), 1, argv[2]);
+   }
+   
+   connection = rb_connection_new(self, user, password, options);
+   if(rb_block_given_p())
+   {
+      result = rb_ensure(connectBlock, connection, connectEnsure, connection);
+   }
+   else
+   {
+      result = connection;
+   }
+   
+   return(result);
+}
+
+
+/**
+ * This function provides the create class method for Database class.
+ *
+ * @param  usused    Like it says, not used.
+ * @param  file      A String containing the  name of the primary file for the
+ *                   database to be created.
+ * @param  user      The database user that will be used in creating the new
+ *                   database.
+ * @param  password  A String containing the password for the user to be used
+ *                   in creating the database.
+ * @param  size      The size of pages that will be used by the database.
+ * @param  set       A String containing the name of the character set to be
+ *                   used in creating the database.
+ *
+ * @return  A reference to a Database object on success, nil on failure.
+ *
+ */
+static VALUE createDatabase(int argc, VALUE *argv, VALUE unused)
+{
+   VALUE         database    = Qnil,
+                 set         = Qnil;
+   char          sql[512]    = "",
+                 *text       = NULL;
+   int           value       = 1024;
+   isc_db_handle connection  = 0;
+   isc_tr_handle transaction = 0;
+   ISC_STATUS    status[20];
+   
+   /* Check that sufficient parameters have been provided. */
+   if(argc < 3)
+   {
+      rb_raise(rb_eArgError, "Wrong number of parameters (%d for %d).", argc,
+               3);
+   }
+   
+   /* Check values that are permitted restricted values. */
+   if(argc > 3)
+   {
+      value = FIX2INT(argv[3]);
+      if(value != 1024 && value != 2048 && value != 4096 && value != 8192)
+      {
+         rb_raise(rb_eException,
+                  "Invalid database page size value . Valid values are 1024, "\
+                  "2048 4096 or 8192.");
+      }
+   }
+   
+   /* Prepare the SQL statement. */
+   sprintf(sql, "CREATE DATABASE '%s'",
+           STR2CSTR(rb_funcall(argv[0], rb_intern("to_s"), 0)));
+   text = STR2CSTR(rb_funcall(argv[1], rb_intern("to_s"), 0));
+   if(strlen(text) > 0)
+   {
+      strcat(sql, " USER '");
+      strcat(sql, text);
+      strcat(sql, "'");
+   }
+   
+   text = STR2CSTR(rb_funcall(argv[2], rb_intern("to_s"), 0));
+   if(strlen(text) > 0)
+   {
+      strcat(sql, " PASSWORD '");
+      strcat(sql, text);
+      strcat(sql, "'");
+   }
+   
+   if(argc > 3)
+   {
+      char text[50];
+      
+      sprintf(text, " PAGE_SIZE = %d", value);
+      strcat(sql, text);
+   }
+   
+   if(argc > 4 && argv[4] != Qnil)
+   {
+      char *text = NULL;
+      
+      set  = rb_funcall(argv[4], rb_intern("to_s"), 0);
+      text = STR2CSTR(set);
+      if(strlen(text) > 0)
+      {
+         strcat(sql, " DEFAULT CHARACTER SET ");
+         strcat(sql, text);
+      }
+   }
+   strcat(sql, ";");
+   
+   if(isc_dsql_execute_immediate(status, &connection, &transaction, 0, sql,
+                                 3, NULL) != 0)
+   {
+      rb_fireruby_raise(status, "Database creation error.");
+   }
+   
+   if(connection != 0)
+   {
+      isc_detach_database(status, &connection);
+   }
+   
+   database = rb_database_new(argv[0]);
+   if(set != Qnil)
+   {
+      setDatabaseCharacterSet(database, set);
+   }
+   
+   return(database);
+}
+
+
+/**
+ * This function attempts to attach to and drop a specified database. This
+ * function provides the drop method for the Database class.
+ *
+ * @param  self      A reference to the Database object representing the
+ *                   database to be dropped.
+ * @param  user      A reference to the database user name that will be used
+ *                   in dropping the database
+ * @param  password  A reference to the user password that will be used in
+ *                   dropping the database.
+ *
+ * @return  Always returns nil.
+ *
+ */
+static VALUE dropDatabase(VALUE self, VALUE user, VALUE password)
+{
+   VALUE            connection = rb_connection_new(self, user, password, Qnil);
+   ConnectionHandle *cHandle   = NULL;
+   ISC_STATUS       status[20];
+   
+   Data_Get_Struct(connection, ConnectionHandle, cHandle);
+   if(isc_drop_database(status, &cHandle->handle) != 0)
+   {
+      rb_fireruby_raise(status, "Error dropping database.");
+   }
+   
+   return(Qnil);
+}
+
+
+/**
+ * This function retrieves the current character set specification for a
+ * Database object.
+ *
+ * @param  self  A reference to the Database object to make the call on.
+ *
+ * @return  A reference to the database character set. May be nil.
+ *
+ */
+static VALUE getDatabaseCharacterSet(VALUE self)
+{
+   VALUE options = rb_iv_get(self, "@options");
+   
+   return(rb_hash_aref(options, INT2FIX(isc_dpb_lc_ctype)));
+}
+
+
+/**
+ * This function assigns a character set for use with a Database object. To
+ * revert to an unspecified character set assign nil to this value.
+ *
+ * @param  self  A reference to the Database object to be updated.
+ * @param  set   A string containing the name of the character set.
+ *
+ * @return  A reference to the updated Database object.
+ *
+ */
+static VALUE setDatabaseCharacterSet(VALUE self, VALUE set)
+{
+   VALUE options = rb_iv_get(self, "@options");
+   
+   if(set != Qnil)
+   {
+      rb_hash_aset(options, INT2FIX(isc_dpb_lc_ctype), set); 
+   }
+   else
+   {
+      rb_hash_delete(options, INT2FIX(isc_dpb_lc_ctype));
+   }
+   
+   return(self);
+}
+
+
+/**                 
+ * This function is used to integrate with the Ruby garbage collection system
+ * to guarantee the release of the resources associated with a Database object.
+ *
+ * @param  database  A pointer to the DatabaseHandle structure associated with
+ *                   a Database object being destroyed.
+ *
+ */
+void databaseFree(void *database)
+{
+   if(database != NULL)
+   {
+      free((DatabaseHandle *)database);
+   }
+}
+
+
+/**
+ * This function implements the handling of blocks passed to a call to the
+ * connect method of the Database class. The block passed to the connect
+ * function is expected to take a single parameter, which will be the connection
+ * created.
+ *
+ * @param  connection  A reference to the connection established for the block.
+ *
+ * @return  The return value provided by execution of the provided block.
+ *
+ */
+VALUE connectBlock(VALUE connection)
+{
+   return(rb_yield(connection));
+}
+
+
+/**
+ * This function provides the ensure aspect for the block handling associated
+ * with the connect method. This method ensures that the connection opened for
+ * the block is closed when the block completes.
+ *
+ * @param  connection  A reference to the connection to be closed.
+ *
+ * @return  Always Qnil.
+ *
+ */
+VALUE connectEnsure(VALUE connection)
+{
+   rb_funcall(connection, rb_intern("close"), 0);
+   return(Qnil);
+}
+
+
+/**
+ * This function provides a means to programmatically create a Database object.
+ *
+ * @param  file A reference to a String containing the database file details.
+ *
+ * @return  A reference to the Database object created.
+ *
+ */
+VALUE rb_database_new(VALUE file)
+{
+   VALUE database     = allocateDatabase(cDatabase),
+         parameters[] = {file};
+   
+   initializeDatabase(1, parameters, database);
+   
+   return(database);
+}
+
+
+/**
+ * This function initializes the Database class within the Ruby environment.
+ * The class is established under the module specified to the function.
+ *
+ * @param  module  A reference to the module to create the class within.
+ *
+ */
+void Init_Database(VALUE module)
+{
+   cDatabase = rb_define_class_under(module, "Database", rb_cObject);
+   rb_define_alloc_func(cDatabase, allocateDatabase);
+   rb_define_method(cDatabase, "initialize", initializeDatabase, -1);
+   rb_define_method(cDatabase, "file", getDatabaseFile, 0);
+   rb_define_method(cDatabase, "connect", connectToDatabase, -1);
+   rb_define_method(cDatabase, "drop", dropDatabase, 2);
+   rb_define_method(cDatabase, "character_set", getDatabaseCharacterSet, 0);
+   rb_define_method(cDatabase, "character_set=", setDatabaseCharacterSet, 1);
+   rb_define_module_function(cDatabase, "create", createDatabase, -1);
+}