Fix of the last merge.

Plus slightly optimized allocating/deallocating of internally used Stmt
handles.

Author: lawrinn

driver/ma_api_internal.cpp

@@ -279,21 +279,19 @@ SQLRETURN MA_SQLCancel(SQLHSTMT StatementHandle)
 
   // Technically, if the application does not do good syncronization of stmt use here, we can have
   // Stmt already freed at this point, and crash right away on reading the mutex in Stmt
-  EnterCriticalSection(&globalLock);
+  std::unique_lock<std::mutex> localScopeLock(globalLock);
   if (CheckDeletedStmt(Stmt) != NULL)
   {
-    LeaveCriticalSection(&globalLock);
     return ret;// i.e. SQL_SUCCESS. Stmt has been deleted, nothing to cancel already
   }
-  if (!TryEnterCriticalSection(&Stmt->CancelDropSwitch))
+  if (!Stmt->CancelDropSwitch.try_lock())
   {
-    LeaveCriticalSection(&globalLock);
     // This is not clear what is right here - success or error
     return SQL_SUCCESS;
   }
   // We can release the lock. SQL_DROP will get it, but stop at the Stmt->CancelDropSwitch
   // that we already own
-  LeaveCriticalSection(&globalLock);
+  localScopeLock.unlock();
   MADB_CLEAR_ERROR(&Stmt->Error);
 
   MDBUG_C_ENTER(Stmt->Connection, "SQLCancel");
