/*------------------------------------------------------------------------------
 * TypeMap.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 "TypeMap.h"
#include <time.h>
#include <math.h>
#include <limits.h>
#include "Blob.h"
#include "Connection.h"
#include "Transaction.h"
#include "ResultSet.h"
#include "Statement.h"
#include "FireRuby.h"

#ifdef OS_UNIX
   #include <inttypes.h>
#else
   typedef short     int16_t;
   typedef long      int32_t;
   typedef long long int64_t;
#endif

/* Function prototypes. */
VALUE createDate(const struct tm *);
VALUE createDateTime(VALUE dt);
VALUE createTime(VALUE dt);
VALUE createSafeTime(const struct tm*);
VALUE getConstant(const char *, VALUE);
VALUE toDateTime(VALUE);
VALUE rescueConvert(VALUE, VALUE);
void storeBlob(VALUE, XSQLVAR *, ConnectionHandle *, TransactionHandle *);
void populateBlobField(VALUE, XSQLVAR *, VALUE);
void populateDoubleField(VALUE, XSQLVAR *);
void populateFloatField(VALUE, XSQLVAR *);
void populateInt64Field(VALUE, XSQLVAR *);
void populateLongField(VALUE, XSQLVAR *);
void populateShortField(VALUE, XSQLVAR *);
void populateTextField(VALUE, XSQLVAR *);
void populateDateField(VALUE, XSQLVAR *);
void populateTimeField(VALUE, XSQLVAR *);
void populateTimestampField(VALUE, XSQLVAR *);


/**
 * This function converts a single XSQLVAR entry to a Ruby VALUE type.
 *
 * @param  entry        A pointer to the SQLVAR type containing the data to be
 *                      converted.
 * @param  database     A pointer to the database handle relating to the data.
 * @param  transaction  A pointer to the transaction handle relating to the
 *                      data.
 *
 * @return  A Ruby type for the XSQLVAR entry. The actual type will depend on
 *          the field type referenced.
 *
 */
