TODBCServer.cxx

Go to the documentation of this file.

// @(#)root/odbc:$Id$
// Author: Sergey Linev   6/02/2006
 
/*************************************************************************
 * Copyright (C) 1995-2006, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
#include "TODBCServer.h"
 
#include "TODBCRow.h"
#include "TODBCResult.h"
#include "TODBCStatement.h"
#include "TSQLColumnInfo.h"
#include "TSQLTableInfo.h"
#include "TUrl.h"
#include "TString.h"
#include "TObjString.h"
#include "TList.h"
#include "strlcpy.h"
 
#include <iostream>
 
 
#include <sqlext.h>
 
 
ClassImp(TODBCServer);
 
////////////////////////////////////////////////////////////////////////////////
/// Open a connection to a ODBC server. The db arguments can be:
/// 1. Form "odbc://[user[:passwd]@]<host>[:<port>][/<database>][?Driver]",
///    e.g.: "odbc://pcroot.cern.ch:3306/test?MySQL".
///    Driver argument specifies ODBC driver, which should be used for
///    connection. By default, MyODBC driver name is used.
///    The uid is the username and pw the password that should be used
///    for the connection.
///    If uid and pw are not specified (==0), user and passwd arguments from
///    URL will be used. Works only with MySQL ODBC, probably with PostrSQL
///    ODBC.
/// 2. Form "odbcd://DRIVER={MyODBC};SERVER=pcroot.cern.ch;DATABASE=test;USER=user;PASSWORD=pass;OPTION=3;PORT=3306;"
///    This is a form, which is accepted by SQLDriverConnect function of ODBC.
///    Here some other arguments can be specified, which are not included
///    in standard URL format.
/// 3. Form "odbcn://MySpecialConfig", where MySpecialConfig is entry,
///    defined in user DSN (user data source). Here uid and pw should be
///    always specified.
///
///    Configuring unixODBC under Linux: http://www.unixodbc.org/odbcinst.html
///    Remarks: for variants 1 & 2 it is enough to create/configure
///    odbcinst.ini file. For variant 3 file odbc.ini should be created.
///    Path to this files can be specified in environmental variables like
///      export ODBCINI=/home/my/unixODBC/etc/odbc.ini
///      export ODBCSYSINI=/home/my/unixODBC/etc
///
///    Configuring MySQL ODBC under Windows.
///    Installing ODBC driver for MySQL is enough to use it under Windows.
///    Afer odbcd:// variant can be used with DRIVER={MySQL ODBC 3.51 Driver};
///    To configure User DSN, go into Start menu -> Settings ->
///    Control panel -> Administrative tools-> Data Sources (ODBC).
///
///    To install Oracle ODBC driver for Windows, one should download
///    and install either complete Oracle client (~500 MB), or so-called
///    Instant Client Basic and Instant Client ODBC (~20 MB together).
///    Some remark about Instant Client:
///       1) Two additional DLLs are required: mfc71.dll & msver71.dll
///          They can be found either in MS VC++ 7.1 Free Toolkit or
///          download from other Internet sites
///       2) ORACLE_HOME environment variable should be specified and point to
///           location, where Instant Client files are extracted
///       3) Run odbc_install.exe from account with administrative rights
///       3) In $ORACLE_HOME/network/admin/ directory appropriate *.ora files
///          like ldap.ora, sqlnet.ora, tnsnames.ora should be installed.
///          Contact your Oracle administrator to get these files.
///    After Oracle ODBC driver is installed, appropriate entry in ODBC drivers
///    list like "Oracle in instantclient10_2" should appear. Connection
///    string example:
///     "odbcd://DRIVER={Oracle in instantclient10_2};DBQ=db-test;UID=user_name;PWD=user_pass;";
 
TODBCServer::TODBCServer(const char *db, const char *uid, const char *pw) :
   TSQLServer()
{
   TString connstr;
   Bool_t simpleconnect = kTRUE;
 
   SQLRETURN retcode;
   SQLHWND  hwnd;
 
   fPort = 1; // indicate that we are connected
 
   if ((strncmp(db, "odbc", 4)!=0) || (strlen(db)<8)) {
      SetError(-1, "db argument should be started from odbc...","TODBCServer");
      goto zombie;
   }
 
   if (strncmp(db, "odbc://", 7)==0) {
      TUrl url(db);
      if (!url.IsValid()) {
         SetError(-1, Form("not valid URL: %s", db), "TODBCServer");
         goto zombie;
      }
      const char* driver = "MyODBC";
      const char* dbase = url.GetFile();
      if (dbase)
         if (*dbase=='/') dbase++; //skip leading "/" if appears
 
      if ((!uid || (*uid==0)) && (strlen(url.GetUser())>0)) {
         uid = url.GetUser();
         pw = url.GetPasswd();
      }
 
      if (strlen(url.GetOptions()) != 0) driver = url.GetOptions();
 
      connstr.Form("DRIVER={%s};"
                   "SERVER=%s;"
                   "DATABASE=%s;"
                   "USER=%s;"
                   "PASSWORD=%s;"
                   "OPTION=3;",
                    driver, url.GetHost(), dbase, uid, pw);
      if (url.GetPort()>0)
          connstr += Form("PORT=%d;", url.GetPort());
 
      fHost = url.GetHost();
      fPort = url.GetPort()>0 ? url.GetPort() : 1;
      fDB = dbase;
      simpleconnect = kFALSE;
   } else
   if (strncmp(db, "odbcd://", 8)==0) {
      connstr = db+8;
      simpleconnect = kFALSE;
   } else
   if (strncmp(db, "odbcn://", 8)==0) {
      connstr = db+8;
      simpleconnect = kTRUE;
   } else {
      SetError(-1, "db argument is invalid", "TODBCServer");
      goto zombie;
   }
 
   retcode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &fHenv);
   if (ExtractErrors(retcode, "TODBCServer")) goto zombie;
 
   /* Set the ODBC version environment attribute */
   retcode = SQLSetEnvAttr(fHenv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0);
   if (ExtractErrors(retcode, "TODBCServer")) goto zombie;
 
   /* Allocate connection handle */
   retcode = SQLAllocHandle(SQL_HANDLE_DBC, fHenv, &fHdbc);
   if (ExtractErrors(retcode, "TODBCServer")) goto zombie;
 
   /* Set login timeout to 5 seconds. */
   retcode = SQLSetConnectAttr(fHdbc, SQL_LOGIN_TIMEOUT, (SQLPOINTER) 5, 0);
   if (ExtractErrors(retcode, "TODBCServer")) goto zombie;
 
   char sbuf[2048];
 
   SQLSMALLINT reslen;
   SQLINTEGER reslen1;
 
   hwnd = nullptr;
 
   if (simpleconnect)
      retcode = SQLConnect(fHdbc, (SQLCHAR*) connstr.Data(), SQL_NTS,
                                  (SQLCHAR*) uid, SQL_NTS,
                                  (SQLCHAR*) pw, SQL_NTS);
   else
      retcode = SQLDriverConnect(fHdbc, hwnd,
                                 (SQLCHAR*) connstr.Data(), SQL_NTS,
                                 (SQLCHAR*) sbuf, sizeof(sbuf), &reslen, SQL_DRIVER_NOPROMPT);
 
   if (ExtractErrors(retcode, "TODBCServer")) goto zombie;
 
   fType = "ODBC";
 
   retcode = SQLGetInfo(fHdbc, SQL_USER_NAME, sbuf, sizeof(sbuf), &reslen);
   if (ExtractErrors(retcode, "TODBCServer")) goto zombie;
   fUserId = sbuf;
 
   retcode = SQLGetInfo(fHdbc, SQL_DBMS_NAME, sbuf, sizeof(sbuf), &reslen);
   if (ExtractErrors(retcode, "TODBCServer")) goto zombie;
   fServerInfo = sbuf;
   fType = sbuf;
 
   retcode = SQLGetInfo(fHdbc, SQL_DBMS_VER, sbuf, sizeof(sbuf), &reslen);
   if (ExtractErrors(retcode, "TODBCServer")) goto zombie;
   fServerInfo += " ";
   fServerInfo += sbuf;
 
   // take current catalog - database name
   retcode = SQLGetConnectAttr(fHdbc, SQL_ATTR_CURRENT_CATALOG, sbuf, sizeof(sbuf), &reslen1);
   if (ExtractErrors(retcode, "TODBCServer")) goto zombie;
   if (fDB.Length()==0) fDB = sbuf;
 
   retcode = SQLGetInfo(fHdbc, SQL_SERVER_NAME, sbuf, sizeof(sbuf), &reslen);
   if (ExtractErrors(retcode, "TODBCServer")) goto zombie;
   if (fHost.Length()==0) fHost = sbuf;
 