@@ -337,7 +335,7 @@ SQLRETURN MA_SQLCancel(SQLHSTMT StatementHandle)
     } // Else we are canceling function running in other thread.
     else if (lock.try_lock())
     {
-      Stmt->canceled= '\1';
+      Stmt->canceled= true;
       try
       {
         /* "If a SQL statement is being executed when SQLCancel is called on another thread to cancel the
@@ -362,7 +360,7 @@ SQLRETURN MA_SQLCancel(SQLHSTMT StatementHandle)
       ret= MADB_KillAtServer(Stmt->Connection, &Stmt->Error);
     }
   }
-  LeaveCriticalSection(&Stmt->CancelDropSwitch);
+  Stmt->CancelDropSwitch.unlock();
   MDBUG_C_RETURN(Stmt->Connection, ret, &Stmt->Error);
 }
 /* }}} */

driver/ma_driver.cpp

@@ -24,9 +24,10 @@
  */
 /************************************* Driver wide stuff ************************************************/
 
-CRITICAL_SECTION globalLock;
+std::mutex globalLock;
 static MADB_List *deletedStmt= NULL;
-static unsigned int envCount= 0;
+//sles12 does not have atomic_uint32 defined
+static std::atomic<uint32_t> envCount(0U);
 
 #ifndef _WIN32
 __attribute__((constructor))
@@ -43,53 +44,48 @@ extern "C" {
   /* {{{ DriverGlobalInit */
   void DriverGlobalInit()
   {
-    InitializeCriticalSection(&globalLock);
   }
   /* }}} */
 
   /* {{{  DriverGlobalClean()*/
   void DriverGlobalClean(void)
   {
-    EnterCriticalSection(&globalLock);
+    // There is no need to lock here at least the while it used the way it used now -
+    // only called when library is unloaded
     if (deletedStmt)
     {
       MADB_ListFree(deletedStmt, FALSE);
     }
-    LeaveCriticalSection(&globalLock);
-    DeleteCriticalSection(&globalLock);
   }
   /* }}} */
 }
 /* {{{ IncrementEnvCount */
 // Normally there should be 1 Env, but nothing forbids app have more than 1. 
 void IncrementEnvCount()
 {
-  EnterCriticalSection(&globalLock);
   ++envCount;
-  LeaveCriticalSection(&globalLock);
 }
 /*}}}*/
 
 /* {{{ DecrementEnvCount */
 // If the last Env has been freed - we should probably clean the list 
 void DecrementEnvCount()
 {
-  EnterCriticalSection(&globalLock);
   --envCount;
   if (!envCount)
   {
+    std::lock_guard<std::mutex> localScopeLock(globalLock);
     MADB_ListFree(deletedStmt, FALSE);
     deletedStmt= NULL;
   }
-  LeaveCriticalSection(&globalLock);
 }
 /*}}}*/
 
 /* {{{ CheckDeletedStmt */
 // If the last Env has been freed - we should probably clean the list 
 MADB_List* CheckDeletedStmt(void* stmtObjAddr)
 {
-  MADB_List* item= deletedStmt;
+  MADB_List *item= deletedStmt;
   while (item != NULL)
   {
     if (item->data == stmtObjAddr)
@@ -104,18 +100,17 @@ MADB_List* CheckDeletedStmt(void* stmtObjAddr)
 
 /* {{{ RemoveStmtFromDeleted */
 // If the last Env has been freed - we should probably clean the list 
-BOOL RemoveStmtFromDeleted(void* stmtObjAddr)
+bool RemoveStmtFromDeleted(void* stmtObjAddr)
 {
-  BOOL result= FALSE;
-  EnterCriticalSection(&globalLock);
+  bool result= false;
+  std::lock_guard<std::mutex> localScopeLock(globalLock);
   MADB_List* found= CheckDeletedStmt(stmtObjAddr);
   if (found)
   {
     deletedStmt= MADB_ListDelete(deletedStmt, found);
     free(found);
-    result= TRUE;
+    result= true;
   }
-  LeaveCriticalSection(&globalLock);
   return result;
 }
 /*}}}*/

driver/ma_driver.h

@@ -30,15 +30,15 @@
 #ifndef _ma_driver_h_
 #define _ma_driver_h_
 
-extern CRITICAL_SECTION globalLock;
+extern std::mutex globalLock;
 extern "C" {
   void DriverGlobalInit();
   void DriverGlobalClean(void);
 }
 void IncrementEnvCount();
 void DecrementEnvCount();
 MADB_List* CheckDeletedStmt(void* stmtObjAddr);
-BOOL RemoveStmtFromDeleted(void* stmtObjAddr);
+bool RemoveStmtFromDeleted(void* stmtObjAddr);
 void RememberDeletedStmt(void* stmtObjAddr);
 
 typedef struct {

driver/ma_helper.cpp

@@ -1141,10 +1141,11 @@ SQLRETURN MADB_DaeStmt(MADB_Stmt *Stmt, SQLUSMALLINT Operation)
   MADB_CLEAR_ERROR(&Stmt->Error);
 
   if (Stmt->DaeStmt)
-    Stmt->Methods->StmtFree(Stmt->DaeStmt, SQL_DROP);
-  Stmt->DaeStmt= nullptr;
+  {
+    MADB_DeleteDaeStmt(Stmt);
+  }
 
-  if (!SQL_SUCCEEDED(MA_SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)Stmt->Connection, (SQLHANDLE *)&Stmt->DaeStmt)))
+  if (!SQL_SUCCEEDED(MADB_StmtInit(Stmt->Connection, (SQLHANDLE *)&Stmt->DaeStmt, false)))
   {
     return MADB_CopyError(&Stmt->Error, &Stmt->Connection->Error);
   }
@@ -1183,7 +1184,7 @@ SQLRETURN MADB_DaeStmt(MADB_Stmt *Stmt, SQLUSMALLINT Operation)
   if (!SQL_SUCCEEDED(Stmt->DaeStmt->Prepare(Query.c_str(), (SQLINTEGER)Query.length(), true)))
   {
     MADB_CopyError(&Stmt->Error, &Stmt->DaeStmt->Error);
-    Stmt->Methods->StmtFree(Stmt->DaeStmt, SQL_DROP);
+    MADB_DeleteDaeStmt(Stmt);
   }
   return Stmt->Error.ReturnValue;
 }

driver/ma_odbc.h

@@ -287,13 +287,14 @@ struct MADB_Env {
 // Stmt has to know few things about connection and descriptor
 #include "ma_connection.h"
 #include "ma_desc.h"
-
+#define xxx sizeof(std::mutex)
 struct MADB_Stmt
 {
   MADB_QUERY                Query;
   MADB_StmtOptions          Options;
   MADB_Error                Error;
-  CRITICAL_SECTION          CancelDropSwitch; /* mutex for SQLCancel/SQLFreeStmt(SQL_DROP) */
+  std::mutex                CancelDropSwitch; /* mutex for SQLCancel/SQLFreeStmt(SQL_DROP) */
+  std::atomic_bool          canceled;
   MADB_Cursor               Cursor;
   MADB_List                 ListItem;
   long long                 AffectedRows= 0;
@@ -339,7 +340,6 @@ struct MADB_Stmt
   bool                      PositionedCommand= false;
   bool                      RebindParams= false;
   bool                      bind_done= false;
-  std::atomic_bool          canceled;
 
   MADB_Stmt(MADB_Dbc *Connection);
   SQLRETURN Prepare(const char* StatementText, SQLINTEGER TextLength, bool ServerSide= true, bool DirectExecution= false);