mirrors/nextcloud-desktop
1
0
Fork 0
mirror of https://github.com/nextcloud/desktop.git synced 2024-11-27 17:37:36 +03:00
Code Issues Projects Releases Packages Wiki Activity

statedb: Remove context where it isn't needed.

Browse source
This commit is contained in:
Andreas Schneider 2013-07-04 10:28:19 +02:00
parent d05b077851
commit 8953ed544c
7 changed files with 82 additions and 84 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/csync.c
View file

@ -683,7 +683,7 @@ static int _merge_and_write_statedb(CSYNC *ctx) {
} }
} }
} }
rc = csync_statedb_close(ctx, ctx->statedb.file, ctx->statedb.db, jwritten); rc = csync_statedb_close(ctx->statedb.file, ctx->statedb.db, jwritten);
ctx->statedb.db = NULL; ctx->statedb.db = NULL;
if (rc < 0) { if (rc < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "ERR: closing of statedb failed."); CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "ERR: closing of statedb failed.");

73
src/csync_statedb.c
View file

@ -50,11 +50,11 @@ int csync_get_statedb_exists(CSYNC *ctx) {
return ctx->statedb.exists; return ctx->statedb.exists;
} }
static int _csync_check_db_integrity(CSYNC *ctx, sqlite3 *db) { static int _csync_check_db_integrity(sqlite3 *db) {
c_strlist_t *result = NULL; c_strlist_t *result = NULL;
int rc = -1; int rc = -1;
result = csync_statedb_query(ctx, db, "PRAGMA quick_check;"); result = csync_statedb_query(db, "PRAGMA quick_check;");
if (result != NULL) { if (result != NULL) {
/* There is a result */ /* There is a result */
if (result->count > 0) { if (result->count > 0) {
@ -69,7 +69,7 @@ static int _csync_check_db_integrity(CSYNC *ctx, sqlite3 *db) {
} }
static int _csync_statedb_check(CSYNC *ctx, const char *statedb) { static int _csync_statedb_check(const char *statedb) {
int fd = -1, rc; int fd = -1, rc;
ssize_t r; ssize_t r;
char buf[BUF_SIZE] = {0}; char buf[BUF_SIZE] = {0};
@ -94,7 +94,7 @@ static int _csync_statedb_check(CSYNC *ctx, const char *statedb) {
buf[BUF_SIZE - 1] = '\0'; buf[BUF_SIZE - 1] = '\0';
if (c_streq(buf, "SQLite format 3")) { if (c_streq(buf, "SQLite format 3")) {
if (sqlite3_open(statedb, &db ) == SQLITE_OK) { if (sqlite3_open(statedb, &db ) == SQLITE_OK) {
rc = _csync_check_db_integrity(ctx, db); rc = _csync_check_db_integrity(db);
sqlite3_close(db); sqlite3_close(db);
@ -129,11 +129,11 @@ static int _csync_statedb_check(CSYNC *ctx, const char *statedb) {
return -1; return -1;
} }
static int _csync_statedb_is_empty(CSYNC *ctx, sqlite3 *db) { static int _csync_statedb_is_empty(sqlite3 *db) {
c_strlist_t *result = NULL; c_strlist_t *result = NULL;
int rc = 0; int rc = 0;
result = csync_statedb_query(ctx, db, "SELECT COUNT(phash) FROM metadata LIMIT 1 OFFSET 0;"); result = csync_statedb_query(db, "SELECT COUNT(phash) FROM metadata LIMIT 1 OFFSET 0;");
if (result == NULL) { if (result == NULL) {
rc = 1; rc = 1;
} }
@ -148,7 +148,7 @@ int csync_statedb_load(CSYNC *ctx, const char *statedb, sqlite3 **pdb) {
char *statedb_tmp = NULL; char *statedb_tmp = NULL;
sqlite3 *db; sqlite3 *db;
if (_csync_statedb_check(ctx, statedb) < 0) { if (_csync_statedb_check(statedb) < 0) {
rc = -1; rc = -1;
goto out; goto out;
} }
@ -176,7 +176,7 @@ int csync_statedb_load(CSYNC *ctx, const char *statedb, sqlite3 **pdb) {
} }
SAFE_FREE(statedb_tmp); SAFE_FREE(statedb_tmp);
if (_csync_statedb_is_empty(ctx, db)) { if (_csync_statedb_is_empty(db)) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "statedb doesn't exist"); CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "statedb doesn't exist");
csync_set_statedb_exists(ctx, 0); csync_set_statedb_exists(ctx, 0);
} else { } else {
@ -184,7 +184,7 @@ int csync_statedb_load(CSYNC *ctx, const char *statedb, sqlite3 **pdb) {
} }
/* optimization for speeding up SQLite */ /* optimization for speeding up SQLite */
result = csync_statedb_query(ctx, db, "PRAGMA default_synchronous = FULL;"); result = csync_statedb_query(db, "PRAGMA default_synchronous = FULL;");
c_strlist_destroy(result); c_strlist_destroy(result);
*pdb = db; *pdb = db;
@ -203,7 +203,7 @@ int csync_statedb_write(CSYNC *ctx, sqlite3 *db)
csync_gettime(&start); csync_gettime(&start);
/* drop tables */ /* drop tables */
rc = csync_statedb_drop_tables(ctx, db); rc = csync_statedb_drop_tables(db);
if (rc < 0) { if (rc < 0) {
return -1; return -1;
} }
@ -214,7 +214,7 @@ int csync_statedb_write(CSYNC *ctx, sqlite3 *db)
/* create tables */ /* create tables */
csync_gettime(&start); csync_gettime(&start);
rc = csync_statedb_create_tables(ctx, db); rc = csync_statedb_create_tables(db);
if (rc < 0) { if (rc < 0) {
return -1; return -1;
} }
@ -237,7 +237,7 @@ int csync_statedb_write(CSYNC *ctx, sqlite3 *db)
return 0; return 0;
} }
int csync_statedb_close(CSYNC *ctx, const char *statedb, sqlite3 *db, int jwritten) { int csync_statedb_close(const char *statedb, sqlite3 *db, int jwritten) {
char *statedb_tmp = NULL; char *statedb_tmp = NULL;
int rc = 0; int rc = 0;
@ -262,7 +262,7 @@ int csync_statedb_close(CSYNC *ctx, const char *statedb, sqlite3 *db, int jwritt
return rc; return rc;
} }
int csync_statedb_create_tables(CSYNC *ctx, sqlite3 *db) { int csync_statedb_create_tables(sqlite3 *db) {
c_strlist_t *result = NULL; c_strlist_t *result = NULL;
/* /*
@ -270,7 +270,7 @@ int csync_statedb_create_tables(CSYNC *ctx, sqlite3 *db) {
* creation of the statedb if we later just rename it to its * creation of the statedb if we later just rename it to its
* final name metadata * final name metadata
*/ */
result = csync_statedb_query(ctx, db, result = csync_statedb_query(db,
"CREATE TABLE IF NOT EXISTS metadata_temp(" "CREATE TABLE IF NOT EXISTS metadata_temp("
"phash INTEGER(8)," "phash INTEGER(8),"
"pathlen INTEGER," "pathlen INTEGER,"
@ -294,7 +294,7 @@ int csync_statedb_create_tables(CSYNC *ctx, sqlite3 *db) {
* for first time sync. Otherwise other functions that query metadata * for first time sync. Otherwise other functions that query metadata
* table whine about the table not existing. * table whine about the table not existing.
*/ */
result = csync_statedb_query(ctx, db, result = csync_statedb_query(db,
"CREATE TABLE IF NOT EXISTS metadata(" "CREATE TABLE IF NOT EXISTS metadata("
"phash INTEGER(8)," "phash INTEGER(8),"
"pathlen INTEGER," "pathlen INTEGER,"
@ -317,10 +317,10 @@ int csync_statedb_create_tables(CSYNC *ctx, sqlite3 *db) {
return 0; return 0;
} }
int csync_statedb_drop_tables(CSYNC *ctx, sqlite3* db) { int csync_statedb_drop_tables(sqlite3* db) {
c_strlist_t *result = NULL; c_strlist_t *result = NULL;
result = csync_statedb_query(ctx, db, result = csync_statedb_query(db,
"DROP TABLE IF EXISTS metadata_temp;" "DROP TABLE IF EXISTS metadata_temp;"
); );
if (result == NULL) { if (result == NULL) {
@ -418,21 +418,21 @@ int csync_statedb_insert_metadata(CSYNC *ctx, sqlite3 *db) {
} }
/* Use transactions as that really speeds up processing */ /* Use transactions as that really speeds up processing */
result = csync_statedb_query(ctx, db, "BEGIN TRANSACTION;"); result = csync_statedb_query(db, "BEGIN TRANSACTION;");
c_strlist_destroy(result); c_strlist_destroy(result);
if (c_rbtree_walk(ctx->local.tree, stmt, _insert_metadata_visitor) < 0) { if (c_rbtree_walk(ctx->local.tree, stmt, _insert_metadata_visitor) < 0) {
/* inserting failed. Drop the metadata_temp table. */ /* inserting failed. Drop the metadata_temp table. */
result = csync_statedb_query(ctx, db, "ROLLBACK TRANSACTION;"); result = csync_statedb_query(db, "ROLLBACK TRANSACTION;");
c_strlist_destroy(result); c_strlist_destroy(result);
result = csync_statedb_query(ctx, db, "DROP TABLE IF EXISTS metadata_temp;"); result = csync_statedb_query(db, "DROP TABLE IF EXISTS metadata_temp;");
c_strlist_destroy(result); c_strlist_destroy(result);
return -1; return -1;
} }
result = csync_statedb_query(ctx, db, "COMMIT TRANSACTION;"); result = csync_statedb_query(db, "COMMIT TRANSACTION;");
c_strlist_destroy(result); c_strlist_destroy(result);
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
@ -442,17 +442,17 @@ int csync_statedb_insert_metadata(CSYNC *ctx, sqlite3 *db) {
c_secdiff(step1, start)); c_secdiff(step1, start));
/* Drop table metadata */ /* Drop table metadata */
result = csync_statedb_query(ctx, db, "BEGIN TRANSACTION;"); result = csync_statedb_query(db, "BEGIN TRANSACTION;");
c_strlist_destroy(result); c_strlist_destroy(result);
result = csync_statedb_query(ctx, db, "DROP TABLE IF EXISTS metadata;"); result = csync_statedb_query(db, "DROP TABLE IF EXISTS metadata;");
c_strlist_destroy(result); c_strlist_destroy(result);
/* Rename temp table to real table. */ /* Rename temp table to real table. */
result = csync_statedb_query(ctx, db, "ALTER TABLE metadata_temp RENAME TO metadata;"); result = csync_statedb_query(db, "ALTER TABLE metadata_temp RENAME TO metadata;");
c_strlist_destroy(result); c_strlist_destroy(result);
result = csync_statedb_query(ctx, db, "COMMIT TRANSACTION;"); result = csync_statedb_query(db, "COMMIT TRANSACTION;");
c_strlist_destroy(result); c_strlist_destroy(result);
csync_gettime(&step2); csync_gettime(&step2);
@ -461,24 +461,24 @@ int csync_statedb_insert_metadata(CSYNC *ctx, sqlite3 *db) {
c_secdiff(step2, step1)); c_secdiff(step2, step1));
/* Recreate indices */ /* Recreate indices */
result = csync_statedb_query(ctx, db, "BEGIN TRANSACTION;"); result = csync_statedb_query(db, "BEGIN TRANSACTION;");
c_strlist_destroy(result); c_strlist_destroy(result);
result = csync_statedb_query(ctx, db, result = csync_statedb_query(db,
"CREATE INDEX IF NOT EXISTS metadata_phash ON metadata(phash);"); "CREATE INDEX IF NOT EXISTS metadata_phash ON metadata(phash);");
if (result == NULL) { if (result == NULL) {
return -1; return -1;
} }
c_strlist_destroy(result); c_strlist_destroy(result);
result = csync_statedb_query(ctx, db, result = csync_statedb_query(db,
"CREATE INDEX IF NOT EXISTS metadata_inode ON metadata(inode);"); "CREATE INDEX IF NOT EXISTS metadata_inode ON metadata(inode);");
if (result == NULL) { if (result == NULL) {
return -1; return -1;
} }
c_strlist_destroy(result); c_strlist_destroy(result);
result = csync_statedb_query(ctx, db, "COMMIT TRANSACTION;"); result = csync_statedb_query(db, "COMMIT TRANSACTION;");
c_strlist_destroy(result); c_strlist_destroy(result);
csync_gettime(&finish); csync_gettime(&finish);
@ -491,8 +491,7 @@ int csync_statedb_insert_metadata(CSYNC *ctx, sqlite3 *db) {
} }
/* caller must free the memory */ /* caller must free the memory */
csync_file_stat_t *csync_statedb_get_stat_by_hash(CSYNC *ctx, csync_file_stat_t *csync_statedb_get_stat_by_hash(sqlite3 *db,
sqlite3 *db,
uint64_t phash) uint64_t phash)
{ {
csync_file_stat_t *st = NULL; csync_file_stat_t *st = NULL;
@ -508,7 +507,7 @@ csync_file_stat_t *csync_statedb_get_stat_by_hash(CSYNC *ctx,
return NULL; return NULL;
} }
result = csync_statedb_query(ctx, db, stmt); result = csync_statedb_query(db, stmt);
sqlite3_free(stmt); sqlite3_free(stmt);
if (result == NULL) { if (result == NULL) {
return NULL; return NULL;
@ -553,8 +552,7 @@ csync_file_stat_t *csync_statedb_get_stat_by_hash(CSYNC *ctx,
} }
/* caller must free the memory */ /* caller must free the memory */
csync_file_stat_t *csync_statedb_get_stat_by_inode(CSYNC *ctx, csync_file_stat_t *csync_statedb_get_stat_by_inode(sqlite3 *db,
sqlite3 *db,
ino_t inode) { ino_t inode) {
csync_file_stat_t *st = NULL; csync_file_stat_t *st = NULL;
c_strlist_t *result = NULL; c_strlist_t *result = NULL;
@ -572,7 +570,7 @@ csync_file_stat_t *csync_statedb_get_stat_by_inode(CSYNC *ctx,
return NULL; return NULL;
} }
result = csync_statedb_query(ctx, db, stmt); result = csync_statedb_query(db, stmt);
sqlite3_free(stmt); sqlite3_free(stmt);
if (result == NULL) { if (result == NULL) {
return NULL; return NULL;
@ -606,8 +604,7 @@ csync_file_stat_t *csync_statedb_get_stat_by_inode(CSYNC *ctx,
} }
/* query the statedb, caller must free the memory */ /* query the statedb, caller must free the memory */
c_strlist_t *csync_statedb_query(CSYNC *ctx, c_strlist_t *csync_statedb_query(sqlite3 *db,
sqlite3 *db,
const char *statement) { const char *statement) {
int err = SQLITE_OK; int err = SQLITE_OK;
int rc = SQLITE_OK; int rc = SQLITE_OK;
@ -721,7 +718,7 @@ c_strlist_t *csync_statedb_query(CSYNC *ctx,
return result; return result;
} }
int csync_statedb_insert(CSYNC *ctx, sqlite3 *db, const char *statement) { int csync_statedb_insert(sqlite3 *db, const char *statement) {
int err; int err;
int rc = 0; int rc = 0;
int busy_count = 0; int busy_count = 0;

14
src/csync_statedb.h
View file

@ -55,11 +55,11 @@ int csync_statedb_load(CSYNC *ctx, const char *statedb, sqlite3 **pdb);
int csync_statedb_write(CSYNC *ctx, sqlite3 *db); int csync_statedb_write(CSYNC *ctx, sqlite3 *db);
int csync_statedb_close(CSYNC *ctx, const char *statedb, sqlite3 *db, int jwritten); int csync_statedb_close(const char *statedb, sqlite3 *db, int jwritten);
csync_file_stat_t *csync_statedb_get_stat_by_hash(CSYNC *ctx, sqlite3 *db, uint64_t phash); csync_file_stat_t *csync_statedb_get_stat_by_hash(sqlite3 *db, uint64_t phash);
csync_file_stat_t *csync_statedb_get_stat_by_inode(CSYNC *ctx, sqlite3 *db, ino_t inode); csync_file_stat_t *csync_statedb_get_stat_by_inode(sqlite3 *db, ino_t inode);
/** /**
* @brief A generic statedb query. * @brief A generic statedb query.
@ -70,7 +70,7 @@ csync_file_stat_t *csync_statedb_get_stat_by_inode(CSYNC *ctx, sqlite3 *db, ino_
* @return A stringlist of the entries of a column. An emtpy stringlist if * @return A stringlist of the entries of a column. An emtpy stringlist if
* nothing has been found. NULL on error. * nothing has been found. NULL on error.
*/ */
c_strlist_t *csync_statedb_query(CSYNC *ctx, sqlite3 *db, const char *statement); c_strlist_t *csync_statedb_query(sqlite3 *db, const char *statement);
/** /**
* @brief Insert function for the statedb. * @brief Insert function for the statedb.
@ -81,11 +81,11 @@ c_strlist_t *csync_statedb_query(CSYNC *ctx, sqlite3 *db, const char *statement)
* @return The rowid of the most recent INSERT on success, 0 if the query * @return The rowid of the most recent INSERT on success, 0 if the query
* wasn't successful. * wasn't successful.
*/ */
int csync_statedb_insert(CSYNC *ctx, sqlite3 *db, const char *statement); int csync_statedb_insert(sqlite3 *db, const char *statement);
int csync_statedb_create_tables(CSYNC *ctx, sqlite3 *db); int csync_statedb_create_tables(sqlite3 *db);
int csync_statedb_drop_tables(CSYNC *ctx, sqlite3 *db); int csync_statedb_drop_tables(sqlite3 *db);
int csync_statedb_insert_metadata(CSYNC *ctx, sqlite3 *db); int csync_statedb_insert_metadata(CSYNC *ctx, sqlite3 *db);

4
src/csync_update.c
View file

@ -104,7 +104,7 @@ static int _csync_detect_update(CSYNC *ctx, const char *file,
/* Update detection */ /* Update detection */
if (csync_get_statedb_exists(ctx)) { if (csync_get_statedb_exists(ctx)) {
tmp = csync_statedb_get_stat_by_hash(ctx, ctx->statedb.db, h); tmp = csync_statedb_get_stat_by_hash(ctx->statedb.db, h);
if (tmp && tmp->phash == h) { if (tmp && tmp->phash == h) {
/* we have an update! */ /* we have an update! */
if (fs->mtime > tmp->modtime) { if (fs->mtime > tmp->modtime) {
@ -116,7 +116,7 @@ static int _csync_detect_update(CSYNC *ctx, const char *file,
/* check if the file has been renamed */ /* check if the file has been renamed */
if (ctx->current == LOCAL_REPLICA) { if (ctx->current == LOCAL_REPLICA) {
SAFE_FREE(tmp); SAFE_FREE(tmp);
tmp = csync_statedb_get_stat_by_inode(ctx, ctx->statedb.db, fs->inode); tmp = csync_statedb_get_stat_by_inode(ctx->statedb.db, fs->inode);
if (tmp && tmp->inode == fs->inode) { if (tmp && tmp->inode == fs->inode) {
/* inode found so the file has been renamed */ /* inode found so the file has been renamed */
st->instruction = CSYNC_INSTRUCTION_RENAME; st->instruction = CSYNC_INSTRUCTION_RENAME;

15
tests/csync_tests/check_csync_statedb_load.c
View file

@ -44,27 +44,28 @@ static void teardown(void **state) {
static void check_csync_statedb_check(void **state) static void check_csync_statedb_check(void **state)
{ {
int rc; int rc;
CSYNC *csync = *state;
(void) state; /* unused */
rc = system("mkdir -p /tmp/check_csync1"); rc = system("mkdir -p /tmp/check_csync1");
/* old db */ /* old db */
rc = system("echo \"SQLite format 2\" > /tmp/check_csync1/test.db"); rc = system("echo \"SQLite format 2\" > /tmp/check_csync1/test.db");
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
rc = _csync_statedb_check(csync, TESTDB); rc = _csync_statedb_check(TESTDB);
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
/* db already exists */ /* db already exists */
rc = _csync_statedb_check(csync, TESTDB); rc = _csync_statedb_check(TESTDB);
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
/* no db exists */ /* no db exists */
rc = system("rm -f /tmp/check_csync1/test.db"); rc = system("rm -f /tmp/check_csync1/test.db");
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
rc = _csync_statedb_check(csync, TESTDB); rc = _csync_statedb_check(TESTDB);
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
rc = _csync_statedb_check(csync, "/tmp/check_csync1/"); rc = _csync_statedb_check("/tmp/check_csync1/");
assert_int_equal(rc, -1); assert_int_equal(rc, -1);
rc = system("rm -rf /tmp/check_csync1"); rc = system("rm -rf /tmp/check_csync1");
@ -104,7 +105,7 @@ static void check_csync_statedb_close(void **state)
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
modtime = sb.st_mtime; modtime = sb.st_mtime;
rc = csync_statedb_close(csync, TESTDB, csync->statedb.db, 0); rc = csync_statedb_close(TESTDB, csync->statedb.db, 0);
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
rc = _tstat(testdb, &sb); rc = _tstat(testdb, &sb);
@ -121,7 +122,7 @@ static void check_csync_statedb_close(void **state)
sleep(1); sleep(1);
/* statedb written */ /* statedb written */
rc = csync_statedb_close(csync, TESTDB, csync->statedb.db, 1); rc = csync_statedb_close(TESTDB, csync->statedb.db, 1);
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
rc = _tstat(testdb, &sb); rc = _tstat(testdb, &sb);

54
tests/csync_tests/check_csync_statedb_query.c
View file

@ -40,7 +40,7 @@ static void setup_db(void **state)
setup(state); setup(state);
csync = *state; csync = *state;
rc = csync_statedb_create_tables(csync, csync->statedb.db); rc = csync_statedb_create_tables(csync->statedb.db);
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
stmt = sqlite3_mprintf("INSERT INTO metadata" stmt = sqlite3_mprintf("INSERT INTO metadata"
@ -55,7 +55,7 @@ static void setup_db(void **state)
42, 42,
42); 42);
rc = csync_statedb_insert(csync, csync->statedb.db, stmt); rc = csync_statedb_insert(csync->statedb.db, stmt);
sqlite3_free(stmt); sqlite3_free(stmt);
} }
@ -81,10 +81,10 @@ static void check_csync_statedb_query_statement(void **state)
CSYNC *csync = *state; CSYNC *csync = *state;
c_strlist_t *result; c_strlist_t *result;
result = csync_statedb_query(csync, csync->statedb.db, ""); result = csync_statedb_query(csync->statedb.db, "");
assert_null(result); assert_null(result);
result = csync_statedb_query(csync, csync->statedb.db, "SELECT;"); result = csync_statedb_query(csync->statedb.db, "SELECT;");
assert_null(result); assert_null(result);
} }
@ -93,11 +93,11 @@ static void check_csync_statedb_create_error(void **state)
CSYNC *csync = *state; CSYNC *csync = *state;
c_strlist_t *result; c_strlist_t *result;
result = csync_statedb_query(csync, csync->statedb.db, "CREATE TABLE test(phash INTEGER, text VARCHAR(10));"); result = csync_statedb_query(csync->statedb.db, "CREATE TABLE test(phash INTEGER, text VARCHAR(10));");
assert_non_null(result); assert_non_null(result);
c_strlist_destroy(result); c_strlist_destroy(result);
result = csync_statedb_query(csync, csync->statedb.db, "CREATE TABLE test(phash INTEGER, text VARCHAR(10));"); result = csync_statedb_query(csync->statedb.db, "CREATE TABLE test(phash INTEGER, text VARCHAR(10));");
assert_null(result); assert_null(result);
} }
@ -107,15 +107,15 @@ static void check_csync_statedb_insert_statement(void **state)
c_strlist_t *result; c_strlist_t *result;
int rc; int rc;
result = csync_statedb_query(csync, csync->statedb.db, "CREATE TABLE test(phash INTEGER, text VARCHAR(10));"); result = csync_statedb_query(csync->statedb.db, "CREATE TABLE test(phash INTEGER, text VARCHAR(10));");
assert_non_null(result); assert_non_null(result);
c_strlist_destroy(result); c_strlist_destroy(result);
rc = csync_statedb_insert(csync, csync->statedb.db, "INSERT;"); rc = csync_statedb_insert(csync->statedb.db, "INSERT;");
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
rc = csync_statedb_insert(csync, csync->statedb.db, "INSERT"); rc = csync_statedb_insert(csync->statedb.db, "INSERT");
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
rc = csync_statedb_insert(csync, csync->statedb.db, ""); rc = csync_statedb_insert(csync->statedb.db, "");
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
} }
@ -125,12 +125,12 @@ static void check_csync_statedb_query_create_and_insert_table(void **state)
c_strlist_t *result; c_strlist_t *result;
int rc; int rc;
result = csync_statedb_query(csync, csync->statedb.db, "CREATE TABLE test(phash INTEGER, text VARCHAR(10));"); result = csync_statedb_query(csync->statedb.db, "CREATE TABLE test(phash INTEGER, text VARCHAR(10));");
c_strlist_destroy(result); c_strlist_destroy(result);
rc = csync_statedb_insert(csync, csync->statedb.db, "INSERT INTO test (phash, text) VALUES (42, 'hello');"); rc = csync_statedb_insert(csync->statedb.db, "INSERT INTO test (phash, text) VALUES (42, 'hello');");
assert_true(rc > 0); assert_true(rc > 0);
result = csync_statedb_query(csync, csync->statedb.db, "SELECT * FROM test;"); result = csync_statedb_query(csync->statedb.db, "SELECT * FROM test;");
assert_non_null(result); assert_non_null(result);
assert_int_equal(result->count, 2); assert_int_equal(result->count, 2);
@ -146,15 +146,15 @@ static void check_csync_statedb_is_empty(void **state)
int rc; int rc;
/* we have an empty db */ /* we have an empty db */
assert_true(_csync_statedb_is_empty(csync, csync->statedb.db)); assert_true(_csync_statedb_is_empty(csync->statedb.db));
/* add a table and an entry */ /* add a table and an entry */
result = csync_statedb_query(csync, csync->statedb.db, "CREATE TABLE metadata(phash INTEGER, text VARCHAR(10));"); result = csync_statedb_query(csync->statedb.db, "CREATE TABLE metadata(phash INTEGER, text VARCHAR(10));");
c_strlist_destroy(result); c_strlist_destroy(result);
rc = csync_statedb_insert(csync, csync->statedb.db, "INSERT INTO metadata (phash, text) VALUES (42, 'hello');"); rc = csync_statedb_insert(csync->statedb.db, "INSERT INTO metadata (phash, text) VALUES (42, 'hello');");
assert_true(rc > 0); assert_true(rc > 0);
assert_false(_csync_statedb_is_empty(csync, csync->statedb.db)); assert_false(_csync_statedb_is_empty(csync->statedb.db));
} }
static void check_csync_statedb_create_tables(void **state) static void check_csync_statedb_create_tables(void **state)
@ -163,7 +163,7 @@ static void check_csync_statedb_create_tables(void **state)
char *stmt = NULL; char *stmt = NULL;
int rc; int rc;
rc = csync_statedb_create_tables(csync, csync->statedb.db); rc = csync_statedb_create_tables(csync->statedb.db);
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
stmt = sqlite3_mprintf("INSERT INTO metadata" stmt = sqlite3_mprintf("INSERT INTO metadata"
@ -178,7 +178,7 @@ static void check_csync_statedb_create_tables(void **state)
42, 42,
42); 42);
rc = csync_statedb_insert(csync, csync->statedb.db, stmt); rc = csync_statedb_insert(csync->statedb.db, stmt);
assert_true(rc > 0); assert_true(rc > 0);
sqlite3_free(stmt); sqlite3_free(stmt);
@ -189,11 +189,11 @@ static void check_csync_statedb_drop_tables(void **state)
CSYNC *csync = *state; CSYNC *csync = *state;
int rc; int rc;
rc = csync_statedb_drop_tables(csync, csync->statedb.db); rc = csync_statedb_drop_tables(csync->statedb.db);
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
rc = csync_statedb_create_tables(csync, csync->statedb.db); rc = csync_statedb_create_tables(csync->statedb.db);
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
rc = csync_statedb_drop_tables(csync, csync->statedb.db); rc = csync_statedb_drop_tables(csync->statedb.db);
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
} }
@ -203,7 +203,7 @@ static void check_csync_statedb_insert_metadata(void **state)
csync_file_stat_t *st; csync_file_stat_t *st;
int i, rc; int i, rc;
rc = csync_statedb_create_tables(csync, csync->statedb.db); rc = csync_statedb_create_tables(csync->statedb.db);
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
for (i = 0; i < 100; i++) { for (i = 0; i < 100; i++) {
@ -241,7 +241,7 @@ static void check_csync_statedb_get_stat_by_hash(void **state)
CSYNC *csync = *state; CSYNC *csync = *state;
csync_file_stat_t *tmp; csync_file_stat_t *tmp;
tmp = csync_statedb_get_stat_by_hash(csync, csync->statedb.db, (uint64_t) 42); tmp = csync_statedb_get_stat_by_hash(csync->statedb.db, (uint64_t) 42);
assert_non_null(tmp); assert_non_null(tmp);
assert_int_equal(tmp->phash, 42); assert_int_equal(tmp->phash, 42);
@ -255,7 +255,7 @@ static void check_csync_statedb_get_stat_by_hash_not_found(void **state)
CSYNC *csync = *state; CSYNC *csync = *state;
csync_file_stat_t *tmp; csync_file_stat_t *tmp;
tmp = csync_statedb_get_stat_by_hash(csync, csync->statedb.db, (uint64_t) 666); tmp = csync_statedb_get_stat_by_hash(csync->statedb.db, (uint64_t) 666);
assert_null(tmp); assert_null(tmp);
} }
@ -264,7 +264,7 @@ static void check_csync_statedb_get_stat_by_inode(void **state)
CSYNC *csync = *state; CSYNC *csync = *state;
csync_file_stat_t *tmp; csync_file_stat_t *tmp;
tmp = csync_statedb_get_stat_by_inode(csync, csync->statedb.db, (ino_t) 23); tmp = csync_statedb_get_stat_by_inode(csync->statedb.db, (ino_t) 23);
assert_non_null(tmp); assert_non_null(tmp);
assert_int_equal(tmp->phash, 42); assert_int_equal(tmp->phash, 42);
@ -278,7 +278,7 @@ static void check_csync_statedb_get_stat_by_inode_not_found(void **state)
CSYNC *csync = *state; CSYNC *csync = *state;
csync_file_stat_t *tmp; csync_file_stat_t *tmp;
tmp = csync_statedb_get_stat_by_inode(csync, csync->statedb.db, (ino_t) 666); tmp = csync_statedb_get_stat_by_inode(csync->statedb.db, (ino_t) 666);
assert_null(tmp); assert_null(tmp);
} }

4
tests/csync_tests/check_csync_update.c
View file

@ -247,7 +247,7 @@ static void check_csync_detect_update_db_rename(void **state)
int rc; int rc;
char *stmt = NULL; char *stmt = NULL;
rc = csync_statedb_create_tables(csync, csync->statedb.db); rc = csync_statedb_create_tables(csync->statedb.db);
assert_int_equal(rc, 0); assert_int_equal(rc, 0);
stmt = sqlite3_mprintf("INSERT INTO metadata" stmt = sqlite3_mprintf("INSERT INTO metadata"
@ -262,7 +262,7 @@ static void check_csync_detect_update_db_rename(void **state)
42, 42,
42); 42);
rc = csync_statedb_insert(csync, csync->statedb.db, stmt); rc = csync_statedb_insert(csync->statedb.db, stmt);
sqlite3_free(stmt); sqlite3_free(stmt);
fs = create_fstat("wurst.txt", 0, 1, 0); fs = create_fstat("wurst.txt", 0, 1, 0);