void PgTblPlnrQDtpAPar::removeRstByJref(
ubigint jref
) {
PGresult* res;
ubigint _jref = htonl64(jref);
const char* vals[] = {
(char*) &_jref
};
const int l[] = {
sizeof(ubigint)
};
const int f[] = {1};
res = PQexecPrepared(dbs, "TblPlnrQDtpAPar_removeRstByJref", 1, vals, l, f, 0);
if (PQresultStatus(res) != PGRES_COMMAND_OK)
throw DbsException("DbsException / PgSQL: error executing statement! (TblPlnrQDtpAPar_removeRstByJref)\n");
PQclear(res);
};
void PgTblFmncRMFileMSample::removeRecByRef(
ubigint ref
) {
PGresult* res;
ubigint _ref = htonl64(ref);
const char* vals[] = {
(char*) &_ref
};
const int l[] = {
sizeof(ubigint)
};
const int f[] = {1};
res = PQexecPrepared(dbs, "TblFmncRMFileMSample_removeRecByRef", 1, vals, l, f, 0);
if (PQresultStatus(res) != PGRES_COMMAND_OK)
throw DbsException("DbsException / PgSQL: error executing statement! (TblFmncRMFileMSample_removeRecByRef)\n");
PQclear(res);
};
int DeviceAgent::sendData(uint32_t action,QByteArray *data)
{
pthread_mutex_lock(&conn_mutex);
DEBUG_INFO << "Enter";
NetPackageHdr hdr;
hdr.TAG = htonl(action);
if (data != NULL && data->length() > 0)
{
hdr.data_len = htonl64(data->length());
}
else
{
hdr.data_len = 0;
}
if (sizeof(NetPackageHdr) != write( (char *)&hdr,sizeof(NetPackageHdr)))\
{
pthread_mutex_unlock(&conn_mutex);
return PL_RET_FAIL;
}
if (data == NULL || data->length() == 0)
{
//flush();
pthread_mutex_unlock(&conn_mutex);
return PL_RET_OK;
}
if (data->length() != write(*data))
{
pthread_mutex_unlock(&conn_mutex);
return PL_RET_FAIL;
}
//flush();
pthread_mutex_unlock(&conn_mutex);
return PL_RET_OK;
}
bool PgTblPlnrMStructure::loadRefByHktHkuSrf(
uint hkIxVTbl
, ubigint hkUref
, string sref
, ubigint& val
) {
uint _hkIxVTbl = htonl(hkIxVTbl);
ubigint _hkUref = htonl64(hkUref);
const char* vals[] = {
(char*) &_hkIxVTbl,
(char*) &_hkUref,
sref.c_str()
};
const int l[] = {
sizeof(uint),
sizeof(ubigint),
0
};
const int f[] = {1,1,0};
return loadUbigintByStmt("TblPlnrMStructure_loadRefByHktHkuSrf", 3, vals, l, f, val);
};
void PgTblPlnrQRtcList::updateRec(
PlnrQRtcList* rec
) {
PGresult* res;
ubigint _jref = htonl64(rec->jref);
uint _jnum = htonl(rec->jnum);
ubigint _ref = htonl64(rec->ref);
uint _hkIxVTbl = htonl(rec->hkIxVTbl);
ubigint _hkUref = htonl64(rec->hkUref);
ubigint _refPlnrMDesign = htonl64(rec->refPlnrMDesign);
ubigint _refPlnrMLayer = htonl64(rec->refPlnrMLayer);
ubigint _qref = htonl64(rec->qref);
const char* vals[] = {
(char*) &_jref,
(char*) &_jnum,
(char*) &_ref,
rec->sref.c_str(),
(char*) &_hkIxVTbl,
(char*) &_hkUref,
(char*) &_refPlnrMDesign,
(char*) &_refPlnrMLayer,
(char*) &_qref
};
const int l[] = {
sizeof(ubigint),
sizeof(uint),
sizeof(ubigint),
0,
sizeof(uint),
sizeof(ubigint),
sizeof(ubigint),
sizeof(ubigint),
sizeof(ubigint)
};
const int f[] = {1, 1, 1, 0, 1, 1, 1, 1, 1};
res = PQexecPrepared(dbs, "TblPlnrQRtcList_updateRec", 9, vals, l, f, 0);
if (PQresultStatus(res) != PGRES_COMMAND_OK) throw DbsException("DbsException / PgSQL: error executing statement! (TblPlnrQRtcList_updateRec)\n");
PQclear(res);
};
static void insert_row(DB_ENV *db_env, struct table *t, DB_TXN *txn, long a, long b, long c, long d) {
int r;
// generate the primary key
char key_buffer[8];
a = htonl64(a);
memcpy(key_buffer, &a, sizeof a);
// generate the primary value
char val_buffer[3*8];
b = htonl64(b);
memcpy(val_buffer+0, &b, sizeof b);
c = htonl64(c);
memcpy(val_buffer+8, &c, sizeof c);
d = htonl64(d);
memcpy(val_buffer+16, &d, sizeof d);
DBT key = { .data = key_buffer, .size = sizeof key_buffer };
DBT value = { .data = val_buffer, .size = sizeof val_buffer };
#if defined(TOKUDB)
if (!force_multiple && t->ndbs == 1) {
r = t->dbs[0]->put(t->dbs[0], txn, &key, &value, t->mult_flags[0]); assert(r == 0);
} else {
r = db_env->put_multiple(db_env, t->dbs[0], txn, &key, &value, t->ndbs, &t->dbs[0], t->mult_keys, t->mult_vals, t->mult_flags); assert(r == 0);
}
#else
assert(db_env);
r = t->dbs[0]->put(t->dbs[0], txn, &key, &value, 0); assert(r == 0);
#endif
}
static inline float tdiff (struct timeval *a, struct timeval *b) {
return (a->tv_sec - b->tv_sec) +1e-6*(a->tv_usec - b->tv_usec);
}
static void insert_all(DB_ENV *db_env, struct table *t, long nrows, long max_rows_per_txn, long key_range, long rows_per_report, bool do_txn) {
int r;
struct timeval tstart;
r = gettimeofday(&tstart, NULL); assert(r == 0);
struct timeval tlast = tstart;
DB_TXN *txn = NULL;
if (do_txn) {
r = db_env->txn_begin(db_env, NULL, &txn, 0); assert(r == 0);
}
long n_rows_per_txn = 0;
long rowi;
for (rowi = 0; rowi < nrows; rowi++) {
long a = rowi;
long b = random64() % key_range;
long c = random64() % key_range;
long d = random64() % key_range;
insert_row(db_env, t, txn, a, b, c, d);
n_rows_per_txn++;
// maybe commit
if (do_txn && n_rows_per_txn == max_rows_per_txn) {
r = txn->commit(txn, 0); assert(r == 0);
r = db_env->txn_begin(db_env, NULL, &txn, 0); assert(r == 0);
n_rows_per_txn = 0;
}
// maybe report performance
if (((rowi + 1) % rows_per_report) == 0) {
struct timeval tnow;
r = gettimeofday(&tnow, NULL); assert(r == 0);
float last_time = tdiff(&tnow, &tlast);
float total_time = tdiff(&tnow, &tstart);
printf("%ld %.3f %.0f/s %.0f/s\n", rowi + 1, last_time, rows_per_report/last_time, rowi/total_time); fflush(stdout);
tlast = tnow;
}
}
if (do_txn) {
r = txn->commit(txn, 0); assert(r == 0);
}
struct timeval tnow;
r = gettimeofday(&tnow, NULL); assert(r == 0);
printf("total %ld %.3f %.0f/s\n", nrows, tdiff(&tnow, &tstart), nrows/tdiff(&tnow, &tstart)); fflush(stdout);
}
int main(int argc, char *argv[]) {
#if defined(TOKDUB)
char *db_env_dir = "insertm.env.tokudb";
#else
char *db_env_dir = "insertm.env.bdb";
#endif
int db_env_open_flags = DB_CREATE | DB_PRIVATE | DB_INIT_MPOOL | DB_INIT_TXN | DB_INIT_LOCK | DB_INIT_LOG;
long rows = 100000000;
long rows_per_txn = 1000;
long rows_per_report = 100000;
long key_range = 100000;
bool do_txn = true;
u_int32_t pagesize = 0;
u_int64_t cachesize = 1000000000;
int ndbs = 4;
#if defined(TOKUDB)
u_int32_t checkpoint_period = 60;
#endif
int i;
for (i = 1; i < argc; i++) {
char *arg = argv[i];
if (strcmp(arg, "--verbose") == 0) {
verbose++;
continue;
}
if (strcmp(arg, "--ndbs") == 0 && i+1 < argc) {
ndbs = atoi(argv[++i]);
continue;
}
if (strcmp(arg, "--rows") == 0 && i+1 < argc) {
rows = atol(argv[++i]);
continue;
}
if (strcmp(arg, "--rows_per_txn") == 0 && i+1 < argc) {
rows_per_txn = atol(argv[++i]);
continue;
}
if (strcmp(arg, "--rows_per_report") == 0 && i+1 < argc) {
rows_per_report = atol(argv[++i]);
continue;
}
if (strcmp(arg, "--key_range") == 0 && i+1 < argc) {
key_range = atol(argv[++i]);
continue;
}
if (strcmp(arg, "--txn") == 0 && i+1 < argc) {
do_txn = atoi(argv[++i]);
continue;
}
if (strcmp(arg, "--pagesize") == 0 && i+1 < argc) {
pagesize = atoi(argv[++i]);
continue;
}
if (strcmp(arg, "--cachesize") == 0 && i+1 < argc) {
cachesize = atol(argv[++i]);
continue;
}
if (strcmp(arg, "--force_multiple") == 0 && i+1 < argc) {
force_multiple = atoi(argv[++i]);
continue;
}
#if defined(TOKUDB)
if (strcmp(arg, "--checkpoint_period") == 0 && i+1 < argc) {
checkpoint_period = atoi(argv[++i]);
continue;
}
#endif
assert(0);
}
int r;
char rm_cmd[strlen(db_env_dir) + strlen("rm -rf ") + 1];
snprintf(rm_cmd, sizeof(rm_cmd), "rm -rf %s", db_env_dir);
r = system(rm_cmd); assert(r == 0);
r = mkdir(db_env_dir, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH); assert(r == 0);
// create and open the env
DB_ENV *db_env = NULL;
r = db_env_create(&db_env, 0); assert(r == 0);
if (!do_txn)
db_env_open_flags &= ~(DB_INIT_TXN | DB_INIT_LOG);
if (cachesize) {
const u_int64_t gig = 1 << 30;
r = db_env->set_cachesize(db_env, cachesize / gig, cachesize % gig, 1); assert(r == 0);
}
#if defined(TOKUDB)
r = db_env->set_generate_row_callback_for_put(db_env, my_generate_row_for_put); assert(r == 0);
#endif
r = db_env->open(db_env, db_env_dir, db_env_open_flags, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); assert(r == 0);
#if defined(TOKUDB)
if (checkpoint_period) {
r = db_env->checkpointing_set_period(db_env, checkpoint_period); assert(r == 0);
u_int32_t period;
r = db_env->checkpointing_get_period(db_env, &period); assert(r == 0 && period == checkpoint_period);
}
#endif
// create the db
DB *dbs[ndbs];
for (i = 0; i < ndbs; i++) {
DB *db = NULL;
r = db_create(&db, db_env, 0); assert(r == 0);
DB_TXN *create_txn = NULL;
if (do_txn) {
r = db_env->txn_begin(db_env, NULL, &create_txn, 0); assert(r == 0);
}
if (pagesize) {
r = db->set_pagesize(db, pagesize); assert(r == 0);
}
char db_filename[32]; sprintf(db_filename, "test%d", i);
r = db->open(db, create_txn, db_filename, NULL, DB_BTREE, DB_CREATE, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); assert(r == 0);
#if defined(TOKUDB)
DESCRIPTOR_S new_descriptor;
int index_num = htonl(i);
new_descriptor.dbt.data = &index_num;
new_descriptor.dbt.size = sizeof i;
r = db->change_descriptor(db, create_txn, &new_descriptor.dbt, 0); assert(r == 0);
#else
db->app_private = (void *) (intptr_t) i;
if (i > 0) {
r = dbs[0]->associate(dbs[0], create_txn, db, my_secondary_key, 0); assert(r == 0);
}
#endif
if (do_txn) {
r = create_txn->commit(create_txn, 0); assert(r == 0);
}
dbs[i] = db;
}
// insert all rows
struct table table;
table_init(&table, ndbs, dbs, 4 * 8, 4 * 8);
insert_all(db_env, &table, rows, rows_per_txn, key_range, rows_per_report, do_txn);
table_destroy(&table);
// shutdown
for (i = 0; i < ndbs; i++) {
DB *db = dbs[i];
r = db->close(db, 0); assert(r == 0); db = NULL;
}
r = db_env->close(db_env, 0); assert(r == 0); db_env = NULL;
return 0;
}
int DeviceAgent::sendFile(uint32_t action,QString &localFileName,QString &dstFileName)
{
pthread_mutex_lock(&conn_mutex);
if (dstFileName.isEmpty() || localFileName.isEmpty())
{
DEBUG_INFO << "fileName is invalid";
pthread_mutex_unlock(&conn_mutex);
return PL_RET_FAIL;
}
QFile file;
file.setFileName(localFileName);
if (!file.open(QIODevice::ReadOnly) || file.size() < 1)
{
DEBUG_INFO << "Failed to open file:" + localFileName;
pthread_mutex_unlock(&conn_mutex);
return PL_RET_FAIL;
}
QJsonObject cmd;
cmd.insert("path",localFileName);
cmd.insert("dstPath",dstFileName);
QJsonDocument doc(cmd);
QByteArray jsonData = doc.toJson(QJsonDocument::Compact);
uint32_t len = jsonData.size();
NetPackageHdr hdr;
hdr.TAG = htonl(action);
hdr.data_len = htonl64(file.size() + len);
if (sizeof(NetPackageHdr) != write( (char *)&hdr,sizeof(NetPackageHdr)))\
{
file.close();
pthread_mutex_unlock(&conn_mutex);
return PL_RET_FAIL;
}
//flush();
uint32_t nlen = htonl(len);
if (sizeof(nlen) != write((char*)&nlen,sizeof(nlen)))
{
file.close();
pthread_mutex_unlock(&conn_mutex);
return PL_RET_FAIL;
}
if (len != write(jsonData))
{
file.close();
pthread_mutex_unlock(&conn_mutex);
return PL_RET_FAIL;
}
qint64 fLen = file.size();
qint64 fTotal = fLen;
int iRead = 0;
char buf[10240];
emit busyMessage("Sendd file...");
while (fLen > 0 && (iRead = file.read(buf,10240)) > 0)
{
if (iRead != write(buf,iRead))
{
file.close();
pthread_mutex_unlock(&conn_mutex);
return PL_RET_FAIL;
}
fLen -= iRead;
if (++m_iLoopCounter % 100 == 0)
{
//flush();
QApplication::processEvents();
QString info = QString("Sending file %1% left").arg((fLen * 100)/fTotal);
emit busyMessage(info);
}
}
//flush();
emit busyMessage("Send file done,wait response from device...");
file.close();
if (fLen != 0)
{
pthread_mutex_unlock(&conn_mutex);
return PL_RET_FAIL;
}
pthread_mutex_unlock(&conn_mutex);
return PL_RET_OK;
}