VALUE toValue(XSQLVAR *entry,
              isc_db_handle *database,
              isc_tr_handle *transaction)
{
   VALUE     value  = rb_ary_new();

   /* Check for NULL values. */
   if(!((entry->sqltype & 1) && (*entry->sqlind < 0)))
   {
      int        type    = (entry->sqltype & ~1);
      char       *array  = NULL,
                 column[256],
                 table[256];
      struct tm  datetime;
      short      length;
      double     actual;
      BlobHandle *blob   = NULL;
      VALUE      setting = getFireRubySetting("DATE_AS_DATE"),
                 working = Qnil;

      switch(type)
      {
         case SQL_ARRAY : /* Type: ARRAY */
            /* TO BE DONE! */
            break;

         case SQL_BLOB:   /* Type: BLOB */
            memset(column, 0, 256);
            memset(table, 0, 256);
            memcpy(column, entry->sqlname, entry->sqlname_length);
            memcpy(table, entry->relname, entry->relname_length);
            blob = openBlob(*(ISC_QUAD *)entry->sqldata, column, table, database,
                            transaction);
            working = Data_Wrap_Struct(cBlob, NULL, blobFree, blob);
            rb_ary_push(value, initializeBlob(working));
            rb_ary_push(value, getColumnType(entry));
            break;

         case SQL_TYPE_DATE : /* Type: DATE */
            memset(&datetime, 0, sizeof(struct tm));
            isc_decode_sql_date((ISC_DATE *)entry->sqldata, &datetime);
            datetime.tm_sec  = 0;
            datetime.tm_min  = 0;
            datetime.tm_hour = 0;
            if(setting == Qtrue)
            {
               rb_ary_push(value, createDate(&datetime));
            }
            else
            {
               rb_ary_push(value, createSafeTime(&datetime));
            }
            rb_ary_push(value, getColumnType(entry));
            break;

         case SQL_DOUBLE : /* Type: DOUBLE PRECISION, DECIMAL, NUMERIC */
            rb_ary_push(value, rb_float_new(*((double *)entry->sqldata)));
            rb_ary_push(value, getColumnType(entry));
            break;

         case SQL_FLOAT : /* Type: FLOAT */
            rb_ary_push(value, rb_float_new(*((float *)entry->sqldata)));
            rb_ary_push(value, getColumnType(entry));
            break;

         case SQL_INT64 : /* Type: DECIMAL, NUMERIC */
            if(entry->sqlscale != 0)
            {
               double divisor  = pow(10, abs(entry->sqlscale));

               actual = *((long long *)entry->sqldata);
               rb_ary_push(value, rb_float_new(actual / divisor));
            }
            else
            {
               rb_ary_push(value, LL2NUM(*((long long *)entry->sqldata)));
            }
            rb_ary_push(value, getColumnType(entry));
            break;

         case SQL_LONG : /* Type: INTEGER, DECIMAL, NUMERIC */
            if(entry->sqlscale != 0)
            {
               double divisor  = pow(10, abs(entry->sqlscale));

               actual = *((int32_t *)entry->sqldata);
               rb_ary_push(value, rb_float_new(actual / divisor));
            }
            else
            {
               rb_ary_push(value, LONG2NUM(*((int32_t *)entry->sqldata)));
            }
            rb_ary_push(value, getColumnType(entry));
            break;

         case SQL_SHORT : /* Type: SMALLINT, DECIMAL, NUMERIC */
            if(entry->sqlscale != 0)
            {
               double divisor  = pow(10, abs(entry->sqlscale));

               actual = *((short *)entry->sqldata);
               rb_ary_push(value, rb_float_new(actual / divisor));
            }
            else
            {
               rb_ary_push(value, INT2NUM(*((short *)entry->sqldata)));
            }
            rb_ary_push(value, getColumnType(entry));
            break;

         case SQL_TEXT : /* Type: CHAR */
            array = ALLOC_N(char, entry->sqllen + 1);
            if(array != NULL)
            {
               memset(array, 0, entry->sqllen + 1);
               memcpy(array, entry->sqldata, entry->sqllen);
               rb_ary_push(value, rb_str_new2(array));
               rb_ary_push(value, getColumnType(entry));
               free(array);
            }
            break;

         case SQL_TYPE_TIME : /* Type: TIME */
            isc_decode_sql_time((ISC_TIME *)entry->sqldata, &datetime);
            datetime.tm_year = 70;
            datetime.tm_mon  = 0;
            datetime.tm_mday = 1;
            rb_ary_push(value, createSafeTime(&datetime));
            rb_ary_push(value, getColumnType(entry));
            break;

         case SQL_TIMESTAMP : /* Type: TIMESTAMP */
            isc_decode_timestamp((ISC_TIMESTAMP *)entry->sqldata, &datetime);
            rb_ary_push(value, createSafeTime(&datetime));
            rb_ary_push(value, getColumnType(entry));
            break;

         case SQL_VARYING :
            memcpy(&length, entry->sqldata, 2);
            if(length >= 0)
            {
               array = ALLOC_N(char, length + 1);
               if(array != NULL)
               {
                  memset(array, 0, length + 1);
                  memcpy(array, &entry->sqldata[2], length);
                  rb_ary_push(value, rb_str_new2(array));
                  rb_ary_push(value, getColumnType(entry));
                  free(array);
               }
            }
            break;

         default :
            rb_ary_push(value, Qnil);
            rb_ary_push(value, Qnil);
      } /* End of switch. */
   }
   else
   {
      rb_ary_push(value, Qnil);
      rb_ary_push(value, getColumnType(entry));   
   }

   return(value);
}


/**
 * This function attempts to convert the data contents of a XSQLDA to a Ruby
 * array of values.
 *
 * @param  results  A reference to the ResultSet object to extract the data row
 *                  from.
 *
 * @return  A reference to the array containing the row data from the XSQLDA.
 *
 */
VALUE toArray(VALUE results)
{
   VALUE             array       = rb_ary_new(),
                     transaction = rb_iv_get(results, "@transaction"),
                     connection  = rb_iv_get(results, "@connection");
   XSQLVAR           *entry      = NULL;
   ConnectionHandle  *cHandle    = NULL;
   ResultsHandle     *rHandle    = NULL;
   TransactionHandle *tHandle    = NULL;
   int               i;

   Data_Get_Struct(connection, ConnectionHandle, cHandle);
   Data_Get_Struct(results, ResultsHandle, rHandle);
   Data_Get_Struct(transaction, TransactionHandle, tHandle);
   entry = rHandle->output->sqlvar;
   for(i = 0; i < rHandle->output->sqln; i++, entry++)
   {
      VALUE value = toValue(entry, &cHandle->handle, &tHandle->handle);

      rb_ary_push(array, value);
   }

   return(array);
}


