rubyfb 0.5.2

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);
+}

data/ext/Database.h

@@ -0,0 +1,48 @@
+/*------------------------------------------------------------------------------
+ * Database.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_DATABASE_H
+#define FIRERUBY_DATABASE_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
+   {
+      int unused;
+   } DatabaseHandle;
+   
+   /* Function prototypes. */
+   void Init_Database(VALUE);
+   void databaseFree(void *);
+   VALUE rb_database_new(VALUE);   
+
+#endif /* FIRERUBY_DATABASE_H */