activerecord-ingres-adapter 3.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ee73a4b0345045c687590229b38fd5e25d272111
+  data.tar.gz: 683714ea31c1aa78d743b67b3194ebb742a63552
+SHA512:
+  metadata.gz: 902d32013ec1c034d404461d40fa255b42dbacd62bef1ae81103596a949d58466b762051a9ae34df4de11aacdbd4c822c0855517fdd1c1756ffe093f08bc0eaf
+  data.tar.gz: aa0267a389c5c1a3e5a6f38840f8184694db859b3d02e3549c9250396443446bd21b46052a057931ae69d26c7b267616b483eb846cdee2fb70e504ee5717fc7c

data/CHANGELOG

@@ -0,0 +1,69 @@
+version 1.4.1
+- Fix #656 - getProcedureName() returns a non-NULL terminated procedure name
+- Fix #653 - Update s.date dynamically for each release
+- Fix #651 - Add support for building a Ruby Gem
+- Fix #555 - SEGV when fetcing LOB data
+- Fix #565 - Compilation errors with Redhat ES 5.4 (x86-64)
+
+version 1.4.0
+- Default to "id" for the :primary_key column in ActiveRecord if no 
+  PRIMARY KEY constraint is defined
+- Update the documentation using RDoc
+- Add Ingres.set_environment()
+- Add the ability to set the date format for ingresdate values at connection
+  time
+- Update ingres_adapter.rb for ActiveRecord 2.3.x
+- Fix #489 - librt.so should only be used on Linux
+- Use IIAPI_VCH_TYPE for converting date values to their string form
+- Add support for the SQL SAVEPOINT statement
+- Fix a regression where certain query would return no data
+- Add support for multiple active connections
+- replaced all calls to ii_allocate()/ii_reallocate() with their ruby
+  counterparts ALLOC_N and REALLOC_N
+  - Except for memory allocation in getColumn()
+- Added a SQL query classifier to eliminate the need to force the query into
+  upper case
+- Moved Unicode functionality into Unicode.c and Unicode.h
+- Moved defines/typedefs/function prototypes into Ingres.h
+- Added new unit tests directory, see "Testing Done" for more information
+- Ingres.connect() takes an optional username/password
+  - eliminates the need for connect_with_credentials (now an alias pointing to
+    connect)
+- Ingres.execute() now accepts a variable number of parameters, requires query
+  but parameter values is optional
+  - Ingres.pexecute() now an alias for Ingres.execute()
+- Re-formatted the code using astyle (http://astyle.sourceforge.net/)
+- Added the following Ruby constants
+  - VERSION - version string, e.g. "1.4.0-dev"
+  - API_LEVEL - value for IIAPI_VERSION
+  - REVISION - the SVN revision for the driver
+- CM_AttrTab should be defined as an extern
+- Improve Ingres library and header detection _ version 1.3.0
+- Add support for the null clause used in Ingres 9.1.x (and earlier)
+- Change status to Beta
+
+version 1.3.0
+- Add quote_column_names() for quoting of table and column names. Required
+  for the ActiveRecord base unit tests
+- Fix data truncation for the ActiveRecord :text type
+- Add support for Ingres datatypes float4, float8, money, decimal, bigint,
+  and ANSI date/time/timestamp.
+- Add support in ingres_adapter.rb for Rails migrations
+- Restrict tables() to non-system tables
+
+version 1.2.2
+- Add an ascii README file for systems without access to a browser
+- Add TODO.txt show show areas that require attention
+- Add missing GPL header text to ingres_adapter.rb
+- Fix quote() in ingres_adapater.rb to use the class of variable rather than
+  the equivalent Ingres column type.
+- Fix segvio in Ingres Ruby driver when fetching char/varchar with data
+  longer than 4074 bytes.
+
+version 1.2.1
+- Initial release
+
+/*
+vim: ts=4 sw=4 expandtab textwidth=78
+$Id$
+*/

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gemspec
+
+#platforms :ruby do
+#  gem 'arel', '~> 5.0.0'
+#end

data/LICENSE

@@ -0,0 +1,258 @@
+GNU GENERAL PUBLIC LICENSE
+Version 2, June 1991
+Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+Preamble
+The licenses for most software are designed to take away your freedom
+to share and change it. By contrast, the GNU General Public License is
+intended to guarantee your freedom to share and change free software--to
+make sure the software is free for all its users. This General Public
+License applies to most of the Free Software Foundation's software and
+to any other program whose authors commit to using it. (Some other Free
+Software Foundation software is covered by the GNU Lesser General Public
+License instead.) You can apply it to your programs, too.
+
+When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it in
+new free programs; and that you know you can do these things.
+
+To protect your rights, we need to make restrictions that forbid anyone
+to deny you these rights or to ask you to surrender the rights. These
+restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+For example, if you distribute copies of such a program, whether gratis or
+for a fee, you must give the recipients all the rights that you have. You
+must make sure that they, too, receive or can get the source code. And
+you must show them these terms so they know their rights.
+
+We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on,
+we want its recipients to know that what they have is not the original,
+so that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+The precise terms and conditions for copying, distribution and
+modification follow.
+
+TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of running
+the Program is not restricted, and the output from the Program is covered
+only if its contents constitute a work based on the Program (independent
+of having been made by running the Program). Whether that is true depends
+on what the Program does.
+
+1. You may copy and distribute verbatim copies of the Program's source
+code as you receive it, in any medium, provided that you conspicuously
+and appropriately publish on each copy an appropriate copyright notice
+and disclaimer of warranty; keep intact all the notices that refer to
+this License and to the absence of any warranty; and give any other
+recipients of the Program a copy of this License along with the Program.
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+2. You may modify your copy or copies of the Program or any portion of
+it, thus forming a work based on the Program, and copy and distribute
+such modifications or work under the terms of Section 1 above, provided
+that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices stating
+    that you changed the files and the date of any change.
+    b) You must cause any work that you distribute or publish, that in whole
+    or in part contains or is derived from the Program or any part thereof,
+    to be licensed as a whole at no charge to all third parties under the
+    terms of this License.
+    c) If the modified program normally reads commands interactively when
+    run, you must cause it, when started running for such interactive use in
+    the most ordinary way, to print or display an announcement including an
+    appropriate copyright notice and a notice that there is no warranty (or
+    else, saying that you provide a warranty) and that users may redistribute
+    the program under these conditions, and telling the user how to view a
+    copy of this License. (Exception: if the Program itself is interactive
+    but does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If identifiable
+sections of that work are not derived from the Program, and can be
+reasonably considered independent and separate works in themselves,
+then this License, and its terms, do not apply to those sections when
+you distribute them as separate works. But when you distribute the same
+sections as part of a whole which is a work based on the Program, the
+distribution of the whole must be on the terms of this License, whose
+permissions for other licensees extend to the entire whole, and thus to
+each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest your
+rights to work written entirely by you; rather, the intent is to exercise
+the right to control the distribution of derivative or collective works
+based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of a
+storage or distribution medium does not bring the other work under the
+scope of this License.
+
+3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable source
+    code, which must be distributed under the terms of Sections 1 and 2
+    above on a medium customarily used for software interchange; or,
+    b) Accompany it with a written offer, valid for at least three years, to
+    give any third party, for a charge no more than your cost of physically
+    performing source distribution, a complete machine-readable copy of the
+    corresponding source code, to be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+    c) Accompany it with the information you received as to the offer to
+    distribute corresponding source code. (This alternative is allowed only
+    for noncommercial distribution and only if you received the program
+    in object code or executable form with such an offer, in accord with
+    Subsection b above.)
+
+The source code for a work means the preferred form of the work for making
+modifications to it. For an executable work, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the executable. However, as a special exception,
+the source code distributed need not include anything that is normally
+distributed (in either source or binary form) with the major components
+(compiler, kernel, and so on) of the operating system on which the
+executable runs, unless that component itself accompanies the executable.
+If distribution of executable or object code is made by offering access
+to copy from a designated place, then offering equivalent access to
+copy the source code from the same place counts as distribution of the
+source code, even though third parties are not compelled to copy the
+source along with the object code.
+
+4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt otherwise
+to copy, modify, sublicense or distribute the Program is void, and will
+automatically terminate your rights under this License. However, parties
+who have received copies, or rights, from you under this License will
+not have their licenses terminated so long as such parties remain in
+full compliance.
+
+5. You are not required to accept this License, since you have not signed
+it. However, nothing else grants you permission to modify or distribute
+the Program or its derivative works. These actions are prohibited
+by law if you do not accept this License. Therefore, by modifying or
+distributing the Program (or any work based on the Program), you indicate
+your acceptance of this License to do so, and all its terms and conditions
+for copying, distributing or modifying the Program or works based on it.
+
+6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further restrictions
+on the recipients' exercise of the rights granted herein. You are not
+responsible for enforcing compliance by third parties to this License.
+
+7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot distribute
+so as to satisfy simultaneously your obligations under this License
+and any other pertinent obligations, then as a consequence you may not
+distribute the Program at all. For example, if a patent license would
+not permit royalty-free redistribution of the Program by all those who
+receive copies directly or indirectly through you, then the only way you
+could satisfy both it and this License would be to refrain entirely from
+distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply
+and the section as a whole is intended to apply in other circumstances.
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any such
+claims; this section has the sole purpose of protecting the integrity of
+the free software distribution system, which is implemented by public
+license practices. Many people have made generous contributions to the
+wide range of software distributed through that system in reliance on
+consistent application of that system; it is up to the author/donor to
+decide if he or she is willing to distribute software through any other
+system and a licensee cannot impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+8. If the distribution and/or use of the Program is restricted in certain
+countries either by patents or by copyrighted interfaces, the original
+copyright holder who places the Program under this License may add an
+explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded. In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail
+to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Program does not specify a version
+number of this License, you may choose any version ever published by
+the Free Software Foundation.
+
+10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software
+and of promoting the sharing and reuse of software generally.
+
+NO WARRANTY
+11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK
+AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL
+DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING
+BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR
+LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM
+TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY
+HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+END OF TERMS AND CONDITIONS

data/README.md

@@ -0,0 +1,69 @@
+# Ingres Ruby ActiveRecord Adapter/Driver
+
+This repository contains code based on the outdated gem provided by Actian support
+for recent Ingres releases and Rails 3/4 compatibility. Bear in mind that not everything
+may be functional. As of today here's a list of what you can do (will update this as I go):
+
+* `SELECT` statements are fully functionals.
+
+## Overview
+
+Three components provide Ingres support for Ruby:
+
+* Ingres Ruby driver - native SQL-level interface
+* Ingres ActiveRecord adapter - object relational adapater for Ruby on Rails
+* Ingres Arel Visitor binding - specific visitor bindings for Arel
+
+All components are required for Rails applications using ActiveRecord,
+which is the standard Rails Object-to-Relations Mapping (ORM) interface. The
+adapter implements the ActiveRecord classes for Ingres; internally, it invokes the
+classes and methods in the driver to actually communicate with Ingres.
+The driver, while primarily intended to service the adapter, can also be
+invoked directly from any Ruby program to communicate with Ingres. The driver
+interface does not follow any standard API and may change in the future.
+
+## Installation Considerations
+
+To build and install the Ingres Ruby interface, the following components are
+required:
+
+* Ingres 9.1 or above. At a minimum, an Ingres client installation is required
+  on the same machine as the Ruby installation. For a list of Ingres binary and
+  source downloads, see http://esd.ingres.com.
+* Ruby, preferably at version 1.9.3 or later. Additional Ruby components or
+  related products (such as ActiveRecord or Rails) may also be required
+  depending on how Ruby will be used with Ingres. See below for details.
+* C compiler (for example, GNU/C on Linux and UNIX, or Microsoft Visual Studio
+  6 on Windows). The C compiler is not needed if you are using using a pre-built 
+  version of the Ingres Ruby driver.
+  Note: It is not possible to build Ruby extensions with newer versions of the
+  Visual Studio C compiler without making changes to the Ruby header files.
+* The Ingres Ruby ActiveRecord adapter source code and driver binary. The source 
+  code for the driver also is needed if not using the pre-built binary.
+
+## Installation
+
+### Rails 3.2.x
+
+I maintain compatibility for Rails 3.2.x and Arel 3 in the 3-0-stable branch. Using rubygems you can do:
+
+    $ gem install activerecord-ingres-adapter -v 3.0.2
+
+### Rails 4
+
+I maintain compatibility for Rails 4 and Arel 4/5 in the 4-0-stable branch. Using rubygems you can do:
+
+    $ gem install activerecord-ingres-adapter -v 4.0.0
+
+## TODO
+
+* Add support for `INSERT`, `UPDATE`, `DELETE` statements.
+* Add support for table manipulation/migrations.
+* Add support for database creation/deletion.
+
+## Notes
+
+I'm not in any part working for Actian, I'm just a third-party developer trying to make do
+with what I can. If some things aren't working I'm willing to help and provide limited support.
+
+If you want to help you're more than welcome to.

data/activerecord_ingres_adapter.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = "activerecord-ingres-adapter"
+  s.version = "3.0.2"
+  s.summary = "ActiveRecord Ingres Adapter"
+  s.email = "felix.bellanger@gmail.com"
+  s.homepage = "https://github.com/Keeguon/activerecord-ingres-adapter"
+  s.description = "ActiveRecord Ingres Adapter and driver for the Ingres Enterprise Relational Database"
+  s.authors = ["Grant Croker","Bruce Lunsford","Jared Richardson","Felix Bellanger"]
+
+  s.rubyforge_project = "activerecord-ingres-adapter"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.require_paths = ["lib"]
+  s.extensions    = ['ext/extconf.rb']
+end

data/ext/Ingres.c

