Pool class, and work on mySQL class pool support

.vscode/settings.json

@@ -3,6 +3,7 @@
         "string": "cpp",
         "vector": "cpp",
         "deque": "cpp",
-        "ostream": "cpp"
+        "ostream": "cpp",
+        "future": "cpp"
     }
 }

lib/mysql.hpp

@@ -7,6 +7,7 @@
 #include <map>
 #include <iostream>
 #include <mutex>
+#include <thread>
 
 #include <mysql_driver.h>
 #include <mysql_connection.h>
@@ -16,7 +17,8 @@
 #include <cppconn/prepared_statement.h>
 #include <cppconn/resultset.h>
 
-#define CONNECT_TRY_LIMIT 3
+#define unlimited 0
+#define reconnectSleep 100000 // in us
 
 using namespace std;
 using namespace sql;
@@ -59,18 +61,50 @@ class mySQL {
     public:
     mutex io;
     MySQL_Driver *drv;
-    Connection *con;
+    // Connection *con;
+    vector<Connection*> con;
     string path, username, password, db;
     bool isPersistent;
+    uint numOfCon;
+    uint reconTrys = 3;
     
-    mySQL(const string _path, const string _username, const string _password, const string _db, bool _isPersistent = false);
-    bool open(const string _db = "");
-    bool connect();
+    mySQL(const string _path, const string _username, const string _password, const string _db, const bool _isPersistent = false, const uint _numOfCon = 1);
+    bool open(const string _db = "", const int con_idx = -1);
+    bool connect(const int con_idx = -1);
     bool disconnect();
+    void reconnectTrys(const uint _trys);
     void exec(sqlQA &sql_qa);
     void getColumns(const string _table, vector<string> &_columns);
     ~mySQL();
 };
 
+// class mySQLPool {
+//     public:
+
+//     struct Drop {
+//         mySQL* instance;
+//         bool used = false;
+//     };
+
+//     struct Swimmer {
+//         thread instance;
+//         bool used = false;
+//     };
+
+//     mutex io;
+//     uint maxpools = 0;
+//     vector<struct Drop> droplets;
+//     bool fixServer = false;
+//     bool fixScheme = false;
+//     vector<struct Swimmer> swimmers;
+
+//     mySQLPool(const uint _maxpools);
+//     mySQLPool(const uint _maxpools, const string _path, const string _username, const string _password, const string _db);
+
+//     void exec(sqlQA &sql_qa, const string _db = "");
+
+    
+// };
+
 
 #endif

src/mysql.cpp

@@ -74,12 +74,15 @@ void sqlQA::parse_columns(const string _columns) {
    }
 }
 
