aherman
/
proxysql
mirror of https://github.com/sysown/proxysql
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Added 'stats_pgsql_errors' and 'stats_pgsql_errors_reset' tables

Browse Source
v2.x_pg_PrepStmtBase_240714
Rahim Kanji 2 years ago
parent caebae6636
commit e939cf088e
11 changed files with 185 additions and 91 deletions
Show Stats Download Patch File Download Diff File

2
include/Base_HostGroups_Manager.h
Unescape View File

@ -132,7 +132,7 @@ namespace nlohmann { class json; }
"weight, compression, max_connections, max_replication_lag, use_ssl, max_latency_ms, comment " \
"FROM main.mysql_servers " \
"WHERE status != \"OFFLINE_HARD\" " \
"ORDER BY hostgroup_id, hostname, port" \
"ORDER BY hostgroup_id, hostname, port"
typedef std::unordered_map<std::uint64_t, void *> umap_mysql_errors;

2
include/MySQL_HostGroups_Manager.h
Unescape View File

@ -119,7 +119,7 @@ namespace nlohmann { class json; }
"weight, compression, max_connections, max_replication_lag, use_ssl, max_latency_ms, comment " \
"FROM main.mysql_servers " \
"WHERE status != \"OFFLINE_HARD\" " \
"ORDER BY hostgroup_id, hostname, port" \
"ORDER BY hostgroup_id, hostname, port"
typedef std::unordered_map<std::uint64_t, void *> umap_mysql_errors;

2
include/PgSQL_Connection.h
Unescape View File