/**
 * This function takes an array of parameters and populates the parameter set
 * for a Statement object with the details. Attempts are made to convert the
 * parameter types where appropriate but, if this isn't possible then an
 * exception is generated.
 *
 * @param  parameters  A pointer to the XSQLDA area that will be used to
 *                     hold the parameter data.
 * @param  array       A reference to an array containing the parameter data to
 *                     be used.
 * @param  source      Either a Statement or ResultSet object that can be used
 *                     to get connection and transaction details.
 *
 */
void setParameters(XSQLDA *parameters, VALUE array, VALUE source)
{
   VALUE   value;
   int     index,
           size;
   XSQLVAR *parameter = NULL;

   /* Check that sufficient parameters have been provided. */
   value     = rb_funcall(array, rb_intern("size"), 0);
   size      = (TYPE(value) == T_FIXNUM ? FIX2INT(value) : NUM2INT(value));
   parameter = parameters->sqlvar;
   if(size != parameters->sqld)
   {
      rb_raise(rb_eException,
               "Parameter set mismatch. Too many or too few parameters "\
               "specified for a SQL statement.");
   }
   parameters->sqln = parameters->sqld;
   parameters->version = 1;

   /* Populate the parameters from the array's contents. */
   for(index = 0; index < size; index++, parameter++)
   {
      int type = (parameter->sqltype & ~1);

      value = rb_ary_entry(array, index);
      /* Check for nils to indicate null values. */
      if(value != Qnil)
      {
         VALUE name = rb_funcall(value, rb_intern("class"), 0);

         parameter->sqlind = 0;
         name = rb_funcall(name, rb_intern("name"), 0);
         switch(type)
         {
            case SQL_ARRAY : /* Type: ARRAY */
               /* TO BE DONE! */
               break;

            case SQL_BLOB:   /* Type: BLOB */
               populateBlobField(value, parameter, source);
               break;

            case SQL_DOUBLE : /* Type: DOUBLE PRECISION, DECIMAL, NUMERIC */
               populateDoubleField(value, parameter);
               break;

            case SQL_FLOAT : /* Type: FLOAT */
               populateFloatField(value, parameter);
               break;

            case SQL_INT64 : /* Type: DECIMAL, NUMERIC */
               populateInt64Field(value, parameter);
               break;

            case SQL_LONG : /* Type: INTEGER, DECIMAL, NUMERIC */
               populateLongField(value, parameter);
               break;

            case SQL_SHORT : /* Type: SMALLINT, DECIMAL, NUMERIC */
               populateShortField(value, parameter);
               break;

            case SQL_TEXT : /* Type: CHAR */
               populateTextField(value, parameter);
               break;

            case SQL_TYPE_DATE : /* Type: DATE */
               populateDateField(value, parameter);
               break;

            case SQL_TYPE_TIME : /* Type: TIME */
               populateTimeField(value, parameter);
               break;

            case SQL_TIMESTAMP : /* Type: TIMESTAMP */
               populateTimestampField(value, parameter);
               break;

            case SQL_VARYING : /* Type: VARCHAR */
               populateTextField(value, parameter);
               break;

            default :
               rb_raise(rb_eException,
                        "Unknown SQL type encountered in statement parameter "\
                        "set.");
         } /* End of the switch statement. */
      }
      else
      {
         /* Mark the field as a NULL value. */
         memset(parameter->sqldata, 0, parameter->sqllen);
         *parameter->sqlind = -1;
      }
   }
}


/**
 * This function converts a struct tm to a Ruby Date instance.
 *
 * @param  date  A structure containing the date details.
 *
 * @return  A Ruby Date object.
 *
 */
VALUE createDate(const struct tm *date)
{
   VALUE result = Qnil,
         klass  = Qnil;

   klass = getClass("Date");

   /* Check if we need to require date. */
   if(klass == Qnil)
   {
      rb_require("date");
      klass = getClass("Date");
   }

   /* Check that we got the Date class. */
   if(klass != Qnil)
   {
      VALUE arguments[3];

      /* Prepare the arguments. */
      arguments[0] = INT2FIX(date->tm_year + 1900);
      arguments[1] = INT2FIX(date->tm_mon + 1);
      arguments[2] = INT2FIX(date->tm_mday);

      /* Create the class instance. */
      result = rb_funcall2(klass, rb_intern("new"), 3, arguments);
   }


   return(result);
}