@@ -0,0 +1,3889 @@
+/*
+**      Copyright (c) 2007 Ingres Corporation
+**
+**      This program is free software; you can redistribute it and/or modify
+**      it under the terms of the GNU General Public License version 2 as
+**      published by the Free Software Foundation.
+**
+**      This program is distributed in the hope that it will be useful,
+**      but WITHOUT ANY WARRANTY; without even the implied warranty of
+**      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+**      GNU General Public License for more details.
+**
+**      You should have received a copy of the GNU General Public License along
+**      with this program; if not, write to the Free Software Foundation, Inc.,
+**      51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+/*      static char     Sccsid[] = "$Id$";        */
+
+/*
+**      INGRES.C
+**
+**      History
+**              12/18/06 (Jared Richardson)
+**                      Community developer provided original source
+**                      for Ingres Corp to use as basis for Ruby driver
+**              02/21/07 (robert.kent@ingres.com)
+**                      General cleanup, removal of unused variables, etc,
+**                      replacement of trim function with Ingres version,
+**                      creation of debug flag setting function
+**              11/30/07 (bruce.lunsford@ingres.com)
+**                      Fix Segvio when selecting char or varchar with data
+**                      longer than 4074 bytes (co_sizeAdvise + 2).  Also
+**                      improve performance on non-lob colunn fetches by
+**                      eliminating alloc/free on every column.
+**              06/17/08 (bruce.lunsford@ingres.com)
+**                      Add support for datatypes float4, float8, money,
+**                      decimal, bigint.  Removed unref'd processShortField().
+**                      Change INT2NUM->INT2FIX where feasible for performance.
+**                      Add support for Ingres ANSI date/time datatypes.
+**              09/30/09 (grant.croker@ingres.com)
+**                      Add support for multiple active connections
+**                      replaced all calls to ii_allocate()/ii_reallocate() 
+**                      with their ruby counterparts ALLOC_N and REALLOC_N
+**                        Except for memory allocation in getColumn()
+**                      Added a SQL query classifier to eliminate the need 
+**                      to force the query into upper case
+**                      Moved Unicode functionality into Unicode.c and Unicode.h
+**                      Moved defines/typedefs/function prototypes into Ingres.h
+**                      Ingres.connect() takes an optional username/password
+**                        eliminates the need for connect_with_credentials 
+**                      (now an alias pointing to connect)
+**                      Ingres.execute() now accepts a variable number of parameters,
+**                      requires query but parameter values is optional
+**                      Ingres.pexecute() now an alias for Ingres.execute()
+**                      Re-formatted the code using astyle (http://astyle.sourceforge.net/)
+**                      Added the following Ruby constants
+**                        VERSION - version string, e.g. "1.4.0-dev"
+**                        API_LEVEL - value for IIAPI_VERSION
+**                        REVISION - the SVN revision for the driver
+**              10/08/09 (grant.croker@ingres.com)
+**                      Add support for the SQL SAVEPOINT statement
+**                      Fix a regression where certain query would return no data
+**              10/27/09 (grant.croker@ingres.com)
+**                      Convert date values to IIAPI_VCH_TYPE to avoid space padded strings
+**              11/09/2009 (grant.croker@ingres.com)
+**                      Add the ability to set the date format for Ingres date values
+**                      from within Ruby.
+**              07/28/2010 (grant.croker@ingres.com)
+**                      Fix bug #555 - SEGV when using memcpy with BLOB data
+**              10/29/2010 (grant.croker@ingres.com)
+**                      Fix bug #656 - getProcedureName() fails to NULL terminate the
+**                      parsed procedure name.
+**                      
+ */
+
+#include "ruby.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <iiapi.h>
+#include "Ingres.h"
+#include "Unicode.h"
+
+
+static VALUE cIngres;
+
+II_GLOBALS ii_globals;
+II_LONG global_rows_affected = 0;
+
+extern u_i2 *CM_AttrTab;
+extern char *CM_CaseTab;
+
+/* static int ii_sync(IIAPI_GENPARM *genParm)
+ * Waits for completion of the last Ingres api call used because of the asynchronous design of this api
+*/
+static int
+ii_sync (IIAPI_GENPARM * genParm)
+{
+  static IIAPI_WAITPARM waitParm =
+  {
+    -1,				/* no timeout, we don't want asynchronous queries */
+    0				/* wt_status (output) */
+  };
+  static char function_name[] = "ii_sync";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  while (genParm->gp_completed == FALSE)
+  {
+    IIapi_wait (&waitParm);
+  }
+
+  if (waitParm.wt_status != IIAPI_ST_SUCCESS)
+    rb_raise (rb_eRuntimeError, "IIapi_wait() failed.");
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return 0;
+}
+
+
+void *
+ii_allocate (size_t nitems, size_t size)
+{
+  void *ptr = NULL;
+  char function_name[] = "ii_allocate";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  ptr = calloc (nitems, size);
+
+  if (ptr == NULL)
+    rb_raise (rb_eRuntimeError, "Error! Failed to allocate memory. ");
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+
+  return ptr;
+}
+
+void *
+ii_reallocate (void *oldPtr, size_t nitems, size_t size)
+{
+  void *ptr = NULL;
+  char function_name[] = "ii_reallocate";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  if (oldPtr == NULL)
+    return ii_allocate (nitems, size);
+
+  ptr = realloc (oldPtr, nitems * size);
+
+  if (ptr == NULL)
+    rb_raise (rb_eRuntimeError, "Error! Failed to reallocate memory. ");
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+
+  return ptr;
+}
+
+void
+ii_free (void **ptr)
+{
+  char function_name[] = "ii_free";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  if (*ptr != NULL)
+    {
+      free (*ptr);
+      *ptr = NULL;
+    }
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return;
+}
+
+void
+ii_api_init ()
+{
+  IIAPI_INITPARM initParm;
+  char function_name[] = "ii_api_init";
+  if (ii_globals.debug)
+    printf ("Entering %s, API Version is %d.\n", function_name, IIAPI_VERSION);
+
+  initParm.in_version = IIAPI_VERSION;
+  initParm.in_timeout = -1;
+  IIapi_initialize (&initParm);
+  ii_globals.envHandle = initParm.in_envHandle;
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+}
+
+/* 
+ * Document-method: new
+ *
+ * Initializes a new instance of Ingres.
+ *
+ * call-seq:
+ *    Ingres.new() -> Ingres
+ *
+ * Example usage:
+ *
+ *    conn = Ingres.new()
+ *
+ */
+VALUE
+ii_init (VALUE param_self) 
+{
+  char function_name[] = "ii_init";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  ii_globals.debug = FALSE;
+  ii_globals.debug_connection = FALSE;
+  ii_globals.debug_sql = FALSE;
+  ii_globals.debug_termination = FALSE;
+  ii_globals.debug_transactions = FALSE;
+
+  if (ii_globals.debug)
+    printf ("%s: About to execute ii_api_init ()\n", function_name);
+  ii_api_init ();
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return param_self;
+}
+
+
+void
+init_rb_array (VALUE * param_rb_array)
+{
+  char function_name[] = "init_rb_array";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  if (!(*param_rb_array))
+  {
+    *param_rb_array = rb_ary_new ();
+    rb_global_variable (param_rb_array);
+  }
+  rb_ary_clear (*param_rb_array);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+}
+
+char *
+getIngresDataTypeAsString (IIAPI_DT_ID param_dt_id)
+{
+  char *dataType = NULL;
+  char function_name[] = "getIngresDataTypeAsString";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  switch (param_dt_id)
+  {
+    case IIAPI_LNVCH_TYPE:
+    case IIAPI_LBYTE_TYPE:
+    case IIAPI_LVCH_TYPE:
+      dataType = RUBY_LOB;
+      break;
+
+    case IIAPI_CHA_TYPE:
+    case IIAPI_NCHA_TYPE:
+    case IIAPI_CHR_TYPE:
+    case IIAPI_DEC_TYPE:
+      dataType = RUBY_STRING;
+      break;
+
+    case IIAPI_INT_TYPE:
+      dataType = RUBY_INTEGER;
+      break;
+
+    case IIAPI_FLT_TYPE:
+    case IIAPI_MNY_TYPE:
+      dataType = RUBY_DOUBLE;
+      break;
+
+    case IIAPI_BYTE_TYPE:
+      dataType = RUBY_BYTE;
+      break;
+
+    case IIAPI_TXT_TYPE:
+      dataType = RUBY_TEXT;
+      break;
+
+    case IIAPI_VCH_TYPE:
+    case IIAPI_NVCH_TYPE:
+      dataType = RUBY_VARCHAR;
+      break;
+
+    case IIAPI_DTE_TYPE:
+#ifdef IIAPI_DATE_TYPE
+    case IIAPI_DATE_TYPE:
+    case IIAPI_TIME_TYPE:
+    case IIAPI_TMWO_TYPE:
+    case IIAPI_TMTZ_TYPE:
+    case IIAPI_TS_TYPE:
+    case IIAPI_TSWO_TYPE:
+    case IIAPI_TSTZ_TYPE:
+    case IIAPI_INTYM_TYPE:
+    case IIAPI_INTDS_TYPE:
+#endif
+      dataType = RUBY_DATE;
+      break;
+
+    default:
+      dataType = RUBY_UNMAPPED;
+      printf ("\nUnmapped data type is %d\n", param_dt_id);
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return dataType;
+}
+
+
+/** check for and print out any errors found */
+/* TODO: we should raise an exception */
+void
+printGPStatus (int param_gp_status)
+{
+  char *ptr = NULL;
+  char val[33] = "";
+  char function_name[] = "printGPStatus";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  switch (param_gp_status)
+  {
+    case IIAPI_ST_ERROR:
+      ptr = "IIAPI_ST_ERROR";
+      break;
+
+    case IIAPI_ST_FAILURE:
+      ptr = "IIAPI_ST_FAILURE";
+      break;
+
+    case IIAPI_ST_NOT_INITIALIZED:
+      ptr = "IIAPI_ST_NOT_INITIALIZED";
+      break;
+
+    case IIAPI_ST_INVALID_HANDLE:
+      ptr = "IIAPI_ST_INVALID_HANDLE";
+      break;
+
+    case IIAPI_ST_OUT_OF_MEMORY:
+      ptr = "IIAPI_ST_OUT_OF_MEMORY";
+      break;
+
+    default:
+      ptr = val;
+      sprintf (val, "%d", param_gp_status);
+      break;
+  }
+  printf ("\n%s: status = %s\n", function_name, ptr);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+}
+
+
+char *
+getErrorTypeStr (int param_ge_type)
+{
+  char *ptr = NULL;
+  char function_name[] = "getErrorTypeStr";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  switch (param_ge_type)
+  {
+    case IIAPI_GE_ERROR:
+      ptr = "ERROR";
+      break;
+    case IIAPI_GE_WARNING:
+      ptr = "WARNING";
+      break;
+    case IIAPI_GE_MESSAGE:
+      ptr = "USER MESSAGE";
+      break;
+    default:
+      ptr = "?";
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return ptr;
+}
+
+
+int
+ii_checkError (IIAPI_GENPARM * param_genParm)
+{
+  int ret_val = FALSE;
+  char function_name[] = "ii_checkError";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  if (param_genParm != NULL && param_genParm->gp_status >= IIAPI_ST_ERROR)
+  {
+    ret_val = TRUE;
+    printGPStatus (param_genParm->gp_status);
+  }
+
+  if (param_genParm != NULL && param_genParm->gp_errorHandle)
+  {
+    IIAPI_GETEINFOPARM getErrParm;
+    char *errorTypeStr = NULL;
+    char *message = NULL;
+
+    ret_val = TRUE;
+    printf ("\n%s: %s\n", function_name, ERROR_MESSAGE_HEADER);
+
+    /* Provide initial error handle. */
+    getErrParm.ge_errorHandle = param_genParm->gp_errorHandle;
+
+    /* Call IIapi_getErrorInfo() in loop until no data. */
+    while (IIapi_getErrorInfo (&getErrParm), getErrParm.ge_status == IIAPI_ST_SUCCESS)
+    {
+      errorTypeStr = getErrorTypeStr (getErrParm.ge_type);
+      message = (getErrParm.ge_message ? getErrParm.ge_message : "NULL");
+
+      /* Print error message info */
+      printf ("%s: SQLSTATE: %s, CODE: 0x%x: %s\n",
+              errorTypeStr, getErrParm.ge_SQLSTATE,
+              getErrParm.ge_errorCode, message);
+    }
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return ret_val;
+}
+
+void
+ii_api_set_connect_param (II_CONN *ii_conn, II_LONG paramID, VALUE paramValue)
+{
+  IIAPI_SETCONPRMPARM    setConPrmParm;
+  II_LONG tmp_long = 0;
+  char function_name[] = "ii_api_set_connect_param";
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  setConPrmParm.sc_genParm.gp_callback = NULL;
+#if defined(IIAPI_VERSION_2)
+  setConPrmParm.sc_connHandle = ii_globals.envHandle;
+#else
+  setConPrmParm.sc_connHandle = NULL;
+#endif
+  setConPrmParm.sc_paramID = paramID;
+
+  switch (TYPE(paramValue))
+  {
+    case T_STRING:
+      setConPrmParm.sc_paramValue = RSTRING_PTR(paramValue);
+      break;
+    case T_FIXNUM:
+      tmp_long = FIX2LONG(paramValue);
+      setConPrmParm.sc_paramValue = (II_PTR)&tmp_long;
+      break;
+    default:
+      rb_raise(rb_eArgError, "Unable to handle an option value of type %d", TYPE(paramValue));
+  }
+
+  IIapi_setConnectParam(&setConPrmParm);
+  ii_sync (&(setConPrmParm.sc_genParm));
+  ii_checkError (&setConPrmParm.sc_genParm);
+
+  ii_conn->connHandle = setConPrmParm.sc_connHandle;
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+
+}
+
+  
+void
+ii_api_set_env_param (II_LONG paramID, VALUE paramValue)
+{
+  IIAPI_SETENVPRMPARM    setEnvPrmParm;
+  II_LONG tmp_long = 0;
+  char function_name[] = "ii_api_set_env_param";
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  setEnvPrmParm.se_envHandle = ii_globals.envHandle;
+  setEnvPrmParm.se_paramID = paramID;
+
+  switch (TYPE(paramValue))
+  {
+    case T_STRING:
+      setEnvPrmParm.se_paramValue = RSTRING_PTR(paramValue);
+      break;
+    case T_FIXNUM:
+      tmp_long = FIX2LONG(paramValue);
+      setEnvPrmParm.se_paramValue = (II_PTR)&tmp_long;
+      break;
+    default:
+      rb_raise(rb_eArgError, "Unable to handle an option value of type %d", TYPE(paramValue));
+  }
+
+  IIapi_setEnvParam (&setEnvPrmParm);
+  if (setEnvPrmParm.se_status != 0)
+  {
+    rb_raise(rb_eRuntimeError, "An error occurred when calling IIapi_setEnvParam, status returned was %d", setEnvPrmParm.se_status);
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+
+}
+
+void
+ii_api_connect (II_CONN *ii_conn, char *param_targetDB, char *param_username, char *param_password)
+{
+  IIAPI_CONNPARM connParm;
+  char function_name[] = "ii_api_connect";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  if (ii_globals.debug || ii_globals.debug_connection)
+    printf
+    ("%s: Attempting to connect to database: %s, as username: %s, password: %s.\n",
+     function_name, param_targetDB, param_username, param_password);
+
+  connParm.co_genParm.gp_callback = NULL;
+  connParm.co_genParm.gp_closure = NULL;
+  connParm.co_target = param_targetDB;
+  connParm.co_connHandle = (ii_conn->connHandle != NULL) ? ii_conn->connHandle : ii_globals.envHandle;
+  connParm.co_tranHandle = NULL;
+  connParm.co_type = IIAPI_CT_SQL;
+  connParm.co_username = param_username;
+  connParm.co_password = param_password;
+  connParm.co_timeout = -1;
+
+  if (ii_globals.debug || ii_globals.debug_connection)
+    printf ("%s: About to execute IIapi_connect (&connParm)\n", function_name);
+
+  IIapi_connect (&connParm);
+  ii_sync (&(connParm.co_genParm));
+
+  if (ii_globals.debug || ii_globals.debug_connection)
+    printf ("%s: Executed IIapi_connect, status is %i\n", function_name, connParm.co_genParm.gp_status);
+  if (connParm.co_genParm.gp_status == IIAPI_ST_SUCCESS)
+  {
+    ii_conn->connHandle = connParm.co_connHandle;
+    ii_conn->lobSegmentSize = connParm.co_sizeAdvise;
+    ii_conn->apiLevel = connParm.co_apiLevel;
+  }
+  else
+  {
+    ii_checkError (&connParm.co_genParm);
+    rb_raise (rb_eRuntimeError, "Error! Failed to connect to database: %s, as username: %s, password: %s. ",
+              param_targetDB, param_username, param_password);
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+}
+
+/* 
+ * Document-method: set_environment
+ *
+ * call-seq:
+ *    Ingres.set_environment(environment_hash) -> nil
+ *
+ * Configures the environment settings for a Ruby application.
+ *
+ * Valid hash keys are:
+ *
+ * * <tt>:dateformat</tt>
+ *
+ * Example usage:
+ *
+ *  conn = Ingres.new()
+ *  conn.connect(:database => "demodb")
+ *  conn.set_environment(:date_format => Ingres::DATE_FORMAT_FINLAND)
+ *
+ */
+VALUE
+ii_set_environment (int param_argc, VALUE *param_argv, VALUE param_self)
+{
+  char function_name[] = "ii_set_environment";
+  VALUE param_value = Qnil;
+  VALUE args,arg;
+  int param_no = 0;
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  rb_scan_args (param_argc, param_argv, "0*", &args);
+
+  if (RARRAY_LEN(args) == 1)
+  {
+    arg = rb_ary_entry(args,0);
+    if (TYPE (arg) == T_HASH)
+    {
+      for (param_no = 0; param_no < INGRES_NO_ENV_PARAMS; param_no++)
+      {
+        param_value = rb_hash_aref(arg, ID2SYM(rb_intern(ENV_PARAMS[param_no].paramName)));
+        if (TYPE(param_value) != T_NIL)
+        {
+          ii_api_set_env_param (ENV_PARAMS[param_no].paramID, param_value);
+        }
+      }
+    }
+    else
+    {
+      rb_raise(rb_eArgError, "Expected a hash of environment parameters");
+    }
+  }
+  else
+  {
+    rb_raise(rb_eArgError, "Expected a hash of environment parameters");
+  }
+
+  return param_self;
+}
+
+/*
+ * Document-method: connect
+ *
+ * call-seq: 
+ *    Ingres.connect(connection_hash) -> Ingres
+ *    Ingres.connect(database[, username, password]) -> Ingres
+ *
+ * Makes a connection to an Ingres database.
+ *
+ * _connection_hash_ keys:
+ * * +database+ - database to connect to in either of the following forms:
+ *    [vnode::]database[/svrclass]
+ *    @hostname,tcp_ip,listen_address[username,password]::database
+ * * +username+ - username to use for connection. 
+ * * +password+ - password for the supplied username
+ * * +date_format+ - the string format to be used for Ingres date values. See the
+ *   DATE_FORMAT_* constants for valid values.
+ *
+ * Usage examples:
+ * * Setting the date format to "YYYY-MM-DD HH:MM:SS"
+ *    Ingres.connect(:database => "demodb", :date_format => Ingres::DATE_FORMAT_SWEDEN)
+ * * Passing a username / password
+ *    Ingres.connect(:database => "demodb", :username => "ruby", password => "s3cr3t")
+ * * Passing a hash variable
+ *    config[:database] = "demodb"
+ *    config[:username] = "ruby"
+ *    config[:password] = "s3cr3t"
+ *    config[:date_format] = Ingres::DATE_FORMAT_ISO4
+ *    Ingres.connect(config)
+ *
+ */
+
+VALUE
+ii_connect (int param_argc, VALUE *param_argv, VALUE param_self)
+{
+  char function_name[] = "ii_connect";
+  VALUE param_targetDB;
+  VALUE param_username = Qnil;
+  VALUE param_password = Qnil;
+  VALUE param_value = Qnil;
+  VALUE args,arg;
+  II_CONN *ii_conn = NULL;
+  int db_length = 0;
+  int param_no = 0;
+  VALUE maxSegmentSize = INT2FIX(LOB_SEGMENT_SIZE);
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  Data_Get_Struct(param_self, II_CONN, ii_conn);
+
+  rb_scan_args (param_argc, param_argv, "0*", &args);
+
+  if (RARRAY_LEN(args) == 1)
+  {
+    arg = rb_ary_entry(args,0);
+    if (TYPE (arg) == T_STRING)
+    {
+      /* Just have a database */
+      param_targetDB = arg;
+      param_username = rb_str_new2 ("");
+      param_password = rb_str_new2 ("");
+    }
+    else if (TYPE (arg) == T_HASH)
+    {
+      /* Ingres.connect({:dbname=>xxxx, :username => "xxxx", :password => "xxxx"}) */
+      param_targetDB = rb_hash_aref(arg, ID2SYM(rb_intern("database")));
+      param_username = rb_hash_aref(arg, ID2SYM(rb_intern("username")));
+      param_password = rb_hash_aref(arg, ID2SYM(rb_intern("password")));
+      
+      if (TYPE(param_targetDB) == T_NIL)
+      {
+        rb_raise(rb_eArgError, "Unable to connect without specifying a database");
+      }
+      for ( param_no = 0; param_no < INGRES_NO_ENV_PARAMS; param_no++)
+      {
+        param_value = rb_hash_aref(arg, ID2SYM(rb_intern(CONN_PARAMS[param_no].paramName)));
+        if (TYPE(param_value) != T_NIL)
+        {
+          ii_api_set_connect_param (ii_conn, CONN_PARAMS[param_no].paramID, param_value);
+        }
+      }
+    }
+  }
+  else if (RARRAY_LEN(args) == 3)
+  {
+    param_targetDB = rb_ary_entry(args,0);
+    param_username = rb_ary_entry(args,1);
+    param_password = rb_ary_entry(args,2);
+  }
+  else
+  {
+		rb_raise(rb_eArgError, "Expected one of: database, database + username/password or hash");
+  }
+
+  /* If param_username and param_password are not supplied, convert them to an empty T_STRING */
+  if ((TYPE (param_username) == T_NIL) && (TYPE (param_password) == T_NIL))
+  {
+    param_username = rb_str_new2 ("");
+    param_password = rb_str_new2 ("");
+  }
+  else if ((TYPE (param_username) == T_STRING) && (TYPE (param_password) == T_NIL))
+  {
+    /* Password is required when a username is supplied */
+    /* This is a hacky way of aborting but will do until an IngresError Exception has been added */
+    rb_raise(rb_eArgError, "A password is required when specifying a username");
+  }
+
+  ii_api_connect (ii_conn, RSTRING_PTR(param_targetDB), RSTRING_PTR(param_username), RSTRING_PTR(param_password));
+
+  if (RARRAY_LEN(args) == 1)
+  {
+    arg = rb_ary_entry(args,0);
+    if (TYPE (arg) == T_HASH)
+    {
+      for (param_no = 0; param_no < INGRES_NO_ENV_PARAMS; param_no++)
+      {
+        param_value = rb_hash_aref(arg, ID2SYM(rb_intern(ENV_PARAMS[param_no].paramName)));
+        if (TYPE(param_value) != T_NIL)
+        {
+          ii_api_set_env_param (ENV_PARAMS[param_no].paramID, param_value);
+        }
+      }
+    }
+  }
+  db_length = strlen(StringValuePtr(param_targetDB));
+
+  ii_conn->currentDatabase = ALLOC_N (char, db_length + 1);
+  memcpy (ii_conn->currentDatabase, StringValuePtr(param_targetDB), db_length);
+  ii_conn->currentDatabase[db_length] = '\0';
+
+  ii_api_set_env_param (IIAPI_EP_MAX_SEGMENT_LEN, maxSegmentSize);
+
+  if (ii_globals.debug || ii_globals.debug_connection)
+    printf ("%s: Set ii_conn->currentDatabase to %s\n", function_name, ii_conn->currentDatabase);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+
+  return param_self;
+}
+
+/*
+ * Document-method: disconnect
+ *
+ * Disconnects from the associated database
+ *
+ * call-seq: 
+ *    Ingres.disconnect ()
+ *
+ */
+static VALUE
+ii_disconnect (VALUE param_self)
+{
+  char function_name[] = "ii_disconnect";
+  II_CONN *ii_conn = NULL;
+
+  Data_Get_Struct(param_self, II_CONN, ii_conn);
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+  if (ii_globals.debug || ii_globals.debug_termination)
+    printf ("%s: Preparing to disconnect\n", function_name);
+
+  if (ii_conn->keep_me)
+    rb_ary_clear (ii_conn->keep_me);
+
+  /* If there is an active transaction it must be closed before disconnection */
+  if (ii_conn->tranHandle)
+  {
+    ii_api_rollback (ii_conn, NULL);
+  }
+  if (ii_conn->connHandle)
+  {
+    ii_api_disconnect(ii_conn);
+  }
+  else
+  {
+    if (ii_globals.debug || ii_globals.debug_termination)
+      printf ("%s: Not connected\n", function_name);
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return Qnil;
+}
+
+void ii_api_disconnect( II_CONN *ii_conn)
+{
+  IIAPI_DISCONNPARM disconnParm;
+  IIAPI_TERMPARM termParm;
+
+  char function_name[] = "ii_disconnect";
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  if (ii_conn->connHandle)
+  {
+    disconnParm.dc_genParm.gp_callback = NULL;
+    disconnParm.dc_genParm.gp_closure = NULL;
+    disconnParm.dc_connHandle = ii_conn->connHandle;
+
+    if (ii_globals.debug || ii_globals.debug_termination)
+      printf ("%s: Next, IIapi_disconnect\n", function_name);
+
+    IIapi_disconnect (&disconnParm);
+    ii_sync (&(disconnParm.dc_genParm));
+
+    if (ii_globals.debug || ii_globals.debug_termination)
+      printf ("%s: Disconnect status is >>%d<<\n", function_name, disconnParm.dc_genParm.gp_status);
+
+    ii_checkError (&disconnParm.dc_genParm);
+
+    if (ii_globals.debug || ii_globals.debug_termination)
+      printf ("%s: Completed IIapi_disconnect and related error checks\n", function_name);
+
+    if (ii_globals.debug || ii_globals.debug_termination)
+      printf ("ii_disconnect: Next, IIapi_terminate( &termParm )\n");
+
+    IIapi_terminate (&termParm);
+    ii_conn->connHandle = NULL;
+
+    if (ii_globals.debug || ii_globals.debug_termination)
+      printf ("%s: Completed IIapi_terminate( &termParm )\n", function_name);
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+}
+
+/*
+ * Document-method: commit
+ *
+ * call-seq:
+ *    Ingres.commit()
+ *
+ * Commit the current open transaction against the associated database
+ * connection. Any active savepoints created by savepoint will be
+ * released.
+ *
+ */
+VALUE
+ii_commit (VALUE param_self)
+{
+  char function_name[] = "ii_commit";
+  II_CONN *ii_conn = NULL;
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  Data_Get_Struct(param_self, II_CONN, ii_conn);
+
+  /* We cannot commit a transaction if there is not one is already in place */
+  if (ii_conn->tranHandle == NULL)
+  {
+    rb_raise (rb_eRuntimeError, "Unable to commit a non-existent transaction");
+  }
+  else
+  {
+    ii_api_commit (ii_conn);
+  }
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return Qnil;
+}
+
+/*
+ * Document-method: rollback
+ *
+ * call-seq:
+ *    Ingres.rollback([savepoint])
+ *
+ * Rolls back the current transaction against the associated database
+ * connection to the named savepoint. If no savepoint is specified, the
+ * transaction is rolled back to the last commit point and all savepoints 
+ * created by savepoint are released.
+ *
+ * Example usage with savepoints:
+ *
+ *  conn = Ingres.new()
+ *  conn.connect(:database => "demodb")
+ *  conn.execute("START TRANSACTION")
+ *  conn.execute("INSERT INTO user_profile VALUES
+ *    (1,'Test', 'User 1', 'user1@example.com','VLL', NULL)")
+ *  conn.savepoint("user1")
+ *  conn.execute("INSERT INTO user_profile VALUES
+ *    (2,'Test', 'User 2', 'user2@example.com','MAD', NULL)")
+ *  conn.execute("INSERT INTO user_profile VALUES
+ *    (3,'Test', 'User 3', 'user3@example.com','JFK', NULL)")
+ *  conn.rollback("user1")
+ *
+ */
+VALUE
+ii_rollback (int param_argc, VALUE * param_argv, VALUE param_self)
+{
+  char function_name[] = "ii_rollback";
+  II_CONN *ii_conn = NULL;
+  VALUE param_savepointName = (VALUE) FALSE;
+  II_SAVEPOINT_ENTRY *savePtEntry = NULL;
+  II_SAVEPOINT_ENTRY *nextSavePtEntry = NULL;
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  rb_scan_args (param_argc, param_argv, "01", &param_savepointName);
+  if (param_argc)
+  {
+    Check_Type(param_savepointName, T_STRING);
+  }
+
+  Data_Get_Struct(param_self, II_CONN, ii_conn);
+
+  /* We cannot rollback a transaction if there is not one is already in place */
+  if (ii_conn->tranHandle == NULL)
+  {
+    rb_raise (rb_eRuntimeError, "Unable to rollback a non-existent transaction");
+  }
+  else
+  {
+    if (param_argc)
+    {
+      /* Find the the savepoint entry in the list of savepoints */
+      if (ii_conn->savePtList)
+      {
+        savePtEntry = ii_conn->savePtList;
+        while (savePtEntry)
+        {
+          /* Check to see if the entry's savePtName is the same length else we could
+           * have a false postive result */
+          if (strlen(savePtEntry->savePtName) == RSTRING_LEN(param_savepointName))
+          {
+            if (strncasecmp(savePtEntry->savePtName, RSTRING_PTR (param_savepointName), RSTRING_LEN(param_savepointName)) == 0)
+            {
+              /* Found it */
+              break;
+            }
+          }
+          /* Not found move on to the next one (if any) */
+          savePtEntry = savePtEntry->nextSavePtEntry;
+        }
+      }
+      else
+      {
+        rb_raise (rb_eRuntimeError, "Unable to rollback to a non-existent savepoint");
+      }
+      if (savePtEntry == NULL)
+      {
+        rb_raise (rb_eRuntimeError, "Savepoint %s does not exist", RSTRING_PTR (param_savepointName));
+      }
+    }
+    
+    ii_api_rollback (ii_conn, savePtEntry);
+
+  }
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return Qnil;
+}
+
+/* Free up the memory allocated for a savepoint
+ * input:
+ *    pointer to a II_SAVEPOINT_ENTRY structure
+ * output:
+ *    none
+ */
+void
+ii_free_savePtEntries (II_SAVEPOINT_ENTRY *savePtEntry)
+{
+  char function_name[] = "ii_free_savePtEntries";
+  II_PTR nextSavePtEntry = NULL;
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  nextSavePtEntry = savePtEntry->nextSavePtEntry;
+
+  if (ii_globals.debug || ii_globals.debug_transactions)
+    printf ("Releasing save point %s.\n", savePtEntry->savePtName);
+
+  ii_free((void **) &savePtEntry);
+
+  /* Follow the white rabbit */
+  if (nextSavePtEntry)
+  {
+    ii_free_savePtEntries (nextSavePtEntry);
+  }
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+}
+
+/*
+ * Document-method: savepoint
+ *
+ * call-seq:
+ *    Ingres.savepoint(savepoint)
+ *
+ * Create a savepoint using the supplied name. The savepoint can be used
+ * as a marker for performing partial rollbacks with rollback. When
+ * either commit or rollback (without specifying a savepoint name)
+ * is called, all savepoints are released.
+ *
+ * Example usage:
+ *
+ *  conn = Ingres.new()
+ *  conn.connect(:database => "demodb")
+ *  conn.execute("START TRANSACTION")
+ *  conn.execute("INSERT INTO user_profile VALUES
+ *    (1,'Test', 'User 1', 'user1@example.com','VLL', NULL)")
+ *  conn.savepoint("user1")
+ *  conn.execute("INSERT INTO user_profile VALUES
+ *    (2,'Test', 'User 2', 'user2@example.com','MAD', NULL)")
+ *  conn.execute("INSERT INTO user_profile VALUES
+ *    (3,'Test', 'User 3', 'user3@example.com','JFK', NULL)")
+ *  conn.rollback("user1")
+ *
+ *
+ */
+
+VALUE
+ii_savepoint (VALUE param_self, VALUE param_savepointName)
+{
+  char function_name[] = "ii_savepoint";
+  II_CONN *ii_conn = NULL;
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  Check_Type (param_savepointName, T_STRING);
+  Data_Get_Struct(param_self, II_CONN, ii_conn);
+
+  /* We cannot generate a save point if there is no transaction or if auto commit is in effect */
+  if (ii_conn->tranHandle == NULL)
+  {
+    rb_raise (rb_eRuntimeError, "Unable to generate a save point if there is no active transaction");
+  }
+  else
+  {
+    ii_api_savepoint (ii_conn, param_savepointName);
+  }
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return Qnil;
+}
+
+void
+startTransaction (VALUE param_self)
+{
+  VALUE sql_string;
+  IIAPI_WAITPARM waitParm = { -1 };
+  char function_name[] = "startTransaction";
+  VALUE params;
+  II_CONN *ii_conn = NULL;
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  Data_Get_Struct(param_self, II_CONN, ii_conn);
+
+  /* We cannot start a transaction if one is already in place */
+  if (ii_conn->tranHandle)
+  {
+    rb_raise (rb_eRuntimeError, "Unable to start a new transaction. COMMIT or ROLLBACK the existing transaction first");
+  }
+
+  /* turn off autocommit. The calling program is now */
+  /* responsible for transactions */
+  ii_conn->autocommit = FALSE;
+  ii_conn->tranHandle = NULL;
+
+  /* now issue a simple query to get a transaction handle */
+  /* FIXEME: consider adding a small, one entry table to make */
+  /* this a really short, small query */
+  sql_string = rb_str_new2 ("SELECT relid FROM iirelation WHERE relid='iirelation'");
+  ii_execute (1, &sql_string, param_self);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+}
+
+
+void
+ii_api_commit (II_CONN *ii_conn)
+{
+  IIAPI_COMMITPARM commitParm;
+  char function_name[] = "commit";
+  II_SAVEPOINT_ENTRY *tmpSavePtEntry; /* pointer to a savePtEntry chain that needs to be free'd up */
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  /* ii_api_commit the transaction */
+  commitParm.cm_genParm.gp_callback = NULL;
+  commitParm.cm_genParm.gp_closure = NULL;
+  commitParm.cm_tranHandle = ii_conn->tranHandle;
+
+  IIapi_commit (&commitParm);
+
+  ii_sync (&(commitParm.cm_genParm));
+
+  if (ii_globals.debug)
+    printf ("\nTransaction ii_api_commit status is ++%d++\n",
+            commitParm.cm_genParm.gp_status);
+  ii_checkError (&commitParm.cm_genParm);
+
+  /* Remove all save points */
+  if (ii_conn->savePtList)
+  {
+    tmpSavePtEntry = (II_SAVEPOINT_ENTRY *) ii_conn->savePtList;
+    ii_free_savePtEntries (tmpSavePtEntry);
+    ii_conn->savePtList = NULL;
+  }
+  /* now turn automatic transaction handling back on */
+  ii_conn->tranHandle = NULL;
+  ii_conn->autocommit = TRUE;
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+}
+
+
+void
+ii_api_rollback (II_CONN *ii_conn, II_SAVEPOINT_ENTRY *savePtEntry)
+{
+  IIAPI_ROLLBACKPARM rollbackParm;
+  II_SAVEPOINT_ENTRY *tmpSavePtEntry; /* pointer to a savePtEntry chain that needs to be free'd up */
+
+  char function_name[] = "ii_api_rollback";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+  
+  if (ii_conn->tranHandle)
+  {
+    rollbackParm.rb_tranHandle = ii_conn->tranHandle;
+    rollbackParm.rb_genParm.gp_callback = NULL;
+    rollbackParm.rb_genParm.gp_closure = NULL;
+    rollbackParm.rb_savePointHandle = savePtEntry ? savePtEntry->savePtHandle : NULL;
+
+    IIapi_rollback (&rollbackParm);
+
+    ii_sync (&(rollbackParm.rb_genParm));
+    ii_checkError (&rollbackParm.rb_genParm);
+
+    /*
+     * Remove successive savePtEntry records as they are no longer valid 
+     * If savePtEntry is NULL then we need to remove all savepoint entries
+     *
+     * For a given set of savepoints, created in the following order: 
+     *      A, B, C, D, E 
+     * Rolling back savepoint C causes D and E to become invalid
+    */
+    if (savePtEntry)
+    {
+      /* Remove any later/newer save points */
+      if (savePtEntry->nextSavePtEntry)
+      {
+        tmpSavePtEntry = savePtEntry->nextSavePtEntry;
+        ii_free_savePtEntries (tmpSavePtEntry);
+        savePtEntry->nextSavePtEntry = NULL;
+        ii_conn->lastSavePtEntry = savePtEntry;
+      }
+    }
+    else if (ii_conn->savePtList && savePtEntry == NULL)
+    {
+      /* remove all save points */
+      tmpSavePtEntry = (II_SAVEPOINT_ENTRY *) ii_conn->savePtList;
+      ii_free_savePtEntries (tmpSavePtEntry);
+      ii_conn->savePtList = NULL;
+    }
+
+    /* We can only set tranHandle to NULL if there are no more save points */
+    if (ii_conn->savePtList == NULL)
+    {
+      /* now turn automatic transaction handling back on */
+      ii_conn->tranHandle = NULL;
+      ii_conn->autocommit = TRUE;
+    }
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+}
+
+void
+ii_api_savepoint (II_CONN *ii_conn, VALUE savePtName)
+{
+  IIAPI_SAVEPTPARM	savePtParm;
+  II_SAVEPOINT_ENTRY *savePtEntry = NULL;
+  char function_name[] = "ii_api_savepoint";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  savePtParm.sp_genParm.gp_callback = NULL;
+  savePtParm.sp_genParm.gp_closure = NULL;
+  savePtParm.sp_tranHandle = ii_conn->tranHandle;
+  savePtParm.sp_savePoint = RSTRING_PTR(savePtName); 
+
+  if (ii_globals.debug || ii_globals.debug_transactions)
+    printf ("Creating savepoint %s\n", RSTRING_PTR(savePtName));
+  IIapi_savePoint( &savePtParm );
+  ii_sync (&(savePtParm.sp_genParm));
+
+  if (ii_globals.debug)
+    printf ("\nTransaction ii_api_savepoint status is ++%d++\n", savePtParm.sp_genParm.gp_status);
+  ii_checkError (&savePtParm.sp_genParm);
+
+  /* store the savepoint name and handle for issuing a rollback later on */
+  savePtEntry = (II_SAVEPOINT_ENTRY *) ii_allocate (1,sizeof(II_SAVEPOINT_ENTRY));
+  savePtEntry->savePtName = (char *) ii_allocate (RSTRING_LEN(savePtName), sizeof(char));
+  savePtEntry->savePtHandle = savePtParm.sp_savePointHandle; 
+  memcpy(savePtEntry->savePtName, RSTRING_PTR(savePtName), RSTRING_LEN(savePtName));
+  savePtEntry->nextSavePtEntry = NULL;
+
+  if (ii_conn->savePtList)
+  {
+    (ii_conn->lastSavePtEntry)->nextSavePtEntry = savePtEntry;
+  }
+  else
+  {
+    ii_conn->savePtList = (II_PTR)savePtEntry;
+  }
+  ii_conn->lastSavePtEntry = savePtEntry;
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+}
+
+
+II_PTR
+executeQuery (II_CONN *ii_conn, char *param_sqlText)
+{
+  IIAPI_QUERYPARM queryParm;
+  char function_name[] = "executeQuery";
+
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  /*
+   ** Call IIapi_query to execute statement.
+   */
+  queryParm.qy_connHandle = ii_conn->connHandle;
+  queryParm.qy_genParm.gp_callback = NULL;
+  queryParm.qy_genParm.gp_closure = NULL;
+  queryParm.qy_queryType = IIAPI_QT_QUERY;
+  queryParm.qy_queryText = param_sqlText;
+  queryParm.qy_parameters = FALSE;
+  queryParm.qy_tranHandle = ii_conn->tranHandle;
+  queryParm.qy_stmtHandle = NULL;
+#if defined(IIAPI_VERSION_6)
+  queryParm.qy_flags  = 0;
+#endif
+
+
+  IIapi_query (&queryParm);
+  ii_sync (&(queryParm.qy_genParm));
+
+  ii_conn->stmtHandle = queryParm.qy_stmtHandle;
+
+  if (ii_globals.debug)
+    printf ("%s: Query status is >>%d<<\n", function_name, queryParm.qy_genParm.gp_status);
+
+  if (ii_conn->tranHandle == NULL)
+    ii_conn->tranHandle = queryParm.qy_tranHandle;
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return queryParm.qy_stmtHandle;
+}
+
+
+/* char * getProcedureName(char *statement) */
+/* check to see if the query is for a procedure or not, if it is return the procedure name
+ *
+ * Procedure calls come in two forms either:
+ * execute procedure procname
+ * call procedure
+ *
+ */
+static char *
+getProcedureName (char *param_sqlText)
+{
+  int proc_len = 0;
+  char *start = NULL;
+  char *end_space = NULL;
+  char *end_term = NULL;
+  char *end_bracket = NULL;
+  char *procedureName = NULL;
+  char exec_proc[] = "{execute procedure";
+  char call_proc[] = "{call";
+  char function_name[] = "getProcedureName";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  if (strncmp (param_sqlText, exec_proc, strlen (exec_proc)) == 0)
+  {
+    start = param_sqlText + strlen (exec_proc);
+  }
+  else if (strncmp (param_sqlText, call_proc, strlen (call_proc)) == 0)
+  {
+    start = param_sqlText + strlen (call_proc);
+  }
+
+  if (start != NULL)
+  {
+    while (*start == ' ')  	/* skip over spaces after 'call' or 'procedure' */
+    {
+      start++;
+    }
+
+    /* look for a space, bracket or null terminator to determine end of */
+    /* the procedure name, end_term should never be NULL */
+    end_term = strchr (start, '}');
+    end_space = strchr (start, ' ');
+    end_bracket = strchr (start, '(');
+
+    if (end_term == NULL)
+    {
+      rb_raise (rb_eRuntimeError, "%s: Error! Call to procedure not terminated with a '}'. ", function_name);
+    }
+
+    if (end_space == NULL && end_bracket == NULL)
+    {
+      proc_len = end_term - start;
+    }
+    else if (end_space != NULL && end_bracket == NULL)
+    {
+      proc_len = end_space - start;
+    }
+    else if (end_space == NULL && end_bracket != NULL)
+    {
+      proc_len = end_bracket - start;
+    }
+    else if (end_space != NULL && end_bracket != NULL)
+    {
+      if (end_space > end_bracket)
+      {
+        proc_len = end_bracket - start;
+      }
+      else
+      {
+        proc_len = end_space - start;
+      }
+    }
+
+    procedureName = ALLOC_N (char, proc_len + 1);
+    memcpy (procedureName, start, proc_len);
+    procedureName[proc_len] = '\0';
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %s.\n", function_name, procedureName);
+  return procedureName;
+}
+
+
+/* static long ii_paramcount(char *statement) */
+/* ----------------------------------------------------------------------
+ * int php_ii_paramcount(char *statement TSRMLS_DC)
+ *
+ * Count the placeholders (?) parameters in the statement
+ * return -1 for error. 0 or number of question marks
+ *
+ * Thanks to ext/informix (based on php_intifx_preparse).
+ *
+ * ----------------------------------------------------------------------
+*/
+static long
+countParameters (char *statement)
+{
+  char *src = statement;
+  char *dst = statement;
+  int parameterCount = 0;
+  char ch;
+  char end_quote = '\0';
+  char function_name[] = "ii_paramcount";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  while ((ch = *src++) != '\0')
+  {
+    if (ch == end_quote)
+    {
+      end_quote = '\0';
+    }
+    else if (end_quote != '\0')
+    {
+      *dst++ = ch;
+      continue;
+    }
+    else if (ch == '\'' || ch == '\"')
+    {
+      end_quote = ch;
+    }
+    if (ch == '?')
+    {
+      /* X/Open standard       */
+      *dst++ = '?';
+      parameterCount++;
+    }
+    else
+    {
+      *dst++ = ch;
+      continue;
+    }
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, parameterCount);
+  return (parameterCount);
+}
+
+
+int
+getIIParameter (RUBY_PARAMETER * parameter, VALUE rubyParams, int iiParam,
+                int isProcedureCall)
+{
+  int returnValue = 0;
+  char function_name[] = "getIIParameter";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  parameter->vkey =
+    rb_ary_entry (rubyParams, RubyParamOffset (iiParam, isProcedureCall) + 0);
+  parameter->vtype =
+    rb_ary_entry (rubyParams, RubyParamOffset (iiParam, isProcedureCall) +
+                  isProcedureCall);
+  parameter->vvalue =
+    rb_ary_entry (rubyParams, RubyParamOffset (iiParam, isProcedureCall) +
+                  isProcedureCall + 1);
+  if (ii_globals.debug)
+    printf
+    ("%s: Completed calls to rb_ary_entry, param = %i, vkey = %s, vtype = %s, vvalue = %s.\n",
+     function_name, iiParam, RSTRING_PTR (parameter->vkey),
+     RSTRING_PTR (parameter->vtype), RSTRING_PTR (parameter->vvalue));
+
+  if (!isProcedureCall)
+    parameter->vkey = Qnil;
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+setDescriptor (IIAPI_DESCRIPTOR * sd_descriptor, RUBY_PARAMETER * parameter,
+               int isProcedureCall, IIAPI_DT_ID ds_dataType,
+               II_UINT2 ds_length, II_INT2 ds_precision, II_INT2 ds_scale)
+{
+  int returnValue = 0;
+  char function_name[] = "setDescriptorCommon";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  if (!isProcedureCall)
+  {
+    sd_descriptor->ds_columnName = NULL;
+    sd_descriptor->ds_columnType = IIAPI_COL_QPARM;
+  }
+  else
+  {
+    sd_descriptor->ds_columnType = IIAPI_COL_PROCPARM;
+    Check_Type (parameter->vkey, T_STRING);
+    sd_descriptor->ds_columnName = RSTRING_PTR (parameter->vkey);
+  }
+  sd_descriptor->ds_nullable = FALSE;
+  sd_descriptor->ds_dataType = ds_dataType;
+  sd_descriptor->ds_length = ds_length;
+  sd_descriptor->ds_precision = ds_precision;
+  sd_descriptor->ds_scale = ds_scale;
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+setLongByteDescriptor (IIAPI_DESCRIPTOR * sd_descriptor, RUBY_PARAMETER * parameter, int isProcedureCall, II_LONG lobSegmentSize)
+{
+  int returnValue = 0;
+  char function_name[] = "setLongByteDescriptor";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  Check_Type (parameter->vvalue, T_STRING);
+  setDescriptor (sd_descriptor, parameter, isProcedureCall, IIAPI_LBYTE_TYPE, (II_UINT2) lobSegmentSize, 0, 0);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+setCharDescriptor (IIAPI_DESCRIPTOR * sd_descriptor,
+                   RUBY_PARAMETER * parameter, int isProcedureCall)
+{
+  int returnValue = 0;
+  char function_name[] = "setCharDescriptor";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  Check_Type (parameter->vvalue, T_STRING);
+  setDescriptor (sd_descriptor, parameter, isProcedureCall, IIAPI_CHA_TYPE,
+                 (II_UINT2) RSTRING_LEN (parameter->vvalue), 0, 0);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+setVarcharDescriptor (IIAPI_DESCRIPTOR * sd_descriptor,
+                      RUBY_PARAMETER * parameter, int isProcedureCall)
+{
+  int returnValue = 0;
+  char function_name[] = "setVarcharDescriptor";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  Check_Type (parameter->vvalue, T_STRING);
+  setDescriptor (sd_descriptor, parameter, isProcedureCall, IIAPI_VCH_TYPE,
+                 (II_UINT2) (RSTRING_LEN (parameter->vvalue) + 2), 0, 0);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+setDecimalDescriptor (IIAPI_DESCRIPTOR * sd_descriptor,
+                      RUBY_PARAMETER * parameter, int isProcedureCall)
+{
+  int returnValue = 0;
+  char function_name[] = "setDecimalDescriptor";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  Check_Type (parameter->vvalue, T_STRING);
+  setDescriptor (sd_descriptor, parameter, isProcedureCall, IIAPI_DEC_TYPE,
+                 (II_UINT2) DECIMAL_BUFFER_LEN, DECIMAL_PRECISION, DECIMAL_SCALE);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+setFloatDescriptor (IIAPI_DESCRIPTOR * sd_descriptor,
+                    RUBY_PARAMETER * parameter, int isProcedureCall)
+{
+  int returnValue = 0;
+  char function_name[] = "setFloatDescriptor";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  Check_Type (parameter->vvalue, T_FLOAT);
+  setDescriptor (sd_descriptor, parameter, isProcedureCall, IIAPI_FLT_TYPE,
+                 (II_UINT2) sizeof (double), DOUBLE_PRECISION, DOUBLE_SCALE);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+setLongVarcharDescriptor (IIAPI_DESCRIPTOR * sd_descriptor, RUBY_PARAMETER * parameter, int isProcedureCall, II_LONG lobSegmentSize)
+{
+  int returnValue = 0;
+  char function_name[] = "setLongVarcharDescriptor";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  Check_Type (parameter->vvalue, T_STRING);
+  setDescriptor (sd_descriptor, parameter, isProcedureCall, IIAPI_VCH_TYPE, (II_UINT2) lobSegmentSize, 0, 0);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+setIntegerDescriptor (IIAPI_DESCRIPTOR * sd_descriptor,
+                      RUBY_PARAMETER * parameter, int isProcedureCall)
+{
+  int returnValue = 0;
+  char function_name[] = "setIntegerDescriptor";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  Check_Type (parameter->vvalue, T_FIXNUM);
+  setDescriptor (sd_descriptor, parameter, isProcedureCall, IIAPI_INT_TYPE,
+                 (II_UINT2) sizeof (long), 0, 0);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+setNCharDescriptor (IIAPI_DESCRIPTOR * sd_descriptor,
+                    RUBY_PARAMETER * parameter, int isProcedureCall)
+{
+  int returnValue = 0;
+  long valueLen = RSTRING_LEN (parameter->vvalue);
+  char *valuePtr = RSTRING_PTR (parameter->vvalue);
+  long ncharLen = valueLen * sizeof (UCS2);
+  char *nchar = ALLOC_N (char, ncharLen + sizeof (UCS2));
+  char function_name[] = "setNCharDescriptor";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  Check_Type (parameter->vvalue, T_STRING);
+
+  if (utf8_to_utf16
+      (valuePtr, valuePtr + valueLen, (UCS2 *) nchar,
+       (UCS2 *) (nchar + ncharLen), &ncharLen))
+    rb_raise (rb_eRuntimeError,
+              "Error! Failed to transcode %s (n) to utf16.\n", valuePtr);
+
+  /* Allow a null at the end */
+  setDescriptor (sd_descriptor, parameter, isProcedureCall, IIAPI_NCHA_TYPE,
+                 (II_UINT2) (ncharLen * sizeof (UCS2)), 0, 0);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+setNVarcharDescriptor (IIAPI_DESCRIPTOR * sd_descriptor,
+                       RUBY_PARAMETER * parameter, int isProcedureCall)
+{
+  int returnValue = 0;
+  long valueLen = RSTRING_LEN (parameter->vvalue);
+  char *valuePtr = RSTRING_PTR (parameter->vvalue);
+  long nvarcharlen = valueLen * sizeof (UCS2);
+  char *nvarchar =
+    ALLOC_N (char, 2 + nvarcharlen + sizeof (UCS2));
+  char function_name[] = "setNVarcharDescriptor";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  Check_Type (parameter->vvalue, T_STRING);
+  nvarcharlen = valueLen * sizeof (UCS2);
+  nvarchar = ALLOC_N (char, 2 + nvarcharlen + sizeof (UCS2));
+  if (utf8_to_utf16 (valuePtr, valuePtr + valueLen, (UCS2 *) nvarchar,
+                     (UCS2 *) (nvarchar + nvarcharlen), &nvarcharlen))
+    rb_raise (rb_eRuntimeError,
+              "Error! Failed to transcode %s (N) to utf16.\n", valuePtr);
+
+  /* The first two bytes will contain the length */
+  setDescriptor (sd_descriptor, parameter, isProcedureCall, IIAPI_NVCH_TYPE,
+                 (II_UINT2) (2 + (nvarcharlen * sizeof (UCS2))), 0, 0);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+setParameterDescriptor (IIAPI_DESCRIPTOR * sd_descriptor, RUBY_PARAMETER * parameter, int isProcedureCall, II_LONG lobSegmentSize)
+{
+  int returnValue = 0;
+  char function_name[] = "setParameterDescriptor";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  Check_Type (parameter->vtype, T_STRING);
+  if (RSTRING_LEN (parameter->vtype) != 1)
+  {
+    rb_raise (rb_eRuntimeError, "Paramter type (%s) length (%i) != 1.",
+              RSTRING_PTR (parameter->vtype),
+              RSTRING_LEN (parameter->vtype));
+  }
+  if (ii_globals.debug)
+    printf ("%s: Type is %c.\n", function_name,
+            (char) *(RSTRING_PTR (parameter->vtype)));
+
+  switch ((char) *(RSTRING_PTR (parameter->vtype)))
+  {
+    case RUBY_LONG_BYTE_PARAMETER:
+      setLongByteDescriptor (sd_descriptor, parameter, isProcedureCall, lobSegmentSize);
+      break;
+
+    case RUBY_BYTE_PARAMETER:
+    case RUBY_CHAR_PARAMETER:
+    case RUBY_DATE_PARAMETER:
+    case RUBY_TEXT_PARAMETER:
+      setCharDescriptor (sd_descriptor, parameter, isProcedureCall);
+      break;
+
+    case RUBY_DECIMAL_PARAMETER:
+      setDecimalDescriptor (sd_descriptor, parameter, isProcedureCall);
+      break;
+
+    case RUBY_FLOAT_PARAMETER:
+      setFloatDescriptor (sd_descriptor, parameter, isProcedureCall);
+      break;
+
+    case RUBY_LONG_TEXT_PARAMETER:
+    case RUBY_LONG_VARCHAR_PARAMETER:
+      setLongVarcharDescriptor (sd_descriptor, parameter, isProcedureCall, lobSegmentSize);
+      break;
+
+    case RUBY_INTEGER_PARAMETER:
+      setIntegerDescriptor (sd_descriptor, parameter, isProcedureCall);
+      break;
+
+    case RUBY_NCHAR_PARAMETER:
+      setNCharDescriptor (sd_descriptor, parameter, isProcedureCall);
+      break;
+
+    case RUBY_NVARCHAR_PARAMETER:
+      setNVarcharDescriptor (sd_descriptor, parameter, isProcedureCall);
+      break;
+
+    case RUBY_VARCHAR_PARAMETER:
+      setVarcharDescriptor (sd_descriptor, parameter, isProcedureCall);
+      break;
+
+    default:
+      if (ii_globals.debug)
+        printf ("%s: Not set ds_length for type = %c.\n",
+                function_name, (char) *(RSTRING_PTR (parameter->vtype)));
+      break;
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+setProcedureNameDescriptor (IIAPI_DESCRIPTOR * sd_descriptor,
+                            char *procedureName)
+{
+  int returnValue = 0;
+  char function_name[] = "setProcedureNameDescriptor";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  /* setup the first parameter as the procedure name */
+  sd_descriptor->ds_dataType = IIAPI_CHA_TYPE;
+  sd_descriptor->ds_length = strlen (procedureName);
+  sd_descriptor->ds_nullable = FALSE;
+  sd_descriptor->ds_precision = 0;
+  sd_descriptor->ds_scale = 0;
+  sd_descriptor->ds_columnType = IIAPI_COL_SVCPARM;
+  sd_descriptor->ds_columnName = NULL;
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+setDescriptorParms (IIAPI_SETDESCRPARM * setDescrParm, int paramCount, int isProcedureCall, II_CONN *ii_conn)
+{
+  int returnValue = 0;
+  char function_name[] = "setDescriptorParms";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  /* if we are sending params then we need to describe them into to Ingres */
+  /* if no parameters have been provided to a procedure call there is always 1 */
+  /* parameter, the procedure name */
+  setDescrParm->sd_genParm.gp_callback = NULL;
+  setDescrParm->sd_genParm.gp_closure = NULL;
+  setDescrParm->sd_stmtHandle = ii_conn->stmtHandle;
+  setDescrParm->sd_descriptorCount = paramCount + isProcedureCall;
+  setDescrParm->sd_descriptor =
+    ALLOC_N (IIAPI_DESCRIPTOR, setDescrParm->sd_descriptorCount);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+ii_putParamter (II_CONN *ii_conn, II_BOOL moreSegments, II_BOOL dv_null, II_UINT2 dv_length, II_PTR dv_value)
+{
+  IIAPI_PUTPARMPARM putParmParm;
+  IIAPI_DATAVALUE dataValue[1];
+  int returnValue = 0;
+  char function_name[] = "ii_putParamter";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  dataValue[0].dv_null = dv_null;
+  dataValue[0].dv_length = dv_length;
+  dataValue[0].dv_value = dv_value;
+
+  putParmParm.pp_moreSegments = moreSegments;
+  putParmParm.pp_parmData = dataValue;
+  putParmParm.pp_genParm.gp_callback = NULL;
+  putParmParm.pp_genParm.gp_closure = NULL;
+  putParmParm.pp_stmtHandle = ii_conn->stmtHandle;
+  putParmParm.pp_parmCount = 1;
+  IIapi_putParms (&putParmParm);
+  ii_sync (&(putParmParm.pp_genParm));
+
+  if (ii_checkError (&(putParmParm.pp_genParm)))
+    rb_raise (rb_eRuntimeError, "Error putting a parameter.");
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+putProcedureNameParameter (II_CONN *ii_conn, char *procedureName)
+{
+  int returnValue = 0;
+  char function_name[] = "putProcedureNameParameter";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  returnValue =
+    ii_putParamter (ii_conn, 0, FALSE, (II_UINT2) strlen (procedureName), procedureName);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+putRubyFixNumParameter (II_CONN *ii_conn, RUBY_PARAMETER * parameter)
+{
+  long number = NUM2INT (parameter->vvalue);
+  int returnValue = 0;
+  char function_name[] = "putRubyFixNumParameter";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  returnValue = ii_putParamter (ii_conn, 0, FALSE, sizeof (number), &number);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+putRubyFloatParameter (II_CONN *ii_conn, RUBY_PARAMETER * parameter)
+{
+  double number = NUM2DBL (parameter->vvalue);
+  int returnValue = 0;
+  char function_name[] = "putRubyFloatParameter";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  returnValue = ii_putParamter (ii_conn, 0, FALSE, sizeof (number), &number);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+putNVarcharParameter (II_CONN *ii_conn, RUBY_PARAMETER * parameter)
+{
+  char *nvarchar = NULL;
+  char *value_ptr = RSTRING_PTR (parameter->vvalue);
+  int value_len = RSTRING_LEN (parameter->vvalue);
+  long ucs2strLen = value_len * sizeof (UCS2);
+  char *ucs2str = ALLOC_N (char, ucs2strLen + 2 + sizeof (UCS2));
+  int returnValue = 0;
+  char function_name[] = "putNVarcharParameter";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  if (utf8_to_utf16 (value_ptr, value_ptr + value_len, (UCS2 *) ucs2str,
+                     (UCS2 *) (ucs2str + ucs2strLen), &ucs2strLen))
+    rb_raise (rb_eRuntimeError,
+              "Error! Failed to transcode %s (N) to utf16.\n", value_ptr);
+  ucs2strLen *= sizeof (UCS2);
+
+  /* copy the data to a new buffer then set the size of the string in
+   * chars at the begining of the buffer
+   * Note: allocate 2 bytes at the start and a null char at the end
+   * of the new buffer
+   */
+  nvarchar = ALLOC_N (char, 2 + ucs2strLen + sizeof (UCS2));
+  memcpy (nvarchar + 2, ucs2str, ucs2strLen);
+  *((II_INT2 *) (nvarchar)) = (II_INT2) ucs2strLen / sizeof (UCS2);
+
+  returnValue = ii_putParamter (ii_conn, 0, FALSE, (II_UINT2) (ucs2strLen + 2), nvarchar);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+putNCharParameter (II_CONN *ii_conn, RUBY_PARAMETER * parameter)
+{
+  char *value_ptr = RSTRING_PTR (parameter->vvalue);
+  int value_len = RSTRING_LEN (parameter->vvalue);
+  long ucs2strlen = value_len * sizeof (UCS2);
+  char *nchar = ALLOC_N (char, ucs2strlen + sizeof (UCS2));
+  int returnValue = 0;
+  char function_name[] = "putNCharParameter";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  if (utf8_to_utf16 (value_ptr, value_ptr + value_len, (UCS2 *) nchar,
+                     (UCS2 *) (nchar + ucs2strlen), &ucs2strlen))
+    rb_raise (rb_eRuntimeError,
+              "Error! Failed to transcode %s (n) to utf16.\n", value_ptr);
+  ucs2strlen *= sizeof (UCS2);
+
+  returnValue = ii_putParamter (ii_conn, 0, FALSE, (II_UINT2) ucs2strlen, nchar);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+putVarcharParameter (II_CONN *ii_conn, RUBY_PARAMETER * parameter)
+{
+  char *value_ptr = RSTRING_PTR (parameter->vvalue);
+  int value_len = RSTRING_LEN (parameter->vvalue);
+  char *varchar = ALLOC_N (char, value_len + 2 + sizeof (char));
+  int returnValue = 0;
+  char function_name[] = "putVarcharParameter";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  /* copy the data to a new buffer then set the size
+   * of the string at the begining of the buffer
+   */
+  memcpy (varchar + 2, value_ptr, value_len);
+  /* set the 1st 2 bytes as the length of the string */
+  *((II_INT2 *) (varchar)) = (II_INT2) value_len;
+
+  returnValue = ii_putParamter (ii_conn, 0, FALSE, (II_UINT2) (value_len + 2), varchar);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+int
+putDecimalParameter (II_CONN *ii_conn, RUBY_PARAMETER * parameter)
+{
+  IIAPI_FORMATPARM formatParm;
+  char *value_ptr = RSTRING_PTR (parameter->vvalue);
+  int value_len = RSTRING_LEN (parameter->vvalue);
+  char decimal[DECIMAL_BUFFER_LEN + 1] = "";
+  int returnValue = 0;
+  char function_name[] = "putDecimalParameter";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  formatParm.fd_envHandle = ii_globals.envHandle;
+  formatParm.fd_srcDesc.ds_dataType = IIAPI_CHA_TYPE;
+  formatParm.fd_srcDesc.ds_nullable = FALSE;
+  formatParm.fd_srcDesc.ds_length = value_len;
+  formatParm.fd_srcDesc.ds_precision = 0;
+  formatParm.fd_srcDesc.ds_scale = 0;
+  formatParm.fd_srcDesc.ds_columnType = IIAPI_COL_QPARM;
+  formatParm.fd_srcDesc.ds_columnName = NULL;
+  formatParm.fd_srcValue.dv_null = FALSE;
+  formatParm.fd_srcValue.dv_length = value_len;
+  formatParm.fd_srcValue.dv_value = value_ptr;
+  formatParm.fd_dstDesc.ds_dataType = IIAPI_DEC_TYPE;
+  formatParm.fd_dstDesc.ds_nullable = FALSE;
+  formatParm.fd_dstDesc.ds_length = DECIMAL_BUFFER_LEN;
+  formatParm.fd_dstDesc.ds_precision = DECIMAL_PRECISION;
+  formatParm.fd_dstDesc.ds_scale = DECIMAL_SCALE;
+  formatParm.fd_dstDesc.ds_columnType = IIAPI_COL_QPARM;
+  formatParm.fd_dstDesc.ds_columnName = NULL;
+  formatParm.fd_dstValue.dv_null = FALSE;
+  formatParm.fd_dstValue.dv_length = DECIMAL_BUFFER_LEN;
+  formatParm.fd_dstValue.dv_value = decimal;
+  IIapi_formatData (&formatParm);
+  if (formatParm.fd_status != IIAPI_ST_SUCCESS)
+  {
+    rb_raise (rb_eRuntimeError,
+              "Error occured converting to DECIMAL. Value supplied was %s",
+              value_ptr);
+  }
+
+  returnValue = ii_putParamter (ii_conn, 0, FALSE, formatParm.fd_dstValue.dv_length, decimal);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+putLOBParameter (II_CONN *ii_conn, RUBY_PARAMETER * parameter)
+{
+  IIAPI_FORMATPARM formatParm;
+  II_BOOL moreSegments = 0;
+  char *segment = ALLOC_N (char, ii_conn->lobSegmentSize + 2);
+  char *value_ptr = RSTRING_PTR (parameter->vvalue);
+  long value_len = RSTRING_LEN (parameter->vvalue);
+  long segment_length = 0;
+  int returnValue = 0;
+  char function_name[] = "putLOBParameter";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  do
+  {
+    memset (segment, 0, ii_conn->lobSegmentSize + 2);
+
+    if (value_len <= ii_conn->lobSegmentSize)
+    {
+      moreSegments = 0;
+      segment_length = value_len;
+    }
+    else
+    {
+      moreSegments = 1;
+      segment_length = ii_conn->lobSegmentSize;
+    }
+    /* copy the segment data to a buffer then set the size
+     * of the segment at the begining of the buffer
+     */
+    memcpy (segment + 2, value_ptr, segment_length);
+    /* set the 1st 2 bytes as the length of the segment */
+    *((II_UINT2 *) segment) = (II_UINT2) segment_length;
+
+    returnValue =
+      ii_putParamter (ii_conn, moreSegments, FALSE, (II_UINT2) (segment_length + 2), segment);
+
+    /* bump pointer for data by segment_length */
+    value_ptr += segment_length;
+    value_len -= segment_length;
+  }
+  while (value_len);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+putCharParameter (II_CONN *ii_conn, RUBY_PARAMETER * parameter)
+{
+  int returnValue = 0;
+  char function_name[] = "putCharParameter";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  returnValue =
+    ii_putParamter (ii_conn, 0, FALSE, (II_UINT2) RSTRING_LEN (parameter->vvalue),
+                    RSTRING_PTR (parameter->vvalue));
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+putNullParameter (II_CONN *ii_conn, RUBY_PARAMETER * parameter)
+{
+  int returnValue = 0;
+  char function_name[] = "putNullParameter";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  returnValue =
+    ii_putParamter (ii_conn, 0, TRUE, (II_UINT2) RSTRING_LEN (parameter->vvalue),
+                    RSTRING_PTR (parameter->vvalue));
+
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+int
+putParameter (II_CONN *ii_conn, RUBY_PARAMETER * parameter)
+{
+  int returnValue = 0;
+  char function_name[] = "putParameter";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  switch (TYPE (parameter->vvalue))
+  {
+    case T_FIXNUM:
+      returnValue = putRubyFixNumParameter (ii_conn, parameter);
+      break;
+
+    case T_FLOAT:
+      returnValue = putRubyFloatParameter (ii_conn, parameter);
+      break;
+
+    case T_STRING:
+      switch ((char) *(RSTRING_PTR (parameter->vtype)))
+      {
+        case RUBY_NVARCHAR_PARAMETER:
+          returnValue = putNVarcharParameter (ii_conn, parameter);
+          break;
+
+        case RUBY_NCHAR_PARAMETER:
+          returnValue = putNCharParameter (ii_conn, parameter);
+          break;
+
+        case RUBY_VARCHAR_PARAMETER:
+          returnValue = putVarcharParameter (ii_conn, parameter);
+          break;
+
+        case RUBY_DECIMAL_PARAMETER:
+          returnValue = putDecimalParameter (ii_conn, parameter);
+          break;
+
+        case RUBY_LONG_BYTE_PARAMETER:
+        case RUBY_LONG_TEXT_PARAMETER:
+        case RUBY_LONG_VARCHAR_PARAMETER:
+          returnValue = putLOBParameter (ii_conn, parameter);
+          break;
+
+        case RUBY_INTEGER_PARAMETER:
+        case RUBY_BYTE_PARAMETER:
+        case RUBY_CHAR_PARAMETER:
+        case RUBY_DATE_PARAMETER:
+        case RUBY_TEXT_PARAMETER:
+        case RUBY_FLOAT_PARAMETER:
+          returnValue = putCharParameter (ii_conn, parameter);
+          break;
+
+        default:		/* everything else */
+          rb_raise (rb_eRuntimeError,
+                    "Error putting a parameter of unknown type");
+          break;
+      }
+      break;
+
+    case T_NIL:		/* TODO need to check this */
+      returnValue = putNullParameter (ii_conn, parameter);
+      break;
+
+    default:
+      rb_raise (rb_eRuntimeError,
+                "Error putting a parameter of unknown type");
+      break;
+  }
+  if (ii_globals.debug)
+    printf ("Exiting %s, returning %i.\n", function_name, returnValue);
+  return (returnValue);
+}
+
+
+
+/* static short ii_bind_params (VALUE param_params, char *procname, long paramCount,II_LONG lobSegmentSize) */
+/* Binds and sends data for parameters passed via param_params */
+/* param_params is expected to be a repeating list of n * [key, type, value] */
+static short
+ii_bind_params (int param_argc, VALUE param_params, char *procname, long paramCount, II_CONN *ii_conn)
+{
+  IIAPI_SETDESCRPARM setDescrParm;
+  IIAPI_PUTPARMPARM putParmParm;
+  int param = 0;
+  short isProcedureCall = 0;
+  char function_name[] = "ii_bind_params";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  if (ii_globals.debug)
+    printf ("%s: argc = %i, paramCount = %li, procedure name = %s.\n", function_name, param_argc, paramCount, procname);
+
+  isProcedureCall = (procname != NULL) ? 1 : 0;
+  setDescriptorParms (&setDescrParm, paramCount, isProcedureCall, ii_conn);
+
+  if (isProcedureCall)
+    setProcedureNameDescriptor (&(setDescrParm.sd_descriptor[0]), procname);
+
+  /* extract the paramtypes */
+  for (param = isProcedureCall; param < setDescrParm.sd_descriptorCount; param++)
+  {
+    RUBY_PARAMETER parameter;
+
+    if (ii_globals.debug)
+      printf ("%s: At start of loop for param = %i.\n", function_name, param);
+
+    getIIParameter (&parameter, param_params, param, isProcedureCall);
+    setParameterDescriptor (&(setDescrParm.sd_descriptor[param]), &parameter, isProcedureCall, ii_conn->lobSegmentSize);
+  }
+
+  if (ii_globals.debug)
+    printf ("%s: About to set parameter descriptors.\n", function_name);
+
+  IIapi_setDescriptor (&setDescrParm);
+
+  if (ii_checkError (&setDescrParm.sd_genParm))
+    rb_raise (rb_eRuntimeError, "Failed to set parameter descriptors.");
+
+  if (ii_globals.debug)
+    printf ("%s: About to put parameters.\n", function_name);
+
+  if (isProcedureCall)
+    putProcedureNameParameter (ii_conn, procname);
+
+  for (param = isProcedureCall; param < setDescrParm.sd_descriptorCount; param++)
+  {
+    RUBY_PARAMETER parameter;
+    getIIParameter (&parameter, param_params, param, isProcedureCall);
+    putParameter (ii_conn, &parameter);
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return 0;
+}
+
+
+char *
+convertParamMarkers (char *param_sqlText, long param_count)
+{
+  /* allow for space either side and a null */
+  char *new_statement = (char *) ALLOC_N (char, strlen (param_sqlText) + (param_count * 3) + 1);
+  char function_name[] = "convertParamMarkers";
+  int i = 0, j = 0;
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  for (i = 0; i < strlen (param_sqlText); i++)
+  {
+    if (param_sqlText[i] == '?')
+    {
+      /* check for space before '?' */
+      /* if there is no space before the '~V' */
+      /* ingres will error with "Invalid operator '~V'" */
+      if (param_sqlText[i - 1] != ' ')
+        new_statement[j++] = ' ';
+      new_statement[j++] = '~';
+      new_statement[j++] = 'V';
+      /* check for space before '?' */
+      /* if there is no space after the '~V' */
+      /* ingres will error with "Invalid operator '~V'" */
+      if (param_sqlText[i + 1] != ' ')
+        new_statement[j++] = ' ';
+    }
+    else
+      new_statement[j++] = param_sqlText[i];
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return new_statement;
+}
+
+II_PTR ii_api_query (II_CONN *ii_conn, char *param_sqlText, int param_argc, VALUE param_params)
+{
+  IIAPI_QUERYPARM queryParm;
+  char function_name[] = "ii_api_query";
+  char *procedureName = getProcedureName (param_sqlText);
+  char *statement = NULL;
+  long paramCount = countParameters (param_sqlText);
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  /*
+   ** Call IIapi_query to execute statement.
+   */
+
+  if (procedureName == NULL)
+  {
+    statement = ((paramCount == 0) ?  (param_sqlText) : (convertParamMarkers (param_sqlText, paramCount)));
+  }
+  queryParm.qy_connHandle = ii_conn->connHandle;
+  queryParm.qy_genParm.gp_callback = NULL;
+  queryParm.qy_genParm.gp_closure = NULL;
+  queryParm.qy_queryType = ((procedureName != NULL) ? IIAPI_QT_EXEC_PROCEDURE : IIAPI_QT_QUERY);
+  queryParm.qy_queryText = ((procedureName == NULL) ? statement : NULL);
+  queryParm.qy_parameters = ((param_argc > 0) ? TRUE : FALSE);
+  queryParm.qy_tranHandle = ii_conn->tranHandle;
+  queryParm.qy_stmtHandle = NULL;
+#if defined(IIAPI_VERSION_6)
+  queryParm.qy_flags  = 0;
+#endif
+
+  IIapi_query (&queryParm);
+  ii_sync (&(queryParm.qy_genParm));
+  ii_conn->stmtHandle = queryParm.qy_stmtHandle;
+
+  if (param_argc > 0 && ii_bind_params (param_argc, param_params, procedureName, paramCount, ii_conn))
+  {
+    rb_raise (rb_eRuntimeError, "Error binding parameters.");
+  }
+
+  if (ii_globals.debug)
+    printf ("%s: Query status is >>%d<<\n", function_name, queryParm.qy_genParm.gp_status);
+
+  if (ii_conn->tranHandle == NULL)
+    ii_conn->tranHandle = queryParm.qy_tranHandle;
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return queryParm.qy_stmtHandle;
+}
+
+
+void
+ii_api_get_metadata (II_CONN * ii_conn, IIAPI_GETDESCRPARM * param_descrParm)
+{
+  int i;
+  char function_name[] = "ii_api_get_metadata";
+  VALUE data_type = (VALUE) FALSE;
+  VALUE column_name = (VALUE) FALSE;
+  VALUE ret_val = (VALUE) FALSE;
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  /* Iterate through each column loading the name and type in to global arrays */
+  for (i = 0; i < param_descrParm->gd_descriptorCount; i++)
+  {
+    ret_val = rb_ary_push (ii_conn->r_data_types, rb_str_new2 (getIngresDataTypeAsString (param_descrParm->gd_descriptor[i].ds_dataType)));
+    rb_ary_push (ii_conn->r_column_names, rb_str_new2 (param_descrParm->gd_descriptor[i].ds_columnName));
+  }
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+}
+
+
+void
+ii_api_getDescriptors (II_CONN *ii_conn, IIAPI_GETDESCRPARM * param_descrParm)
+{
+  char function_name[] = "ii_api_getDescriptors";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  param_descrParm->gd_genParm.gp_callback = NULL;
+  param_descrParm->gd_genParm.gp_closure = NULL;
+  param_descrParm->gd_stmtHandle = ii_conn->stmtHandle;
+  param_descrParm->gd_descriptorCount = 0;
+  param_descrParm->gd_descriptor = NULL;
+
+  IIapi_getDescriptor (param_descrParm);
+
+  ii_sync (&(param_descrParm->gd_genParm));
+
+  if (ii_globals.debug)
+    printf ("%s: GetDescriptor status is **%d**", function_name, param_descrParm->gd_genParm.gp_status);
+
+  if (ii_checkError (&(param_descrParm->gd_genParm)))
+  {
+    ii_api_query_close (ii_conn);
+    ii_api_rollback (ii_conn, NULL);
+    rb_raise (rb_eRuntimeError, "Error! Failed while getting Descriptors. ");
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+}
+
+
+void
+ii_api_query_close (II_CONN *ii_conn)
+{
+  IIAPI_CLOSEPARM closeParm;
+  char function_name[] = "ii_api_query_close";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  closeParm.cl_genParm.gp_callback = NULL;
+  closeParm.cl_genParm.gp_closure = NULL;
+  closeParm.cl_stmtHandle = ii_conn->stmtHandle;
+
+  IIapi_close (&closeParm);
+
+  ii_sync (&(closeParm.cl_genParm));
+
+  if (ii_globals.debug)
+    printf ("%s: closeParm status is >>%d<<", function_name,
+            closeParm.cl_genParm.gp_status);
+  ii_checkError (&closeParm.cl_genParm);
+
+  ii_conn->stmtHandle = NULL;
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+}
+
+
+II_LONG
+getRowsAffected (II_CONN *ii_conn)
+{
+  IIAPI_GETQINFOPARM getQInfoParm;
+  char function_name[] = "getRowsAffected";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  getQInfoParm.gq_genParm.gp_callback = NULL;
+  getQInfoParm.gq_genParm.gp_closure = NULL;
+  getQInfoParm.gq_stmtHandle = ii_conn->stmtHandle;
+
+  IIapi_getQueryInfo (&getQInfoParm);
+
+  ii_sync (&(getQInfoParm.gq_genParm));
+
+  if (ii_globals.debug)
+    printf ("%s: GetQueryInfo status is >>%d<<", function_name,
+            getQInfoParm.gq_genParm.gp_status);
+  ii_checkError (&getQInfoParm.gq_genParm);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return (II_LONG) getQInfoParm.gq_rowCount;
+}
+
+
+VALUE
+processDateField (IIAPI_DATAVALUE * param_columnData, int param_dataType)
+{
+  VALUE returnValue;
+  IIAPI_CONVERTPARM convertParm;
+  IIAPI_FORMATPARM formatParm;
+  int dateStrLen = 260;
+  char *dateStr = NULL;
+  char function_name[] = "processDateField";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  dateStr = ALLOC_N (char, dateStrLen + 1);
+
+  if (ii_globals.debug)
+    printf ("%s: Found a DATE or TIME field of type %d >>%s<<\n", function_name,
+            param_dataType, (char *)(param_columnData->dv_value));
+
+  formatParm.fd_envHandle = ii_globals.envHandle;
+  formatParm.fd_srcDesc.ds_dataType = param_dataType;
+  formatParm.fd_srcDesc.ds_nullable = FALSE;
+  formatParm.fd_srcDesc.ds_length = param_columnData->dv_length;
+  formatParm.fd_srcDesc.ds_precision = 0;
+  formatParm.fd_srcDesc.ds_scale = 0;
+  formatParm.fd_srcDesc.ds_columnType = IIAPI_COL_QPARM;
+  formatParm.fd_srcDesc.ds_columnName = NULL;
+
+  formatParm.fd_srcValue.dv_null = FALSE;
+  formatParm.fd_srcValue.dv_length = param_columnData->dv_length;
+  formatParm.fd_srcValue.dv_value = param_columnData->dv_value;
+
+  formatParm.fd_dstDesc.ds_dataType = IIAPI_VCH_TYPE;
+  formatParm.fd_dstDesc.ds_nullable = FALSE;
+  formatParm.fd_dstDesc.ds_length = dateStrLen;
+  formatParm.fd_dstDesc.ds_precision = 0;
+  formatParm.fd_dstDesc.ds_scale = 0;
+  formatParm.fd_dstDesc.ds_columnType = IIAPI_COL_QPARM;
+  formatParm.fd_dstDesc.ds_columnName = NULL;
+
+  formatParm.fd_dstValue.dv_null = FALSE;
+  formatParm.fd_dstValue.dv_length = dateStrLen;
+  formatParm.fd_dstValue.dv_value = dateStr;
+
+  IIapi_formatData (&formatParm);
+
+  dateStr[formatParm.fd_dstValue.dv_length] = '\0';
+  if (ii_globals.debug)
+    printf ("%s: Converted the DATE/TIME field >>%s<< to the string >>%s<<\n",
+            function_name, (char *)param_columnData->dv_value, dateStr + 2);
+
+  returnValue = rb_str_new (dateStr + 2, *(II_INT2 *)dateStr);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return returnValue;
+}
+
+
+VALUE
+processDecimalField (IIAPI_DATAVALUE * param_columnData, IIAPI_DESCRIPTOR * param_descrParm)
+{
+  VALUE returnValue;
+  IIAPI_CONVERTPARM convertParm;
+  int decimalStrLen = 42;
+  /* FIXME: use Ingres MAX_DECIMAL_LEN or something like that */
+  char decimalStr[42] = {0};
+  char function_name[] = "processDecimalField";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  convertParm.cv_srcDesc.ds_dataType = IIAPI_DEC_TYPE;
+  convertParm.cv_srcDesc.ds_nullable = FALSE;
+  convertParm.cv_srcDesc.ds_length = param_descrParm->ds_length;
+  convertParm.cv_srcDesc.ds_precision = param_descrParm->ds_precision;
+  convertParm.cv_srcDesc.ds_scale = param_descrParm->ds_scale;
+  convertParm.cv_srcDesc.ds_columnType = IIAPI_COL_QPARM;
+  convertParm.cv_srcDesc.ds_columnName = NULL;
+
+  convertParm.cv_srcValue.dv_null = FALSE;
+  convertParm.cv_srcValue.dv_length = param_columnData->dv_length;
+  convertParm.cv_srcValue.dv_value = param_columnData->dv_value;
+
+  convertParm.cv_dstDesc.ds_dataType = IIAPI_VCH_TYPE;
+  convertParm.cv_dstDesc.ds_nullable = FALSE;
+  convertParm.cv_dstDesc.ds_length = decimalStrLen;
+  convertParm.cv_dstDesc.ds_precision = 0;
+  convertParm.cv_dstDesc.ds_scale = 0;
+  convertParm.cv_dstDesc.ds_columnType = IIAPI_COL_QPARM;
+  convertParm.cv_dstDesc.ds_columnName = NULL;
+
+  convertParm.cv_dstValue.dv_null = FALSE;
+  convertParm.cv_dstValue.dv_length = decimalStrLen;
+  convertParm.cv_dstValue.dv_value = decimalStr;
+
+  IIapi_convertData (&convertParm);
+
+  returnValue = rb_str_new2 (decimalStr + 2);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return returnValue;
+}
+
+
+/*
+**      processIntField() - Convert Ingres integer to Ruby numeric
+**
+**      Description -
+**              Convert Ingres integer (lengths 1, 2, 4 or 8) to Ruby
+**              numeric (Fixnum or Bignum).
+**
+**              Ruby numeric types w/ ranges:
+**                 Fixnum  -2**30      ->    2**30-1    #most platforms
+**                    (-1,073,741,824)   (1,073,741,823)
+**                         -2**62      ->    2**62-1    #some 64-bit? platforms
+**                 Bignum: unlimited...anything outside range of Fixnum
+**
+**              Ingres integer types w/ ranges and mapping to Ruby:
+**                 tinyint(integer1)  -128 -> 127                  Fixnum
+**                 smallint(integer2) -32768 -> 32767              Fixnum
+**                 integer(integer4)  -2**31     ->    2**31-1     Fixnum/Bignum
+**                               (-2,147,483,648)  (2,147,483,647)
+**                 bigint(integer8)   -2**63     ->    2**63-1     Fixnum/Bignum
+**
+**              The Ruby macros xxx2NUM/FIX are used to do the conversion.
+**              If the Ingres type will always fit within a Ruby Fixnum,
+**              then use INT2FIX because it is faster.  Otherwise, use the
+**              appropriate xxx2NUM macro which will convert it to either
+**              Fixnum or Bignum depending on the value.
+**
+**      History
+**              06/18/08 (lunbr01)
+**                      Added Ingres bigint support and used INT2FIX
+**                      instead of INT2NUM where possible for performance.
+**                      Add function documentation.
+*/
+VALUE
+processIntField (IIAPI_DATAVALUE * param_columnData)
+{
+  VALUE ret_val;
+  char function_name[] = "processIntField";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  switch (param_columnData->dv_length)
+  {
+    case 1:
+      ret_val = INT2FIX ((char) * ((II_INT1 *) param_columnData->dv_value));
+      break;
+    case 2:
+      ret_val = INT2FIX ((short) * ((II_INT2 *) param_columnData->dv_value));
+      break;
+    case 4:
+      ret_val = LONG2NUM ((long) * ((II_INT4 *) param_columnData->dv_value));
+      break;
+    case 8:
+      ret_val = LL2NUM ((__int64) * ((__int64 *) param_columnData->dv_value));
+      break;
+    default:
+      if (ii_globals.debug)
+        printf
+        ("%s: Bad size for IIAPI_INT_TYPE. The size %d is invalid. Returning NULL.\n",
+         function_name, param_columnData->dv_length);
+      /* if the data size is zero, this is a NULL value. */
+      ret_val = rb_str_new2 ("NULL");
+      break;
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return ret_val;
+}
+
+
+VALUE
+processFloatField (IIAPI_DATAVALUE * param_columnData)
+{
+  VALUE ret_val;
+  char function_name[] = "processFloatField";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  switch (param_columnData->dv_length)
+  {
+    case 4:
+      ret_val =
+        rb_float_new ((double) * ((II_FLOAT4 *) param_columnData->dv_value));
+      break;
+
+    case 8:
+      ret_val =
+        rb_float_new ((double) * ((II_FLOAT8 *) param_columnData->dv_value));
+      break;
+
+    default:
+      if (ii_globals.debug)
+        printf
+        ("%s: Bad size for IIAPI_FLT_TYPE. The size %d is invalid. Valid sizes are 4 and 8. Returning NULL.",
+         function_name, param_columnData->dv_length);
+      ret_val = rb_str_new2 ("NULL");;
+      break;
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return ret_val;
+}
+
+
+VALUE
+processMoneyField (IIAPI_DATAVALUE * param_columnData)
+{
+  VALUE ret_val;
+  char function_name[] = "processMoneyField";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  ret_val = rb_float_new ((double) * ((II_FLOAT8 *) param_columnData->dv_value) / 100.00);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return ret_val;
+}
+
+
+
+VALUE
+processCharField (char *param_char_field, int param_char_length)
+{
+  VALUE ret_val = (VALUE)FALSE;
+  int trimmed_len = 0;
+  char *newstring = NULL;
+  char function_name[] = "processCharField";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  newstring = (char *) ALLOC_N(char, param_char_length + 1);
+  memcpy (newstring, param_char_field, param_char_length);
+  newstring[param_char_length] = '\0';
+
+  /* remove any trailing blanks */
+  trimmed_len = STtrmwhite (newstring);
+  newstring[trimmed_len] = '\0';
+  ret_val = rb_str_new (newstring, trimmed_len);
+
+  if (ii_globals.debug)
+    printf ("oldchar is >>%s<<, newchar is >>%s<<\n", param_char_field, RSTRING_PTR (ret_val));
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return ret_val;
+}
+
+
+VALUE
+processStringField (char *param_varchar_field, int param_varchar_length)
+{
+  VALUE result_value;
+  int i;
+  char *newstring = ALLOC_N (char, param_varchar_length - 1);
+  char function_name[] = "processStringField";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  /* the first two bytes holds the length. */
+  /* since we already have that, we don't need it, */
+  /* so we just skip over that information. */
+  memcpy (newstring, param_varchar_field + 2, param_varchar_length - 2);
+
+  if (ii_globals.debug)
+    printf ("oldstring is >>%s<<, newstring is >>%s<<\n", param_varchar_field,
+            newstring);
+
+  /* make a Ruby value out of the result */
+  result_value = rb_str_new (newstring, param_varchar_length - 2);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+
+  return result_value;
+}
+
+VALUE
+processUTF16StringField (char *param_nvarchar_field,
+                         int param_nvarchar_length)
+{
+  VALUE result_value;
+  int i, ret_val;
+  long utf8strlen;
+  unsigned char *utf8str = NULL;
+  char function_name[] = "processUTF16StringField";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  utf8strlen = param_nvarchar_length * 4;
+  utf8str = ALLOC_N (char, utf8strlen + 3);
+
+  if (utf16_to_utf8
+      ((UCS2 *) (param_nvarchar_field + 2),
+       (UCS2 *) (param_nvarchar_field + param_nvarchar_length),
+       (char *) (utf8str + 2), (char *) (utf8str + utf8strlen + 2),
+       &utf8strlen))
+    rb_raise (rb_eRuntimeError,
+              "Transcode of UTF16 %s, string to UTF failed.",
+              param_nvarchar_field);
+
+  result_value = processStringField (utf8str, utf8strlen + 2);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+
+  return result_value;
+}
+
+
+VALUE
+processUTF16CharField (char *param_nchar_field, int param_nchar_length)
+{
+  VALUE result_value;
+  long utf8strlen;
+  unsigned char *utf8str = NULL;
+  char function_name[] = "processUTF16CharField";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  utf8strlen = param_nchar_length * 4;
+  utf8str = ALLOC_N (char, utf8strlen + 1);
+
+  if (utf16_to_utf8 ((UCS2 *) param_nchar_field, (UCS2 *) (param_nchar_field + param_nchar_length), (char *) utf8str, (char *) (utf8str + utf8strlen), &utf8strlen))
+    rb_raise (rb_eRuntimeError, "Transcode of UTF16 %s, char to UTF failed.", param_nchar_field);
+
+  result_value = processCharField (utf8str, utf8strlen);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+
+  return result_value;
+}
+
+
+VALUE
+processUTF16LOBField (char *param_nlob_field, int param_nlob_length)
+{
+  VALUE result_value;
+  long utf8strlen;
+  unsigned char *utf8str = NULL;
+  char function_name[] = "processUTF16LOBField";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  utf8strlen = param_nlob_length * 4;
+  utf8str = ALLOC_N (char, utf8strlen + 1);
+
+  if (utf16_to_utf8
+      ((UCS2 *) param_nlob_field,
+       (UCS2 *) (param_nlob_field + param_nlob_length), (char *) utf8str,
+       (char *) (utf8str + utf8strlen), &utf8strlen))
+    rb_raise (rb_eRuntimeError, "Transcode of UTF16 %s, char to UTF failed.",
+              param_nlob_field);
+
+  result_value = rb_str_new (utf8str, utf8strlen);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+
+  return result_value;
+}
+
+
+VALUE
+processLOBField (char *param_nlob_field, int param_nlob_length)
+{
+  VALUE result_value;
+  char function_name[] = "processLOBField";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  result_value = rb_str_new (param_nlob_field, param_nlob_length);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+
+  return result_value;
+}
+
+
+VALUE
+processUnImplementedField ()
+{
+  char function_name[] = "processUnImplementedField";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  rb_notimplement ();
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return rb_str_new2 ("NULL");
+}
+
+
+VALUE
+processField (II_CONN * ii_conn, RUBY_IIAPI_DATAVALUE * param_columnData, int param_columnNumber, IIAPI_DESCRIPTOR * param_descrParm)
+{
+  VALUE ret_val;
+  IIAPI_DATAVALUE *dataValue = param_columnData->dataValue;
+  int param_dataType = param_descrParm->ds_dataType;
+  char function_name[] = "processField";
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  rb_ary_store (ii_conn->r_data_sizes, param_columnNumber, INT2NUM (param_columnData->dv_length));
+
+  /* fetch the data differently depending on the type of data it is */
+  switch (param_dataType)
+  {
+      /* I followed the Ingres doc for these types */
+      /* anything listed as a char * will be treated as varchar or text */
+    case IIAPI_NVCH_TYPE:
+      ret_val = processUTF16StringField (dataValue->dv_value, param_columnData->dv_length);
+      break;
+
+    case IIAPI_LNVCH_TYPE:
+      ret_val = processUTF16LOBField (dataValue->dv_value, param_columnData->dv_length);
+      break;
+
+    case IIAPI_LBYTE_TYPE:
+    case IIAPI_LVCH_TYPE:
+      ret_val = processLOBField (dataValue->dv_value, param_columnData->dv_length);
+      break;
+
+    case IIAPI_BYTE_TYPE:
+    case IIAPI_LOGKEY_TYPE:
+    case IIAPI_TABKEY_TYPE:
+    case IIAPI_VBYTE_TYPE:
+      /* tested */
+    case IIAPI_TXT_TYPE:
+    case IIAPI_VCH_TYPE:
+      ret_val = processStringField (dataValue->dv_value, param_columnData->dv_length);
+      break;
+
+    case IIAPI_INT_TYPE:
+      ret_val = processIntField (dataValue);
+      break;
+
+    case IIAPI_DEC_TYPE:
+      ret_val = processDecimalField (dataValue, param_descrParm);
+      break;
+
+    case IIAPI_FLT_TYPE:
+      ret_val = processFloatField (dataValue);
+      break;
+
+    case IIAPI_DTE_TYPE:
+#ifdef IIAPI_DATE_TYPE
+    case IIAPI_DATE_TYPE:
+    case IIAPI_TIME_TYPE:
+    case IIAPI_TMWO_TYPE:
+    case IIAPI_TMTZ_TYPE:
+    case IIAPI_TS_TYPE:
+    case IIAPI_TSWO_TYPE:
+    case IIAPI_TSTZ_TYPE:
+    case IIAPI_INTYM_TYPE:
+    case IIAPI_INTDS_TYPE:
+#endif
+      ret_val = processDateField (dataValue, param_dataType);
+      break;
+
+    case IIAPI_MNY_TYPE:
+      ret_val = processMoneyField (dataValue);
+      break;
+
+    case IIAPI_NCHA_TYPE:
+      ret_val = processUTF16CharField (dataValue->dv_value, param_columnData->dv_length);
+      break;
+
+    case IIAPI_CHR_TYPE:
+    case IIAPI_CHA_TYPE:
+    default:
+      ret_val = processCharField ((char *)dataValue->dv_value, param_columnData->dv_length);
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return ret_val;
+}
+
+
+int getColumn (II_CONN  *ii_conn, RUBY_IIAPI_DATAVALUE * param_columnData, II_LONG param_columnType)
+{
+  IIAPI_GETCOLPARM getColParm;
+  IIAPI_DATAVALUE *dataValue = param_columnData->dataValue;
+  int status = 0;
+  long bufferLen = 0;
+  char *buffer = NULL;
+  char *bufferPtr = NULL;
+  char function_name[] = "getColumn";
+  short int segmentLen = 0;
+  char *lob_data = NULL;
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  getColParm.gc_columnData = dataValue;
+
+  do
+  {
+    getColParm.gc_genParm.gp_callback = NULL;
+    getColParm.gc_genParm.gp_closure = NULL;
+    getColParm.gc_rowCount = 1;
+    getColParm.gc_columnCount = 1;
+    getColParm.gc_rowsReturned = 0;
+    getColParm.gc_stmtHandle = ii_conn->stmtHandle;
+    getColParm.gc_moreSegments = 0;
+    dataValue->dv_length = 0;
+
+    IIapi_getColumns (&getColParm);
+    ii_sync (&(getColParm.gc_genParm));
+    if (ii_checkError (&(getColParm.gc_genParm)))
+    {
+      memset (dataValue, 0, sizeof (IIAPI_DATAVALUE));
+      rb_raise (rb_eRuntimeError, "IIapi_getColumns() failed.");
+      break;
+    }
+
+    /* Size of the data being returned is in the first 2 bytes of dataValue->dv_value */
+    if (param_columnType == IIAPI_LVCH_TYPE ||
+        param_columnType == IIAPI_LBYTE_TYPE ||
+        param_columnType == IIAPI_LNVCH_TYPE)
+    {
+        param_columnData->dv_length = *(II_INT2 *)dataValue->dv_value;
+    }
+    else
+    {
+        param_columnData->dv_length = dataValue->dv_length;
+    }
+
+    /* Handle LOB data slightly differently */
+    if (param_columnType == IIAPI_LVCH_TYPE ||
+        param_columnType == IIAPI_LBYTE_TYPE ||
+        param_columnType == IIAPI_LNVCH_TYPE)
+    {
+      /* Copy the first two bytes of dataValue->dv_value to get the length */
+      /* of the data fetched from the server */
+      memcpy ((char *) &segmentLen, dataValue->dv_value, 2);
+
+      if (buffer == NULL)
+      {
+        /* Init buffer to place LOB data */
+        buffer = ii_allocate(LOB_SEGMENT_SIZE, sizeof(char *));
+        bufferPtr = buffer;
+      }
+      else
+      {
+        /*
+        ** TODO Improve performance by not reallocating new larger
+        ** buffer for every lob segment (approx 4K bytes each).  See
+        ** Ingres ODBC driver for more efficient algorithm.
+        */
+        buffer = ii_reallocate (buffer, bufferLen + segmentLen + 1, sizeof(char));
+        bufferPtr = buffer + bufferLen;
+      }
+      memcpy (bufferPtr, (char *)dataValue->dv_value + 2, segmentLen);
+      bufferLen += segmentLen;
+      param_columnData->dv_length = bufferLen;
+    }
+  }
+  while (getColParm.gc_moreSegments);
+
+  if (buffer != NULL)   /* If blob col, return alloc'd buffer */
+  {
+    if (dataValue->dv_value)
+    {
+      ii_free((void **) &(dataValue->dv_value));
+    }
+    dataValue->dv_value = buffer;
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return getColParm.gc_genParm.gp_status;
+}
+
+
+int
+processColumn (II_CONN *ii_conn, VALUE * param_values, int param_columnNumber, IIAPI_DESCRIPTOR * param_descrParm)
+{
+  RUBY_IIAPI_DATAVALUE columnData = {FALSE, 0, NULL};
+  int done = FALSE;
+  char *tmp = NULL;
+  char function_name[] = "processColumn";
+
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  /* Allocate storage space for incoming data */
+  tmp = (char *) ii_allocate(param_descrParm->ds_length + 1, sizeof(char));
+  memset (tmp, 0, param_descrParm->ds_length + 1);
+  columnData.dataValue[0].dv_value = tmp;
+
+  if (getColumn (ii_conn, &columnData, param_descrParm->ds_dataType ) >= IIAPI_ST_NO_DATA)
+  {
+    /* we've reached the end of the data */
+    done = TRUE;
+  }
+  else
+  {
+    /* let's copy out and convert the data */
+    VALUE nextEntry;
+
+    if (columnData.dataValue[0].dv_null == TRUE)
+    {
+      /* this is a null value. Don't try to convert it. */
+      if (ii_globals.debug)
+        printf ("\nFound a NULL value\n");
+      nextEntry = rb_str_new2 ("NULL");
+    }
+    else
+    {
+      nextEntry = processField (ii_conn, &columnData, param_columnNumber, param_descrParm);
+    }
+
+    rb_ary_push ((*param_values), nextEntry);
+  }
+
+  if (tmp)
+  {
+    ii_free((void **) &(columnData.dataValue[0].dv_value));
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return done;
+}
+
+
+void
+ii_api_get_data (II_CONN *ii_conn, IIAPI_GETDESCRPARM * param_descrParm)
+{
+  int done = FALSE;
+  char function_name[] = "ii_api_get_data";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  /* loop until all rows are fetched */
+  while (!done)
+  {
+    VALUE values;
+    int columnCount = 0;
+
+    values = rb_ary_new ();
+
+    while (columnCount < param_descrParm->gd_descriptorCount && !done)
+    {
+      done = processColumn (ii_conn, &values, columnCount, &(param_descrParm->gd_descriptor[columnCount]));
+      columnCount++;
+    }
+
+    if (!done)
+    {
+      rb_ary_push (ii_conn->resultset, values);
+    }
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+}
+
+
+VALUE
+ii_execute_query (II_CONN *ii_conn, char *param_sqlText, int param_argc, VALUE param_params)
+{
+  IIAPI_GETDESCRPARM getDescrParm;
+  IIAPI_WAITPARM waitParm = { -1 };
+  VALUE ret_val;
+  char function_name[] = "ii_execute_query";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  if (ii_globals.debug)
+    printf ("\n AUTOCOMMIT_ON = %d\n", ii_conn->autocommit);
+
+  ii_api_query (ii_conn, param_sqlText, param_argc, param_params);
+  ii_api_getDescriptors (ii_conn, &getDescrParm);
+
+  if (ii_globals.debug)
+    printf ("\nFound %d column(s)\n", getDescrParm.gd_descriptorCount);
+
+  /* fetch the query results */
+  if (getDescrParm.gd_descriptorCount > 0)
+  {
+    init_rb_array (&ii_conn->resultset);
+    init_rb_array (&ii_conn->r_data_sizes);
+    init_rb_array (&ii_conn->r_column_names);
+    init_rb_array (&ii_conn->r_data_types);
+
+    ii_api_get_metadata (ii_conn, &getDescrParm);
+    ii_api_get_data (ii_conn, &getDescrParm);
+  }
+
+  ret_val = ii_conn->resultset;
+  global_rows_affected = getRowsAffected (ii_conn);
+
+  ii_api_query_close (ii_conn);
+
+  if (ii_conn->autocommit)
+    ii_api_commit (ii_conn);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return ret_val;
+}
+
+
+/*
+ * Document-method: execute
+ *
+ * call-seq:
+ *    Ingres.execute(sql[ param_types, param_values]) -> Array
+ *
+ * Executes the supplied _sql_ statement returning the results as a
+ * two-dimensional Array. The first dimension represents each row, and the 
+ * second dimension represents each column within the row. _param_types_ is
+ * a string of letters, with each letter representing the type of each
+ * parameter being passed.
+ *
+ * For SQL queries or database procedure calls that contain parameters, use the
+ * Ingres.execute() method in one of the following formats.
+ * For selects, inserts, deletes, and updates:
+ * 
+ *   execute(sql [ [, param_type, param_value ] … ] )
+ * 
+ * For database procedure calls:
+ * 
+ *   execute("{ <call> | <execute procedure> procedure_name [ (column_name = ? [
+ *   [ , column_name = ? ] … ] ) ] }" [ [ , column_name, param_type, param_value
+ *   ] … ] )
+ * 
+ * where parameters in the sql text are represented by question marks (?) and
+ * there is one set of param_type/param_value entries for each one.
+ * param_type must be one of the following single characters:
+ * 
+ * <table>
+ * <tr><td>*param_type*<td>*Description*
+ * <tr><td>b<td>byte
+ * <tr><td>B<td>long_byte
+ * <tr><td>c<td>char
+ * <tr><td>d<td>date
+ * <tr><td>D<td>decimal
+ * <tr><td>f<td>float
+ * <tr><td>i<td>integer
+ * <tr><td>n<td>nchar
+ * <tr><td>N<td>nvarchar
+ * <tr><td>t<td>text
+ * <tr><td>T<td>long_text
+ * <tr><td>v<td>varchar
+ * <tr><td>V<td>long_varchar
+ * </table>
+ * 
+ * param_value should correspond to the expected type being sent.
+ * 
+ * Example usage:
+ *
+ *   conn = Ingres.new()
+ *   conn.connect(:database => "demodb")
+ *   results = conn.execute("select up_first, up_last, up_email from user_profile where up_id = ?", "i", 1)
+ *
+ */
+VALUE
+ii_execute (int param_argc, VALUE * param_argv, VALUE param_self)
+{
+  VALUE ret_val = Qnil;
+  VALUE param_queryText;
+  VALUE params;
+  VALUE savePtName;
+  int i;
+  char function_name[] = "ii_execute";
+  II_CONN *ii_conn;
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  rb_scan_args (param_argc, param_argv, "1*", &param_queryText, &params);
+
+  Check_Type(param_queryText, T_STRING);
+
+  Data_Get_Struct(param_self, II_CONN, ii_conn);
+
+  /* determine what sort of query is being executed */
+  if (ii_globals.debug)
+    printf ("Classifying query\n");
+  ii_conn->queryType = ii_query_type(RSTRING_PTR (param_queryText));
+  if (ii_globals.debug)
+    printf ("Classified query\n");
+
+  switch (ii_conn->queryType)
+  {
+    case INGRES_SQL_COMMIT:
+      if (ii_conn->tranHandle != NULL)
+        ii_api_commit (ii_conn);
+      else if (ii_globals.debug || ii_globals.debug_transactions)
+        rb_warn ("Attempting to ii_api_commit a non-existent transaction");
+      break;
+    case INGRES_SQL_ROLLBACK:
+      if (ii_conn->tranHandle != NULL)
+        ii_api_rollback (ii_conn, NULL);
+      else if (ii_globals.debug || ii_globals.debug_transactions)
+        rb_warn ("Attempting to ii_api_rollback a non-existent transaction");
+      break;
+    case INGRES_SQL_ROLLBACK_TO:
+    case INGRES_SQL_ROLLBACK_WORK_TO:
+      /* ROLLBACK [WORK] TO SAVEPOINT */
+      if (ii_conn->tranHandle == NULL)
+      {
+        rb_raise (rb_eRuntimeError, "Unable to rollback a non-existent transaction");
+      }
+      else
+      {
+        /* Extract Savepoint name */
+        savePtName = ii_savepoint_name(ii_conn, StringValuePtr(param_queryText));
+        ii_rollback (1, &savePtName, param_self);
+      }
+      break;
+    case INGRES_START_TRANSACTION:
+      startTransaction (param_self);
+      break;
+    case INGRES_SQL_CONNECT:
+      rb_warn ("Use connect() to connect to a database");
+      break;
+    case INGRES_SQL_DISCONNECT:
+      rb_warn ("Use disconnect() to disconnect from a database");
+      break;
+    case INGRES_SQL_GETDBEVENT:
+      rb_warn ("Ingres 'GET DBEVENT' is not supported at the current time");
+      break;
+    case INGRES_SQL_SAVEPOINT:
+      /* We cannot generate a save point if there is no transaction or if auto commit is in effect */
+      if (ii_conn->tranHandle == NULL)
+      {
+        rb_raise (rb_eRuntimeError, "Unable to generate a save point if there is no active transaction");
+      }
+      else
+      {
+        /* Extract Savepoint name */
+        savePtName = ii_savepoint_name(ii_conn, StringValuePtr(param_queryText));
+        ii_api_savepoint (ii_conn, savePtName);
+      }
+      break;
+    case INGRES_SQL_AUTOCOMMIT:
+      rb_warn ("Use autocommit() to set the auto-commit state");
+      break;
+    case INGRES_SQL_COPY:
+      rb_warn ("Ingres 'COPY TABLE() INTO/FROM' is not supported at the current time");
+      break;
+    case INGRES_SQL_SELECT:
+    case INGRES_SQL_INSERT:
+    case INGRES_SQL_UPDATE:
+    case INGRES_SQL_DELETE:
+    case INGRES_SQL_CREATE:
+    case INGRES_SQL_ALTER:
+    case INGRES_SQL_EXECUTE_PROCEDURE:
+    case INGRES_SQL_CALL:
+    default:
+      if (ii_globals.debug || ii_globals.debug_transactions)
+        printf ("Executing %s\n", StringValuePtr (param_queryText));
+      ret_val = ii_execute_query (ii_conn, StringValuePtr (param_queryText), param_argc - 1, params);
+      break;
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return ret_val;
+}
+
+/* 
+ * Document-method: tables
+ *
+ * call-seq:
+ *    Ingres.tables() -> Array
+ *
+ * Returns a list of all the tables in the database associated with this instance.
+ *
+ * Example usage:
+ *
+ *   conn = Ingres.new()
+ *   conn = Ingres.connect(:database => "demodb")
+ *   con.tables
+ *
+ */
+static VALUE
+ii_tables (VALUE param_self)
+{
+  VALUE table_list;
+  VALUE sql_string;
+  VALUE *params;
+  char function_name[] = "ii_tables";
+  II_CONN *ii_conn = NULL;
+
+  Data_Get_Struct(param_self, II_CONN, ii_conn);
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  sql_string = rb_str_new2 ("SELECT table_name FROM iitables WHERE table_type = 'T' AND table_name not like 'ii%'");
+  table_list = ii_execute (1, &sql_string, param_self);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return table_list;
+}
+
+/* 
+ * Document-method: current_database
+ *
+ * call-seq:
+ *    Ingres.current_database() -> String
+ *
+ * Returns the name of associated database, if connected.
+ *
+ * Example usage:
+ *
+ *   conn = Ingres.new()
+ *   conn = Ingres.connect(:database => "demodb")
+ *   puts conn.current_database()
+ *
+ */
+VALUE
+ii_current_database (VALUE param_self)
+{
+  VALUE curr_db;
+  char function_name[] = "ii_current_database";
+  II_CONN *ii_conn = NULL;
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  Data_Get_Struct(param_self, II_CONN, ii_conn);
+
+  curr_db = rb_str_new2 (ii_conn->currentDatabase);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return curr_db;
+}
+
+VALUE
+ii_crash_it (VALUE param_self) //:nodoc
+{
+  VALUE a_string;
+  VALUE yet_another_string;
+  char *my_string = NULL;
+  char *another_string = NULL;
+  char function_name[] = "ii_crash_it";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  printf ("\n\nMalloc some memory\n");
+  my_string = malloc (strlen ("activerecord_unittest") + 1);
+  my_string = "activerecord_unittest";
+
+  printf ("\n Create the Ruby string \n");
+  a_string = rb_str_new2 (my_string);
+
+  printf ("Now convert it to a C string\n");
+  another_string = STR2CSTR (a_string);
+
+  printf ("Now convert it back to a Ruby string\n");
+  yet_another_string = rb_str_new2 (another_string);
+
+  printf ("Done!");
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return yet_another_string;
+}
+
+/* 
+ * Document-method: rows_affected
+ *
+ * call-seq:
+ *    Ingres.rows_affected() -> Fixnum
+ *
+ * Returns the number of rows affected by the last SQL statement.
+ *
+ *   conn = Ingres.new()
+ *   conn = Ingres.connect(:database => "demodb")
+ *   users = conn.execute("select * from user_profile")
+ *   user_count = conn.rows_affected()
+ *
+ */
+VALUE
+ii_rows_affected (VALUE param_self)
+{
+  VALUE return_value;
+  char function_name[] = "ii_rows_affected";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  return_value = INT2NUM (global_rows_affected);
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return return_value;
+}
+
+/* 
+ * Document-method: data_types
+ *
+ * call-seq:
+ *    Ingres.data_types() -> Array
+ *
+ * Returns an Array of data types names for the last SQL SELECT statement executed.
+ *
+ *   conn = Ingres.new()
+ *   conn = Ingres.connect(:database => "demodb")
+ *   users = conn.execute("select * from user_profile")
+ *   types = conn.data_types()
+ *
+ */
+VALUE
+ii_return_data_types (VALUE param_self)
+{
+  char function_name[] = "ii_return_data_types";
+  II_CONN *ii_conn = NULL;
+
+  Data_Get_Struct(param_self, II_CONN, ii_conn);
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  return ii_conn->r_data_types;
+}
+
+
+/* 
+ * Document-method: column_list_of_names
+ *
+ * call-seq:
+ *    Ingres.column_list_of_names() -> Array
+ *
+ * Returns an Array of column names for the last SQL _SELECT_ statement executed.
+ *
+ *   conn = Ingres.new()
+ *   conn = Ingres.connect(:database => "demodb")
+ *   users = conn.execute("select * from user_profile")
+ *   columns = conn.column_list_of_names()
+ *
+ */
+VALUE
+ii_column_names (VALUE param_self)
+{
+  char function_name[] = "ii_column_names";
+  II_CONN *ii_conn = NULL;
+
+  Data_Get_Struct(param_self, II_CONN, ii_conn);
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  return ii_conn->r_column_names;
+}
+
+
+/* 
+ * Document-method: data_sizes
+ *
+ * call-seq:
+ *    Ingres.data_sizes() -> Array
+ *
+ * Returns an Array of Fixnum values representing the width of each column from the last
+ * SQL SELECT statement executed.
+ *
+ *   conn = Ingres.new()
+ *   conn = Ingres.connect(:database => "demodb")
+ *   users = conn.execute("select * from user_profile")
+ *   sizes = conn.data_sizes()
+ *
+ */
+VALUE
+ii_data_sizes (VALUE param_self)
+{
+  char function_name[] = "ii_data_sizes";
+  II_CONN *ii_conn = NULL;
+
+  Data_Get_Struct(param_self, II_CONN, ii_conn);
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+
+  return ii_conn->r_data_sizes;
+}
+
+
+/* 
+ * Document-method: set_debug_flag
+ *
+ * call-seq:
+ *    Ingres.set_debug_flag(flag, flag_value) -> nil
+ *
+ * Turns trace debugging on or off
+ *
+ * Valid values:
+ * * _flag_ can be one of  <tt>GLOBAL_DEBUG</tt>, <tt>DEBUG_TRANSACTIONS</tt>, <tt>DEBUG_SQL</tt>, <tt>DEBUG_TERMINATION</tt>
+ * * _flag_value_ is either <tt>TRUE</tt> or <tt>FALSE</tt>
+ *
+ * Example usage:
+ *
+ *    conn = Ingres.new()
+ *    conn.set_debug_flag("GLOBAL_DEBUG","TRUE")
+ *
+ */
+VALUE
+ii_set_debug_flag (VALUE param_self, VALUE param_debug_flag, VALUE param_debug_flag_value)
+{
+  int new_debug_value = FALSE;
+  char function_name[] = "ii_set_debug_flag";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  Check_Type (param_debug_flag, T_STRING);
+  Check_Type (param_debug_flag_value, T_STRING);
+
+  if (!strcmp (RSTRING_PTR (param_debug_flag_value), "TRUE"))
+    new_debug_value = TRUE;
+
+  if (!strcmp (RSTRING_PTR (param_debug_flag), "GLOBAL_DEBUG"))
+    ii_globals.debug = new_debug_value;
+  else if (!strcmp (RSTRING_PTR (param_debug_flag), "DEBUG_TRANSACTIONS"))
+    ii_globals.debug_transactions = new_debug_value;
+  else if (!strcmp (RSTRING_PTR (param_debug_flag), "DEBUG_SQL"))
+    ii_globals.debug_sql = new_debug_value;
+  else if (!strcmp (RSTRING_PTR (param_debug_flag), "DEBUG_TERMINATION"))
+    ii_globals.debug_termination = new_debug_value;
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return Qnil;
+}
+
+size_t STtrmwhite (register char *string)
+{
+  register size_t len;
+  register char *nw = NULL;
+  register size_t nwl;
+  char function_name[] = "STtrmwhite";
+  if (ii_globals.debug)
+  {
+    printf ("Entering %s.\n", function_name);
+  }
+
+  /*
+   ** after the loop, nw points to the first character beyond
+   ** the last non-white character.  Done this way because you
+   ** can't reverse scan a string with CM efficiently
+   */
+  len = 0;
+  nwl = 0;
+  nw = string;
+  while (*string != EOS)
+  {
+    len += CMbytecnt (string);
+    if (!CMwhite (string))
+    {
+      CMnext (string);
+      nw = string;
+      nwl = len;
+    }
+    else
+    {
+      CMnext (string);
+    }
+  }
+
+  if (nw != string)
+  {
+    *nw = EOS;
+  }
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+  return nwl;
+}
+
+/********************************************************************
+ * 
+ * Document-class: Ingres
+ *
+ * This class accesses the Ingres RDBMS through OpenAPI
+ *
+ * For example, to execute a simple query
+ *    require 'Ingres'
+ *    ing = Ingres.new()
+ *    ing.connect(:database => 'demodb')
+ *    result = ing.execute('SELECT * from user_profile')
+ * 
+ * See README.rdoc for information about obtaining and installing the 
+ * Ingres Ruby Driver.
+ */
+void
+Init_Ingres ()
+{
+  char function_name[] = "Init_Ingres";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  /* Define Ingres Class */
+  cIngres = rb_define_class ("Ingres", rb_cObject);
+
+  /* Allocation of memory for II_CONN structure */
+  rb_define_alloc_func(cIngres, rb_ingres_alloc);
+
+  /* Constants for the driver */
+
+  /* Driver version */
+  rb_define_const(cIngres, "VERSION", rb_str_new2 (RUBY_INGRES_VERSION));
+  /* Driver OpenAPI level */
+  rb_define_const(cIngres, "API_LEVEL", INT2FIX(RUBY_INGRES_API));
+  /* Source code revision level */
+  rb_define_const(cIngres, "REVISION", rb_str_new2 ("$Rev$"));
+
+  rb_define_method (cIngres, "initialize", ii_init, 0);
+  rb_define_method (cIngres, "connect", ii_connect, -1);
+  rb_define_method (cIngres, "disconnect", ii_disconnect, 0);
+  rb_define_method (cIngres, "execute", ii_execute, -1);
+  rb_define_method (cIngres, "tables", ii_tables, 0);
+  rb_define_method (cIngres, "current_database", ii_current_database, 0);
+  rb_define_method (cIngres, "data_types", ii_return_data_types, 0);
+  rb_define_method (cIngres, "rows_affected", ii_rows_affected, 0);
+  rb_define_method (cIngres, "column_list_of_names", ii_column_names, 0);
+  rb_define_method (cIngres, "data_sizes", ii_data_sizes, 0);
+  rb_define_method (cIngres, "set_environment", ii_set_environment, -1);
+
+  /* Transaction Methods */
+  rb_define_method (cIngres, "commit", ii_commit, 0);
+  rb_define_method (cIngres, "rollback", ii_rollback, -1);
+  rb_define_method (cIngres, "savepoint", ii_savepoint, 1);
+
+  /* Aliases of methods */
+  rb_define_alias (cIngres, "connect_with_credentials", "connect");
+  rb_define_alias (cIngres, "pexecute", "execute"); // Deprecated
+  rb_define_alias (cIngres, "exec", "execute");
+
+  rb_define_method (cIngres, "crash_it", ii_crash_it, 0);
+  rb_define_method (cIngres, "set_debug_flag", ii_set_debug_flag, 2);
+
+  /* :date_format Constants */
+
+  /* DMY Date format */
+  rb_define_const(cIngres,"DATE_FORMAT_DMY", INT2FIX(IIAPI_CPV_DFRMT_DMY)); 
+  /* FINLAND Date format */
+  rb_define_const(cIngres,"DATE_FORMAT_FINLAND", INT2FIX(IIAPI_CPV_DFRMT_FINNISH));
+  /* GERMAN Date format */
+  rb_define_const(cIngres,"DATE_FORMAT_GERMAN", INT2FIX(IIAPI_CPV_DFRMT_GERMAN));
+  /* ISO Date format */
+  rb_define_const(cIngres,"DATE_FORMAT_ISO", INT2FIX(IIAPI_CPV_DFRMT_ISO));
+  /* ISO4 Date format */
+  rb_define_const(cIngres,"DATE_FORMAT_ISO4", INT2FIX(IIAPI_CPV_DFRMT_ISO4));
+  /* MDY Date format */
+  rb_define_const(cIngres,"DATE_FORMAT_MDY", INT2FIX(IIAPI_CPV_DFRMT_MDY));
+  /* MULTINATIONAL Date format */
+  rb_define_const(cIngres,"DATE_FORMAT_MULTINATIONAL", INT2FIX(IIAPI_CPV_DFRMT_MULTI));
+  /* MULTINATIONAL4 Date format */
+  rb_define_const(cIngres,"DATE_FORMAT_MULTINATIONAL4", INT2FIX(IIAPI_CPV_DFRMT_MLT4));
+  /* SWEDEN Date format */
+  rb_define_const(cIngres,"DATE_FORMAT_SWEDEN", INT2FIX(IIAPI_CPV_DFRMT_FINNISH));
+  /* US Date format */
+  rb_define_const(cIngres,"DATE_FORMAT_US", INT2FIX(IIAPI_CPV_DFRMT_US));
+  /* YMD Date format */
+  rb_define_const(cIngres,"DATE_FORMAT_YMD", INT2FIX(IIAPI_CPV_DFRMT_YMD));
+
+
+  if (ii_globals.debug)
+    printf ("Exiting %s.\n", function_name);
+}
+
+
+/* Allocate the II_CONN structure used to store connection state et. al. */
+static VALUE rb_ingres_alloc(VALUE klass)
+{
+  II_CONN *ii_conn = NULL;
+
+  char function_name[] = "rb_ingres_alloc";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  ii_conn = (II_CONN *)ALLOC(II_CONN);
+  ii_conn_init(ii_conn);
+
+  return Data_Wrap_Struct(klass, NULL, free_ii_conn, ii_conn);
+}
+static void free_ii_conn (II_CONN *ii_conn)
+{
+  char function_name[] = "free_ii_conn";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  if (ii_conn)
+  {
+    /* Clean up the connection */
+    ii_api_rollback (ii_conn, NULL);
+    ii_api_disconnect (ii_conn);
+  }
+}
+
+/* Set the defaults for II_CONN internals */
+static void ii_conn_init(II_CONN *ii_conn)
+{
+  char function_name[] = "ii_conn_init";
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  ii_conn->autocommit = TRUE;
+  ii_conn->connHandle = NULL;
+  ii_conn->tranHandle = NULL;
+  ii_conn->stmtHandle = NULL;
+  ii_conn->envHandle = NULL;
+  ii_conn->fieldCount = 0;
+  ii_conn->lobSegmentSize = 0;
+  ii_conn->descriptor = NULL;
+  ii_conn->errorText = NULL;
+  ii_conn->sqlstate[0] = '\0';
+  ii_conn->errorCode = 0;
+  ii_conn->apiLevel = IIAPI_VERSION - 1;
+  ii_conn->paramCount = 0;
+  ii_conn->cursor_id = NULL;
+  ii_conn->cursor_mode = INGRES_CURSOR_READONLY;
+  ii_conn->currentDatabase = NULL;
+  ii_conn->keep_me = (VALUE) FALSE;
+  ii_conn->resultset = (VALUE) FALSE;
+  ii_conn->r_column_names = (VALUE) FALSE;
+  ii_conn->r_data_sizes = (VALUE) FALSE;
+  ii_conn->r_data_types = (VALUE) FALSE;
+  ii_conn->savePtList = NULL; /* Linked list of Save point names and their handles */
+  ii_conn->lastSavePtEntry = NULL; 
+
+}
+
+static int ii_query_type(char *statement)
+{
+  char function_name[] = "ii_query_type";
+  int count = 0;
+  char *statement_ptr = NULL;
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  statement_ptr = statement;
+  /* Look for some white space */
+  while (isspace(*statement_ptr))
+  {
+    statement_ptr++;
+  }
+  for ( count = 0; count < INGRES_NO_OF_COMMANDS; count++ )
+  {
+    if (strncasecmp(SQL_COMMANDS[count].command, statement_ptr, SQL_COMMANDS[count].length) == 0)
+    {
+      if (count == INGRES_SQL_ROLLBACK)
+      {
+        /* Verify this is ROLLBACK and not ROLLBACK [WORK] TO */
+        if (strlen(statement_ptr) != SQL_COMMANDS[count].length)
+        { 
+          if (strncasecmp(SQL_COMMANDS[INGRES_SQL_ROLLBACK_TO].command, statement_ptr, SQL_COMMANDS[INGRES_SQL_ROLLBACK_TO].length) == 0)
+          {
+            return SQL_COMMANDS[INGRES_SQL_ROLLBACK_TO].code;
+          }
+          if (strncasecmp(SQL_COMMANDS[INGRES_SQL_ROLLBACK_WORK_TO].command, statement_ptr, SQL_COMMANDS[INGRES_SQL_ROLLBACK_WORK_TO].length) == 0)
+          {
+            return SQL_COMMANDS[INGRES_SQL_ROLLBACK_WORK_TO].code;
+          }
+        }
+      }
+      return SQL_COMMANDS[count].code;
+    }
+  }
+
+  return -1;
+}
+
+VALUE
+ii_savepoint_name(II_CONN *ii_conn, char *statement)
+{
+  char function_name[] = "ii_savepoint_name";
+  int count = 0;
+  char *statement_ptr = NULL;
+  char *savePtName_start = NULL;
+  char *tmp_savePtName = NULL;
+  char ch;
+  VALUE savePtName = (VALUE) FALSE;
+
+  if (ii_globals.debug)
+    printf ("Entering %s.\n", function_name);
+
+  statement_ptr = statement + SQL_COMMANDS[ii_conn->queryType].length;
+  /* Look for some white space */
+  while (isspace(*statement_ptr))
+  {
+    statement_ptr++;
+  }
+  savePtName_start = statement_ptr;
+
+  while (*statement_ptr != EOS)
+  {
+    ch = *statement_ptr;
+    if ((isalnum (*statement_ptr)) ||
+        (ch == ' ') || 
+        (ch == '_') || 
+        (ch == '"'))
+    {
+      statement_ptr++;
+    }
+    else
+    {
+      rb_raise(rb_eRuntimeError, "%s : found an invalid character %c", function_name, ch);
+      return Qnil;
+    }
+  }
+
+  tmp_savePtName = (char *) ii_allocate (statement_ptr - savePtName_start, sizeof(char *));
+  memcpy (tmp_savePtName, savePtName_start, statement_ptr - savePtName_start);
+  savePtName = rb_str_new2 (tmp_savePtName);
+  ii_free ((void **) &tmp_savePtName);
+
+  return savePtName;
+}
+
+/*
+vim:  ts=2 sw=2 expandtab
+*/