src/db/libnxdb/session.cpp

   1 /*
   2 ** NetXMS - Network Management System
   3 ** Database Abstraction Library
   4 ** Copyright (C) 2003-2016 Victor Kirhenshtein
   5 **
   6 ** This program is free software; you can redistribute it and/or modify
   7 ** it under the terms of the GNU Lesser General Public License as published by
   8 ** the Free Software Foundation; either version 3 of the License, or
   9 ** (at your option) any later version.
  10 **
  11 ** This program is distributed in the hope that it will be useful,
  12 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 ** GNU General Public License for more details.
  15 **
  16 ** You should have received a copy of the GNU Lesser General Public License
  17 ** along with this program; if not, write to the Free Software
  18 ** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 **
  20 ** File: session.cpp
  21 **
  22 **/
  23
  24 #include "libnxdb.h"
  25
  26 /**
  27  * Check if statement handle is valid
  28  */
  29 #define IS_VALID_STATEMENT_HANDLE(s) ((s != NULL) && (s->m_connection != NULL))
  30
  31 /**
  32  * Performance counters
  33  */
  34 static UINT64 s_perfSelectQueries = 0;
  35 static UINT64 s_perfNonSelectQueries = 0;
  36 static UINT64 s_perfTotalQueries = 0;
  37 static UINT64 s_perfLongRunningQueries = 0;
  38 static UINT64 s_perfFailedQueries = 0;
  39
  40 /**
  41  * Session init callback
  42  */
  43 static void (*s_sessionInitCb)(DB_HANDLE session) = NULL;
  44
  45 /**
  46  * Invalidate all prepared statements on connection
  47  */
  48 static void InvalidatePreparedStatements(DB_HANDLE hConn)
  49 {
  50    for(int i = 0; i < hConn->m_preparedStatements->size(); i++)
  51    {
  52       db_statement_t *stmt = hConn->m_preparedStatements->get(i);
  53       hConn->m_driver->m_fpDrvFreeStatement(stmt->m_statement);
  54       stmt->m_statement = NULL;
  55       stmt->m_connection = NULL;
  56    }
  57    hConn->m_preparedStatements->clear();
  58 }
  59
  60 /**
  61  * Connect to database
  62  */
  63 DB_HANDLE LIBNXDB_EXPORTABLE DBConnect(DB_DRIVER driver, const TCHAR *server, const TCHAR *dbName,
  64                                        const TCHAR *login, const TCHAR *password, const TCHAR *schema, TCHAR *errorText)
  65 {
  66    DBDRV_CONNECTION hDrvConn;
  67    DB_HANDLE hConn = NULL;
  68
  69         nxlog_debug(8, _T("DBConnect: server=%s db=%s login=%s schema=%s"), CHECK_NULL(server), CHECK_NULL(dbName), CHECK_NULL(login), CHECK_NULL(schema));
  70 #ifdef UNICODE
  71         char *mbServer = (server == NULL) ? NULL : MBStringFromWideString(server);
  72         char *mbDatabase = (dbName == NULL) ? NULL : MBStringFromWideString(dbName);
  73         char *mbLogin = (login == NULL) ? NULL : MBStringFromWideString(login);
  74         char *mbPassword = (password == NULL) ? NULL : MBStringFromWideString(password);
  75         char *mbSchema = (schema == NULL) ? NULL : MBStringFromWideString(schema);
  76         errorText[0] = 0;
  77    hDrvConn = driver->m_fpDrvConnect(mbServer, mbLogin, mbPassword, mbDatabase, mbSchema, errorText);
  78 #else
  79         WCHAR wcErrorText[DBDRV_MAX_ERROR_TEXT] = L"";
  80    hDrvConn = driver->m_fpDrvConnect(server, login, password, dbName, schema, wcErrorText);
  81         WideCharToMultiByte(CP_ACP, WC_DEFAULTCHAR | WC_COMPOSITECHECK, wcErrorText, -1, errorText, DBDRV_MAX_ERROR_TEXT, NULL, NULL);
  82         errorText[DBDRV_MAX_ERROR_TEXT - 1] = 0;
  83 #endif
  84    if (hDrvConn != NULL)
  85    {
  86       hConn = (DB_HANDLE)malloc(sizeof(struct db_handle_t));
  87       if (hConn != NULL)
  88       {
  89                         hConn->m_driver = driver;
  90                         hConn->m_dumpSql = driver->m_dumpSql;
  91                         hConn->m_reconnectEnabled = true;
  92                         hConn->m_connection = hDrvConn;
  93          hConn->m_mutexTransLock = MutexCreateRecursive();
  94          hConn->m_transactionLevel = 0;
  95          hConn->m_preparedStatements = new ObjectArray<db_statement_t>(4, 4, false);
  96 #ifdef UNICODE
  97          hConn->m_dbName = mbDatabase;
  98          hConn->m_login = mbLogin;
  99          hConn->m_password = mbPassword;
 100          hConn->m_server = mbServer;
 101          hConn->m_schema = mbSchema;
 102 #else
 103          hConn->m_dbName = (dbName == NULL) ? NULL : _tcsdup(dbName);
 104          hConn->m_login = (login == NULL) ? NULL : _tcsdup(login);
 105          hConn->m_password = (password == NULL) ? NULL : _tcsdup(password);
 106          hConn->m_server = (server == NULL) ? NULL : _tcsdup(server);
 107          hConn->m_schema = (schema == NULL) ? NULL : _tcsdup(schema);
 108 #endif
 109          if (driver->m_fpDrvSetPrefetchLimit != NULL)
 110             driver->m_fpDrvSetPrefetchLimit(hDrvConn, driver->m_defaultPrefetchLimit);
 111                    nxlog_debug(4, _T("New DB connection opened: handle=%p"), hConn);
 112          if (s_sessionInitCb != NULL)
 113             s_sessionInitCb(hConn);
 114       }
 115       else
 116       {
 117          driver->m_fpDrvDisconnect(hDrvConn);
 118       }
 119    }
 120 #ifdef UNICODE
 121         if (hConn == NULL)
 122         {
 123                 safe_free(mbServer);
 124                 safe_free(mbDatabase);
 125                 safe_free(mbLogin);
 126                 safe_free(mbPassword);
 127                 safe_free(mbSchema);
 128         }
 129 #endif
 130    return hConn;
 131 }
 132
 133 /**
 134  * Disconnect from database
 135  */
 136 void LIBNXDB_EXPORTABLE DBDisconnect(DB_HANDLE hConn)
 137 {
 138    if (hConn == NULL)
 139       return;
 140
 141    nxlog_debug(4, _T("DB connection %p closed"), hConn);
 142
 143    InvalidatePreparedStatements(hConn);
 144
 145         hConn->m_driver->m_fpDrvDisconnect(hConn->m_connection);
 146    MutexDestroy(hConn->m_mutexTransLock);
 147    safe_free(hConn->m_dbName);
 148    safe_free(hConn->m_login);
 149    safe_free(hConn->m_password);
 150    safe_free(hConn->m_server);
 151    safe_free(hConn->m_schema);
 152    delete hConn->m_preparedStatements;
 153    free(hConn);
 154 }
 155
 156 /**
 157  * Enable/disable reconnect
 158  */
 159 void LIBNXDB_EXPORTABLE DBEnableReconnect(DB_HANDLE hConn, bool enabled)
 160 {
 161         if (hConn != NULL)
 162         {
 163                 hConn->m_reconnectEnabled = enabled;
 164         }
 165 }
 166
 167 /**
 168  * Reconnect to database
 169  */
 170 static void DBReconnect(DB_HANDLE hConn)
 171 {
 172    int nCount;
 173         WCHAR errorText[DBDRV_MAX_ERROR_TEXT];
 174
 175    nxlog_debug(4, _T("DB reconnect: handle=%p"), hConn);
 176
 177    InvalidatePreparedStatements(hConn);
 178         hConn->m_driver->m_fpDrvDisconnect(hConn->m_connection);
 179    for(nCount = 0; ; nCount++)
 180    {
 181                 hConn->m_connection = hConn->m_driver->m_fpDrvConnect(hConn->m_server, hConn->m_login,
 182                                                             hConn->m_password, hConn->m_dbName, hConn->m_schema, errorText);
 183       if (hConn->m_connection != NULL)
 184       {
 185          if (hConn->m_driver->m_fpDrvSetPrefetchLimit != NULL)
 186             hConn->m_driver->m_fpDrvSetPrefetchLimit(hConn->m_connection, hConn->m_driver->m_defaultPrefetchLimit);
 187          if (s_sessionInitCb != NULL)
 188             s_sessionInitCb(hConn);
 189          break;
 190       }
 191       if (nCount == 0)
 192       {
 193                         MutexLock(hConn->m_driver->m_mutexReconnect);
 194          if ((hConn->m_driver->m_reconnect == 0) && (hConn->m_driver->m_fpEventHandler != NULL))
 195                                 hConn->m_driver->m_fpEventHandler(DBEVENT_CONNECTION_LOST, NULL, NULL, true, hConn->m_driver->m_userArg);
 196          hConn->m_driver->m_reconnect++;
 197          MutexUnlock(hConn->m_driver->m_mutexReconnect);
 198       }
 199       ThreadSleepMs(1000);
 200    }
 201    if (nCount > 0)
 202    {
 203       MutexLock(hConn->m_driver->m_mutexReconnect);
 204       hConn->m_driver->m_reconnect--;
 205       if ((hConn->m_driver->m_reconnect == 0) && (hConn->m_driver->m_fpEventHandler != NULL))
 206                         hConn->m_driver->m_fpEventHandler(DBEVENT_CONNECTION_RESTORED, NULL, NULL, false, hConn->m_driver->m_userArg);
 207       MutexUnlock(hConn->m_driver->m_mutexReconnect);
 208    }
 209 }
 210
 211 /**
 212  * Set default prefetch limit
 213  */
 214 void LIBNXDB_EXPORTABLE DBSetDefaultPrefetchLimit(DB_DRIVER driver, int limit)
 215 {
 216    driver->m_defaultPrefetchLimit = limit;
 217 }
 218
 219 /**
 220  * Set prefetch limit
 221  */
 222 bool LIBNXDB_EXPORTABLE DBSetPrefetchLimit(DB_HANDLE hConn, int limit)
 223 {
 224    if (hConn->m_driver->m_fpDrvSetPrefetchLimit == NULL)
 225       return false;  // Not supported by driver
 226    return hConn->m_driver->m_fpDrvSetPrefetchLimit(hConn->m_connection, limit);
 227 }
 228
 229 /**
 230  * Set session initialization callback
 231  */
 232 void LIBNXDB_EXPORTABLE DBSetSessionInitCallback(void (*cb)(DB_HANDLE))
 233 {
 234    s_sessionInitCb = cb;
 235 }
 236
 237 /**
 238  * Perform a non-SELECT SQL query
 239  */
 240 bool LIBNXDB_EXPORTABLE DBQueryEx(DB_HANDLE hConn, const TCHAR *szQuery, TCHAR *errorText)
 241 {
 242    DWORD dwResult;
 243 #ifdef UNICODE
 244 #define pwszQuery szQuery
 245 #define wcErrorText errorText
 246 #else
 247    WCHAR *pwszQuery = WideStringFromMBString(szQuery);
 248         WCHAR wcErrorText[DBDRV_MAX_ERROR_TEXT] = L"";
 249 #endif
 250
 251    MutexLock(hConn->m_mutexTransLock);
 252    INT64 ms = GetCurrentTimeMs();
 253
 254    dwResult = hConn->m_driver->m_fpDrvQuery(hConn->m_connection, pwszQuery, wcErrorText);
 255    if ((dwResult == DBERR_CONNECTION_LOST) && hConn->m_reconnectEnabled)
 256    {
 257       DBReconnect(hConn);
 258       dwResult = hConn->m_driver->m_fpDrvQuery(hConn->m_connection, pwszQuery, wcErrorText);
 259    }
 260
 261    s_perfNonSelectQueries++;
 262    s_perfTotalQueries++;
 263
 264    ms = GetCurrentTimeMs() - ms;
 265    if (hConn->m_driver->m_dumpSql)
 266    {
 267       nxlog_debug(9, _T("%s sync query: \"%s\" [%d ms]"), (dwResult == DBERR_SUCCESS) ? _T("Successful") : _T("Failed"), szQuery, ms);
 268    }
 269    if ((dwResult == DBERR_SUCCESS) && ((UINT32)ms > g_sqlQueryExecTimeThreshold))
 270    {
 271       nxlog_debug(3, _T("Long running query: \"%s\" [%d ms]"), szQuery, (int)ms);
 272       s_perfLongRunningQueries++;
 273    }
 274
 275    MutexUnlock(hConn->m_mutexTransLock);
 276
 277 #ifndef UNICODE
 278         WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK | WC_DEFAULTCHAR, wcErrorText, -1, errorText, DBDRV_MAX_ERROR_TEXT, NULL, NULL);
 279         errorText[DBDRV_MAX_ERROR_TEXT - 1] = 0;
 280 #endif
 281
 282    if (dwResult != DBERR_SUCCESS)
 283         {
 284       s_perfFailedQueries++;
 285                 if (hConn->m_driver->m_logSqlErrors)
 286                         nxlog_write(g_sqlErrorMsgCode, EVENTLOG_ERROR_TYPE, "ss", szQuery, errorText);
 287                 if (hConn->m_driver->m_fpEventHandler != NULL)
 288                         hConn->m_driver->m_fpEventHandler(DBEVENT_QUERY_FAILED, pwszQuery, wcErrorText, dwResult == DBERR_CONNECTION_LOST, hConn->m_driver->m_userArg);
 289         }
 290
 291 #ifndef UNICODE
 292    free(pwszQuery);
 293 #endif
 294
 295    return dwResult == DBERR_SUCCESS;
 296 #undef pwszQuery
 297 #undef wcErrorText
 298 }
 299
 300 bool LIBNXDB_EXPORTABLE DBQuery(DB_HANDLE hConn, const TCHAR *query)
 301 {
 302    TCHAR errorText[DBDRV_MAX_ERROR_TEXT];
 303         return DBQueryEx(hConn, query, errorText);
 304 }
 305
 306 /**
 307  * Perform SELECT query
 308  */
 309 DB_RESULT LIBNXDB_EXPORTABLE DBSelectEx(DB_HANDLE hConn, const TCHAR *szQuery, TCHAR *errorText)
 310 {
 311    DBDRV_RESULT hResult;
 312         DB_RESULT result = NULL;
 313    DWORD dwError = DBERR_OTHER_ERROR;
 314 #ifdef UNICODE
 315 #define pwszQuery szQuery
 316 #define wcErrorText errorText
 317 #else
 318    WCHAR *pwszQuery = WideStringFromMBString(szQuery);
 319         WCHAR wcErrorText[DBDRV_MAX_ERROR_TEXT] = L"";
 320 #endif
 321
 322    MutexLock(hConn->m_mutexTransLock);
 323    INT64 ms = GetCurrentTimeMs();
 324
 325    s_perfSelectQueries++;
 326    s_perfTotalQueries++;
 327
 328    hResult = hConn->m_driver->m_fpDrvSelect(hConn->m_connection, pwszQuery, &dwError, wcErrorText);
 329    if ((hResult == NULL) && (dwError == DBERR_CONNECTION_LOST) && hConn->m_reconnectEnabled)
 330    {
 331       DBReconnect(hConn);
 332       hResult = hConn->m_driver->m_fpDrvSelect(hConn->m_connection, pwszQuery, &dwError, wcErrorText);
 333    }
 334
 335    ms = GetCurrentTimeMs() - ms;
 336    if (hConn->m_driver->m_dumpSql)
 337    {
 338       nxlog_debug(9, _T("%s sync query: \"%s\" [%d ms]"), (hResult != NULL) ? _T("Successful") : _T("Failed"), szQuery, (int)ms);
 339    }
 340    if ((hResult != NULL) && ((UINT32)ms > g_sqlQueryExecTimeThreshold))
 341    {
 342       nxlog_debug(3, _T("Long running query: \"%s\" [%d ms]"), szQuery, (int)ms);
 343       s_perfLongRunningQueries++;
 344    }
 345    MutexUnlock(hConn->m_mutexTransLock);
 346
 347 #ifndef UNICODE
 348         WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK | WC_DEFAULTCHAR, wcErrorText, -1, errorText, DBDRV_MAX_ERROR_TEXT, NULL, NULL);
 349         errorText[DBDRV_MAX_ERROR_TEXT - 1] = 0;
 350 #endif
 351
 352         if (hResult == NULL)
 353         {
 354            s_perfFailedQueries++;
 355                 if (hConn->m_driver->m_logSqlErrors)
 356                         nxlog_write(g_sqlErrorMsgCode, EVENTLOG_ERROR_TYPE, "ss", szQuery, errorText);
 357                 if (hConn->m_driver->m_fpEventHandler != NULL)
 358                         hConn->m_driver->m_fpEventHandler(DBEVENT_QUERY_FAILED, pwszQuery, wcErrorText, dwError == DBERR_CONNECTION_LOST, hConn->m_driver->m_userArg);
 359         }
 360
 361 #ifndef UNICODE
 362    free(pwszQuery);
 363 #endif
 364
 365         if (hResult != NULL)
 366         {
 367                 result = (DB_RESULT)malloc(sizeof(db_result_t));
 368                 result->m_driver = hConn->m_driver;
 369                 result->m_connection = hConn;
 370                 result->m_data = hResult;
 371         }
 372
 373    return result;
 374 #undef pwszQuery
 375 #undef wcErrorText
 376 }
 377
 378 DB_RESULT LIBNXDB_EXPORTABLE DBSelect(DB_HANDLE hConn, const TCHAR *query)
 379 {
 380    TCHAR errorText[DBDRV_MAX_ERROR_TEXT];
 381
 382         return DBSelectEx(hConn, query, errorText);
 383 }
 384
 385 /**
 386  * Get number of columns
 387  */
 388 int LIBNXDB_EXPORTABLE DBGetColumnCount(DB_RESULT hResult)
 389 {
 390         return hResult->m_driver->m_fpDrvGetColumnCount(hResult->m_data);
 391 }
 392
 393 /**
 394  * Get column name
 395  */
 396 bool LIBNXDB_EXPORTABLE DBGetColumnName(DB_RESULT hResult, int column, TCHAR *buffer, int bufSize)
 397 {
 398         const char *name;
 399
 400         name = hResult->m_driver->m_fpDrvGetColumnName(hResult->m_data, column);
 401         if (name != NULL)
 402         {
 403 #ifdef UNICODE
 404                 MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, name, -1, buffer, bufSize);
 405                 buffer[bufSize - 1] = 0;
 406 #else
 407                 nx_strncpy(buffer, name, bufSize);
 408 #endif
 409         }
 410         return name != NULL;
 411 }
 412
 413 /**
 414  * Get column count for unbuffered result set
 415  */
 416 int LIBNXDB_EXPORTABLE DBGetColumnCount(DB_UNBUFFERED_RESULT hResult)
 417 {
 418         return hResult->m_driver->m_fpDrvGetColumnCountUnbuffered(hResult->m_data);
 419 }
 420
 421 /**
 422  * Get column name for unbuffered result set
 423  */
 424 bool LIBNXDB_EXPORTABLE DBGetColumnName(DB_UNBUFFERED_RESULT hResult, int column, TCHAR *buffer, int bufSize)
 425 {
 426         const char *name;
 427
 428         name = hResult->m_driver->m_fpDrvGetColumnNameUnbuffered(hResult->m_data, column);
 429         if (name != NULL)
 430         {
 431 #ifdef UNICODE
 432                 MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, name, -1, buffer, bufSize);
 433                 buffer[bufSize - 1] = 0;
 434 #else
 435                 nx_strncpy(buffer, name, bufSize);
 436 #endif
 437         }
 438         return name != NULL;
 439 }
 440
 441 /**
 442  * Get field's value. If buffer is NULL, dynamically allocated string will be returned.
 443  * Caller is responsible for destroying it by calling free().
 444  */
 445 TCHAR LIBNXDB_EXPORTABLE *DBGetField(DB_RESULT hResult, int iRow, int iColumn, TCHAR *pszBuffer, int nBufLen)
 446 {
 447 #ifdef UNICODE
 448    if (pszBuffer != NULL)
 449    {
 450       *pszBuffer = 0;
 451       return hResult->m_driver->m_fpDrvGetField(hResult->m_data, iRow, iColumn, pszBuffer, nBufLen);
 452    }
 453    else
 454    {
 455       WCHAR *pszTemp;
 456       LONG nLen = hResult->m_driver->m_fpDrvGetFieldLength(hResult->m_data, iRow, iColumn);
 457       if (nLen == -1)
 458       {
 459          pszTemp = NULL;
 460       }
 461       else
 462       {
 463          nLen++;
 464          pszTemp = (WCHAR *)malloc(nLen * sizeof(WCHAR));
 465          hResult->m_driver->m_fpDrvGetField(hResult->m_data, iRow, iColumn, pszTemp, nLen);
 466       }
 467       return pszTemp;
 468    }
 469 #else
 470         return DBGetFieldA(hResult, iRow, iColumn, pszBuffer, nBufLen);
 471 #endif
 472 }
 473
 474 /**
 475  * Get field's value as UTF8 string. If buffer is NULL, dynamically allocated string will be returned.
 476  * Caller is responsible for destroying it by calling free().
 477  */
 478 char LIBNXDB_EXPORTABLE *DBGetFieldUTF8(DB_RESULT hResult, int iRow, int iColumn, char *pszBuffer, int nBufLen)
 479 {
 480    if (hResult->m_driver->m_fpDrvGetFieldUTF8 != NULL)
 481    {
 482       if (pszBuffer != NULL)
 483       {
 484          *pszBuffer = 0;
 485          return hResult->m_driver->m_fpDrvGetFieldUTF8(hResult->m_data, iRow, iColumn, pszBuffer, nBufLen);
 486       }
 487       else
 488       {
 489          char *pszTemp;
 490          LONG nLen = hResult->m_driver->m_fpDrvGetFieldLength(hResult->m_data, iRow, iColumn);
 491          if (nLen == -1)
 492          {
 493             pszTemp = NULL;
 494          }
 495          else
 496          {
 497             nLen = nLen * 2 + 1;  // increase buffer size because driver may return field length in characters
 498             pszTemp = (char *)malloc(nLen);
 499             hResult->m_driver->m_fpDrvGetFieldUTF8(hResult->m_data, iRow, iColumn, pszTemp, nLen);
 500          }
 501          return pszTemp;
 502       }
 503    }
 504    else
 505    {
 506       LONG nLen = hResult->m_driver->m_fpDrvGetFieldLength(hResult->m_data, iRow, iColumn);
 507       if (nLen == -1)
 508          return NULL;
 509       nLen = nLen * 2 + 1;  // increase buffer size because driver may return field length in characters
 510
 511       WCHAR *wtemp = (WCHAR *)malloc(nLen * sizeof(WCHAR));
 512       hResult->m_driver->m_fpDrvGetField(hResult->m_data, iRow, iColumn, wtemp, nLen);
 513       char *value = (pszBuffer != NULL) ? pszBuffer : (char *)malloc(nLen);
 514       WideCharToMultiByte(CP_UTF8, 0, wtemp, -1, value, (pszBuffer != NULL) ? nBufLen : nLen, NULL, NULL);
 515       free(wtemp);
 516       return value;
 517    }
 518 }
 519
 520 /**
 521  * Get field's value as multibyte string. If buffer is NULL, dynamically allocated string will be returned.
 522  * Caller is responsible for destroying it by calling free().
 523  */
 524 char LIBNXDB_EXPORTABLE *DBGetFieldA(DB_RESULT hResult, int iRow, int iColumn, char *pszBuffer, int nBufLen)
 525 {
 526    WCHAR *pwszData, *pwszBuffer;
 527    char *pszRet;
 528    int nLen;
 529
 530    if (pszBuffer != NULL)
 531    {
 532       *pszBuffer = 0;
 533       pwszBuffer = (WCHAR *)malloc(nBufLen * sizeof(WCHAR));
 534       pwszData = hResult->m_driver->m_fpDrvGetField(hResult->m_data, iRow, iColumn, pwszBuffer, nBufLen);
 535       if (pwszData != NULL)
 536       {
 537          WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK | WC_DEFAULTCHAR, pwszData, -1, pszBuffer, nBufLen, NULL, NULL);
 538          pszRet = pszBuffer;
 539       }
 540       else
 541       {
 542          pszRet = NULL;
 543       }
 544       free(pwszBuffer);
 545    }
 546    else
 547    {
 548       nLen = hResult->m_driver->m_fpDrvGetFieldLength(hResult->m_data, iRow, iColumn);
 549       if (nLen == -1)
 550       {
 551          pszRet = NULL;
 552       }
 553       else
 554       {
 555          nLen++;
 556          pwszBuffer = (WCHAR *)malloc(nLen * sizeof(WCHAR));
 557          pwszData = hResult->m_driver->m_fpDrvGetField(hResult->m_data, iRow, iColumn, pwszBuffer, nLen);
 558          if (pwszData != NULL)
 559          {
 560             nLen = (int)wcslen(pwszData) + 1;
 561             pszRet = (char *)malloc(nLen);
 562             WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK | WC_DEFAULTCHAR, pwszData, -1, pszRet, nLen, NULL, NULL);
 563          }
 564          else
 565          {
 566             pszRet = NULL;
 567          }
 568          free(pwszBuffer);
 569       }
 570    }
 571    return pszRet;
 572 }
 573
 574 /**
 575  * Get text field and escape it for XML document. Returned string
 576  * always dynamically allocated and must be destroyed by caller.
 577  */
 578 TCHAR LIBNXDB_EXPORTABLE *DBGetFieldForXML(DB_RESULT hResult, int row, int col)
 579 {
 580    TCHAR *value = DBGetField(hResult, row, col, NULL, 0);
 581    TCHAR *xmlString = EscapeStringForXML(value, -1);
 582    safe_free(value);
 583    return xmlString;
 584 }
 585
 586 /**
 587  * Get field's value as unsigned long
 588  */
 589 UINT32 LIBNXDB_EXPORTABLE DBGetFieldULong(DB_RESULT hResult, int iRow, int iColumn)
 590 {
 591    INT32 iVal;
 592    UINT32 dwVal;
 593    TCHAR *pszVal, szBuffer[256];
 594
 595    pszVal = DBGetField(hResult, iRow, iColumn, szBuffer, 256);
 596    if (pszVal == NULL)
 597       return 0;
 598         StrStrip(pszVal);
 599         if (*pszVal == _T('-'))
 600         {
 601                 iVal = _tcstol(pszVal, NULL, 10);
 602                 memcpy(&dwVal, &iVal, sizeof(INT32));   // To prevent possible conversion
 603         }
 604         else
 605         {
 606                 dwVal = _tcstoul(pszVal, NULL, 10);
 607         }
 608    return dwVal;
 609 }
 610
 611 /**
 612  * Get field's value as unsigned 64-bit int
 613  */
 614 UINT64 LIBNXDB_EXPORTABLE DBGetFieldUInt64(DB_RESULT hResult, int iRow, int iColumn)
 615 {
 616    INT64 iVal;
 617    UINT64 qwVal;
 618    TCHAR *pszVal, szBuffer[256];
 619
 620    pszVal = DBGetField(hResult, iRow, iColumn, szBuffer, 256);
 621    if (pszVal == NULL)
 622       return 0;
 623         StrStrip(pszVal);
 624         if (*pszVal == _T('-'))
 625         {
 626                 iVal = _tcstoll(pszVal, NULL, 10);
 627                 memcpy(&qwVal, &iVal, sizeof(INT64));   // To prevent possible conversion
 628         }
 629         else
 630         {
 631                 qwVal = _tcstoull(pszVal, NULL, 10);
 632         }
 633    return qwVal;
 634 }
 635
 636 /**
 637  * Get field's value as signed long
 638  */
 639 INT32 LIBNXDB_EXPORTABLE DBGetFieldLong(DB_RESULT hResult, int iRow, int iColumn)
 640 {
 641    TCHAR *pszVal, szBuffer[256];
 642
 643    pszVal = DBGetField(hResult, iRow, iColumn, szBuffer, 256);
 644    return pszVal == NULL ? 0 : _tcstol(pszVal, NULL, 10);
 645 }
 646
 647 /**
 648  * Get field's value as signed 64-bit int
 649  */
 650 INT64 LIBNXDB_EXPORTABLE DBGetFieldInt64(DB_RESULT hResult, int iRow, int iColumn)
 651 {
 652    TCHAR *pszVal, szBuffer[256];
 653
 654    pszVal = DBGetField(hResult, iRow, iColumn, szBuffer, 256);
 655    return pszVal == NULL ? 0 : _tcstoll(pszVal, NULL, 10);
 656 }
 657
 658 /**
 659  * Get field's value as double
 660  */
 661 double LIBNXDB_EXPORTABLE DBGetFieldDouble(DB_RESULT hResult, int iRow, int iColumn)
 662 {
 663    TCHAR *pszVal, szBuffer[256];
 664
 665    pszVal = DBGetField(hResult, iRow, iColumn, szBuffer, 256);
 666    return pszVal == NULL ? 0 : _tcstod(pszVal, NULL);
 667 }
 668
 669 /**
 670  * Get field's value as IPv4 address
 671  */
 672 UINT32 LIBNXDB_EXPORTABLE DBGetFieldIPAddr(DB_RESULT hResult, int iRow, int iColumn)
 673 {
 674    TCHAR *pszVal, szBuffer[256];
 675
 676    pszVal = DBGetField(hResult, iRow, iColumn, szBuffer, 256);
 677    return pszVal == NULL ? 0 : ntohl(_t_inet_addr(pszVal));
 678 }
 679
 680 /**
 681  * Get field's value as IP address
 682  */
 683 InetAddress LIBNXDB_EXPORTABLE DBGetFieldInetAddr(DB_RESULT hResult, int iRow, int iColumn)
 684 {
 685    TCHAR *pszVal, szBuffer[256];
 686
 687    pszVal = DBGetField(hResult, iRow, iColumn, szBuffer, 256);
 688    return pszVal == NULL ? InetAddress() : InetAddress::parse(pszVal);
 689 }
 690
 691 /**
 692  * Get field's value as integer array from byte array encoded in hex
 693  */
 694 bool LIBNXDB_EXPORTABLE DBGetFieldByteArray(DB_RESULT hResult, int iRow, int iColumn,
 695                                             int *pnArray, int nSize, int nDefault)
 696 {
 697    char pbBytes[128];
 698    bool bResult;
 699    int i, nLen;
 700    TCHAR *pszVal, szBuffer[256];
 701
 702    pszVal = DBGetField(hResult, iRow, iColumn, szBuffer, 256);
 703    if (pszVal != NULL)
 704    {
 705       StrToBin(pszVal, (BYTE *)pbBytes, 128);
 706       nLen = (int)_tcslen(pszVal) / 2;
 707       for(i = 0; (i < nSize) && (i < nLen); i++)
 708          pnArray[i] = pbBytes[i];
 709       for(; i < nSize; i++)
 710          pnArray[i] = nDefault;
 711       bResult = true;
 712    }
 713    else
 714    {
 715       for(i = 0; i < nSize; i++)
 716          pnArray[i] = nDefault;
 717       bResult = false;
 718    }
 719    return bResult;
 720 }
 721
 722 bool LIBNXDB_EXPORTABLE DBGetFieldByteArray2(DB_RESULT hResult, int iRow, int iColumn,
 723                                              BYTE *data, int nSize, int nDefault)
 724 {
 725    bool bResult;
 726    TCHAR *pszVal, szBuffer[256];
 727
 728    pszVal = DBGetField(hResult, iRow, iColumn, szBuffer, 256);
 729    if (pszVal != NULL)
 730    {
 731       int bytes = (int)StrToBin(pszVal, data, nSize);
 732                 if (bytes < nSize)
 733                         memset(&data[bytes], 0, nSize - bytes);
 734       bResult = true;
 735    }
 736    else
 737    {
 738                 memset(data, nDefault, nSize);
 739       bResult = false;
 740    }
 741    return bResult;
 742 }
 743
 744 /**
 745  * Get field's value as GUID
 746  */
 747 uuid LIBNXDB_EXPORTABLE DBGetFieldGUID(DB_RESULT hResult, int iRow, int iColumn)
 748 {
 749    TCHAR buffer[256];
 750    TCHAR *value = DBGetField(hResult, iRow, iColumn, buffer, 256);
 751    return (value == NULL) ? uuid::NULL_UUID : uuid::parse(value);
 752 }
 753
 754 /**
 755  * Get number of rows in result
 756  */
 757 int LIBNXDB_EXPORTABLE DBGetNumRows(DB_RESULT hResult)
 758 {
 759    if (hResult == NULL)
 760       return 0;
 761    return hResult->m_driver->m_fpDrvGetNumRows(hResult->m_data);
 762 }
 763
 764 /**
 765  * Free result
 766  */
 767 void LIBNXDB_EXPORTABLE DBFreeResult(DB_RESULT hResult)
 768 {
 769    if (hResult != NULL)
 770         {
 771       hResult->m_driver->m_fpDrvFreeResult(hResult->m_data);
 772                 free(hResult);
 773         }
 774 }
 775
 776 /**
 777  * Unbuffered SELECT query
 778  */
 779 DB_UNBUFFERED_RESULT LIBNXDB_EXPORTABLE DBSelectUnbufferedEx(DB_HANDLE hConn, const TCHAR *szQuery, TCHAR *errorText)
 780 {
 781    DBDRV_UNBUFFERED_RESULT hResult;
 782         DB_UNBUFFERED_RESULT result = NULL;
 783    DWORD dwError = DBERR_OTHER_ERROR;
 784 #ifdef UNICODE
 785 #define pwszQuery szQuery
 786 #define wcErrorText errorText
 787 #else
 788    WCHAR *pwszQuery = WideStringFromMBString(szQuery);
 789         WCHAR wcErrorText[DBDRV_MAX_ERROR_TEXT] = L"";
 790 #endif
 791
 792    MutexLock(hConn->m_mutexTransLock);
 793    INT64 ms = GetCurrentTimeMs();
 794
 795    s_perfSelectQueries++;
 796    s_perfTotalQueries++;
 797
 798    hResult = hConn->m_driver->m_fpDrvSelectUnbuffered(hConn->m_connection, pwszQuery, &dwError, wcErrorText);
 799    if ((hResult == NULL) && (dwError == DBERR_CONNECTION_LOST) && hConn->m_reconnectEnabled)
 800    {
 801       DBReconnect(hConn);
 802       hResult = hConn->m_driver->m_fpDrvSelectUnbuffered(hConn->m_connection, pwszQuery, &dwError, wcErrorText);
 803    }
 804
 805    ms = GetCurrentTimeMs() - ms;
 806    if (hConn->m_driver->m_dumpSql)
 807    {
 808       nxlog_debug(9, _T("%s unbuffered query: \"%s\" [%d ms]"), (hResult != NULL) ? _T("Successful") : _T("Failed"), szQuery, (int)ms);
 809    }
 810    if ((hResult != NULL) && ((UINT32)ms > g_sqlQueryExecTimeThreshold))
 811    {
 812       nxlog_debug(3, _T("Long running query: \"%s\" [%d ms]"), szQuery, (int)ms);
 813       s_perfLongRunningQueries++;
 814    }
 815    if (hResult == NULL)
 816    {
 817       s_perfFailedQueries++;
 818       MutexUnlock(hConn->m_mutexTransLock);
 819
 820 #ifndef UNICODE
 821                 WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK | WC_DEFAULTCHAR, wcErrorText, -1, errorText, DBDRV_MAX_ERROR_TEXT, NULL, NULL);
 822                 errorText[DBDRV_MAX_ERROR_TEXT - 1] = 0;
 823 #endif
 824
 825                 if (hConn->m_driver->m_logSqlErrors)
 826         nxlog_write(g_sqlErrorMsgCode, EVENTLOG_ERROR_TYPE, "ss", szQuery, errorText);
 827                 if (hConn->m_driver->m_fpEventHandler != NULL)
 828                         hConn->m_driver->m_fpEventHandler(DBEVENT_QUERY_FAILED, pwszQuery, wcErrorText, dwError == DBERR_CONNECTION_LOST, hConn->m_driver->m_userArg);
 829    }
 830
 831 #ifndef UNICODE
 832    free(pwszQuery);
 833 #endif
 834
 835         if (hResult != NULL)
 836         {
 837                 result = (DB_UNBUFFERED_RESULT)malloc(sizeof(db_unbuffered_result_t));
 838                 result->m_driver = hConn->m_driver;
 839                 result->m_connection = hConn;
 840                 result->m_data = hResult;
 841         }
 842
 843    return result;
 844 #undef pwszQuery
 845 #undef wcErrorText
 846 }
 847
 848 DB_UNBUFFERED_RESULT LIBNXDB_EXPORTABLE DBSelectUnbuffered(DB_HANDLE hConn, const TCHAR *query)
 849 {
 850    TCHAR errorText[DBDRV_MAX_ERROR_TEXT];
 851
 852         return DBSelectUnbufferedEx(hConn, query, errorText);
 853 }
 854
 855 /**
 856  * Fetch next row from unbuffered SELECT result
 857  */
 858 bool LIBNXDB_EXPORTABLE DBFetch(DB_UNBUFFERED_RESULT hResult)
 859 {
 860         return hResult->m_driver->m_fpDrvFetch(hResult->m_data);
 861 }
 862
 863 /**
 864  * Get field's value from unbuffered SELECT result
 865  */
 866 TCHAR LIBNXDB_EXPORTABLE *DBGetField(DB_UNBUFFERED_RESULT hResult, int iColumn, TCHAR *pBuffer, int iBufSize)
 867 {
 868 #ifdef UNICODE
 869    if (pBuffer != NULL)
 870    {
 871            return hResult->m_driver->m_fpDrvGetFieldUnbuffered(hResult->m_data, iColumn, pBuffer, iBufSize);
 872    }
 873    else
 874    {
 875       INT32 nLen;
 876       WCHAR *pszTemp;
 877
 878       nLen = hResult->m_driver->m_fpDrvGetFieldLengthUnbuffered(hResult->m_data, iColumn);
 879       if (nLen == -1)
 880       {
 881          pszTemp = NULL;
 882       }
 883       else
 884       {
 885          nLen++;
 886          pszTemp = (WCHAR *)malloc(nLen * sizeof(WCHAR));
 887          hResult->m_driver->m_fpDrvGetFieldUnbuffered(hResult->m_data, iColumn, pszTemp, nLen);
 888       }
 889       return pszTemp;
 890    }
 891 #else
 892    WCHAR *pwszData, *pwszBuffer;
 893    char *pszRet;
 894    int nLen;
 895
 896    if (pBuffer != NULL)
 897    {
 898                 pwszBuffer = (WCHAR *)malloc(iBufSize * sizeof(WCHAR));
 899                 if (hResult->m_driver->m_fpDrvGetFieldUnbuffered(hResult->m_data, iColumn, pwszBuffer, iBufSize) != NULL)
 900                 {
 901                         WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK | WC_DEFAULTCHAR,
 902                                                                           pwszBuffer, -1, pBuffer, iBufSize, NULL, NULL);
 903                         pszRet = pBuffer;
 904                 }
 905                 else
 906                 {
 907                         pszRet = NULL;
 908                 }
 909                 free(pwszBuffer);
 910    }
 911    else
 912    {
 913                 nLen = hResult->m_driver->m_fpDrvGetFieldLengthUnbuffered(hResult->m_data, iColumn);
 914       if (nLen == -1)
 915       {
 916          pszRet = NULL;
 917       }
 918       else
 919       {
 920          nLen++;
 921          pwszBuffer = (WCHAR *)malloc(nLen * sizeof(WCHAR));
 922                         pwszData = hResult->m_driver->m_fpDrvGetFieldUnbuffered(hResult->m_data, iColumn, pwszBuffer, nLen);
 923          if (pwszData != NULL)
 924          {
 925             nLen = (int)wcslen(pwszData) + 1;
 926             pszRet = (char *)malloc(nLen);
 927             WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK | WC_DEFAULTCHAR,
 928                                 pwszData, -1, pszRet, nLen, NULL, NULL);
 929          }
 930          else
 931          {
 932             pszRet = NULL;
 933          }
 934          free(pwszBuffer);
 935       }
 936    }
 937    return pszRet;
 938 #endif
 939 }
 940
 941 /**
 942  * Get field's value as unsigned long from unbuffered SELECT result
 943  */
 944 UINT32 LIBNXDB_EXPORTABLE DBGetFieldULong(DB_UNBUFFERED_RESULT hResult, int iColumn)
 945 {
 946    INT32 iVal;
 947    UINT32 dwVal;
 948    TCHAR szBuffer[64];
 949
 950    if (DBGetField(hResult, iColumn, szBuffer, 64) == NULL)
 951       return 0;
 952         StrStrip(szBuffer);
 953         if (szBuffer[0] == _T('-'))
 954         {
 955                 iVal = _tcstol(szBuffer, NULL, 10);
 956                 memcpy(&dwVal, &iVal, sizeof(INT32));   // To prevent possible conversion
 957         }
 958         else
 959         {
 960                 dwVal = _tcstoul(szBuffer, NULL, 10);
 961         }
 962    return dwVal;
 963 }
 964
 965 /**
 966  * Get field's value as unsigned 64-bit int from unbuffered SELECT result
 967  */
 968 UINT64 LIBNXDB_EXPORTABLE DBGetFieldUInt64(DB_UNBUFFERED_RESULT hResult, int iColumn)
 969 {
 970    INT64 iVal;
 971    UINT64 qwVal;
 972    TCHAR szBuffer[64];
 973
 974    if (DBGetField(hResult, iColumn, szBuffer, 64) == NULL)
 975       return 0;
 976         StrStrip(szBuffer);
 977         if (szBuffer[0] == _T('-'))
 978         {
 979                 iVal = _tcstoll(szBuffer, NULL, 10);
 980                 memcpy(&qwVal, &iVal, sizeof(INT64));   // To prevent possible conversion
 981         }
 982         else
 983         {
 984                 qwVal = _tcstoull(szBuffer, NULL, 10);
 985         }
 986    return qwVal;
 987 }
 988
 989 /**
 990  * Get field's value as signed long from unbuffered SELECT result
 991  */
 992 INT32 LIBNXDB_EXPORTABLE DBGetFieldLong(DB_UNBUFFERED_RESULT hResult, int iColumn)
 993 {
 994    TCHAR szBuffer[64];
 995    return DBGetField(hResult, iColumn, szBuffer, 64) == NULL ? 0 : _tcstol(szBuffer, NULL, 10);
 996 }
 997
 998 /**
 999  * Get field's value as signed 64-bit int from unbuffered SELECT result
1000  */
1001 INT64 LIBNXDB_EXPORTABLE DBGetFieldInt64(DB_UNBUFFERED_RESULT hResult, int iColumn)
1002 {
1003    TCHAR szBuffer[64];
1004    return DBGetField(hResult, iColumn, szBuffer, 64) == NULL ? 0 : _tcstoll(szBuffer, NULL, 10);
1005 }
1006
1007 /**
1008  * Get field's value as signed long from unbuffered SELECT result
1009  */
1010 double LIBNXDB_EXPORTABLE DBGetFieldDouble(DB_UNBUFFERED_RESULT hResult, int iColumn)
1011 {
1012    TCHAR szBuffer[64];
1013    return DBGetField(hResult, iColumn, szBuffer, 64) == NULL ? 0 : _tcstod(szBuffer, NULL);
1014 }
1015
1016 /**
1017  * Get field's value as IPv4 address from unbuffered SELECT result
1018  */
1019 UINT32 LIBNXDB_EXPORTABLE DBGetFieldIPAddr(DB_UNBUFFERED_RESULT hResult, int iColumn)
1020 {
1021    TCHAR buffer[64];
1022    return (DBGetField(hResult, iColumn, buffer, 64) == NULL) ? INADDR_NONE : ntohl(_t_inet_addr(buffer));
1023 }
1024
1025 /**
1026  * Get field's value as IP address from unbuffered SELECT result
1027  */
1028 InetAddress LIBNXDB_EXPORTABLE DBGetFieldInetAddr(DB_UNBUFFERED_RESULT hResult, int iColumn)
1029 {
1030    TCHAR buffer[64];
1031    return (DBGetField(hResult, iColumn, buffer, 64) == NULL) ? InetAddress() : InetAddress::parse(buffer);
1032 }
1033
1034 /**
1035  * Get field's value as GUID from unbuffered SELECT result
1036  */
1037 uuid LIBNXDB_EXPORTABLE DBGetFieldGUID(DB_UNBUFFERED_RESULT hResult, int iColumn)
1038 {
1039    TCHAR buffer[64];
1040    return (DBGetField(hResult, iColumn, buffer, 64) == NULL) ? uuid::NULL_UUID : uuid::parse(buffer);
1041 }
1042
1043 /**
1044  * Free unbuffered SELECT result
1045  */
1046 void LIBNXDB_EXPORTABLE DBFreeResult(DB_UNBUFFERED_RESULT hResult)
1047 {
1048         hResult->m_driver->m_fpDrvFreeUnbufferedResult(hResult->m_data);
1049         MutexUnlock(hResult->m_connection->m_mutexTransLock);
1050         free(hResult);
1051 }
1052
1053 /**
1054  * Prepare statement
1055  */
1056 DB_STATEMENT LIBNXDB_EXPORTABLE DBPrepareEx(DB_HANDLE hConn, const TCHAR *query, TCHAR *errorText)
1057 {
1058         DB_STATEMENT result = NULL;
1059         INT64 ms;
1060
1061 #ifdef UNICODE
1062 #define pwszQuery query
1063 #define wcErrorText errorText
1064 #else
1065    WCHAR *pwszQuery = WideStringFromMBString(query);
1066         WCHAR wcErrorText[DBDRV_MAX_ERROR_TEXT] = L"";
1067 #endif
1068
1069         MutexLock(hConn->m_mutexTransLock);
1070
1071         if (hConn->m_driver->m_dumpSql)
1072       ms = GetCurrentTimeMs();
1073
1074         DWORD errorCode;
1075         DBDRV_STATEMENT stmt = hConn->m_driver->m_fpDrvPrepare(hConn->m_connection, pwszQuery, &errorCode, wcErrorText);
1076    if ((stmt == NULL) && (errorCode == DBERR_CONNECTION_LOST) && hConn->m_reconnectEnabled)
1077    {
1078       DBReconnect(hConn);
1079                 stmt = hConn->m_driver->m_fpDrvPrepare(hConn->m_connection, pwszQuery, &errorCode, wcErrorText);
1080         }
1081    MutexUnlock(hConn->m_mutexTransLock);
1082
1083         if (stmt != NULL)
1084         {
1085                 result = (DB_STATEMENT)malloc(sizeof(db_statement_t));
1086                 result->m_driver = hConn->m_driver;
1087                 result->m_connection = hConn;
1088                 result->m_statement = stmt;
1089                 result->m_query = _tcsdup(query);
1090         }
1091         else
1092         {
1093 #ifndef UNICODE
1094                 WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK | WC_DEFAULTCHAR, wcErrorText, -1, errorText, DBDRV_MAX_ERROR_TEXT, NULL, NULL);
1095                 errorText[DBDRV_MAX_ERROR_TEXT - 1] = 0;
1096 #endif
1097
1098                 if (hConn->m_driver->m_logSqlErrors)
1099         nxlog_write(g_sqlErrorMsgCode, EVENTLOG_ERROR_TYPE, "ss", query, errorText);
1100                 if (hConn->m_driver->m_fpEventHandler != NULL)
1101                         hConn->m_driver->m_fpEventHandler(DBEVENT_QUERY_FAILED, pwszQuery, wcErrorText, errorCode == DBERR_CONNECTION_LOST, hConn->m_driver->m_userArg);
1102
1103                 s_perfFailedQueries++;
1104                 s_perfTotalQueries++;
1105         }
1106
1107    if (hConn->m_driver->m_dumpSql)
1108    {
1109       ms = GetCurrentTimeMs() - ms;
1110                 nxlog_debug(9, _T("{%p} %s prepare: \"%s\" [%d ms]"), result, (result != NULL) ? _T("Successful") : _T("Failed"), query, ms);
1111         }
1112
1113 #ifndef UNICODE
1114         free(pwszQuery);
1115 #endif
1116
1117    if (result != NULL)
1118    {
1119       hConn->m_preparedStatements->add(result);
1120    }
1121
1122         return result;
1123 #undef pwszQuery
1124 #undef wcErrorText
1125 }
1126
1127 /**
1128  * Prepare statement
1129  */
1130 DB_STATEMENT LIBNXDB_EXPORTABLE DBPrepare(DB_HANDLE hConn, const TCHAR *query)
1131 {
1132         TCHAR errorText[DBDRV_MAX_ERROR_TEXT];
1133         return DBPrepareEx(hConn, query, errorText);
1134 }
1135
1136 /**
1137  * Destroy prepared statement
1138  */
1139 void LIBNXDB_EXPORTABLE DBFreeStatement(DB_STATEMENT hStmt)
1140 {
1141    if (hStmt == NULL)
1142       return;
1143
1144    if (hStmt->m_connection != NULL)
1145    {
1146       hStmt->m_connection->m_preparedStatements->remove(hStmt);
1147    }
1148    hStmt->m_driver->m_fpDrvFreeStatement(hStmt->m_statement);
1149    safe_free(hStmt->m_query);
1150         free(hStmt);
1151 }
1152
1153 /**
1154  * Get source query for prepared statement
1155  */
1156 const TCHAR LIBNXDB_EXPORTABLE *DBGetStatementSource(DB_STATEMENT hStmt)
1157 {
1158    return hStmt->m_query;
1159 }
1160
1161 /**
1162  * Open batch
1163  */
1164 bool LIBNXDB_EXPORTABLE DBOpenBatch(DB_STATEMENT hStmt)
1165 {
1166    if (!IS_VALID_STATEMENT_HANDLE(hStmt) || (hStmt->m_driver->m_fpDrvOpenBatch == NULL))
1167       return false;
1168    return hStmt->m_driver->m_fpDrvOpenBatch(hStmt->m_statement);
1169 }
1170
1171 /**
1172  * Start next batch row batch
1173  */
1174 void LIBNXDB_EXPORTABLE DBNextBatchRow(DB_STATEMENT hStmt)
1175 {
1176    if (IS_VALID_STATEMENT_HANDLE(hStmt) && (hStmt->m_driver->m_fpDrvNextBatchRow != NULL))
1177       hStmt->m_driver->m_fpDrvNextBatchRow(hStmt->m_statement);
1178 }
1179
1180 /**
1181  * Bind parameter (generic)
1182  */
1183 void LIBNXDB_EXPORTABLE DBBind(DB_STATEMENT hStmt, int pos, int sqlType, int cType, void *buffer, int allocType)
1184 {
1185         if ((pos <= 0) || !IS_VALID_STATEMENT_HANDLE(hStmt))
1186                 return;
1187
1188         if (hStmt->m_connection->m_driver->m_dumpSql)
1189    {
1190                 if (cType == DB_CTYPE_STRING)
1191                 {
1192                         nxlog_debug(9, _T("{%p} bind at pos %d: \"%s\""), hStmt, pos, buffer);
1193                 }
1194                 else
1195                 {
1196                         TCHAR text[64];
1197                         switch(cType)
1198                         {
1199                                 case DB_CTYPE_INT32:
1200                                         _sntprintf(text, 64, _T("%d"), *((INT32 *)buffer));
1201                                         break;
1202                                 case DB_CTYPE_UINT32:
1203                                         _sntprintf(text, 64, _T("%u"), *((UINT32 *)buffer));
1204                                         break;
1205                                 case DB_CTYPE_INT64:
1206                                         _sntprintf(text, 64, INT64_FMT, *((INT64 *)buffer));
1207                                         break;
1208                                 case DB_CTYPE_UINT64:
1209                                         _sntprintf(text, 64, UINT64_FMT, *((UINT64 *)buffer));
1210                                         break;
1211                                 case DB_CTYPE_DOUBLE:
1212                                         _sntprintf(text, 64, _T("%f"), *((double *)buffer));
1213                                         break;
1214                         }
1215                         nxlog_debug(9, _T("{%p} bind at pos %d: \"%s\""), hStmt, pos, text);
1216                 }
1217         }
1218
1219 #ifdef UNICODE
1220 #define wBuffer buffer
1221 #define realAllocType allocType
1222 #else
1223         void *wBuffer;
1224         int realAllocType = allocType;
1225         if (cType == DB_CTYPE_STRING)
1226         {
1227                 wBuffer = (void *)WideStringFromMBString((char *)buffer);
1228                 if (allocType == DB_BIND_DYNAMIC)
1229                         free(buffer);
1230                 realAllocType = DB_BIND_DYNAMIC;
1231         }
1232         else
1233         {
1234                 wBuffer = buffer;
1235         }
1236 #endif
1237         hStmt->m_driver->m_fpDrvBind(hStmt->m_statement, pos, sqlType, cType, wBuffer, realAllocType);
1238 #undef wBuffer
1239 #undef realAllocType
1240 }
1241
1242 /**
1243  * Bind string parameter
1244  */
1245 void LIBNXDB_EXPORTABLE DBBind(DB_STATEMENT hStmt, int pos, int sqlType, const TCHAR *value, int allocType)
1246 {
1247         if (value != NULL)
1248                 DBBind(hStmt, pos, sqlType, DB_CTYPE_STRING, (void *)value, allocType);
1249         else
1250                 DBBind(hStmt, pos, sqlType, DB_CTYPE_STRING, (void *)_T(""), DB_BIND_STATIC);
1251 }
1252
1253 /**
1254  * Bind string parameter with length validation
1255  */
1256 void LIBNXDB_EXPORTABLE DBBind(DB_STATEMENT hStmt, int pos, int sqlType, const TCHAR *value, int allocType, int maxLen)
1257 {
1258         if (value != NULL)
1259    {
1260       if ((int)_tcslen(value) <= maxLen)
1261       {
1262                    DBBind(hStmt, pos, sqlType, DB_CTYPE_STRING, (void *)value, allocType);
1263       }
1264       else
1265       {
1266          if (allocType == DB_BIND_DYNAMIC)
1267          {
1268             ((TCHAR *)value)[maxLen] = 0;
1269                    DBBind(hStmt, pos, sqlType, DB_CTYPE_STRING, (void *)value, DB_BIND_DYNAMIC);
1270          }
1271          else
1272          {
1273             TCHAR *temp = (TCHAR *)nx_memdup(value, sizeof(TCHAR) * (maxLen + 1));
1274             temp[maxLen] = 0;
1275                    DBBind(hStmt, pos, sqlType, DB_CTYPE_STRING, temp, DB_BIND_DYNAMIC);
1276          }
1277       }
1278    }
1279         else
1280    {
1281                 DBBind(hStmt, pos, sqlType, DB_CTYPE_STRING, (void *)_T(""), DB_BIND_STATIC);
1282    }
1283 }
1284
1285 /**
1286  * Bind 32 bit integer parameter
1287  */
1288 void LIBNXDB_EXPORTABLE DBBind(DB_STATEMENT hStmt, int pos, int sqlType, INT32 value)
1289 {
1290         DBBind(hStmt, pos, sqlType, DB_CTYPE_INT32, &value, DB_BIND_TRANSIENT);
1291 }
1292
1293 /**
1294  * Bind 32 bit unsigned integer parameter
1295  */
1296 void LIBNXDB_EXPORTABLE DBBind(DB_STATEMENT hStmt, int pos, int sqlType, UINT32 value)
1297 {
1298         // C type intentionally set to INT32 - unsigned numbers will be written as negatives
1299         // and correctly parsed on read by DBGetFieldULong
1300         // Setting it to UINT32 may cause INSERT/UPDATE failures on some databases
1301         DBBind(hStmt, pos, sqlType, DB_CTYPE_INT32, &value, DB_BIND_TRANSIENT);
1302 }
1303
1304 /**
1305  * Bind 64 bit integer parameter
1306  */
1307 void LIBNXDB_EXPORTABLE DBBind(DB_STATEMENT hStmt, int pos, int sqlType, INT64 value)
1308 {
1309         DBBind(hStmt, pos, sqlType, DB_CTYPE_INT64, &value, DB_BIND_TRANSIENT);
1310 }
1311
1312 /**
1313  * Bind 64 bit unsigned integer parameter
1314  */
1315 void LIBNXDB_EXPORTABLE DBBind(DB_STATEMENT hStmt, int pos, int sqlType, UINT64 value)
1316 {
1317         DBBind(hStmt, pos, sqlType, DB_CTYPE_UINT64, &value, DB_BIND_TRANSIENT);
1318 }
1319
1320 /**
1321  * Bind floating point parameter
1322  */
1323 void LIBNXDB_EXPORTABLE DBBind(DB_STATEMENT hStmt, int pos, int sqlType, double value)
1324 {
1325         DBBind(hStmt, pos, sqlType, DB_CTYPE_DOUBLE, &value, DB_BIND_TRANSIENT);
1326 }
1327
1328 /**
1329  * Bind UUID parameter
1330  */
1331 void LIBNXDB_EXPORTABLE DBBind(DB_STATEMENT hStmt, int pos, int sqlType, const uuid& value)
1332 {
1333    TCHAR buffer[64];
1334    DBBind(hStmt, pos, sqlType, DB_CTYPE_STRING, value.toString(buffer), DB_BIND_TRANSIENT);
1335 }
1336
1337 /**
1338  * Execute prepared statement (non-SELECT)
1339  */
1340 bool LIBNXDB_EXPORTABLE DBExecuteEx(DB_STATEMENT hStmt, TCHAR *errorText)
1341 {
1342    if (!IS_VALID_STATEMENT_HANDLE(hStmt))
1343    {
1344       _tcscpy(errorText, _T("Invalid statement handle"));
1345       return false;
1346    }
1347
1348 #ifdef UNICODE
1349 #define wcErrorText errorText
1350 #else
1351         WCHAR wcErrorText[DBDRV_MAX_ERROR_TEXT] = L"";
1352 #endif
1353
1354         DB_HANDLE hConn = hStmt->m_connection;
1355         MutexLock(hConn->m_mutexTransLock);
1356    UINT64 ms = GetCurrentTimeMs();
1357
1358    s_perfNonSelectQueries++;
1359    s_perfTotalQueries++;
1360
1361         DWORD dwResult = hConn->m_driver->m_fpDrvExecute(hConn->m_connection, hStmt->m_statement, wcErrorText);
1362    ms = GetCurrentTimeMs() - ms;
1363    if (hConn->m_driver->m_dumpSql)
1364    {
1365       nxlog_debug(9, _T("%s prepared sync query: \"%s\" [%d ms]"), (dwResult == DBERR_SUCCESS) ? _T("Successful") : _T("Failed"), hStmt->m_query, (int)ms);
1366    }
1367    if ((dwResult == DBERR_SUCCESS) && ((UINT32)ms > g_sqlQueryExecTimeThreshold))
1368    {
1369       nxlog_debug(3, _T("Long running query: \"%s\" [%d ms]"), hStmt->m_query, (int)ms);
1370       s_perfLongRunningQueries++;
1371    }
1372
1373    // Do reconnect if needed, but don't retry statement execution
1374    // because it will fail anyway
1375    if ((dwResult == DBERR_CONNECTION_LOST) && hConn->m_reconnectEnabled)
1376    {
1377       DBReconnect(hConn);
1378    }
1379
1380    MutexUnlock(hConn->m_mutexTransLock);
1381
1382 #ifndef UNICODE
1383         WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK | WC_DEFAULTCHAR, wcErrorText, -1, errorText, DBDRV_MAX_ERROR_TEXT, NULL, NULL);
1384         errorText[DBDRV_MAX_ERROR_TEXT - 1] = 0;
1385 #endif
1386
1387    if (dwResult != DBERR_SUCCESS)
1388         {
1389                 if (hConn->m_driver->m_logSqlErrors)
1390                         nxlog_write(g_sqlErrorMsgCode, EVENTLOG_ERROR_TYPE, "ss", hStmt->m_query, errorText);
1391                 if (hConn->m_driver->m_fpEventHandler != NULL)
1392                 {
1393 #ifdef UNICODE
1394                         hConn->m_driver->m_fpEventHandler(DBEVENT_QUERY_FAILED, hStmt->m_query, wcErrorText, dwResult == DBERR_CONNECTION_LOST, hConn->m_driver->m_userArg);
1395 #else
1396                         WCHAR *query = WideStringFromMBString(hStmt->m_query);
1397                         hConn->m_driver->m_fpEventHandler(DBEVENT_QUERY_FAILED, query, wcErrorText, dwResult == DBERR_CONNECTION_LOST, hConn->m_driver->m_userArg);
1398                         free(query);
1399 #endif
1400                 }
1401                 s_perfFailedQueries++;
1402         }
1403
1404    return dwResult == DBERR_SUCCESS;
1405 #undef wcErrorText
1406 }
1407
1408 /**
1409  * Execute prepared statement (non-SELECT)
1410  */
1411 bool LIBNXDB_EXPORTABLE DBExecute(DB_STATEMENT hStmt)
1412 {
1413         TCHAR errorText[DBDRV_MAX_ERROR_TEXT];
1414         return DBExecuteEx(hStmt, errorText);
1415 }
1416
1417 /**
1418  * Execute prepared SELECT statement
1419  */
1420 DB_RESULT LIBNXDB_EXPORTABLE DBSelectPreparedEx(DB_STATEMENT hStmt, TCHAR *errorText)
1421 {
1422    if (!IS_VALID_STATEMENT_HANDLE(hStmt))
1423    {
1424       _tcscpy(errorText, _T("Invalid statement handle"));
1425       return NULL;
1426    }
1427
1428         DB_RESULT result = NULL;
1429 #ifdef UNICODE
1430 #define wcErrorText errorText
1431 #else
1432         WCHAR wcErrorText[DBDRV_MAX_ERROR_TEXT] = L"";
1433 #endif
1434
1435         DB_HANDLE hConn = hStmt->m_connection;
1436    MutexLock(hConn->m_mutexTransLock);
1437
1438    s_perfSelectQueries++;
1439    s_perfTotalQueries++;
1440
1441    INT64 ms = GetCurrentTimeMs();
1442    DWORD dwError = DBERR_OTHER_ERROR;
1443         DBDRV_RESULT hResult = hConn->m_driver->m_fpDrvSelectPrepared(hConn->m_connection, hStmt->m_statement, &dwError, wcErrorText);
1444
1445    ms = GetCurrentTimeMs() - ms;
1446    if (hConn->m_driver->m_dumpSql)
1447    {
1448       nxlog_debug(9, _T("%s prepared sync query: \"%s\" [%d ms]"),
1449                               (hResult != NULL) ? _T("Successful") : _T("Failed"), hStmt->m_query, (int)ms);
1450    }
1451    if ((hResult != NULL) && ((UINT32)ms > g_sqlQueryExecTimeThreshold))
1452    {
1453       nxlog_debug(3, _T("Long running query: \"%s\" [%d ms]"), hStmt->m_query, (int)ms);
1454       s_perfLongRunningQueries++;
1455    }
1456
1457    // Do reconnect if needed, but don't retry statement execution
1458    // because it will fail anyway
1459    if ((hResult == NULL) && (dwError == DBERR_CONNECTION_LOST) && hConn->m_reconnectEnabled)
1460    {
1461       DBReconnect(hConn);
1462    }
1463
1464    MutexUnlock(hConn->m_mutexTransLock);
1465
1466 #ifndef UNICODE
1467         WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK | WC_DEFAULTCHAR, wcErrorText, -1, errorText, DBDRV_MAX_ERROR_TEXT, NULL, NULL);
1468         errorText[DBDRV_MAX_ERROR_TEXT - 1] = 0;
1469 #endif
1470
1471         if (hResult == NULL)
1472         {
1473                 if (hConn->m_driver->m_logSqlErrors)
1474                         nxlog_write(g_sqlErrorMsgCode, EVENTLOG_ERROR_TYPE, "ss", hStmt->m_query, errorText);
1475                 if (hConn->m_driver->m_fpEventHandler != NULL)
1476                 {
1477 #ifdef UNICODE
1478                         hConn->m_driver->m_fpEventHandler(DBEVENT_QUERY_FAILED, hStmt->m_query, wcErrorText, dwError == DBERR_CONNECTION_LOST, hConn->m_driver->m_userArg);
1479 #else
1480                         WCHAR *query = WideStringFromMBString(hStmt->m_query);
1481                         hConn->m_driver->m_fpEventHandler(DBEVENT_QUERY_FAILED, query, wcErrorText, dwError == DBERR_CONNECTION_LOST, hConn->m_driver->m_userArg);
1482                         free(query);
1483 #endif
1484                 }
1485                 s_perfFailedQueries++;
1486         }
1487
1488         if (hResult != NULL)
1489         {
1490                 result = (DB_RESULT)malloc(sizeof(db_result_t));
1491                 result->m_driver = hConn->m_driver;
1492                 result->m_connection = hConn;
1493                 result->m_data = hResult;
1494         }
1495
1496    return result;
1497 #undef wcErrorText
1498 }
1499
1500 /**
1501  * Execute prepared SELECT statement
1502  */
1503 DB_RESULT LIBNXDB_EXPORTABLE DBSelectPrepared(DB_STATEMENT hStmt)
1504 {
1505         TCHAR errorText[DBDRV_MAX_ERROR_TEXT];
1506         return DBSelectPreparedEx(hStmt, errorText);
1507 }
1508
1509 /**
1510  * Execute prepared SELECT statement without caching results
1511  */
1512 DB_UNBUFFERED_RESULT LIBNXDB_EXPORTABLE DBSelectPreparedUnbufferedEx(DB_STATEMENT hStmt, TCHAR *errorText)
1513 {
1514    if (!IS_VALID_STATEMENT_HANDLE(hStmt))
1515    {
1516       _tcscpy(errorText, _T("Invalid statement handle"));
1517       return NULL;
1518    }
1519
1520    DB_UNBUFFERED_RESULT result = NULL;
1521 #ifdef UNICODE
1522 #define wcErrorText errorText
1523 #else
1524    WCHAR wcErrorText[DBDRV_MAX_ERROR_TEXT] = L"";
1525 #endif
1526
1527    DB_HANDLE hConn = hStmt->m_connection;
1528    MutexLock(hConn->m_mutexTransLock);
1529
1530    s_perfSelectQueries++;
1531    s_perfTotalQueries++;
1532
1533    INT64 ms = GetCurrentTimeMs();
1534    DWORD dwError = DBERR_OTHER_ERROR;
1535    DBDRV_UNBUFFERED_RESULT hResult = hConn->m_driver->m_fpDrvSelectPreparedUnbuffered(hConn->m_connection, hStmt->m_statement, &dwError, wcErrorText);
1536
1537    ms = GetCurrentTimeMs() - ms;
1538    if (hConn->m_driver->m_dumpSql)
1539    {
1540       nxlog_debug(9, _T("%s prepared sync query: \"%s\" [%d ms]"),
1541                     (hResult != NULL) ? _T("Successful") : _T("Failed"), hStmt->m_query, (int)ms);
1542    }
1543    if ((hResult != NULL) && ((UINT32)ms > g_sqlQueryExecTimeThreshold))
1544    {
1545       nxlog_debug(3, _T("Long running query: \"%s\" [%d ms]"), hStmt->m_query, (int)ms);
1546       s_perfLongRunningQueries++;
1547    }
1548
1549    // Do reconnect if needed, but don't retry statement execution
1550    // because it will fail anyway
1551    if ((hResult == NULL) && (dwError == DBERR_CONNECTION_LOST) && hConn->m_reconnectEnabled)
1552    {
1553       DBReconnect(hConn);
1554    }
1555
1556 #ifndef UNICODE
1557    WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK | WC_DEFAULTCHAR, wcErrorText, -1, errorText, DBDRV_MAX_ERROR_TEXT, NULL, NULL);
1558    errorText[DBDRV_MAX_ERROR_TEXT - 1] = 0;
1559 #endif
1560
1561    if (hResult == NULL)
1562    {
1563       MutexUnlock(hConn->m_mutexTransLock);
1564
1565       if (hConn->m_driver->m_logSqlErrors)
1566          nxlog_write(g_sqlErrorMsgCode, EVENTLOG_ERROR_TYPE, "ss", hStmt->m_query, errorText);
1567       if (hConn->m_driver->m_fpEventHandler != NULL)
1568       {
1569 #ifdef UNICODE
1570          hConn->m_driver->m_fpEventHandler(DBEVENT_QUERY_FAILED, hStmt->m_query, wcErrorText, dwError == DBERR_CONNECTION_LOST, hConn->m_driver->m_userArg);
1571 #else
1572          WCHAR *query = WideStringFromMBString(hStmt->m_query);
1573          hConn->m_driver->m_fpEventHandler(DBEVENT_QUERY_FAILED, query, wcErrorText, dwError == DBERR_CONNECTION_LOST, hConn->m_driver->m_userArg);
1574          free(query);
1575 #endif
1576       }
1577       s_perfFailedQueries++;
1578    }
1579
1580    if (hResult != NULL)
1581    {
1582       result = (DB_UNBUFFERED_RESULT)malloc(sizeof(db_unbuffered_result_t));
1583       result->m_driver = hConn->m_driver;
1584       result->m_connection = hConn;
1585       result->m_data = hResult;
1586    }
1587
1588    return result;
1589 #undef wcErrorText
1590 }
1591
1592 /**
1593  * Execute prepared SELECT statement
1594  */
1595 DB_UNBUFFERED_RESULT LIBNXDB_EXPORTABLE DBSelectPreparedUnbuffered(DB_STATEMENT hStmt)
1596 {
1597    TCHAR errorText[DBDRV_MAX_ERROR_TEXT];
1598    return DBSelectPreparedUnbufferedEx(hStmt, errorText);
1599 }
1600
1601 /**
1602  * Begin transaction
1603  */
1604 bool LIBNXDB_EXPORTABLE DBBegin(DB_HANDLE hConn)
1605 {
1606    DWORD dwResult;
1607    bool bRet = false;
1608
1609    MutexLock(hConn->m_mutexTransLock);
1610    if (hConn->m_transactionLevel == 0)
1611    {
1612       dwResult = hConn->m_driver->m_fpDrvBegin(hConn->m_connection);
1613       if ((dwResult == DBERR_CONNECTION_LOST) && hConn->m_reconnectEnabled)
1614       {
1615          DBReconnect(hConn);
1616          dwResult = hConn->m_driver->m_fpDrvBegin(hConn->m_connection);
1617       }
1618       if (dwResult == DBERR_SUCCESS)
1619       {
1620          hConn->m_transactionLevel++;
1621          bRet = true;
1622                         nxlog_debug(9, _T("BEGIN TRANSACTION successful (level %d)"), hConn->m_transactionLevel);
1623       }
1624       else
1625       {
1626          MutexUnlock(hConn->m_mutexTransLock);
1627                         nxlog_debug(9, _T("BEGIN TRANSACTION failed"), hConn->m_transactionLevel);
1628       }
1629    }
1630    else
1631    {
1632       hConn->m_transactionLevel++;
1633       bRet = true;
1634                 nxlog_debug(9, _T("BEGIN TRANSACTION successful (level %d)"), hConn->m_transactionLevel);
1635    }
1636    return bRet;
1637 }
1638
1639 /**
1640  * Commit transaction
1641  */
1642 bool LIBNXDB_EXPORTABLE DBCommit(DB_HANDLE hConn)
1643 {
1644    bool bRet = false;
1645
1646    MutexLock(hConn->m_mutexTransLock);
1647    if (hConn->m_transactionLevel > 0)
1648    {
1649       hConn->m_transactionLevel--;
1650       if (hConn->m_transactionLevel == 0)
1651          bRet = (hConn->m_driver->m_fpDrvCommit(hConn->m_connection) == DBERR_SUCCESS);
1652       else
1653          bRet = true;
1654                 nxlog_debug(9, _T("COMMIT TRANSACTION %s (level %d)"), bRet ? _T("successful") : _T("failed"), hConn->m_transactionLevel);
1655       MutexUnlock(hConn->m_mutexTransLock);
1656    }
1657    MutexUnlock(hConn->m_mutexTransLock);
1658    return bRet;
1659 }
1660
1661 /**
1662  * Rollback transaction
1663  */
1664 bool LIBNXDB_EXPORTABLE DBRollback(DB_HANDLE hConn)
1665 {
1666    bool bRet = false;
1667
1668    MutexLock(hConn->m_mutexTransLock);
1669    if (hConn->m_transactionLevel > 0)
1670    {
1671       hConn->m_transactionLevel--;
1672       if (hConn->m_transactionLevel == 0)
1673          bRet = (hConn->m_driver->m_fpDrvRollback(hConn->m_connection) == DBERR_SUCCESS);
1674       else
1675          bRet = true;
1676                 nxlog_debug(9, _T("ROLLBACK TRANSACTION %s (level %d)"), bRet ? _T("successful") : _T("failed"), hConn->m_transactionLevel);
1677       MutexUnlock(hConn->m_mutexTransLock);
1678    }
1679    MutexUnlock(hConn->m_mutexTransLock);
1680    return bRet;
1681 }
1682
1683 /**
1684  * Prepare string for using in SQL statement
1685  */
1686 String LIBNXDB_EXPORTABLE DBPrepareString(DB_HANDLE conn, const TCHAR *str, int maxSize)
1687 {
1688    return DBPrepareString(conn->m_driver, str, maxSize);
1689 }
1690
1691 /**
1692  * Prepare string for using in SQL statement
1693  */
1694 String LIBNXDB_EXPORTABLE DBPrepareString(DB_DRIVER drv, const TCHAR *str, int maxSize)
1695 {
1696         String out;
1697         if ((maxSize > 0) && (str != NULL) && (maxSize < (int)_tcslen(str)))
1698         {
1699                 TCHAR *temp = (TCHAR *)malloc((maxSize + 1) * sizeof(TCHAR));
1700                 nx_strncpy(temp, str, maxSize + 1);
1701 #ifdef UNICODE
1702                 out.setBuffer(drv->m_fpDrvPrepareStringW(temp));
1703 #else
1704                 out.setBuffer(drv->m_fpDrvPrepareStringA(temp));
1705 #endif
1706                 free(temp);
1707         }
1708         else
1709         {
1710 #ifdef UNICODE
1711                 out.setBuffer(drv->m_fpDrvPrepareStringW(CHECK_NULL_EX(str)));
1712 #else
1713                 out.setBuffer(drv->m_fpDrvPrepareStringA(CHECK_NULL_EX(str)));
1714 #endif
1715         }
1716         return out;
1717 }
1718
1719 /**
1720  * Prepare string for using in SQL statement (multi-byte string version)
1721  */
1722 #ifdef UNICODE
1723
1724 String LIBNXDB_EXPORTABLE DBPrepareStringA(DB_HANDLE conn, const char *str, int maxSize)
1725 {
1726         WCHAR *wcs = WideStringFromMBString(str);
1727         String s = DBPrepareString(conn, wcs, maxSize);
1728         free(wcs);
1729         return s;
1730 }
1731
1732 String LIBNXDB_EXPORTABLE DBPrepareStringA(DB_DRIVER drv, const char *str, int maxSize)
1733 {
1734    WCHAR *wcs = WideStringFromMBString(str);
1735    String s = DBPrepareString(drv, wcs, maxSize);
1736    free(wcs);
1737    return s;
1738 }
1739
1740 #endif
1741
1742 /**
1743  * Check if given table exist
1744  */
1745 int LIBNXDB_EXPORTABLE DBIsTableExist(DB_HANDLE conn, const TCHAR *table)
1746 {
1747 #ifdef UNICODE
1748    return conn->m_driver->m_fpDrvIsTableExist(conn->m_connection, table);
1749 #else
1750    WCHAR wname[256];
1751    MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, table, -1, wname, 256);
1752    return conn->m_driver->m_fpDrvIsTableExist(conn->m_connection, wname);
1753 #endif
1754 }
1755
1756 /**
1757  * Get performance counters
1758  */
1759 void LIBNXDB_EXPORTABLE DBGetPerfCounters(LIBNXDB_PERF_COUNTERS *counters)
1760 {
1761    counters->failedQueries = s_perfFailedQueries;
1762    counters->longRunningQueries = s_perfLongRunningQueries;
1763    counters->nonSelectQueries = s_perfNonSelectQueries;
1764    counters->selectQueries = s_perfSelectQueries;
1765    counters->totalQueries = s_perfTotalQueries;
1766 }