src/platform/Tizen/Messaging/messageDB/MsgSqliteWrapper.cpp

   1 /*
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include <stdio.h>
  18 #include <stddef.h>
  19 #include <unistd.h>
  20 #include <string.h>
  21 #include <stdlib.h>
  22
  23 #include <dpl/log.h>
  24 //#include "MsgDebug.h"
  25 #include "MsgSqliteWrapper.h"
  26
  27
  28 #if 1
  29 __thread sqlite3 *handle = NULL;
  30 __thread sqlite3_stmt *stmt = NULL;
  31 __thread char **result = NULL;
  32 #endif
  33
  34 /*==================================================================================================
  35                                      IMPLEMENTATION OF MsgDbHandler - Member Functions
  36 ==================================================================================================*/
  37 MsgDbHandler::MsgDbHandler()
  38 {
  39         handle = NULL;
  40         stmt = NULL;
  41         result = NULL;
  42 }
  43
  44
  45 MsgDbHandler::~MsgDbHandler()
  46 {
  47         if(handle != NULL)
  48                 disconnect();
  49
  50         if(stmt != NULL)
  51                 finalizeQuery();
  52
  53         if(result != NULL)
  54                 freeTable();
  55 }
  56
  57
  58 MSG_ERROR_T MsgDbHandler::connect()
  59 {
  60         int ret = 0;
  61
  62         if (handle == NULL)
  63         {
  64                 char strDBName[64];
  65
  66                 memset(strDBName, 0x00, sizeof(strDBName));
  67                 snprintf(strDBName, 64, "%s", MSGFW_DB_NAME);
  68
  69                 ret = db_util_open(strDBName, &handle, DB_UTIL_REGISTER_HOOK_METHOD);
  70
  71                 if (ret == SQLITE_OK)
  72                 {
  73                         LogDebug("DB Connect Success : [" << handle << "]");
  74                         return MSG_SUCCESS;
  75                 }
  76                 else
  77                 {
  78                         LogDebug("DB Connect Fail [" << ret << "]");
  79                         return MSG_ERR_DB_CONNECT;
  80                 }
  81         }
  82         else
  83         {
  84                 LogDebug("DB Connect exist : [" << handle << "]");
  85         }
  86
  87         return MSG_SUCCESS;
  88 }
  89
  90
  91 MSG_ERROR_T MsgDbHandler::disconnect()
  92 {
  93         int ret = 0;
  94
  95         if (handle != NULL)
  96         {
  97                 ret = db_util_close(handle);
  98
  99                 if (ret == SQLITE_OK)
 100                 {
 101                         handle = NULL;
 102                         LogDebug("DB Disconnect Success");
 103                         return MSG_SUCCESS;
 104                 }
 105                 else
 106                 {
 107                         LogDebug("DB Disconnect Fail [" << ret << "]");
 108                         return MSG_ERR_DB_DISCONNECT;
 109                 }
 110         }
 111
 112         return MSG_SUCCESS;
 113 }
 114
 115
 116 bool MsgDbHandler::checkTableExist(const char *pTableName)
 117 {
 118         char strQuery[256];
 119         int nRowCnt = 0, nResult = 0;
 120
 121         /* Formulate the Query */
 122         memset(strQuery, 0x00, sizeof(strQuery));
 123         snprintf(strQuery, sizeof(strQuery), "select count(name) from sqlite_master where name='%s'", pTableName);
 124
 125         if (getTable(strQuery, &nRowCnt) != MSG_SUCCESS)
 126         {
 127                 freeTable();
 128                 return false;
 129         }
 130
 131         nResult = getColumnToInt(1);
 132         LogDebug("Result [" << nResult << "]");
 133
 134         freeTable();
 135
 136         if (nResult > 0)
 137                 return true;
 138         else
 139                 return false;
 140 }
 141
 142
 143 MSG_ERROR_T MsgDbHandler::execQuery(const char *pQuery)
 144 {
 145         int ret = 0;
 146
 147         if (!pQuery)
 148                 return MSG_ERR_INVALID_PARAMETER;
 149
 150         if(connect() != MSG_SUCCESS)
 151                 return MSG_ERR_DB_DISCONNECT;
 152
 153         ret = sqlite3_exec(handle, pQuery, 0, 0, NULL);
 154
 155         if (ret == SQLITE_OK)
 156         {
 157                 LogDebug("Execute Query Success");
 158                 return MSG_SUCCESS;
 159         }
 160         else
 161         {
 162                 LogDebug("Execute Query Fail [" << ret << "]");
 163
 164                 return MSG_ERR_DB_EXEC;
 165         }
 166
 167         return MSG_SUCCESS;
 168 }
 169
 170
 171 MSG_ERROR_T MsgDbHandler::getTable(const char *pQuery, int *pRowCnt)
 172 {
 173         int ret = 0;
 174
 175         *pRowCnt = 0;
 176
 177         if(connect() != MSG_SUCCESS)
 178                 return MSG_ERR_DB_DISCONNECT;
 179
 180
 181         ret = sqlite3_get_table(handle, pQuery, &result, pRowCnt, 0, NULL);
 182
 183         if (ret == SQLITE_OK)
 184         {
 185                 if (*pRowCnt == 0)    // when the no record return 'MSG_ERR_DB_NORECORD'
 186                 {
 187                         LogDebug("No Query Result");
 188                         return MSG_ERR_DB_NORECORD;
 189                 }
 190
 191                 LogDebug("Get Table Success");
 192                 return MSG_SUCCESS;
 193         }
 194         else
 195         {
 196                 LogDebug("Get Table Fail [" << ret << "]");
 197                 return MSG_ERR_DB_GETTABLE;
 198         }
 199
 200         return MSG_SUCCESS;
 201 }
 202
 203
 204 void MsgDbHandler::freeTable()
 205 {
 206         if (result)
 207         {
 208                 sqlite3_free_table(result);
 209                 result = NULL;
 210         }
 211 }
 212
 213
 214 MSG_ERROR_T MsgDbHandler::bindText(const char *pBindStr, int index)
 215 {
 216         int ret = 0;
 217
 218         if (pBindStr != NULL)
 219                 ret = sqlite3_bind_text(stmt, index, pBindStr, (strlen(pBindStr) + sizeof(unsigned char)), SQLITE_STATIC);
 220
 221         return ret;
 222 }
 223
 224
 225 MSG_ERROR_T MsgDbHandler::bindBlob(const void * pBindBlob, int size, int index)
 226 {
 227         int ret = 0;
 228
 229         ret = sqlite3_bind_blob(stmt, index, pBindBlob, size, SQLITE_STATIC);
 230
 231         return ret;
 232 }
 233
 234
 235 MSG_ERROR_T MsgDbHandler::prepareQuery(const char *pQuery)
 236 {
 237         int ret = 0;
 238
 239         stmt = NULL;
 240
 241         if(connect() != MSG_SUCCESS)
 242                 return MSG_ERR_DB_DISCONNECT;
 243
 244
 245         if ((ret = sqlite3_prepare_v2(handle, pQuery, strlen(pQuery), &stmt, NULL)) == SQLITE_OK)
 246         {
 247                 LogDebug("Prepare Query Success");
 248                 return MSG_SUCCESS;
 249         }
 250         else
 251         {
 252                 LogDebug("Prepare Query Fail [" << ret << "]");
 253                 return MSG_ERR_DB_PREPARE;
 254         }
 255
 256         return MSG_SUCCESS;
 257 }
 258
 259
 260 MSG_ERROR_T MsgDbHandler::stepQuery()
 261 {
 262         int ret = 0;
 263
 264         ret = sqlite3_step(stmt);
 265
 266         if (ret == SQLITE_ROW)
 267         {
 268                 LogDebug("MsgStepQuery() SQLITE_ROW");
 269                 return MSG_ERR_DB_ROW;
 270         }
 271         else if (ret == SQLITE_DONE)
 272         {
 273                 LogDebug("MsgStepQuery() SQLITE_DONE");
 274                 return MSG_ERR_DB_DONE;
 275         }
 276         else
 277         {
 278                 LogDebug("MsgStepQuery() Fail [" << ret << "]");
 279                 return MSG_ERR_DB_STEP;
 280         }
 281
 282         return MSG_SUCCESS;
 283 }
 284
 285
 286 void MsgDbHandler::finalizeQuery()
 287 {
 288         if(stmt != NULL)
 289                 sqlite3_finalize(stmt);
 290         stmt = NULL;
 291 }
 292
 293
 294 int MsgDbHandler::columnInt(int ColumnIndex)
 295 {
 296         return sqlite3_column_int(stmt, ColumnIndex);
 297 }
 298
 299
 300 const unsigned char* MsgDbHandler::columnText(int ColumnIndex)
 301 {
 302         return sqlite3_column_text(stmt, ColumnIndex);
 303 }
 304
 305
 306 const void* MsgDbHandler::columnBlob(int ColumnIndex)
 307 {
 308         return sqlite3_column_blob(stmt, ColumnIndex);
 309 }
 310
 311
 312 MSG_ERROR_T MsgDbHandler::beginTrans()
 313 {
 314         int ret = 0;
 315
 316         if(connect() != MSG_SUCCESS)
 317                 return MSG_ERR_DB_DISCONNECT;
 318
 319
 320         ret = sqlite3_exec(handle, "BEGIN deferred;", 0, 0, NULL);
 321
 322         if (ret == SQLITE_OK)
 323         {
 324                 LogDebug("Begin Transaction Success");
 325                 return MSG_SUCCESS;
 326         }
 327         else
 328         {
 329                 LogDebug("Begin Transaction Fail [" << ret << "]");
 330                 return MSG_ERR_DB_EXEC;
 331         }
 332
 333         return MSG_SUCCESS;
 334 }
 335
 336
 337 MSG_ERROR_T MsgDbHandler::endTrans(bool Success)
 338 {
 339         int ret = 0;
 340
 341         if(connect() != MSG_SUCCESS)
 342                 return MSG_ERR_DB_DISCONNECT;
 343
 344
 345         if (Success == true)
 346         {
 347                 ret = sqlite3_exec(handle, "END;", 0, 0, NULL);
 348         }
 349         else
 350         {
 351                 ret = sqlite3_exec(handle, "rollback", 0, 0, NULL);
 352                 ret = sqlite3_exec(handle, "END;", 0, 0, NULL);
 353         }
 354
 355         if (ret == SQLITE_OK)
 356         {
 357                 LogDebug("End Transaction Success");
 358                 return MSG_SUCCESS;
 359         }
 360         else
 361         {
 362                 LogDebug("End Transaction Fail [" << ret << "]");
 363                 return MSG_ERR_DB_EXEC;
 364         }
 365
 366         return MSG_SUCCESS;
 367 }
 368
 369
 370 int MsgDbHandler::getColumnToInt(int RowIndex)
 371 {
 372         char* pTemp = result[RowIndex];
 373
 374         int nTemp = 0;
 375
 376         if (pTemp == NULL)
 377         {
 378                 LogDebug("NULL");
 379                 return nTemp;
 380         }
 381
 382         nTemp = (int)strtol(pTemp, (char**)NULL, 10);
 383
 384 //      nTemp = atoi(pTemp);
 385
 386         return nTemp;
 387 }
 388
 389
 390 char MsgDbHandler::getColumnToChar(int RowIndex)
 391 {
 392         char* pTemp = result[RowIndex];
 393
 394         if (pTemp == NULL)
 395         {
 396                 LogDebug("NULL");
 397                 return *pTemp;
 398         }
 399
 400         return *pTemp;
 401 }
 402
 403
 404 void MsgDbHandler::getColumnToString(int RowIndex, int Length, char *pString)
 405 {
 406         char* pTemp = result[RowIndex];
 407
 408         if (pTemp == NULL)
 409         {
 410                 LogDebug("NULL");
 411                 return;
 412         }
 413
 414         strncpy(pString, pTemp, Length);
 415 }
 416
 417
 418 MSG_ERROR_T MsgDbHandler::getRowId(const char *pTableName, unsigned int *pRowId)
 419 {
 420         int ret = 0, nRowId = 0, nRowCnt = 0;
 421         char strQuery[256];
 422
 423         if (pTableName == NULL || pRowId == NULL)
 424                 return MSG_ERR_INVALID_PARAMETER;
 425
 426         LogDebug("Table Name [" << pTableName << "]");
 427
 428         memset(strQuery, 0x00, sizeof(strQuery));
 429         snprintf(strQuery, sizeof(strQuery), "select max(rowid) from %s", pTableName);
 430
 431         ret = getTable(strQuery, &nRowCnt);
 432
 433         if (ret == SQLITE_OK)
 434         {
 435                 nRowId = getColumnToInt(1);
 436
 437                 if ((nRowCnt <= 1) && (nRowId == 0))
 438                         *pRowId = 1;
 439                 else
 440                         *pRowId = nRowId + 1;
 441         }
 442         else
 443         {
 444                 LogDebug("MsgGetRowId failed");
 445                 *pRowId = 0;
 446                 freeTable();
 447                 return MSG_ERR_DB_GETTABLE;
 448         }
 449
 450         freeTable();
 451
 452         LogDebug("Row ID [" << *pRowId << "]");
 453
 454         return MSG_SUCCESS;
 455 }
 456
 457
 458 /*==================================================================================================
 459                                      FUNCTION IMPLEMENTATION
 460 ==================================================================================================*/
 461 #if 0
 462 MSG_ERROR_T MsgConnectDB()
 463 {
 464         int ret = 0;
 465
 466         char strDBName[64];
 467
 468         memset(strDBName, 0x00, sizeof(strDBName));
 469         snprintf(strDBName, 64, "%s", MSGFW_DB_NAME);
 470
 471         if (gDBHandle == NULL)
 472         {
 473
 474 #ifdef INCLUDE_SQLITE3
 475                 ret = sqlite3_open(strDBName, &gDBHandle);
 476 #else
 477                 ret = db_util_open(strDBName, &gDBHandle, DB_UTIL_REGISTER_HOOK_METHOD);
 478 #endif
 479
 480                 if (ret == SQLITE_OK)
 481                 {
 482                         LogDebug("DB Connect Success");
 483                         return MSG_SUCCESS;
 484                 }
 485                 else
 486                 {
 487                         LogDebug("DB Connect Fail [" << ret "]");
 488                         return MSG_ERR_DB_CONNECT;
 489                 }
 490         }
 491
 492         return MSG_SUCCESS;
 493 }
 494
 495
 496 MSG_ERROR_T MsgDisconnectDB()
 497 {
 498         int ret = 0;
 499
 500         if (gDBHandle != NULL)
 501         {
 502
 503 #ifdef INCLUDE_SQLITE3
 504                 ret = sqlite3_close(gDBHandle);
 505 #else
 506                 ret = db_util_close(gDBHandle);
 507 #endif
 508
 509                 if (ret == SQLITE_OK)
 510                 {
 511                         gDBHandle = NULL;
 512                         LogDebug("DB Disconnect Success");
 513                         return MSG_SUCCESS;
 514                 }
 515                 else
 516                 {
 517                         LogDebug("DB Disconnect Fail [" << ret << "]");
 518                         return MSG_ERR_DB_DISCONNECT;
 519                 }
 520         }
 521
 522         return MSG_SUCCESS;
 523 }
 524
 525
 526 bool MsgIsTableExist(const char *pTableName)
 527 {
 528         char strQuery[256];
 529         int nRowCnt = 0, nResult = 0;
 530
 531         /* Formulate the Query */
 532         memset(strQuery, 0x00, sizeof(strQuery));
 533         snprintf(strQuery, sizeof(strQuery), "select count(name) from sqlite_master where name='%s'", pTableName);
 534
 535         if (MsgGetTable(strQuery, &nRowCnt) != MSG_SUCCESS)
 536         {
 537                 MsgFreeTable();
 538                 return false;
 539         }
 540
 541         nResult = MsgGetColumnToInt(1);
 542         LogDebug("Result [" << nResult << "]");
 543
 544         MsgFreeTable();
 545
 546         if (nResult > 0)
 547                 return true;
 548         else
 549                 return false;
 550 }
 551
 552
 553 MSG_ERROR_T MsgExecQuery(const char *pQuery)
 554 {
 555         int ret = 0;
 556
 557         if (!pQuery)
 558                 return MSG_ERR_INVALID_PARAMETER;
 559
 560         ret = sqlite3_exec(gDBHandle, pQuery, 0, 0, NULL);
 561
 562         if (ret == SQLITE_OK)
 563         {
 564                 LogDebug("Execute Query Success");
 565                 return MSG_SUCCESS;
 566         }
 567         else
 568         {
 569                 LogDebug("Execute Query Fail [" << ret << "]");
 570                 return MSG_ERR_DB_EXEC;
 571         }
 572
 573         return MSG_SUCCESS;
 574 }
 575
 576
 577 MSG_ERROR_T MsgGetTable(const char *pQuery, int *pRowCnt)
 578 {
 579         int ret = 0;
 580
 581         *pRowCnt = 0;
 582
 583         ret = sqlite3_get_table(gDBHandle, pQuery, &gQueryResult, pRowCnt, 0, NULL);
 584
 585         if (ret == SQLITE_OK)
 586         {
 587                 if (*pRowCnt == 0)    // when the no record return 'MSG_ERR_DB_NORECORD'
 588                 {
 589                         LogDebug("No Query Result");
 590                         return MSG_ERR_DB_NORECORD;
 591                 }
 592
 593                 LogDebug("Get Table Success");
 594                 return MSG_SUCCESS;
 595         }
 596         else
 597         {
 598                 LogDebug("Get Table Fail [" << ret << "]");
 599                 return MSG_ERR_DB_GETTABLE;
 600         }
 601
 602         return MSG_SUCCESS;
 603 }
 604
 605
 606 void MsgFreeTable()
 607 {
 608         if (gQueryResult)
 609         {
 610                 sqlite3_free_table(gQueryResult);
 611                 gQueryResult = NULL;
 612         }
 613 }
 614
 615 /* End of supporting two queries simultaneously*/
 616
 617 MSG_ERROR_T MsgBindText(const char *pBindStr, int index)
 618 {
 619         int ret = 0;
 620
 621         if (pBindStr != NULL)
 622                 ret = sqlite3_bind_text(gStmt, index, pBindStr, (strlen(pBindStr) + sizeof(unsigned char)), SQLITE_STATIC);
 623
 624         return ret;
 625 }
 626
 627
 628 MSG_ERROR_T MsgBindBlob(const void * pBindBlob, int size, int index)
 629 {
 630         int ret = 0;
 631
 632         ret = sqlite3_bind_blob(gStmt, index, pBindBlob, size, SQLITE_STATIC);
 633
 634         return ret;
 635 }
 636
 637
 638 MSG_ERROR_T MsgPrepareQuery(const char *pQuery)
 639 {
 640         int ret = 0;
 641
 642         gStmt = NULL;
 643
 644         if ((ret = sqlite3_prepare_v2(gDBHandle, pQuery, strlen(pQuery), &gStmt, NULL)) == SQLITE_OK)
 645         {
 646                 LogDebug("Prepare Query Success");
 647                 return MSG_SUCCESS;
 648         }
 649         else
 650         {
 651                 LogDebug("Prepare Query Fail [" << ret "]");
 652                 return MSG_ERR_DB_PREPARE;
 653         }
 654
 655         return MSG_SUCCESS;
 656 }
 657
 658
 659 MSG_ERROR_T MsgStepQuery()
 660 {
 661         int ret = 0;
 662
 663         ret = sqlite3_step(gStmt);
 664
 665         if (ret == SQLITE_ROW)
 666         {
 667                 LogDebug("MsgStepQuery() SQLITE_ROW");
 668                 return MSG_ERR_DB_ROW;
 669         }
 670         else if (ret == SQLITE_DONE)
 671         {
 672                 LogDebug("MsgStepQuery() SQLITE_DONE");
 673                 return MSG_ERR_DB_DONE;
 674         }
 675         else
 676         {
 677                 LogDebug("MsgStepQuery() Fail [" << ret << "]");
 678                 return MSG_ERR_DB_STEP;
 679         }
 680
 681         return MSG_SUCCESS;
 682 }
 683
 684
 685 void MsgFinalizeQuery()
 686 {
 687         sqlite3_finalize(gStmt);
 688         gStmt = NULL;
 689 }
 690
 691
 692 int MsgColumnInt(int ColumnIndex)
 693 {
 694         return sqlite3_column_int(gStmt, ColumnIndex);
 695 }
 696
 697
 698 const unsigned char* MsgColumnText(int ColumnIndex)
 699 {
 700         return sqlite3_column_text(gStmt, ColumnIndex);
 701 }
 702
 703
 704 const void* MsgColumnBlob(int ColumnIndex)
 705 {
 706         return sqlite3_column_blob(gStmt, ColumnIndex);
 707 }
 708
 709
 710 MSG_ERROR_T MsgBeginTrans()
 711 {
 712         int ret = 0;
 713
 714         ret = sqlite3_exec(gDBHandle, "BEGIN deferred;", 0, 0, NULL);
 715
 716         if (ret == SQLITE_OK)
 717         {
 718                 LogDebug("Begin Transaction Success");
 719                 return MSG_SUCCESS;
 720         }
 721         else
 722         {
 723                 LogDebug("Begin Transaction Fail [" << ret "]");
 724                 return MSG_ERR_DB_EXEC;
 725         }
 726
 727         return MSG_SUCCESS;
 728 }
 729
 730
 731 MSG_ERROR_T MsgEndTrans(bool Success)
 732 {
 733         int ret = 0;
 734
 735         if (Success == true)
 736         {
 737                 ret = sqlite3_exec(gDBHandle, "END;", 0, 0, NULL);
 738         }
 739         else
 740         {
 741                 ret = sqlite3_exec(gDBHandle, "rollback", 0, 0, NULL);
 742                 ret = sqlite3_exec(gDBHandle, "END;", 0, 0, NULL);
 743         }
 744
 745         if (ret == SQLITE_OK)
 746         {
 747                 LogDebug("End Transaction Success");
 748                 return MSG_SUCCESS;
 749         }
 750         else
 751         {
 752                 LogDebug("End Transaction Fail [" << ret << "]");
 753                 return MSG_ERR_DB_EXEC;
 754         }
 755
 756         return MSG_SUCCESS;
 757 }
 758
 759
 760 int MsgGetColumnToInt(int RowIndex)
 761 {
 762         char* pTemp = gQueryResult[RowIndex];
 763
 764         int nTemp = 0;
 765
 766         if (pTemp == NULL)
 767         {
 768                 LogDebug("NULL");
 769                 return nTemp;
 770         }
 771
 772         nTemp = (int)strtol(pTemp, (char**)NULL, 10);
 773
 774 //      nTemp = atoi(pTemp);
 775
 776         return nTemp;
 777 }
 778
 779
 780 char MsgGetColumnToChar(int RowIndex)
 781 {
 782         char* pTemp = gQueryResult[RowIndex];
 783
 784         if (pTemp == NULL)
 785         {
 786                 LogDebug("NULL");
 787                 return NULL;
 788         }
 789
 790         return *pTemp;
 791 }
 792
 793
 794 void MsgGetColumnToString(int RowIndex, int Length, char *pString)
 795 {
 796         char* pTemp = gQueryResult[RowIndex];
 797
 798         if (pTemp == NULL)
 799         {
 800                 LogDebug("NULL");
 801                 return;
 802         }
 803
 804         strncpy(pString, pTemp, Length);
 805 }
 806
 807
 808 MSG_ERROR_T MsgGetRowId(const char *pTableName, unsigned int *pRowId)
 809 {
 810         int ret = 0, nRowId = 0, nRowCnt = 0;
 811         char strQuery[256];
 812
 813         if (pTableName == NULL || pRowId == NULL)
 814                 return MSG_ERR_INVALID_PARAMETER;
 815
 816         LogDebug("Table Name [" << pTableName << "]");
 817
 818         memset(strQuery, 0x00, sizeof(strQuery));
 819         snprintf(strQuery, sizeof(strQuery), "select max(rowid) from %s", pTableName);
 820
 821         ret = MsgGetTable(strQuery, &nRowCnt);
 822
 823         if (ret == SQLITE_OK)
 824         {
 825                 nRowId = MsgGetColumnToInt(1);
 826
 827                 if ((nRowCnt <= 1) && (nRowId == 0))
 828                         *pRowId = 1;
 829                 else
 830                         *pRowId = nRowId + 1;
 831         }
 832         else
 833         {
 834                 LogDebug("MsgGetRowId failed");
 835                 *pRowId = 0;
 836                 MsgFreeTable();
 837                 return MSG_ERR_DB_GETTABLE;
 838         }
 839
 840         MsgFreeTable();
 841
 842         LogDebug("Row ID [" << *pRowId << "]");
 843
 844         return MSG_SUCCESS;
 845 }
 846 #endif
 847
 848 void MsgReleaseMemoryDB()
 849 {
 850         int freeSize = 0;
 851
 852         freeSize = sqlite3_release_memory(-1);
 853
 854         LogDebug("freed memory size (bytes) : [" << freeSize << "]");
 855 }
 856