bool Query_Processor::insert(QP_rule_t *qr, bool lock) {
bool ret=true;
if (lock) spin_wrlock(&rwlock);
rules.push_back(qr);
if (lock) spin_wrunlock(&rwlock);
return ret;
};
void KV_BtreeArray::empty() {
spin_wrlock(&lock);
btree::btree_map<uint64_t, QC_entry_t *>::iterator lookup;
while (bt_map.size()) {
lookup = bt_map.begin();
if ( lookup != bt_map.end() ) {
lookup->second->expire_ms=EXPIRE_DROPIT;
//const char *f=lookup->first;
bt_map.erase(lookup);
}
}
spin_wrunlock(&lock);
};
void KV_BtreeArray::purge_some(unsigned long long QCnow_ms) {
uint64_t ret=0, i, _size=0;
QC_entry_t *qce;
spin_rdlock(&lock);
for (i=0; i<ptrArray->len;i++) {
qce=(QC_entry_t *)ptrArray->index(i);
if (qce->expire_ms==EXPIRE_DROPIT || qce->expire_ms<QCnow_ms) {
ret++;
_size+=qce->length;
}
}
freeable_memory=_size;
spin_rdunlock(&lock);
if ( (freeable_memory + ret * (sizeof(QC_entry_t)+sizeof(QC_entry_t *)*2+sizeof(uint64_t)*2) ) > get_data_size()*0.01) {
uint64_t removed_entries=0;
uint64_t freed_memory=0;
spin_wrlock(&lock);
for (i=0; i<ptrArray->len;i++) {
qce=(QC_entry_t *)ptrArray->index(i);
if ((qce->expire_ms==EXPIRE_DROPIT || qce->expire_ms<QCnow_ms) && (__sync_fetch_and_add(&qce->ref_count,0)<=1)) {
qce=(QC_entry_t *)ptrArray->remove_index_fast(i);
btree::btree_map<uint64_t, QC_entry_t *>::iterator lookup;
lookup = bt_map.find(qce->key);
if (lookup != bt_map.end()) {
bt_map.erase(lookup);
}
i--;
freed_memory+=qce->length;
removed_entries++;
free(qce->value);
free(qce);
}
}
spin_wrunlock(&lock);
THR_DECREASE_CNT(__thr_num_deleted,Glo_num_entries,removed_entries,1);
if (removed_entries) {
__sync_fetch_and_add(&Glo_total_freed_memory,freed_memory);
__sync_fetch_and_sub(&Glo_size_values,freed_memory);
__sync_fetch_and_add(&Glo_cntPurge,removed_entries);
// if (removed_entries) fprintf(stderr,"Removed: %lu, total: %lu, arraylen: %d\n", removed_entries, __sync_fetch_and_sub(&Glo_num_entries,0), ptrArray.len);
// if (removed_entries) firintf(stderr,"Size of KVBtreeArray:%d , freed_memory:%lu, Glo_cntGet:%lu, Glo_cntGetOK:%lu, Glo_cntSet:%lu, cntPurge:%lu, dataIN:%lu, dataOUT:%lu\n", cnt() , Glo_total_freed_memory, Glo_cntGet, Glo_cntGetOK, Glo_cntSet, Glo_cntPurge, Glo_dataIN, Glo_dataOUT);
}
}
};
void Query_Processor::update_query_digest(void *p, MySQL_Connection_userinfo *ui, unsigned long long t, unsigned long long n) {
SQP_par_t *qp=(SQP_par_t *)p;
spin_wrlock(&digest_rwlock);
QP_query_digest_stats *qds;
btree::btree_map<uint64_t, void *>::iterator it;
it=digest_bt_map.find(qp->digest_total);
if (it != digest_bt_map.end()) {
// found
qds=(QP_query_digest_stats *)it->second;
qds->add_time(t,n);
} else {
qds=new QP_query_digest_stats(ui->username, ui->schemaname, qp->digest, qp->digest_text);
qds->add_time(t,n);
digest_bt_map.insert(std::make_pair(qp->digest_total,(void *)qds));
}
spin_wrunlock(&digest_rwlock);
}
bool KV_BtreeArray::replace(uint64_t key, QC_entry_t *entry) {
spin_wrlock(&lock);
THR_UPDATE_CNT(__thr_cntSet,Glo_cntSet,1,100);
THR_UPDATE_CNT(__thr_size_values,Glo_size_values,entry->length,100);
THR_UPDATE_CNT(__thr_dataIN,Glo_dataIN,entry->length,100);
THR_UPDATE_CNT(__thr_num_entries,Glo_num_entries,1,1);
entry->ref_count=1;
ptrArray->add(entry);
btree::btree_map<uint64_t, QC_entry_t *>::iterator lookup;
lookup = bt_map.find(key);
if (lookup != bt_map.end()) {
lookup->second->expire_ms=EXPIRE_DROPIT;
__sync_fetch_and_sub(&lookup->second->ref_count,1);
bt_map.erase(lookup);
}
bt_map.insert(std::make_pair(key,entry));
spin_wrunlock(&lock);
return true;
}
SQLite3_result * Query_Processor::get_query_digests_reset() {
SQLite3_result *result=new SQLite3_result(10);
spin_wrlock(&digest_rwlock);
result->add_column_definition(SQLITE_TEXT,"schemaname");
result->add_column_definition(SQLITE_TEXT,"usernname");
result->add_column_definition(SQLITE_TEXT,"digest");
result->add_column_definition(SQLITE_TEXT,"digest_text");
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,"sum_time");
result->add_column_definition(SQLITE_TEXT,"min_time");
result->add_column_definition(SQLITE_TEXT,"max_time");
for (btree::btree_map<uint64_t, void *>::iterator it=digest_bt_map.begin(); it!=digest_bt_map.end(); ++it) {
QP_query_digest_stats *qds=(QP_query_digest_stats *)it->second;
char **pta=qds->get_row();
result->add_row(pta);
qds->free_row(pta);
delete qds;
}
digest_bt_map.erase(digest_bt_map.begin(),digest_bt_map.end());
spin_wrunlock(&digest_rwlock);
return result;
}
// when commit is called, the version number is increased and the this will trigger the mysql threads to get a new Query Processor Table
// The operation is asynchronous
void Query_Processor::commit() {
spin_wrlock(&rwlock);
__sync_add_and_fetch(&version,1);
proxy_debug(PROXY_DEBUG_MYSQL_QUERY_PROCESSOR, 4, "Increasing version number to %d - all threads will notice this and refresh their rules\n", version);
spin_wrunlock(&rwlock);
};
void Query_Processor::sort(bool lock) {
if (lock) spin_wrlock(&rwlock);
proxy_debug(PROXY_DEBUG_MYSQL_QUERY_PROCESSOR, 4, "Sorting rules\n");
std::sort (rules.begin(), rules.end(), rules_sort_comp_function);
if (lock) spin_wrunlock(&rwlock);
};
void Query_Processor::reset_all(bool lock) {
if (lock) spin_wrlock(&rwlock);
__reset_rules(&rules);
if (lock) spin_wrunlock(&rwlock);
};
void Query_Processor::wrunlock() {
spin_wrunlock(&rwlock);
};
void SQLite3DB::wrunlock() {
spin_wrunlock(&rwlock);
}
void MySQL_Logger::wrunlock() {
spin_wrunlock(&rwlock);
};