/*
 
   SQLUINTEGER iinfo;
   retcode = SQLGetInfo(fHdbc, SQL_PARAM_ARRAY_ROW_COUNTS, &iinfo, sizeof(iinfo), 0);
   if (ExtractErrors(retcode, "TODBCServer")) goto zombie;
   Info("Constr", "SQL_PARAM_ARRAY_ROW_COUNTS = %u", iinfo);
 
   retcode = SQLGetInfo(fHdbc, SQL_PARAM_ARRAY_SELECTS, &iinfo, sizeof(iinfo), 0);
   if (ExtractErrors(retcode, "TODBCServer")) goto zombie;
   Info("Constr", "SQL_PARAM_ARRAY_SELECTS = %u", iinfo);
 
   retcode = SQLGetInfo(fHdbc, SQL_BATCH_ROW_COUNT, &iinfo, sizeof(iinfo), 0);
   if (ExtractErrors(retcode, "TODBCServer")) goto zombie;
   Info("Constr", "SQL_BATCH_ROW_COUNT = %u", iinfo);
*/
 
   return;
 
zombie:
   fPort = -1;
   fHost = "";
   MakeZombie();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Close connection to MySQL DB server.
 
TODBCServer::~TODBCServer()
{
   if (IsConnected())
      Close();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Produce TList object with list of available
/// ODBC drivers (isdrivers = kTRUE) or data sources (isdrivers = kFALSE)
 
TList* TODBCServer::ListData(Bool_t isdrivers)
{
   SQLHENV   henv;
   SQLRETURN retcode;
 
   retcode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
   if ((retcode!=SQL_SUCCESS) && (retcode!=SQL_SUCCESS_WITH_INFO)) return nullptr;
 
   retcode = SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0);
   if ((retcode!=SQL_SUCCESS) && (retcode!=SQL_SUCCESS_WITH_INFO)) return nullptr;
 
   TList* lst = nullptr;
 
   char namebuf[2048], optbuf[2048];
   SQLSMALLINT reslen1, reslen2;
 
   do {
      strlcpy(namebuf, "",2048);
      strlcpy(optbuf, "",2048);
      if (isdrivers)
         retcode = SQLDrivers(henv, (!lst ? SQL_FETCH_FIRST : SQL_FETCH_NEXT),
                     (SQLCHAR*) namebuf, sizeof(namebuf), &reslen1,
                     (SQLCHAR*) optbuf, sizeof(optbuf), &reslen2);
      else
         retcode = SQLDataSources(henv, (!lst ? SQL_FETCH_FIRST : SQL_FETCH_NEXT),
                     (SQLCHAR*) namebuf, sizeof(namebuf), &reslen1,
                     (SQLCHAR*) optbuf, sizeof(optbuf), &reslen2);
 
      if (retcode==SQL_NO_DATA) break;
      if ((retcode==SQL_SUCCESS) || (retcode==SQL_SUCCESS_WITH_INFO)) {
         if (!lst) {
            lst = new TList;
            lst->SetOwner(kTRUE);
         }
         for (int n = 0; n < reslen2 - 1; n++)
            if (optbuf[n] == '\0')
               optbuf[n] = ';';
 
         lst->Add(new TNamed(namebuf, optbuf));
      }
   } while ((retcode==SQL_SUCCESS) || (retcode==SQL_SUCCESS_WITH_INFO));
 
   SQLFreeHandle(SQL_HANDLE_ENV, henv);
 
   return lst;
}
 
 
////////////////////////////////////////////////////////////////////////////////
/// Produce TList object with list of available ODBC drivers
/// User must delete TList object afterwards
/// Name of driver can be used in connecting to data base in form
/// TSQLServer::Connect("odbcd://DRIVER={<drivername>};DBQ=<dbname>;UID=user;PWD=pass;", 0, 0);
 