/**
 * This function converts a struct tm to a Ruby DateTime instance.
 *
 * @param  datetime  A structure containing the date/time details.
 *
 * @return  A Ruby DateTime object.
 *
 */
VALUE createDateTime(VALUE dt)
{
   VALUE result = Qnil,
         klass  = Qnil;

   struct tm *datetime;
   Data_Get_Struct(dt, struct tm, datetime);

   klass = getClass("DateTime");

   /* Check if we need to require date. */
   if(klass == Qnil)
   {
      rb_require("date");
      klass = getClass("DateTime");
   }

   /* Check that we got the DateTime class. */
   if(klass != Qnil)
   {
      VALUE arguments[7];

      /* Prepare the arguments. */
      arguments[0] = INT2FIX(datetime->tm_year + 1900);
      arguments[1] = INT2FIX(datetime->tm_mon + 1);
      arguments[2] = INT2FIX(datetime->tm_mday);
      arguments[3] = INT2FIX(datetime->tm_hour);
      arguments[4] = INT2FIX(datetime->tm_min);
      arguments[5] = INT2FIX(datetime->tm_sec);
      arguments[6] = rb_funcall(rb_funcall(klass, rb_intern("now"), 0), rb_intern("offset"), 0);

      /* Create the class instance. */
      result = rb_funcall2(klass, rb_intern("new"), 7, arguments);
   }

   return(result);
}


/**
 * This function converts a struct tm to a Ruby Time instance.
 *
 * @param  datetime  A structure containing the date/time details.
 *
 * @return  A Ruby Time object.
 *
 */
VALUE createTime(VALUE dt)
{
   VALUE result = Qnil,
         klass  = Qnil;

   struct tm *datetime;
   Data_Get_Struct(dt, struct tm, datetime);

   klass = getClass("Time");

   /* Check that we got the Time class. */
   if(klass != Qnil)
   {
      VALUE arguments[6];

      /* Prepare the arguments. */
      /*fprintf(stderr, "%d-%d-%d %d:%d:%d\n", datetime->tm_year + 1900,
              datetime->tm_mon + 1, datetime->tm_mday, datetime->tm_hour,
              datetime->tm_min, datetime->tm_sec);*/
      arguments[0] = INT2FIX(datetime->tm_year + 1900);
      arguments[1] = INT2FIX(datetime->tm_mon + 1);
      arguments[2] = INT2FIX(datetime->tm_mday);
      arguments[3] = INT2FIX(datetime->tm_hour);
      arguments[4] = INT2FIX(datetime->tm_min);
      arguments[5] = INT2FIX(datetime->tm_sec);

      /* Create the class instance. */
      result = rb_funcall2(klass, rb_intern("local"), 6, arguments);
   }

   return(result);
}

/**
 * This function converts a struct tm to a Ruby Time instance. 
 * If the conversion process results in an out of range error then
 * it will convert the struct to a DateTime instance.
 *
 * @param datetime  A structure containing the date/time details.
 *
 * @return  A Ruby Time object if the arguments are in range, otherwise 
 *          a Ruby DateTime object.
 *
 */
VALUE createSafeTime(const struct tm *datetime)
{
   VALUE dt = Data_Wrap_Struct(rb_cObject, NULL, NULL, datetime);
   return rb_rescue(createTime, dt, createDateTime, dt);
}

/**
 * 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.
 *
 */
VALUE getConstant(const char *name, VALUE module)
{
   VALUE owner = module,
         constants,
         string,
         exists,
         entry;

   /* Check that we've got somewhere to look. */
   if(owner == Qnil)
   {
      owner = rb_cModule;
   }
   constants = rb_funcall(owner, rb_intern("constants"), 0),
   string    = rb_str_new2(name),
   exists    = rb_funcall(constants, rb_intern("include?"), 1, string);

   if(exists != Qfalse)
   {
      ID    id     = rb_intern(name);
      VALUE symbol = ID2SYM(id);

      entry = rb_funcall(owner, rb_intern("const_get"), 1, symbol);
   }

   return(entry);
}


