ruby-odbc 0.99995 → 0.99996

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c7479d33fa9c59ff9ddceda117a54eff5b755a40
-  data.tar.gz: ffe877023d88272ddb59da531bf1fda03cdf6c35
+  metadata.gz: 7504ee7d8bcf0055aa40cdb22f44a7bf697f3494
+  data.tar.gz: 10f13522e517035268aaee2af4964911e06068d2
 SHA512:
-  metadata.gz: 95b9dd91fe942297cd879cfc83c82af7fe9a2aeaabcff01a65a9870b89886e8a7d729f8a2119241d46363282081bfeb9d8c0a21daf8836b619807deea947d0e8
-  data.tar.gz: 328aa7cff9af2f30af215560abc65d947879468299e31e449d7c919cb146a84effde0f88e9816fd7633230c70ecded79417db8dae00d1cb882f76b114f2d6040
+  metadata.gz: b7d6a796455a8bd4e9cdb8dfff99b30424a4cc15a4346a95bdedb7975dcdc48e729090ae7d1c34f589c29d705c8f8b8c1ba153234373f9cf0f75707043922002
+  data.tar.gz: 3478edc7204561c5b930e203b0879bf93d3d19a15b653750e4395a2b22c9c0ec2de49b37f9b8d45659760acaf0a9584cc91ddcccfb27f441f2334d0523f791b1

data/ChangeLog

@@ -1,6 +1,12 @@
 ODBC binding for Ruby
 ---------------------
 
+Wed Mar 25 2015 version 0.99996 released
+
+	* when built for Ruby >= 2.0 release GVL for potentially
+	  long running ODBC API functions, thanks Matt Conover
+	  for initial implementation
+
 Wed Mar 13 2013 version 0.99995 released
 
 	* added ODBC::Database.use_sql_column_name= flag to switch

data/README

@@ -1,6 +1,6 @@
-# $Id: README,v 1.42 2013/03/13 19:24:03 chw Exp chw $
+# $Id: README,v 1.43 2015/03/25 10:54:58 chw Exp chw $
 
-ruby-odbc-0.99995
+ruby-odbc-0.99996
 
 This is an ODBC binding for Ruby. So far it has been tested with
 

data/ext/extconf.rb

@@ -78,6 +78,40 @@ rescue
   puts "WARNING: the option -DHAVE_TYPE_SQLULEN"
 end
 $have_odbcinst_h = have_header("odbcinst.h")
+begin
+  if PLATFORM !~ /(mingw|cygwin)/ then
+    header = "sqltypes.h"
+  else
+    header = ["windows.h", "sqltypes.h"]
+  end
+  if defined? have_type
+    have_type("SQLROWOFFSET", header)
+  else
+    throw
+  end
+rescue
+  puts "WARNING: please check sqltypes.h for SQLROWOFFSET manually,"
+  puts "WARNING: if defined, modify CFLAGS in Makefile to contain"
+  puts "WARNING: the option -DHAVE_TYPE_SQLROWOFFSET"
+end
+$have_odbcinst_h = have_header("odbcinst.h")
+begin
+  if PLATFORM !~ /(mingw|cygwin)/ then
+    header = "sqltypes.h"
+  else
+    header = ["windows.h", "sqltypes.h"]
+  end
+  if defined? have_type
+    have_type("SQLROWSETSIZE", header)
+  else
+    throw
+  end
+rescue
+  puts "WARNING: please check sqltypes.h for SQLROWSETSIZE manually,"
+  puts "WARNING: if defined, modify CFLAGS in Makefile to contain"
+  puts "WARNING: the option -DHAVE_TYPE_SQLROWSETSIZE"
+end
+$have_odbcinst_h = have_header("odbcinst.h")
 
 if PLATFORM =~ /mswin32/ then
   if !have_library_ex("odbc32", "SQLAllocConnect", "sql.h") ||

data/ext/odbc.c

@@ -1,6 +1,6 @@
 /*
  * ODBC-Ruby binding
- * Copyright (c) 2001-2013 Christian Werner <chw@ch-werner.de>
+ * Copyright (c) 2001-2015 Christian Werner <chw@ch-werner.de>
  * Portions copyright (c) 2004 Ryszard Niewisiewicz <micz@fibernet.pl>
  * Portions copyright (c) 2006 Carl Blakeley <cblakeley@openlinksw.co.uk>
  *
@@ -8,7 +8,7 @@
  * and redistribution of this file and for a
  * DISCLAIMER OF ALL WARRANTIES.
  *
- * $Id: odbc.c,v 1.75 2013/03/13 19:31:13 chw Exp chw $
+ * $Id: odbc.c,v 1.76 2015/03/25 10:55:52 chw Exp chw $
  */
 
 #undef ODBCVER
@@ -49,16 +49,26 @@ typedef SQLCHAR SQLTCHAR;
 #endif
 
 #ifndef HAVE_TYPE_SQLLEN
-#define SQLLEN  SQLINTEGER
+#define SQLLEN SQLINTEGER
 #endif
 #ifndef HAVE_TYPE_SQLULEN
 #define SQLULEN SQLUINTEGER
 #endif
+#ifndef HAVE_TYPE_SQLROWOFFSET
+#define SQLROWOFFSET SQLLEN
+#endif
+#ifndef HAVE_TYPE_SQLROWSETSIZE
+#define SQLROWSETSIZE SQLULEN
+#endif
 
 #if (RUBY_VERSION_MAJOR <= 1) && (RUBY_VERSION_MINOR < 9)
 #define TIME_USE_USEC 1
 #endif
 
+#ifdef HAVE_RUBY_THREAD_H
+#include "ruby/thread.h"
+#endif
+
 /*
  * Conditionally undefine aliases of ODBC installer UNICODE functions.
  */
