sqlanywhere 0.1.0-i486-linux

data/CHANGELOG

@@ -0,0 +1,7 @@
+=CHANGE LOG
+
+=====0.1.0 -- 2008/10/15
+- Initial Release
+- Wraps DBCAPI funcationality
+- Includes a simple unit test suite
+

data/LICENSE

@@ -0,0 +1,23 @@
+/*====================================================
+*
+*   Copyright 2008 iAnywhere Solutions, Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*                                                                               
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+* While not a requirement of the license, if you do modify this file, we
+* would appreciate hearing about it.   Please email sqlany_interfaces@sybase.com
+*
+*
+*====================================================*/

data/README

@@ -0,0 +1,126 @@
+=SQL Anywhere Ruby Driver
+
+This is a native SQL Anywhere driver for Ruby. This library wraps the 
+functionality provided by the SQL Anywhere DBCAPI library. This driver
+is intended to be a base-level library to be used by interface libraries
+such as Ruby-DBI and ActiveRecord.
+
+This driver can be used with SQL Anywhere 11 and SQL Anywhere 10.
+
+This driver is licensed under the Apache License, Version 2.
+
+==Build Instructions
+
+===Requirements
+* C Compiler
+* Ruby
+* RubyGem Package manager
+
+
+===All Platforms
+
+To build and install the gem, use:
+
+   rake
+   rake install
+
+The other rake tasks are 
+
+   rake clean   -> Cleans up all temp files (ex *.~)
+   rake clobber -> Cleans up all built files (ex *.gem, *.o, *.so)
+
+===Additional Install Notes for Windows
+
+The popular One-Click Ruby Installer for Windows (RubyInstaller) is built using 
+Microsoft Visual C++ 6.0. Since problems can arise by combining binaries from
+different compilers, we advise you use this compiler.
+
+If you want to use a more recent version of the MS C++ compiler, you will need to make a few changes:
+
+1. Open the file: <RUBY DIR>\lib\ruby\1.8\i386-mswin32\config.h, and comment out the first three lines so they look like:
+
+    //#if _MSC_VER != 1200
+    //#error MSC version unmatch
+    //#endif
+  
+   This removes the check for C++ Version 6.0
+
+2. Open <tt>rakefile</tt> and set:
+
+      APPLY_MANIFEST = true
+
+   This will add the manifest to the compiled binaries.
+
+By default, rake will attempt to use Microsoft <tt>nmake</tt> when building under Windows. To use another make program, set:
+
+     USE_NMAKE_ON_WIN = FALSE
+
+==Running Unit Tests
+
+1. Change to the the <tt>test</tt> directory
+
+    cd test
+
+2. Create a testing database:
+
+    dbinit test
+
+3. Start the testing database:
+
+    dbeng11 test.db
+ 
+4. Create the test schema:
+
+    dbisql -c "eng=test;uid=dba;pwd=sql" test.sql
+
+5. Run the unit tests:
+
+    ruby sqlanywhere_test.rb
+
+<b>If the tests fail to run, make sure you have set up the SQL Anywhere environment variables correctly.</b> For more information
+review the online documentation here[http://dcx.sybase.com/index.php#http%3A%2F%2Fdcx.sybase.com%2F1100en%2Fdbadmin_en11%2Fda-envvar-sect1-3672410.html].
+
+==Sample
+
+This script makes a connection, prints <tt>Successful Ruby Connection</tt> to the SQL
+Anywhere console, then disconnects.
+  
+   # load the SQLAnywhere gem
+   begin
+     require 'rubygems'
+     gem 'sqlanywhere'
+     unless defined? SQLAnywhere
+       require 'sqlanywhere'
+     end    
+   end
+
+   # create an interface
+   api = SQLAnywhere::SQLAnywhereInterface.new()
+
+   # initialize the interface (loads the DLL/SO)
+   SQLAnywhere::API.sqlany_initialize_interface( api )
+
+   # initialize our api object
+   api.sqlany_init()
+
+   # create a connection
+   conn = api.sqlany_new_connection()
+
+   # establish a connection
+   api.sqlany_connect(conn, "uid=dba;pwd=sql")
+
+   # execute a query without a result set
+   api.sqlany_execute_immediate(conn, "MESSAGE 'Successful Ruby Connection'")
+
+   # disconnect from the database
+   api.sqlany_disconnect(conn)
+
+   # free the connection resources
+   api.sqlany_free_connection(conn)
+
+   # free resources the api object uses
+   api.sqlany_fini()
+
+   # close the interface
+   SQLAnywhere::API.sqlany_finalize_interface( api )
+

data/ext/sqlanywhere.c

@@ -0,0 +1,1624 @@
+/*====================================================
+*
+*   Copyright 2008 iAnywhere Solutions, Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*                                                                               
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+* While not a requirement of the license, if you do modify this file, we
+* would appreciate hearing about it.   Please email sqlany_interfaces@sybase.com
+*:
+*
+*====================================================*/
+#include "ruby.h"
+#include "sacapidll.h"
+
+const char* VERSION = "0.1.0";
+
+// Defining the Ruby Modules
+static VALUE mSQLAnywhere;
+static VALUE mAPI;
+static VALUE cSQLAnywhereInterface;
+
+// Defining binder for DBCAPI types
+static VALUE cA_sqlany_connection;
+static VALUE cA_sqlany_data_value;
+static VALUE cA_sqlany_stmt;
+static VALUE cA_sqlany_bind_param;
+static VALUE cA_sqlany_bind_param_info;
+
+// This function is called when the module is first loaded by ruby.
+// The name of this function MUST match be Init_<modulename>.
+void Init_sqlanywhere();
+
+// Wrapper functions for the DBICAPI functions
+
+static VALUE
+static_API_sqlany_initialize_interface(VALUE module, VALUE api);
+
+static VALUE
+static_API_sqlany_finalize_interface(VALUE module, VALUE api);
+
+static VALUE
+static_SQLAnywhereInterface_alloc(VALUE class);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_init(VALUE class);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_new_connection(VALUE class);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_disconnect(VALUE api, VALUE sqlany_conn);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_free_connection(VALUE api, VALUE sqlany_conn);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_fini(VALUE api);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_error(VALUE api, VALUE sqlany_conn);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_execute_immediate(VALUE api, VALUE sqlany_conn, VALUE sql);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_execute_direct(VALUE api, VALUE sqlany_conn, VALUE sql);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_num_cols(VALUE api, VALUE sqlany_stmt);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_num_rows(VALUE api, VALUE sqlany_stmt);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_get_column(VALUE api, VALUE sqlany_stmt, VALUE col_num);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_fetch_next(VALUE api, VALUE sqlany_stmt);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_get_column_info(VALUE api, VALUE sqlany_stmt, VALUE col_num);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_commit(VALUE api, VALUE sqlany_conn);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_rollback(VALUE api, VALUE sqlany_conn);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_prepare(VALUE api, VALUE sqlany_conn, VALUE sql);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_free_stmt(VALUE api, VALUE sqlany_stmt);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_execute(VALUE api, VALUE sqlany_stmt);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_affected_rows(VALUE api, VALUE sqlany_stmt);
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_describe_bind_param(VALUE api, VALUE sqlany_stmt, VALUE index);
+
+/* 
+ * C to Ruby Data conversion function to convert DBCAPI column type into the correct Ruby type
+ */
+static VALUE C2RB(a_sqlany_data_value* value)
+{
+   VALUE tdata;
+
+    switch( value->type ) {
+	case A_BINARY:
+	    tdata = rb_str_new(value->buffer, *value->length);
+	    break;
+	case A_STRING:
+	    tdata = rb_str_new(value->buffer, *value->length);
+	    break;
+	case A_DOUBLE:
+	    tdata = rb_float_new(*(double*) value->buffer);
+	    break;
+	case A_VAL64:
+	    tdata = LL2NUM(*(LONG_LONG*)value->buffer);
+	    break;
+	case A_UVAL64:
+	    tdata = ULL2NUM(*(unsigned LONG_LONG*)value->buffer);
+	    break;
+	case A_VAL32:
+	    tdata = INT2NUM(*(int *)value->buffer);
+	    break;
+	case A_UVAL32:
+	    tdata = UINT2NUM(*(unsigned int *)value->buffer);
+	    break;
+	case A_VAL16:
+	    tdata = INT2NUM(*(short *)value->buffer);	       
+	    break;
+	case A_UVAL16:
+	    tdata = UINT2NUM(*( unsigned short *)value->buffer);	    
+	    break;
+	case A_VAL8:
+	    tdata = CHR2FIX(*(unsigned char *)value->buffer);	       
+	    break;
+	case A_UVAL8:
+	    tdata = CHR2FIX(*(unsigned char *)value->buffer);	       
+	    break;
+        default:
+	    rb_raise(rb_eTypeError, "Invalid Data Type");
+	    tdata = Qnil;
+	    break;
+    }
+
+    return tdata;
+}
+
+/*
+ * call-seq:
+ *    sqlany_initialize_interface(VALUE api) -> int result
+ *
+ *  Initializes the SQLAnywhereInterface object and loads the DLL dynamically.
+ *
+ *  This function attempts to load the SQL Anywhere C API DLL dynamically and 
+ *  looks up all the entry points of the DLL. 
+ *
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> -- an API structure to initialize
+ *
+ *  <b>Returns</b>:
+ *  - <tt>result</tt>: <tt>1</tt> on successful initialization, <tt>0</tt> on failure
+ *   
+ */
+static VALUE
+static_API_sqlany_initialize_interface(VALUE module, VALUE api)
+{
+    SQLAnywhereInterface* s_api;
+    int result;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    
+    result = sqlany_initialize_interface( s_api, NULL );
+
+    return( INT2NUM(result) ); 
+}
+
+/*
+ * call-seq:
+ *    sqlany_finalize_interface(VALUE api) -> nil
+ *
+ *  Finalize and free resources associated with the SQL Anywhere C API DLL.
+ *
+ *  This function will unload the library and uninitialize the supplied SQLAnywhereInterface structure. 
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt>
+ *   
+ */
+static VALUE
+static_API_sqlany_finalize_interface(VALUE module, VALUE api)
+{
+    SQLAnywhereInterface* s_api;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+
+    sqlany_finalize_interface(s_api);
+
+    free(s_api);
+
+    return( Qnil );
+}
+
+static VALUE
+static_SQLAnywhereInterface_alloc(VALUE class)
+{ 
+  SQLAnywhereInterface *s_api = NULL;
+  VALUE 	        tdata;
+
+  s_api = malloc( sizeof(SQLAnywhereInterface) );
+  memset( s_api, 0, sizeof(SQLAnywhereInterface));
+
+  tdata = Data_Wrap_Struct(class, 0, 0, s_api);
+  return tdata;
+}
+
+/*
+ * call-seq:
+ *   sqlany_init(VALUE api) -> [VALUE result, VALUE version] 
+ *
+ *  Initialize the interface..
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on success, <tt>0</tt> on failure
+ *  - <tt>VALUE version</tt>: The maximum API version that is supported.  
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_init(VALUE api)
+{
+    SQLAnywhereInterface* s_api;
+    sacapi_bool result;
+    sacapi_u32 s_version_available;   
+    VALUE multi_result;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+
+    multi_result = rb_ary_new();
+
+    if( s_api == NULL ) {
+	rb_ary_push(multi_result, INT2NUM(0));
+	rb_ary_push(multi_result, Qnil );
+    } else {
+	result = s_api->sqlany_init("RUBY", SQLANY_CURRENT_API_VERSION , &s_version_available );
+	rb_ary_push(multi_result, INT2NUM(result));
+	rb_ary_push(multi_result, INT2NUM(s_version_available));
+    }
+
+    return( multi_result ); 
+}
+
+/*
+ * call-seq:
+ *   sqlany_new_connection(VALUE api) -> VALUE connection
+ *
+ *  Creates a connection object.
+ *
+ *  An API connection object needs to be created before a database connection is 
+ *  established. Errors can be retrieved from the connection object. Only one 
+ *  request can be processed on a connection at a time. 
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE connection</tt>: A connection object.  
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_new_connection(VALUE api)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_connection* ptr;
+    VALUE tdata;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    ptr = s_api->sqlany_new_connection();
+
+    tdata = Data_Wrap_Struct(cA_sqlany_connection, 0, 0, ptr);
+    
+    return (tdata);
+}
+
+/*
+ * call-seq:
+ *   sqlany_connect(VALUE api, VALUE sqlany_conn, VALUE str) -> VALUE result
+ *
+ *  Creates a connection object.
+ *
+ *  An API connection object needs to be created before a database connection is 
+ *  established. Errors can be retrieved from the connection object. Only one 
+ *  request can be processed on a connection at a time. 
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_conn</tt> -- A connection object that was created by sqlany_new_connection()
+ *  - <tt>VALUE str</tt> -- A SQL Anywhere connection string
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on success, <tt>0</tt> on failure 
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_connect(VALUE api, VALUE sqlany_conn, VALUE str)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_connection* s_sqlany_conn;
+    char* s_str;
+    sacapi_bool   result;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_conn, a_sqlany_connection, s_sqlany_conn);
+
+    s_str = StringValueCStr( str );
+
+    result = s_api->sqlany_connect( s_sqlany_conn, s_str );
+
+    return( INT2NUM(result) ); 
+}
+
+/*
+ * call-seq:
+ *   sqlany_disconnect(VALUE api, VALUE sqlany_conn) -> nil
+ *
+ *  Disconnect an already established connection.
+ *
+ *  This function disconnects a SQL Anywhere connection. Any uncommited transactions will be rolled back. 
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_conn</tt> -- A connection object that was connected by sqlany_connect()
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt> 
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_disconnect(VALUE api, VALUE sqlany_conn)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_connection* s_sqlany_conn;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_conn, a_sqlany_connection, s_sqlany_conn);
+
+
+    s_api->sqlany_disconnect( s_sqlany_conn );
+
+    return( Qnil ); 
+}
+
+/*
+ * call-seq:
+ *   sqlany_free_connection(VALUE api, VALUE sqlany_conn) -> nil
+ *
+ *  Frees the resources associated with a connection object.
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_conn</tt> -- A connection object that was disconnected by sqlany_disconnect()
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt> 
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_free_connection(VALUE api, VALUE sqlany_conn)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_connection* s_sqlany_conn;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_conn, a_sqlany_connection, s_sqlany_conn);
+
+
+    s_api->sqlany_free_connection( s_sqlany_conn );
+
+    return( Qnil ); 
+}
+
+/*
+ * call-seq:
+ *   sqlany_fini(VALUE api) -> nil
+ * 	
+ *  Finalize the interface.
+ *  Frees any resources allocated by the API
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt> 
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_fini(VALUE api)
+{
+    SQLAnywhereInterface* s_api;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+
+    s_api->sqlany_fini();
+
+    return( Qnil ); 
+}
+
+/*
+ * call-seq:
+ *   sqlany_error(VALUE api, VALUE sqlany_conn) -> [VALUE result, VALUE errstr]
+ * 
+ *  Retrieves the last error code and message.
+ *
+ *  This function can be used to retrieve the last error code and message stored in the connection object. 
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_conn</tt> -- A connection object that was connected by sqlany_connect()
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: The last error code. Positive values are warnings, negative values are errors, and <tt>0</tt> is success.
+ *  - <tt>VALUE errstr</tt>: The error message corresponding to the error code  
+ *   
+ */
+
+static VALUE
+static_SQLAnywhereInterface_sqlany_error(VALUE api, VALUE sqlany_conn)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_connection* s_sqlany_conn;
+    size_t s_size; 
+    char s_buffer[255];
+    sacapi_i32 result;
+    VALUE multi_result;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_conn, a_sqlany_connection, s_sqlany_conn);
+
+    result = s_api->sqlany_error(s_sqlany_conn, s_buffer, 255);
+
+    multi_result = rb_ary_new();
+
+    rb_ary_push(multi_result, INT2NUM(result));
+    rb_ary_push(multi_result, rb_str_new2(s_buffer));
+    
+    return( multi_result );
+}
+
+/*
+ * call-seq:
+ *   sqlany_execute_immediate(VALUE api, VALUE sqlany_conn, VALUE sql) -> VALUE result
+ * 
+ *  Execute a SQL statement immediately without returning a result set.
+ *
+ *  Execute the specified SQL statement immediately. This function is useful for SQL statements that do not return a result set. 
+ * 
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_conn</tt> -- A connection object that was connected by sqlany_connect()
+ *  - <tt>VALUE sql</tt> -- A SQL query string
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on success, <tt>0</tt> on failure 
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_execute_immediate(VALUE api, VALUE sqlany_conn, VALUE sql)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_connection* s_sqlany_conn;
+    char* s_sql;
+    sacapi_bool result;
+
+    s_sql = StringValueCStr( sql );
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_conn, a_sqlany_connection, s_sqlany_conn);
+
+    result = s_api->sqlany_execute_immediate(s_sqlany_conn, s_sql);
+
+    return( INT2NUM(result) );
+}
+
+/*
+ * call-seq:
+ *   sqlany_execute_direct(VALUE api, VALUE sqlany_conn, VALUE sql) -> VALUE resultset
+ * 
+ *  Executes a SQL statement and possibly returns a result set.
+ *
+ *  This function executes the SQL statement specified by the string argument. 
+ *  This function is suitable if you want to prepare and then execute a statement, and can be 
+ *  used instead of calling sqlany_prepare() followed by sqlany_execute(). 
+ *
+ *  This function can not be used for executing a SQL statement with parameters. 
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_conn</tt> -- A connection object that was connected by sqlany_connect()
+ *  - <tt>VALUE sql</tt> -- A SQL query string
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: A query result set if successful, nil if failed
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_execute_direct(VALUE api, VALUE sqlany_conn, VALUE sql)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_connection* s_sqlany_conn;
+    a_sqlany_stmt* resultset = NULL;
+    char* s_sql;
+    VALUE tdata;
+
+    s_sql = StringValueCStr( sql );
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_conn, a_sqlany_connection, s_sqlany_conn);
+
+    resultset = s_api->sqlany_execute_direct(s_sqlany_conn, s_sql);
+   
+    if (resultset)
+    {
+       tdata = Data_Wrap_Struct(cA_sqlany_stmt, 0, 0, resultset);
+    }
+    else
+    {
+       tdata = Qnil;
+    }
+   
+    return (tdata);
+}
+
+/*
+ * call-seq:
+ *   sqlany_num_cols(VALUE api, VALUE sqlany_stmt) -> VALUE num_cols
+ * 
+ *  Returns number of columns in the result set 
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_stmt</tt> -- A statement object that was created by sqlany_prepare() or sqlany_execute_direct() 
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE num_cols</tt>: The number of columns in the result set or <tt>-1</tt> on a failure.
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_num_cols(VALUE api, VALUE sqlany_stmt)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_stmt* s_stmt;
+    sacapi_i32 result;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_stmt, a_sqlany_stmt, s_stmt);
+
+    result = s_api->sqlany_num_cols(s_stmt);
+
+    return( INT2NUM(result) );
+}
+
+/*
+ * call-seq:
+ *   sqlany_num_rows(VALUE api, VALUE sqlany_stmt) -> VALUE num_rows
+ * 
+ *  Returns number of rows in the result set.
+ *
+ *  By default this function only returns an estimate. To return an exact count,
+ *  users must set the ROW_COUNTS option on the connection. 
+ *  Refer to SQL Anywhere documentation for the SQL syntax to set this option
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_stmt</tt> -- A statement object that was created by sqlany_prepare() or sqlany_execute_direct() 
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE num_rows</tt>: The number of rows in the result set or <tt>-1</tt> on a failure.
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_num_rows(VALUE api, VALUE sqlany_stmt)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_stmt* s_stmt;
+    sacapi_i32 result;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_stmt, a_sqlany_stmt, s_stmt);
+
+    result = s_api->sqlany_num_rows(s_stmt);
+
+    return( INT2NUM(result) );
+}
+
+/*
+ * call-seq:
+ *   sqlany_get_column(VALUE api, VALUE sqlany_stmt, VALUE col_num) -> [VALUE result, VALUE column_value]
+ * 
+ *  Retrieve the data fetched for the specified column.
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_stmt</tt> -- A statement object that was created by sqlany_prepare() or sqlany_execute_direct()
+ *  - <tt>VALUE col_num</tt> -- The number of the column to be retrieved. A column number is between 0 and sqlany_num_cols() - 1.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE column_value</tt>: The value of the column. nil is returned if the value was NULL
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_get_column(VALUE api, VALUE sqlany_stmt, VALUE col_num)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_stmt* s_stmt;
+    sacapi_u32 s_col_num;
+    a_sqlany_data_value value;
+    sacapi_bool result;
+    VALUE multi_result;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_stmt, a_sqlany_stmt, s_stmt);
+    s_col_num = NUM2INT(col_num);
+
+    result = s_api->sqlany_get_column(s_stmt, s_col_num, &value );
+
+    multi_result = rb_ary_new();
+    rb_ary_push(multi_result, INT2NUM(result));
+
+    if( !result ) {
+       rb_ary_push(multi_result, Qnil);
+    }
+    else
+    {
+       if( *value.is_null )
+       {
+	  rb_ary_push(multi_result, Qnil);
+       }
+       else
+       {
+	  rb_ary_push(multi_result, C2RB(&value));
+       }
+    }
+
+    return( multi_result );
+}
+
+/*
+ * call-seq:
+ *   sqlany_fetch_next(VALUE api, VALUE sqlany_stmt) -> VALUE result
+ * 
+ *  Fetch the next row from the result set.
+ *  This function fetches the next row from the result set. When the result object is first created, 
+ *  the current row pointer is set to before the first row (i.e. row 0). 
+ *  This function first advances the row pointer and then fetches the data at the new row. 
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_stmt</tt> -- A statement object that was created by sqlany_prepare() or sqlany_execute_direct()
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on successful fetch, <tt>0</tt> otherwise
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_fetch_next(VALUE api, VALUE sqlany_stmt)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_stmt* s_stmt;
+    sacapi_bool result;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_stmt, a_sqlany_stmt, s_stmt);
+
+    result = s_api->sqlany_fetch_next(s_stmt);
+
+    return( INT2NUM(result) );
+}
+
+/*
+ * call-seq:
+ *   sqlany_get_column_info(VALUE api, VALUE sqlany_stmt, VALUE col_num) -> [VALUE result, VALUE col_num, VALUE name, VALUE type, VALUE max_size]
+ * 
+ *  Fetch the next row from the result set.
+ *  This function fetches the next row from the result set. When the result object is first created, 
+ *  the current row pointer is set to before the first row (i.e. row 0). 
+ *  This function first advances the row pointer and then fetches the data at the new row. 
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_stmt</tt> -- A statement object that was created by sqlany_prepare() or sqlany_execute_direct()
+ *  - <tt>VALUE col_num</tt> -- The number of the column to be retrieved. A column number is between 0 and sqlany_num_cols() - 1.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on success. Returns <tt>0</tt> if the column index is out of range, or if the statement does not return a result set.
+ *  - <tt>VALUE col_num</tt>: The number of the column retrieved
+ *  - <tt>VALUE name</tt>: The name of the column
+ *  - <tt>VALUE type</tt>: The type of the column data
+ *  - <tt>VALUE native_type</tt>: The SQL Anywhere native type of the column data
+ *  - <tt>VALUE precision</tt>: The precision of the column
+ *  - <tt>VALUE scale</tt>: The scale of the column
+ *  - <tt>VALUE max_size</tt>: The maximum size a data value in this column can take
+ *  - <tt>VALUE nullable</tt>: The nullability of the column
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_get_column_info(VALUE api, VALUE sqlany_stmt, VALUE col_num)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_stmt* s_stmt;
+    sacapi_u32 s_col_num;
+    a_sqlany_column_info info;
+    sacapi_bool result;
+    VALUE multi_result;    
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_stmt, a_sqlany_stmt, s_stmt);
+    s_col_num = NUM2INT(col_num);
+
+    result = s_api->sqlany_get_column_info(s_stmt, s_col_num, &info );
+
+    multi_result = rb_ary_new();
+    rb_ary_push(multi_result, INT2NUM(result));
+    rb_ary_push(multi_result, col_num );
+    rb_ary_push(multi_result, rb_str_new2(info.name));
+    rb_ary_push(multi_result, INT2NUM(info.type)); 
+    rb_ary_push(multi_result, INT2NUM(info.native_type)); 
+    rb_ary_push(multi_result, INT2NUM(info.precision)); 
+    rb_ary_push(multi_result, INT2NUM(info.scale)); 
+    rb_ary_push(multi_result, INT2NUM(info.max_size)); 
+    rb_ary_push(multi_result, INT2NUM(info.nullable)); 
+
+    return( multi_result );
+}
+
+/*
+ * call-seq:
+ *   sqlany_commit(VALUE api, VALUE sqlany_conn) -> VALUE result
+ * 
+ *  Commit the current transaction.
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_conn</tt> -- A connection object that was connected by sqlany_connect()
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on successful commit, <tt>0</tt> otherwise
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_commit(VALUE api, VALUE sqlany_conn)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_connection* s_sqlany_conn;
+    sacapi_bool result;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_conn, a_sqlany_connection, s_sqlany_conn);
+
+    result = s_api->sqlany_commit(s_sqlany_conn);
+
+    return( INT2NUM(result) );
+}
+
+
+/*
+ * call-seq:
+ *   sqlany_rollback(VALUE api, VALUE sqlany_conn) -> VALUE result
+ * 
+ *  Rollback the current transaction.
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_conn</tt> -- A connection object that was connected by sqlany_connect()
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on successful rollback, <tt>0</tt> otherwise
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_rollback(VALUE api, VALUE sqlany_conn)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_connection* s_sqlany_conn;
+    sacapi_bool result;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_conn, a_sqlany_connection, s_sqlany_conn);
+
+    result = s_api->sqlany_rollback(s_sqlany_conn);
+
+    return( INT2NUM(result) );
+}
+
+/*
+ * call-seq:
+ *   sqlany_prepare(VALUE api, VALUE sqlany_conn, VALUE sql) -> VALUE stmt
+ * 
+ *  Prepare a SQL statement.
+ *
+ *  This function prepares the supplied SQL string. Execution does not happen until sqlany_execute() 
+ *  is called. The returned statement object should be freed using sqlany_free_stmt(). 
+ *  
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_conn</tt> -- A connection object that was connected by sqlany_connect()
+ *  - <tt>VALUE sql</tt> -- SQL query to prepare
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE stmt</tt>: A statement object, or nil on failure. The statement object can be used by sqlany_execute() to execute the statement.
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_prepare(VALUE api, VALUE sqlany_conn, VALUE sql)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_connection* s_sqlany_conn;
+    a_sqlany_stmt* ptr = NULL;
+    char* s_sql;
+    int   result;
+    VALUE tdata;
+
+    s_sql = StringValueCStr( sql );
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_conn, a_sqlany_connection, s_sqlany_conn);
+
+    ptr = s_api->sqlany_prepare(s_sqlany_conn, s_sql);
+
+    if (ptr)
+    {
+       tdata = Data_Wrap_Struct(cA_sqlany_stmt, 0, 0, ptr);
+    }
+    else 
+    {
+       tdata = Qnil;
+    }  
+      
+    return (tdata);
+}
+
+/*
+ * call-seq:
+ *   sqlany_free_stmt(VALUE api, VALUE sqlany_stmt) -> nil
+ * 
+ *  Frees resources associated with a prepared statement object.
+ *
+ *  This function frees the resources associated with a prepared statement object. 
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_stmt</tt> -- A statement object that was created by sqlany_prepare() or sqlany_execute_direct()
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt>
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_free_stmt(VALUE api, VALUE sqlany_stmt)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_stmt* s_sqlany_stmt;
+    int i;
+    int number_of_params = 0;
+    a_sqlany_bind_param_info bind_info;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_stmt, a_sqlany_stmt, s_sqlany_stmt);
+
+    number_of_params = s_api->sqlany_num_params(s_sqlany_stmt);
+
+    for (i = 0; i < number_of_params; i++)
+    {
+       if( s_api->sqlany_get_bind_param_info(s_sqlany_stmt, i, &bind_info) ) 
+       {
+	  // We don't free bind_info.name as it's not allocated
+	  // if (bind_info.name) {free (bind_info.name);}
+
+	  if (bind_info.input_value.is_null) {free(bind_info.input_value.is_null); }
+	  if (bind_info.input_value.length)  {free(bind_info.input_value.length);  }
+	  if (bind_info.input_value.buffer)  {free(bind_info.input_value.buffer);  }
+
+	  if (bind_info.output_value.is_null) {free(bind_info.output_value.is_null); }
+	  if (bind_info.output_value.length)  {free(bind_info.output_value.length);  }
+	  if (bind_info.output_value.buffer)  {free(bind_info.output_value.buffer);  }
+       }
+    }
+    
+    s_api->sqlany_free_stmt(s_sqlany_stmt);
+    
+    return ( Qnil );
+}
+
+/*
+ * call-seq:
+ *   sqlany_execute(VALUE api, VALUE sqlany_stmt) -> VALUE result
+ * 
+ *  This function executes a prepared statement.
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_stmt</tt> -- A statement object that was created by sqlany_prepare() or sqlany_execute_direct()
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on successful execution, <tt>0</tt> otherwise
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_execute(VALUE api, VALUE sqlany_stmt)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_stmt* s_sqlany_stmt;
+    sacapi_bool result;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_stmt, a_sqlany_stmt, s_sqlany_stmt);
+
+    result = s_api->sqlany_execute(s_sqlany_stmt);
+
+    return (INT2NUM(result));
+}
+
+/*
+ * call-seq:
+ *   sqlany_affected_rows(VALUE api, VALUE sqlany_stmt) -> VALUE result
+ * 
+ *  Returns the number of rows affected by execution of the prepared statement.
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_stmt</tt> -- A statement that was prepared and executed successfully with no result set returned.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: The number of rows affected or <tt>-1</tt> on failure.
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_affected_rows(VALUE api, VALUE sqlany_stmt)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_stmt* s_sqlany_stmt;
+    sacapi_i32 result;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_stmt, a_sqlany_stmt, s_sqlany_stmt);
+
+    result = s_api->sqlany_affected_rows(s_sqlany_stmt);
+    
+    return ( INT2NUM(result) );
+}
+
+/*
+ * call-seq:
+ *   sqlany_describe_bind_param(VALUE api, VALUE sqlany_stmt, VALUE index) -> [VALUE result, VALUE bind_param]
+ * 
+ *  Describes the bind parameters of a prepared statement.
+ *
+ *  This function allows the caller to determine information about parameters to a prepared statement. 
+ *  Depending on the type of the prepared statement (call to stored procedured or a DML), only some information will be provided.
+ *  The information that will always be provided is the direction of the parameters (input, output, or input-output). 
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_stmt</tt> -- A statement object that was returned from sqlany_prepare().
+ *  - <tt>VALUE index</tt> -- The index of the parameter. This should be a number between 0 and sqlany_num_params()-  1
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on success or <tt>0</tt> on failure.
+ *  - <tt>VALUE bind_param</tt>: The described param object.
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_describe_bind_param(VALUE api, VALUE sqlany_stmt, VALUE index)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_stmt* s_sqlany_stmt;
+    a_sqlany_bind_param* s_sqlany_bind_param;
+    sacapi_bool result;
+    sacapi_u32 s_index;
+    VALUE tdata;
+    VALUE multi_result;  
+
+    s_sqlany_bind_param = malloc(sizeof(a_sqlany_bind_param));
+    memset( s_sqlany_bind_param, 0, sizeof(a_sqlany_bind_param) );
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_stmt, a_sqlany_stmt, s_sqlany_stmt);
+    s_index = NUM2INT(index);  
+
+    result = s_api->sqlany_describe_bind_param(s_sqlany_stmt, s_index, s_sqlany_bind_param);
+
+    //FIXME handle failed result
+
+    multi_result = rb_ary_new();
+
+    rb_ary_push(multi_result, INT2NUM(result));
+
+    tdata = Data_Wrap_Struct(cA_sqlany_bind_param, 0, 0, s_sqlany_bind_param);
+    rb_ary_push(multi_result, tdata);
+    
+    return( multi_result );    
+}
+
+/*
+ * call-seq:
+ *   sqlany_bind_param(VALUE api, VALUE sqlany_stmt, VALUE index, VALUE sqlany_bind_param) -> VALUE result
+ * 
+ *  Bind a user supplied buffer as a parameter to the prepared statement.
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_stmt</tt> -- A statement object that was returned from sqlany_prepare().
+ *  - <tt>VALUE index</tt> -- The index of the parameter. This should be a number between 0 and sqlany_num_params() - 1
+ *  - <tt>VALUE sqlany_bind_param</tt> -- A filled bind object retrieved from sqlany_describe_bind_param()
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on success or <tt>0</tt> on failure.
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_bind_param(VALUE api, VALUE sqlany_stmt, VALUE index, VALUE sqlany_bind_param )
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_stmt* s_sqlany_stmt;
+    a_sqlany_bind_param* s_sqlany_bind_param;
+    sacapi_bool result;
+    sacapi_u32 s_index;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_stmt, a_sqlany_stmt, s_sqlany_stmt);
+    Data_Get_Struct(sqlany_bind_param, a_sqlany_bind_param, s_sqlany_bind_param);    
+    s_index = NUM2INT(index);  
+
+    result = s_api->sqlany_bind_param(s_sqlany_stmt, s_index, s_sqlany_bind_param);
+    
+    return( INT2NUM(result) );    
+}
+
+/*
+ * call-seq:
+ *   sqlany_get_bind_param_info(VALUE api, VALUE sqlany_stmt, VALUE index) -> [VALUE result, VALUE bind_param]
+ * 
+ *  Get bound parameter info.
+ *
+ *  This function retrieves information about the parameters that were bound using sqlany_bind_param(). 
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_stmt</tt> -- A statement object that was returned from sqlany_prepare().
+ *  - <tt>VALUE index</tt> -- The index of the parameter. This should be a number between 0 and sqlany_num_params() - 1
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> on success or <tt>0</tt> on failure.
+ *  - <tt>VALUE bind_param</tt>: The described param object.
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_get_bind_param_info(VALUE api, VALUE sqlany_stmt, VALUE index)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_stmt* s_sqlany_stmt;
+    a_sqlany_bind_param_info s_sqlany_bind_param_info;
+    sacapi_bool result;
+    sacapi_u32 s_index;
+    VALUE tdata;
+    VALUE multi_result;  
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_stmt, a_sqlany_stmt, s_sqlany_stmt);
+    s_index = NUM2INT(index);  
+
+    result = s_api->sqlany_get_bind_param_info(s_sqlany_stmt, s_index, &s_sqlany_bind_param_info);
+
+    //FIXME handle failed result
+    multi_result = rb_ary_new();
+
+    rb_ary_push(multi_result, INT2NUM(result));
+
+    // FIXME: Is this safe to be on the stack?
+    tdata = Data_Wrap_Struct(cA_sqlany_bind_param_info, 0, 0, &s_sqlany_bind_param_info);
+    rb_ary_push(multi_result, tdata);
+    
+    return( multi_result );    
+}
+
+/*
+ * call-seq:
+ *   sqlany_num_params(VALUE api, VALUE sqlany_stmt) -> VALUE result
+ * 
+ *  Returns the number of parameters that are expected for a prepared statement.
+ *
+ *  This function retrieves information about the parameters that were bound using sqlany_bind_param(). 
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_stmt</tt> -- A statement object that was returned from sqlany_prepare().
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: The number of parameters that are expected. <tt>-1</tt> if the sqlany_stmt object is not valid.
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_num_params(VALUE api, VALUE sqlany_stmt)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_stmt* s_sqlany_stmt;
+    sacapi_i32 result;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_stmt, a_sqlany_stmt, s_sqlany_stmt);
+
+    result = s_api->sqlany_num_params(s_sqlany_stmt);
+    
+    return( INT2NUM(result) );    
+}
+
+/*
+ * call-seq:
+ *   sqlany_get_next_result(VALUE api, VALUE sqlany_stmt) -> VALUE result
+ * 
+ *  Advance to the next result set in a multiple result set query.
+ *
+ *  If a query (such as a call to a stored procedure) returns multiple result sets, 
+ *  then this function advances from the current result set to the next. 
+ * 
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_stmt</tt> -- A statement object that was executed by sqlany_execute() or sqlany_execute_direct()
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> if was successfully able to advance to the next result set, <tt>0</tt> otherwise
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_get_next_result(VALUE api, VALUE sqlany_stmt)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_stmt* s_sqlany_stmt;
+    sacapi_bool result;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_stmt, a_sqlany_stmt, s_sqlany_stmt);
+
+    result = s_api->sqlany_get_next_result(s_sqlany_stmt);
+    
+    return( INT2NUM(result) );    
+}
+
+/*
+ * call-seq:
+ *   sqlany_fetch_absolute(VALUE api, VALUE sqlany_stmt, VALUE offset) -> VALUE result
+ * 
+ *  Fetch data at a specific row number in the result set.
+ *
+ *  This function moves the current row in the result set to the row number specified and fetches the data at that row. 
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_stmt</tt> -- A statement object that was executed by sqlany_execute() or sqlany_execute_direct()
+ *  - <tt>VALUE offset</tt> -- he row number to be fetched. The first row is <tt>1</tt>, the last row is <tt>-1</tt>.
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE result</tt>: <tt>1</tt> if the fetch was successfully, <tt>0</tt> otherwise
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_fetch_absolute(VALUE api, VALUE sqlany_stmt, VALUE offset)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_stmt* s_sqlany_stmt;
+    sacapi_i32  s_offset;
+    sacapi_bool result;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_stmt, a_sqlany_stmt, s_sqlany_stmt);
+    s_offset = NUM2INT(offset);
+    result = s_api->sqlany_fetch_absolute(s_sqlany_stmt, s_offset);
+    
+    return( INT2NUM(result) );    
+}
+
+/*
+ * call-seq:
+ *   sqlany_sqlstate(VALUE api, VALUE sqlany_conn) -> VALUE sqlstate_str
+ * 
+ *  Retrieve the current SQL state.
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_conn</tt> -- A connection object that was connected by sqlany_connect()
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE sqlstate_str</tt>: The SQL State
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_sqlstate(VALUE api, VALUE sqlany_conn)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_connection* s_sqlany_conn;
+    size_t s_size; 
+    char   s_buffer[255];
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_conn, a_sqlany_connection, s_sqlany_conn);
+
+    s_size = s_api->sqlany_sqlstate(s_sqlany_conn, s_buffer, sizeof(s_buffer));
+
+    return( rb_str_new(s_buffer, s_size));
+}
+
+/*
+ * call-seq:
+ *   sqlany_clear_error(VALUE api, VALUE sqlany_conn) -> nil
+ * 
+ *  Clears the last stored error code.
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE api</tt> --  an initialized API structure to finalize
+ *  - <tt>VALUE sqlany_conn</tt> -- A connection object that was connected by sqlany_connect()
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt>:
+ *   
+ */
+static VALUE
+static_SQLAnywhereInterface_sqlany_clear_error(VALUE api, VALUE sqlany_conn)
+{
+    SQLAnywhereInterface* s_api;
+    a_sqlany_connection* s_sqlany_conn;
+
+    Data_Get_Struct(api, SQLAnywhereInterface, s_api);
+    Data_Get_Struct(sqlany_conn, a_sqlany_connection, s_sqlany_conn);
+
+    s_api->sqlany_clear_error(s_sqlany_conn);
+    
+    return( Qnil );
+}
+
+/*
+ * call-seq:
+ *   get_name(VALUE bind) -> VALUE name
+ * 
+ *  Get name of the bound paramater.
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE bind</tt> -- Bound parameter retrieved from sqlany_describe_bind_param()
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE name</tt>: The bound variable's name
+ *   
+ */
+static VALUE
+static_Bind_get_name(VALUE bind)
+{
+    a_sqlany_bind_param* s_bind;
+    Data_Get_Struct(bind, a_sqlany_bind_param, s_bind);
+    return (rb_str_new2(s_bind->name));
+}
+
+/*
+ * call-seq:
+ *   set_value(VALUE bind, VALUE val) -> nil
+ * 
+ *  Set the value of a bind parameter.
+ *
+ *  Used to bind a Ruby VALUE to a give parameter in a prepared statement
+ *  If the bind_direction is INPUT only, the type INPUT will be bound
+ *  based on the RUBY type:
+ *
+ *    +-------------+------------+
+ *    | Ruby Type   |  Bind Type |
+ *    +-------------+------------+
+ *    | T_STRING   =>  A_STRING  |
+ *    | T_FIXNUM   =>  A_VAL_32  |
+ *    | T_BIGNUM   =>  A_DOUBLE  |
+ *    | T_FLOAT    =>  A_DOUBLE  |
+ *    | T_STRING   =>  A_STRING  |
+ *    | T_NIL      => isnull = 1 |
+ *    +--------------------------+
+ *
+ *  If the bind direction is output, instead use DBCAPI type to set the size of the buffer
+ *
+ *  In the case of INOUT parameters, it is the applications job to call this method twice, 
+ *  once to bind the INPUT, once to bind the OUTPUT
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE bind</tt> -- Bound parameter retrieved from sqlany_describe_bind_param()
+ *  - <tt>VALUE val</tt> -- The value to bind into the bound variable
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt>
+ */
+static VALUE
+static_Bind_set_value(VALUE bind, VALUE val)
+{
+    a_sqlany_bind_param* s_bind;
+    int length;
+
+    Data_Get_Struct(bind, a_sqlany_bind_param, s_bind); 
+
+    // FIXME: use Ruby's allocation routines?
+    s_bind->value.is_null = malloc(sizeof(sacapi_bool));
+    *s_bind->value.is_null = 0;
+
+    if (s_bind->direction == DD_INPUT)
+    {
+       switch(TYPE(val))
+       {
+	 case T_STRING:      
+	    s_bind->value.length  = malloc(sizeof(size_t));
+	    length = RSTRING(val)->len;
+	    *s_bind->value.length = length;
+	    s_bind->value.buffer = malloc(length);
+	    memcpy(s_bind->value.buffer, RSTRING(val)->ptr, length);
+	    s_bind->value.type = A_STRING;
+	    break;
+	 case T_FIXNUM:
+	    s_bind->value.buffer = malloc(sizeof(int));
+	    *((int*)s_bind->value.buffer) = FIX2INT(val);
+	    s_bind->value.type = A_VAL32;
+	    break;
+	 case T_BIGNUM:
+	    s_bind->value.buffer = malloc(sizeof(LONG_LONG));
+	    *((LONG_LONG*)s_bind->value.buffer) = rb_num2ll(val);	
+	    s_bind->value.type = A_VAL64;  
+	    break;
+	 case T_FLOAT:
+	    s_bind->value.buffer = malloc(sizeof(double));
+	    *((double*)s_bind->value.buffer) = NUM2DBL(val);
+	    s_bind->value.type = A_DOUBLE;
+	    break;
+	 case T_NIL:
+	    *s_bind->value.is_null = 1;	 	 
+	    s_bind->value.buffer = malloc(sizeof(int));
+	    s_bind->value.type = A_VAL32;
+	    break;
+	 default:
+	    rb_raise(rb_eTypeError, "Cannot convert type. Must be STRING, FIXNUM, BIGNUM, FLOAT, or NIL");
+	    break;
+       }
+    }
+    else
+    {
+      switch (s_bind->value.type)
+      {
+	 case A_STRING:
+	    s_bind->value.buffer = malloc(s_bind->value.buffer_size);
+	    break;
+	 case A_DOUBLE:
+	    s_bind->value.buffer = malloc(sizeof(float));
+	    break;
+   	 case A_VAL64:
+   	 case A_UVAL64:
+	    s_bind->value.buffer = malloc(sizeof(LONG_LONG));	   
+	    break;
+         case A_VAL32:
+         case A_UVAL32:
+	    s_bind->value.buffer = malloc(sizeof(int));
+	    break;
+	 case A_VAL16:
+	 case A_UVAL16:
+	    s_bind->value.buffer = malloc(sizeof(short));
+	    break;
+	 case A_VAL8:
+	 case A_UVAL8:
+   	    s_bind->value.buffer = malloc(sizeof(char));
+	    break;
+	 default:
+	    rb_raise(rb_eTypeError, "Type unknown");
+	    break;
+      }
+    }
+    return (Qnil);
+}
+
+/*
+ * call-seq:
+ *   set_direction(VALUE bind, VALUE direction) -> nil
+ * 
+ *  Set the direction of the bound parameter before binding
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE bind</tt> -- Bound parameter retrieved from sqlany_describe_bind_param()
+ *  - <tt>VALUE direction</tt> -- The direction of the binding variable
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt>
+ *   
+ */
+static VALUE
+static_Bind_set_direction(VALUE bind, VALUE direction)
+{
+    a_sqlany_bind_param* s_bind;
+
+    Data_Get_Struct(bind, a_sqlany_bind_param, s_bind);
+
+    s_bind->direction = NUM2CHR(direction);
+
+    return (Qnil);
+}
+
+/*
+ * call-seq:
+ *   set_buffer_size(VALUE bind, VALUE size) -> nil
+ * 
+ *  For strings and binary, set the buffer size of INOUT and OUT parameters
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE bind</tt> -- Bound parameter retrieved from sqlany_describe_bind_param()
+ *  - <tt>VALUE size</tt> -- The size of the buffer to hold the INOUT or OUT parameter
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt>
+ *   
+ */
+static VALUE
+static_Bind_set_buffer_size(VALUE bind, VALUE size)
+{
+    a_sqlany_bind_param* s_bind;
+
+    Data_Get_Struct(bind, a_sqlany_bind_param, s_bind);
+
+    s_bind->value.buffer_size = NUM2INT(size);
+
+    return (Qnil);
+}
+
+/*
+ * call-seq:
+ *   get_direction(VALUE bind) -> VALUE direction
+ * 
+ *  Get direction of the bound paramater.
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE bind</tt> -- Bound parameter retrieved from sqlany_describe_bind_param()
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE name</tt>: The direction of the bound parameter
+ *   
+ */
+static VALUE
+static_Bind_get_direction(VALUE bind)
+{
+    a_sqlany_bind_param* s_bind;
+    Data_Get_Struct(bind, a_sqlany_bind_param, s_bind);
+
+    return (CHR2FIX(s_bind->direction));
+}
+
+/*
+ * call-seq:
+ *   finish(VALUE bind) -> nil
+ * 
+ *  Free resources associated with the bound parameter
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE bind</tt> -- Bound parameter retrieved from sqlany_describe_bind_param()
+ *
+ *  <b>Returns</b>:
+ *  - <tt>nil</tt>
+ *   
+ */
+static VALUE
+static_Bind_finish(VALUE bind)
+{
+    a_sqlany_bind_param* s_bind;
+
+    Data_Get_Struct(bind, a_sqlany_bind_param, s_bind);
+
+    // FIXME: use Ruby's allocation routines?
+    if (s_bind) { free(s_bind);};
+
+    return (Qnil);
+}
+
+/*
+ * call-seq:
+ *  get_info_direction(VALUE bind) -> VALUE direction
+ * 
+ *  Get name of the bound paramater info object.
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE bind</tt> -- Bound parameter info retrieved from sqlany_describe_bind_param_info()
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE direction</tt>: The bound variable's direction
+ *   
+ */
+static VALUE
+static_Bind_get_info_direction(VALUE bind)
+{
+    a_sqlany_bind_param_info* s_bind;
+    Data_Get_Struct(bind, a_sqlany_bind_param_info, s_bind);
+
+    return (CHR2FIX(s_bind->direction));
+}
+
+/*
+ * call-seq:
+ *   get_info_output(VALUE bind) -> VALUE name
+ * 
+ *  Get the value of a bound parameter after execution
+ *  
+ *  <b>Parameters</b>:
+ *  - <tt>VALUE bind</tt> -- Bound parameter retrieved from sqlany_describe_bind_param()
+ *
+ *  <b>Returns</b>:
+ *  - <tt>VALUE name</tt>: The bound variable value
+ *   
+ */
+static VALUE
+static_Bind_get_info_output(VALUE bind)
+{
+    a_sqlany_bind_param_info* s_bind;
+    Data_Get_Struct(bind, a_sqlany_bind_param_info, s_bind);
+
+    if( *s_bind->output_value.is_null ) {
+       return( Qnil );
+    }
+    else
+    {
+       return(C2RB(&s_bind->output_value));
+    }
+}
+
+/*
+ *
+ */
+void Init_sqlanywhere()
+{
+  // Define top leve 'SQLAnywhere' module
+  mSQLAnywhere = rb_define_module( "SQLAnywhere" );
+
+  // Define a sub-module name 'API' under SQLAnywhere.
+  // In Ruby, this is accessed as SQLAnywhere::API
+  mAPI = rb_define_module_under( mSQLAnywhere, "API" );
+
+  // Define sqlany interface functions
+  rb_define_module_function( mAPI, "sqlany_initialize_interface", static_API_sqlany_initialize_interface, 1 );
+  rb_define_module_function( mAPI, "sqlany_finalize_interface", static_API_sqlany_finalize_interface, 1 );
+  rb_define_const(mAPI, "VERSION", rb_str_new2(VERSION));
+  
+
+  // Define interface classes under the SQLAnywhere module
+  cSQLAnywhereInterface = rb_define_class_under( mSQLAnywhere, "SQLAnywhereInterface", rb_cObject);
+  rb_define_alloc_func(cSQLAnywhereInterface, static_SQLAnywhereInterface_alloc);
+
+  // Define all of the DBCAPI functions as methods under an interface instance
+  rb_define_method(cSQLAnywhereInterface, "sqlany_init", static_SQLAnywhereInterface_sqlany_init, 0);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_new_connection", static_SQLAnywhereInterface_sqlany_new_connection, 0);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_connect", static_SQLAnywhereInterface_sqlany_connect, 2);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_disconnect", static_SQLAnywhereInterface_sqlany_disconnect, 1);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_free_connection", static_SQLAnywhereInterface_sqlany_free_connection, 1);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_fini", static_SQLAnywhereInterface_sqlany_fini, 0);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_error", static_SQLAnywhereInterface_sqlany_error, 1);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_execute_immediate", static_SQLAnywhereInterface_sqlany_execute_immediate, 2);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_execute_direct", static_SQLAnywhereInterface_sqlany_execute_direct, 2);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_num_cols", static_SQLAnywhereInterface_sqlany_num_cols, 1);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_num_rows", static_SQLAnywhereInterface_sqlany_num_rows, 1);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_get_column", static_SQLAnywhereInterface_sqlany_get_column, 2);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_fetch_next", static_SQLAnywhereInterface_sqlany_fetch_next, 1);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_get_column_info", static_SQLAnywhereInterface_sqlany_get_column_info, 2);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_commit", static_SQLAnywhereInterface_sqlany_commit, 1);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_rollback", static_SQLAnywhereInterface_sqlany_rollback, 1);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_prepare", static_SQLAnywhereInterface_sqlany_prepare, 2);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_free_stmt", static_SQLAnywhereInterface_sqlany_free_stmt, 1);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_execute", static_SQLAnywhereInterface_sqlany_execute, 1);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_affected_rows", static_SQLAnywhereInterface_sqlany_affected_rows, 1);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_describe_bind_param", static_SQLAnywhereInterface_sqlany_describe_bind_param, 2);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_bind_param", static_SQLAnywhereInterface_sqlany_bind_param, 3);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_get_bind_param_info", static_SQLAnywhereInterface_sqlany_get_bind_param_info, 2);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_num_params", static_SQLAnywhereInterface_sqlany_num_params, 1);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_get_next_result", static_SQLAnywhereInterface_sqlany_get_next_result, 1);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_fetch_absolute", static_SQLAnywhereInterface_sqlany_fetch_absolute, 2);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_sqlstate", static_SQLAnywhereInterface_sqlany_sqlstate, 1);
+  rb_define_method(cSQLAnywhereInterface, "sqlany_clear_error", static_SQLAnywhereInterface_sqlany_clear_error, 1);
+
+  // Define classes for accessing structures under SQLAnywhere module
+  cA_sqlany_connection = rb_define_class_under (mSQLAnywhere, "a_sqlany_connection", rb_cObject);
+  cA_sqlany_data_value = rb_define_class_under (mSQLAnywhere, "a_sqlany_data_value", rb_cObject);
+  cA_sqlany_stmt = rb_define_class_under (mSQLAnywhere, "a_sqlany_stmt", rb_cObject);  
+  cA_sqlany_bind_param = rb_define_class_under (mSQLAnywhere, "a_sqlany_bind_param", rb_cObject);
+  cA_sqlany_bind_param_info = rb_define_class_under (mSQLAnywhere, "a_sqlany_bind_param_info", rb_cObject);
+
+
+  // Define methods for obtaining bind_parameter fields
+  rb_define_method(cA_sqlany_bind_param, "get_name", static_Bind_get_name, 0);
+  rb_define_method(cA_sqlany_bind_param, "set_value", static_Bind_set_value, 1);
+  rb_define_method(cA_sqlany_bind_param, "get_direction", static_Bind_get_direction, 0);
+  rb_define_method(cA_sqlany_bind_param, "set_direction", static_Bind_set_direction, 1);  
+  rb_define_method(cA_sqlany_bind_param, "set_buffer_size", static_Bind_set_buffer_size, 1);  
+  rb_define_method(cA_sqlany_bind_param, "finish", static_Bind_finish, 0);  
+  
+  // Define methods for obtainting bind_paramenter_info fields
+  rb_define_method(cA_sqlany_bind_param_info, "get_direction", static_Bind_get_info_direction, 0);
+  rb_define_method(cA_sqlany_bind_param_info, "get_output", static_Bind_get_info_output, 0);
+}
+
+