TList* TODBCServer::GetDrivers()
{
   return ListData(kTRUE);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Print list of ODBC drivers in form:
///   `<name`> : `<options-list>`
 
void TODBCServer::PrintDrivers()
{
   TList* lst = GetDrivers();
   std::cout << "List of ODBC drivers:" << std::endl;
   TIter iter(lst);
   while (auto n = dynamic_cast<TNamed *>(iter()))
      std::cout << "  " << n->GetName() << " : " << n->GetTitle() << std::endl;
   delete lst;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Produce TList object with list of available ODBC data sources
/// User must delete TList object afterwards
/// Name of data source can be used later for connection:
/// TSQLServer::Connect("odbcn://<data_source_name>", "user", "pass");
 
TList* TODBCServer::GetDataSources()
{
   return ListData(kFALSE);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Print list of ODBC data sources in form:
///   `<name>` : `<options list>`
 
void TODBCServer::PrintDataSources()
{
   TList* lst = GetDataSources();
   std::cout << "List of ODBC data sources:" << std::endl;
   TIter iter(lst);
   while (auto n = dynamic_cast<TNamed *>(iter()))
      std::cout << "  " << n->GetName() << " : " << n->GetTitle() << std::endl;
   delete lst;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Extract errors, produced by last ODBC function call
 
Bool_t TODBCServer::ExtractErrors(SQLRETURN retcode, const char* method)
{
   if ((retcode==SQL_SUCCESS) || (retcode==SQL_SUCCESS_WITH_INFO)) return kFALSE;
 
   SQLINTEGER i = 0;
   SQLINTEGER native;
   SQLCHAR state[7];
   SQLCHAR text[256];
   SQLSMALLINT len;
 
   while (SQLGetDiagRec(SQL_HANDLE_ENV, fHenv, ++i, state, &native, text,
                          sizeof(text), &len ) == SQL_SUCCESS)
      SetError(native, (const char *) text, method);
 
   i = 0;
 
   while (SQLGetDiagRec(SQL_HANDLE_DBC, fHdbc, ++i, state, &native, text,
                          sizeof(text), &len ) == SQL_SUCCESS)
      SetError(native, (const char *) text, method);
 
   return kTRUE;
}
 
// Reset error and check that server connected
#define CheckConnect(method, res)                       \
   {                                                    \
      ClearError();                                     \
      if (!IsConnected()) {                             \
         SetError(-1,"ODBC driver is not connected",method); \
         return res;                                    \
      }                                                 \
   }
 
////////////////////////////////////////////////////////////////////////////////
/// Close connection to MySQL DB server.
 
void TODBCServer::Close(Option_t *)
{
   SQLDisconnect(fHdbc);
   SQLFreeHandle(SQL_HANDLE_DBC, fHdbc);
   SQLFreeHandle(SQL_HANDLE_ENV, fHenv);
   fPort = -1;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Execute SQL command. Result object must be deleted by the user.
/// Returns a pointer to a TSQLResult object if successful, 0 otherwise.
/// The result object must be deleted by the user.
 
TSQLResult *TODBCServer::Query(const char *sql)
{
   CheckConnect("Query", nullptr);
 
   SQLRETURN    retcode;
   SQLHSTMT     hstmt;
 
   SQLAllocHandle(SQL_HANDLE_STMT, fHdbc, &hstmt);
 
   retcode = SQLExecDirect(hstmt, (SQLCHAR*) sql, SQL_NTS);
   if (ExtractErrors(retcode, "Query")) {
      SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
      return nullptr;
   }
 
   return new TODBCResult(hstmt);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Executes query which does not produce any results set
/// Return kTRUE if successful
 
Bool_t TODBCServer::Exec(const char* sql)
{
   CheckConnect("Exec", 0);
 
   SQLRETURN    retcode;
   SQLHSTMT     hstmt;
 
   SQLAllocHandle(SQL_HANDLE_STMT, fHdbc, &hstmt);
 
   retcode = SQLExecDirect(hstmt, (SQLCHAR*) sql, SQL_NTS);
 
   Bool_t res = !ExtractErrors(retcode, "Exec");
 
   SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
 
   return res;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Select a database. Returns 0 if successful, non-zero otherwise.
/// Not all RDBMS support selecting of database (catalog) after connecting
/// Normally user should specify database name at time of connection
 
Int_t TODBCServer::SelectDataBase(const char *db)
{
   CheckConnect("SelectDataBase", -1);
 
   SQLRETURN retcode = SQLSetConnectAttr(fHdbc, SQL_ATTR_CURRENT_CATALOG, (SQLCHAR*) db, SQL_NTS);
   if (ExtractErrors(retcode, "SelectDataBase")) return -1;
 
   fDB = db;
 
   return 0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// List all available databases. Wild is for wildcarding "t%" list all
/// databases starting with "t".
/// Returns a pointer to a TSQLResult object if successful, 0 otherwise.
/// The result object must be deleted by the user.
 
TSQLResult *TODBCServer::GetDataBases(const char *)
{
   CheckConnect("GetDataBases", nullptr);
 
   return nullptr;
}
 
////////////////////////////////////////////////////////////////////////////////
/// List all tables in the specified database. Wild is for wildcarding
/// "t%" list all tables starting with "t".
/// Returns a pointer to a TSQLResult object if successful, 0 otherwise.
/// The result object must be deleted by the user.
 
TSQLResult *TODBCServer::GetTables(const char*, const char* wild)
{
   CheckConnect("GetTables", nullptr);
 
   SQLRETURN    retcode;
   SQLHSTMT     hstmt;
 
   SQLAllocHandle(SQL_HANDLE_STMT, fHdbc, &hstmt);
 
   SQLCHAR* schemaName = nullptr;
   SQLSMALLINT schemaNameLength = 0;
 
/*
   TString schemabuf;
   // schema is used by Oracle to specify to which user belong table
   // therefore, to see correct tables, schema name is set to user name
   if ((fUserId.Length()>0) && (fServerInfo.Contains("Oracle"))) {
      schemabuf = fUserId;
      schemabuf.ToUpper();
      schemaName = (SQLCHAR*) schemabuf.Data();
      schemaNameLength = schemabuf.Length();
   }
*/
 
   SQLCHAR* tableName = nullptr;
   SQLSMALLINT tableNameLength = 0;
 
   if (wild && *wild) {
      tableName = (SQLCHAR*) wild;
      tableNameLength = strlen(wild);
      SQLSetStmtAttr(hstmt, SQL_ATTR_METADATA_ID, (SQLPOINTER) SQL_FALSE, 0);
   }
 
   retcode = SQLTables(hstmt, nullptr, 0, schemaName, schemaNameLength, tableName, tableNameLength, (SQLCHAR*) "TABLE", 5);
   if (ExtractErrors(retcode, "GetTables")) {
      SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
      return nullptr;
   }
 
   return new TODBCResult(hstmt);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return list of tables in database
/// See TSQLServer::GetTablesList() for details.
 
TList* TODBCServer::GetTablesList(const char* wild)
{
   CheckConnect("GetTablesList", nullptr);
 
   TSQLResult* res = GetTables(nullptr, wild);
   if (!res) return nullptr;
 
   TList* lst = nullptr;
 
   TSQLRow* row = nullptr;
 
   while ((row = res->Next()) != nullptr) {
      const char* tablename = row->GetField(2);
      if (tablename) {
//         Info("List","%s %s %s %s %s", tablename, row->GetField(0), row->GetField(1), row->GetField(3), row->GetField(4));
         if (!lst) {
            lst = new TList;
            lst->SetOwner(kTRUE);
         }
         lst->Add(new TObjString(tablename));
      }
      delete row;
   }
 
   delete res;
 
   return lst;
}
 
 
////////////////////////////////////////////////////////////////////////////////
/// Produces SQL table info
/// Object must be deleted by user
 
TSQLTableInfo* TODBCServer::GetTableInfo(const char* tablename)
{
   CheckConnect("GetTableInfo", nullptr);
 
   #define STR_LEN 128+1
   #define REM_LEN 254+1
 
   /* Declare buffers for result set data */
 
   SQLCHAR       szCatalog[STR_LEN], szSchema[STR_LEN];
   SQLCHAR       szTableName[STR_LEN], szColumnName[STR_LEN];
   SQLCHAR       szTypeName[STR_LEN], szRemarks[REM_LEN];
   SQLCHAR       szColumnDefault[STR_LEN], szIsNullable[STR_LEN];
   SQLLEN        columnSize, bufferLength, charOctetLength, ordinalPosition;
   SQLSMALLINT   dataType, decimalDigits, numPrecRadix, nullable;
   SQLSMALLINT   sqlDataType, datetimeSubtypeCode;
   SQLRETURN     retcode;
   SQLHSTMT      hstmt;
 
   /* Declare buffers for bytes available to return */
 
   SQLLEN cbCatalog, cbSchema, cbTableName, cbColumnName;
   SQLLEN cbDataType, cbTypeName, cbColumnSize, cbBufferLength;
   SQLLEN cbDecimalDigits, cbNumPrecRadix, cbNullable, cbRemarks;
   SQLLEN cbColumnDefault, cbSQLDataType, cbDatetimeSubtypeCode, cbCharOctetLength;
   SQLLEN cbOrdinalPosition, cbIsNullable;
 
 
   SQLAllocHandle(SQL_HANDLE_STMT, fHdbc, &hstmt);
 
   retcode = SQLColumns(hstmt, nullptr, 0, nullptr, 0, (SQLCHAR*) tablename, SQL_NTS, nullptr, 0);
   if (ExtractErrors(retcode, "GetTableInfo")) {
      SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
      return nullptr;
   }
 
   TList* lst = nullptr;
 
   /* Bind columns in result set to buffers */
 
   SQLBindCol(hstmt, 1, SQL_C_CHAR, szCatalog, STR_LEN,&cbCatalog);
   SQLBindCol(hstmt, 2, SQL_C_CHAR, szSchema, STR_LEN, &cbSchema);
   SQLBindCol(hstmt, 3, SQL_C_CHAR, szTableName, STR_LEN,&cbTableName);
   SQLBindCol(hstmt, 4, SQL_C_CHAR, szColumnName, STR_LEN, &cbColumnName);
   SQLBindCol(hstmt, 5, SQL_C_SSHORT, &dataType, 0, &cbDataType);
   SQLBindCol(hstmt, 6, SQL_C_CHAR, szTypeName, STR_LEN, &cbTypeName);
   SQLBindCol(hstmt, 7, SQL_C_SLONG, &columnSize, 0, &cbColumnSize);
   SQLBindCol(hstmt, 8, SQL_C_SLONG, &bufferLength, 0, &cbBufferLength);
   SQLBindCol(hstmt, 9, SQL_C_SSHORT, &decimalDigits, 0, &cbDecimalDigits);
   SQLBindCol(hstmt, 10, SQL_C_SSHORT, &numPrecRadix, 0, &cbNumPrecRadix);
   SQLBindCol(hstmt, 11, SQL_C_SSHORT, &nullable, 0, &cbNullable);
   SQLBindCol(hstmt, 12, SQL_C_CHAR, szRemarks, REM_LEN, &cbRemarks);
   SQLBindCol(hstmt, 13, SQL_C_CHAR, szColumnDefault, STR_LEN, &cbColumnDefault);
   SQLBindCol(hstmt, 14, SQL_C_SSHORT, &sqlDataType, 0, &cbSQLDataType);
   SQLBindCol(hstmt, 15, SQL_C_SSHORT, &datetimeSubtypeCode, 0, &cbDatetimeSubtypeCode);
   SQLBindCol(hstmt, 16, SQL_C_SLONG, &charOctetLength, 0, &cbCharOctetLength);
   SQLBindCol(hstmt, 17, SQL_C_SLONG, &ordinalPosition, 0, &cbOrdinalPosition);
   SQLBindCol(hstmt, 18, SQL_C_CHAR, szIsNullable, STR_LEN, &cbIsNullable);
 
   retcode = SQLFetch(hstmt);
 
   while ((retcode == SQL_SUCCESS) || (retcode == SQL_SUCCESS_WITH_INFO)) {
 
      Int_t sqltype = kSQL_NONE;
 
      Int_t data_size = -1;    // size in bytes
      Int_t data_length = -1;  // declaration like VARCHAR(n) or NUMERIC(n)
      Int_t data_scale = -1;   // second argument in declaration
      Int_t data_sign = -1; // no info about sign
 
      switch (dataType) {
         case SQL_CHAR:
            sqltype = kSQL_CHAR;
            data_size = columnSize;
            data_length = charOctetLength;
            break;
         case SQL_VARCHAR:
         case SQL_LONGVARCHAR:
            sqltype = kSQL_VARCHAR;
            data_size = columnSize;
            data_length = charOctetLength;
            break;
         case SQL_DECIMAL:
         case SQL_NUMERIC:
            sqltype = kSQL_NUMERIC;
            data_size = columnSize; // size of column in database
            data_length = columnSize;
            data_scale = decimalDigits;
            break;
         case SQL_INTEGER:
         case SQL_TINYINT:
         case SQL_BIGINT:
            sqltype = kSQL_INTEGER;
            data_size = columnSize;
            break;
         case SQL_REAL:
         case SQL_FLOAT:
            sqltype = kSQL_FLOAT;
            data_size = columnSize;
            data_sign = 1;
            break;
         case SQL_DOUBLE:
            sqltype = kSQL_DOUBLE;
            data_size = columnSize;
            data_sign = 1;
            break;
         case SQL_BINARY:
         case SQL_VARBINARY:
         case SQL_LONGVARBINARY:
            sqltype = kSQL_BINARY;
            data_size = columnSize;
            break;
         case SQL_TYPE_TIMESTAMP:
            sqltype = kSQL_TIMESTAMP;
            data_size = columnSize;
            break;
      }
 
      if (!lst) lst = new TList;
 
      lst->Add(new TSQLColumnInfo((const char *) szColumnName,
                                  (const char *) szTypeName,
                                  nullable != 0,
                                  sqltype,
                                  data_size,
                                  data_length,
                                  data_scale,
                                  data_sign));
 
      retcode = SQLFetch(hstmt);
   }
 
   SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
 
   return new TSQLTableInfo(tablename, lst);
}
 
////////////////////////////////////////////////////////////////////////////////
/// List all columns in specified table in the specified database.
/// Wild is for wildcarding "t%" list all columns starting with "t".
/// Returns a pointer to a TSQLResult object if successful, 0 otherwise.
/// The result object must be deleted by the user.
 
TSQLResult *TODBCServer::GetColumns(const char*, const char *table, const char*)
{
   CheckConnect("GetColumns", nullptr);
 
   SQLRETURN    retcode;
   SQLHSTMT     hstmt;
 
   SQLAllocHandle(SQL_HANDLE_STMT, fHdbc, &hstmt);
 
   retcode = SQLColumns(hstmt, nullptr, 0, nullptr, 0, (SQLCHAR*) table, SQL_NTS, nullptr, 0);
   if (ExtractErrors(retcode, "GetColumns")) {
      SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
      return nullptr;
   }
 
   return new TODBCResult(hstmt);
}
 
////////////////////////////////////////////////////////////////////////////////
/// returns maximum allowed length of identifier (table name, column name, index name)
 
Int_t TODBCServer::GetMaxIdentifierLength()
{
   CheckConnect("GetMaxIdentifierLength", 20);
 
   SQLUINTEGER info = 0;
   SQLRETURN retcode;
 
   retcode = SQLGetInfo(fHdbc, SQL_MAX_IDENTIFIER_LEN, (SQLPOINTER)&info, sizeof(info), nullptr);
 
   if (ExtractErrors(retcode, "GetMaxIdentifierLength")) return 20;
 
   return info;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Create a database. Returns 0 if successful, non-zero otherwise.
 
Int_t TODBCServer::CreateDataBase(const char*)
{
   CheckConnect("CreateDataBase", -1);
 
   return -1;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Drop (i.e. delete) a database. Returns 0 if successful, non-zero
/// otherwise.
 
Int_t TODBCServer::DropDataBase(const char*)
{
   CheckConnect("DropDataBase", -1);
 
   return -1;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Reload permission tables. Returns 0 if successful, non-zero
/// otherwise. User must have reload permissions.
 
Int_t TODBCServer::Reload()
{
   CheckConnect("Reload", -1);
 
   return -1;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Shutdown the database server. Returns 0 if successful, non-zero
/// otherwise. User must have shutdown permissions.
 
Int_t TODBCServer::Shutdown()
{
   CheckConnect("Shutdown", -1);
 
   return -1;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Return server info.
 
const char *TODBCServer::ServerInfo()
{
   CheckConnect("ServerInfo", nullptr);
 
   return fServerInfo;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Creates ODBC statement for provided query.
/// See TSQLStatement class for more details.
 
TSQLStatement *TODBCServer::Statement(const char *sql, Int_t bufsize)
{
   CheckConnect("Statement", nullptr);
 
   if (!sql || !*sql) {
      SetError(-1, "no query string specified", "Statement");
      return nullptr;
   }
 
//   SQLUINTEGER info = 0;
//   SQLGetInfo(fHdbc, SQL_PARAM_ARRAY_ROW_COUNTS, (SQLPOINTER)&info, sizeof(info), nullptr);
//   if (info==SQL_PARC_BATCH) Info("Statement","info==SQL_PARC_BATCH"); else
//   if (info==SQL_PARC_NO_BATCH) Info("Statement","info==SQL_PARC_NO_BATCH"); else
//    Info("Statement","info==%u", info);
 
 
   SQLRETURN    retcode;
   SQLHSTMT     hstmt;
 
   retcode = SQLAllocHandle(SQL_HANDLE_STMT, fHdbc, &hstmt);
   if (ExtractErrors(retcode, "Statement")) return nullptr;
 
   retcode = SQLPrepare(hstmt, (SQLCHAR*) sql, SQL_NTS);
   if (ExtractErrors(retcode, "Statement")) {
      SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
      return nullptr;
   }
 
   return new TODBCStatement(hstmt, bufsize, fErrorOut);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Starts transaction.
/// Check for transaction support.
/// Switch off autocommitment mode.
 
Bool_t TODBCServer::StartTransaction()
{
   CheckConnect("StartTransaction", kFALSE);
 
   SQLUINTEGER info = 0;
   SQLRETURN retcode;
 
   retcode = SQLGetInfo(fHdbc, SQL_TXN_CAPABLE, (SQLPOINTER)&info, sizeof(info), nullptr);
   if (ExtractErrors(retcode, "StartTransaction")) return kFALSE;
 
   if (info == 0) {
      SetError(-1,"Transactions not supported","StartTransaction");
      return kFALSE;
   }
 
   if (!Commit()) return kFALSE;
 
   retcode = SQLSetConnectAttr(fHdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER) SQL_AUTOCOMMIT_OFF, 0);
   if (ExtractErrors(retcode, "StartTransaction")) return kFALSE;
 
   return kTRUE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Complete current transaction (commit = kTRUE) or rollback
/// Switches on autocommit mode of ODBC driver
 
Bool_t TODBCServer::EndTransaction(Bool_t commit)
{
   const char* method = commit ? "Commit" : "Rollback";
 
   CheckConnect(method, kFALSE);
 
   SQLRETURN retcode = SQLEndTran(SQL_HANDLE_DBC, fHdbc, commit ? SQL_COMMIT : SQL_ROLLBACK);
   if (ExtractErrors(retcode, method)) return kFALSE;
 
   retcode = SQLSetConnectAttr(fHdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER) SQL_AUTOCOMMIT_ON, 0);
 
   return kTRUE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Commit transaction
 
Bool_t TODBCServer::Commit()
{
   return EndTransaction(kTRUE);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Rollback transaction
 
Bool_t TODBCServer::Rollback()
{
   return EndTransaction(kFALSE);
}