@@ -163,7 +173,7 @@ typedef struct dbc {
     VALUE self;
     VALUE env;
     struct env *envp;
-    LINK stmts; 
+    LINK stmts;
     SQLHDBC hdbc;
     VALUE rbtime;
     VALUE gmtime;
@@ -355,7 +365,911 @@ static const char *colnamebuf[] = {
 /*
  *----------------------------------------------------------------------
  *
- *      UNICODE converters et.al.
+ *	Wrappers for long running SQL APIs with GVL released.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifdef RUBY_CALL_WO_GVL_FLAG_SKIP_CHECK_INTS_
+
+static void
+empty_ubf(void *args)
+{
+}
+
+struct S_SQLCONNECT {
+    SQLHDBC hdbc;
+    SQLTCHAR *dsn;
+    SQLSMALLINT dsn_len;
+    SQLTCHAR *usr;
+    SQLSMALLINT usr_len;
+    SQLTCHAR *pwd;
+    SQLSMALLINT pwd_len;
+};
+
+static void *
+F_SQLCONNECT(void *args)
+{
+    size_t ret;
+    struct S_SQLCONNECT *argp = (struct S_SQLCONNECT *) args;
+
+    ret = SQLConnect(argp->hdbc, argp->dsn, argp->dsn_len,
+		     argp->usr, argp->usr_len, argp->pwd, argp->pwd_len);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLCONNECT(SQLHDBC hdbc, SQLTCHAR *dsn, SQLSMALLINT dsn_len, SQLTCHAR *usr,
+	   SQLSMALLINT usr_len, SQLTCHAR *pwd, SQLSMALLINT pwd_len)
+{
+    size_t ret;
+    struct S_SQLCONNECT arg;
+
+    arg.hdbc = hdbc;
+    arg.dsn = dsn;
+    arg.dsn_len = dsn_len;
+    arg.usr = usr;
+    arg.usr_len = usr_len;
+    arg.pwd = pwd;
+    arg.pwd_len = pwd_len;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLCONNECT, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+struct S_SQLDRIVERCONNECT {
+    SQLHDBC hdbc;
+    SQLHWND hwnd;
+    SQLTCHAR *connin;
+    SQLSMALLINT connin_len;
+    SQLTCHAR *connout;
+    SQLSMALLINT connout_max;
+    SQLSMALLINT *connout_len;
+    SQLUSMALLINT compl;
+};
+
+static void *
+F_SQLDRIVERCONNECT(void *args)
+{
+    size_t ret;
+    struct S_SQLDRIVERCONNECT *argp = (struct S_SQLDRIVERCONNECT *) args;
+
+    ret = SQLDriverConnect(argp->hdbc, argp->hwnd, argp->connin,
+			   argp->connin_len, argp->connout, argp->connout_max,
+			   argp->connout_len, argp->compl);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLDRIVERCONNECT(SQLHDBC hdbc, SQLHWND hwnd, SQLTCHAR *connin,
+		 SQLSMALLINT connin_len, SQLTCHAR *connout,
+		 SQLSMALLINT connout_max, SQLSMALLINT *connout_len,
+		 SQLUSMALLINT compl)
+{
+    size_t ret;
+    struct S_SQLDRIVERCONNECT arg;
+
+    arg.hdbc = hdbc;
+    arg.hwnd = hwnd;
+    arg.connin = connin;
+    arg.connin_len = connin_len;
+    arg.connout = connout;
+    arg.connout_max = connout_max;
+    arg.connout_len = connout_len;
+    arg.compl = compl;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLDRIVERCONNECT, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+struct S_SQLDISCONNECT {
+    SQLHSTMT hstmt;
+};
+
+static void *
+F_SQLDISCONNECT(void *args)
+{
+    size_t ret;
+    struct S_SQLDISCONNECT *argp = (struct S_SQLDISCONNECT *) args;
+
+    ret = SQLDisconnect(argp->hstmt);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLDISCONNECT(SQLHSTMT hstmt)
+{
+    size_t ret;
+    struct S_SQLDISCONNECT arg;
+
+    arg.hstmt = hstmt;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLDISCONNECT, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+struct S_SQLTABLES {
+    SQLHSTMT hdbc;
+    SQLTCHAR *cat;
+    SQLSMALLINT cat_len;
+    SQLTCHAR *sch;
+    SQLSMALLINT sch_len;
+    SQLTCHAR *tbl;
+    SQLSMALLINT tbl_len;
+    SQLTCHAR *typ;
+    SQLSMALLINT typ_len;
+};
+
+static void *
+F_SQLTABLES(void *args)
+{
+    size_t ret;
+    struct S_SQLTABLES *argp = (struct S_SQLTABLES *) args;
+
+    ret = SQLTables(argp->hdbc, argp->cat, argp->cat_len,
+		    argp->sch, argp->sch_len, argp->tbl,
+		    argp->tbl_len, argp->typ, argp->typ_len);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLTABLES(SQLHDBC hdbc, SQLTCHAR *cat, SQLSMALLINT cat_len,
+	  SQLTCHAR *sch, SQLSMALLINT sch_len, SQLTCHAR *tbl,
+	  SQLSMALLINT tbl_len, SQLTCHAR *typ, SQLSMALLINT typ_len)
+{
+    size_t ret;
+    struct S_SQLTABLES arg;
+
+    arg.hdbc = hdbc;
+    arg.cat = cat;
+    arg.cat_len = cat_len;
+    arg.sch = sch;
+    arg.sch_len = sch_len;
+    arg.tbl = tbl;
+    arg.tbl_len = tbl_len;
+    arg.typ = typ;
+    arg.typ_len = typ_len;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLTABLES, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+struct S_SQLCOLUMNS {
+    SQLHSTMT hdbc;
+    SQLTCHAR *cat;
+    SQLSMALLINT cat_len;
+    SQLTCHAR *sch;
+    SQLSMALLINT sch_len;
+    SQLTCHAR *tbl;
+    SQLSMALLINT tbl_len;
+    SQLTCHAR *col;
+    SQLSMALLINT col_len;
+};
+
+static void *
+F_SQLCOLUMNS(void *args)
+{
+    size_t ret;
+    struct S_SQLCOLUMNS *argp = (struct S_SQLCOLUMNS *) args;
+
+    ret = SQLColumns(argp->hdbc, argp->cat, argp->cat_len,
+		    argp->sch, argp->sch_len, argp->tbl,
+		    argp->tbl_len, argp->col, argp->col_len);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLCOLUMNS(SQLHDBC hdbc, SQLTCHAR *cat, SQLSMALLINT cat_len,
+	  SQLTCHAR *sch, SQLSMALLINT sch_len, SQLTCHAR *tbl,
+	  SQLSMALLINT tbl_len, SQLTCHAR *col, SQLSMALLINT col_len)
+{
+    size_t ret;
+    struct S_SQLCOLUMNS arg;
+
+    arg.hdbc = hdbc;
+    arg.cat = cat;
+    arg.cat_len = cat_len;
+    arg.sch = sch;
+    arg.sch_len = sch_len;
+    arg.tbl = tbl;
+    arg.tbl_len = tbl_len;
+    arg.col = col;
+    arg.col_len = col_len;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLCOLUMNS, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+struct S_SQLPRIMARYKEYS {
+    SQLHSTMT hdbc;
+    SQLTCHAR *cat;
+    SQLSMALLINT cat_len;
+    SQLTCHAR *sch;
+    SQLSMALLINT sch_len;
+    SQLTCHAR *tbl;
+    SQLSMALLINT tbl_len;
+};
+
+static void *
+F_SQLPRIMARYKEYS(void *args)
+{
+    size_t ret;
+    struct S_SQLPRIMARYKEYS *argp = (struct S_SQLPRIMARYKEYS *) args;
+
+    ret = SQLPrimaryKeys(argp->hdbc, argp->cat, argp->cat_len,
+			 argp->sch, argp->sch_len, argp->tbl, argp->tbl_len);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLPRIMARYKEYS(SQLHDBC hdbc, SQLTCHAR *cat, SQLSMALLINT cat_len,
+	       SQLTCHAR *sch, SQLSMALLINT sch_len, SQLTCHAR *tbl,
+	       SQLSMALLINT tbl_len)
+{
+    size_t ret;
+    struct S_SQLPRIMARYKEYS arg;
+
+    arg.hdbc = hdbc;
+    arg.cat = cat;
+    arg.cat_len = cat_len;
+    arg.sch = sch;
+    arg.sch_len = sch_len;
+    arg.tbl = tbl;
+    arg.tbl_len = tbl_len;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLPRIMARYKEYS, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+struct S_SQLFOREIGNKEYS {
+    SQLHSTMT hdbc;
+    SQLTCHAR *pkcat;
+    SQLSMALLINT pkcat_len;
+    SQLTCHAR *pksch;
+    SQLSMALLINT pksch_len;
+    SQLTCHAR *pktbl;
+    SQLSMALLINT pktbl_len;
+    SQLTCHAR *fkcat;
+    SQLSMALLINT fkcat_len;
+    SQLTCHAR *fksch;
+    SQLSMALLINT fksch_len;
+    SQLTCHAR *fktbl;
+    SQLSMALLINT fktbl_len;
+};
+
+static void *
+F_SQLFOREIGNKEYS(void *args)
+{
+    size_t ret;
+    struct S_SQLFOREIGNKEYS *argp = (struct S_SQLFOREIGNKEYS *) args;
+
+    ret = SQLForeignKeys(argp->hdbc, argp->pkcat, argp->pkcat_len,
+			 argp->pksch, argp->pksch_len,
+			 argp->pktbl, argp->pktbl_len,
+			 argp->fkcat, argp->fkcat_len,
+			 argp->fksch, argp->fksch_len,
+			 argp->fktbl, argp->fktbl_len);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLFOREIGNKEYS(SQLHDBC hdbc, SQLTCHAR *pkcat, SQLSMALLINT pkcat_len,
+	       SQLTCHAR *pksch, SQLSMALLINT pksch_len, SQLTCHAR *pktbl,
+	       SQLSMALLINT pktbl_len, SQLTCHAR *fkcat, SQLSMALLINT fkcat_len,
+	       SQLTCHAR *fksch, SQLSMALLINT fksch_len, SQLTCHAR *fktbl,
+	       SQLSMALLINT fktbl_len)
+{
+    size_t ret;
+    struct S_SQLFOREIGNKEYS arg;
+
+    arg.hdbc = hdbc;
+    arg.pkcat = pkcat;
+    arg.pkcat_len = pkcat_len;
+    arg.pksch = pksch;
+    arg.pksch_len = pksch_len;
+    arg.pktbl = pktbl;
+    arg.pktbl_len = pktbl_len;
+    arg.fkcat = fkcat;
+    arg.fkcat_len = fkcat_len;
+    arg.fksch = fksch;
+    arg.fksch_len = fksch_len;
+    arg.fktbl = fktbl;
+    arg.fktbl_len = fktbl_len;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLFOREIGNKEYS, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+struct S_SQLPROCEDURES {
+    SQLHSTMT hdbc;
+    SQLTCHAR *cat;
+    SQLSMALLINT cat_len;
+    SQLTCHAR *sch;
+    SQLSMALLINT sch_len;
+    SQLTCHAR *prc;
+    SQLSMALLINT prc_len;
+};
+
+static void *
+F_SQLPROCEDURES(void *args)
+{
+    size_t ret;
+    struct S_SQLPROCEDURES *argp = (struct S_SQLPROCEDURES *) args;
+
+    ret = SQLProcedures(argp->hdbc, argp->cat, argp->cat_len,
+			argp->sch, argp->sch_len, argp->prc, argp->prc_len);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLPROCEDURES(SQLHDBC hdbc, SQLTCHAR *cat, SQLSMALLINT cat_len,
+	      SQLTCHAR *sch, SQLSMALLINT sch_len, SQLTCHAR *prc,
+	      SQLSMALLINT prc_len)
+{
+    size_t ret;
+    struct S_SQLPROCEDURES arg;
+
+    arg.hdbc = hdbc;
+    arg.cat = cat;
+    arg.cat_len = cat_len;
+    arg.sch = sch;
+    arg.sch_len = sch_len;
+    arg.prc = prc;
+    arg.prc_len = prc_len;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLPROCEDURES, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+struct S_SQLPROCEDURECOLUMNS {
+    SQLHSTMT hdbc;
+    SQLTCHAR *cat;
+    SQLSMALLINT cat_len;
+    SQLTCHAR *sch;
+    SQLSMALLINT sch_len;
+    SQLTCHAR *prc;
+    SQLSMALLINT prc_len;
+    SQLTCHAR *col;
+    SQLSMALLINT col_len;
+};
+
+static void *
+F_SQLPROCEDURECOLUMNS(void *args)
+{
+    size_t ret;
+    struct S_SQLPROCEDURECOLUMNS *argp = (struct S_SQLPROCEDURECOLUMNS *) args;
+
+    ret = SQLProcedureColumns(argp->hdbc, argp->cat, argp->cat_len,
+			      argp->sch, argp->sch_len, argp->prc,
+			      argp->prc_len, argp->col, argp->col_len);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLPROCEDURECOLUMNS(SQLHDBC hdbc, SQLTCHAR *cat, SQLSMALLINT cat_len,
+		    SQLTCHAR *sch, SQLSMALLINT sch_len, SQLTCHAR *prc,
+		    SQLSMALLINT prc_len, SQLTCHAR *col, SQLSMALLINT col_len)
+{
+    size_t ret;
+    struct S_SQLPROCEDURECOLUMNS arg;
+
+    arg.hdbc = hdbc;
+    arg.cat = cat;
+    arg.cat_len = cat_len;
+    arg.sch = sch;
+    arg.sch_len = sch_len;
+    arg.prc = prc;
+    arg.prc_len = prc_len;
+    arg.col = col;
+    arg.col_len = col_len;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLPROCEDURECOLUMNS, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+struct S_SQLTABLEPRIVILEGES {
+    SQLHSTMT hdbc;
+    SQLTCHAR *cat;
+    SQLSMALLINT cat_len;
+    SQLTCHAR *sch;
+    SQLSMALLINT sch_len;
+    SQLTCHAR *tbl;
+    SQLSMALLINT tbl_len;
+};
+
+static void *
+F_SQLTABLEPRIVILEGES(void *args)
+{
+    size_t ret;
+    struct S_SQLTABLEPRIVILEGES *argp = (struct S_SQLTABLEPRIVILEGES *) args;
+
+    ret = SQLTablePrivileges(argp->hdbc, argp->cat, argp->cat_len,
+			     argp->sch, argp->sch_len, argp->tbl,
+			     argp->tbl_len);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLTABLEPRIVILEGES(SQLHDBC hdbc, SQLTCHAR *cat, SQLSMALLINT cat_len,
+		   SQLTCHAR *sch, SQLSMALLINT sch_len, SQLTCHAR *tbl,
+		   SQLSMALLINT tbl_len)
+{
+    size_t ret;
+    struct S_SQLTABLEPRIVILEGES arg;
+
+    arg.hdbc = hdbc;
+    arg.cat = cat;
+    arg.cat_len = cat_len;
+    arg.sch = sch;
+    arg.sch_len = sch_len;
+    arg.tbl = tbl;
+    arg.tbl_len = tbl_len;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLTABLEPRIVILEGES, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+struct S_SQLSTATISTICS {
+    SQLHSTMT hdbc;
+    SQLTCHAR *cat;
+    SQLSMALLINT cat_len;
+    SQLTCHAR *sch;
+    SQLSMALLINT sch_len;
+    SQLTCHAR *tbl;
+    SQLSMALLINT tbl_len;
+    SQLUSMALLINT uniq;
+    SQLUSMALLINT resv;
+};
+
+static void *
+F_SQLSTATISTICS(void *args)
+{
+    size_t ret;
+    struct S_SQLSTATISTICS *argp = (struct S_SQLSTATISTICS *) args;
+
+    ret = SQLStatistics(argp->hdbc, argp->cat, argp->cat_len,
+			argp->sch, argp->sch_len, argp->tbl,
+			argp->tbl_len, argp->uniq, argp->resv);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLSTATISTICS(SQLHDBC hdbc, SQLTCHAR *cat, SQLSMALLINT cat_len,
+	      SQLTCHAR *sch, SQLSMALLINT sch_len, SQLTCHAR *tbl,
+	      SQLSMALLINT tbl_len, SQLUSMALLINT uniq, SQLUSMALLINT resv)
+{
+    size_t ret;
+    struct S_SQLSTATISTICS arg;
+
+    arg.hdbc = hdbc;
+    arg.cat = cat;
+    arg.cat_len = cat_len;
+    arg.sch = sch;
+    arg.sch_len = sch_len;
+    arg.tbl = tbl;
+    arg.tbl_len = tbl_len;
+    arg.uniq = uniq;
+    arg.resv = resv;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLSTATISTICS, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+struct S_SQLSPECIALCOLUMNS {
+    SQLHSTMT hdbc;
+    SQLUSMALLINT idtyp;
+    SQLTCHAR *cat;
+    SQLSMALLINT cat_len;
+    SQLTCHAR *sch;
+    SQLSMALLINT sch_len;
+    SQLTCHAR *tbl;
+    SQLSMALLINT tbl_len;
+    SQLUSMALLINT scope;
+    SQLUSMALLINT nulbl;
+};
+
+static void *
+F_SQLSPECIALCOLUMNS(void *args)
+{
+    size_t ret;
+    struct S_SQLSPECIALCOLUMNS *argp = (struct S_SQLSPECIALCOLUMNS *) args;
+
+    ret = SQLSpecialColumns(argp->hdbc, argp->idtyp, argp->cat, argp->cat_len,
+			    argp->sch, argp->sch_len, argp->tbl,
+			    argp->tbl_len, argp->scope, argp->nulbl);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLSPECIALCOLUMNS(SQLHDBC hdbc, SQLUSMALLINT idtyp, SQLTCHAR *cat,
+		  SQLSMALLINT cat_len, SQLTCHAR *sch, SQLSMALLINT sch_len,
+		  SQLTCHAR *tbl, SQLSMALLINT tbl_len,
+		  SQLUSMALLINT scope, SQLUSMALLINT nulbl)
+{
+    size_t ret;
+    struct S_SQLSPECIALCOLUMNS arg;
+
+    arg.hdbc = hdbc;
+    arg.idtyp = idtyp;
+    arg.cat = cat;
+    arg.cat_len = cat_len;
+    arg.sch = sch;
+    arg.sch_len = sch_len;
+    arg.tbl = tbl;
+    arg.tbl_len = tbl_len;
+    arg.scope = scope;
+    arg.nulbl = nulbl;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLSPECIALCOLUMNS, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+struct S_SQLGETTYPEINFO {
+    SQLHSTMT hdbc;
+    SQLSMALLINT type;
+};
+
+static void *
+F_SQLGETTYPEINFO(void *args)
+{
+    size_t ret;
+    struct S_SQLGETTYPEINFO *argp = (struct S_SQLGETTYPEINFO *) args;
+
+    ret = SQLGetTypeInfo(argp->hdbc, argp->type);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLGETTYPEINFO(SQLHDBC hdbc, SQLSMALLINT type)
+{
+    size_t ret;
+    struct S_SQLGETTYPEINFO arg;
+
+    arg.hdbc = hdbc;
+    arg.type = type;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLGETTYPEINFO, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+#if (ODBCVER >= 0x0300)
+
+struct S_SQLENDTRAN {
+    SQLSMALLINT htype;
+    SQLHANDLE handle;
+    SQLSMALLINT op;
+};
+
+static void *
+F_SQLENDTRAN(void *args)
+{
+    size_t ret;
+    struct S_SQLENDTRAN *argp = (struct S_SQLENDTRAN *) args;
+
+    ret = SQLEndTran(argp->htype, argp->handle, argp->op);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLENDTRAN(SQLUSMALLINT htype, SQLHANDLE handle, SQLUSMALLINT op)
+{
+    size_t ret;
+    struct S_SQLENDTRAN arg;
+
+    arg.htype = htype;
+    arg.handle = handle;
+    arg.op = op;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLENDTRAN, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+#else
+
+struct S_SQLTRANSACT {
+    SQLHENV henv;
+    SQLHDBC hdbc;
+    SQLSMALLINT op;
+};
+
+static void *
+F_SQLTRANSACT(void *args)
+{
+    size_t ret;
+    struct S_SQLTRANSACT *argp = (struct S_SQLTRANSACT *) args;
+
+    ret = SQLTransact(argp->henv, argp->hdbc, argp->op);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLTRANSACT(SQLHENV henv, SQLHDBC hdbc, SQLUSMALLINT op)
+{
+    size_t ret;
+    struct S_SQLTRANSACT arg;
+
+    arg.henv = henv;
+    arg.hdbc = hdbc;
+    arg.op = op;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLTRANCACT, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+#endif
+
+struct S_SQLEXECDIRECT {
+    SQLHSTMT hstmt;
+    SQLTCHAR *sql;
+    SQLINTEGER len;
+};
+
+static void *
+F_SQLEXECDIRECT(void *args)
+{
+    size_t ret;
+    struct S_SQLEXECDIRECT *argp = (struct S_SQLEXECDIRECT *) args;
+
+    ret = SQLExecDirect(argp->hstmt, argp->sql, argp->len);
+    return (void *) ret;
+}
+
+static void
+F_SQLEXECDIRECT_UBF(void *args)
+{
+    struct S_SQLEXECDIRECT *argp = (struct S_SQLEXECDIRECT *) args;
+
+    SQLCancel(argp->hstmt);
+}
+
+static inline SQLRETURN
+SQLEXECDIRECT(SQLHSTMT hstmt, SQLTCHAR *sql, SQLINTEGER len)
+{
+    size_t ret;
+    struct S_SQLEXECDIRECT arg;
+
+    arg.hstmt = hstmt;
+    arg.sql = sql;
+    arg.len = len;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLEXECDIRECT, &arg,
+					      F_SQLEXECDIRECT_UBF, &arg);
+    return ret;
+}
+
+struct S_SQLEXECUTE {
+    SQLHSTMT hstmt;
+};
+
+static void *
+F_SQLEXECUTE(void *args)
+{
+    size_t ret;
+    struct S_SQLEXECUTE *argp = (struct S_SQLEXECUTE *) args;
+
+    ret = SQLExecute(argp->hstmt);
+    return (void *) ret;
+}
+
+static void
+F_SQLEXECUTE_UBF(void *args)
+{
+    struct S_SQLEXECUTE *argp = (struct S_SQLEXECUTE *) args;
+
+    SQLCancel(argp->hstmt);
+}
+
+static inline SQLRETURN
+SQLEXECUTE(SQLHSTMT hstmt)
+{
+    size_t ret;
+    struct S_SQLEXECUTE arg;
+
+    arg.hstmt = hstmt;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLEXECUTE, &arg,
+					      F_SQLEXECUTE_UBF, &arg);
+    return ret;
+}
+
+struct S_SQLPREPARE {
+    SQLHSTMT hstmt;
+    SQLTCHAR *sql;
+    SQLINTEGER len;
+};
+
+static void *
+F_SQLPREPARE(void *args)
+{
+    size_t ret;
+    struct S_SQLPREPARE *argp = (struct S_SQLPREPARE *) args;
+
+    ret = SQLPrepare(argp->hstmt, argp->sql, argp->len);
+    return (void *) ret;
+}
+
+static void
+F_SQLPREPARE_UBF(void *args)
+{
+    struct S_SQLPREPARE *argp = (struct S_SQLPREPARE *) args;
+
+    SQLCancel(argp->hstmt);
+}
+
+static inline SQLRETURN
+SQLPREPARE(SQLHSTMT hstmt, SQLTCHAR *sql, SQLINTEGER len)
+{
+    size_t ret;
+    struct S_SQLPREPARE arg;
+
+    arg.hstmt = hstmt;
+    arg.sql = sql;
+    arg.len = len;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLPREPARE, &arg,
+					      F_SQLPREPARE_UBF, &arg);
+    return ret;
+}
+
+struct S_SQLMORERESULTS {
+    SQLHSTMT hstmt;
+};
+
+static void *
+F_SQLMORERESULTS(void *args)
+{
+    size_t ret;
+    struct S_SQLMORERESULTS *argp = (struct S_SQLMORERESULTS *) args;
+
+    ret = SQLMoreResults(argp->hstmt);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLMORERESULTS(SQLHSTMT hstmt)
+{
+    size_t ret;
+    struct S_SQLMORERESULTS arg;
+
+    arg.hstmt = hstmt;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLMORERESULTS, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+struct S_SQLFETCH {
+    SQLHSTMT hstmt;
+};
+
+static void *
+F_SQLFETCH(void *args)
+{
+    size_t ret;
+    struct S_SQLFETCH *argp = (struct S_SQLFETCH *) args;
+
+    ret = SQLFetch(argp->hstmt);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLFETCH(SQLHSTMT hstmt)
+{
+    size_t ret;
+    struct S_SQLFETCH arg;
+
+    arg.hstmt = hstmt;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLFETCH, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+#if (ODBCVER >= 0x0300)
+
+struct S_SQLFETCHSCROLL {
+    SQLHSTMT hstmt;
+    SQLSMALLINT dir;
+    SQLROWOFFSET offs;
+};
+
+static void *
+F_SQLFETCHSCROLL(void *args)
+{
+    size_t ret;
+    struct S_SQLFETCHSCROLL *argp = (struct S_SQLFETCHSCROLL *) args;
+
+    ret = SQLFetchScroll(argp->hstmt, argp->dir, argp->offs);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLFETCHSCROLL(SQLHSTMT hstmt, SQLSMALLINT dir, SQLROWOFFSET offs)
+{
+    size_t ret;
+    struct S_SQLFETCHSCROLL arg;
+
+    arg.hstmt = hstmt;
+    arg.dir = dir;
+    arg.offs = offs;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLFETCHSCROLL, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+#else
+
+struct S_SQLEXTENDEDFETCH {
+    SQLHSTMT hstmt;
+    SQLUSMALLINT type;
+    SQLROWOFFSET row;
+    SQLROWSETSIZE *rowp;
+    SQLUSMALLINT *status
+};
+
+static void *
+F_SQLEXTENDEDFETCH(void *args)
+{
+    size_t ret;
+    struct S_SQLEXTENDEDFETCH *argp = (struct S_SQLEXTENDEDFETCH *) args;
+
+    ret = SQLExtendedFetch(argp->hstmt, argp->type, argp->row, argp->rowp,
+			   argp->status);
+    return (void *) ret;
+}
+
+static inline SQLRETURN
+SQLEXTENDEDFETCH(SQLHSTMT hstmt, SQLUSMALLINT type, SQLROWOFFSET row,
+		 SQLROWSETSIZE *rowp, SQLUSMALLINT *status)
+{
+    size_t ret;
+    struct S_SQLEXTENDEDFETCH arg;
+
+    arg.hstmt = hstmt;
+    arg.type = type;
+    arg.row = row;
+    arg.rowp = rowp;
+    arg.status = status;
+    ret = (size_t) rb_thread_call_without_gvl(F_SQLEXTENDEDFETCH, &arg,
+					      empty_ubf, &arg);
+    return ret;
+}
+
+#endif
+
+#else
+
+#define SQLCONNECT		SQLConnect
+#define SQLDRIVERCONNECT	SQLDriverConnect
+#define SQLDISCONNECT		SQLDisconnect
+#define SQLTABLES		SQLTables
+#define SQLCOLUMNS		SQLColumns
+#define SQLPRIMARYKEYS		SQLPrimaryKeys
+#define SQLFOREGINKEYS		SQLForeignKeys
+#define SQLPROCEDURES		SQLProcedures
+#define SQLPROCEDURECOLUMNS	SQLProcedureColumns
+#define SQLTABLEPRIVILEGES	SQLTablePrivileges
+#define SQLSTATISTICS		SQLStatistics
+#define SQLSPECIALCOLUMNS	SQLSpecialColumns
+#define SQLGETTYPEINFO		SQLGetTypeInfo
+#if (ODBCVER >= 0x0300)
+#define SQLENDTRAN		SQLEndTran
+#else
+#define SQLTRANSACT		SQLTransact
+#endif
+#define SQLEXECDIRECT		SQLExecDirect
+#define SQLEXECUTE		SQLExecute
+#define SQLPREPARE		SQLPrepare
+#define SQLMORERESULTS		SQLMoreResults
+#define SQLFETCH		SQLFetch
+#if (ODBCVER >= 0x0300)
+#define SQLFETCHSCROLL		SQLFetchScroll
+#else
+#define SQLEXTENDEDFETCH	SQLExtendedFetch
+#endif
+
+#endif
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ *	UNICODE converters et.al.
  *
  *----------------------------------------------------------------------
  */
@@ -390,7 +1304,7 @@ uc_strchr(SQLWCHAR *str, SQLWCHAR c)
 
 static int
 mkutf(char *dest, SQLWCHAR *src, int len)
-{      
+{
     int i;
     char *cp = dest;
 
@@ -629,7 +1543,7 @@ uc_free(SQLWCHAR *str)
 /*
  *----------------------------------------------------------------------
  *
- *      Things for ODBC::DSN
+ *	Things for ODBC::DSN
  *
  *----------------------------------------------------------------------
  */
@@ -656,7 +1570,7 @@ dsn_init(VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Things for ODBC::Driver
+ *	Things for ODBC::Driver
  *
  *----------------------------------------------------------------------
  */
@@ -683,7 +1597,7 @@ drv_init(VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Cleanup routines and GC mark/free callbacks.
+ *	Cleanup routines and GC mark/free callbacks.
  *
  *----------------------------------------------------------------------
  */
@@ -745,7 +1659,7 @@ list_first(LINK *head)
 static int
 list_empty(LINK *head)
 {
-    return head->succ == NULL; 
+    return head->succ == NULL;
 }
 
 static void
@@ -799,7 +1713,7 @@ free_dbc(DBC *p)
     tracemsg(2, fprintf(stderr, "ObjFree: DBC %p\n", p););
     if (p->hdbc != SQL_NULL_HDBC) {
 	callsql(SQL_NULL_HENV, p->hdbc, SQL_NULL_HSTMT,
-		SQLDisconnect(p->hdbc), "SQLDisconnect");
+		SQLDISCONNECT(p->hdbc), "SQLDisconnect");
 	callsql(SQL_NULL_HENV, p->hdbc, SQL_NULL_HSTMT,
 		SQLFreeConnect(p->hdbc), "SQLFreeConnect");
 	p->hdbc = SQL_NULL_HDBC;
@@ -932,7 +1846,7 @@ mark_stmt(STMT *q)
 /*
  *----------------------------------------------------------------------
  *
- *      Set internal error (or warning) message.
+ *	Set internal error (or warning) message.
  *
  *----------------------------------------------------------------------
  */
@@ -955,7 +1869,7 @@ set_err(const char *msg, int warn)
 /*
  *----------------------------------------------------------------------
  *
- *      Functions to retrieve last SQL error or warning.
+ *	Functions to retrieve last SQL error or warning.
  *
  *----------------------------------------------------------------------
  */
@@ -1286,7 +2200,7 @@ succeeded_nodata(SQLHENV henv, SQLHDBC hdbc, SQLHSTMT hstmt, SQLRETURN ret,
 /*
  *----------------------------------------------------------------------
  *
- *      Return ENV from VALUE.
+ *	Return ENV from VALUE.
  *
  *----------------------------------------------------------------------
  */
@@ -1327,7 +2241,7 @@ get_env(VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Return DBC from VALUE.
+ *	Return DBC from VALUE.
  *
  *----------------------------------------------------------------------
  */
@@ -1353,7 +2267,7 @@ get_dbc(VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Raise ODBC error from Ruby.
+ *	Raise ODBC error from Ruby.
  *
  *----------------------------------------------------------------------
  */
@@ -1384,7 +2298,7 @@ dbc_raise(VALUE self, VALUE msg)
 /*
  *----------------------------------------------------------------------
  *
- *      Obtain an ENV.
+ *	Obtain an ENV.
  *
  *----------------------------------------------------------------------
  */
@@ -1422,7 +2336,7 @@ env_new(VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Obtain array of known DSNs.
+ *	Obtain array of known DSNs.
  *
  *----------------------------------------------------------------------
  */
@@ -1477,7 +2391,7 @@ dbc_dsns(VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Obtain array of known drivers.
+ *	Obtain array of known drivers.
  *
  *----------------------------------------------------------------------
  */
@@ -1553,7 +2467,7 @@ dbc_drivers(VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Management methods.
+ *	Management methods.
  *
  *----------------------------------------------------------------------
  */
@@ -1872,7 +2786,7 @@ dbc_rfdsn(int argc, VALUE *argv, VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Return last ODBC error or warning.
+ *	Return last ODBC error or warning.
  *
  *----------------------------------------------------------------------
  */
@@ -1900,7 +2814,7 @@ dbc_clrerror(VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Connection instance initializer.
+ *	Connection instance initializer.
  *
  *----------------------------------------------------------------------
  */
@@ -1972,7 +2886,7 @@ dbc_new(int argc, VALUE *argv, VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Connect to data source.
+ *	Connect to data source.
  *
  *----------------------------------------------------------------------
  */
@@ -2062,7 +2976,7 @@ dbc_connect(int argc, VALUE *argv, VALUE self)
 	rb_raise(Cerror, "%s", msg);
     }
     if (!succeeded(SQL_NULL_HENV, dbc, SQL_NULL_HSTMT,
-		   SQLConnect(dbc, (SQLTCHAR *) sdsn, SQL_NTS,
+		   SQLCONNECT(dbc, (SQLTCHAR *) sdsn, SQL_NTS,
 			      (SQLTCHAR *) suser,
 			      (SQLSMALLINT) (suser ? SQL_NTS : 0),
 			      (SQLTCHAR *) spasswd,
@@ -2146,7 +3060,7 @@ dbc_drvconnect(VALUE self, VALUE drv)
 	rb_raise(Cerror, "%s", msg);
     }
     if (!succeeded(e->henv, dbc, SQL_NULL_HSTMT,
-		   SQLDriverConnect(dbc, NULL, (SQLTCHAR *) sdrv, SQL_NTS,
+		   SQLDRIVERCONNECT(dbc, NULL, (SQLTCHAR *) sdrv, SQL_NTS,
 				    NULL, 0, NULL, SQL_DRIVER_NOPROMPT),
 		   &msg, "SQLDriverConnect")) {
 #ifdef UNICODE
@@ -2214,7 +3128,7 @@ dbc_use_scn(int argc, VALUE *argv, VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Drop all active statements from data source.
+ *	Drop all active statements from data source.
  *
  *----------------------------------------------------------------------
  */
@@ -2238,7 +3152,7 @@ dbc_dropall(VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Disconnect from data source.
+ *	Disconnect from data source.
  *
  *----------------------------------------------------------------------
  */
@@ -2259,7 +3173,7 @@ dbc_disconnect(int argc, VALUE *argv, VALUE self)
     }
     if (list_empty(&p->stmts)) {
 	callsql(SQL_NULL_HENV, p->hdbc, SQL_NULL_HSTMT,
-		SQLDisconnect(p->hdbc), "SQLDisconnect");
+		SQLDISCONNECT(p->hdbc), "SQLDisconnect");
 	if (!succeeded(SQL_NULL_HENV, p->hdbc, SQL_NULL_HSTMT,
 		       SQLFreeConnect(p->hdbc), &msg, "SQLFreeConnect")) {
 	    rb_raise(Cerror, "%s", msg);
@@ -2275,11 +3189,21 @@ dbc_disconnect(int argc, VALUE *argv, VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Database meta data via SQLGetInfo()
+ *	Database meta data via SQLGetInfo()
  *
  *----------------------------------------------------------------------
  */
 
+#ifndef SQL_DTC_TRANSITION_COST
+#define SQL_DTC_TRANSITION_COST 1750
+#endif
+#ifndef SQL_DTC_ENLIST_EXPENSIZE
+#define SQL_DTC_ENLIST_EXPENDSIZE 1
+#endif
+#ifndef SQL_DTC_UNENLIST_EXPENSIZE
+#define SQL_DTC_UNENLIST_EXPENDSIZE 2
+#endif
+
 #define GI_CONST_SINT(x) { #x, x, SQL_C_SHORT }
 #define GI_CONST_INT(x)  { #x, x, SQL_C_LONG }
 #define GI_CONST_BITS(x) { #x, x, SQL_C_LONG }
@@ -3189,7 +4113,7 @@ dbc_getinfo(int argc, VALUE *argv, VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Fill column type array for statement.
+ *	Fill column type array for statement.
  *
  *----------------------------------------------------------------------
  */
@@ -3340,7 +4264,7 @@ make_coltypes(SQLHSTMT hstmt, int ncols, char **msgp)
 /*
  *----------------------------------------------------------------------
  *
- *      Fill parameter info array for statement.
+ *	Fill parameter info array for statement.
  *
  *----------------------------------------------------------------------
  */
@@ -3420,7 +4344,7 @@ retain_paraminfo_override(STMT *q, int nump, PARAMINFO *paraminfo)
 /*
  *----------------------------------------------------------------------
  *
- *      Wrap SQLHSTMT into struct/VALUE.
+ *	Wrap SQLHSTMT into struct/VALUE.
  *
  *----------------------------------------------------------------------
  */
@@ -3465,7 +4389,7 @@ wrap_stmt(VALUE dbc, DBC *p, SQLHSTMT hstmt, STMT **qp)
 /*
  *----------------------------------------------------------------------
  *
- *      Create statement with result.
+ *	Create statement with result.
  *
  *----------------------------------------------------------------------
  */
@@ -3575,7 +4499,7 @@ upcase_if(char *string, int upc)
 /*
  *----------------------------------------------------------------------
  *
- *      Constructor: make column from statement.
+ *	Constructor: make column from statement.
  *
  *----------------------------------------------------------------------
  */
@@ -3747,7 +4671,7 @@ make_column(SQLHSTMT hstmt, int i, int upc, int use_scn)
 /*
  *----------------------------------------------------------------------
  *
- *      Constructor: make parameter from statement.
+ *	Constructor: make parameter from statement.
  *
  *----------------------------------------------------------------------
  */
@@ -3787,7 +4711,7 @@ make_param(STMT *q, int i)
 /*
  *----------------------------------------------------------------------
  *
- *      Query tables/columns/keys/indexes/types of data source.
+ *	Query tables/columns/keys/indexes/types of data source.
  *
  *----------------------------------------------------------------------
  */
@@ -3900,7 +4824,7 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
     switch (mode) {
     case INFO_TABLES:
 	if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
-		       SQLTables(hstmt, NULL, 0, NULL, 0,
+		       SQLTABLES(hstmt, NULL, 0, NULL, 0,
 				 swhich, (swhich == NULL) ? 0 : SQL_NTS,
 				 NULL, 0),
 		       &msg, "SQLTables")) {
@@ -3909,7 +4833,7 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
 	break;
     case INFO_COLUMNS:
 	if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
-		       SQLColumns(hstmt, NULL, 0, NULL, 0,
+		       SQLCOLUMNS(hstmt, NULL, 0, NULL, 0,
 				  swhich, (swhich == NULL) ? 0 : SQL_NTS,
 				  swhich2, (swhich2 == NULL) ? 0 : SQL_NTS),
 		       &msg, "SQLColumns")) {
@@ -3918,7 +4842,7 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
 	break;
     case INFO_PRIMKEYS:
 	if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
-		       SQLPrimaryKeys(hstmt, NULL, 0, NULL, 0,
+		       SQLPRIMARYKEYS(hstmt, NULL, 0, NULL, 0,
 				      swhich, (swhich == NULL) ? 0 : SQL_NTS),
 		       &msg, "SQLPrimaryKeys")) {
 	    goto error;
@@ -3926,7 +4850,7 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
 	break;
     case INFO_INDEXES:
 	if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
-		       SQLStatistics(hstmt, NULL, 0, NULL, 0,
+		       SQLSTATISTICS(hstmt, NULL, 0, NULL, 0,
 				     swhich, (swhich == NULL) ? 0 : SQL_NTS,
 				     (SQLUSMALLINT) (RTEST(which2) ?
 				      SQL_INDEX_UNIQUE : SQL_INDEX_ALL),
@@ -3937,14 +4861,14 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
 	break;
     case INFO_TYPES:
 	if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
-		       SQLGetTypeInfo(hstmt, (SQLSMALLINT) itype),
+		       SQLGETTYPEINFO(hstmt, (SQLSMALLINT) itype),
 		       &msg, "SQLGetTypeInfo")) {
 	    goto error;
 	}
 	break;
     case INFO_FORKEYS:
 	if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
-		       SQLForeignKeys(hstmt, NULL, 0, NULL, 0,
+		       SQLFOREIGNKEYS(hstmt, NULL, 0, NULL, 0,
 				      swhich, (swhich == NULL) ? 0 : SQL_NTS,
 				      NULL, 0, NULL, 0,
 				      swhich2, (swhich2 == NULL) ? 0 : SQL_NTS),
@@ -3954,7 +4878,7 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
 	break;
     case INFO_TPRIV:
 	if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
-		       SQLTablePrivileges(hstmt, NULL, 0, NULL, 0, swhich,
+		       SQLTABLEPRIVILEGES(hstmt, NULL, 0, NULL, 0, swhich,
 					  (swhich == NULL) ? 0 : SQL_NTS),
 		       &msg, "SQLTablePrivileges")) {
 	    goto error;
@@ -3962,7 +4886,7 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
 	break;
     case INFO_PROCS:
 	if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
-		       SQLProcedures(hstmt, NULL, 0, NULL, 0,
+		       SQLPROCEDURES(hstmt, NULL, 0, NULL, 0,
 				     swhich, (swhich == NULL) ? 0 : SQL_NTS),
 		       &msg, "SQLProcedures")) {
 	    goto error;
@@ -3970,7 +4894,7 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
 	break;
     case INFO_PROCCOLS:
 	if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
-		       SQLProcedureColumns(hstmt, NULL, 0, NULL, 0,
+		       SQLPROCEDURECOLUMNS(hstmt, NULL, 0, NULL, 0,
 					   swhich,
 					   (swhich == NULL) ? 0 : SQL_NTS,
 					   swhich2,
@@ -3981,7 +4905,7 @@ dbc_info(int argc, VALUE *argv, VALUE self, int mode)
 	break;
     case INFO_SPECCOLS:
 	if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
-		       SQLSpecialColumns(hstmt, (SQLUSMALLINT) iid,
+		       SQLSPECIALCOLUMNS(hstmt, (SQLUSMALLINT) iid,
 					 NULL, 0, NULL, 0,
 					 swhich,
 					 (swhich == NULL) ? 0 : SQL_NTS,
@@ -4071,7 +4995,7 @@ dbc_speccols(int argc, VALUE *argv, VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Transaction stuff.
+ *	Transaction stuff.
  *
  *----------------------------------------------------------------------
  */
@@ -4081,6 +5005,7 @@ dbc_trans(VALUE self, int what)
 {
     ENV *e;
     SQLHDBC dbc = SQL_NULL_HDBC;
+    SQLRETURN ret;
     char *msg;
 
     e = get_env(self);
@@ -4090,16 +5015,18 @@ dbc_trans(VALUE self, int what)
 	d = get_dbc(self);
 	dbc = d->hdbc;
     }
-    if (!succeeded(e->henv, dbc, SQL_NULL_HSTMT,
 #if (ODBCVER >= 0x0300)
-		   SQLEndTran((SQLSMALLINT)
-			      ((dbc == SQL_NULL_HDBC) ? SQL_HANDLE_ENV :
-							SQL_HANDLE_DBC),
-			      (dbc == SQL_NULL_HDBC) ? e->henv : dbc,
-			      (SQLSMALLINT) what),
+    ret = SQLENDTRAN((SQLSMALLINT)
+		     ((dbc == SQL_NULL_HDBC) ? SQL_HANDLE_ENV : SQL_HANDLE_DBC),
+		     (dbc == SQL_NULL_HDBC) ? e->henv : dbc,
+		     (SQLSMALLINT) what);
+#else
+    ret = SQLTRANSACT(e->henv, dbc, (SQLUSMALLINT) what);
+#endif
+    if (!succeeded(e->henv, dbc, SQL_NULL_HSTMT, ret,
+#if (ODBCVER >= 0x0300)
 		   &msg, "SQLEndTran"
 #else
-		   SQLTransact(e->henv, dbc, (SQLUSMALLINT) what),
 		   &msg, "SQLTransact"
 #endif
        )) {
@@ -4166,7 +5093,7 @@ dbc_transaction(VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Environment attribute handling.
+ *	Environment attribute handling.
  *
  *----------------------------------------------------------------------
  */
@@ -4247,17 +5174,17 @@ env_odbcver(int argc, VALUE *argv, VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Connection/statement option handling.
+ *	Connection/statement option handling.
  *
- *      Note:
- *      ODBC 2 allows statement options to be set using SQLSetConnectOption,
- *      establishing the statement option as a default for any hstmts
- *      later allocated for that hdbc. This feature was deprecated in
- *      ODBC 3.x and may not work with ODBC 3.x drivers.
+ *	Note:
+ *	ODBC 2 allows statement options to be set using SQLSetConnectOption,
+ *	establishing the statement option as a default for any hstmts
+ *	later allocated for that hdbc. This feature was deprecated in
+ *	ODBC 3.x and may not work with ODBC 3.x drivers.
  *
- *      Although the Database class includes attribute accessors for
- *      statement-level options, a safer alternative, if using an ODBC 3
- *      driver, is to set the option directly on the Statement instance.
+ *	Although the Database class includes attribute accessors for
+ *	statement-level options, a safer alternative, if using an ODBC 3
+ *	driver, is to set the option directly on the Statement instance.
  *
  *----------------------------------------------------------------------
  */
@@ -4385,8 +5312,8 @@ do_option(int argc, VALUE *argv, VALUE self, int isstmt, int op)
 	if (val == Qnil) {
 	    return v ? Qtrue : Qfalse;
 	}
-	v = (TYPE(val) == T_FIXNUM) ?  
-	    (FIX2INT(val) ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF) : 
+	v = (TYPE(val) == T_FIXNUM) ?
+	    (FIX2INT(val) ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF) :
 	    (RTEST(val) ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF);
 	break;
 
@@ -4394,8 +5321,8 @@ do_option(int argc, VALUE *argv, VALUE self, int isstmt, int op)
 	if (val == Qnil) {
 	    return v ? Qtrue : Qfalse;
 	}
-	v = (TYPE(val) == T_FIXNUM) ?  
-	    (FIX2INT(val) ? SQL_NOSCAN_ON : SQL_NOSCAN_OFF) : 
+	v = (TYPE(val) == T_FIXNUM) ?
+	    (FIX2INT(val) ? SQL_NOSCAN_ON : SQL_NOSCAN_OFF) :
 	    (RTEST(val) ? SQL_NOSCAN_ON : SQL_NOSCAN_OFF);
 	break;
 
@@ -4424,7 +5351,7 @@ do_option(int argc, VALUE *argv, VALUE self, int isstmt, int op)
 	    rb_raise(Cerror, "%s", msg);
 	}
     } else {
-	if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt, 
+	if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt,
 		       SQLSetStmtOption(q->hstmt, (SQLUSMALLINT) op,
 					(SQLUINTEGER) v),
 		       &msg, "SQLSetStmtOption(%d)", op)) {
@@ -4539,7 +5466,7 @@ stmt_getsetoption(int argc, VALUE *argv, VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Scan literal date/time/timestamp to TIMESTAMP_STRUCT.
+ *	Scan literal date/time/timestamp to TIMESTAMP_STRUCT.
  *
  *----------------------------------------------------------------------
  */
@@ -4573,7 +5500,7 @@ scan_dtts(VALUE str, int do_d, int do_t, TIMESTAMP_STRUCT *ts)
 	ts->day = dd;
 	return 1;
     }
-    if (do_t && 
+    if (do_t &&
 	(sscanf(cstr, "{t '%d:%d:%d' %c", &hh, &mmm, &ss, &c) == 4) &&
 	(c == '}')) {
 	ts->hour = yy;
@@ -4617,7 +5544,7 @@ next:
 /*
  *----------------------------------------------------------------------
  *
- *      Date methods.
+ *	Date methods.
  *
  *----------------------------------------------------------------------
  */
@@ -4638,7 +5565,7 @@ date_new(int argc, VALUE *argv, VALUE self)
 {
     DATE_STRUCT *date;
     VALUE obj = Data_Make_Struct(self, DATE_STRUCT, 0, xfree, date);
-    
+
     rb_obj_call_init(obj, argc, argv);
     return obj;
 }
@@ -4852,7 +5779,7 @@ date_cmp(VALUE self, VALUE date)
 /*
  *----------------------------------------------------------------------
  *
- *      Time methods.
+ *	Time methods.
  *
  *----------------------------------------------------------------------
  */
@@ -4873,7 +5800,7 @@ time_new(int argc, VALUE *argv, VALUE self)
 {
     TIME_STRUCT *time;
     VALUE obj = Data_Make_Struct(self, TIME_STRUCT, 0, xfree, time);
-    
+
     rb_obj_call_init(obj, argc, argv);
     return obj;
 }
@@ -4887,7 +5814,7 @@ time_load1(VALUE self, VALUE str, int load)
     if (scan_dtts(str, 0, 1, &tss)) {
 	TIME_STRUCT *time;
 	VALUE obj;
-       
+
 	if (load) {
 	    obj = Data_Make_Struct(self, TIME_STRUCT, 0, xfree, time);
 	} else {
@@ -5080,7 +6007,7 @@ time_cmp(VALUE self, VALUE time)
 /*
  *----------------------------------------------------------------------
  *
- *      TimeStamp methods.
+ *	TimeStamp methods.
  *
  *----------------------------------------------------------------------
  */
@@ -5423,7 +6350,7 @@ timestamp_cmp(VALUE self, VALUE timestamp)
 /*
  *----------------------------------------------------------------------
  *
- *      Statement methods.
+ *	Statement methods.
  *
  *----------------------------------------------------------------------
  */
@@ -5481,7 +6408,7 @@ check_ncols(STMT *q)
 	(q->coltypes == NULL)) {
 	COLTYPE *coltypes = NULL;
 	SQLSMALLINT cols = 0;
-	
+
 	if (succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt,
 		      SQLNumResultCols(q->hstmt, &cols), NULL,
 		      "SQLNumResultCols")
@@ -5985,7 +6912,7 @@ do_fetch(STMT *q, int mode)
     }
     if (q->dbcp != NULL && q->dbcp->use_sql_column_name == Qtrue) {
 	use_scn = 1;
-    } 
+    }
     switch (mode & DOFETCH_MODES) {
     case DOFETCH_HASH:
     case DOFETCH_HASH2:
@@ -6460,7 +7387,7 @@ stmt_fetch1(VALUE self, int bang)
     const char *msg;
     char *err;
 #if (ODBCVER < 0x0300)
-    SQLUINTEGER nRows;
+    SQLROWSETSIZE nRows;
     SQLUSMALLINT rowStat[1];
 #endif
 
@@ -6473,10 +7400,10 @@ stmt_fetch1(VALUE self, int bang)
     }
 #if (ODBCVER < 0x0300)
     msg = "SQLExtendedFetch(SQL_FETCH_NEXT)";
-    ret = SQLExtendedFetch(q->hstmt, SQL_FETCH_NEXT, 0, &nRows, rowStat);
+    ret = SQLEXTENDEDFETCH(q->hstmt, SQL_FETCH_NEXT, 0, &nRows, rowStat);
 #else
     msg = "SQLFetchScroll(SQL_FETCH_NEXT)";
-    ret = SQLFetchScroll(q->hstmt, SQL_FETCH_NEXT, 0);
+    ret = SQLFETCHSCROLL(q->hstmt, SQL_FETCH_NEXT, 0);
 #endif
     if (ret == SQL_NO_DATA) {
 	(void) tracesql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt, ret, msg);
@@ -6492,7 +7419,7 @@ usef:
 	/* Fallback to SQLFetch() when others not implemented */
 	msg = "SQLFetch";
 	q->usef = 1;
-	ret = SQLFetch(q->hstmt);
+	ret = SQLFETCH(q->hstmt);
 	if (ret == SQL_NO_DATA) {
 	    (void) tracesql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt, ret, msg);
 	    return Qnil;
@@ -6532,7 +7459,7 @@ stmt_fetch_first1(VALUE self, int bang, int nopos)
     const char *msg;
     char *err;
 #if (ODBCVER < 0x0300)
-    SQLUINTEGER nRows;
+    SQLROWSETSIZE nRows;
     SQLUSMALLINT rowStat[1];
 #endif
 
@@ -6545,10 +7472,10 @@ stmt_fetch_first1(VALUE self, int bang, int nopos)
     }
 #if (ODBCVER < 0x0300)
     msg = "SQLExtendedFetch(SQL_FETCH_FIRST)";
-    ret = SQLExtendedFetch(q->hstmt, SQL_FETCH_FIRST, 0, &nRows, rowStat);
+    ret = SQLEXTENDEDFETCH(q->hstmt, SQL_FETCH_FIRST, 0, &nRows, rowStat);
 #else
     msg = "SQLFetchScroll(SQL_FETCH_FIRST)";
-    ret = SQLFetchScroll(q->hstmt, SQL_FETCH_FIRST, 0);
+    ret = SQLFETCHSCROLL(q->hstmt, SQL_FETCH_FIRST, 0);
 #endif
     if (ret == SQL_NO_DATA) {
 	(void) tracesql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt, ret, msg);
@@ -6583,7 +7510,7 @@ stmt_fetch_scroll1(int argc, VALUE *argv, VALUE self, int bang)
     int idir, ioffs = 1;
     char msg[128], *err;
 #if (ODBCVER < 0x0300)
-    SQLUINTEGER nRows;
+    SQLROWSETSIZE nRows;
     SQLUSMALLINT rowStat[1];
 #endif
 
@@ -6598,11 +7525,11 @@ stmt_fetch_scroll1(int argc, VALUE *argv, VALUE self, int bang)
     }
 #if (ODBCVER < 0x0300)
     sprintf(msg, "SQLExtendedFetch(%d)", idir);
-    ret = SQLExtendedFetch(q->hstmt, (SQLSMALLINT) idir, (SQLINTEGER) ioffs,
+    ret = SQLEXTENDEDFETCH(q->hstmt, (SQLSMALLINT) idir, (SQLROWOFFSET) ioffs,
 			   &nRows, rowStat);
 #else
     sprintf(msg, "SQLFetchScroll(%d)", idir);
-    ret = SQLFetchScroll(q->hstmt, (SQLSMALLINT) idir, (SQLINTEGER) ioffs);
+    ret = SQLFETCHSCROLL(q->hstmt, (SQLSMALLINT) idir, (SQLROWOFFSET) ioffs);
 #endif
     if (ret == SQL_NO_DATA) {
 	(void) tracesql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt, ret, msg);
@@ -6703,7 +7630,7 @@ stmt_fetch_hash1(int argc, VALUE *argv, VALUE self, int bang)
     const char *msg;
     char *err;
 #if (ODBCVER < 0x0300)
-    SQLUINTEGER nRows;
+    SQLROWSETSIZE nRows;
     SQLUSMALLINT rowStat[1];
 #endif
 
@@ -6716,10 +7643,10 @@ stmt_fetch_hash1(int argc, VALUE *argv, VALUE self, int bang)
     }
 #if (ODBCVER < 0x0300)
     msg = "SQLExtendedFetch(SQL_FETCH_NEXT)";
-    ret = SQLExtendedFetch(q->hstmt, SQL_FETCH_NEXT, 0, &nRows, rowStat);
+    ret = SQLEXTENDEDFETCH(q->hstmt, SQL_FETCH_NEXT, 0, &nRows, rowStat);
 #else
     msg = "SQLFetchScroll(SQL_FETCH_NEXT)";
-    ret = SQLFetchScroll(q->hstmt, SQL_FETCH_NEXT, 0);
+    ret = SQLFETCHSCROLL(q->hstmt, SQL_FETCH_NEXT, 0);
 #endif
     if (ret == SQL_NO_DATA) {
 	(void) tracesql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt, ret, msg);
@@ -6735,7 +7662,7 @@ usef:
 	/* Fallback to SQLFetch() when others not implemented */
 	msg = "SQLFetch";
 	q->usef = 1;
-	ret = SQLFetch(q->hstmt);
+	ret = SQLFETCH(q->hstmt);
 	if (ret == SQL_NO_DATA) {
 	    (void) tracesql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt, ret, msg);
 	    return Qnil;
@@ -6776,7 +7703,7 @@ stmt_fetch_first_hash1(int argc, VALUE *argv, VALUE self, int bang, int nopos)
     const char *msg;
     char *err;
 #if (ODBCVER < 0x0300)
-    SQLUINTEGER nRows;
+    SQLROWSETSIZE nRows;
     SQLUSMALLINT rowStat[1];
 #endif
 
@@ -6789,10 +7716,10 @@ stmt_fetch_first_hash1(int argc, VALUE *argv, VALUE self, int bang, int nopos)
     }
 #if (ODBCVER < 0x0300)
     msg = "SQLExtendedFetch(SQL_FETCH_FIRST)";
-    ret = SQLExtendedFetch(q->hstmt, SQL_FETCH_FIRST, 0, &nRows, rowStat);
+    ret = SQLEXTENDEDFETCH(q->hstmt, SQL_FETCH_FIRST, 0, &nRows, rowStat);
 #else
     msg = "SQLFetchScroll(SQL_FETCH_FIRST)";
-    ret = SQLFetchScroll(q->hstmt, SQL_FETCH_FIRST, 0);
+    ret = SQLFETCHSCROLL(q->hstmt, SQL_FETCH_FIRST, 0);
 #endif
     if (ret == SQL_NO_DATA) {
 	(void) tracesql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt, ret, msg);
@@ -6818,19 +7745,19 @@ stmt_each(VALUE self)
     VALUE row, res = Qnil;
     STMT *q;
 #if (ODBCVER < 0x0300)
-    SQLUINTEGER nRows;
+    SQLROWSETSIZE nRows;
     SQLUSMALLINT rowStat[1];
 #endif
 
     Data_Get_Struct(self, STMT, q);
 #if (ODBCVER < 0x0300)
     switch (callsql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt,
-		    SQLExtendedFetch(q->hstmt, SQL_FETCH_FIRST, 0, &nRows,
+		    SQLEXTENDEDFETCH(q->hstmt, SQL_FETCH_FIRST, 0, &nRows,
 				     rowStat),
 		    "SQLExtendedFetch(SQL_FETCH_FIRST)"))
 #else
     switch (callsql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt,
-		    SQLFetchScroll(q->hstmt, SQL_FETCH_FIRST, 0),
+		    SQLFETCHSCROLL(q->hstmt, SQL_FETCH_FIRST, 0),
 		    "SQLFetchScroll(SQL_FETCH_FIRST)"))
 #endif
     {
@@ -6868,7 +7795,7 @@ stmt_each_hash(int argc, VALUE *argv, VALUE self)
     STMT *q;
     int mode = stmt_hash_mode(argc, argv, self);
 #if (ODBCVER < 0x0300)
-    SQLUINTEGER nRows;
+    SQLROWSETSIZE nRows;
     SQLUSMALLINT rowStat[1];
 #endif
 
@@ -6884,12 +7811,12 @@ stmt_each_hash(int argc, VALUE *argv, VALUE self)
     Data_Get_Struct(self, STMT, q);
 #if (ODBCVER < 0x0300)
     switch (callsql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt,
-		    SQLExtendedFetch(q->hstmt, SQL_FETCH_FIRST, 0, &nRows,
+		    SQLEXTENDEDFETCH(q->hstmt, SQL_FETCH_FIRST, 0, &nRows,
 				     rowStat),
 		    "SQLExtendedFetch(SQL_FETCH_FIRST)"))
 #else
     switch (callsql(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt,
-		    SQLFetchScroll(q->hstmt, SQL_FETCH_FIRST, 0),
+		    SQLFETCHSCROLL(q->hstmt, SQL_FETCH_FIRST, 0),
 		    "SQLFetchScroll(SQL_FETCH_FIRST)"))
 #endif
     {
@@ -6955,6 +7882,7 @@ stmt_prep_int(int argc, VALUE *argv, VALUE self, int mode)
     STMT *q = NULL;
     VALUE sql, dbc, stmt;
     SQLHSTMT hstmt;
+    SQLRETURN ret;
 #ifdef UNICODE
     SQLWCHAR *ssql = NULL;
 #else
@@ -7004,10 +7932,8 @@ stmt_prep_int(int argc, VALUE *argv, VALUE self, int mode)
     ssql = (SQLCHAR *) csql;
 #endif
     if ((mode & MAKERES_EXECD)) {
-	SQLRETURN ret;
-
-	if (!succeeded_nodata(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
-			      (ret = SQLExecDirect(hstmt, ssql, SQL_NTS)),
+	ret = SQLEXECDIRECT(hstmt, ssql, SQL_NTS);
+	if (!succeeded_nodata(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt, ret,
 			      &msg, "SQLExecDirect('%s')", csql)) {
 	    goto sqlerr;
 	}
@@ -7020,22 +7946,24 @@ stmt_prep_int(int argc, VALUE *argv, VALUE self, int mode)
 	    }
 	    hstmt = SQL_NULL_HSTMT;
 	}
-    } else if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
-			  SQLPrepare(hstmt, ssql, SQL_NTS),
+    } else {
+	ret = SQLPREPARE(hstmt, ssql, SQL_NTS);
+	if (!succeeded(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt, ret,
 			  &msg, "SQLPrepare('%s')", csql)) {
 sqlerr:
 #ifdef UNICODE
-	uc_free(ssql);
+	    uc_free(ssql);
 #endif
-	callsql(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
-		SQLFreeStmt(hstmt, SQL_DROP), "SQLFreeStmt(SQL_DROP)");
-	if (q != NULL) {
-	    q->hstmt = SQL_NULL_HSTMT;
-	    unlink_stmt(q);
+	    callsql(SQL_NULL_HENV, SQL_NULL_HDBC, hstmt,
+		    SQLFreeStmt(hstmt, SQL_DROP), "SQLFreeStmt(SQL_DROP)");
+	    if (q != NULL) {
+		q->hstmt = SQL_NULL_HSTMT;
+		unlink_stmt(q);
+		}
+	    rb_raise(Cerror, "%s", msg);
+	} else {
+	    mode |= MAKERES_PREPARE;
 	}
-	rb_raise(Cerror, "%s", msg);
-    } else {
-	mode |= MAKERES_PREPARE;
     }
 #ifdef UNICODE
     uc_free(ssql);
@@ -7452,8 +8380,8 @@ stmt_exec_int(int argc, VALUE *argv, VALUE self, int mode)
 	    goto error;
 	}
     }
-    if (!succeeded_nodata(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt,
-			  (ret = SQLExecute(q->hstmt)),
+    ret = SQLEXECUTE(q->hstmt);
+    if (!succeeded_nodata(SQL_NULL_HENV, SQL_NULL_HDBC, q->hstmt, ret,
 			  &msg, "SQLExecute")) {
 error:
 #ifdef UNICODE
@@ -7512,7 +8440,7 @@ static VALUE
 stmt_do(int argc, VALUE *argv, VALUE self)
 {
     VALUE stmt;
-    
+
     if (argc < 1) {
 	rb_raise(rb_eArgError, "wrong # of arguments");
     }
@@ -7557,7 +8485,7 @@ stmt_ignorecase(int argc, VALUE *argv, VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Create statement without implicit SQL prepare or execute.
+ *	Create statement without implicit SQL prepare or execute.
  *
  *----------------------------------------------------------------------
  */
@@ -7580,7 +8508,7 @@ stmt_new(VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Procedures with statements.
+ *	Procedures with statements.
  *
  *----------------------------------------------------------------------
  */
@@ -7671,7 +8599,7 @@ stmt_procwrap(int argc, VALUE *argv, VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Module functions.
+ *	Module functions.
  *
  *----------------------------------------------------------------------
  */
@@ -7854,7 +8782,7 @@ mod_trace(int argc, VALUE *argv, VALUE self)
 /*
  *----------------------------------------------------------------------
  *
- *      Table of constants and intern'ed string mappings.
+ *	Table of constants and intern'ed string mappings.
  *
  *----------------------------------------------------------------------
  */
@@ -7990,10 +8918,26 @@ static struct {
     O_CONST2(SQL_OV_ODBC3, 3),
 #endif
 #ifdef SQL_ATTR_CONNECTION_POOLING
+#ifdef SQL_CP_OFF
     O_CONST(SQL_CP_OFF),
+#else
+    O_CONST2(SQL_CP_OFF, 0),
+#endif
+#ifdef SQL_CP_ONE_PER_DRIVER
     O_CONST(SQL_CP_ONE_PER_DRIVER),
+#else
+    O_CONST2(SQL_CP_ONE_PER_DRIVER, 1),
+#endif
+#ifdef SQL_CP_ONE_PER_HENV
     O_CONST(SQL_CP_ONE_PER_HENV),
+#else
+    O_CONST2(SQL_CP_ONE_PER_HENV, 2),
+#endif
+#ifdef SQL_CP_DEFAULT
     O_CONST(SQL_CP_DEFAULT),
+#else
+    O_CONST2(SQL_CP_DEFAULT, 0),
+#endif
 #else
     O_CONST2(SQL_CP_OFF, 0),
     O_CONST2(SQL_CP_ONE_PER_DRIVER, 0),
@@ -8107,7 +9051,7 @@ static struct {
 /*
  *----------------------------------------------------------------------
  *
- *      Module initializer.
+ *	Module initializer.
  *
  *----------------------------------------------------------------------
  */
@@ -8128,7 +9072,7 @@ Init_odbc()
     rb_cDate = rb_eval_string("Date");
 
     if (rb_const_defined(rb_cObject, modid)) {
-	v = rb_const_get(rb_cObject, modid); 
+	v = rb_const_get(rb_cObject, modid);
 	if (TYPE(v) != T_MODULE) {
 	    rb_raise(rb_eTypeError, "%s already defined", modname);
 	}
@@ -8470,3 +9414,12 @@ Init_odbc()
     }
 #endif
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * tab-width: 8
+ * End:
+ */