@ -546,7 +546,7 @@ public:
}
inline
const char* get_error_code_str() const {
const char* get_error_code_str() const {
return error_info.sqlstate;
}

10
include/PgSQL_HostGroups_Manager.h
Unescape View File

@ -100,14 +100,15 @@ namespace nlohmann { class json; }
"weight, compression, max_connections, max_replication_lag, use_ssl, max_latency_ms, comment " \
"FROM main.pgsql_servers " \
"WHERE status != \"OFFLINE_HARD\" " \
"ORDER BY hostgroup_id, hostname, port" \
typedef std::unordered_map<std::uint64_t, void *> umap_pgsql_errors;
"ORDER BY hostgroup_id, hostname, port"
class PgSQL_SrvConnList;
class PgSQL_SrvC;
class PgSQL_SrvList;
class PgSQL_HGC;
class PgSQL_Errors_stats;
typedef std::unordered_map<std::uint64_t, PgSQL_Errors_stats*> umap_pgsql_errors;
class PgSQL_GTID_Server_Data {
public:
@ -847,7 +848,8 @@ class PgSQL_HostGroups_Manager : public Base_HostGroups_Manager<PgSQL_HGC> {
SQLite3_result *SQL3_Get_ConnPool_Stats();
void increase_reset_counter();
void add_pgsql_errors(int hostgroup, char *hostname, int port, char *username, char *address, char *schemaname, int err_no, char *last_error);
void add_pgsql_errors(int hostgroup, const char* hostname, int port, const char* username, const char* address,
const char* dbname, const char* sqlstate, const char* errmsg);
SQLite3_result *get_pgsql_errors(bool);
void shutdown();

5
include/ProxySQL_Admin_Tables_Definitions.h
Unescape View File

@ -301,10 +301,11 @@
#define STATS_SQLITE_TABLE_PGSQL_FREE_CONNECTIONS "CREATE TABLE stats_pgsql_free_connections (fd INT NOT NULL , hostgroup INT NOT NULL , srv_host VARCHAR NOT NULL , srv_port INT NOT NULL , user VARCHAR NOT NULL , database VARCHAR , init_connect VARCHAR , time_zone VARCHAR , sql_mode VARCHAR , idle_ms INT , statistics VARCHAR , pgsql_info VARCHAR)"
#define STATS_SQLITE_TABLE_PGSQL_USERS "CREATE TABLE stats_pgsql_users (username VARCHAR PRIMARY KEY , frontend_connections INT NOT NULL , frontend_max_connections INT NOT NULL)"
#define STATS_SQLITE_TABLE_PGSQL_PROCESSLIST "CREATE TABLE stats_pgsql_processlist (ThreadID INT NOT NULL , SessionID INTEGER PRIMARY KEY , user VARCHAR , database VARCHAR , cli_host VARCHAR , cli_port INT , hostgroup INT , l_srv_host VARCHAR , l_srv_port INT , srv_host VARCHAR , srv_port INT , command VARCHAR , time_ms INT NOT NULL , info VARCHAR , status_flags INT , extended_info VARCHAR)"
#define STATS_SQLITE_TABLE_PGSQL_ERRORS "CREATE TABLE stats_pgsql_errors (hostgroup INT NOT NULL , hostname VARCHAR NOT NULL , port INT NOT NULL , username VARCHAR NOT NULL , client_address VARCHAR NOT NULL , database VARCHAR NOT NULL , sqlstate VARCHAR NOT NULL , count_star INTEGER NOT NULL , first_seen INTEGER NOT NULL , last_seen INTEGER NOT NULL , last_error VARCHAR NOT NULL DEFAULT '' , PRIMARY KEY (hostgroup, hostname, port, username, database, sqlstate) )"
#define STATS_SQLITE_TABLE_PGSQL_ERRORS_RESET "CREATE TABLE stats_pgsql_errors_reset (hostgroup INT NOT NULL , hostname VARCHAR NOT NULL , port INT NOT NULL , username VARCHAR NOT NULL , client_address VARCHAR NOT NULL , database VARCHAR NOT NULL , sqlstate VARCHAR NOT NULL , count_star INTEGER NOT NULL , first_seen INTEGER NOT NULL , last_seen INTEGER NOT NULL , last_error VARCHAR NOT NULL DEFAULT '' , PRIMARY KEY (hostgroup, hostname, port, username, database, sqlstate) )"
//#define STATS_SQLITE_TABLE_MEMORY_METRICS "CREATE TABLE stats_memory_metrics (Variable_Name VARCHAR NOT NULL PRIMARY KEY , Variable_Value VARCHAR NOT NULL)"
/*
#define STATS_SQLITE_TABLE_MYSQL_ERRORS "CREATE TABLE stats_pgsql_errors (hostgroup INT NOT NULL , hostname VARCHAR NOT NULL , port INT NOT NULL , username VARCHAR NOT NULL , client_address VARCHAR NOT NULL , schemaname VARCHAR NOT NULL , errno INT NOT NULL , count_star INTEGER NOT NULL , first_seen INTEGER NOT NULL , last_seen INTEGER NOT NULL , last_error VARCHAR NOT NULL DEFAULT '' , PRIMARY KEY (hostgroup, hostname, port, username, schemaname, errno) )"
#define STATS_SQLITE_TABLE_MYSQL_ERRORS_RESET "CREATE TABLE stats_pgsql_errors_reset (hostgroup INT NOT NULL , hostname VARCHAR NOT NULL , port INT NOT NULL , username VARCHAR NOT NULL , client_address VARCHAR NOT NULL , schemaname VARCHAR NOT NULL , errno INT NOT NULL , count_star INTEGER NOT NULL , first_seen INTEGER NOT NULL , last_seen INTEGER NOT NULL , last_error VARCHAR NOT NULL DEFAULT '' , PRIMARY KEY (hostgroup, hostname, port, username, schemaname, errno) )"
#define STATS_SQLITE_TABLE_MYSQL_CLIENT_HOST_CACHE "CREATE TABLE stats_pgsql_client_host_cache (client_address VARCHAR NOT NULL , error_count INT NOT NULL , last_updated BIGINT NOT NULL)"
#define STATS_SQLITE_TABLE_MYSQL_CLIENT_HOST_CACHE_RESET "CREATE TABLE stats_pgsql_client_host_cache_reset (client_address VARCHAR NOT NULL , error_count INT NOT NULL , last_updated BIGINT NOT NULL)"

1
include/proxysql_admin.h
Unescape View File

@ -655,6 +655,7 @@ class ProxySQL_Admin {
void stats___pgsql_free_connections();
void stats___pgsql_connection_pool(bool _reset);
void stats___pgsql_processlist();
void stats___pgsql_errors(bool reset);
void stats___proxysql_servers_checksums();
void stats___proxysql_servers_metrics();

2
lib/Admin_Bootstrap.cpp
Unescape View File

@ -679,6 +679,8 @@ bool ProxySQL_Admin::init(const bootstrap_info_t& bootstrap_info) {
insert_into_tables_defs(tables_defs_stats,"stats_pgsql_free_connections", STATS_SQLITE_TABLE_PGSQL_FREE_CONNECTIONS);
insert_into_tables_defs(tables_defs_stats,"stats_pgsql_users", STATS_SQLITE_TABLE_PGSQL_USERS);
insert_into_tables_defs(tables_defs_stats,"stats_pgsql_processlist", STATS_SQLITE_TABLE_PGSQL_PROCESSLIST);
insert_into_tables_defs(tables_defs_stats,"stats_pgsql_errors", STATS_SQLITE_TABLE_PGSQL_ERRORS);
insert_into_tables_defs(tables_defs_stats,"stats_pgsql_errors_reset", STATS_SQLITE_TABLE_PGSQL_ERRORS_RESET);
// ProxySQL Cluster
insert_into_tables_defs(tables_defs_admin,"proxysql_servers", ADMIN_SQLITE_TABLE_PROXYSQL_SERVERS);

151
lib/PgSQL_HostGroups_Manager.cpp
Unescape View File

@ -1319,7 +1319,7 @@ bool PgSQL_HostGroups_Manager::commit(
if (atoi(r->fields[3])!=atoi(r->fields[12])) {
if (GloMTH->variables.hostgroup_manager_verbose)
proxy_debug(PROXY_DEBUG_MYSQL_CONNPOOL, 5, "Changing weight for server %d:%s:%d (%s:%d) from %d (%d) to %d\n" , mysrvc->myhgc->hid , mysrvc->address, mysrvc->port, r->fields[1], atoi(r->fields[2]), atoi(r->fields[3]) , mysrvc->weight , atoi(r->fields[12]));
proxy_debug(PROXY_DEBUG_MYSQL_CONNPOOL, 5, "Changing weight for server %d:%s:%d (%s:%d) from %d (%ld) to %d\n" , mysrvc->myhgc->hid , mysrvc->address, mysrvc->port, r->fields[1], atoi(r->fields[2]), atoi(r->fields[3]) , mysrvc->weight , atoi(r->fields[12]));
mysrvc->weight=atoi(r->fields[12]);
}
if (atoi(r->fields[4])!=atoi(r->fields[13])) {
@ -3950,53 +3950,48 @@ unsigned long long PgSQL_HostGroups_Manager::Get_Memory_Stats() {
return intsize;
}
class MySQL_Errors_stats {
public:
int hostgroup;
char *hostname;
int port;
char *username;
char *client_address;
char *schemaname;
int err_no;
char *last_error;
time_t first_seen;
time_t last_seen;
unsigned long long count_star;
MySQL_Errors_stats(int hostgroup_, char *hostname_, int port_, char *username_, char *address_, char *schemaname_, int err_no_, char *last_error_, time_t tn) {
hostgroup = hostgroup_;
if (hostname_) {
hostname = strdup(hostname_);
class PgSQL_Errors_stats {
public:
PgSQL_Errors_stats(int _hostgroup, const char *_hostname, int _port, const char *_username, const char *_address, const char *_dbname,
const char* _sqlstate, const char *_errmsg, time_t tn) {
hostgroup = _hostgroup;
if (_hostname) {
hostname = strdup(_hostname);
} else {
hostname = strdup((char *)"");
}
port = port_;
if (username_) {
username = strdup(username_);
port = _port;
if (_username) {
username = strdup(_username);
} else {
username = strdup((char *)"");
}
if (address_) {
client_address = strdup(address_);
if (_address) {
client_address = strdup(_address);
} else {
client_address = strdup((char *)"");
}
if (schemaname_) {
schemaname = strdup(schemaname_);
if (_dbname) {
dbname = strdup(_dbname);
} else {
dbname = strdup((char *)"");
}
if (_sqlstate) {
strncpy(sqlstate, _sqlstate, 5);
sqlstate[5] = '\0';
} else {
schemaname = strdup((char *)"");
sqlstate[0] = '\0';
}
err_no = err_no_;
if (last_error_) {
last_error = strdup(last_error_);
if (_errmsg) {
errmsg = strdup(_errmsg);
} else {
last_error = strdup((char *)"");
_errmsg = strdup((char *)"");
}
last_seen = tn;
first_seen = tn;
count_star = 1;
}
~MySQL_Errors_stats() {
~PgSQL_Errors_stats() {
if (hostname) {
free(hostname);
hostname=NULL;
@ -4009,13 +4004,13 @@ class MySQL_Errors_stats {
free(client_address);
client_address=NULL;
}
if (schemaname) {
free(schemaname);
schemaname=NULL;
if (dbname) {
free(dbname);
dbname=NULL;
}
if (last_error) {
free(last_error);
last_error=NULL;
if (errmsg) {
free(errmsg);
errmsg=NULL;
}
}
char **get_row() {
@ -4031,33 +4026,28 @@ class MySQL_Errors_stats {
pta[3]=strdup(username);
assert(client_address);
pta[4]=strdup(client_address);
assert(schemaname);
pta[5]=strdup(schemaname);
sprintf(buf,"%d",err_no);
pta[6]=strdup(buf);
assert(dbname);
pta[5]=strdup(dbname);
pta[6]=strdup(sqlstate);
sprintf(buf,"%llu",count_star);
pta[7]=strdup(buf);
sprintf(buf,"%ld", first_seen);
pta[8]=strdup(buf);
sprintf(buf,"%ld", last_seen);
pta[9]=strdup(buf);
assert(last_error);
pta[10]=strdup(last_error);
assert(errmsg);
pta[10]=strdup(errmsg);
return pta;
}
void add_time(unsigned long long n, char *le) {
void add_time(unsigned long long n, const char *le) {
count_star++;
if (first_seen==0) {
first_seen=n;
}
last_seen=n;
if (strcmp(last_error,le)){
free(last_error);
last_error=strdup(le);
if (strcmp(errmsg,le)){
free(errmsg);
errmsg=strdup(le);
}
}
void free_row(char **pta) {
@ -4068,13 +4058,25 @@ class MySQL_Errors_stats {
}
free(pta);
}
private:
int hostgroup;
char *hostname;
int port;
char *username;
char *client_address;
char *dbname;
char sqlstate[5+1];
char *errmsg;
time_t first_seen;
time_t last_seen;
unsigned long long count_star;
};
void PgSQL_HostGroups_Manager::add_pgsql_errors(int hostgroup, char *hostname, int port, char *username, char *address, char *schemaname, int err_no, char *last_error) {
void PgSQL_HostGroups_Manager::add_pgsql_errors(int hostgroup, const char *hostname, int port, const char *username, const char *address,
const char *dbname, const char* sqlstate, const char *errmsg) {
SpookyHash myhash;
uint64_t hash1;
uint64_t hash2;
MySQL_Errors_stats *mes = NULL;
size_t rand_del_len=strlen(rand_del);
time_t tn = time(NULL);
myhash.Init(11,4);
@ -4093,39 +4095,32 @@ void PgSQL_HostGroups_Manager::add_pgsql_errors(int hostgroup, char *hostname, i
myhash.Update(address,strlen(address));
}
myhash.Update(rand_del,rand_del_len);
if (schemaname) {
myhash.Update(schemaname,strlen(schemaname));
if (dbname) {
myhash.Update(dbname,strlen(dbname));
}
myhash.Update(rand_del,rand_del_len);
myhash.Update(&err_no,sizeof(err_no));
if (sqlstate) {
myhash.Update(sqlstate, strlen(sqlstate));
}
myhash.Final(&hash1,&hash2);
std::unordered_map<uint64_t, void *>::iterator it;
std::unordered_map<uint64_t, PgSQL_Errors_stats*>::iterator it;
pthread_mutex_lock(&pgsql_errors_mutex);
it=pgsql_errors_umap.find(hash1);
if (it != pgsql_errors_umap.end()) {
// found
mes=(MySQL_Errors_stats *)it->second;
mes->add_time(tn, last_error);
/*
mes->last_seen = tn;
if (strcmp(mes->last_error,last_error)) {
free(mes->last_error);
mes->last_error = strdup(last_error);
mes->count_star++;
}
*/
PgSQL_Errors_stats* err_stats = it->second;
err_stats->add_time(tn, errmsg);
} else {
mes = new MySQL_Errors_stats(hostgroup, hostname, port, username, address, schemaname, err_no, last_error, tn);
pgsql_errors_umap.insert(std::make_pair(hash1,(void *)mes));
PgSQL_Errors_stats* err_stats = new PgSQL_Errors_stats(hostgroup, hostname, port, username, address, dbname, sqlstate, errmsg, tn);
pgsql_errors_umap.insert(std::make_pair(hash1, err_stats));
}
pthread_mutex_unlock(&pgsql_errors_mutex);
}
SQLite3_result * PgSQL_HostGroups_Manager::get_pgsql_errors(bool reset) {
SQLite3_result* PgSQL_HostGroups_Manager::get_pgsql_errors(bool reset) {
SQLite3_result *result=new SQLite3_result(PgSQL_ERRORS_STATS_FIELD_NUM);
pthread_mutex_lock(&pgsql_errors_mutex);
result->add_column_definition(SQLITE_TEXT,"hid");
@ -4133,19 +4128,19 @@ SQLite3_result * PgSQL_HostGroups_Manager::get_pgsql_errors(bool reset) {
result->add_column_definition(SQLITE_TEXT,"port");
result->add_column_definition(SQLITE_TEXT,"username");
result->add_column_definition(SQLITE_TEXT,"client_address");
result->add_column_definition(SQLITE_TEXT,"schemaname");
result->add_column_definition(SQLITE_TEXT,"err_no");
result->add_column_definition(SQLITE_TEXT,"database");
result->add_column_definition(SQLITE_TEXT,"sqlstate");
result->add_column_definition(SQLITE_TEXT,"count_star");
result->add_column_definition(SQLITE_TEXT,"first_seen");
result->add_column_definition(SQLITE_TEXT,"last_seen");
result->add_column_definition(SQLITE_TEXT,"last_error");
for (std::unordered_map<uint64_t, void *>::iterator it=pgsql_errors_umap.begin(); it!=pgsql_errors_umap.end(); ++it) {
MySQL_Errors_stats *mes=(MySQL_Errors_stats *)it->second;
char **pta=mes->get_row();
for (std::unordered_map<uint64_t, PgSQL_Errors_stats*>::iterator it=pgsql_errors_umap.begin(); it!=pgsql_errors_umap.end(); ++it) {
PgSQL_Errors_stats *err_stats=it->second;
char **pta= err_stats->get_row();
result->add_row(pta);
mes->free_row(pta);
err_stats->free_row(pta);
if (reset) {
delete mes;
delete err_stats;
}
}
if (reset) {

7
lib/PgSQL_Session.cpp
Unescape View File

@ -4141,11 +4141,12 @@ bool PgSQL_Session::handler_minus1_ClientLibraryError(PgSQL_Data_Stream* myds) {
void PgSQL_Session::handler_minus1_LogErrorDuringQuery(PgSQL_Connection* myconn) {
if (pgsql_thread___verbose_query_error) {
proxy_warning("Error during query on (%d,%s,%d,%lu) , user \"%s@%s\" , dbname \"%s\" , %s . digest_text = \"%s\"\n", myconn->parent->myhgc->hid, myconn->parent->address, myconn->parent->port, myconn->get_mysql_thread_id(), client_myds->myconn->userinfo->username, (client_myds->addr.addr ? client_myds->addr.addr : (char*)"unknown"), client_myds->myconn->userinfo->dbname, myconn->get_error_code_with_message().c_str(), CurrentQuery.QueryParserArgs.digest_text);
}
else {
} else {
proxy_warning("Error during query on (%d,%s,%d,%lu): %s\n", myconn->parent->myhgc->hid, myconn->parent->address, myconn->parent->port, myconn->get_mysql_thread_id(), myconn->get_error_code_with_message().c_str());
}
PgHGM->add_pgsql_errors(myconn->parent->myhgc->hid, myconn->parent->address, myconn->parent->port, client_myds->myconn->userinfo->username, (client_myds->addr.addr ? client_myds->addr.addr : (char*)"unknown"), client_myds->myconn->userinfo->dbname, 9999, (char*)myconn->get_error_code_with_message().c_str());
PgHGM->add_pgsql_errors(myconn->parent->myhgc->hid, myconn->parent->address, myconn->parent->port, client_myds->myconn->userinfo->username,
(client_myds->addr.addr ? client_myds->addr.addr : "unknown"), client_myds->myconn->userinfo->dbname,
myconn->get_error_code_str(), myconn->get_error_message().c_str());
}

15
lib/ProxySQL_Admin.cpp
Unescape View File

@ -1144,6 +1144,8 @@ bool ProxySQL_Admin::GenericRefreshStatistics(const char *query_no_space, unsign
bool stats_mysql_query_digest_reset=false;
bool stats_mysql_errors=false;
bool stats_mysql_errors_reset=false;
bool stats_pgsql_errors = false;
bool stats_pgsql_errors_reset = false;
bool stats_mysql_global=false;
bool stats_memory_metrics=false;
bool stats_mysql_commands_counters=false;
@ -1245,6 +1247,10 @@ bool ProxySQL_Admin::GenericRefreshStatistics(const char *query_no_space, unsign
{ stats_mysql_errors=true; refresh=true; }
if (strstr(query_no_space,"stats_mysql_errors_reset"))
{ stats_mysql_errors_reset=true; refresh=true; }
if (strstr(query_no_space, "stats_pgsql_errors"))
{ stats_pgsql_errors = true; refresh = true; }
if (strstr(query_no_space, "stats_pgsql_errors_reset"))
{ stats_pgsql_errors_reset = true; refresh = true; }
if (strstr(query_no_space,"stats_mysql_global"))
{ stats_mysql_global=true; refresh=true; }
if (strstr(query_no_space, "stats_pgsql_global"))
@ -1429,6 +1435,12 @@ bool ProxySQL_Admin::GenericRefreshStatistics(const char *query_no_space, unsign
if (stats_mysql_errors_reset) {
stats___mysql_errors(true);
}
if (stats_pgsql_errors) {
stats___pgsql_errors(false);
}
if (stats_pgsql_errors_reset) {
stats___pgsql_errors(true);
}
if (stats_mysql_connection_pool_reset) {
stats___mysql_connection_pool(true);
} else {
@ -1612,7 +1624,8 @@ bool ProxySQL_Admin::GenericRefreshStatistics(const char *query_no_space, unsign
stats_mysql_commands_counters || stats_mysql_query_rules || stats_mysql_users ||
stats_mysql_gtid_executed || stats_mysql_free_connections ||
stats_pgsql_global || stats_pgsql_connection_pool || stats_pgsql_connection_pool_reset ||
stats_pgsql_free_connections || stats_pgsql_users || stats_pgsql_processlist
stats_pgsql_free_connections || stats_pgsql_users || stats_pgsql_processlist ||
stats_pgsql_errors || stats_pgsql_errors_reset
) {
ret = true;
}

79
lib/ProxySQL_Admin_Stats.cpp
Unescape View File

@ -1853,6 +1853,85 @@ void ProxySQL_Admin::stats___mysql_errors(bool reset) {
delete resultset;
}
void ProxySQL_Admin::stats___pgsql_errors(bool reset) {
if (!PgHGM) return;
SQLite3_result* resultset = PgHGM->get_pgsql_errors(reset);
if (resultset == NULL) return;
statsdb->execute("BEGIN");
int rc;
sqlite3_stmt* statement1 = NULL;
sqlite3_stmt* statement32 = NULL;
char* query1 = NULL;
char* query32 = NULL;
std::string query32s = "";
if (reset) {
statsdb->execute("DELETE FROM stats_pgsql_errors_reset");
}
else {
statsdb->execute("DELETE FROM stats_pgsql_errors");
}
if (reset) {
query1 = (char*)"INSERT INTO stats_pgsql_errors_reset VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)";
query32s = "INSERT INTO stats_pgsql_errors_reset VALUES " + generate_multi_rows_query(32, 11);
query32 = (char*)query32s.c_str();
}
else {
query1 = (char*)"INSERT INTO stats_pgsql_errors VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)";
query32s = "INSERT INTO stats_pgsql_errors VALUES " + generate_multi_rows_query(32, 11);
query32 = (char*)query32s.c_str();
}
rc = statsdb->prepare_v2(query1, &statement1);
ASSERT_SQLITE_OK(rc, statsdb);
rc = statsdb->prepare_v2(query32, &statement32);
ASSERT_SQLITE_OK(rc, statsdb);
int row_idx = 0;
int max_bulk_row_idx = resultset->rows_count / 32;
max_bulk_row_idx = max_bulk_row_idx * 32;
for (std::vector<SQLite3_row*>::iterator it = resultset->rows.begin(); it != resultset->rows.end(); ++it) {
SQLite3_row* r1 = *it;
int idx = row_idx % 32;
if (row_idx < max_bulk_row_idx) { // bulk
rc = (*proxy_sqlite3_bind_int64)(statement32, (idx * 11) + 1, atoll(r1->fields[0])); ASSERT_SQLITE_OK(rc, statsdb); // hid
rc = (*proxy_sqlite3_bind_text)(statement32, (idx * 11) + 2, r1->fields[1], -1, SQLITE_TRANSIENT); ASSERT_SQLITE_OK(rc, statsdb); // hostname
rc = (*proxy_sqlite3_bind_int64)(statement32, (idx * 11) + 3, atoll(r1->fields[2])); ASSERT_SQLITE_OK(rc, statsdb); // port
rc = (*proxy_sqlite3_bind_text)(statement32, (idx * 11) + 4, r1->fields[3], -1, SQLITE_TRANSIENT); ASSERT_SQLITE_OK(rc, statsdb); // username
rc = (*proxy_sqlite3_bind_text)(statement32, (idx * 11) + 5, r1->fields[4], -1, SQLITE_TRANSIENT); ASSERT_SQLITE_OK(rc, statsdb); // client_address
rc = (*proxy_sqlite3_bind_text)(statement32, (idx * 11) + 6, r1->fields[5], -1, SQLITE_TRANSIENT); ASSERT_SQLITE_OK(rc, statsdb); // database
rc = (*proxy_sqlite3_bind_text)(statement32, (idx * 11) + 7, r1->fields[6], -1, SQLITE_TRANSIENT); ASSERT_SQLITE_OK(rc, statsdb); // sqlstate
rc = (*proxy_sqlite3_bind_int64)(statement32, (idx * 11) + 8, atoll(r1->fields[7])); ASSERT_SQLITE_OK(rc, statsdb); // count_star
rc = (*proxy_sqlite3_bind_int64)(statement32, (idx * 11) + 9, atoll(r1->fields[8])); ASSERT_SQLITE_OK(rc, statsdb); // first_seen
rc = (*proxy_sqlite3_bind_int64)(statement32, (idx * 11) + 10, atoll(r1->fields[9])); ASSERT_SQLITE_OK(rc, statsdb); // last_seen
rc = (*proxy_sqlite3_bind_text)(statement32, (idx * 11) + 11, r1->fields[10], -1, SQLITE_TRANSIENT); ASSERT_SQLITE_OK(rc, statsdb); // last_error
if (idx == 31) {
SAFE_SQLITE3_STEP2(statement32);
rc = (*proxy_sqlite3_clear_bindings)(statement32); //ASSERT_SQLITE_OK(rc, statsdb);
rc = (*proxy_sqlite3_reset)(statement32); //ASSERT_SQLITE_OK(rc, statsdb);
}
} else { // single row
rc = (*proxy_sqlite3_bind_int64)(statement1, 1, atoll(r1->fields[0])); ASSERT_SQLITE_OK(rc, statsdb); // hid
rc = (*proxy_sqlite3_bind_text)(statement1, 2, r1->fields[1], -1, SQLITE_TRANSIENT); ASSERT_SQLITE_OK(rc, statsdb); // hostname
rc = (*proxy_sqlite3_bind_int64)(statement1, 3, atoll(r1->fields[2])); ASSERT_SQLITE_OK(rc, statsdb); // port
rc = (*proxy_sqlite3_bind_text)(statement1, 4, r1->fields[3], -1, SQLITE_TRANSIENT); ASSERT_SQLITE_OK(rc, statsdb); // username
rc = (*proxy_sqlite3_bind_text)(statement1, 5, r1->fields[4], -1, SQLITE_TRANSIENT); ASSERT_SQLITE_OK(rc, statsdb); // client_address
rc = (*proxy_sqlite3_bind_text)(statement1, 6, r1->fields[5], -1, SQLITE_TRANSIENT); ASSERT_SQLITE_OK(rc, statsdb); // database
rc = (*proxy_sqlite3_bind_text)(statement1, 7, r1->fields[6], -1, SQLITE_TRANSIENT); ASSERT_SQLITE_OK(rc, statsdb); // sqlstate
rc = (*proxy_sqlite3_bind_int64)(statement1, 8, atoll(r1->fields[7])); ASSERT_SQLITE_OK(rc, statsdb); // count_star
rc = (*proxy_sqlite3_bind_int64)(statement1, 9, atoll(r1->fields[8])); ASSERT_SQLITE_OK(rc, statsdb); // first_seen
rc = (*proxy_sqlite3_bind_int64)(statement1, 10, atoll(r1->fields[9])); ASSERT_SQLITE_OK(rc, statsdb); // last_seen
rc = (*proxy_sqlite3_bind_text)(statement1, 11, r1->fields[10], -1, SQLITE_TRANSIENT); ASSERT_SQLITE_OK(rc, statsdb); // last_error
SAFE_SQLITE3_STEP2(statement1);
rc = (*proxy_sqlite3_clear_bindings)(statement1); //ASSERT_SQLITE_OK(rc, statsdb);
rc = (*proxy_sqlite3_reset)(statement1); //ASSERT_SQLITE_OK(rc, statsdb);
}
row_idx++;
}
(*proxy_sqlite3_finalize)(statement1);
(*proxy_sqlite3_finalize)(statement32);
statsdb->execute("COMMIT");
delete resultset;
}
void ProxySQL_Admin::stats___mysql_users() {
account_details_t **ads=NULL;
statsdb->execute("DELETE FROM stats_mysql_users");

Write Preview
Loading…
Cancel
Save