-mySQL::mySQL(const string _path, const string _username, const string _password, const string _db, bool _isPersistent) {
+mySQL::mySQL(const string _path, const string _username, const string _password, const string _db, const bool _isPersistent, const uint _numOfCon) {
    path = _path;
    username = _username;
    password = _password;
    db = _db;
-   isPersistent = _isPersistent;
+   isPersistent = _numOfCon > 1 ? true : _isPersistent;
+   numOfCon = _numOfCon;
+
+   drv = get_mysql_driver_instance();
 
    if (isPersistent) {
       if (connect()) {
@@ -95,13 +98,15 @@ mySQL::mySQL(const string _path, const string _username, const string _password,
 
 }
 
-bool mySQL::open(const string _db) {
+bool mySQL::open(const string _db, const int con_idx) {
    io.lock();
    db = _db.empty() ? db : _db;
-   bool status = true;
+   bool status = true; // ako true greška je
 
+   for (uint i=0; i<con.size(); i++) {
+      con_idx != -1 ? i = con_idx : i;
       try {
-      con->setSchema(db);
+         con[i]->setSchema(db);
          status = false;
          io.unlock();
       }
@@ -109,27 +114,38 @@ bool mySQL::open(const string _db) {
          cout << error.what() << endl;
          io.unlock();
       }
+      con_idx != -1 ? i = con.size() : i;
+   }
+   
    return status;
 }
 
-bool mySQL::connect() {
+bool mySQL::connect(const int con_idx) {
    io.lock();
    uint trys = 0;
    bool status = true;
 
-   while (trys < CONNECT_TRY_LIMIT && status) {
+   for (uint i=0; i<numOfCon; i++) {
+      con_idx != -1 ? i = con_idx : i;
+      while (reconTrys == 0 ? status : (trys < reconTrys && status)) {
          try {
-         drv = get_mysql_driver_instance();
-         con = drv->connect(path, username, password);
+            if (con_idx == -1) {
+               con.push_back(drv->connect(path, username, password));
+            }
+            else {
+               con[i] = drv->connect(path, username, password);
+            }
             status = false;
             io.unlock();
          }
          catch (const SQLException &error) {
             cout << error.what() << endl;
-         usleep(10000*trys++);
+            usleep(reconnectSleep);
+            reconTrys == 0 ? trys : trys++;
             io.unlock();
          }
       }
+   }
 
    return status;
 }
@@ -138,9 +154,10 @@ bool mySQL::disconnect() {
    io.lock();
    bool status = true;
 
-   if (con->isValid() && !con->isClosed()) {
+   for (uint i=0; i<con.size(); i++) {
+      if (con[i]->isValid() && !con[i]->isClosed()) {
          try {
-         con->close();
+            con[i]->close();
             status = false;
             io.unlock();
          } 
@@ -152,23 +169,38 @@ bool mySQL::disconnect() {
       }
 
       else {
-      status = false;
+         status = false; // već je zatvorena
+      }
    }
 
    return status;
 }
 
+/**
+ * Broj pokušaja usljed povezivanja s bazom od 1 do unlimited;
+*/
+
+void mySQL::reconnectTrys(const uint _trys) {
+   io.lock();
+   reconTrys = _trys;
+   io.unlock();
+}
+
 void mySQL::exec(sqlQA &sql_qa) {
 
-   if (!isPersistent || !con->isValid() || con->isClosed()) {
-      if (connect()) {
+   for (uint i=0; i<con.size(); i++) {
+      if (!isPersistent || !con[i]->isValid() || con[i]->isClosed()) {
+         if (connect(i)) {
             throw string("[ERROR] Unable to connect database ");
          }
 
-      if (open()) {
+         if (open(i)) {
             throw string("[ERROR] Unable to open database " + db);
          }
       }
+   }
+
+   // find free connection
 
    io.lock();
    /**/
@@ -249,3 +281,50 @@ mySQL::~mySQL() {
       throw string("[ERROR] Unable to close database ");
    }
 }
+
+// mySQLPool::mySQLPool(const uint _maxpools) {
+//    maxpools = _maxpools;
+//    fixServer = false;
+//    fixScheme = true;
+// }
+
+// mySQLPool::mySQLPool(const uint _maxpools, const string _path, const string _username, const string _password, const string _db) {
+//    maxpools = _maxpools;
+//    fixServer = true;
+//    fixScheme = !_db.empty();
+//    for (uint i=0; i<maxpools; i++) {
+//       mySQL tmpmysql(_path, _username, _password, _db);
+//       // struct Drop tmpdrop(new mySQL(_path, _username, _password, _db), false);
+//       droplets.push_back({mySQL(_path, _username, _password, _db, true), false});
+//    }
+// }
+
+// void mySQLPool::exec(sqlQA &sql_qa, const string _db) {
+//    if (!fixScheme && _db.empty()) {
+//       throw string("[ERROR] Database is not selected! ");
+//    }
+
+//    for (uint i=0; i<droplets.size(); i++) {
+//       if (droplets[i].used == false) {
+//          droplets[i].used = true;
+
+//          bool isRunned = false;
+
+//          while (!isRunned) {
+//             for (uint i=0; i<swimmers.size(); i++) {
+//                if (swimmers[i].used == false) {
+//                   swimmers[i].used = true;
+//                   swimmers[i].instance = thread([&]() {
+//                      droplets[i].instance->exec(sql_qa);
+//                   });
+//                   swimmers[i].instance.join();
+//                   swimmers[i].used = false;
+//                   isRunned = true;
+//                }
+//             }
+//          }
+//          droplets[i].used = false;
+//       }
+//    }
+
+// }