@ind-rcg/backend 246.1008.0

package/nativeSrc/common/DBAccess/SimpleDBConnection.cpp

@@ -0,0 +1,800 @@
+#include "SimpleDBConnection.h"
+#include "../stdngm.h"
+#include "../Utils/StringFormat.h"
+#include "../LogAdapter/LogAdapter.h"
+#include "../Utils/miniz/timer.h"
+//#ifdef WINAPI_FAMILY	//WIN_PHONE
+#if defined(WIN32) || defined(WINAPI_FAMILY)
+#include <windows.h>
+#endif
+
+SimpleDBConnection::SimpleDBConnection()
+{
+  m_DB = NULL;  
+}
+
+SimpleDBConnection::~SimpleDBConnection()
+{
+   if (isValid()) close(); 
+}
+
+bool SimpleDBConnection::close()
+{
+ 
+  if (m_DB == NULL) {
+    if (LogAdapter::logConsole()) LogAdapter::Console("Open a database connection first, then pass the request");
+    return false;
+  }
+  int rc;
+  if (SQLITE_OK != (rc = sqlite3_close(m_DB))) {   
+    if (LogAdapter::logConsole()) LogAdapter::Console("Something went wrong. Try closing the database connection again or contact Salesforce Support for help."); 
+    return false;
+  }
+
+  m_DB = NULL;
+  return true;
+}
+
+void SimpleDBConnection::LogError(const char *modulename, const char *classname, const char *methodname, const char *message)
+{
+   std::string msg = modulename;
+    msg = msg + " " + classname;
+    msg = msg + " " + methodname;
+    msg = msg + " " + message;
+    LogAdapter::Console(msg.c_str());
+}
+
+void SimpleDBConnection::LogPerformance(const char * message, double performance)
+{
+  LogAdapter::Console(StringFormat("[%f] %s", performance, message).c_str());
+}
+
+bool SimpleDBConnection::openConnection(const char * sDBFullPath){
+    
+  if (m_DB != NULL) {
+    if (LogAdapter::logConsole()) LogAdapter::Console("The database connection is already open.");
+    return true;
+  }
+  
+    const int CREATE_FLAGS = SQLITE_OPEN_READWRITE | SQLITE_OPEN_FULLMUTEX;
+    m_DB = _concurrent_openConnection(sDBFullPath, CREATE_FLAGS);
+
+    return (m_DB != NULL) ? true : false;
+}
+
+sqlite3* SimpleDBConnection::_concurrent_openConnection(const char * sDBFullPath, const int CREATE_FLAGS){
+  
+  int rc;
+  int n = 0;
+
+  sqlite3 *m_DB = NULL;
+
+  do {
+       rc = sqlite3_open_v2(sDBFullPath, &m_DB, CREATE_FLAGS, NULL);
+
+       if (SQLITE_BUSY == rc) {
+         n++;
+         msleep(SLEEP_LOCK_MS);
+       }
+       else if (SQLITE_OK != rc) {
+         rc = sqlite3_open_v2(sDBFullPath, &m_DB, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX, NULL);
+         
+         if (SQLITE_OK != rc) {
+           std::string msg = "The SQLite library failed to open the database with the ";
+           msg += sqlite3_errmsg(m_DB);
+           msg += " error. For more information about the SQLite error codes, see Result and Error Codes in SQLite documentation.";
+           if (LogAdapter::logConsole()) LogAdapter::Console(msg.c_str());
+           break;
+         }
+         else {
+           if (LogAdapter::logConsole()) LogAdapter::Console("The database connection opened successfully.");
+         }
+       }
+  } while ((n < SLEEP_LOCK_TIMES) && (rc == SQLITE_BUSY));
+
+  if ((SQLITE_OK != rc) || (NULL == m_DB)) {
+    if (LogAdapter::logConsole()) LogAdapter::Console("Failed to open the database connection. You’ve reached the maximum retry attempts to open the database connection. Confirm whether the database file is accessible or that the database is readable. If the issue persists, contact Salesforce Support for help.");
+  }
+
+  return (SQLITE_OK == rc) ? m_DB : NULL;
+}
+
+
+cJSON * SimpleDBConnection::universalParameterizedBatch(cJSON *statements, bool isHESAMode, bool isExecute, bool enableLog /*= true*/)
+{
+  // enableLog is false to avoid the new LogEntry being created when this
+  // API is invoked to inserts the Log into RpsLog Table.
+  sqlite3_stmt* stmt = NULL;
+
+  resetLastError();
+
+  if (!isValid())
+  {
+    handleException("universalParameterizedBatch() invalid call", 0);
+    return (cJSON *)0;
+  }
+
+  timer t;
+
+  if (enableLog)
+  {
+    t.start();
+  }
+
+  std::string check_begin = "BEGIN";
+  std::string check_commit = "COMMIT";
+  std::string check_rollback = "ROLLBACK";
+
+  std::string tx_rollback_reason = "";
+
+  bool req_begin = false;
+  bool req_commit = false;
+  bool req_rollback = false;
+
+  cJSON *statement = (NULL != statements) ? statements->child : NULL;
+  cJSON *result = cJSON_CreateArray();
+
+  while (statement)
+  {
+    int total_changes = sqlite3_total_changes(m_DB);
+
+    //Compatibility with HESA implementation
+    std::string qid_value = "0";
+
+    cJSON *sql = cJSON_GetObjectItem(statement, "sql");
+    
+    //Compatibility with HESA implementation
+    if (NULL == sql) sql = cJSON_GetObjectItem(statement, "query");
+
+    cJSON *params = cJSON_GetObjectItem(statement, "params");
+
+    //Compatibility with HESA implementation
+    if (NULL == params) params = cJSON_GetObjectItem(statement, "parameters");
+
+    //Compatibility with HESA implementation
+    cJSON *qid = cJSON_GetObjectItem(statement, "qid");
+    
+    //Compatibility with HESA implementation
+    if (NULL != qid) qid_value = (const char *)qid->valuestring;
+    
+    const char *sSQL = (const char *)sql->valuestring;
+
+    int param_count = cJSON_GetArraySize(params);
+
+    if ((param_count < 1) && (safe_strlen(sSQL) < 32)) 
+    {
+      std::string command = to_upper(sSQL);
+      
+      //Only start a new transaction of no transaction is running.
+      //Otherwise use the existing transaction and let the caller decide on result what to do.
+      //Note that an outer transaction also enables the the break on first error in the statement preparation.
+      if (starts_with(command, check_begin) && !inTransaction())
+      {
+        if (beginTransaction())
+        {
+          cJSON_AddItemToArray(result, CreateJSONSuccessObject(cJSON_CreateArray(), 0, qid_value.c_str(), isHESAMode, isExecute));
+          statement = statement->next;
+          req_begin = true;
+          req_commit = true;
+          continue;
+        }
+        else
+        {
+          cJSON_AddItemToArray(result, CreateJSONErrorObject("Unable to begin transaction", qid_value.c_str(), isHESAMode, isExecute));
+          break;
+        }
+      }
+      else if (starts_with(command, check_commit) || starts_with(command, check_rollback))
+      {
+        cJSON_AddItemToArray(result, CreateJSONSuccessObject(cJSON_CreateArray(), 0, qid_value.c_str(), isHESAMode, isExecute));
+        statement = statement->next;
+        continue;
+      }
+    } 
+
+    if (LogAdapter::logDebug())
+    {
+       LogAdapter::Console(sSQL);
+    }
+
+    if (!concurrent_prepare(&stmt, sSQL))
+    {
+      std::string msg = "ERROR prepare stmt ";
+      msg += sqlite3_errmsg(m_DB);
+      msg += ": ";
+      msg += sSQL;
+      sqlite3_finalize(stmt);
+
+      cJSON_AddItemToArray(result, CreateJSONErrorObject(msg.c_str(), qid_value.c_str(), isHESAMode, isExecute));
+
+      if (req_begin) // we need to stop right now and make sure to roll back
+      {
+        // Can't call handleException(...) here yet because our own
+        // transaction would be blocking it from fullfilling it's destiny.
+        tx_rollback_reason = msg;
+
+        //All-Or-Nothing. The first error ends the batch.
+        req_commit = false;
+        req_rollback = true;
+        break;
+      }
+      else if (inTransaction())
+      {
+        // This case handles batches with an outer transaction.
+        handleException(msg, 0);
+        break;
+      }
+      else // keep it chill and carry on despite the failure
+      {
+        // This case handles batches without transaction.
+        handleException(msg, 0);
+        statement = statement->next;
+        continue;
+      }
+    }
+
+    bindParameters(stmt, params);
+
+    cJSON *rows = cJSON_CreateArray();
+    cJSON *columns = NULL;
+
+    int column_count = sqlite3_column_count(stmt);
+
+    if (column_count > 0)
+    {
+      int istep = 0;
+
+      cJSON *previous_row = NULL;
+
+      cJSON *previous_col = NULL;
+      columns = cJSON_CreateArray();
+      bool first_step = true;
+
+      while ((istep = concurrent_step(stmt)) == SQLITE_ROW) {
+        int col_type;
+
+        cJSON *row = cJSON_CreateObject();
+
+        for (int i = 0; i<column_count; i++) {
+          col_type = sqlite3_column_type(stmt, i);
+          std::string key = sqlite3_column_name(stmt, i);
+
+          if (first_step) {
+            cJSON *col_metadata = cJSON_CreateObject();
+            cJSON_AddStringToObject(col_metadata, "col_name", key.c_str());
+            cJSON_AddNumberToObject(col_metadata, "col_type", col_type);
+
+            if (previous_col == NULL) {
+              cJSON_AddItemToArray(columns, col_metadata);
+            } else {
+              previous_col->next = col_metadata;
+              col_metadata->prev = previous_col;
+            }
+
+            previous_col = col_metadata;
+          }
+
+          if (col_type == SQLITE_TEXT) {
+            const char *data = (const char *)sqlite3_column_text(stmt, i);
+
+            if (data != NULL) {
+              cJSON_AddStringToObject(row, key.c_str(), data);
+            }
+            else {
+              cJSON_AddNullToObject(row, key.c_str());
+            }
+          }
+          else if (col_type == SQLITE_FLOAT) {
+            double float_data = sqlite3_column_double(stmt, i);
+            cJSON_AddNumberToObject(row, key.c_str(), float_data);
+          }
+          else if (col_type == SQLITE_INTEGER) {
+            INT64 int_data = sqlite3_column_int64(stmt, i);
+            cJSON_AddNumberToObject(row, key.c_str(), (double)int_data);
+          }
+          else if (col_type == SQLITE_BLOB) {
+            cJSON_AddNullToObject(row, key.c_str());
+          }
+          else {
+            cJSON_AddNullToObject(row, key.c_str());
+          }
+        }
+
+        // The linked list implementation of the cJSON library does NOT have a pointer stored to the
+        // last item of the list which then forces the implementation of cJSON_AddItemToArray(...)
+        // to loop through all current items of the array whenever we want to add a new item at the end.
+        //
+        // The big o time complexity of this is a massive O( (1 + n)^0.5n )
+        // https://www.wolframalpha.com/input/?i=1+%2B+2+%2B+3+%2B+4+%2B+...+%2B+n
+        // Which leads to 15 minutes query execution time on my iPhone for the SQL:
+        // SELECT Id FROM 'Order_Item__c' (with 130k rows in the table).
+        //
+        // The optimization below keeps track of the last item's reference manually, outside of the cJSON
+        // implementation so that we can work with O(1) append time. Now the query from above runs in 3 seconds.
+        //
+        if (previous_row == NULL)
+        {
+          cJSON_AddItemToArray(rows, row);
+        }
+        else
+        {
+          previous_row->next = row;
+          row->prev = previous_row;
+        }
+        previous_row = row;
+
+        first_step = false;
+      }
+
+      if (SQLITE_DONE != istep) {
+        std::string msg = "ERROR execute select stmt ";
+        msg += sqlite3_errmsg(m_DB);
+        msg += ": ";
+        msg += sSQL;
+
+        cJSON_Delete(rows);
+        cJSON_AddItemToArray(result, CreateJSONErrorObject(msg.c_str(), qid_value.c_str(), isHESAMode, isExecute));
+
+        handleException(msg, 0);
+      }
+    }
+    else
+    {
+      if (SQLITE_DONE != concurrent_step(stmt)) {
+        std::string msg = "ERROR execute stmt ";
+        msg += sqlite3_errmsg(m_DB);
+        msg += ": ";
+        msg += sSQL;
+
+        cJSON_AddItemToArray(result, CreateJSONErrorObject(msg.c_str(), qid_value.c_str(), isHESAMode, isExecute));
+
+        handleException(msg, 0);
+      }
+    }
+
+    if (param_count > 0)
+    {
+      sqlite3_clear_bindings(stmt);
+      sqlite3_reset(stmt);
+    }
+
+    sqlite3_finalize(stmt);
+
+    //[{"type":"success", "result": {"rows":[], "rowsAffected" : 0}},
+    // {"type":"success", "result": {"rows":[], "rowsAffected" : 0}},
+    // {"type":"success", "result": {"rows":[], "rowsAffected" : 1, "insertId" : 1}}]
+
+    int rows_affected = sqlite3_total_changes(m_DB) - total_changes;
+
+    cJSON_AddItemToArray(result, CreateJSONSuccessObject(rows, rows_affected, qid_value.c_str(), isHESAMode, isExecute, columns));
+
+    statement = statement->next;
+  }
+
+  if (req_begin)
+  {
+    if (req_commit)
+    {
+      commit();
+      endTransaction();
+    }
+    else
+    {
+      endTransaction();
+
+      if (req_rollback)
+      {
+        handleException(tx_rollback_reason, 0);
+      }
+    }
+  }
+
+  if (enableLog)
+  {
+    t.stop();
+
+    timer_ticks ticks = t.get_elapsed_us();
+    double performance = t.ticks_to_ms(ticks) / 1000;
+
+    if (LogAdapter::logPerformance()) LogPerformance("universalParameterizedBatch", performance);
+  }
+
+  return result;
+}
+
+cJSON * SimpleDBConnection::CreateJSONErrorObject(const char *msg, const char *qid, bool isHESAMode, bool isExecute)
+{
+  cJSON *err = cJSON_CreateObject();
+
+  if (isHESAMode)
+  {
+    cJSON_AddStringToObject(err, "qid", qid);
+
+    if (isExecute)
+    {
+      cJSON_AddBoolToObject(err, "result", false);
+      cJSON_AddNumberToObject(err, "rowsAffected", 0);
+    }
+    else
+    {
+      cJSON *rows = cJSON_CreateArray();
+      cJSON_AddItemToObject(err, "result", rows);
+    }
+  }
+  else
+  {
+    cJSON *res = cJSON_CreateObject();
+    cJSON_AddStringToObject(err, "type", "error");
+    cJSON_AddNumberToObject(res, "code", -1);
+    cJSON_AddStringToObject(res, "message", msg);
+    cJSON_AddItemToObject(err, "result", res);
+  }
+
+  return err;
+}
+
+int SimpleDBConnection::msleep(long int msec)
+{
+  if (msec < 0) return -1;
+
+  if (LogAdapter::logDebug()) LogAdapter::Console("sleep()");
+  #if defined(WIN32) || defined(WINAPI_FAMILY)
+    
+    Sleep(msec);
+    return 0;
+  #else
+    struct timespec timeout0;
+    struct timespec timeout1;
+
+    struct timespec* t0 = &timeout0;
+    struct timespec* t1 = &timeout1;
+    struct timespec* tmp;
+
+    t0->tv_sec = msec / 1000;
+    t0->tv_nsec = (msec % 1000) * (1000 * 1000);
+
+    while (nanosleep(t0, t1) == -1) {
+      if (errno == EINTR) {
+        tmp = t0; t0 = t1; t1 = tmp;
+      }
+      else {
+        return -1;
+      }
+    }
+
+    return 0;
+  #endif
+}
+
+
+int SimpleDBConnection::concurrent_step(sqlite3_stmt  *stmt)
+{
+  int rc;
+  int n=0;
+
+  do {
+    rc = sqlite3_step(stmt);
+
+    if (rc == SQLITE_LOCKED) {
+      rc = sqlite3_reset(stmt); /** Note: This will return SQLITE_LOCKED as well... **/
+      n++;
+      msleep(SLEEP_LOCK_MS);
+    } else if (rc == SQLITE_BUSY) {
+      msleep(SLEEP_LOCK_MS);
+      n++;
+    }
+  } while ((n < SLEEP_LOCK_TIMES) && ((rc == SQLITE_BUSY) || (rc == SQLITE_LOCKED)));
+
+  if ((rc != SQLITE_ROW && (rc != SQLITE_DONE) && (rc != SQLITE_SCHEMA))) {
+    if (LogAdapter::logConsole()) LogAdapter::Console(StringFormat("Failed concurrent_step(): %d", rc).c_str());
+  }
+
+  return rc;
+}
+
+cJSON * SimpleDBConnection::CreateJSONSuccessObject(cJSON *rows, int rows_affected, const char *qid, bool isHESAMode, bool isExecute, cJSON *columns)
+{
+  cJSON *ok = cJSON_CreateObject();
+  
+  if (isHESAMode)
+  {
+    cJSON_Delete(columns);
+    cJSON_AddStringToObject(ok, "qid", qid);
+
+    if (isExecute)
+    {
+      cJSON_AddBoolToObject(ok, "result", true);
+      cJSON_AddNumberToObject(ok, "rowsAffected", rows_affected);
+    }
+    else
+    {
+      cJSON_AddItemToObject(ok, "result", rows);
+    }
+  }
+  else
+  {
+    cJSON *res = cJSON_CreateObject();
+    cJSON_AddStringToObject(ok, "type", "success");
+    cJSON_AddItemToObject(res, "rows", rows);
+    cJSON_AddNumberToObject(res, "rowsAffected", rows_affected);
+    if (rows_affected > 0) cJSON_AddNumberToObject(res, "insertId", (double)sqlite3_last_insert_rowid(m_DB));
+    if (columns != NULL) cJSON_AddItemToObject(res, "columns", columns);
+    
+    cJSON_AddItemToObject(ok, "result", res);
+  }
+
+  return ok;
+}
+
+bool SimpleDBConnection::beginTransaction()
+{
+  if (LogAdapter::logConsole()) LogAdapter::Console("beginTransaction()");
+
+  bool ret = false;
+
+  resetLastError();
+
+  if (inTransaction()) {
+    if (LogAdapter::logConsole()) LogAdapter::Console("beginTransaction() other transaction already started");
+    return ret;
+  }
+
+  if (!isValid()) {
+    handleException("beginTransaction() invalid call",0);
+    return false;
+  }
+
+  ret = concurrent_beginTransaction();
+
+  if (ret) {
+    m_bInTransaction=true;
+    m_bTransactionCommit=false;
+  }
+
+  if (LogAdapter::logDebug()) LogAdapter::Console(StringFormat("beginTransaction OK (%d)", ret).c_str());
+
+  return ret;
+}
+
+bool SimpleDBConnection::concurrent_prepare(sqlite3_stmt  **stmt, const char * sql)
+{
+  int rc;
+  int n=0;
+
+  do {
+    rc = sqlite3_prepare_v2(m_DB, sql, -1, stmt, NULL);
+
+    if ((rc == SQLITE_BUSY) || (rc == SQLITE_LOCKED)) {
+       n++;
+       msleep(SLEEP_LOCK_MS);
+    }
+  } while ((n < SLEEP_LOCK_TIMES) && ((rc == SQLITE_BUSY) || (rc == SQLITE_LOCKED)));
+
+  if (rc != SQLITE_OK) {
+	  if (LogAdapter::logConsole()) LogAdapter::Console(StringFormat("Failed concurrent_prepare(): %d : %s", rc, sql).c_str());
+  }
+
+  return (rc == SQLITE_OK) ? true : false;
+}
+
+void SimpleDBConnection::bindParameters(sqlite3_stmt *stmt, cJSON *params) {
+  if (stmt == NULL || params == NULL) return;
+  if (params->type != cJSON_Array) return;
+
+  std::string cvt_true  = "1";
+  std::string cvt_false = "0";
+
+  int param_count = cJSON_GetArraySize(params);
+
+  for (int i=0, j=1; i < param_count; i++, j++)
+    {
+      cJSON *param = cJSON_GetArrayItem(params, i);
+
+      switch (param->type)
+      {
+        case cJSON_String:
+          if (sqlite3_bind_text(stmt, j, param->valuestring, -1, SQLITE_STATIC) != SQLITE_OK) {} //Todo
+          break;
+
+        case cJSON_Number:
+          //Range of int and double is assumed equal in cJSON, so it will crash when parsing a large
+          //number before even coming to this point. You need to patch cJSON to allow big numbers.
+          if (fabs(param->valuedouble - (double)param->valueint) < 1E-14)
+          {
+            if (sqlite3_bind_int(stmt, j, param->valueint) != SQLITE_OK) {} //Todo
+          }
+          else
+          {
+            INT64 valueInt64 = (INT64)param->valuedouble;
+            if (fabs(param->valuedouble - (double)valueInt64) < 1E-14){
+              if (sqlite3_bind_int64(stmt, j, valueInt64) != SQLITE_OK) {} //Todo
+            } else {
+              if (sqlite3_bind_double(stmt, j, param->valuedouble) != SQLITE_OK) {} //Todo
+            }
+          }
+          break;
+
+        case cJSON_True:
+          if (sqlite3_bind_text(stmt, j, cvt_true.c_str(), -1, SQLITE_STATIC) != SQLITE_OK){} //Todo
+          break;
+
+        case cJSON_False:
+          if (sqlite3_bind_text(stmt, j, cvt_false.c_str(), -1, SQLITE_STATIC) != SQLITE_OK) {} //Todo
+          break;
+
+        default:
+          if (sqlite3_bind_null(stmt, j) != SQLITE_OK) {} //Todo
+          break;
+      }
+    }
+}
+
+bool SimpleDBConnection::endTransaction()
+{
+  if (LogAdapter::logConsole()) LogAdapter::Console("endTransaction()");
+
+  bool ret = false;
+
+  resetLastError();
+
+  if (!inTransaction()) {
+    if (LogAdapter::logConsole()) LogAdapter::Console("endTransaction() no open transaction to end");
+    return ret;
+  }
+
+  if (!isValid()) {
+    handleException("endTransaction() invalid call",0);
+    return false;
+  }
+
+  ret = concurrent_endTransaction(m_bTransactionCommit);
+
+  if (ret) {
+    m_bInTransaction = false;
+    m_bTransactionCommit = false;
+  }
+  if (LogAdapter::logDebug()) LogAdapter::Console(StringFormat("endTransaction OK (%d)", ret).c_str());
+
+  return ret;
+}
+
+
+void SimpleDBConnection::handleException(const char *err_text, int err_code)
+{
+  if (LogAdapter::logConsole()) LogAdapter::Console(err_text);
+  //Always set the last error after error logging which otherwise resets the last error.
+  setLastError(err_text, err_code);
+}
+
+void SimpleDBConnection::handleException(std::string& err_text, int err_code)
+{
+  handleException(err_text.c_str(), err_code);
+}
+
+bool SimpleDBConnection::concurrent_beginTransaction()
+{
+  int rc;
+  sqlite3_stmt* bt_stmt;
+
+  bt_stmt = NULL;
+
+  if (!concurrent_prepare(&bt_stmt, "BEGIN EXCLUSIVE TRANSACTION")) {
+	  if (LogAdapter::logConsole()) LogAdapter::Console("Failed concurrent_beginTransaction() in prepare");
+    return false;
+  }
+
+  rc = concurrent_step(bt_stmt);
+
+  if (rc != SQLITE_DONE) {
+    if (LogAdapter::logConsole()) LogAdapter::Console(StringFormat("Failed concurrent_beginTransaction() in step: %d.", rc).c_str());
+  }
+
+  sqlite3_finalize(bt_stmt);
+
+  return (rc == SQLITE_DONE) ? true : false;
+}
+
+bool SimpleDBConnection::concurrent_endTransaction(bool bCommit)
+{
+  int rc;
+  sqlite3_stmt* bt_stmt;
+
+  const char * sql = (bCommit) ? "COMMIT TRANSACTION" : "ROLLBACK TRANSACTION";
+
+  if (!concurrent_prepare(&bt_stmt, sql)) {
+    if (LogAdapter::logConsole()) LogAdapter::Console("Failed concurrent_endTransaction() in prepare");
+    return false;
+  }
+
+  rc = concurrent_step(bt_stmt);
+
+  if (rc != SQLITE_DONE) {
+	  if (LogAdapter::logConsole()) LogAdapter::Console(StringFormat("Failed concurrent_endTransaction() in step: %d.", rc).c_str());
+  }
+
+  sqlite3_finalize(bt_stmt);
+
+  return (rc == SQLITE_DONE ) ? true : false;
+}
+
+void SimpleDBConnection::setLastError(std::string error_message, int error_code) { 
+  m_sLastError = StringFormat("(%d) %s", error_code, error_message.c_str()); 
+}
+
+
+cJSON * SimpleDBConnection::CreateJSONQuery()
+{
+  cJSON *qry = cJSON_CreateArray();
+
+  return qry;
+}
+
+
+cJSON * SimpleDBConnection::AddJSONQueryItem(cJSON *qry, const char *sql)
+{
+  if (((cJSON *)0 != qry) && ((const char *)0 != sql))
+  {
+    cJSON *itm = cJSON_CreateObject();
+    cJSON *par = cJSON_CreateArray();
+
+    cJSON_AddStringToObject(itm, "sql", sql);
+    cJSON_AddItemToObject(itm, "params", par);
+
+    cJSON_AddItemToArray(qry, itm);
+
+    return par;
+  }
+  else
+  {
+    return (cJSON *)0;
+  }
+}
+
+void SimpleDBConnection::AddJSONQueryItemParam(cJSON *par, const char *str)
+{
+  if ((cJSON *)0 != par)
+  {
+    if ((const char *)0 != str)
+    {
+      cJSON_AddItemToArray(par, cJSON_CreateString(str));
+    }
+    else
+    {
+      cJSON_AddItemToArray(par, cJSON_CreateNull());
+    }
+  }
+}
+
+void SimpleDBConnection::AddJSONQueryItemParam(cJSON *par, int d)
+{
+  if ((cJSON *)0 != par)
+  {
+    cJSON_AddItemToArray(par, cJSON_CreateNumber((double)d));
+  }
+}
+
+void SimpleDBConnection::AddJSONQueryItemParam(cJSON *par, double dbl)
+{
+  if ((cJSON *)0 != par)
+  {
+    cJSON_AddItemToArray(par, cJSON_CreateNumber(dbl));
+  }
+}
+
+void SimpleDBConnection::AddJSONQueryItemParam(cJSON *par, bool bln)
+{
+  if ((cJSON *)0 != par)
+  {
+    cJSON_AddItemToArray(par, ((bln) ? cJSON_CreateTrue() : cJSON_CreateFalse()));
+  }
+}
+
+void SimpleDBConnection::ReplaceJSONSqlStatement(cJSON *query, const char* sqlStatement) {
+  if ((cJSON *)0 == query || ((const char *)0 == sqlStatement)) return;
+
+  cJSON *statement = query->child;
+  if ((cJSON *)0 != statement) {
+    cJSON_DeleteItemFromObject(statement, "sql");
+    cJSON_AddStringToObject(statement, "sql", sqlStatement);
+  }
+}