/**
 * This method fetches a Ruby module definition object based on a class name.
 * The method is assumed to have been defined at the top level.
 *
 * @return  A Ruby VALUE representing the Module requested, or nil if the
 *          module could not be located.
 *
 */
VALUE getModule(const char *name)
{
   VALUE module = getConstant(name, Qnil);

   if(module != Qnil)
   {
      VALUE type = rb_funcall(module, rb_intern("class"), 0);

      if(type != rb_cModule)
      {
         module = Qnil;
      }
   }

   return(module);
}


/**
 * 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)
{
   VALUE klass = getConstant(name, Qnil);

   if(klass != Qnil)
   {
      VALUE type = rb_funcall(klass, rb_intern("class"), 0);

      if(type != rb_cClass)
      {
         klass = Qnil;
      }
   }

   return(klass);
}


/**
 * This method fetches a module from a specified module.
 *
 * @param  name   The name of the class to fetch.
 * @param  owner  The module to search for the module in.
 *
 * @return  A Ruby VALUE representing the requested module, or nil if it could
 *          not be located.
 *
 */
VALUE getModuleInModule(const char *name, VALUE owner)
{
   VALUE module = getConstant(name, owner);

   if(module != Qnil)
   {
      VALUE type = rb_funcall(module, rb_intern("class"), 0);

      if(type != rb_cModule)
      {
         module = Qnil;
      }
   }

   return(module);
}


/**
 * 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);
}


/**
 * This function attempts to convert a VALUE to a series of date/time values.
 *
 * @param  value  A reference to the value to be converted.
 *
 * @return  A VALUE that represents an array containing the date/time details
 *          in the order year, month, day of month, hours, minutes and seconds.
 *
 */
VALUE toDateTime(VALUE value)
{
   VALUE result,
         klass = rb_funcall(value, rb_intern("class"), 0);

   if(klass == rb_cTime)
   {
      VALUE data;

      result = rb_ary_new();

      data = rb_funcall(value, rb_intern("year"), 0);
      rb_ary_push(result, INT2FIX(FIX2INT(data) - 1900));
      data = rb_funcall(value, rb_intern("month"), 0);
      rb_ary_push(result, INT2FIX(FIX2INT(data) - 1));
      rb_ary_push(result, rb_funcall(value, rb_intern("day"), 0));
      rb_ary_push(result, rb_funcall(value, rb_intern("hour"), 0));
      rb_ary_push(result, rb_funcall(value, rb_intern("min"), 0));
      rb_ary_push(result, rb_funcall(value, rb_intern("sec"), 0));
   }
   else if(klass == getClass("Date"))
   {
      VALUE data;

      result = rb_ary_new();

      data = rb_funcall(value, rb_intern("year"), 0);
      rb_ary_push(result, INT2FIX(FIX2INT(data) - 1900));
      data = rb_funcall(value, rb_intern("month"), 0);
      rb_ary_push(result, INT2FIX(FIX2INT(data) - 1));
      rb_ary_push(result, rb_funcall(value, rb_intern("mday"), 0));
      rb_ary_push(result, INT2FIX(0));
      rb_ary_push(result, INT2FIX(0));
      rb_ary_push(result, INT2FIX(0));
   }
   else
   {
      rb_raise(rb_eException, "Value conversion error.");
   }

   return(result);
}


/**
 * This function represents the rescue block for data conversions.
 *
 * @param  arguments  An array of VALUEs. The first is expected to contain the
 *                    field offset of the value being converted. The second a
 *                    string containing the name of the data type being
 *                    converted from and the third a string containing the name
 *                    of the data type being converted to.
 * @param  error      Will be populates with error details of the exception
 *                    raised.
 *
 */
VALUE rescueConvert(VALUE arguments, VALUE error)
{
   VALUE message;
   char  text[512];

   sprintf(text, "Error converting input column %d from a %s to a %s.",
           FIX2INT(rb_ary_entry(arguments, 0)),
           STR2CSTR(rb_ary_entry(arguments, 1)),
           STR2CSTR(rb_ary_entry(arguments, 2)));
   message = rb_str_new2(text);

   return(rb_funcall(rb_eException, rb_intern("exception"), 1, &message));
}


