advantage 0.1.2

data/ext/advantage/adscapidll.c

@@ -0,0 +1,164 @@
+/* ====================================================
+ *
+*       Copyright 2008-2012 iAnywhere Solutions, Inc.
+ *
+ *    Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ * ====================================================
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#if defined(_WIN32)
+#include <windows.h>
+#ifdef x64
+#define DEFAULT_LIBRARY_NAME "ace64.dll"
+#else
+#define DEFAULT_LIBRARY_NAME "ace32.dll"
+#endif
+#else
+#include <dlfcn.h>
+#define DEFAULT_LIBRARY_NAME "libace.so"
+#endif
+#include "ace.h"
+#include "adscapidll.h"
+
+static void *loadLibrary(const char *name)
+/*************************************/
+{
+   void *handle;
+#if defined(_WIN32)
+   handle = LoadLibrary(name);
+#else
+   handle = dlopen(name, RTLD_LAZY);
+#endif
+   return handle;
+}
+
+static void unloadLibrary(void *handle)
+/**********************************/
+{
+#if defined(_WIN32)
+   FreeLibrary(handle);
+#else
+   dlclose(handle);
+#endif
+}
+
+static void *findSymbol(void *dll_handle, const char *name)
+/**************************************************/
+{
+#if defined(_WIN32)
+   return GetProcAddress(dll_handle, name);
+#else
+   return dlsym(dll_handle, name);
+#endif
+}
+
+#define LookupSymbol(api, sym) \
+   api->sym = (sym##_func)findSymbol(api->dll_handle, #sym);
+
+#define LookupSymbolAndCheck(api, sym)                       \
+   api->sym = (sym##_func)findSymbol(api->dll_handle, #sym); \
+   if (api->sym == NULL)                                     \
+   {                                                         \
+      unloadLibrary(api->dll_handle);                        \
+      return 0;                                              \
+   }
+
+int ads_initialize_interface(AdvantageInterface *api, const char *path)
+/*******************************************************************************/
+{
+   char *env;
+   memset(api, 0, sizeof(*api));
+
+   if (path != NULL)
+   {
+      api->dll_handle = loadLibrary(path);
+      if (api->dll_handle != NULL)
+      {
+         goto loaded;
+      }
+   }
+   env = getenv("ADS_API_DLL");
+   if (env != NULL)
+   {
+      api->dll_handle = loadLibrary(env);
+      if (api->dll_handle != NULL)
+      {
+         goto loaded;
+      }
+   }
+   api->dll_handle = loadLibrary(DEFAULT_LIBRARY_NAME);
+   if (api->dll_handle != NULL)
+   {
+      goto loaded;
+   }
+   return 0;
+
+loaded:
+   LookupSymbolAndCheck(api, ads_init);
+   LookupSymbolAndCheck(api, ads_fini);
+   LookupSymbolAndCheck(api, ads_new_connection);
+   LookupSymbolAndCheck(api, ads_free_connection);
+   LookupSymbolAndCheck(api, ads_make_connection);
+   LookupSymbolAndCheck(api, ads_connect);
+   LookupSymbolAndCheck(api, ads_disconnect);
+   LookupSymbolAndCheck(api, ads_execute_immediate);
+   LookupSymbolAndCheck(api, ads_prepare);
+   LookupSymbolAndCheck(api, ads_free_stmt);
+   LookupSymbolAndCheck(api, ads_num_params);
+   LookupSymbolAndCheck(api, ads_describe_bind_param);
+   LookupSymbolAndCheck(api, ads_bind_param);
+   LookupSymbolAndCheck(api, ads_send_param_data);
+   LookupSymbolAndCheck(api, ads_reset);
+   LookupSymbolAndCheck(api, ads_get_bind_param_info);
+   LookupSymbolAndCheck(api, ads_execute);
+   LookupSymbolAndCheck(api, ads_execute_direct);
+   LookupSymbolAndCheck(api, ads_fetch_absolute);
+   LookupSymbolAndCheck(api, ads_fetch_next);
+   LookupSymbolAndCheck(api, ads_get_next_result);
+   LookupSymbolAndCheck(api, ads_affected_rows);
+   LookupSymbolAndCheck(api, ads_num_cols);
+   LookupSymbolAndCheck(api, ads_num_rows);
+   LookupSymbolAndCheck(api, ads_get_column);
+   LookupSymbolAndCheck(api, ads_get_data);
+   LookupSymbolAndCheck(api, ads_get_data_info);
+   LookupSymbolAndCheck(api, ads_get_column_info);
+   LookupSymbolAndCheck(api, ads_commit);
+   LookupSymbolAndCheck(api, ads_rollback);
+   LookupSymbolAndCheck(api, ads_client_version);
+   LookupSymbolAndCheck(api, ads_error);
+   LookupSymbolAndCheck(api, ads_sqlstate);
+   LookupSymbolAndCheck(api, ads_clear_error);
+   LookupSymbolAndCheck(api, ads_cancel);
+   LookupSymbolAndCheck(api, AdsBeginTransaction);
+
+   api->initialized = 1;
+   return 1;
+}
+#undef LookupSymbolAndCheck
+
+void ads_finalize_interface(AdvantageInterface *api)
+/***********************************************************/
+{
+   if (!api->initialized)
+   {
+      return;
+   }
+   unloadLibrary(api->dll_handle);
+   memset(api, 0, sizeof(*api));
+}

data/ext/advantage/adscapidll.h

@@ -0,0 +1,245 @@
+/* ====================================================
+ *
+*       Copyright 2008-2012 iAnywhere Solutions, Inc.
+ *
+ *    Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ * ====================================================
+ */
+
+#ifndef ADSCAPIDLL_H
+#define ADSCAPIDLL_H
+
+#include "ace.h"
+#include "dbcapi.h"
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif
+   typedef UNSIGNED32(WINAPI *ads_affected_rows_func)(ADSHANDLE hStatement);
+   typedef UNSIGNED32(WINAPI *AdsBeginTransaction_func)(ADSHANDLE hConnect);
+   typedef UNSIGNED32(WINAPI *ads_bind_param_func)(ADSHANDLE hStatement, UNSIGNED32 ulIndex, a_ads_bind_param *param);
+   typedef void(WINAPI *ads_cancel_func)(a_ads_connection *poConnect);
+   typedef void(WINAPI *ads_clear_error_func)(a_ads_connection *poConnect);
+   typedef UNSIGNED32(WINAPI *ads_client_version_func)(UNSIGNED8 *pucBuffer, UNSIGNED32 ulLength);
+   typedef UNSIGNED32(WINAPI *ads_commit_func)(a_ads_connection *poConnect);
+   typedef UNSIGNED32(WINAPI *ads_connect_func)(a_ads_connection *poConnect, UNSIGNED8 *pucConnectString);
+   typedef UNSIGNED32(WINAPI *ads_describe_bind_param_func)(ADSHANDLE ads_stmt, UNSIGNED32 index, a_ads_bind_param *params);
+   typedef UNSIGNED32(WINAPI *ads_disconnect_func)(a_ads_connection *poConnect);
+   typedef UNSIGNED32(WINAPI *ads_error_func)(a_ads_connection *poConnect, UNSIGNED8 *pucError, UNSIGNED32 ulLength);
+   typedef UNSIGNED32(WINAPI *ads_execute_func)(ADSHANDLE hStatement);
+   typedef ADSHANDLE(WINAPI *ads_execute_direct_func)(a_ads_connection *poConnect, UNSIGNED8 *pucSQL);
+   typedef UNSIGNED32(WINAPI *ads_execute_immediate_func)(a_ads_connection *poConnect, UNSIGNED8 *pucSQL);
+   typedef UNSIGNED32(WINAPI *ads_fetch_absolute_func)(ADSHANDLE hStatement, UNSIGNED32 ulRowNum);
+   typedef UNSIGNED32(WINAPI *ads_fetch_next_func)(ADSHANDLE hStatement);
+   typedef UNSIGNED32(WINAPI *ads_fini_func)();
+   typedef UNSIGNED32(WINAPI *ads_free_connection_func)(a_ads_connection *poConnect);
+   typedef UNSIGNED32(WINAPI *ads_free_stmt_func)(ADSHANDLE hStatement);
+   typedef UNSIGNED32(WINAPI *ads_get_bind_param_info_func)(ADSHANDLE hStatement, UNSIGNED32 ulIndex, a_ads_bind_param_info *info);
+   typedef UNSIGNED32(WINAPI *ads_get_column_func)(ADSHANDLE hStatement, UNSIGNED32 ulIndex, a_ads_data_value *buffer);
+   typedef UNSIGNED32(WINAPI *ads_get_column_info_func)(ADSHANDLE hStatement, UNSIGNED32 ulIndex, a_ads_column_info *buffer);
+   typedef UNSIGNED32(WINAPI *ads_get_data_func)(ADSHANDLE hStatement, UNSIGNED32 ulIndex, UNSIGNED32 ulOffset, void *buffer, UNSIGNED32 ulLength);
+   typedef UNSIGNED32(WINAPI *ads_get_data_info_func)(ADSHANDLE hStatement, UNSIGNED32 ulIndex, a_ads_data_info *buffer);
+   typedef UNSIGNED32(WINAPI *ads_get_next_result_func)(ADSHANDLE hStatement);
+   typedef UNSIGNED32(WINAPI *ads_init_func)(UNSIGNED8 *app_name, UNSIGNED32 api_version, UNSIGNED32 *max_version);
+   typedef a_ads_connection_ptr(WINAPI *ads_make_connection_func)(void *arg);
+   typedef a_ads_connection_ptr(WINAPI *ads_new_connection_func)();
+   typedef UNSIGNED32(WINAPI *ads_num_cols_func)(ADSHANDLE hStatement);
+   typedef UNSIGNED32(WINAPI *ads_num_params_func)(ADSHANDLE hStatement);
+   typedef UNSIGNED32(WINAPI *ads_num_rows_func)(ADSHANDLE hStatement);
+   typedef ADSHANDLE(WINAPI *ads_prepare_func)(a_ads_connection *poConnect, UNSIGNED8 *pucSQL, UNSIGNED8 ucIsUnicode);
+   typedef UNSIGNED32(WINAPI *ads_reset_func)(ADSHANDLE hStatement);
+   typedef UNSIGNED32(WINAPI *ads_rollback_func)(a_ads_connection *poConnect);
+   typedef UNSIGNED32(WINAPI *ads_send_param_data_func)(ADSHANDLE hStatement, UNSIGNED32 ulIndex, UNSIGNED8 *pucBuffer, UNSIGNED32 ulLength);
+   typedef UNSIGNED32(WINAPI *ads_sqlstate_func)(a_ads_connection *poConnect, UNSIGNED8 *pucBuffer, UNSIGNED32 ulLength);
+
+#if defined(__cplusplus)
+}
+#endif
+
+/// @internal
+#define function(x) x##_func x
+
+typedef struct AdvantageInterface
+{
+   /** DLL handle.
+    */
+   void *dll_handle;
+
+   /** Flag to know if initialized or not.
+    */
+   int initialized;
+
+   /** Pointer to ::ads_init() function.
+    */
+   function(ads_init);
+
+   /** Pointer to ::ads_fini() function.
+    */
+   function(ads_fini);
+
+   /** Pointer to ::ads_new_connection() function.
+    */
+   function(ads_new_connection);
+
+   /** Pointer to ::ads_free_connection() function.
+    */
+   function(ads_free_connection);
+
+   /** Pointer to ::ads_make_connection() function.
+    */
+   function(ads_make_connection);
+
+   /** Pointer to ::ads_connect() function.
+    */
+   function(ads_connect);
+
+   /** Pointer to ::ads_disconnect() function.
+    */
+   function(ads_disconnect);
+
+   /** Pointer to ::ads_execute_immediate() function.
+    */
+   function(ads_execute_immediate);
+
+   /** Pointer to ::ads_prepare() function.
+    */
+   function(ads_prepare);
+
+   /** Pointer to ::ads_free_stmt() function.
+    */
+   function(ads_free_stmt);
+
+   /** Pointer to ::ads_num_params() function.
+    */
+   function(ads_num_params);
+
+   /** Pointer to ::ads_describe_bind_param() function.
+    */
+   function(ads_describe_bind_param);
+
+   /** Pointer to ::ads_bind_param() function.
+    */
+   function(ads_bind_param);
+
+   /** Pointer to ::ads_send_param_data() function.
+    */
+   function(ads_send_param_data);
+
+   /** Pointer to ::ads_reset() function.
+    */
+   function(ads_reset);
+
+   /** Pointer to ::ads_get_bind_param_info() function.
+    */
+   function(ads_get_bind_param_info);
+
+   /** Pointer to ::ads_execute() function.
+    */
+   function(ads_execute);
+
+   /** Pointer to ::ads_execute_direct() function.
+    */
+   function(ads_execute_direct);
+
+   /** Pointer to ::ads_fetch_absolute() function.
+    */
+   function(ads_fetch_absolute);
+
+   /** Pointer to ::ads_fetch_next() function.
+    */
+   function(ads_fetch_next);
+
+   /** Pointer to ::ads_get_next_result() function.
+    */
+   function(ads_get_next_result);
+
+   /** Pointer to ::ads_affected_rows() function.
+    */
+   function(ads_affected_rows);
+
+   /** Pointer to ::ads_num_cols() function.
+    */
+   function(ads_num_cols);
+
+   /** Pointer to ::ads_num_rows() function.
+    */
+   function(ads_num_rows);
+
+   /** Pointer to ::ads_get_column() function.
+    */
+   function(ads_get_column);
+
+   /** Pointer to ::ads_get_data() function.
+    */
+   function(ads_get_data);
+
+   /** Pointer to ::ads_get_data_info() function.
+    */
+   function(ads_get_data_info);
+
+   /** Pointer to ::ads_get_column_info() function.
+    */
+   function(ads_get_column_info);
+
+   /** Pointer to ::ads_commit() function.
+    */
+   function(ads_commit);
+
+   /** Pointer to ::ads_rollback() function.
+    */
+   function(ads_rollback);
+
+   /** Pointer to ::ads_client_version() function.
+    */
+   function(ads_client_version);
+
+   /** Pointer to ::ads_error() function.
+    */
+   function(ads_error);
+
+   /** Pointer to ::ads_sqlstate() function.
+    */
+   function(ads_sqlstate);
+
+   /** Pointer to ::ads_clear_error() function.
+    */
+   function(ads_clear_error);
+
+   /** Pointer to ::ads_cancel() function.
+    */
+   function(ads_cancel);
+
+   /** Pointer to ::AdsBeginTransaction() function.
+    */
+   function(AdsBeginTransaction);
+
+} AdvantageInterface;
+#undef function
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif
+
+   int ads_initialize_interface(AdvantageInterface *api, const char *optional_path_to_dll);
+
+   void ads_finalize_interface(AdvantageInterface *api);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

data/ext/advantage/advantage.c

@@ -0,0 +1,1836 @@
+/*====================================================
+*
+*   Copyright 2008-2010 iAnywhere Solutions, Inc.
+*
+* Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+*
+*====================================================*/
+#include "ruby.h"
+#include "adscapidll.h"
+
+const char *VERSION = "0.1.2";
+
+typedef struct imp_drh_st
+{
+   AdvantageInterface api;
+   void *adscapi_context;
+} imp_drh_st;
+
+// Defining the Ruby Modules
+static VALUE mAdvantage;
+static VALUE mAPI;
+static VALUE cAdvantageInterface;
+
+// Defining binder for DBCAPI types
+static VALUE cA_ads_connection;
+static VALUE cA_ads_data_value;
+static VALUE cA_ads_bind_param;
+static VALUE cA_ads_bind_param_info;
+
+// This function is called when the module is first loaded by ruby.
+// The name of this function MUST match be Init_<modulename>.
+void Init_advantage();
+
+// Wrapper functions for the DBICAPI functions
+
+static VALUE
+static_API_ads_initialize_interface(VALUE module, VALUE imp_drh);
+
+static VALUE
+static_API_ads_finalize_interface(VALUE module, VALUE imp_drh);
+
+static VALUE
+    static_AdvantageInterface_alloc(VALUE class);
+
+static VALUE
+    static_AdvantageInterface_ads_init(VALUE class);
+
+static VALUE
+    static_AdvantageInterface_ads_new_connection(VALUE class);
+
+static VALUE
+static_AdvantageInterface_ads_client_version(VALUE imp_drh);
+
+static VALUE
+static_AdvantageInterface_ads_connect(VALUE imp_drh, VALUE ads_conn, VALUE str);
+
+static VALUE
+static_AdvantageInterface_ads_disconnect(VALUE imp_drh, VALUE ads_conn);
+
+static VALUE
+static_AdvantageInterface_ads_free_connection(VALUE imp_drh, VALUE ads_conn);
+
+static VALUE
+static_AdvantageInterface_ads_fini(VALUE imp_drh);
+
+static VALUE
+static_AdvantageInterface_ads_error(VALUE imp_drh, VALUE ads_conn);
+
+static VALUE
+static_AdvantageInterface_ads_execute_immediate(VALUE imp_drh, VALUE ads_conn, VALUE sql);
+
+static VALUE
+static_AdvantageInterface_ads_execute_direct(VALUE imp_drh, VALUE ads_conn, VALUE sql);
+
+static VALUE
+static_AdvantageInterface_ads_num_cols(VALUE imp_drh, VALUE ads_stmt);
+
+static VALUE
+static_AdvantageInterface_ads_num_rows(VALUE imp_drh, VALUE ads_stmt);
+
+static VALUE
+static_AdvantageInterface_ads_get_column(VALUE imp_drh, VALUE ads_stmt, VALUE col_num);
+
+static VALUE
+static_AdvantageInterface_ads_fetch_next(VALUE imp_drh, VALUE ads_stmt);
+
+static VALUE
+static_AdvantageInterface_ads_get_column_info(VALUE imp_drh, VALUE ads_stmt, VALUE col_num);
+
+static VALUE
+static_AdvantageInterface_AdsBeginTransaction(VALUE imp_drh, VALUE ads_conn);
+
+static VALUE
+static_AdvantageInterface_ads_commit(VALUE imp_drh, VALUE ads_conn);
+
+static VALUE
+static_AdvantageInterface_ads_rollback(VALUE imp_drh, VALUE ads_conn);
+
+static VALUE
+static_AdvantageInterface_ads_prepare(VALUE imp_drh, VALUE ads_conn, VALUE sql);
+
+static VALUE
+static_AdvantageInterface_ads_free_stmt(VALUE imp_drh, VALUE ads_stmt);
+
+static VALUE
+static_AdvantageInterface_ads_reset(VALUE imp_drh, VALUE ads_stmt);
+
+static VALUE
+static_AdvantageInterface_ads_execute(VALUE imp_drh, VALUE ads_stmt);
+
+static VALUE
+static_AdvantageInterface_ads_affected_rows(VALUE imp_drh, VALUE ads_stmt);
+
+static VALUE
+static_AdvantageInterface_ads_describe_bind_param(VALUE imp_drh, VALUE ads_stmt, VALUE index);
+
+/*
+ * C to Ruby Data conversion function to convert DBCAPI column type into the correct Ruby type
+ */
+static VALUE C2RB(a_ads_data_value *value)
+{
+   VALUE tdata;
+
+   if (value == NULL || value->buffer == NULL || value->is_null == NULL)
+   {
+      rb_raise(rb_eTypeError, "Operation not allowed. Has no value.");
+   }
+   else if (*value->is_null)
+   {
+      tdata = Qnil;
+   }
+   else
+   {
+      switch (value->type)
+      {
+      case A_BINARY:
+         tdata = rb_str_new((char *)value->buffer, *value->length);
+         break;
+      case A_STRING:
+      case A_DATE:
+      case A_TIME:
+      case A_TIMESTAMP:
+      case A_NCHAR:
+      case A_DECIMAL:
+         tdata = rb_str_new((char *)value->buffer, *value->length);
+         break;
+      case A_DOUBLE:
+         tdata = rb_float_new(*(double *)value->buffer);
+         break;
+      case A_VAL64:
+         tdata = LL2NUM(*(LONG_LONG *)value->buffer);
+         break;
+      case A_UVAL64:
+         tdata = ULL2NUM(*(unsigned LONG_LONG *)value->buffer);
+         break;
+      case A_VAL32:
+         tdata = INT2FIX(*(int *)value->buffer);
+         break;
+      case A_UVAL32:
+         tdata = UINT2NUM(*(unsigned int *)value->buffer);
+         break;
+      case A_VAL16:
+         tdata = INT2FIX(*(short *)value->buffer);
+         break;
+      case A_UVAL16:
+         tdata = UINT2NUM(*(unsigned short *)value->buffer);
+         break;
+      case A_VAL8:
+         tdata = CHR2FIX(*(unsigned char *)value->buffer);
+         break;
+      case A_UVAL8:
+         tdata = CHR2FIX(*(unsigned char *)value->buffer);
+         break;
+      default:
+         rb_raise(rb_eTypeError, "Invalid Data Type");
+         tdata = Qnil;
+         break;
+      }
+   }
+
+   return tdata;
+}
+
+/*
+ * call-seq:
+ *    ads_initialize_interface( VALUE imp_drh ) -> int result
+ *
+ *  Initializes the AdvantageInterface object and loads the DLL dynamically.
+ *
+ *  This function attempts to load the Advantage C API DLL dynamically and
+ *  looks up all the entry points of the DLL.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An API structure to initialize.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>result</tt>: <tt>1</tt> on successful initialization, <tt>0</tt> on failure.
+ *
+ */
+static VALUE
+static_API_ads_initialize_interface(VALUE module, VALUE imp_drh)
+{
+   imp_drh_st *s_imp_drh;
+   int result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+
+   result = ads_initialize_interface(&(s_imp_drh->api), NULL);
+
+   return (INT2FIX(result));
+}
+
+/*
+ * call-seq:
+ *    ads_finalize_interface( VALUE imp_drh ) -> nil
+ *
+ *  Finalize and free resources associated with the Advantage C API DLL.
+ *
+ *  This function will unload the library and uninitialize the supplied
+ *  AdvantageInterface structure.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt>.
+ *
+ */
+static VALUE
+static_API_ads_finalize_interface(VALUE module, VALUE imp_drh)
+{
+   imp_drh_st *s_imp_drh;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+
+   ads_finalize_interface(&(s_imp_drh->api));
+
+   free(&(s_imp_drh->api));
+
+   return (Qnil);
+}
+
+static VALUE
+    static_AdvantageInterface_alloc(VALUE class)
+{
+   imp_drh_st *imp_drh = NULL;
+   VALUE tdata;
+
+   imp_drh = malloc(sizeof(imp_drh_st));
+   memset(imp_drh, 0, sizeof(imp_drh_st));
+
+   tdata = Data_Wrap_Struct(class, 0, 0, imp_drh);
+   return tdata;
+}
+
+/*
+ * call-seq:
+ *   ads_init( VALUE imp_drh ) -> [VALUE result, VALUE version]
+ *
+ *  Initializes the interface.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on success, <tt>0</tt> on failure.
+ *  - <tt>VALUE version</tt>: The maximum API version that is supported.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_init(VALUE imp_drh)
+{
+   imp_drh_st *s_imp_drh;
+   UNSIGNED32 result;
+   UNSIGNED32 s_version_available;
+   VALUE multi_result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+
+   multi_result = rb_ary_new();
+
+   if (&(s_imp_drh->api) == NULL)
+   {
+      rb_ary_push(multi_result, INT2FIX(0));
+      rb_ary_push(multi_result, Qnil);
+   }
+   else
+   {
+      result = s_imp_drh->api.ads_init((UNSIGNED8 *)"RUBY", 1, &s_version_available);
+      rb_ary_push(multi_result, INT2FIX(result));
+      rb_ary_push(multi_result, INT2FIX(s_version_available));
+   }
+
+   return (multi_result);
+}
+
+/*
+ * call-seq:
+ *   ads_new_connection( VALUE imp_drh ) -> VALUE connection
+ *
+ *  Creates a connection object.
+ *
+ *  An API connection object needs to be created before a database connection
+ *  is established. Errors can be retrieved from the connection object. Only
+ *  one request can be processed on a connection at a time.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE connection</tt>: A connection object.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_new_connection(VALUE imp_drh)
+{
+   imp_drh_st *s_imp_drh;
+   a_ads_connection *ptr;
+   VALUE tdata;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   ptr = s_imp_drh->api.ads_new_connection();
+
+   tdata = Data_Wrap_Struct(cA_ads_connection, 0, 0, ptr);
+
+   return (tdata);
+}
+
+/*
+ * call-seq:
+ *   ads_client_version( VALUE imp_drh ) -> [VALUE verstr]
+ *
+ *  Retrieves the client version as a string.
+ *
+ *  This function can be used to retrieve the client version.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> --  an initialized API structure to finalize
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE verstr</tt>: The client version string.
+ *
+ */
+
+static VALUE
+static_AdvantageInterface_ads_client_version(VALUE imp_drh)
+{
+   imp_drh_st *s_imp_drh;
+   char s_buffer[255];
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+
+   s_imp_drh->api.ads_client_version((UNSIGNED8 *)s_buffer, 255);
+
+   return (rb_str_new2(s_buffer));
+}
+
+/*
+ * call-seq:
+ *   ads_connect( VALUE imp_drh, VALUE ads_conn, VALUE str ) -> VALUE result
+ *
+ *  Creates a connection object.
+ *
+ *  An API connection object needs to be created before a database connection
+ *  is established. Errors can be retrieved from the connection object. Only
+ *  one request can be processed on a connection at a time.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_conn</tt> -- A connection object that was created by ads_new_connection(  ).
+ *  - <tt>VALUE str</tt> -- A connection string.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on success, <tt>0</tt> on failure.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_connect(VALUE imp_drh, VALUE ads_conn, VALUE str)
+{
+   imp_drh_st *s_imp_drh;
+   a_ads_connection *s_ads_conn;
+   char *s_str;
+   UNSIGNED32 result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   Data_Get_Struct(ads_conn, a_ads_connection, s_ads_conn);
+
+   s_str = StringValueCStr(str);
+
+   result = s_imp_drh->api.ads_connect(s_ads_conn, (UNSIGNED8 *)s_str);
+
+   return (INT2FIX(result));
+}
+
+/*
+ * call-seq:
+ *   ads_disconnect( VALUE imp_drh, VALUE ads_conn ) -> nil
+ *
+ *  Disconnect an already established connection.
+ *
+ *  This function disconnects the connection. Any
+ *  uncommitted transactions will be rolled back.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_conn</tt> -- A connection object that was connected by ads_connect(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt>.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_disconnect(VALUE imp_drh, VALUE ads_conn)
+{
+   imp_drh_st *s_imp_drh;
+   a_ads_connection *s_ads_conn;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   Data_Get_Struct(ads_conn, a_ads_connection, s_ads_conn);
+
+   s_imp_drh->api.ads_disconnect(s_ads_conn);
+
+   return (Qnil);
+}
+
+/*
+ * call-seq:
+ *   ads_free_connection( VALUE imp_drh, VALUE ads_conn ) -> nil
+ *
+ *  Frees the resources associated with a connection object.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_conn</tt> -- A connection object that was disconnected by ads_disconnect(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt>.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_free_connection(VALUE imp_drh, VALUE ads_conn)
+{
+   imp_drh_st *s_imp_drh;
+   a_ads_connection *s_ads_conn;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   Data_Get_Struct(ads_conn, a_ads_connection, s_ads_conn);
+
+   s_imp_drh->api.ads_free_connection(s_ads_conn);
+
+   return (Qnil);
+}
+
+/*
+ * call-seq:
+ *   ads_fini( VALUE imp_drh ) -> nil
+ *
+ *  Finalizes the interface.
+ *
+ *  Thus function frees any resources allocated by the API.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt>.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_fini(VALUE imp_drh)
+{
+   imp_drh_st *s_imp_drh;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+
+   s_imp_drh->api.ads_fini();
+
+   return (Qnil);
+}
+
+/*
+ * call-seq:
+ *   ads_error( VALUE imp_drh, VALUE ads_conn ) -> [VALUE result, VALUE errstr]
+ *
+ *  Retrieves the last error code and message.
+ *
+ *  This function can be used to retrieve the last error code and message
+ *  stored in the connection object.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_conn</tt> -- A connection object that was connected by ads_connect(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: The last error code. Positive values are warnings, negative values are errors, and <tt>0</tt> is success.
+ *  - <tt>VALUE errstr</tt>: The error message corresponding to the error code.
+ *
+ */
+
+static VALUE
+static_AdvantageInterface_ads_error(VALUE imp_drh, VALUE ads_conn)
+{
+   imp_drh_st *s_imp_drh;
+   a_ads_connection *s_ads_conn;
+   char s_buffer[255];
+   UNSIGNED32 result;
+   VALUE multi_result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   Data_Get_Struct(ads_conn, a_ads_connection, s_ads_conn);
+
+   result = s_imp_drh->api.ads_error(s_ads_conn, (UNSIGNED8 *)s_buffer, 255);
+
+   multi_result = rb_ary_new();
+
+   rb_ary_push(multi_result, INT2FIX(result));
+   rb_ary_push(multi_result, rb_str_new2(s_buffer));
+
+   return (multi_result);
+}
+
+/*
+ * call-seq:
+ *   ads_execute_immediate( VALUE imp_drh, VALUE ads_conn, VALUE sql ) -> VALUE result
+ *
+ *  Executes a SQL statement immediately without returning a result set.
+ *
+ *  This function executes the specified SQL statement immediately. It is
+ *  useful for SQL statements that do not return a result set.
+ *
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_conn</tt> -- A connection object that was connected by ads_connect(  ).
+ *  - <tt>VALUE sql</tt> -- A SQL query string.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on success, <tt>0</tt> on failure.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_execute_immediate(VALUE imp_drh, VALUE ads_conn, VALUE sql)
+{
+   imp_drh_st *s_imp_drh;
+   a_ads_connection *s_ads_conn;
+   char *s_sql;
+   UNSIGNED32 result;
+
+   s_sql = StringValueCStr(sql);
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   Data_Get_Struct(ads_conn, a_ads_connection, s_ads_conn);
+
+   result = s_imp_drh->api.ads_execute_immediate(s_ads_conn, (UNSIGNED8 *)s_sql);
+
+   return (INT2FIX(result));
+}
+
+/*
+ * call-seq:
+ *   ads_execute_direct( VALUE imp_drh, VALUE ads_conn, VALUE sql ) -> VALUE resultset
+ *
+ *  Executes a SQL statement and possibly returns a result set.
+ *
+ *  This function executes the SQL statement specified by the string argument.
+ *  This function is suitable if you want to prepare and then execute a
+ *  statement, and can be used instead of calling ads_prepare(  ) followed
+ *  by ads_execute(  ).
+ *
+ *  This function cannot be used for executing a SQL statement with
+ *  parameters.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_conn</tt> -- A connection object that was connected by ads_connect(  ).
+ *  - <tt>VALUE sql</tt> -- A SQL query string.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: A query result set if successful, nil if failed.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_execute_direct(VALUE imp_drh, VALUE ads_conn, VALUE sql)
+{
+   imp_drh_st *s_imp_drh;
+   a_ads_connection *s_ads_conn;
+   ADSHANDLE resultset = 0;
+   char *s_sql;
+   VALUE tdata;
+
+   s_sql = StringValueCStr(sql);
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   Data_Get_Struct(ads_conn, a_ads_connection, s_ads_conn);
+
+   resultset = s_imp_drh->api.ads_execute_direct(s_ads_conn, (UNSIGNED8 *)s_sql);
+
+   if (resultset)
+   {
+      tdata = INT2FIX(resultset);
+   }
+   else
+   {
+      tdata = Qnil;
+   }
+
+   return (tdata);
+}
+
+/*
+ * call-seq:
+ *   ads_num_cols( VALUE imp_drh, VALUE ads_stmt ) -> VALUE num_cols
+ *
+ *  Returns number of columns in the result set.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_stmt</tt> -- A statement object that was created by ads_prepare(  ) or ads_execute_direct(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE num_cols</tt>: The number of columns in the result set or <tt>-1</tt> on a failure.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_num_cols(VALUE imp_drh, VALUE ads_stmt)
+{
+   imp_drh_st *s_imp_drh;
+   ADSHANDLE s_stmt;
+   UNSIGNED32 result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   //Data_Get_Struct( ads_stmt, ADSHANDLE, s_stmt );
+   s_stmt = NUM2ULONG(ads_stmt);
+
+   result = s_imp_drh->api.ads_num_cols(s_stmt);
+
+   return (INT2NUM(result));
+}
+
+/*
+ * call-seq:
+ *   ads_num_rows( VALUE imp_drh, VALUE ads_stmt ) -> VALUE num_rows
+ *
+ *  Returns number of rows in the result set.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> --  An initialized API structure to finalize.
+ *  - <tt>VALUE ads_stmt</tt> -- A statement object that was created by ads_prepare(  ) or ads_execute_direct(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE num_rows</tt>: The number of rows in the result set or <tt>-1</tt> on a failure.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_num_rows(VALUE imp_drh, VALUE ads_stmt)
+{
+   imp_drh_st *s_imp_drh;
+   ADSHANDLE s_stmt;
+   UNSIGNED32 result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   //Data_Get_Struct( ads_stmt, ADSHANDLE, s_stmt );
+   s_stmt = NUM2ULONG(ads_stmt);
+
+   result = s_imp_drh->api.ads_num_rows(s_stmt);
+
+   return (INT2FIX(result));
+}
+
+/*
+ * call-seq:
+ *   ads_get_column( VALUE imp_drh, VALUE ads_stmt, VALUE col_num ) -> [VALUE result, VALUE column_value]
+ *
+ *  Retrieves the data fetched for the specified column.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_stmt</tt> -- A statement object that was created by ads_prepare(  ) or ads_execute_direct(  ).
+ *  - <tt>VALUE col_num</tt> -- The number of the column to be retrieved. A column number is between 0 and ads_num_cols(  ) - 1.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE column_value</tt>: The value of the column. nil is returned if the value was NULL.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_get_column(VALUE imp_drh, VALUE ads_stmt, VALUE col_num)
+{
+   imp_drh_st *s_imp_drh;
+   ADSHANDLE s_stmt;
+   UNSIGNED32 s_col_num;
+   a_ads_data_value value;
+   UNSIGNED32 result;
+   VALUE multi_result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   //Data_Get_Struct( ads_stmt, ADSHANDLE, s_stmt );
+   s_stmt = NUM2ULONG(ads_stmt);
+   s_col_num = NUM2INT(col_num);
+
+   result = s_imp_drh->api.ads_get_column(s_stmt, s_col_num, &value);
+
+   multi_result = rb_ary_new();
+   rb_ary_push(multi_result, INT2FIX(result));
+
+   if (!result)
+   {
+      rb_ary_push(multi_result, Qnil);
+   }
+   else
+   {
+      if (*value.is_null)
+      {
+         rb_ary_push(multi_result, Qnil);
+      }
+      else
+      {
+         rb_ary_push(multi_result, C2RB(&value));
+      }
+   }
+
+   return (multi_result);
+}
+
+/*
+ * call-seq:
+ *   ads_fetch_next( VALUE imp_drh, VALUE ads_stmt ) -> VALUE result
+ *
+ *  Fetches the next row from the result set.
+ *
+ *  This function fetches the next row from the result set. When the result
+ *  object is first created, the current row pointer is set to point before
+ *  the first row ( that is, row 0 ).
+ *  This function advances the row pointer first and then fetches the data
+ *  at the new row.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_stmt</tt> -- A statement object that was created by ads_prepare(  ) or ads_execute_direct(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on successful fetch, <tt>0</tt> otherwise.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_fetch_next(VALUE imp_drh, VALUE ads_stmt)
+{
+   imp_drh_st *s_imp_drh;
+   ADSHANDLE s_stmt;
+   UNSIGNED32 result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   //Data_Get_Struct( ads_stmt, ADSHANDLE, s_stmt );
+   s_stmt = NUM2ULONG(ads_stmt);
+
+   result = s_imp_drh->api.ads_fetch_next(s_stmt);
+
+   return (INT2FIX(result));
+}
+
+/*
+ * call-seq:
+ *   ads_get_column_info( VALUE imp_drh, VALUE ads_stmt, VALUE col_num ) -> [VALUE result, VALUE col_num, VALUE name, VALUE type, VALUE max_size]
+ *
+ *  Fetches the next row from the result set.
+ *
+ *  This function fetches the next row from the result set. When the result
+ *  object is first created, the current row pointer is set to point before
+ *  the first row ( that is, row 0 ).
+ *  This function advances the row pointer first and then fetches the data
+ *  at the new row.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_stmt</tt> -- A statement object that was created by ads_prepare(  ) or ads_execute_direct(  ).
+ *  - <tt>VALUE col_num</tt> -- The number of the column to be retrieved. A column number is between 0 and ads_num_cols(  ) - 1.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on success. Returns <tt>0</tt> if the column index is out of range, or if the statement does not return a result set.
+ *  - <tt>VALUE col_num</tt>: The number of the column retrieved.
+ *  - <tt>VALUE name</tt>: The name of the column.
+ *  - <tt>VALUE type</tt>: The type of the column data.
+ *  - <tt>VALUE native_type</tt>: The Advantage native type of the column data.
+ *  - <tt>VALUE precision</tt>: The precision of the column.
+ *  - <tt>VALUE scale</tt>: The scale of the column.
+ *  - <tt>VALUE max_size</tt>: The maximum size a data value in this column can take.
+ *  - <tt>VALUE nullable</tt>: The nullability of the column.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_get_column_info(VALUE imp_drh, VALUE ads_stmt, VALUE col_num)
+{
+   imp_drh_st *s_imp_drh;
+   ADSHANDLE s_stmt;
+   UNSIGNED32 s_col_num;
+   a_ads_column_info info;
+   UNSIGNED32 result;
+   VALUE multi_result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   //Data_Get_Struct( ads_stmt, ADSHANDLE, s_stmt );
+   s_stmt = NUM2ULONG(ads_stmt);
+   s_col_num = NUM2INT(col_num);
+
+   result = s_imp_drh->api.ads_get_column_info(s_stmt, s_col_num, &info);
+
+   multi_result = rb_ary_new();
+   rb_ary_push(multi_result, INT2FIX(result));
+   rb_ary_push(multi_result, col_num);
+   rb_ary_push(multi_result, rb_str_new2((char *)info.name));
+   rb_ary_push(multi_result, INT2FIX(info.type));
+   rb_ary_push(multi_result, INT2FIX(info.native_type));
+   rb_ary_push(multi_result, INT2FIX(info.precision));
+   rb_ary_push(multi_result, INT2FIX(info.scale));
+   rb_ary_push(multi_result, INT2FIX(info.max_size));
+   rb_ary_push(multi_result, INT2FIX(info.nullable));
+
+   return (multi_result);
+}
+
+/*
+ * call-seq:
+ *   AdsBeginTransaction( VALUE imp_drh, VALUE ads_conn ) -> VALUE result
+ *
+ *  Starts a transaction on the current connection.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_conn</tt> -- A connection object that was connected by ads_connect(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on successful begining a transaction, <tt>0</tt> otherwise.
+ *
+ */
+static VALUE
+static_AdvantageInterface_AdsBeginTransaction(VALUE imp_drh, VALUE ads_conn)
+{
+   imp_drh_st *s_imp_drh;
+   a_ads_connection *s_ads_conn;
+   UNSIGNED32 result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   Data_Get_Struct(ads_conn, a_ads_connection, s_ads_conn);
+
+   result = s_imp_drh->api.AdsBeginTransaction(s_ads_conn->hConnect);
+   if (result == 0)
+      return (INT2FIX(1));
+   else
+      return (INT2FIX(0));
+}
+
+/*
+ * call-seq:
+ *   ads_commit( VALUE imp_drh, VALUE ads_conn ) -> VALUE result
+ *
+ *  Commits the current transaction.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_conn</tt> -- A connection object that was connected by ads_connect(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on successful commit, <tt>0</tt> otherwise.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_commit(VALUE imp_drh, VALUE ads_conn)
+{
+   imp_drh_st *s_imp_drh;
+   a_ads_connection *s_ads_conn;
+   UNSIGNED32 result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   Data_Get_Struct(ads_conn, a_ads_connection, s_ads_conn);
+
+   result = s_imp_drh->api.ads_commit(s_ads_conn);
+
+   return (INT2FIX(result));
+}
+
+/*
+ * call-seq:
+ *   ads_rollback( VALUE imp_drh, VALUE ads_conn ) -> VALUE result
+ *
+ *  Rolls back the current transaction.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_conn</tt> -- A connection object that was connected by ads_connect(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on successful rollback, <tt>0</tt> otherwise.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_rollback(VALUE imp_drh, VALUE ads_conn)
+{
+   imp_drh_st *s_imp_drh;
+   a_ads_connection *s_ads_conn;
+   UNSIGNED32 result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   Data_Get_Struct(ads_conn, a_ads_connection, s_ads_conn);
+
+   result = s_imp_drh->api.ads_rollback(s_ads_conn);
+
+   return (INT2FIX(result));
+}
+
+/*
+ * call-seq:
+ *   ads_prepare( VALUE imp_drh, VALUE ads_conn, VALUE sql ) -> VALUE stmt
+ *
+ *  Prepares a SQL statement.
+ *
+ *  This function prepares the supplied SQL string. Execution does not
+ *  happen until ads_execute(  ) is called. The returned statement object
+ *  should be freed using ads_free_stmt(  ).
+ *
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_conn</tt> -- A connection object that was connected by ads_connect(  ).
+ *  - <tt>VALUE sql</tt> -- SQL query to prepare.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE stmt</tt>: A statement object, or nil on failure. The statement object can be used by ads_execute(  ) to execute the statement.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_prepare(VALUE imp_drh, VALUE ads_conn, VALUE sql)
+{
+   imp_drh_st *s_imp_drh;
+   a_ads_connection *s_ads_conn;
+   ADSHANDLE s_stmt = 0;
+   char *s_sql;
+   VALUE tdata;
+
+   s_sql = StringValueCStr(sql);
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   Data_Get_Struct(ads_conn, a_ads_connection, s_ads_conn);
+
+   //EJS Passing FALSE for isUnicode
+   s_stmt = s_imp_drh->api.ads_prepare(s_ads_conn, (UNSIGNED8 *)s_sql, '\0');
+
+   if (s_stmt)
+   {
+      tdata = INT2FIX(s_stmt);
+   }
+   else
+   {
+      tdata = Qnil;
+   }
+
+   return (tdata);
+}
+
+/*
+ * call-seq:
+ *   ads_free_stmt( VALUE imp_drh, VALUE ads_stmt ) -> nil
+ *
+ *  Frees resources associated with a prepared statement object.
+ *
+ *  This function frees the resources associated with a prepared statement
+ *  object.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_stmt</tt> -- A statement object that was created by ads_prepare(  ) or ads_execute_direct(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt>.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_free_stmt(VALUE imp_drh, VALUE ads_stmt)
+{
+   imp_drh_st *s_imp_drh;
+   ADSHANDLE s_stmt;
+   int i;
+   int number_of_params = 0;
+   a_ads_bind_param_info bind_info;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   //Data_Get_Struct( ads_stmt, ADSHANDLE, s_ads_stmt );
+   s_stmt = NUM2ULONG(ads_stmt);
+
+   number_of_params = s_imp_drh->api.ads_num_params(s_stmt);
+
+   for (i = 0; i < number_of_params; i++)
+   {
+      if (s_imp_drh->api.ads_get_bind_param_info(s_stmt, i, &bind_info))
+      {
+         // We don't free bind_info.name as it's not allocated
+         // if ( bind_info.name ) {free ( bind_info.name );}
+
+         if (bind_info.input_value.is_null)
+         {
+            free(bind_info.input_value.is_null);
+         }
+         if (bind_info.input_value.length)
+         {
+            free(bind_info.input_value.length);
+         }
+         if (bind_info.input_value.buffer)
+         {
+            free(bind_info.input_value.buffer);
+         }
+
+         if (bind_info.output_value.is_null)
+         {
+            free(bind_info.output_value.is_null);
+         }
+         if (bind_info.output_value.length)
+         {
+            free(bind_info.output_value.length);
+         }
+         if (bind_info.output_value.buffer)
+         {
+            free(bind_info.output_value.buffer);
+         }
+      }
+   }
+
+   s_imp_drh->api.ads_free_stmt(s_stmt);
+
+   return (Qnil);
+}
+
+/*
+ * call-seq:
+ *   ads_reset( VALUE imp_drh, VALUE ads_stmt ) -> VALUE result
+ *
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_stmt</tt> -- A statement object that was created by ads_prepare(  ) or ads_execute_direct(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on successful execution, <tt>0</tt> otherwise.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_reset(VALUE imp_drh, VALUE ads_stmt)
+{
+   imp_drh_st *s_imp_drh;
+   ADSHANDLE s_stmt;
+   UNSIGNED32 result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   //Data_Get_Struct( ads_stmt, ADSHANDLE, s_ads_stmt );
+   s_stmt = NUM2ULONG(ads_stmt);
+
+   result = s_imp_drh->api.ads_reset(s_stmt);
+
+   return (INT2FIX(result));
+}
+
+/*
+ * call-seq:
+ *   ads_execute( VALUE imp_drh, VALUE ads_stmt ) -> VALUE result
+ *
+ *  Executes a prepared statement.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_stmt</tt> -- A statement object that was created by ads_prepare(  ) or ads_execute_direct(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on successful execution, <tt>0</tt> otherwise.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_execute(VALUE imp_drh, VALUE ads_stmt)
+{
+   imp_drh_st *s_imp_drh;
+   ADSHANDLE s_stmt;
+   UNSIGNED32 result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   //Data_Get_Struct( ads_stmt, ADSHANDLE, s_ads_stmt );
+   s_stmt = NUM2ULONG(ads_stmt);
+
+   //printf(  "CEXT s_ads_stmt: %d \n", s_stmt );
+   result = s_imp_drh->api.ads_execute(s_stmt);
+   /*if (  result != AE_SUCCESS  )
+      return ( 0 );
+   else
+      return ( 1 );*/
+   return (INT2FIX(result));
+}
+
+/*
+ * call-seq:
+ *   ads_affected_rows( VALUE imp_drh, VALUE ads_stmt ) -> VALUE result
+ *
+ *  Returns the number of rows affected by execution of the prepared
+ *  statement.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_stmt</tt> -- A statement that was prepared and executed successfully with no result set returned.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: The number of rows affected or <tt>-1</tt> on failure.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_affected_rows(VALUE imp_drh, VALUE ads_stmt)
+{
+   imp_drh_st *s_imp_drh;
+   ADSHANDLE s_stmt;
+   UNSIGNED32 result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   //Data_Get_Struct( ads_stmt, ADSHANDLE, s_ads_stmt );
+   s_stmt = NUM2ULONG(ads_stmt);
+
+   result = s_imp_drh->api.ads_affected_rows(s_stmt);
+
+   return (INT2FIX(result));
+}
+
+/*
+ * call-seq:
+ *   ads_describe_bind_param( VALUE imp_drh, VALUE ads_stmt, VALUE index ) -> [VALUE result, VALUE bind_param]
+ *
+ *  Describes the bind parameters of a prepared statement.
+ *
+ *  This function allows the caller to determine information about parameters
+ *  to a prepared statement. Depending on the type of the prepared statement
+ *  ( call to stored procedure or a DML ), only some information will be
+ *  provided. The information that will always be provided is the direction
+ *  of the parameters ( input, output, or input-output ).
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_stmt</tt> -- A statement object that was returned from ads_prepare(  ).
+ *  - <tt>VALUE index</tt> -- The index of the parameter. This should be a number between 0 and ads_num_params(  )-  1.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on success or <tt>0</tt> on failure.
+ *  - <tt>VALUE bind_param</tt>: The described param object.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_describe_bind_param(VALUE imp_drh, VALUE ads_stmt, VALUE index)
+{
+   imp_drh_st *s_imp_drh;
+   ADSHANDLE s_stmt;
+   a_ads_bind_param *s_ads_bind_param;
+   UNSIGNED32 result;
+   UNSIGNED32 s_index;
+   VALUE tdata;
+   VALUE multi_result;
+
+   s_ads_bind_param = malloc(sizeof(a_ads_bind_param));
+   memset(s_ads_bind_param, 0, sizeof(a_ads_bind_param));
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   s_stmt = NUM2ULONG(ads_stmt);
+   s_index = NUM2INT(index);
+
+   result = s_imp_drh->api.ads_describe_bind_param(s_stmt, s_index, s_ads_bind_param);
+
+   //FIXME handle failed result
+
+   multi_result = rb_ary_new();
+
+   rb_ary_push(multi_result, INT2FIX(result));
+
+   tdata = Data_Wrap_Struct(cA_ads_bind_param, 0, 0, s_ads_bind_param);
+   rb_ary_push(multi_result, tdata);
+
+   return (multi_result);
+}
+
+/*
+ * call-seq:
+ *   ads_bind_param( VALUE imp_drh, VALUE ads_stmt, VALUE index, VALUE ads_bind_param ) -> VALUE result
+ *
+ *  Binds a user supplied buffer as a parameter to the prepared statement.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_stmt</tt> -- A statement object that was returned from ads_prepare(  ).
+ *  - <tt>VALUE index</tt> -- The index of the parameter. This should be a number between 0 and ads_num_params(  ) - 1.
+ *  - <tt>VALUE ads_bind_param</tt> -- A filled bind object retrieved from ads_describe_bind_param(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on success or <tt>0</tt> on failure.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_bind_param(VALUE imp_drh, VALUE ads_stmt, VALUE index, VALUE ads_bind_param)
+{
+   imp_drh_st *s_imp_drh;
+   ADSHANDLE s_stmt;
+   a_ads_bind_param *s_ads_bind_param;
+   UNSIGNED32 result;
+   UNSIGNED32 s_index;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   //Data_Get_Struct( ads_stmt, ADSHANDLE, s_ads_stmt );
+   s_stmt = NUM2ULONG(ads_stmt);
+   Data_Get_Struct(ads_bind_param, a_ads_bind_param, s_ads_bind_param);
+   s_index = NUM2INT(index);
+
+   result = s_imp_drh->api.ads_bind_param(s_stmt, s_index, s_ads_bind_param);
+
+   return (INT2FIX(result));
+}
+
+/*
+ * call-seq:
+ *   ads_get_bind_param_info( VALUE imp_drh, VALUE ads_stmt, VALUE index ) -> [VALUE result, VALUE bind_param]
+ *
+ *  Gets bound parameter info.
+ *
+ *  This function retrieves information about the parameters that were
+ *  bound using ads_bind_param(  ).
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_stmt</tt> -- A statement object that was returned from ads_prepare(  ).
+ *  - <tt>VALUE index</tt> -- The index of the parameter. This should be a number between 0 and ads_num_params(  ) - 1.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on success or <tt>0</tt> on failure.
+ *  - <tt>VALUE bind_param</tt>: The described param object.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_get_bind_param_info(VALUE imp_drh, VALUE ads_stmt, VALUE index)
+{
+   imp_drh_st *s_imp_drh;
+   ADSHANDLE s_stmt;
+   a_ads_bind_param_info s_ads_bind_param_info;
+   UNSIGNED32 result;
+   UNSIGNED32 s_index;
+   VALUE tdata;
+   VALUE multi_result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   s_stmt = NUM2ULONG(ads_stmt);
+   s_index = NUM2INT(index);
+
+   result = s_imp_drh->api.ads_get_bind_param_info(s_stmt, s_index, &s_ads_bind_param_info);
+
+   //FIXME handle failed result
+   multi_result = rb_ary_new();
+
+   rb_ary_push(multi_result, INT2FIX(result));
+
+   // FIXME: Is this safe to be on the stack?
+   tdata = Data_Wrap_Struct(cA_ads_bind_param_info, 0, 0, &s_ads_bind_param_info);
+   rb_ary_push(multi_result, tdata);
+
+   return (multi_result);
+}
+
+/*
+ * call-seq:
+ *   ads_num_params( VALUE imp_drh, VALUE ads_stmt ) -> VALUE result
+ *
+ *  Returns the number of parameters that are expected for a prepared
+ *  statement.
+ *
+ *  This function retrieves information about the parameters that were bound
+ *  using ads_bind_param(  ).
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_stmt</tt> -- A statement object that was returned from ads_prepare(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: The number of parameters that are expected. <tt>-1</tt> if the ads_stmt object is not valid.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_num_params(VALUE imp_drh, VALUE ads_stmt)
+{
+   imp_drh_st *s_imp_drh;
+   ADSHANDLE s_stmt;
+   UNSIGNED32 result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   //Data_Get_Struct( ads_stmt, ADSHANDLE, s_ads_stmt );
+   s_stmt = NUM2ULONG(ads_stmt);
+
+   result = s_imp_drh->api.ads_num_params(s_stmt);
+
+   return (INT2FIX(result));
+}
+
+/*
+ * call-seq:
+ *   ads_get_next_result( VALUE imp_drh, VALUE ads_stmt ) -> VALUE result
+ *
+ *  Advances to the next result set in a multiple result set query.
+ *
+ *  If a query ( such as a call to a stored procedure ) returns multiple result
+ *  sets, then this function advances from the current result set to the next.
+ *
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_stmt</tt> -- A statement object that was executed by ads_execute(  ) or ads_execute_direct(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> if was successfully able to advance to the next result set, <tt>0</tt> otherwise.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_get_next_result(VALUE imp_drh, VALUE ads_stmt)
+{
+   imp_drh_st *s_imp_drh;
+   ADSHANDLE s_stmt;
+   UNSIGNED32 result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   //Data_Get_Struct( ads_stmt, ADSHANDLE, s_ads_stmt );
+   s_stmt = NUM2ULONG(ads_stmt);
+
+   result = s_imp_drh->api.ads_get_next_result(s_stmt);
+
+   return (INT2FIX(result));
+}
+
+/*
+ * call-seq:
+ *   ads_fetch_absolute( VALUE imp_drh, VALUE ads_stmt, VALUE offset ) -> VALUE result
+ *
+ *  Fetches data at a specific row number in the result set.
+ *
+ *  This function moves the current row in the result set to the row number
+ *  specified and fetches the data at that row.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_stmt</tt> -- A statement object that was executed by ads_execute(  ) or ads_execute_direct(  ).
+ *  - <tt>VALUE offset</tt> -- The row number to be fetched. The first row is <tt>1</tt>, the last row is <tt>-1</tt>.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> if the fetch was successfully, <tt>0</tt> otherwise.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_fetch_absolute(VALUE imp_drh, VALUE ads_stmt, VALUE offset)
+{
+   imp_drh_st *s_imp_drh;
+   ADSHANDLE s_stmt;
+   UNSIGNED32 s_offset;
+   UNSIGNED32 result;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   //Data_Get_Struct( ads_stmt, ADSHANDLE, s_ads_stmt );
+   s_stmt = NUM2ULONG(ads_stmt);
+   s_offset = NUM2INT(offset);
+   result = s_imp_drh->api.ads_fetch_absolute(s_stmt, s_offset);
+
+   return (INT2FIX(result));
+}
+
+/*
+ * call-seq:
+ *   ads_sqlstate( VALUE imp_drh, VALUE ads_conn ) -> VALUE sqlstate_str
+ *
+ *  Retrieves the current SQL state.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_conn</tt> -- A connection object that was connected by ads_connect(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE sqlstate_str</tt>: The SQL State.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_sqlstate(VALUE imp_drh, VALUE ads_conn)
+{
+   imp_drh_st *s_imp_drh;
+   a_ads_connection *s_ads_conn;
+   UNSIGNED32 result;
+   char s_buffer[255];
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   Data_Get_Struct(ads_conn, a_ads_connection, s_ads_conn);
+
+   result = s_imp_drh->api.ads_sqlstate(s_ads_conn, (UNSIGNED8 *)s_buffer, sizeof(s_buffer));
+
+   if (result)
+      return (rb_str_new(s_buffer, strlen(s_buffer)));
+   else
+      return Qnil;
+}
+
+/*
+ * call-seq:
+ *   ads_clear_error( VALUE imp_drh, VALUE ads_conn ) -> nil
+ *
+ *  Clears the last stored error code.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE imp_drh</tt> -- An initialized API structure to finalize.
+ *  - <tt>VALUE ads_conn</tt> -- A connection object that was connected by ads_connect(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt>:.
+ *
+ */
+static VALUE
+static_AdvantageInterface_ads_clear_error(VALUE imp_drh, VALUE ads_conn)
+{
+   imp_drh_st *s_imp_drh;
+   a_ads_connection *s_ads_conn;
+
+   Data_Get_Struct(imp_drh, imp_drh_st, s_imp_drh);
+   Data_Get_Struct(ads_conn, a_ads_connection, s_ads_conn);
+
+   s_imp_drh->api.ads_clear_error(s_ads_conn);
+
+   return (Qnil);
+}
+
+/*
+ * call-seq:
+ *   get_name( VALUE bind ) -> VALUE name
+ *
+ *  Gets the name of the bound parameter.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE bind</tt> -- Bound parameter retrieved from ads_describe_bind_param(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE name</tt>: The bound variable's name.
+ *
+ */
+static VALUE
+static_Bind_get_name(VALUE bind)
+{
+   a_ads_bind_param *s_bind;
+   Data_Get_Struct(bind, a_ads_bind_param, s_bind);
+   return (rb_str_new2((char *)s_bind->name));
+}
+
+/*
+ * call-seq:
+ *   set_value( VALUE bind, VALUE val ) -> nil
+ *
+ *  Sets the value of a bind parameter.
+ *
+ *  This function is used to bind a Ruby VALUE to a given parameter in a
+ *  prepared statement. If the bind_direction is INPUT only, the type INPUT
+ *  will be bound based on the RUBY type:
+ *
+ *    +-------------+------------+
+ *    | Ruby Type   |  Bind Type |
+ *    +-------------+------------+
+ *    | T_STRING   =>  A_STRING  |
+ *    | T_FIXNUM   =>  A_VAL_32  |
+ *    | T_BIGNUM   =>  A_DOUBLE  |
+ *    | T_FLOAT    =>  A_DOUBLE  |
+ *    | T_STRING   =>  A_STRING  |
+ *    | T_NIL      => isnull = 1 |
+ *    +--------------------------+
+ *
+ *  If the bind direction is OUTPUT, instead use the DBCAPI type to set the
+ *  size of the buffer.
+ *
+ *  In the case of INOUT parameters, it is the application's job to call this
+ *  method twice, once to bind the INPUT, and once to bind the OUTPUT.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE bind</tt> -- Bound parameter retrieved from ads_describe_bind_param(  ).
+ *  - <tt>VALUE val</tt> -- The value to bind into the bound variable.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt>.
+ */
+static VALUE
+static_Bind_set_value(VALUE bind, VALUE val)
+{
+   a_ads_bind_param *s_bind;
+   int length;
+
+   Data_Get_Struct(bind, a_ads_bind_param, s_bind);
+
+   // FIXME: use Ruby's allocation routines?
+   s_bind->value.is_null = malloc(sizeof(UNSIGNED32));
+   *s_bind->value.is_null = 0;
+
+   if (s_bind->direction == DD_INPUT)
+   {
+      switch (TYPE(val))
+      {
+      case T_STRING:
+         s_bind->value.length = malloc(sizeof(size_t));
+         length = RSTRING_LEN(val);
+         *s_bind->value.length = length;
+         s_bind->value.buffer = malloc(length);
+         memcpy(s_bind->value.buffer, RSTRING_PTR(val), length);
+         s_bind->value.type = A_STRING;
+         break;
+      case T_FIXNUM:
+         if (sizeof(void *) == 4) //32-bit
+         {
+            s_bind->value.length = malloc(sizeof(size_t));
+            s_bind->value.buffer = malloc(sizeof(int));
+            *((int *)s_bind->value.buffer) = FIX2INT(val);
+            s_bind->value.type = A_VAL32;
+            length = 1;
+            *s_bind->value.length = length;
+         }
+         else //64-bit
+         {
+            s_bind->value.length = malloc(sizeof(size_t));
+            s_bind->value.buffer = malloc(sizeof(long));
+            *((long *)s_bind->value.buffer) = FIX2LONG(val);
+            s_bind->value.type = A_VAL64;
+            length = 1;
+            *s_bind->value.length = length;
+         }
+         break;
+      case T_BIGNUM:
+         s_bind->value.length = malloc(sizeof(size_t));
+         s_bind->value.buffer = malloc(sizeof(LONG_LONG));
+         *((LONG_LONG *)s_bind->value.buffer) = rb_num2ll(val);
+         s_bind->value.type = A_VAL64;
+         length = 1;
+         *s_bind->value.length = length;
+         break;
+      case T_FLOAT:
+         s_bind->value.length = malloc(sizeof(size_t));
+         s_bind->value.buffer = malloc(sizeof(double));
+         *((double *)s_bind->value.buffer) = NUM2DBL(val);
+         s_bind->value.type = A_DOUBLE;
+         length = 1;
+         *s_bind->value.length = length;
+         break;
+      case T_FALSE:
+         s_bind->value.length = malloc(sizeof(size_t));
+         s_bind->value.buffer = malloc(sizeof(short));
+         *((int *)s_bind->value.buffer) = ADS_FALSE;
+         s_bind->value.type = A_UVAL16;
+         length = 1;
+         *s_bind->value.length = length;
+         break;
+      case T_TRUE:
+         s_bind->value.length = malloc(sizeof(size_t));
+         s_bind->value.buffer = malloc(sizeof(short));
+         *((int *)s_bind->value.buffer) = ADS_TRUE;
+         s_bind->value.type = A_UVAL16;
+         length = 1;
+         *s_bind->value.length = length;
+         break;
+      case T_NIL:
+         s_bind->value.length = malloc(sizeof(size_t));
+         *s_bind->value.is_null = 1;
+         s_bind->value.buffer = malloc(sizeof(int));
+         s_bind->value.type = A_VAL32;
+         length = 1;
+         *s_bind->value.length = length;
+         break;
+      default:
+         rb_raise(rb_eTypeError, "Cannot convert type. Must be STRING, FIXNUM, BIGNUM, FLOAT, or NIL");
+         break;
+      }
+   }
+   else
+   {
+      switch (s_bind->value.type)
+      {
+      case A_STRING:
+         s_bind->value.buffer = malloc(s_bind->value.buffer_size);
+         break;
+      case A_DOUBLE:
+         s_bind->value.buffer = malloc(sizeof(float));
+         break;
+      case A_VAL64:
+      case A_UVAL64:
+         s_bind->value.buffer = malloc(sizeof(LONG_LONG));
+         break;
+      case A_VAL32:
+      case A_UVAL32:
+         s_bind->value.buffer = malloc(sizeof(int));
+         break;
+      case A_VAL16:
+      case A_UVAL16:
+         s_bind->value.buffer = malloc(sizeof(short));
+         break;
+      case A_VAL8:
+      case A_UVAL8:
+         s_bind->value.buffer = malloc(sizeof(char));
+         break;
+      default:
+         rb_raise(rb_eTypeError, "Type unknown");
+         break;
+      }
+   }
+   return (Qnil);
+}
+
+/*
+ * call-seq:
+ *   set_direction( VALUE bind, VALUE direction ) -> nil
+ *
+ *  Sets the direction of the bound parameter before binding.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE bind</tt> -- Bound parameter retrieved from ads_describe_bind_param(  ).
+ *  - <tt>VALUE direction</tt> -- The direction of the binding variable.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt>.
+ *
+ */
+static VALUE
+static_Bind_set_direction(VALUE bind, VALUE direction)
+{
+   a_ads_bind_param *s_bind;
+
+   Data_Get_Struct(bind, a_ads_bind_param, s_bind);
+
+   s_bind->direction = NUM2CHR(direction);
+
+   return (Qnil);
+}
+
+/*
+ * call-seq:
+ *   set_buffer_size( VALUE bind, VALUE size ) -> nil
+ *
+ *  Sets the buffer size of INOUT and OUT parameters for string and binary
+ *  data.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE bind</tt> -- Bound parameter retrieved from ads_describe_bind_param(  ).
+ *  - <tt>VALUE size</tt> -- The size of the buffer to hold the INOUT or OUT parameter.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt>.
+ *
+ */
+static VALUE
+static_Bind_set_buffer_size(VALUE bind, VALUE size)
+{
+   a_ads_bind_param *s_bind;
+
+   Data_Get_Struct(bind, a_ads_bind_param, s_bind);
+
+   s_bind->value.buffer_size = NUM2INT(size);
+
+   return (Qnil);
+}
+
+/*
+ * call-seq:
+ *   get_direction( VALUE bind ) -> VALUE direction
+ *
+ *  Gets the direction of the bound parameter.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE bind</tt> -- Bound parameter retrieved from ads_describe_bind_param(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE name</tt>: The direction of the bound parameter.
+ *
+ */
+static VALUE
+static_Bind_get_direction(VALUE bind)
+{
+   a_ads_bind_param *s_bind;
+   Data_Get_Struct(bind, a_ads_bind_param, s_bind);
+
+   return (CHR2FIX(s_bind->direction));
+}
+
+/*
+ * call-seq:
+ *   finish( VALUE bind ) -> nil
+ *
+ *  Frees the resources associated with the bound parameter.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE bind</tt> -- Bound parameter retrieved from ads_describe_bind_param(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt>.
+ *
+ */
+static VALUE
+static_Bind_finish(VALUE bind)
+{
+   a_ads_bind_param *s_bind;
+
+   Data_Get_Struct(bind, a_ads_bind_param, s_bind);
+
+   // FIXME: use Ruby's allocation routines?
+   if (s_bind)
+   {
+      free(s_bind);
+   };
+
+   return (Qnil);
+}
+
+/*
+ * call-seq:
+ *  get_info_direction( VALUE bind ) -> VALUE direction
+ *
+ *  Gets the name of the bound parameter info object.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE bind</tt> -- Bound parameter info retrieved from ads_describe_bind_param_info(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE direction</tt>: The bound variable's direction.
+ *
+ */
+static VALUE
+static_Bind_get_info_direction(VALUE bind)
+{
+   a_ads_bind_param_info *s_bind;
+   Data_Get_Struct(bind, a_ads_bind_param_info, s_bind);
+
+   return (CHR2FIX(s_bind->direction));
+}
+
+/*
+ * call-seq:
+ *   get_info_output( VALUE bind ) -> VALUE name
+ *
+ *  Gets the value of a bound parameter after execution.
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE bind</tt> -- Bound parameter retrieved from ads_describe_bind_param(  ).
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE name</tt>: The bound variable value.
+ *
+ */
+static VALUE
+static_Bind_get_info_output(VALUE bind)
+{
+   a_ads_bind_param_info *s_bind;
+   Data_Get_Struct(bind, a_ads_bind_param_info, s_bind);
+   return (C2RB(&s_bind->output_value));
+}
+
+/*
+ *
+ */
+void Init_advantage()
+{
+   // Define top leve 'Advantage' module
+   mAdvantage = rb_define_module("Advantage");
+
+   // Define a sub-module name 'API' under Advantage.
+   // In Ruby, this is accessed as Advantage::API
+   mAPI = rb_define_module_under(mAdvantage, "API");
+
+   // Define ads interface functions
+   rb_define_module_function(mAPI, "ads_initialize_interface", static_API_ads_initialize_interface, 1);
+   rb_define_module_function(mAPI, "ads_finalize_interface", static_API_ads_finalize_interface, 1);
+   rb_define_const(mAPI, "VERSION", rb_str_new2(VERSION));
+
+   // Define interface classes under the Advantage module
+   cAdvantageInterface = rb_define_class_under(mAdvantage, "AdvantageInterface", rb_cObject);
+   rb_define_alloc_func(cAdvantageInterface, static_AdvantageInterface_alloc);
+
+   // Define all of the DBCAPI functions as methods under an interface instance
+   rb_define_method(cAdvantageInterface, "ads_init", static_AdvantageInterface_ads_init, 0);
+   rb_define_method(cAdvantageInterface, "ads_new_connection", static_AdvantageInterface_ads_new_connection, 0);
+   rb_define_method(cAdvantageInterface, "ads_client_version", static_AdvantageInterface_ads_client_version, 0);
+   rb_define_method(cAdvantageInterface, "ads_connect", static_AdvantageInterface_ads_connect, 2);
+   rb_define_method(cAdvantageInterface, "ads_disconnect", static_AdvantageInterface_ads_disconnect, 1);
+   rb_define_method(cAdvantageInterface, "ads_free_connection", static_AdvantageInterface_ads_free_connection, 1);
+   rb_define_method(cAdvantageInterface, "ads_fini", static_AdvantageInterface_ads_fini, 0);
+   rb_define_method(cAdvantageInterface, "ads_error", static_AdvantageInterface_ads_error, 1);
+   rb_define_method(cAdvantageInterface, "ads_execute_immediate", static_AdvantageInterface_ads_execute_immediate, 2);
+   rb_define_method(cAdvantageInterface, "ads_execute_direct", static_AdvantageInterface_ads_execute_direct, 2);
+   rb_define_method(cAdvantageInterface, "ads_num_cols", static_AdvantageInterface_ads_num_cols, 1);
+   rb_define_method(cAdvantageInterface, "ads_num_rows", static_AdvantageInterface_ads_num_rows, 1);
+   rb_define_method(cAdvantageInterface, "ads_get_column", static_AdvantageInterface_ads_get_column, 2);
+   rb_define_method(cAdvantageInterface, "ads_fetch_next", static_AdvantageInterface_ads_fetch_next, 1);
+   rb_define_method(cAdvantageInterface, "ads_get_column_info", static_AdvantageInterface_ads_get_column_info, 2);
+   rb_define_method(cAdvantageInterface, "AdsBeginTransaction", static_AdvantageInterface_AdsBeginTransaction, 1);
+   rb_define_method(cAdvantageInterface, "ads_commit", static_AdvantageInterface_ads_commit, 1);
+   rb_define_method(cAdvantageInterface, "ads_rollback", static_AdvantageInterface_ads_rollback, 1);
+   rb_define_method(cAdvantageInterface, "ads_prepare", static_AdvantageInterface_ads_prepare, 2);
+   rb_define_method(cAdvantageInterface, "ads_free_stmt", static_AdvantageInterface_ads_free_stmt, 1);
+   rb_define_method(cAdvantageInterface, "ads_reset", static_AdvantageInterface_ads_reset, 1);
+   rb_define_method(cAdvantageInterface, "ads_execute", static_AdvantageInterface_ads_execute, 1);
+   rb_define_method(cAdvantageInterface, "ads_affected_rows", static_AdvantageInterface_ads_affected_rows, 1);
+   rb_define_method(cAdvantageInterface, "ads_describe_bind_param", static_AdvantageInterface_ads_describe_bind_param, 2);
+   rb_define_method(cAdvantageInterface, "ads_bind_param", static_AdvantageInterface_ads_bind_param, 3);
+   rb_define_method(cAdvantageInterface, "ads_get_bind_param_info", static_AdvantageInterface_ads_get_bind_param_info, 2);
+   rb_define_method(cAdvantageInterface, "ads_num_params", static_AdvantageInterface_ads_num_params, 1);
+   rb_define_method(cAdvantageInterface, "ads_get_next_result", static_AdvantageInterface_ads_get_next_result, 1);
+   rb_define_method(cAdvantageInterface, "ads_fetch_absolute", static_AdvantageInterface_ads_fetch_absolute, 2);
+   rb_define_method(cAdvantageInterface, "ads_sqlstate", static_AdvantageInterface_ads_sqlstate, 1);
+   rb_define_method(cAdvantageInterface, "ads_clear_error", static_AdvantageInterface_ads_clear_error, 1);
+
+   // Define classes for accessing structures under Advantage module
+   cA_ads_connection = rb_define_class_under(mAdvantage, "a_ads_connection", rb_cObject);
+   cA_ads_data_value = rb_define_class_under(mAdvantage, "a_ads_data_value", rb_cObject);
+   //cA_ads_stmt = rb_define_class_under ( mAdvantage, "ADSHANDLE", rb_cObject );
+   cA_ads_bind_param = rb_define_class_under(mAdvantage, "a_ads_bind_param", rb_cObject);
+   cA_ads_bind_param_info = rb_define_class_under(mAdvantage, "a_ads_bind_param_info", rb_cObject);
+
+   // Define methods for obtaining bind_parameter fields
+   rb_define_method(cA_ads_bind_param, "get_name", static_Bind_get_name, 0);
+   rb_define_method(cA_ads_bind_param, "set_value", static_Bind_set_value, 1);
+   rb_define_method(cA_ads_bind_param, "get_direction", static_Bind_get_direction, 0);
+   rb_define_method(cA_ads_bind_param, "set_direction", static_Bind_set_direction, 1);
+   rb_define_method(cA_ads_bind_param, "set_buffer_size", static_Bind_set_buffer_size, 1);
+   rb_define_method(cA_ads_bind_param, "finish", static_Bind_finish, 0);
+
+   // Define methods for obtaining bind_parameter_info fields
+   rb_define_method(cA_ads_bind_param_info, "get_direction", static_Bind_get_info_direction, 0);
+   rb_define_method(cA_ads_bind_param_info, "get_output", static_Bind_get_info_output, 0);
+}