int inserir(cliente c) {
char sql_insert = "INSERT INTO clientes VALUES(?, ?, ?, ?, ?, ?, ?, ?);";
int r = connect_db();
if (r != SQLITE_OK) {
fprintf(stderr, "Erro ao conectar com o banco de dados!! %s\n", sqlite3_errmsg(conn));
close_db();
return 0;
} else {
msg = sqlite3_exec(conn, sql_insert, callback, 0, &errMsg);
if (msg != SQLITE_OK) {
fprintf(stderr, "Não foi possivel executar comando!! %s\n", errMsg);
close_db();
return 0;
} else {
sqlite3_bind_null(stmt, 1);
sqlite3_bind_int(stmt, 2, c.id_cliente);
sqlite3_bind_text(stmt, 3, c.nome_cliente, strlen(c.nome_cliente), 0);
sqlite3_bind_text(stmt, 4, c.localizacao, strlen(c.localizacao), 0);
sqlite3_bind_text(stmt, 5, c.email, strlen(c.email), 0);
sqlite3_bind_text(stmt, 6, c.aniversario, strlen(c.aniversario), 0);
sqlite3_bind_text(stmt, 7, c.link, strlen(c.link), 0);
}
close_db();
return 1;
}
}
/**
* Esse método cria as tabelas de clientes e log_usuários caso elas não existam.
* @return
*/
int criar_tabelas() {
char sql_cliente = "CREATE TABLE IF NOT EXISTS clientes (id INTEGER PRIMARY KEY ASC NOT NULL, id_cliente INTEGER, nome_cliente VARCHAR(100), localizacao VARCHAR[255], email VARCHAR[50], aniversario VARCHAR[12], link VARCHAR[255]);";
char sql_log_usuario = "CREATE TABLE IF NOT EXISTS log_usuario (id INTEGER NOT NULL PRIMARY KEY, created_at DATETIME NOT NULL, fk_id INTEGER NOT NULL, FOREIGN KEY (fk_id) REFERENCES cliente(id));";
int resposta = connectar_banco();
if (resposta != SQLITE_OK) {
fprintf(stdout, "Não foi possivel conectar ao banco de dados: %s\n", sqlite3_errmsg(conn));
close_db();
return 0;
} else {
msg = sqlite3_exec(conn, sql_cliente, callback, 0, 0);
if (msg != SQLITE_OK) {
fprintf(stdout, "Não foi posível criar a tabela clientes: %s\n", sqlite3_errmsg(conn));
close_db();
return 0;
} else {
msg = sqlite3_exec(conn, sql_log_usuario, callback, 0, 0);
if (msg != SQLITE_OK) {
fprintf(stdout, "Não foi posível criar a tabela log_usuário: %s\n", sqlite3_errmsg(conn));
close_db();
return 0;
} else {
close_db();
return 1;
}
}
}
}
int atualizar(cliente c) {
sql_update = "UPDATE clientes SET nome_cliente = ?, localizacao = ?, email = ?, aniversario = ?, link = ? WHERE id_cliente = ?;";
int r = connect_db();
if (r != SQLITE_OK) {
fprintf(stderr, "Erro ao conectar com o banco de dados!! %s\n", sqlite3_errmsg(conn));
close_db();
return 0;
} else {
msg = sqlite3_exec(conn, sql_update, callback, 0, &errMsg);
if (msg != SQLITE_OK) {
fprintf(stderr, "Não foi possivel executar comando!! %s\n", errMsg);
close_db();
return 0;
} else {
sqlite3_bind_text(stmt, 1, c.nome_cliente, strlen(c.nome_cliente), 0);
sqlite3_bind_text(stmt, 2, c.localizacao, strlen(c.localizacao), 0);
sqlite3_bind_text(stmt, 3, c.email, strlen(c.email), 0);
sqlite3_bind_text(stmt, 4, c.aniversario, strlen(c.aniversario), 0);
sqlite3_bind_text(stmt, 5, c.link, strlen(c.link), 0);
sqlite3_bind_int(stmt, 6, c.id_cliente);
}
close_db();
return 1;
}
}
int TestPartOneKeyNoData(CuTest *ct) {
DB_ENV *dbenv;
DB *dbp;
/* Allocate the memory from stack. */
DBT keys[4];
u_int32_t i;
dbenv = NULL;
dbp = NULL;
nparts = 5;
/* Do not assign any data to the first DBT. */
memset(&keys[0], 0, sizeof(DBT));
for (i = 1 ; i < (nparts - 1); i++) {
memset(&keys[i], 0, sizeof(DBT));
keys[i].data = &content[(i + 1) * (strlen(content) / nparts)];
keys[i].size = sizeof(char);
}
/* Do not set any database flags. */
CuAssertTrue(ct, create_db(&dbenv, &dbp, 0, ct) == 0);
/*
* Verify that before the database is opened, DB->set_partition can
* be called multiple times regardless of its return code.
*/
keys[0].flags = DB_DBT_MALLOC;
CuAssertTrue(ct, dbp->set_partition(dbp, nparts, keys, NULL) != 0);
keys[0].flags = 0;
CuAssertTrue(ct, dbp->set_partition(dbp, nparts, keys, NULL) == 0);
CuAssertTrue(ct, dbp->set_partition(dbp, nparts, keys, NULL) == 0);
CuAssertTrue(ct, dbp->open(dbp, NULL,
"test.db", NULL, DB_BTREE, DB_CREATE, 0644) != 0);
CuAssertTrue(ct, close_db(dbenv, dbp, ct) == 0);
fclose(errfp);
errfp = NULL;
/* Set DB_DUPSORT flags. */
setup_envdir(TEST_ENV, 1);
errfp = fopen("TESTDIR/errfile", "w");
CuAssertTrue(ct, create_db(&dbenv, &dbp, 0, ct) == 0);
CuAssertTrue(ct, dbp->set_partition(dbp, nparts, keys, NULL) == 0);
CuAssertTrue(ct, dbp->set_flags(dbp, DB_DUPSORT) == 0);
CuAssertTrue(ct, dbp->open(dbp, NULL,
"test.db", NULL, DB_BTREE, DB_CREATE, 0644) != 0);
CuAssertTrue(ct, close_db(dbenv, dbp, ct) == 0);
fclose(errfp);
errfp = NULL;
/* Set DB_DUP flags. */
setup_envdir(TEST_ENV, 1);
CuAssertTrue(ct, create_db(&dbenv, &dbp, 0, ct) == 0);
CuAssertTrue(ct, dbp->set_partition(dbp, nparts, keys, NULL) == 0);
CuAssertTrue(ct, dbp->set_flags(dbp, DB_DUP) == 0);
CuAssertTrue(ct, dbp->open(dbp, NULL,
"test.db", NULL, DB_BTREE, DB_CREATE, 0644) == 0);
CuAssertTrue(ct, put_data(dbp) == 0);
CuAssertTrue(ct, close_db(dbenv, dbp, ct) == 0);
return (0);
}
int TestPartDuplicatedKey(CuTest *ct) {
DB_ENV *dbenv;
DB *dbp;
DBT *keys;
u_int32_t i;
dbenv = NULL;
dbp = NULL;
keys = NULL;
nparts = 5;
CuAssertTrue(ct, (keys = malloc((nparts - 1) * sizeof(DBT))) != NULL);
memset(keys, 0, (nparts - 1) * sizeof(DBT));
/* Assign the same data to the first 2 DBTs. */
for (i = 0 ; i < (nparts - 1); i++) {
if (i < 2)
keys[i].data = &content[strlen(content) / nparts];
else
keys[i].data = &content[(i + 1) *
(strlen(content) / nparts)];
keys[i].size = sizeof(char);
}
/* Do not set any database flags. */
CuAssertTrue(ct, create_db(&dbenv, &dbp, 0, ct) == 0);
CuAssertTrue(ct, dbp->set_partition(dbp, nparts, keys, NULL) == 0);
CuAssertTrue(ct, dbp->open(dbp, NULL,
"test.db", NULL, DB_BTREE, DB_CREATE, 0644) != 0);
CuAssertTrue(ct, close_db(dbenv, dbp, ct) == 0);
fclose(errfp);
errfp = NULL;
/* Set DB_DUPSORT flags. */
setup_envdir(TEST_ENV, 1);
errfp = fopen("TESTDIR/errfile", "w");
CuAssertTrue(ct, create_db(&dbenv, &dbp, 0, ct) == 0);
CuAssertTrue(ct, dbp->set_partition(dbp, nparts, keys, NULL) == 0);
CuAssertTrue(ct, dbp->set_flags(dbp, DB_DUPSORT) == 0);
CuAssertTrue(ct, dbp->open(dbp, NULL,
"test.db", NULL, DB_BTREE, DB_CREATE, 0644) != 0);
CuAssertTrue(ct, close_db(dbenv, dbp, ct) == 0);
fclose(errfp);
errfp = NULL;
/* Set DB_DUP flags. */
setup_envdir(TEST_ENV, 1);
CuAssertTrue(ct, create_db(&dbenv, &dbp, 0, ct) == 0);
CuAssertTrue(ct, dbp->set_partition(dbp, nparts, keys, NULL) == 0);
CuAssertTrue(ct, dbp->set_flags(dbp, DB_DUP) == 0);
CuAssertTrue(ct, dbp->open(dbp, NULL,
"test.db", NULL, DB_BTREE, DB_CREATE, 0644) == 0);
CuAssertTrue(ct, put_data(dbp) == 0);
CuAssertTrue(ct, close_db(dbenv, dbp, ct) == 0);
free(keys);
return (0);
}
/***********************************************************************
*
* Function: sync_CopyToPilot
*
* Summary: Copy all desktop records to the Palm
*
* Parameters: None
*
* Returns: 0 on success, non-zero otherwise
*
***********************************************************************/
int sync_CopyToPilot(SyncHandler * sh)
{
int dbhandle,
slow = 0,
result = 0;
DesktopRecord *drecord = NULL;
result = open_db(sh, &dbhandle);
if (result < 0)
goto cleanup;
result = sh->Pre(sh, dbhandle, &slow);
if (result < 0)
goto cleanup;
result = dlp_DeleteRecord(sh->sd, dbhandle, 1, 0);
if (result < 0)
goto cleanup;
while (sh->ForEach(sh, &drecord) == 0 && drecord) {
result =
store_record_on_pilot(sh, dbhandle, drecord, BOTH);
if (result < 0)
goto cleanup;
}
result = sh->Post(sh, dbhandle);
cleanup:
close_db(sh, dbhandle);
return result;
}
static void
find(isc_assertioncallback_t callback) {
isc_result_t result;
dns_rdataset_t rdataset;
dns_fixedname_t fixed;
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
setup_db();
dns_rdataset_init(&rdataset);
dns_fixedname_init(&fixed);
isc_assertion_setcallback(callback);
result = dns_db_find(db1, dns_rootname, VERSION(callback),
dns_rdatatype_soa, 0, 0, NULL,
dns_fixedname_name(&fixed), &rdataset, NULL);
if (callback != NULL)
atf_tc_fail("dns_db_find did not assert");
ATF_REQUIRE_EQ(result, DNS_R_NXDOMAIN);
close_db();
dns_test_end();
}
int main(int argc, char **argv) {
GapIO *io;
char *project, *version;
int status;
int argn;
if (argc < 2) {
usage();
}
for (argn = 1; argn < argc; argn++) {
project = argv[argn];
version = strchr(project, '.');
if (!version) {
fprintf(stderr, "Malformed project name\n");
return 1;
}
*version++ = 0;
printf("Opening project '%s' version '%s'\n", project, version);
io = open_db(project, version, &status, 0, 1);
if (!io) {
fprintf(stderr, "Couldn't open database\n");
return 1;
}
read_size_dist(io);
close_db(io);
}
return 0;
}
int main(int argc, char *argv[])
{
int i, r;
i = proc_args(argc, argv);
if (!args.subcmd)
do_usage();
if (args.dbfile)
{
if (args.needwrite)
{
fprintf(stderr, "you can't write to a database specified with -d.\n");
return 1;
}
else
r = init_named_db(args.dbfile);
}
else
r = init_db(args.needwrite);
if (r)
{
fprintf(stderr, "can't open database.\n");
return 1;
}
i++; /* eat argv[0] */
i = args.subcmd(argc - i, argv + i);
close_db();
return i;
}
/***********************************************************************
*
* Function: sync_MergeToPilot
*
* Summary: Synchronize the desktop records to the pilot, but do
* not alter the desktop records
*
* Parameters: None
*
* Returns: 0 on success, non-zero otherwise
*
***********************************************************************/
int sync_MergeToPilot(SyncHandler * sh)
{
int dbhandle,
slow = 0,
result = 0;
result = open_db(sh, &dbhandle);
if (result < 0)
goto cleanup;
result = sh->Pre(sh, dbhandle, &slow);
if (result < 0)
goto cleanup;
if (!slow) {
sync_MergeToPilot_fast(sh, dbhandle, PILOT);
if (result < 0)
goto cleanup;
} else {
sync_MergeToPilot_slow(sh, dbhandle, PILOT);
if (result < 0)
goto cleanup;
}
result = sh->Post(sh, dbhandle);
cleanup:
close_db(sh, dbhandle);
return result;
}
void close_all() {
o_log(DEBUGM, "|Finished");
close_db ();
free(BASE_DIR);
free(LOG_DIR);
}
static void
deleterdataset(isc_assertioncallback_t callback) {
isc_result_t result;
dns_rdataset_t rdataset;
dns_fixedname_t fixed;
dns_dbnode_t *node = NULL;
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
setup_db();
dns_rdataset_init(&rdataset);
dns_fixedname_init(&fixed);
result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
isc_assertion_setcallback(callback);
result = dns_db_deleterdataset(db1, node, VERSION(callback),
dns_rdatatype_soa, 0);
if (callback != NULL)
atf_tc_fail("dns_db_deleterdataset did not assert");
ATF_REQUIRE_EQ(result, DNS_R_UNCHANGED);
dns_db_detachnode(db1, &node);
ATF_REQUIRE_EQ(node, NULL);
close_db();
dns_test_end();
}
static void
getnsec3parameters(isc_assertioncallback_t callback) {
isc_result_t result;
dns_hash_t hash;
isc_uint8_t flags;
isc_uint16_t iterations;
unsigned char salt[DNS_NSEC3_SALTSIZE];
size_t salt_length = sizeof(salt);
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
setup_db();
isc_assertion_setcallback(callback);
result = dns_db_getnsec3parameters(db1, VERSION(callback), &hash,
&flags, &iterations, salt,
&salt_length);
if (callback != NULL)
atf_tc_fail("dns_db_dump did not assert");
ATF_REQUIRE_EQ(result, ISC_R_NOTFOUND);
close_db();
dns_test_end();
}
static void
dump(isc_assertioncallback_t callback) {
isc_result_t result;
FILE *f = NULL;
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
setup_db();
result = isc_file_openunique(tempname, &f);
fclose(f);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
isc_assertion_setcallback(callback);
result = dns_db_dump(db1, VERSION(callback), tempname);
(void)unlink(tempname);
if (callback != NULL)
atf_tc_fail("dns_db_dump did not assert");
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
close_db();
dns_test_end();
}
int test_db_connection(char *database_name){
PGconn *conn;
conn = connect_db(database_name);
if (PQstatus(conn) != CONNECTION_OK)
{
close_db(conn);
return(1);
}
else {
printf("Connection to database successful! Will use database for storage of data.\n");
}
close_db(conn);
return(0);
}
void test_db(int n)
{
char *dir = Option.dir;
struct db db;
u64 key;
struct lump val;
u64 i;
int rc;
if (1) set_cleanup(cleanup);
create_db(dir);
db = open_db(dir);
for (i = 0; i < n; i++) {
key = randkey();
if (0) val = randlump();
if (1) val = key2lump(key);
//printf("%lld %*s %zd\n", key, val.size, (char *)val.d, strlen(val.d));
insert_db(&db, key, val);
}
if (1)
for (i = 0; i < n + 1; i++) {
rc = next_log(db.r);
if (rc == DONE)
break;
//printf("%lld %s\n", key_log(db.r), (char *)val_log(db.r).d);
}
if (1) merge_db(&db);
close_db(&db);
destroy_db(dir);
}
void verify_db(dbfile_t *proot){
if(proot->head.magic != MAGIC){
close_dbfile(proot->vfp);
close_db(proot);
exit(1);
}
}
int TestPartNumber(CuTest *ct) {
DB_ENV *dbenv;
DB *dbp;
DBT *keys;
u_int32_t i;
dbenv = NULL;
dbp = NULL;
keys = NULL;
nparts = 5;
CuAssertTrue(ct, (keys = malloc((nparts - 1) * sizeof(DBT))) != NULL);
memset(keys, 0, (nparts - 1) * sizeof(DBT));
/* Assign data to the keys. */
for (i = 0 ; i < (nparts - 1); i++) {
keys[i].data = &content[(i + 1) * (strlen(content) / nparts)];
keys[i].size = sizeof(char);
}
/* Partition number is less than 2. */
CuAssertTrue(ct, create_db(&dbenv, &dbp, ct) == 0);
CuAssertTrue(ct, dbp->set_partition(dbp, 1, keys, NULL) != 0);
/* Partition number is less than key array length plus 1. */
CuAssertTrue(ct, dbp->set_partition(dbp, nparts - 1, keys, NULL) == 0);
CuAssertTrue(ct, dbp->open(dbp, NULL,
"test.db", NULL, DB_BTREE, DB_CREATE, 0644) == 0);
CuAssertTrue(ct, put_data(dbp) == 0);
CuAssertTrue(ct, close_db(dbenv, dbp, ct) == 0);
free(keys);
return (0);
}
static void
allrdatasets(isc_assertioncallback_t callback) {
isc_result_t result;
dns_dbnode_t *node = NULL;
dns_rdatasetiter_t *iterator = NULL;
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
setup_db();
result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
isc_assertion_setcallback(callback);
result = dns_db_allrdatasets(db1, node, VERSION(callback), 0,
&iterator);
if (callback != NULL)
atf_tc_fail("dns_db_allrdatasets did not assert");
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
dns_rdatasetiter_destroy(&iterator);
ATF_REQUIRE_EQ(iterator, NULL);
dns_db_detachnode(db1, &node);
ATF_REQUIRE_EQ(node, NULL);
close_db();
dns_test_end();
}
static int
sqlite_init(_SqliteObject *self, PyObject *args, G_GNUC_UNUSED PyObject *kwds)
{
char *path;
int db_type;
GError *err = NULL;
PyObject *ret;
if (!PyArg_ParseTuple(args, "si|:sqlite_init", &path, &db_type))
return -1;
/* Check arguments */
if (db_type < CR_DB_PRIMARY || db_type >= CR_DB_SENTINEL) {
PyErr_SetString(PyExc_ValueError, "Unknown db type");
return -1;
}
/* Free all previous resources when reinitialization */
ret = close_db(self, NULL);
Py_XDECREF(ret);
if (ret == NULL) {
// Error encountered!
return -1;
}
/* Init */
self->db = cr_db_open(path, db_type, &err);
if (err) {
nice_exception(&err, NULL);
return -1;
}
return 0;
}
int thin_id_new(const char *m_name, const char *v_name, unsigned *ret_id)
{
FILE *db, *udb;
char str[1024];
unsigned max_id = 0;
db = open_db(m_name, &udb);
if (!db)
return -1;
while (fgets(str, sizeof(str), db)) {
char *aux, *e;
unsigned id;
aux = strchr(str, ':');
if (!aux)
goto fatal;
id = strtol(aux + 1, &e, 10);
if (*e != '\n')
goto fatal;
*aux = '\0';
if (strcmp(v_name, str) != 0) {
/* FIXME -- IDs can overflow */
if (id > max_id)
max_id = id;
fprintf(udb, "%s:%u\n", str, id);
continue;
}
*ret_id = id;
close_db(m_name, db, udb, false);
return 1;
}
max_id++;
fprintf(udb, "%s:%u\n", v_name, max_id);
*ret_id = max_id;
return close_db(m_name, db, udb, true) ? : 0;
fatal:
loge("RT database corrupted at [%s]\n", str);
close_db(m_name, db, udb, false);
return -1;
}
int free_db(CDatabase *db)
{
if(db!=0){
close_db(db);
delete db;
}
return TRUE;
}
int main(int argc, char** argv)
{
open_db();
create_tab();
insert_db();
select_db();
close_db();
}
int delete_nevera_fsm(nevera_fsm_t* nevera_fsm){
commit_db(nevera_fsm->db,nevera_fsm->lista_usuarios,nevera_fsm->lista_productos);
close_db(nevera_fsm->db);
usuario_list_delete(nevera_fsm->lista_usuarios);
producto_list_delete(nevera_fsm->lista_productos);
free(nevera_fsm);
return 0;
}
int main(int argc, char **argv)
{
if (argc < 2) {
fprintf(stderr, "Usage: %s hostname\n", argv[0]);
return EXIT_FAILURE;
}
bool start_upgrade_server = true;
if (argc >= 3) {
if (strcmp(argv[2], "--no-upgrade") == 0) {
start_upgrade_server = false;
}
}
/* start server for upgrading */
pthread_t serverthread;
if (start_upgrade_server == true) {
pthread_create(&serverthread, NULL, server_thread, NULL);
} else {
printf("no upgrade server\n");
}
char *hostname = argv[1];
char *port = PORT;
/* connect to the database */
setup_db();
/* connect to the server and start the main loop */
int socket = connectToServer(hostname, port);
/* set default language */
language_code = (char *) malloc(3);
language_code[0] = 's';
language_code[1] = 'v';
language_code[2] = '\0';
start_loop(socket);
/* cleanup starts here */
close(socket);
mlog("client.log", "cancelling serverthread");
if (start_upgrade_server == true) {
pthread_cancel(serverthread);
pthread_join(serverthread, NULL);
mlog("client.log", "closing upgrade_socket");
close(upgrade_socket);
}
mlog("client.log", "closing db");
close_db();
free(language_code);
return EXIT_SUCCESS;
}
void login_record_cleanup(void)
{
// clean up the file descriptor
fclose(student_file);
// close the db
close_db(db);
}
consensus_component* init_consensus_comp(struct node_t* node,uint32_t node_id, FILE* log,
int sys_log,int stat_log,const char* db_name,
int deliver_mode,void* db_ptr,int group_size,
view* cur_view,view_stamp* to_commit,view_stamp* committed,view_stamp* highest,user_cb u_cb,up_call uc,void* arg){
consensus_component* comp = (consensus_component*)
malloc(sizeof(consensus_component));
memset(comp,0,sizeof(consensus_component));
if(NULL!=comp){
if(deliver_mode==50){
comp->db_ptr = db_ptr;
}else{
comp->db_ptr = initialize_db(db_name,0);
if(NULL==comp->db_ptr){
goto consensus_error_exit;
}
}
comp->sys_log = sys_log;
comp->stat_log = stat_log;
comp->sys_log_file = log;
comp->my_node = node;
comp->node_id = node_id;
comp->deliver_mode = deliver_mode;
comp->group_size = group_size;
comp->cur_view = cur_view;
if(comp->cur_view->leader_id == comp->node_id){
comp->my_role = LEADER;
}else{
comp->my_role = SECONDARY;
}
comp->ucb = u_cb;
comp->uc = uc;
comp->up_para = arg;
comp->highest_seen_vs = highest;
comp->highest_seen_vs->view_id = 1;
comp->highest_seen_vs->req_id = 0;
comp->highest_committed_vs = committed;
comp->highest_committed_vs->view_id = 1;
comp->highest_committed_vs->req_id = 0;
comp->highest_to_commit_vs = to_commit;
comp->highest_to_commit_vs->view_id = 1;
comp->highest_to_commit_vs->req_id = 0;
goto consensus_init_exit;
}
consensus_error_exit:
if(comp!=NULL){
if(NULL!=comp->db_ptr && comp->deliver_mode == 1){
close_db(comp->db_ptr,0);
}
free(comp);
}
consensus_init_exit:
return comp;
}
int main(void)
{
int len;
char *lenstr,poststr[512];
char *player_id, *server_id;
int can_share = 1;
init_db((char *)"127.0.0.1", 3306, (char *)"pay", (char *)"root", (char *)"123456");
printf("Content-Type:text/html\n\n");
lenstr=getenv("CONTENT_LENGTH");
if(lenstr == NULL) {
printf("<DIV STYLE=\"COLOR:RED\">Errorarameters should be entered!</DIV>\n");
return (0);
}
len=atoi(lenstr) + 1;
if (len >= 512)
return (0);
fgets(poststr,len,stdin);
parse_post_data(poststr, len);
server_id = get_value((char *)"server_id");
player_id = get_value((char *)"player_id");
if (!server_id || !player_id)
return (0);
MYSQL_RES *res = NULL;
MYSQL_ROW row;
char sql[256];
sprintf(sql, "select last_share_time, share_times, pay_times from share where server_id = %s and player_id = %s", server_id, player_id);
res = query(sql, 1, NULL);
if (!res) {
send_no_record();
goto done;
}
row = fetch_row(res);
if (!row) {
send_no_record();
goto done;
}
if (!check_can_share(row)) {
can_share = 0;
}
printf("[%d, %s, %s]", can_share, row[1], row[2]);
done:
if (res)
free_query(res);
fflush(stdout);
close_db();
return 0;
}
int TestPartUnsortedKey(CuTest *ct) {
DB_ENV *dbenv;
DB *dbp;
DBT *keys;
u_int32_t i, indx;
dbenv = NULL;
dbp = NULL;
keys = NULL;
nparts = 6;
CuAssertTrue(ct, (keys = malloc((nparts - 1) * sizeof(DBT))) != NULL);
memset(keys, 0, (nparts - 1) * sizeof(DBT));
/* Assign unsorted keys to the array. */
for (i = 0, indx = 0; i < (nparts - 1); i++) {
if (i == (nparts - 2) && i % 2 == 0)
indx = i;
else if (i % 2 != 0)
indx = i - 1;
else
indx = i + 1;
keys[i].data =
&content[(indx + 1) * (strlen(content) / nparts)];
keys[i].size = sizeof(char);
}
CuAssertTrue(ct, create_db(&dbenv, &dbp, 0, ct) == 0);
CuAssertTrue(ct,
dbp->set_partition(dbp, nparts - 1, &keys[1], NULL) == 0);
CuAssertTrue(ct, dbp->open(dbp, NULL,
"test.db", NULL, DB_BTREE, DB_CREATE, 0644) == 0);
CuAssertTrue(ct, put_data(dbp) == 0);
CuAssertTrue(ct, dbp->close(dbp, 0) == 0);
/*
* Reconfig with a different partition number and
* re-open the database.
*/
CuAssertTrue(ct, db_create(&dbp, dbenv, 0) == 0);
CuAssertTrue(ct, dbp->set_partition(dbp, nparts, keys, NULL) == 0);
CuAssertTrue(ct, dbp->open(dbp, NULL,
"test.db", NULL, DB_BTREE, 0, 0644) != 0);
CuAssertTrue(ct, dbp->close(dbp, 0) == 0);
/*
* Reconfig with a different set of partition keys and
* re-open the database.
*/
CuAssertTrue(ct, db_create(&dbp, dbenv, 0) == 0);
CuAssertTrue(ct, dbp->set_partition(dbp, nparts - 1, keys, NULL) == 0);
CuAssertTrue(ct, dbp->open(dbp, NULL,
"test.db", NULL, DB_BTREE, 0, 0644) != 0);
CuAssertTrue(ct, close_db(dbenv, dbp, ct) == 0);
free(keys);
return (0);
}
void cleanup(void) {
close_out();
close_watch();
close_db();
printf("Manually stopped. Wrote data to %s<x>vals!\n", output);
logm("INFO successfully shut down!");
free(output);
free(logfile);
free(dbfile);
}