/**
 * This function creates a new blob and returns the identifier for it.
 *
 * @param  info         A pointer to a string containing the blob data.
 * @param  field        The field that the blob identifier needs to be inserted
 *                      into.
 * @param  database     A pointer to the database handle to be used in creating
 *                      the blob.
 * @param  transaction  A pointer to the transaction handle to be used in
 *                      creating the blob.
 *
 * @return  An ISC_QUAD value containing the identifier for the blob created.
 *
 */
void storeBlob(VALUE info,
               XSQLVAR *field,
               ConnectionHandle *connection,
               TransactionHandle *transaction)
{
   ISC_STATUS      status[20];
   isc_blob_handle handle  = 0;
   ISC_QUAD        *blobId = (ISC_QUAD *)field->sqldata;
   VALUE           number  = rb_funcall(info, rb_intern("length"), 0);
   long            length  = 0;
   char            *data   = STR2CSTR(info);

   length = TYPE(number) == T_FIXNUM ? FIX2INT(number) : NUM2INT(number);
   field->sqltype = SQL_BLOB;
   if(isc_create_blob(status, &connection->handle, &transaction->handle,
                      &handle, blobId) == 0)
   {
      long           offset = 0;
      unsigned short size   = 0;

      while(offset < length)
      {
         char *buffer = &data[offset];

         size = (length - offset) > USHRT_MAX ? USHRT_MAX : length - offset;
         if(isc_put_segment(status, &handle, size, buffer) != 0)
         {
            ISC_STATUS other[20];

            isc_close_blob(other, &handle);
            rb_fireruby_raise(status, "Error writing blob data.");
         }

         offset = offset + size;
      }

      if(isc_close_blob(status, &handle) != 0)
      {
         rb_fireruby_raise(status, "Error closing blob.");
      }
   }
   else
   {
      rb_fireruby_raise(status, "Error storing blob data.");
   }
}


/**
 * This function populates a blob output parameter.
 *
 * @param  value   The value to be insert into the blob.
 * @param  field   A pointer to the output field to be populated.
 * @param  source  A reference to either a Statement or ResultSet object that
 *                 contains the connection and transaction details.
 *
 */
void populateBlobField(VALUE value, XSQLVAR *field, VALUE source)
{
   VALUE             attribute;
   ConnectionHandle  *connection = NULL;
   TransactionHandle *transaction = NULL;

   if(TYPE(value) != T_STRING)
   {
      rb_fireruby_raise(NULL, "Error converting input parameter to blob.");
   }

   /* Fetch the connection and transaction details. */
   attribute = rb_iv_get(source, "@connection");
   Data_Get_Struct(attribute, ConnectionHandle, connection);
   attribute = rb_iv_get(source, "@transaction");
   Data_Get_Struct(attribute, TransactionHandle, transaction);
   storeBlob(value, field, connection, transaction);
   field->sqltype = SQL_BLOB;
}


/**
 * This method populates a date output field.
 *
 * @param  value  A reference to the value to be used to populate the field.
 * @param  field  A pointer to the output field to be populated.
 *
 */
void populateDateField(VALUE value, XSQLVAR *field)
{
   struct tm datetime;
   VALUE     arguments = rb_ary_new();

   rb_ary_push(arguments, rb_str_new2("date"));
   value = rb_rescue(toDateTime, value, rescueConvert, arguments);
   if(TYPE(value) != T_ARRAY)
   {
      VALUE message = rb_funcall(value, rb_intern("message"), 0);
      rb_fireruby_raise(NULL, STR2CSTR(message));
   }
   datetime.tm_year = FIX2INT(rb_ary_entry(value, 0));
   datetime.tm_mon  = FIX2INT(rb_ary_entry(value, 1));
   datetime.tm_mday = FIX2INT(rb_ary_entry(value, 2));
   isc_encode_sql_date(&datetime, (ISC_DATE *)field->sqldata);
   field->sqltype   = SQL_TYPE_DATE;
}


/**
 * This method populates a double output field.
 *
 * @param  value  A reference to the value to be used to populate the field.
 * @param  field  A pointer to the output field to be populated.
 *
 */
