You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
223 lines
5.2 KiB
223 lines
5.2 KiB
#ifndef _MYSQL_
|
|
#define _MYSQL_
|
|
|
|
#include <deque>
|
|
#include <mutex>
|
|
#include <thread>
|
|
#include <future>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <tuple>
|
|
|
|
#include <mysql_driver.h>
|
|
#include <mysql_connection.h>
|
|
#include <cppconn/driver.h>
|
|
#include <cppconn/connection.h>
|
|
#include <cppconn/statement.h>
|
|
#include <cppconn/prepared_statement.h>
|
|
#include <cppconn/resultset.h>
|
|
|
|
#define unlimited 0
|
|
#define reconnectSleep 10000 // in us
|
|
|
|
using namespace std;
|
|
using namespace sql;
|
|
using namespace mysql;
|
|
|
|
namespace marcelb {
|
|
namespace mysql {
|
|
|
|
/**
|
|
*
|
|
*/
|
|
#define MYSQL_PERIODIC_INTERNAL_TIME 1000
|
|
|
|
/**
|
|
* An enumeration of how periodic functions will be run
|
|
* internal - run periodic_maintenance() i new thread
|
|
* external - expects periodic_maintenance() to be run periodically outside the library
|
|
*
|
|
*/
|
|
enum class periodical_engine {
|
|
internal,
|
|
external
|
|
};
|
|
|
|
/**
|
|
* A class for creating sql responses
|
|
*/
|
|
template<typename... Types>
|
|
class MySQL_Res : public vector<tuple<Types...>> {
|
|
public:
|
|
bool have_result = false;
|
|
uint16_t affected = 0;
|
|
uint16_t rows = 0;
|
|
uint16_t columns = sizeof...(Types);
|
|
vector<string> columns_name;
|
|
};
|
|
|
|
/**
|
|
* Type conversion functions
|
|
*/
|
|
template<typename T>
|
|
T getValue(ResultSet* res, int column);
|
|
template<>
|
|
inline int getValue<int>(ResultSet* res, int column) {
|
|
return res->getInt(column);
|
|
}
|
|
template<>
|
|
inline uint getValue<uint>(ResultSet* res, int column) {
|
|
return res->getUInt(column);
|
|
}
|
|
template<>
|
|
inline int64_t getValue<int64_t>(ResultSet* res, int column) {
|
|
return res->getInt64(column);
|
|
}
|
|
template<>
|
|
inline uint64_t getValue<uint64_t>(ResultSet* res, int column) {
|
|
return res->getUInt64(column);
|
|
}
|
|
template<>
|
|
inline float getValue<float>(ResultSet* res, int column) {
|
|
return res->getDouble(column);
|
|
}
|
|
template<>
|
|
inline double getValue<double>(ResultSet* res, int column) {
|
|
return res->getDouble(column);
|
|
}
|
|
template<>
|
|
inline string getValue<string>(ResultSet* res, int column) {
|
|
return res->getString(column);
|
|
}
|
|
template<>
|
|
inline bool getValue<bool>(ResultSet* res, int column) {
|
|
return res->getBoolean(column);
|
|
}
|
|
// implementiraj neku c++ kompatibilnu pretvorbu za timestampe, time, date datetime itd.
|
|
|
|
class MySQL {
|
|
mutex io;
|
|
MySQL_Driver *drv;
|
|
deque<Connection*> con;
|
|
string path, username, password, db;
|
|
uint available;
|
|
uint reconTrys = 3;
|
|
bool run_engin = true;
|
|
future<void> periodic_engin;
|
|
periodical_engine engine_type;
|
|
|
|
/**
|
|
* Open one database
|
|
*/
|
|
bool open_one(Connection* con_ptr);
|
|
|
|
/**
|
|
* Open one database server connection
|
|
*/
|
|
Connection* create_con();
|
|
|
|
/**
|
|
* Close one database connection
|
|
*/
|
|
bool disconnect_one(Connection* con_ptr);
|
|
|
|
/**
|
|
* Take an available database connection
|
|
*/
|
|
Connection* shift_con();
|
|
|
|
/**
|
|
* Function parses a parameterized row
|
|
*/
|
|
|
|
template<typename... Types, size_t... Is>
|
|
static tuple<Types...> getRow(sql::ResultSet* res, index_sequence<Is...>) {
|
|
return make_tuple(getValue<Types>(res, Is + 1)...);
|
|
}
|
|
|
|
public:
|
|
|
|
/**
|
|
* MySQL constructor,
|
|
* receive the path to the mysql server,
|
|
* username, password, database name,
|
|
* and number of active connections (optional)
|
|
*/
|
|
MySQL(const string _path, const string _username, const string _password, const string _db, const uint _available = 1, const periodical_engine _engine_type = periodical_engine::internal);
|
|
|
|
/**
|
|
* Disconnect all connections to server
|
|
*/
|
|
bool disconnect();
|
|
|
|
/**
|
|
* Define the maximum number of attempts to
|
|
* reconnect to the server
|
|
*/
|
|
void reconnectTrys(const uint _trys);
|
|
|
|
/**
|
|
* Execute the SQL statement
|
|
*/
|
|
template<typename... Types>
|
|
MySQL_Res<Types...> exec(const string& sql_q) {
|
|
Connection* con_ptr = shift_con();
|
|
MySQL_Res<Types...> result;
|
|
|
|
try {
|
|
Statement *stmt;
|
|
stmt = con_ptr->createStatement();
|
|
result.have_result = stmt->execute(sql_q);
|
|
|
|
if (result.have_result) {
|
|
ResultSet* res = stmt->getResultSet();
|
|
result.rows = res->rowsCount();
|
|
|
|
ResultSetMetaData *metaData = res->getMetaData();
|
|
int columnCount = metaData->getColumnCount();
|
|
|
|
for (int i = 1; i <= columnCount; ++i) {
|
|
result.columns_name.push_back(metaData->getColumnName(i));
|
|
}
|
|
|
|
while (res->next()) {
|
|
result.push_back(MySQL::getRow<Types...>(res, make_index_sequence<sizeof...(Types)>{}));
|
|
}
|
|
|
|
res->close();
|
|
delete res;
|
|
} else {
|
|
result.affected = stmt->getUpdateCount();
|
|
}
|
|
|
|
stmt->close();
|
|
delete stmt;
|
|
disconnect_one(con_ptr);
|
|
|
|
} catch (sql::SQLException& e) {
|
|
throw runtime_error(e.what());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* If you are using an external periodic motor,
|
|
* please call this function in it for proper operation at a certain time interval.
|
|
* You can use the default MYSQL_PERIODIC_INTERNAL_TIME
|
|
*/
|
|
void periodic_maintenance();
|
|
|
|
/**
|
|
* Destruktor
|
|
* close all connections
|
|
*/
|
|
~MySQL();
|
|
|
|
};
|
|
|
|
|
|
}
|
|
}
|
|
|
|
#endif |