void populateDoubleField(VALUE value, XSQLVAR *field)
{
   double store;
   VALUE  actual;

   if(TYPE(value) != T_FLOAT)
   {
      if(rb_obj_is_kind_of(value, rb_cNumeric) || TYPE(value) == T_STRING)
      {
         actual = rb_funcall(value, rb_intern("to_f"), 0);
      }
      else
      {
         rb_fireruby_raise(NULL,
                           "Error converting input parameter to double.");
      }
   }

   store = NUM2DBL(value);
   memcpy(field->sqldata, &store, field->sqllen);
   field->sqltype = SQL_DOUBLE;
}


/**
 * This method populates a double output field.
 *
 * @param  value  A reference to the value to be used to populate the field.
 * @param  field  A pointer to the output field to be populated.
 *
 */
void populateFloatField(VALUE value, XSQLVAR *field)
{
   double full  = 0.0;
   float  store = 0.0;
   VALUE  actual;

   if(TYPE(value) != T_FLOAT)
   {
      if(rb_obj_is_kind_of(value, rb_cNumeric) || TYPE(value) == T_STRING)
      {
         actual = rb_funcall(value, rb_intern("to_f"), 0);
      }
      else
      {
         rb_fireruby_raise(NULL,
                           "Error converting input parameter to double.");
      }
   }

   full = NUM2DBL(value);
   store = (float)full;
   memcpy(field->sqldata, &store, field->sqllen);
   field->sqltype = SQL_FLOAT;
}


/**
 * This function populates a output parameter field with the data of a Ruby
 * value.
 *
 * @param  value  A reference to the Ruby value to be inserted into the field.
 * @param  field  A pointer to the XSQLVAR field that the value will go into.
 *
 */
void populateInt64Field(VALUE value, XSQLVAR *field)
{
   VALUE     actual = Qnil;
   long long store  = 0;

   if(rb_obj_is_kind_of(value, rb_cInteger))
   {
      actual = value;
   }
   else if(TYPE(value) == T_FLOAT)
   {
      double number = NUM2DBL(value);

      if(field->sqlscale != 0)
      {
         number = number * pow(10, abs(field->sqlscale));
         actual = INT2NUM((long)number);
      }
   }
   else if(TYPE(value) == T_STRING)
   {
      actual = rb_funcall(value, rb_intern("to_i"), 0);
   }
   else
   {
      rb_fireruby_raise(NULL,
                        "Error converting input parameter to 64 bit integer.");
   }

   store = TYPE(actual) == T_FIXNUM ? FIX2INT(actual) : NUM2INT(actual);
   memcpy(field->sqldata, &store, field->sqllen);
   field->sqltype = SQL_INT64;
}


/**
 * This function populates a output parameter field with the data of a Ruby
 * value.
 *
 * @param  value  A reference to the Ruby value to be inserted into the field.
 * @param  field  A pointer to the XSQLVAR field that the value will go into.
 *
 */
void populateLongField(VALUE value, XSQLVAR *field)
{
   VALUE     actual = Qnil;
   long long full   = 0;
   long      store  = 0;

   if(rb_obj_is_kind_of(value, rb_cInteger))
   {
      actual = value;
   }
   else if(TYPE(value) == T_FLOAT)
   {
      double number = NUM2DBL(value);

      if(field->sqlscale != 0)
      {
         number = number * pow(10, abs(field->sqlscale));
         actual = INT2NUM((long)number);
      }
   }
   else if(TYPE(value) == T_STRING)
   {
      actual = rb_funcall(value, rb_intern("to_i"), 0);
   }
   else
   {
      rb_fireruby_raise(NULL,
                        "Error converting input parameter to long integer.");
   }

   full  = TYPE(actual) == T_FIXNUM ? FIX2INT(actual) : NUM2INT(actual);
   store = (long)full;
   memcpy(field->sqldata, &store, field->sqllen);
   field->sqltype = SQL_LONG;
}


/**
 * This function populates a output parameter field with the data of a Ruby
 * value.
 *
 * @param  value  A reference to the Ruby value to be inserted into the field.
 * @param  field  A pointer to the XSQLVAR field that the value will go into.
 *
 */
void populateShortField(VALUE value, XSQLVAR *field)
{
   VALUE     actual = Qnil;
   long long full   = 0;
   short     store  = 0;

   if(rb_obj_is_kind_of(value, rb_cInteger))
   {
      actual = value;
   }
   else if(TYPE(value) == T_FLOAT)
   {
      double number = NUM2DBL(value);

      if(field->sqlscale != 0)
      {
         number = number * pow(10, abs(field->sqlscale));
         actual = INT2NUM((long)number);
      }
   }
   else if(TYPE(value) == T_STRING)
   {
      actual = rb_funcall(value, rb_intern("to_i"), 0);
   }
   else
   {
      rb_fireruby_raise(NULL,
                        "Error converting input parameter to short integer.");
   }

   full  = TYPE(actual) == T_FIXNUM ? FIX2INT(actual) : NUM2INT(actual);
   store = (short)full;
   memcpy(field->sqldata, &store, field->sqllen);
   field->sqltype = SQL_SHORT;
}


/**
 * This function populates a output parameter field with the data of a Ruby
 * value.
 *
 * @param  value  A reference to the Ruby value to be inserted into the field.
 * @param  field  A pointer to the XSQLVAR field that the value will go into.
 *
 */
void populateTextField(VALUE value, XSQLVAR *field)
{
   VALUE actual;
   char  *text  = NULL;
   short length = 0;

   if(TYPE(value) != T_STRING)
   {
      actual = value;
   }
   else
   {
      actual = rb_funcall(value, rb_intern("to_s"), 0);
   }

   text   = STR2CSTR(actual);
   length = strlen(text) > field->sqllen ? field->sqllen : strlen(text);

   if((field->sqltype & ~1) == SQL_TEXT)
   {
      memcpy(field->sqldata, text, length);
      field->sqltype = SQL_TEXT;
   }
   else
   {
      memcpy(field->sqldata, &length, sizeof(short));
      memcpy(&field->sqldata[sizeof(short)], text, length);
      field->sqltype = SQL_VARYING;
   }
	 field->sqllen = length;
}


/**
 * This method populates a date output field.
 *
 * @param  value  A reference to the value to be used to populate the field.
 * @param  field  A pointer to the output field to be populated.
 *
 */
void populateTimeField(VALUE value, XSQLVAR *field)
{
   struct tm datetime;
   VALUE     arguments = rb_ary_new();

   rb_ary_push(arguments, rb_str_new2("time"));
   value = rb_rescue(toDateTime, value, rescueConvert, arguments);
   if(TYPE(value) != T_ARRAY)
   {
      VALUE message = rb_funcall(value, rb_intern("message"), 0);
      rb_fireruby_raise(NULL, STR2CSTR(message));
   }
   datetime.tm_hour = FIX2INT(rb_ary_entry(value, 3));
   datetime.tm_min  = FIX2INT(rb_ary_entry(value, 4));
   datetime.tm_sec  = FIX2INT(rb_ary_entry(value, 5));
   isc_encode_sql_time(&datetime, (ISC_TIME *)field->sqldata);
   field->sqltype   = SQL_TYPE_TIME;
}


/**
 * This method populates a date output field.
 *
 * @param  value  A reference to the value to be used to populate the field.
 * @param  field  A pointer to the output field to be populated.
 *
 */
void populateTimestampField(VALUE value, XSQLVAR *field)
{
   struct tm datetime;
   VALUE     arguments = rb_ary_new();

   rb_ary_push(arguments, rb_str_new2("timestamp"));
   value = rb_rescue(toDateTime, value, rescueConvert, arguments);
   if(TYPE(value) != T_ARRAY)
   {
      VALUE message = rb_funcall(value, rb_intern("message"), 0);
      rb_fireruby_raise(NULL, STR2CSTR(message));
   }
   datetime.tm_year = FIX2INT(rb_ary_entry(value, 0));
   datetime.tm_mon  = FIX2INT(rb_ary_entry(value, 1));
   datetime.tm_mday = FIX2INT(rb_ary_entry(value, 2));
   datetime.tm_hour = FIX2INT(rb_ary_entry(value, 3));
   datetime.tm_min  = FIX2INT(rb_ary_entry(value, 4));
   datetime.tm_sec  = FIX2INT(rb_ary_entry(value, 5));
   isc_encode_timestamp(&datetime, (ISC_TIMESTAMP *)field->sqldata);
   field->sqltype   = SQL_TIMESTAMP;
}