diff options
Diffstat (limited to 'libglusterfs/src/gfdb')
| -rw-r--r-- | libglusterfs/src/gfdb/gfdb_data_store.c | 1005 | ||||
| -rw-r--r-- | libglusterfs/src/gfdb/gfdb_data_store_helper.c | 773 | ||||
| -rw-r--r-- | libglusterfs/src/gfdb/gfdb_sqlite3.c | 2355 | ||||
| -rw-r--r-- | libglusterfs/src/gfdb/gfdb_sqlite3_helper.c | 2361 |
4 files changed, 3114 insertions, 3380 deletions
diff --git a/libglusterfs/src/gfdb/gfdb_data_store.c b/libglusterfs/src/gfdb/gfdb_data_store.c index 78fd22ee252..426596c571e 100644 --- a/libglusterfs/src/gfdb/gfdb_data_store.c +++ b/libglusterfs/src/gfdb/gfdb_data_store.c @@ -30,11 +30,10 @@ * gfdb_conn_node_t is an opaque structure. * */ struct gfdb_conn_node_t { - gfdb_connection_t gfdb_connection; - struct list_head conn_list; + gfdb_connection_t gfdb_connection; + struct list_head conn_list; }; - /* * db_conn_list is the circular linked list which * will have all the database connections for the process @@ -48,173 +47,168 @@ static gfdb_conn_node_t *db_conn_list; * */ static pthread_mutex_t db_conn_mutex = PTHREAD_MUTEX_INITIALIZER; - /*Checks the sanity of the connection node*/ -#define CHECK_CONN_NODE(_conn_node)\ -do {\ - GF_ASSERT (_conn_node);\ - GF_ASSERT (_conn_node->gfdb_connection.gf_db_connection);\ -} while (0) +#define CHECK_CONN_NODE(_conn_node) \ + do { \ + GF_ASSERT(_conn_node); \ + GF_ASSERT(_conn_node->gfdb_connection.gf_db_connection); \ + } while (0) /* Checks the sanity of the connection node and goto */ -#define CHECK_CONN_NODE_GOTO(_conn_node, label)\ -do {\ - if (!_conn_node) {\ - goto label;\ - };\ - if (!_conn_node->gfdb_connection.gf_db_connection) {\ - goto label;\ - };\ -} while (0) +#define CHECK_CONN_NODE_GOTO(_conn_node, label) \ + do { \ + if (!_conn_node) { \ + goto label; \ + }; \ + if (!_conn_node->gfdb_connection.gf_db_connection) { \ + goto label; \ + }; \ + } while (0) /*Check if the conn node is first in the list*/ -#define IS_FIRST_NODE(db_conn_list, _conn_node)\ - ((_conn_node == db_conn_list) ? _gf_true : _gf_false) - +#define IS_FIRST_NODE(db_conn_list, _conn_node) \ + ((_conn_node == db_conn_list) ? _gf_true : _gf_false) /*Check if the conn node is the only node in the list*/ -#define IS_THE_ONLY_NODE(_conn_node)\ -((_conn_node->conn_list.next == _conn_node->conn_list.prev)\ - ? _gf_true : _gf_false) - - +#define IS_THE_ONLY_NODE(_conn_node) \ + ((_conn_node->conn_list.next == _conn_node->conn_list.prev) ? _gf_true \ + : _gf_false) /*Internal Function: Adds connection node to the end of * the db connection list.*/ static int -add_connection_node (gfdb_conn_node_t *_conn_node) { - int ret = -1; - - GF_ASSERT (_conn_node); - - /*Lock the list*/ - ret = pthread_mutex_lock (&db_conn_mutex); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ret, - LG_MSG_LOCK_LIST_FAILED, "Failed lock db connection " - "list %s", strerror(ret)); - ret = -1; - goto out; - } - - if (db_conn_list == NULL) { - db_conn_list = _conn_node; - } else { - list_add_tail (&_conn_node->conn_list, - &db_conn_list->conn_list); - } - - /*unlock the list*/ - ret = pthread_mutex_unlock (&db_conn_mutex); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ret, - LG_MSG_UNLOCK_LIST_FAILED, "Failed unlock db " - "connection list %s", strerror(ret)); - ret = -1; - goto out; - /*TODO What if the unlock fails. - * Will it lead to deadlock? - * Most of the gluster code - * no check for unlock or destroy of mutex!*/ - } - ret = 0; +add_connection_node(gfdb_conn_node_t *_conn_node) +{ + int ret = -1; + + GF_ASSERT(_conn_node); + + /*Lock the list*/ + ret = pthread_mutex_lock(&db_conn_mutex); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, ret, LG_MSG_LOCK_LIST_FAILED, + "Failed lock db connection " + "list %s", + strerror(ret)); + ret = -1; + goto out; + } + + if (db_conn_list == NULL) { + db_conn_list = _conn_node; + } else { + list_add_tail(&_conn_node->conn_list, &db_conn_list->conn_list); + } + + /*unlock the list*/ + ret = pthread_mutex_unlock(&db_conn_mutex); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, ret, LG_MSG_UNLOCK_LIST_FAILED, + "Failed unlock db " + "connection list %s", + strerror(ret)); + ret = -1; + goto out; + /*TODO What if the unlock fails. + * Will it lead to deadlock? + * Most of the gluster code + * no check for unlock or destroy of mutex!*/ + } + ret = 0; out: - return ret; + return ret; } - /*Internal Function: * Delete connection node from the list*/ static int -delete_conn_node (gfdb_conn_node_t *_conn_node) +delete_conn_node(gfdb_conn_node_t *_conn_node) { - int ret = -1; - - GF_ASSERT (_conn_node); - - /*Lock of the list*/ - ret = pthread_mutex_lock (&db_conn_mutex); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ret, - LG_MSG_LOCK_LIST_FAILED, "Failed lock on db connection" - " list %s", strerror(ret)); - goto out; + int ret = -1; + + GF_ASSERT(_conn_node); + + /*Lock of the list*/ + ret = pthread_mutex_lock(&db_conn_mutex); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, ret, LG_MSG_LOCK_LIST_FAILED, + "Failed lock on db connection" + " list %s", + strerror(ret)); + goto out; + } + + /*Remove the connection object from list*/ + if (IS_THE_ONLY_NODE(_conn_node)) { + db_conn_list = NULL; + GF_FREE(_conn_node); + } else { + if (IS_FIRST_NODE(db_conn_list, _conn_node)) { + db_conn_list = list_entry(db_conn_list->conn_list.next, + gfdb_conn_node_t, conn_list); } - - /*Remove the connection object from list*/ - if (IS_THE_ONLY_NODE(_conn_node)) { - db_conn_list = NULL; - GF_FREE (_conn_node); - } else { - if (IS_FIRST_NODE(db_conn_list, _conn_node)) { - db_conn_list = list_entry (db_conn_list->conn_list.next, - gfdb_conn_node_t, conn_list); - } - list_del(&_conn_node->conn_list); - GF_FREE (_conn_node); - } - - /*Release the list lock*/ - ret = pthread_mutex_unlock (&db_conn_mutex); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_WARNING, ret, - LG_MSG_UNLOCK_LIST_FAILED, "Failed unlock on db " - "connection list %s", strerror(ret)); - /*TODO What if the unlock fails. - * Will it lead to deadlock? - * Most of the gluster code - * no check for unlock or destroy of mutex!*/ - ret = -1; - goto out; - } - ret = 0; + list_del(&_conn_node->conn_list); + GF_FREE(_conn_node); + } + + /*Release the list lock*/ + ret = pthread_mutex_unlock(&db_conn_mutex); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_WARNING, ret, LG_MSG_UNLOCK_LIST_FAILED, + "Failed unlock on db " + "connection list %s", + strerror(ret)); + /*TODO What if the unlock fails. + * Will it lead to deadlock? + * Most of the gluster code + * no check for unlock or destroy of mutex!*/ + ret = -1; + goto out; + } + ret = 0; out: - return ret; + return ret; } - /*Internal function: Used initialize/map db operation of * specified type of db plugin*/ static int -init_db_operations (gfdb_db_type_t gfdb_db_type, - gfdb_db_operations_t *gfdb_db_operations) +init_db_operations(gfdb_db_type_t gfdb_db_type, + gfdb_db_operations_t *gfdb_db_operations) { + int ret = -1; - int ret = -1; + GF_ASSERT(gfdb_db_operations); - GF_ASSERT (gfdb_db_operations); - - /*Clear the gfdb_db_operations*/ - gfdb_db_operations = memset(gfdb_db_operations, 0, - sizeof(*gfdb_db_operations)); - switch (gfdb_db_type) { + /*Clear the gfdb_db_operations*/ + gfdb_db_operations = memset(gfdb_db_operations, 0, + sizeof(*gfdb_db_operations)); + switch (gfdb_db_type) { case GFDB_SQLITE3: - gf_sqlite3_fill_db_operations (gfdb_db_operations); - ret = 0; - break; + gf_sqlite3_fill_db_operations(gfdb_db_operations); + ret = 0; + break; case GFDB_HYPERDEX: case GFDB_HASH_FILE_STORE: case GFDB_ROCKS_DB: - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_UNSUPPORTED_PLUGIN, "Plugin not supported"); - break; + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_UNSUPPORTED_PLUGIN, + "Plugin not supported"); + break; case GFDB_INVALID_DB: case GFDB_DB_END: - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_INVALID_DB_TYPE, "Invalid DB Type"); - break; - } - return ret; + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_INVALID_DB_TYPE, + "Invalid DB Type"); + break; + } + return ret; } - /****************************************************************************** * * LIBGFDB API Functions * * ****************************************************************************/ - /*Libgfdb API Function: Used to initialize a db connection * (Constructor function for db connection object) * Arguments: @@ -225,85 +219,79 @@ init_db_operations (gfdb_db_type_t gfdb_db_type, * Returns : if successful return the GFDB Connection node to the caller or * NULL in case of failure*/ gfdb_conn_node_t * -init_db (dict_t *args, gfdb_db_type_t gfdb_db_type) +init_db(dict_t *args, gfdb_db_type_t gfdb_db_type) { - int ret = -1; - gfdb_conn_node_t *_conn_node = NULL; - gfdb_db_operations_t *db_operations_t = NULL; - - /*Create data base connection object*/ - _conn_node = GF_CALLOC (1, sizeof(gfdb_conn_node_t), - gf_mt_db_conn_node_t); - if (!_conn_node) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ENOMEM, - LG_MSG_NO_MEMORY, "Failed mem alloc for " - "gfdb_conn_node_t"); - goto alloc_failed; - } - - /*Init the list component of db connection object*/ - INIT_LIST_HEAD (&_conn_node->conn_list); - - - /*Add created connection node to the list*/ - ret = add_connection_node (_conn_node); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_ADD_TO_LIST_FAILED, "Failed to add connection " - "node to list"); - goto _conn_failed; - } - - db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; - - /*init the db ops object of db connection object*/ - ret = init_db_operations(gfdb_db_type, db_operations_t); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_INIT_DB_FAILED, "Failed initializing database " - "operation failed."); - goto init_db_failed; - } - - /*Calling the init_db_op of the respected db type*/ - GF_ASSERT (db_operations_t->init_db_op); - ret = db_operations_t->init_db_op (args, &_conn_node->gfdb_connection. - gf_db_connection); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_INIT_DB_FAILED, "Failed initializing database"); - goto init_db_failed; - } - _conn_node->gfdb_connection.gfdb_db_type = gfdb_db_type; - ret = 0; - - return _conn_node; - - /*****Error Handling********/ - /* If init_db_operations or init_db of plugin failed delete - * conn node from the list. - * connection node will be free by delete_conn_node*/ + int ret = -1; + gfdb_conn_node_t *_conn_node = NULL; + gfdb_db_operations_t *db_operations_t = NULL; + + /*Create data base connection object*/ + _conn_node = GF_CALLOC(1, sizeof(gfdb_conn_node_t), gf_mt_db_conn_node_t); + if (!_conn_node) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY, + "Failed mem alloc for " + "gfdb_conn_node_t"); + goto alloc_failed; + } + + /*Init the list component of db connection object*/ + INIT_LIST_HEAD(&_conn_node->conn_list); + + /*Add created connection node to the list*/ + ret = add_connection_node(_conn_node); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_ADD_TO_LIST_FAILED, + "Failed to add connection " + "node to list"); + goto _conn_failed; + } + + db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; + + /*init the db ops object of db connection object*/ + ret = init_db_operations(gfdb_db_type, db_operations_t); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_INIT_DB_FAILED, + "Failed initializing database " + "operation failed."); + goto init_db_failed; + } + + /*Calling the init_db_op of the respected db type*/ + GF_ASSERT(db_operations_t->init_db_op); + ret = db_operations_t->init_db_op( + args, &_conn_node->gfdb_connection.gf_db_connection); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_INIT_DB_FAILED, + "Failed initializing database"); + goto init_db_failed; + } + _conn_node->gfdb_connection.gfdb_db_type = gfdb_db_type; + ret = 0; + + return _conn_node; + + /*****Error Handling********/ + /* If init_db_operations or init_db of plugin failed delete + * conn node from the list. + * connection node will be free by delete_conn_node*/ init_db_failed: - ret = delete_conn_node (_conn_node); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_DELETE_FROM_LIST_FAILED, "Failed deleting " - "connection node from list"); - } - return NULL; - /*if adding to the list failed free connection node*/ + ret = delete_conn_node(_conn_node); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DELETE_FROM_LIST_FAILED, + "Failed deleting " + "connection node from list"); + } + return NULL; + /*if adding to the list failed free connection node*/ _conn_failed: - GF_FREE (_conn_node); - /*if allocation failed*/ + GF_FREE(_conn_node); + /*if allocation failed*/ alloc_failed: - return NULL; - /*****Error Handling********/ + return NULL; + /*****Error Handling********/ } - - - - /*Libgfdb API Function: Used to terminate/de-initialize db connection * (Destructor function for db connection object) * Arguments: @@ -311,43 +299,38 @@ alloc_failed: * Returns : if successful return 0 or * -ve value in case of failure*/ int -fini_db (gfdb_conn_node_t *_conn_node) +fini_db(gfdb_conn_node_t *_conn_node) { - int ret = -1; - gfdb_db_operations_t *db_operations_t = NULL; - - CHECK_CONN_NODE_GOTO (_conn_node, empty); - - db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; - - GF_ASSERT (db_operations_t->fini_db_op); - - ret = db_operations_t->fini_db_op(&_conn_node->gfdb_connection. - gf_db_connection); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_CLOSE_CONNECTION_FAILED, "Failed close the db " - "connection"); - goto out; - } - - ret = delete_conn_node (_conn_node); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_DELETE_FROM_LIST_FAILED, "Failed deleting " - "connection node from list"); - } + int ret = -1; + gfdb_db_operations_t *db_operations_t = NULL; + + CHECK_CONN_NODE_GOTO(_conn_node, empty); + + db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; + + GF_ASSERT(db_operations_t->fini_db_op); + + ret = db_operations_t->fini_db_op( + &_conn_node->gfdb_connection.gf_db_connection); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_CLOSE_CONNECTION_FAILED, + "Failed close the db " + "connection"); + goto out; + } + + ret = delete_conn_node(_conn_node); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DELETE_FROM_LIST_FAILED, + "Failed deleting " + "connection node from list"); + } empty: - ret = 0; + ret = 0; out: - return ret; + return ret; } - - - - - /*Libgfdb API Function: Used to insert/update records in the database * NOTE: In current gfdb_sqlite plugin we use that * same function to delete the record. Set the @@ -364,36 +347,32 @@ out: * Returns : if successful return 0 or * -ve value in case of failure*/ int -insert_record (gfdb_conn_node_t *_conn_node, - gfdb_db_record_t *gfdb_db_record) +insert_record(gfdb_conn_node_t *_conn_node, gfdb_db_record_t *gfdb_db_record) { - int ret = 0; - gfdb_db_operations_t *db_operations_t = NULL; - void *gf_db_connection = NULL; + int ret = 0; + gfdb_db_operations_t *db_operations_t = NULL; + void *gf_db_connection = NULL; - CHECK_CONN_NODE(_conn_node); + CHECK_CONN_NODE(_conn_node); - db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; - gf_db_connection = _conn_node->gfdb_connection.gf_db_connection; + db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; + gf_db_connection = _conn_node->gfdb_connection.gf_db_connection; - if (db_operations_t->insert_record_op) { - - ret = db_operations_t->insert_record_op (gf_db_connection, - gfdb_db_record); - if (ret) { - gf_msg (GFDB_DATA_STORE, _gfdb_log_level (GF_LOG_ERROR, - gfdb_db_record->ignore_errors), 0, - LG_MSG_INSERT_OR_UPDATE_FAILED, "Insert/Update" - " operation failed"); - } + if (db_operations_t->insert_record_op) { + ret = db_operations_t->insert_record_op(gf_db_connection, + gfdb_db_record); + if (ret) { + gf_msg(GFDB_DATA_STORE, + _gfdb_log_level(GF_LOG_ERROR, gfdb_db_record->ignore_errors), + 0, LG_MSG_INSERT_OR_UPDATE_FAILED, + "Insert/Update" + " operation failed"); } + } - return ret; + return ret; } - - - /*Libgfdb API Function: Used to delete record from the database * NOTE: In the current gfdb_sqlite3 plugin * implementation this function is dummy. @@ -405,31 +384,28 @@ insert_record (gfdb_conn_node_t *_conn_node, * Returns : if successful return 0 or * -ve value in case of failure*/ int -delete_record (gfdb_conn_node_t *_conn_node, - gfdb_db_record_t *gfdb_db_record) +delete_record(gfdb_conn_node_t *_conn_node, gfdb_db_record_t *gfdb_db_record) { - int ret = 0; - gfdb_db_operations_t *db_operations_t = NULL; - void *gf_db_connection = NULL; - - CHECK_CONN_NODE(_conn_node); + int ret = 0; + gfdb_db_operations_t *db_operations_t = NULL; + void *gf_db_connection = NULL; - db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; - gf_db_connection = _conn_node->gfdb_connection.gf_db_connection; + CHECK_CONN_NODE(_conn_node); - if (db_operations_t->delete_record_op) { - - ret = db_operations_t->delete_record_op (gf_db_connection, - gfdb_db_record); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_DELETE_FAILED, "Delete operation " - "failed"); - } + db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; + gf_db_connection = _conn_node->gfdb_connection.gf_db_connection; + if (db_operations_t->delete_record_op) { + ret = db_operations_t->delete_record_op(gf_db_connection, + gfdb_db_record); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DELETE_FAILED, + "Delete operation " + "failed"); } + } - return ret; + return ret; } /*Libgfdb API Function: Compact the database. @@ -441,38 +417,31 @@ delete_record (gfdb_conn_node_t *_conn_node, * Returns : if successful return 0 or * -ve value in case of failure*/ int -compact_db (gfdb_conn_node_t *_conn_node, gf_boolean_t _compact_active, - gf_boolean_t _compact_mode_switched) +compact_db(gfdb_conn_node_t *_conn_node, gf_boolean_t _compact_active, + gf_boolean_t _compact_mode_switched) { - int ret = 0; - gfdb_db_operations_t *db_operations_t = NULL; - void *gf_db_connection = NULL; + int ret = 0; + gfdb_db_operations_t *db_operations_t = NULL; + void *gf_db_connection = NULL; - CHECK_CONN_NODE(_conn_node); + CHECK_CONN_NODE(_conn_node); - db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; - gf_db_connection = _conn_node->gfdb_connection.gf_db_connection; - - if (db_operations_t->compact_db_op) { - - ret = db_operations_t->compact_db_op (gf_db_connection, - _compact_active, - _compact_mode_switched); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_COMPACT_FAILED, "Compaction operation " - "failed"); - } + db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; + gf_db_connection = _conn_node->gfdb_connection.gf_db_connection; + if (db_operations_t->compact_db_op) { + ret = db_operations_t->compact_db_op(gf_db_connection, _compact_active, + _compact_mode_switched); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_COMPACT_FAILED, + "Compaction operation " + "failed"); } + } - return ret; + return ret; } - - - - /*Libgfdb API Function: Query all the records from the database * Arguments: * _conn_node : GFDB Connection node @@ -484,37 +453,30 @@ compact_db (gfdb_conn_node_t *_conn_node, gf_boolean_t _compact_active, * Returns : if successful return 0 or * -ve value in case of failure*/ int -find_all (gfdb_conn_node_t *_conn_node, - gf_query_callback_t query_callback, - void *_query_cbk_args, - int query_limit) +find_all(gfdb_conn_node_t *_conn_node, gf_query_callback_t query_callback, + void *_query_cbk_args, int query_limit) { - int ret = 0; - gfdb_db_operations_t *db_operations_t = NULL; - void *gf_db_connection = NULL; - - CHECK_CONN_NODE(_conn_node); - - db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; - gf_db_connection = _conn_node->gfdb_connection.gf_db_connection; - - if (db_operations_t->find_all_op) { - ret = db_operations_t->find_all_op (gf_db_connection, - query_callback, - _query_cbk_args, - query_limit); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_FIND_OP_FAILED, "Find all operation " - "failed"); - } + int ret = 0; + gfdb_db_operations_t *db_operations_t = NULL; + void *gf_db_connection = NULL; - } + CHECK_CONN_NODE(_conn_node); - return ret; -} + db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; + gf_db_connection = _conn_node->gfdb_connection.gf_db_connection; + if (db_operations_t->find_all_op) { + ret = db_operations_t->find_all_op(gf_db_connection, query_callback, + _query_cbk_args, query_limit); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_FIND_OP_FAILED, + "Find all operation " + "failed"); + } + } + return ret; +} /*Libgfdb API Function: Query records/files that have not changed/accessed * from a time in past to current time @@ -529,35 +491,30 @@ find_all (gfdb_conn_node_t *_conn_node, * Returns : if successful return 0 or * -ve value in case of failure*/ int -find_unchanged_for_time(gfdb_conn_node_t *_conn_node, - gf_query_callback_t query_callback, - void *_query_cbk_args, - gfdb_time_t *for_time) +find_unchanged_for_time(gfdb_conn_node_t *_conn_node, + gf_query_callback_t query_callback, + void *_query_cbk_args, gfdb_time_t *for_time) { + int ret = 0; + gfdb_db_operations_t *db_operations_t = NULL; + void *gf_db_connection = NULL; - int ret = 0; - gfdb_db_operations_t *db_operations_t = NULL; - void *gf_db_connection = NULL; - - CHECK_CONN_NODE(_conn_node); - - db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; - gf_db_connection = _conn_node->gfdb_connection.gf_db_connection; - - if (db_operations_t->find_unchanged_for_time_op) { + CHECK_CONN_NODE(_conn_node); - ret = db_operations_t->find_unchanged_for_time_op - (gf_db_connection, query_callback, - _query_cbk_args, for_time); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_FIND_OP_FAILED, "Find unchanged " - "operation failed"); - } + db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; + gf_db_connection = _conn_node->gfdb_connection.gf_db_connection; + if (db_operations_t->find_unchanged_for_time_op) { + ret = db_operations_t->find_unchanged_for_time_op( + gf_db_connection, query_callback, _query_cbk_args, for_time); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_FIND_OP_FAILED, + "Find unchanged " + "operation failed"); } + } - return ret; + return ret; } /*Libgfdb API Function: Query records/files that have changed/accessed from a @@ -573,36 +530,29 @@ find_unchanged_for_time(gfdb_conn_node_t *_conn_node, * Returns : if successful return 0 or * -ve value in case of failure*/ int -find_recently_changed_files(gfdb_conn_node_t *_conn_node, +find_recently_changed_files(gfdb_conn_node_t *_conn_node, gf_query_callback_t query_callback, - void *_query_cbk_args, - gfdb_time_t *from_time) + void *_query_cbk_args, gfdb_time_t *from_time) { + int ret = 0; + gfdb_db_operations_t *db_operations_t = NULL; + void *gf_db_connection = NULL; - int ret = 0; - gfdb_db_operations_t *db_operations_t = NULL; - void *gf_db_connection = NULL; - - CHECK_CONN_NODE(_conn_node); - - db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; - gf_db_connection = _conn_node->gfdb_connection.gf_db_connection; + CHECK_CONN_NODE(_conn_node); - if (db_operations_t->find_recently_changed_files_op) { - - ret = db_operations_t->find_recently_changed_files_op ( - gf_db_connection, query_callback, - _query_cbk_args, from_time); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_FIND_OP_FAILED, - "Find changed operation failed"); - } + db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; + gf_db_connection = _conn_node->gfdb_connection.gf_db_connection; + if (db_operations_t->find_recently_changed_files_op) { + ret = db_operations_t->find_recently_changed_files_op( + gf_db_connection, query_callback, _query_cbk_args, from_time); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_FIND_OP_FAILED, + "Find changed operation failed"); } + } - return ret; - + return ret; } /*Libgfdb API Function: Query records/files that have not changed/accessed @@ -624,38 +574,31 @@ find_recently_changed_files(gfdb_conn_node_t *_conn_node, * -ve value in case of failure*/ int find_unchanged_for_time_freq(gfdb_conn_node_t *_conn_node, - gf_query_callback_t query_callback, - void *_query_cbk_args, - gfdb_time_t *for_time, - int write_freq_thresold, - int read_freq_thresold, - gf_boolean_t _clear_counters) + gf_query_callback_t query_callback, + void *_query_cbk_args, gfdb_time_t *for_time, + int write_freq_thresold, int read_freq_thresold, + gf_boolean_t _clear_counters) { - int ret = 0; - gfdb_db_operations_t *db_operations_t = NULL; - void *gf_db_connection = NULL; - - CHECK_CONN_NODE(_conn_node); + int ret = 0; + gfdb_db_operations_t *db_operations_t = NULL; + void *gf_db_connection = NULL; - db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; - gf_db_connection = _conn_node->gfdb_connection.gf_db_connection; + CHECK_CONN_NODE(_conn_node); - if (db_operations_t->find_unchanged_for_time_freq_op) { - - ret = db_operations_t->find_unchanged_for_time_freq_op( - gf_db_connection, query_callback, - _query_cbk_args, for_time, - write_freq_thresold, read_freq_thresold, - _clear_counters); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_FIND_OP_FAILED, - "Find unchanged with freq operation failed"); - } + db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; + gf_db_connection = _conn_node->gfdb_connection.gf_db_connection; + if (db_operations_t->find_unchanged_for_time_freq_op) { + ret = db_operations_t->find_unchanged_for_time_freq_op( + gf_db_connection, query_callback, _query_cbk_args, for_time, + write_freq_thresold, read_freq_thresold, _clear_counters); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_FIND_OP_FAILED, + "Find unchanged with freq operation failed"); } + } - return ret; + return ret; } /*Libgfdb API Function: Query records/files that have changed/accessed from a @@ -677,44 +620,34 @@ find_unchanged_for_time_freq(gfdb_conn_node_t *_conn_node, * -ve value in case of failure*/ int find_recently_changed_files_freq(gfdb_conn_node_t *_conn_node, - gf_query_callback_t query_callback, - void *_query_cbk_args, - gfdb_time_t *from_time, - int write_freq_thresold, - int read_freq_thresold, - gf_boolean_t _clear_counters) + gf_query_callback_t query_callback, + void *_query_cbk_args, gfdb_time_t *from_time, + int write_freq_thresold, + int read_freq_thresold, + gf_boolean_t _clear_counters) { + int ret = 0; + gfdb_db_operations_t *db_operations_t = NULL; + void *gf_db_connection = NULL; - int ret = 0; - gfdb_db_operations_t *db_operations_t = NULL; - void *gf_db_connection = NULL; - - CHECK_CONN_NODE(_conn_node); - - db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; - gf_db_connection = _conn_node->gfdb_connection.gf_db_connection; + CHECK_CONN_NODE(_conn_node); - if (db_operations_t->find_recently_changed_files_freq_op) { - - ret = db_operations_t->find_recently_changed_files_freq_op( - gf_db_connection, query_callback, - _query_cbk_args, from_time, - write_freq_thresold, read_freq_thresold, - _clear_counters); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_FIND_OP_FAILED, - "Find changed with freq operation failed"); - } + db_operations_t = &_conn_node->gfdb_connection.gfdb_db_operations; + gf_db_connection = _conn_node->gfdb_connection.gf_db_connection; + if (db_operations_t->find_recently_changed_files_freq_op) { + ret = db_operations_t->find_recently_changed_files_freq_op( + gf_db_connection, query_callback, _query_cbk_args, from_time, + write_freq_thresold, read_freq_thresold, _clear_counters); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_FIND_OP_FAILED, + "Find changed with freq operation failed"); } + } - return ret; - + return ret; } - - /*Libgfdb API Function: Clear the heat for all the files * * Arguments: @@ -725,30 +658,29 @@ find_recently_changed_files_freq(gfdb_conn_node_t *_conn_node, **/ int -clear_files_heat (gfdb_conn_node_t *conn_node) +clear_files_heat(gfdb_conn_node_t *conn_node) { - int ret = 0; - gfdb_db_operations_t *db_operations = NULL; - void *gf_db_connection = NULL; - - CHECK_CONN_NODE(conn_node); - - db_operations = &conn_node->gfdb_connection.gfdb_db_operations; - gf_db_connection = conn_node->gfdb_connection.gf_db_connection; - - if (db_operations->clear_files_heat_op) { - ret = db_operations->clear_files_heat_op (gf_db_connection); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_INSERT_OR_UPDATE_FAILED, - "Clear files heat operation failed"); - } + int ret = 0; + gfdb_db_operations_t *db_operations = NULL; + void *gf_db_connection = NULL; + + CHECK_CONN_NODE(conn_node); + + db_operations = &conn_node->gfdb_connection.gfdb_db_operations; + gf_db_connection = conn_node->gfdb_connection.gf_db_connection; + + if (db_operations->clear_files_heat_op) { + ret = db_operations->clear_files_heat_op(gf_db_connection); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, + LG_MSG_INSERT_OR_UPDATE_FAILED, + "Clear files heat operation failed"); } + } - return ret; + return ret; } - /* Libgfdb API Function: Function to extract version of the db * Input: * gfdb_conn_node_t *conn_node : GFDB Connection node @@ -761,122 +693,111 @@ clear_files_heat (gfdb_conn_node_t *conn_node) * On failure return -1 * */ int -get_db_version (gfdb_conn_node_t *conn_node, char **version) +get_db_version(gfdb_conn_node_t *conn_node, char **version) { - int ret = 0; - gfdb_db_operations_t *db_operations = NULL; - void *gf_db_connection = NULL; - - CHECK_CONN_NODE(conn_node); - - db_operations = &conn_node->gfdb_connection.gfdb_db_operations; - gf_db_connection = conn_node->gfdb_connection.gf_db_connection; - - if (db_operations->get_db_version) { - ret = db_operations->get_db_version (gf_db_connection, - version); - if (ret < 0) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_FIND_OP_FAILED, - "Get version failed"); - } + int ret = 0; + gfdb_db_operations_t *db_operations = NULL; + void *gf_db_connection = NULL; + + CHECK_CONN_NODE(conn_node); + + db_operations = &conn_node->gfdb_connection.gfdb_db_operations; + gf_db_connection = conn_node->gfdb_connection.gf_db_connection; + + if (db_operations->get_db_version) { + ret = db_operations->get_db_version(gf_db_connection, version); + if (ret < 0) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_FIND_OP_FAILED, + "Get version failed"); } + } - return ret; + return ret; } int -get_db_params (gfdb_conn_node_t *conn_node, char *param_key, - char **param_value) +get_db_params(gfdb_conn_node_t *conn_node, char *param_key, char **param_value) { - int ret = -1; - gfdb_db_operations_t *db_operations = NULL; - void *gf_db_connection = NULL; - - CHECK_CONN_NODE(conn_node); - - db_operations = &conn_node->gfdb_connection.gfdb_db_operations; - gf_db_connection = conn_node->gfdb_connection.gf_db_connection; - - if (db_operations->get_db_params) { - ret = db_operations->get_db_params (gf_db_connection, - param_key, - param_value); - if (ret < 0) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_FIND_OP_FAILED, - "Get setting failed"); - } + int ret = -1; + gfdb_db_operations_t *db_operations = NULL; + void *gf_db_connection = NULL; + + CHECK_CONN_NODE(conn_node); + + db_operations = &conn_node->gfdb_connection.gfdb_db_operations; + gf_db_connection = conn_node->gfdb_connection.gf_db_connection; + + if (db_operations->get_db_params) { + ret = db_operations->get_db_params(gf_db_connection, param_key, + param_value); + if (ret < 0) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_FIND_OP_FAILED, + "Get setting failed"); } + } - return ret; + return ret; } - int -set_db_params (gfdb_conn_node_t *conn_node, char *param_key, - char *param_value) +set_db_params(gfdb_conn_node_t *conn_node, char *param_key, char *param_value) { - int ret = -1; - gfdb_db_operations_t *db_operations = NULL; - void *gf_db_connection = NULL; - - CHECK_CONN_NODE(conn_node); - - db_operations = &conn_node->gfdb_connection.gfdb_db_operations; - gf_db_connection = conn_node->gfdb_connection.gf_db_connection; - - if (db_operations->set_db_params) { - ret = db_operations->set_db_params (gf_db_connection, - param_key, - param_value); - if (ret < 0) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_INSERT_OR_UPDATE_FAILED, - "Failed to set database setting"); - } + int ret = -1; + gfdb_db_operations_t *db_operations = NULL; + void *gf_db_connection = NULL; + + CHECK_CONN_NODE(conn_node); + + db_operations = &conn_node->gfdb_connection.gfdb_db_operations; + gf_db_connection = conn_node->gfdb_connection.gf_db_connection; + + if (db_operations->set_db_params) { + ret = db_operations->set_db_params(gf_db_connection, param_key, + param_value); + if (ret < 0) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, + LG_MSG_INSERT_OR_UPDATE_FAILED, + "Failed to set database setting"); } + } - return ret; + return ret; } - - - -static const -char *get_db_path_key() +static const char * +get_db_path_key() { - return GFDB_SQL_PARAM_DBPATH; + return GFDB_SQL_PARAM_DBPATH; } -void get_gfdb_methods (gfdb_methods_t *methods) +void +get_gfdb_methods(gfdb_methods_t *methods) { - methods->init_db = init_db; - methods->fini_db = fini_db; - methods->find_all = find_all; - methods->find_unchanged_for_time = find_unchanged_for_time; - methods->find_recently_changed_files = find_recently_changed_files; - methods->find_unchanged_for_time_freq = find_unchanged_for_time_freq; - methods->find_recently_changed_files_freq = - find_recently_changed_files_freq; - methods->clear_files_heat = clear_files_heat; - methods->get_db_version = get_db_version; - methods->get_db_params = get_db_params; - methods->set_db_params = set_db_params; - methods->get_db_path_key = get_db_path_key; - - /* Query Record related functions */ - methods->gfdb_query_record_new = gfdb_query_record_new; - methods->gfdb_query_record_free = gfdb_query_record_free; - methods->gfdb_add_link_to_query_record = gfdb_add_link_to_query_record; - methods->gfdb_write_query_record = gfdb_write_query_record; - methods->gfdb_read_query_record = gfdb_read_query_record; - - /* Link info related functions */ - methods->gfdb_link_info_new = gfdb_link_info_new; - methods->gfdb_link_info_free = gfdb_link_info_free; - - /* Compaction related functions */ - methods->compact_db = compact_db; + methods->init_db = init_db; + methods->fini_db = fini_db; + methods->find_all = find_all; + methods->find_unchanged_for_time = find_unchanged_for_time; + methods->find_recently_changed_files = find_recently_changed_files; + methods->find_unchanged_for_time_freq = find_unchanged_for_time_freq; + methods + ->find_recently_changed_files_freq = find_recently_changed_files_freq; + methods->clear_files_heat = clear_files_heat; + methods->get_db_version = get_db_version; + methods->get_db_params = get_db_params; + methods->set_db_params = set_db_params; + methods->get_db_path_key = get_db_path_key; + + /* Query Record related functions */ + methods->gfdb_query_record_new = gfdb_query_record_new; + methods->gfdb_query_record_free = gfdb_query_record_free; + methods->gfdb_add_link_to_query_record = gfdb_add_link_to_query_record; + methods->gfdb_write_query_record = gfdb_write_query_record; + methods->gfdb_read_query_record = gfdb_read_query_record; + + /* Link info related functions */ + methods->gfdb_link_info_new = gfdb_link_info_new; + methods->gfdb_link_info_free = gfdb_link_info_free; + + /* Compaction related functions */ + methods->compact_db = compact_db; } - diff --git a/libglusterfs/src/gfdb/gfdb_data_store_helper.c b/libglusterfs/src/gfdb/gfdb_data_store_helper.c index 39a97ff73d9..fb01a6c699b 100644 --- a/libglusterfs/src/gfdb/gfdb_data_store_helper.c +++ b/libglusterfs/src/gfdb/gfdb_data_store_helper.c @@ -9,151 +9,139 @@ * ****************************************************************************/ /*Create a single link info structure*/ -gfdb_link_info_t* -gfdb_link_info_new () +gfdb_link_info_t * +gfdb_link_info_new() { - gfdb_link_info_t *link_info = NULL; + gfdb_link_info_t *link_info = NULL; - link_info = GF_CALLOC (1, sizeof(gfdb_link_info_t), - gf_mt_gfdb_link_info_t); - if (!link_info) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ENOMEM, - LG_MSG_NO_MEMORY, "Memory allocation failed for " - "link_info "); - goto out; - } + link_info = GF_CALLOC(1, sizeof(gfdb_link_info_t), gf_mt_gfdb_link_info_t); + if (!link_info) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY, + "Memory allocation failed for " + "link_info "); + goto out; + } - INIT_LIST_HEAD (&link_info->list); + INIT_LIST_HEAD(&link_info->list); out: - return link_info; + return link_info; } /*Destroy a link info structure*/ void gfdb_link_info_free(gfdb_link_info_t *link_info) { - GF_FREE (link_info); + GF_FREE(link_info); } - /*Function to create the query_record*/ gfdb_query_record_t * gfdb_query_record_new() { - int ret = -1; - gfdb_query_record_t *query_record = NULL; - - query_record = GF_CALLOC (1, sizeof(gfdb_query_record_t), - gf_mt_gfdb_query_record_t); - if (!query_record) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, ENOMEM, - LG_MSG_NO_MEMORY, "Memory allocation failed for " - "query_record "); - goto out; - } + int ret = -1; + gfdb_query_record_t *query_record = NULL; - INIT_LIST_HEAD (&query_record->link_list); + query_record = GF_CALLOC(1, sizeof(gfdb_query_record_t), + gf_mt_gfdb_query_record_t); + if (!query_record) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY, + "Memory allocation failed for " + "query_record "); + goto out; + } - ret = 0; + INIT_LIST_HEAD(&query_record->link_list); + + ret = 0; out: - if (ret == -1) { - GF_FREE (query_record); - } - return query_record; + if (ret == -1) { + GF_FREE(query_record); + } + return query_record; } - /*Function to delete a single linkinfo from list*/ static void -gfdb_delete_linkinfo_from_list (gfdb_link_info_t **link_info) +gfdb_delete_linkinfo_from_list(gfdb_link_info_t **link_info) { - GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, link_info, out); - GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, *link_info, out); + GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, link_info, out); + GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, *link_info, out); - /*Remove hard link from list*/ - list_del(&(*link_info)->list); - gfdb_link_info_free (*link_info); - link_info = NULL; + /*Remove hard link from list*/ + list_del(&(*link_info)->list); + gfdb_link_info_free(*link_info); + link_info = NULL; out: - return; + return; } - /*Function to destroy link_info list*/ void -gfdb_free_link_info_list (gfdb_query_record_t *query_record) +gfdb_free_link_info_list(gfdb_query_record_t *query_record) { - gfdb_link_info_t *link_info = NULL; - gfdb_link_info_t *temp = NULL; + gfdb_link_info_t *link_info = NULL; + gfdb_link_info_t *temp = NULL; - GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out); + GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, query_record, out); - list_for_each_entry_safe(link_info, temp, - &query_record->link_list, list) - { - gfdb_delete_linkinfo_from_list (&link_info); - link_info = NULL; - } + list_for_each_entry_safe(link_info, temp, &query_record->link_list, list) + { + gfdb_delete_linkinfo_from_list(&link_info); + link_info = NULL; + } out: - return; + return; } - - /* Function to add linkinfo to the query record */ int -gfdb_add_link_to_query_record (gfdb_query_record_t *query_record, - uuid_t pgfid, - char *base_name) +gfdb_add_link_to_query_record(gfdb_query_record_t *query_record, uuid_t pgfid, + char *base_name) { - int ret = -1; - gfdb_link_info_t *link_info = NULL; - int base_name_len = 0; + int ret = -1; + gfdb_link_info_t *link_info = NULL; + int base_name_len = 0; - GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out); - GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, pgfid, out); - GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, base_name, out); + GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, query_record, out); + GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, pgfid, out); + GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, base_name, out); - link_info = gfdb_link_info_new (); - if (!link_info) { - goto out; - } + link_info = gfdb_link_info_new(); + if (!link_info) { + goto out; + } - gf_uuid_copy (link_info->pargfid, pgfid); - base_name_len = strlen (base_name); - memcpy (link_info->file_name, base_name, base_name_len); - link_info->file_name[base_name_len] = '\0'; + gf_uuid_copy(link_info->pargfid, pgfid); + base_name_len = strlen(base_name); + memcpy(link_info->file_name, base_name, base_name_len); + link_info->file_name[base_name_len] = '\0'; - list_add_tail (&link_info->list, - &query_record->link_list); + list_add_tail(&link_info->list, &query_record->link_list); - query_record->link_count++; + query_record->link_count++; - ret = 0; + ret = 0; out: - if (ret) { - gfdb_link_info_free (link_info); - link_info = NULL; - } - return ret; + if (ret) { + gfdb_link_info_free(link_info); + link_info = NULL; + } + return ret; } - - /*Function to destroy query record*/ void gfdb_query_record_free(gfdb_query_record_t *query_record) { - if (query_record) { - gfdb_free_link_info_list (query_record); - GF_FREE (query_record); - } + if (query_record) { + gfdb_free_link_info_list(query_record); + GF_FREE(query_record); + } } - /****************************************************************************** SERIALIZATION/DE-SERIALIZATION OF QUERY RECORD *******************************************************************************/ @@ -197,40 +185,39 @@ gfdb_query_record_free(gfdb_query_record_t *query_record) * ****************************************************************************/ #define GFDB_QUERY_RECORD_FOOTER 0xBAADF00D -#define UUID_LEN 16 +#define UUID_LEN 16 /*Function to get the potential length of the serialized buffer*/ static int32_t -gfdb_query_record_serialized_length (gfdb_query_record_t *query_record) +gfdb_query_record_serialized_length(gfdb_query_record_t *query_record) { - int32_t len = -1; - gfdb_link_info_t *link_info = NULL; - - GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out); + int32_t len = -1; + gfdb_link_info_t *link_info = NULL; - /* Length of GFID */ - len = UUID_LEN; + GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, query_record, out); - /* length of number of links*/ - len += sizeof (int32_t); + /* Length of GFID */ + len = UUID_LEN; - list_for_each_entry (link_info, &query_record->link_list, list) { + /* length of number of links*/ + len += sizeof(int32_t); - /* length of PFID */ - len += UUID_LEN; + list_for_each_entry(link_info, &query_record->link_list, list) + { + /* length of PFID */ + len += UUID_LEN; - /* Add size of base name length*/ - len += sizeof (int32_t); + /* Add size of base name length*/ + len += sizeof(int32_t); - /* Length of base_name */ - len += strlen (link_info->file_name); - - } + /* Length of base_name */ + len += strlen(link_info->file_name); + } - /* length of footer */ - len += sizeof (int32_t); + /* length of footer */ + len += sizeof(int32_t); out: - return len; + return len; } /* Function for serializing query record. @@ -259,210 +246,200 @@ out: * * */ static int -gfdb_query_record_serialize (gfdb_query_record_t *query_record, - char **in_buffer) +gfdb_query_record_serialize(gfdb_query_record_t *query_record, char **in_buffer) { - gfdb_link_info_t *link_info = NULL; - int count = -1; - int base_name_len = 0; - int buffer_length = 0; - int footer = GFDB_QUERY_RECORD_FOOTER; - char *buffer = NULL; - char *ret_buffer = NULL; - - GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out); - GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, - (query_record->link_count > 0), out); - GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, in_buffer, out); - - - /* Calculate the total length of the serialized buffer */ - buffer_length = gfdb_query_record_serialized_length (query_record); - if (buffer_length <= 0) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_DB_ERROR, "Failed to calculate the length of " - "serialized buffer"); - goto out; - } - - /* Allocate memory to the serialized buffer */ - ret_buffer = GF_CALLOC (1, buffer_length, gf_common_mt_char); - if (!ret_buffer) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_DB_ERROR, "Memory allocation failed for " - "serialized buffer."); - goto out; - } - - buffer = ret_buffer; - - count = 0; - - /* Copying the GFID */ - memcpy (buffer, query_record->gfid, UUID_LEN); + gfdb_link_info_t *link_info = NULL; + int count = -1; + int base_name_len = 0; + int buffer_length = 0; + int footer = GFDB_QUERY_RECORD_FOOTER; + char *buffer = NULL; + char *ret_buffer = NULL; + + GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, query_record, out); + GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, (query_record->link_count > 0), out); + GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, in_buffer, out); + + /* Calculate the total length of the serialized buffer */ + buffer_length = gfdb_query_record_serialized_length(query_record); + if (buffer_length <= 0) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR, + "Failed to calculate the length of " + "serialized buffer"); + goto out; + } + + /* Allocate memory to the serialized buffer */ + ret_buffer = GF_CALLOC(1, buffer_length, gf_common_mt_char); + if (!ret_buffer) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR, + "Memory allocation failed for " + "serialized buffer."); + goto out; + } + + buffer = ret_buffer; + + count = 0; + + /* Copying the GFID */ + memcpy(buffer, query_record->gfid, UUID_LEN); + buffer += UUID_LEN; + count += UUID_LEN; + + /* Copying the number of links */ + memcpy(buffer, &query_record->link_count, sizeof(int32_t)); + buffer += sizeof(int32_t); + count += sizeof(int32_t); + + list_for_each_entry(link_info, &query_record->link_list, list) + { + /* Copying the PFID */ + memcpy(buffer, link_info->pargfid, UUID_LEN); buffer += UUID_LEN; count += UUID_LEN; - /* Copying the number of links */ - memcpy (buffer, &query_record->link_count, sizeof (int32_t)); - buffer += sizeof (int32_t); - count += sizeof (int32_t); - - list_for_each_entry (link_info, &query_record->link_list, list) { - - /* Copying the PFID */ - memcpy(buffer, link_info->pargfid, UUID_LEN); - buffer += UUID_LEN; - count += UUID_LEN; - - /* Copying base name length*/ - base_name_len = strlen (link_info->file_name); - memcpy (buffer, &base_name_len, sizeof (int32_t)); - buffer += sizeof (int32_t); - count += sizeof (int32_t); + /* Copying base name length*/ + base_name_len = strlen(link_info->file_name); + memcpy(buffer, &base_name_len, sizeof(int32_t)); + buffer += sizeof(int32_t); + count += sizeof(int32_t); - /* Length of base_name */ - memcpy(buffer, link_info->file_name, base_name_len); - buffer += base_name_len; - count += base_name_len; + /* Length of base_name */ + memcpy(buffer, link_info->file_name, base_name_len); + buffer += base_name_len; + count += base_name_len; + } - } - - /* Copying the Footer of the record */ - memcpy (buffer, &footer, sizeof (int32_t)); - buffer += sizeof (int32_t); - count += sizeof (int32_t); + /* Copying the Footer of the record */ + memcpy(buffer, &footer, sizeof(int32_t)); + buffer += sizeof(int32_t); + count += sizeof(int32_t); out: - if (count < 0) { - GF_FREE (ret_buffer); - ret_buffer = NULL; - } - *in_buffer = ret_buffer; - return count; + if (count < 0) { + GF_FREE(ret_buffer); + ret_buffer = NULL; + } + *in_buffer = ret_buffer; + return count; } static gf_boolean_t -is_serialized_buffer_valid (char *in_buffer, int buffer_length) { - gf_boolean_t ret = _gf_false; - int footer = 0; - - /* Read the footer */ - in_buffer += (buffer_length - sizeof (int32_t)); - memcpy (&footer, in_buffer, sizeof (int32_t)); - - /* - * if the footer is not GFDB_QUERY_RECORD_FOOTER - * then the serialized record is invalid - * - * */ - if (footer != GFDB_QUERY_RECORD_FOOTER) { - goto out; - } - - ret = _gf_true; +is_serialized_buffer_valid(char *in_buffer, int buffer_length) +{ + gf_boolean_t ret = _gf_false; + int footer = 0; + + /* Read the footer */ + in_buffer += (buffer_length - sizeof(int32_t)); + memcpy(&footer, in_buffer, sizeof(int32_t)); + + /* + * if the footer is not GFDB_QUERY_RECORD_FOOTER + * then the serialized record is invalid + * + * */ + if (footer != GFDB_QUERY_RECORD_FOOTER) { + goto out; + } + + ret = _gf_true; out: - return ret; + return ret; } - static int -gfdb_query_record_deserialize (char *in_buffer, - int buffer_length, - gfdb_query_record_t **query_record) +gfdb_query_record_deserialize(char *in_buffer, int buffer_length, + gfdb_query_record_t **query_record) { - int ret = -1; - char *buffer = NULL; - int i = 0; - gfdb_link_info_t *link_info = NULL; - int count = 0; - int base_name_len = 0; - gfdb_query_record_t *ret_qrecord = NULL; - - GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, in_buffer, out); - GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out); - GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, (buffer_length > 0), out); - - if (!is_serialized_buffer_valid (in_buffer, buffer_length)) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_DB_ERROR, "Invalid serialized query record"); - goto out; + int ret = -1; + char *buffer = NULL; + int i = 0; + gfdb_link_info_t *link_info = NULL; + int count = 0; + int base_name_len = 0; + gfdb_query_record_t *ret_qrecord = NULL; + + GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, in_buffer, out); + GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, query_record, out); + GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, (buffer_length > 0), out); + + if (!is_serialized_buffer_valid(in_buffer, buffer_length)) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR, + "Invalid serialized query record"); + goto out; + } + + buffer = in_buffer; + + ret_qrecord = gfdb_query_record_new(); + if (!ret_qrecord) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR, + "Failed to allocate space to " + "gfdb_query_record_t"); + goto out; + } + + /* READ GFID */ + memcpy((ret_qrecord)->gfid, buffer, UUID_LEN); + buffer += UUID_LEN; + count += UUID_LEN; + + /* Read the number of link */ + memcpy(&(ret_qrecord->link_count), buffer, sizeof(int32_t)); + buffer += sizeof(int32_t); + count += sizeof(int32_t); + + /* Read all the links */ + for (i = 0; i < ret_qrecord->link_count; i++) { + if (count >= buffer_length) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR, + "Invalid serialized " + "query record"); + ret = -1; + goto out; } - buffer = in_buffer; - - ret_qrecord = gfdb_query_record_new (); - if (!ret_qrecord) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_DB_ERROR, "Failed to allocate space to " - "gfdb_query_record_t"); - goto out; + link_info = gfdb_link_info_new(); + if (!link_info) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR, + "Failed to create link_info"); + goto out; } - /* READ GFID */ - memcpy ((ret_qrecord)->gfid, buffer, UUID_LEN); + /* READ PGFID */ + memcpy(link_info->pargfid, buffer, UUID_LEN); buffer += UUID_LEN; count += UUID_LEN; - /* Read the number of link */ - memcpy (&(ret_qrecord->link_count), buffer, sizeof (int32_t)); - buffer += sizeof (int32_t); - count += sizeof (int32_t); - - /* Read all the links */ - for (i = 0; i < ret_qrecord->link_count; i++) { - if (count >= buffer_length) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_DB_ERROR, "Invalid serialized " - "query record"); - ret = -1; - goto out; - } - - link_info = gfdb_link_info_new (); - if (!link_info) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_DB_ERROR, "Failed to create link_info"); - goto out; - } - - /* READ PGFID */ - memcpy (link_info->pargfid, buffer, UUID_LEN); - buffer += UUID_LEN; - count += UUID_LEN; - - /* Read base name length */ - memcpy (&base_name_len, buffer, sizeof (int32_t)); - buffer += sizeof (int32_t); - count += sizeof (int32_t); - - /* READ basename */ - memcpy (link_info->file_name, buffer, base_name_len); - buffer += base_name_len; - count += base_name_len; - link_info->file_name[base_name_len] = '\0'; - - /* Add link_info to the list */ - list_add_tail (&link_info->list, - &(ret_qrecord->link_list)); - - /* Resetting link_info */ - link_info = NULL; - } - - ret = 0; -out: - if (ret) { - gfdb_query_record_free (ret_qrecord); - ret_qrecord = NULL; - } - *query_record = ret_qrecord; - return ret; -} + /* Read base name length */ + memcpy(&base_name_len, buffer, sizeof(int32_t)); + buffer += sizeof(int32_t); + count += sizeof(int32_t); + /* READ basename */ + memcpy(link_info->file_name, buffer, base_name_len); + buffer += base_name_len; + count += base_name_len; + link_info->file_name[base_name_len] = '\0'; + /* Add link_info to the list */ + list_add_tail(&link_info->list, &(ret_qrecord->link_list)); + /* Resetting link_info */ + link_info = NULL; + } + ret = 0; +out: + if (ret) { + gfdb_query_record_free(ret_qrecord); + ret_qrecord = NULL; + } + *query_record = ret_qrecord; + return ret; +} /* Function to write query record to file * @@ -477,57 +454,54 @@ out: * * */ int -gfdb_write_query_record (int fd, - gfdb_query_record_t *query_record) +gfdb_write_query_record(int fd, gfdb_query_record_t *query_record) { - int ret = -1; - int buffer_len = 0; - char *buffer = NULL; - int write_len = 0; - char *write_buffer = NULL; - - GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, (fd >= 0), out); - GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out); - - buffer_len = gfdb_query_record_serialize (query_record, &buffer); - if (buffer_len < 0) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_DB_ERROR, "Failed to serialize query record"); - goto out; - } - - /* Serialize the buffer length and write to file */ - ret = write (fd, &buffer_len, sizeof (int32_t)); + int ret = -1; + int buffer_len = 0; + char *buffer = NULL; + int write_len = 0; + char *write_buffer = NULL; + + GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, (fd >= 0), out); + GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, query_record, out); + + buffer_len = gfdb_query_record_serialize(query_record, &buffer); + if (buffer_len < 0) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR, + "Failed to serialize query record"); + goto out; + } + + /* Serialize the buffer length and write to file */ + ret = write(fd, &buffer_len, sizeof(int32_t)); + if (ret < 0) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR, + "Failed to write buffer length" + " to file"); + goto out; + } + + /* Write the serialized query record to file */ + write_len = buffer_len; + write_buffer = buffer; + while ((ret = write(fd, write_buffer, write_len)) < write_len) { if (ret < 0) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_DB_ERROR, "Failed to write buffer length" - " to file"); - goto out; + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, errno, LG_MSG_DB_ERROR, + "Failed to write serialized " + "query record to file"); + goto out; } - /* Write the serialized query record to file */ - write_len = buffer_len; - write_buffer = buffer; - while ((ret = write (fd, write_buffer, write_len)) < write_len) { - if (ret < 0) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, errno, - LG_MSG_DB_ERROR, "Failed to write serialized " - "query record to file"); - goto out; - } - - write_buffer += ret; - write_len -= ret; - } + write_buffer += ret; + write_len -= ret; + } - ret = 0; + ret = 0; out: - GF_FREE (buffer); - return ret; + GF_FREE(buffer); + return ret; } - - /* Function to read query record from file. * Allocates memory to query record and * returns length of serialized query record when successful @@ -535,86 +509,81 @@ out: * Return 0 when reached EOF. * */ int -gfdb_read_query_record (int fd, - gfdb_query_record_t **query_record) +gfdb_read_query_record(int fd, gfdb_query_record_t **query_record) { - int ret = -1; - int buffer_len = 0; - int read_len = 0; - char *buffer = NULL; - char *read_buffer = NULL; - - GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, (fd >= 0), out); - GF_VALIDATE_OR_GOTO (GFDB_DATA_STORE, query_record, out); - - - /* Read serialized query record length from the file*/ - ret = sys_read (fd, &buffer_len, sizeof (int32_t)); + int ret = -1; + int buffer_len = 0; + int read_len = 0; + char *buffer = NULL; + char *read_buffer = NULL; + + GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, (fd >= 0), out); + GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, query_record, out); + + /* Read serialized query record length from the file*/ + ret = sys_read(fd, &buffer_len, sizeof(int32_t)); + if (ret < 0) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR, + "Failed reading buffer length" + " from file"); + goto out; + } + /* EOF */ + else if (ret == 0) { + ret = 0; + goto out; + } + + /* Assumed sane range is 1B - 10MB */ + if ((buffer_len <= 0) || (buffer_len > (10 * 1024 * 1024))) { + ret = -1; + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR, + "buffer length range is out of bound %d", buffer_len); + goto out; + } + + /* Allocating memory to the serialization buffer */ + buffer = GF_CALLOC(1, buffer_len, gf_common_mt_char); + if (!buffer) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR, + "Failed to allocate space to " + "serialized buffer"); + goto out; + } + + /* Read the serialized query record from file */ + read_len = buffer_len; + read_buffer = buffer; + while ((ret = sys_read(fd, read_buffer, read_len)) < read_len) { + /*Any error */ if (ret < 0) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_DB_ERROR, "Failed reading buffer length" - " from file"); - goto out; + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, errno, LG_MSG_DB_ERROR, + "Failed to read serialized " + "query record from file"); + goto out; } /* EOF */ else if (ret == 0) { - ret = 0; - goto out; + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR, + "Invalid query record or " + "corrupted query file"); + ret = -1; + goto out; } - /* Assumed sane range is 1B - 10MB */ - if ((buffer_len <= 0) || (buffer_len > (10 * 1024 * 1024))) { - ret = -1; - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR, - "buffer length range is out of bound %d", buffer_len); - goto out; - } - - /* Allocating memory to the serialization buffer */ - buffer = GF_CALLOC (1, buffer_len, gf_common_mt_char); - if (!buffer) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_DB_ERROR, "Failed to allocate space to " - "serialized buffer"); - goto out; - } + read_buffer += ret; + read_len -= ret; + } + ret = gfdb_query_record_deserialize(buffer, buffer_len, query_record); + if (ret) { + gf_msg(GFDB_DATA_STORE, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR, + "Failed to de-serialize query record"); + goto out; + } - /* Read the serialized query record from file */ - read_len = buffer_len; - read_buffer = buffer; - while ((ret = sys_read (fd, read_buffer, read_len)) < read_len) { - - /*Any error */ - if (ret < 0) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, errno, - LG_MSG_DB_ERROR, "Failed to read serialized " - "query record from file"); - goto out; - } - /* EOF */ - else if (ret == 0) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_DB_ERROR, "Invalid query record or " - "corrupted query file"); - ret = -1; - goto out; - } - - read_buffer += ret; - read_len -= ret; - } - - ret = gfdb_query_record_deserialize (buffer, buffer_len, - query_record); - if (ret) { - gf_msg (GFDB_DATA_STORE, GF_LOG_ERROR, 0, - LG_MSG_DB_ERROR, "Failed to de-serialize query record"); - goto out; - } - - ret = buffer_len; + ret = buffer_len; out: - GF_FREE (buffer); - return ret; + GF_FREE(buffer); + return ret; } diff --git a/libglusterfs/src/gfdb/gfdb_sqlite3.c b/libglusterfs/src/gfdb/gfdb_sqlite3.c index ad94d648369..63957278e8a 100644 --- a/libglusterfs/src/gfdb/gfdb_sqlite3.c +++ b/libglusterfs/src/gfdb/gfdb_sqlite3.c @@ -19,160 +19,158 @@ * * ***************************************************************************/ gf_sql_connection_t * -gf_sql_connection_init () +gf_sql_connection_init() { - gf_sql_connection_t *gf_sql_conn = NULL; - - gf_sql_conn = GF_CALLOC (1, sizeof(gf_sql_connection_t), - gf_mt_sql_connection_t); - if (gf_sql_conn == NULL) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, ENOMEM, - LG_MSG_NO_MEMORY, "Error allocating memory to " - "gf_sql_connection_t "); - } + gf_sql_connection_t *gf_sql_conn = NULL; + + gf_sql_conn = GF_CALLOC(1, sizeof(gf_sql_connection_t), + gf_mt_sql_connection_t); + if (gf_sql_conn == NULL) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY, + "Error allocating memory to " + "gf_sql_connection_t "); + } - return gf_sql_conn; + return gf_sql_conn; } void -gf_sql_connection_fini (gf_sql_connection_t **sql_connection) +gf_sql_connection_fini(gf_sql_connection_t **sql_connection) { - if (!sql_connection) - return; - GF_FREE (*sql_connection); - *sql_connection = NULL; + if (!sql_connection) + return; + GF_FREE(*sql_connection); + *sql_connection = NULL; } const char * -gf_sql_jm2str (gf_sql_journal_mode_t jm) +gf_sql_jm2str(gf_sql_journal_mode_t jm) { - switch (jm) { + switch (jm) { case gf_sql_jm_delete: - return GF_SQL_JM_DELETE; + return GF_SQL_JM_DELETE; case gf_sql_jm_truncate: - return GF_SQL_JM_TRUNCATE; + return GF_SQL_JM_TRUNCATE; case gf_sql_jm_persist: - return GF_SQL_JM_PERSIST; + return GF_SQL_JM_PERSIST; case gf_sql_jm_memory: - return GF_SQL_JM_MEMORY; + return GF_SQL_JM_MEMORY; case gf_sql_jm_wal: - return GF_SQL_JM_WAL; + return GF_SQL_JM_WAL; case gf_sql_jm_off: - return GF_SQL_JM_OFF; + return GF_SQL_JM_OFF; case gf_sql_jm_invalid: - break; - } - return NULL; + break; + } + return NULL; } gf_sql_journal_mode_t -gf_sql_str2jm (const char *jm_str) +gf_sql_str2jm(const char *jm_str) { - if (!jm_str) { - return gf_sql_jm_invalid; - } else if (strcmp (jm_str, GF_SQL_JM_DELETE) == 0) { - return gf_sql_jm_delete; - } else if (strcmp (jm_str, GF_SQL_JM_TRUNCATE) == 0) { - return gf_sql_jm_truncate; - } else if (strcmp (jm_str, GF_SQL_JM_PERSIST) == 0) { - return gf_sql_jm_persist; - } else if (strcmp (jm_str, GF_SQL_JM_MEMORY) == 0) { - return gf_sql_jm_memory; - } else if (strcmp (jm_str, GF_SQL_JM_WAL) == 0) { - return gf_sql_jm_wal; - } else if (strcmp (jm_str, GF_SQL_JM_OFF) == 0) { - return gf_sql_jm_off; - } + if (!jm_str) { return gf_sql_jm_invalid; + } else if (strcmp(jm_str, GF_SQL_JM_DELETE) == 0) { + return gf_sql_jm_delete; + } else if (strcmp(jm_str, GF_SQL_JM_TRUNCATE) == 0) { + return gf_sql_jm_truncate; + } else if (strcmp(jm_str, GF_SQL_JM_PERSIST) == 0) { + return gf_sql_jm_persist; + } else if (strcmp(jm_str, GF_SQL_JM_MEMORY) == 0) { + return gf_sql_jm_memory; + } else if (strcmp(jm_str, GF_SQL_JM_WAL) == 0) { + return gf_sql_jm_wal; + } else if (strcmp(jm_str, GF_SQL_JM_OFF) == 0) { + return gf_sql_jm_off; + } + return gf_sql_jm_invalid; } const char * -gf_sql_av_t2str (gf_sql_auto_vacuum_t sql_av) +gf_sql_av_t2str(gf_sql_auto_vacuum_t sql_av) { - switch (sql_av) { + switch (sql_av) { case gf_sql_av_none: - return GF_SQL_AV_NONE; + return GF_SQL_AV_NONE; case gf_sql_av_full: - return GF_SQL_AV_FULL; + return GF_SQL_AV_FULL; case gf_sql_av_incr: - return GF_SQL_AV_INCR; + return GF_SQL_AV_INCR; case gf_sql_av_invalid: - break; - } - return NULL; + break; + } + return NULL; } gf_sql_auto_vacuum_t -gf_sql_str2av_t (const char *av_str) +gf_sql_str2av_t(const char *av_str) { - if (!av_str) { - return gf_sql_av_invalid; - } else if (strcmp (av_str, GF_SQL_AV_NONE) == 0) { - return gf_sql_av_none; - } else if (strcmp (av_str, GF_SQL_AV_FULL) == 0) { - return gf_sql_av_full; - } else if (strcmp (av_str, GF_SQL_AV_INCR) == 0) { - return gf_sql_av_incr; - } + if (!av_str) { return gf_sql_av_invalid; + } else if (strcmp(av_str, GF_SQL_AV_NONE) == 0) { + return gf_sql_av_none; + } else if (strcmp(av_str, GF_SQL_AV_FULL) == 0) { + return gf_sql_av_full; + } else if (strcmp(av_str, GF_SQL_AV_INCR) == 0) { + return gf_sql_av_incr; + } + return gf_sql_av_invalid; } const char * -gf_sync_t2str (gf_sql_sync_t sql_sync) +gf_sync_t2str(gf_sql_sync_t sql_sync) { - switch (sql_sync) { + switch (sql_sync) { case gf_sql_sync_off: - return GF_SQL_SYNC_OFF; + return GF_SQL_SYNC_OFF; case gf_sql_sync_normal: - return GF_SQL_SYNC_NORMAL; + return GF_SQL_SYNC_NORMAL; case gf_sql_sync_full: - return GF_SQL_SYNC_FULL; + return GF_SQL_SYNC_FULL; case gf_sql_sync_invalid: - break; - } - return NULL; + break; + } + return NULL; } gf_sql_sync_t -gf_sql_str2sync_t (const char *sync_str) +gf_sql_str2sync_t(const char *sync_str) { - if (!sync_str) { - return gf_sql_sync_invalid; - } else if (strcmp (sync_str, GF_SQL_SYNC_OFF) == 0) { - return gf_sql_sync_off; - } else if (strcmp (sync_str, GF_SQL_SYNC_NORMAL) == 0) { - return gf_sql_sync_normal; - } else if (strcmp (sync_str, GF_SQL_SYNC_FULL) == 0) { - return gf_sql_sync_full; - } + if (!sync_str) { return gf_sql_sync_invalid; + } else if (strcmp(sync_str, GF_SQL_SYNC_OFF) == 0) { + return gf_sql_sync_off; + } else if (strcmp(sync_str, GF_SQL_SYNC_NORMAL) == 0) { + return gf_sql_sync_normal; + } else if (strcmp(sync_str, GF_SQL_SYNC_FULL) == 0) { + return gf_sql_sync_full; + } + return gf_sql_sync_invalid; } - /*TODO replace GF_CALLOC by mem_pool or iobuff if required for performance */ static char * -sql_stmt_init () +sql_stmt_init() { - char *sql_stmt = NULL; + char *sql_stmt = NULL; - sql_stmt = GF_CALLOC (GF_STMT_SIZE_MAX, sizeof(char), - gf_common_mt_char); + sql_stmt = GF_CALLOC(GF_STMT_SIZE_MAX, sizeof(char), gf_common_mt_char); - if (!sql_stmt) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, ENOMEM, - LG_MSG_NO_MEMORY, "Error allocating memory to SQL " - "Statement "); - goto out; - } + if (!sql_stmt) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, ENOMEM, LG_MSG_NO_MEMORY, + "Error allocating memory to SQL " + "Statement "); + goto out; + } out: - return sql_stmt; + return sql_stmt; } /*TODO replace GF_FREE by mem_pool or iobuff if required for performance */ static void -sql_stmt_fini (char **sql_stmt) +sql_stmt_fini(char **sql_stmt) { - GF_FREE (*sql_stmt); + GF_FREE(*sql_stmt); } /****************************************************************************** @@ -183,334 +181,313 @@ sql_stmt_fini (char **sql_stmt) static sqlite3 * gf_open_sqlite3_conn(char *sqlite3_db_path, int flags) { - sqlite3 *sqlite3_db_conn = NULL; - int ret = -1; - - GF_ASSERT (sqlite3_db_path); - - /*Creates DB if not created*/ - ret = sqlite3_open_v2 (sqlite3_db_path, &sqlite3_db_conn, flags, NULL); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR, - "FATAL: Could open %s : %s", - sqlite3_db_path, sqlite3_errmsg (sqlite3_db_conn)); - } - return sqlite3_db_conn; + sqlite3 *sqlite3_db_conn = NULL; + int ret = -1; + + GF_ASSERT(sqlite3_db_path); + + /*Creates DB if not created*/ + ret = sqlite3_open_v2(sqlite3_db_path, &sqlite3_db_conn, flags, NULL); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_DB_ERROR, + "FATAL: Could open %s : %s", sqlite3_db_path, + sqlite3_errmsg(sqlite3_db_conn)); + } + return sqlite3_db_conn; } static int gf_close_sqlite3_conn(sqlite3 *sqlite3_db_conn) { - int ret = 0; - - GF_ASSERT (sqlite3_db_conn); - - if (sqlite3_db_conn) { - ret = sqlite3_close (sqlite3_db_conn); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_CONNECTION_ERROR, "FATAL: sqlite3 close" - " connection failed %s", - sqlite3_errmsg (sqlite3_db_conn)); - ret = -1; - goto out; - } - } - ret = 0; + int ret = 0; + + GF_ASSERT(sqlite3_db_conn); + + if (sqlite3_db_conn) { + ret = sqlite3_close(sqlite3_db_conn); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CONNECTION_ERROR, + "FATAL: sqlite3 close" + " connection failed %s", + sqlite3_errmsg(sqlite3_db_conn)); + ret = -1; + goto out; + } + } + ret = 0; out: - return ret; + return ret; } /****************************************************************************** -* -* Database init / fini / create table -* -* ***************************************************************************/ - + * + * Database init / fini / create table + * + * ***************************************************************************/ /*Function to fill db operations*/ void -gf_sqlite3_fill_db_operations(gfdb_db_operations_t *gfdb_db_ops) +gf_sqlite3_fill_db_operations(gfdb_db_operations_t *gfdb_db_ops) { - GF_ASSERT (gfdb_db_ops); + GF_ASSERT(gfdb_db_ops); - gfdb_db_ops->init_db_op = gf_sqlite3_init; - gfdb_db_ops->fini_db_op = gf_sqlite3_fini; + gfdb_db_ops->init_db_op = gf_sqlite3_init; + gfdb_db_ops->fini_db_op = gf_sqlite3_fini; - gfdb_db_ops->insert_record_op = gf_sqlite3_insert; - gfdb_db_ops->delete_record_op = gf_sqlite3_delete; - gfdb_db_ops->compact_db_op = gf_sqlite3_vacuum; + gfdb_db_ops->insert_record_op = gf_sqlite3_insert; + gfdb_db_ops->delete_record_op = gf_sqlite3_delete; + gfdb_db_ops->compact_db_op = gf_sqlite3_vacuum; - gfdb_db_ops->find_all_op = gf_sqlite3_find_all; - gfdb_db_ops->find_unchanged_for_time_op = - gf_sqlite3_find_unchanged_for_time; - gfdb_db_ops->find_recently_changed_files_op = - gf_sqlite3_find_recently_changed_files; - gfdb_db_ops->find_unchanged_for_time_freq_op = - gf_sqlite3_find_unchanged_for_time_freq; - gfdb_db_ops->find_recently_changed_files_freq_op = - gf_sqlite3_find_recently_changed_files_freq; + gfdb_db_ops->find_all_op = gf_sqlite3_find_all; + gfdb_db_ops + ->find_unchanged_for_time_op = gf_sqlite3_find_unchanged_for_time; + gfdb_db_ops->find_recently_changed_files_op = + gf_sqlite3_find_recently_changed_files; + gfdb_db_ops->find_unchanged_for_time_freq_op = + gf_sqlite3_find_unchanged_for_time_freq; + gfdb_db_ops->find_recently_changed_files_freq_op = + gf_sqlite3_find_recently_changed_files_freq; - gfdb_db_ops->clear_files_heat_op = gf_sqlite3_clear_files_heat; + gfdb_db_ops->clear_files_heat_op = gf_sqlite3_clear_files_heat; - gfdb_db_ops->get_db_version = gf_sqlite3_version; + gfdb_db_ops->get_db_version = gf_sqlite3_version; - gfdb_db_ops->get_db_params = gf_sqlite3_pragma; + gfdb_db_ops->get_db_params = gf_sqlite3_pragma; - gfdb_db_ops->set_db_params = gf_sqlite3_set_pragma; + gfdb_db_ops->set_db_params = gf_sqlite3_set_pragma; } - static int -create_filetable (sqlite3 *sqlite3_db_conn) +create_filetable(sqlite3 *sqlite3_db_conn) { - int ret = -1; - char *sql_stmt = NULL; - char *sql_strerror = NULL; - - GF_ASSERT(sqlite3_db_conn); - - sql_stmt = sql_stmt_init (); - if (!sql_stmt) { - ret = ENOMEM; - goto out; - } - - GF_CREATE_STMT(sql_stmt); - - ret = sqlite3_exec (sqlite3_db_conn, sql_stmt, NULL, NULL, - &sql_strerror); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED, - "Failed executing: %s : %s", sql_stmt, sql_strerror); - sqlite3_free (sql_strerror); - ret = -1; - goto out; - } - - - ret = 0; + int ret = -1; + char *sql_stmt = NULL; + char *sql_strerror = NULL; + + GF_ASSERT(sqlite3_db_conn); + + sql_stmt = sql_stmt_init(); + if (!sql_stmt) { + ret = ENOMEM; + goto out; + } + + GF_CREATE_STMT(sql_stmt); + + ret = sqlite3_exec(sqlite3_db_conn, sql_stmt, NULL, NULL, &sql_strerror); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED, + "Failed executing: %s : %s", sql_stmt, sql_strerror); + sqlite3_free(sql_strerror); + ret = -1; + goto out; + } + + ret = 0; out: - sql_stmt_fini (&sql_stmt); - return ret; + sql_stmt_fini(&sql_stmt); + return ret; } - - - static int apply_sql_params_db(gf_sql_connection_t *sql_conn, dict_t *param_dict) { - int ret = -1; - char *temp_str = NULL; - char sqlite3_config_str[GF_NAME_MAX] = ""; - - GF_ASSERT(sql_conn); - GF_ASSERT(param_dict); - - /*Extract sql page_size from param_dict, - * if not specified default value will be GF_SQL_DEFAULT_PAGE_SIZE*/ - temp_str = NULL; - GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict, - GFDB_SQL_PARAM_PAGE_SIZE, temp_str, - GF_SQL_DEFAULT_PAGE_SIZE); - sql_conn->page_size = atoi (temp_str); - /*Apply page_size on the sqlite db*/ - GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "page_size", "%zd", - sql_conn->page_size, ret, out); - - - - /*Extract sql cache size from param_dict, + int ret = -1; + char *temp_str = NULL; + char sqlite3_config_str[GF_NAME_MAX] = ""; + + GF_ASSERT(sql_conn); + GF_ASSERT(param_dict); + + /*Extract sql page_size from param_dict, + * if not specified default value will be GF_SQL_DEFAULT_PAGE_SIZE*/ + temp_str = NULL; + GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict, + GFDB_SQL_PARAM_PAGE_SIZE, temp_str, + GF_SQL_DEFAULT_PAGE_SIZE); + sql_conn->page_size = atoi(temp_str); + /*Apply page_size on the sqlite db*/ + GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "page_size", "%zd", + sql_conn->page_size, ret, out); + + /*Extract sql cache size from param_dict, + * if not specified default value will be + * GF_SQL_DEFAULT_CACHE_SIZE pages*/ + temp_str = NULL; + GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict, + GFDB_SQL_PARAM_CACHE_SIZE, temp_str, + GF_SQL_DEFAULT_CACHE_SIZE); + sql_conn->cache_size = atoi(temp_str); + /*Apply cache size on the sqlite db*/ + GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "cache_size", "%zd", + sql_conn->cache_size, ret, out); + + /*Extract sql journal mode from param_dict, + * if not specified default value will be + * GF_SQL_DEFAULT_JOURNAL_MODE i.e "wal"*/ + temp_str = NULL; + GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict, + GFDB_SQL_PARAM_JOURNAL_MODE, temp_str, + GF_SQL_DEFAULT_JOURNAL_MODE); + sql_conn->journal_mode = gf_sql_str2jm(temp_str); + /*Apply journal mode to the sqlite db*/ + GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "journal_mode", "%s", temp_str, + ret, out); + + /*Only when the journal mode is WAL, wal_autocheckpoint makes sense*/ + if (sql_conn->journal_mode == gf_sql_jm_wal) { + /*Extract sql wal auto check point from param_dict * if not specified default value will be - * GF_SQL_DEFAULT_CACHE_SIZE pages*/ + * GF_SQL_DEFAULT_WAL_AUTOCHECKPOINT pages*/ temp_str = NULL; GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict, - GFDB_SQL_PARAM_CACHE_SIZE, temp_str, - GF_SQL_DEFAULT_CACHE_SIZE); - sql_conn->cache_size = atoi (temp_str); - /*Apply cache size on the sqlite db*/ - GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "cache_size", "%zd", - sql_conn->cache_size, ret, out); - - - - - /*Extract sql journal mode from param_dict, - * if not specified default value will be - * GF_SQL_DEFAULT_JOURNAL_MODE i.e "wal"*/ - temp_str = NULL; - GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict, - GFDB_SQL_PARAM_JOURNAL_MODE, temp_str, - GF_SQL_DEFAULT_JOURNAL_MODE); - sql_conn->journal_mode = gf_sql_str2jm (temp_str); - /*Apply journal mode to the sqlite db*/ - GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "journal_mode", "%s", - temp_str, ret, out); - - - - /*Only when the journal mode is WAL, wal_autocheckpoint makes sense*/ - if (sql_conn->journal_mode == gf_sql_jm_wal) { - /*Extract sql wal auto check point from param_dict - * if not specified default value will be - * GF_SQL_DEFAULT_WAL_AUTOCHECKPOINT pages*/ - temp_str = NULL; - GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict, - GFDB_SQL_PARAM_WAL_AUTOCHECK, temp_str, - GF_SQL_DEFAULT_WAL_AUTOCHECKPOINT); - sql_conn->wal_autocheckpoint = atoi(temp_str); - /*Apply wal auto check point to the sqlite db*/ - GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "wal_autocheckpoint", - "%zd", sql_conn->wal_autocheckpoint, ret, out); - } - - - - /*Extract sql synchronous from param_dict - * if not specified default value will be GF_SQL_DEFAULT_SYNC*/ - temp_str = NULL; - GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict, - GFDB_SQL_PARAM_SYNC, temp_str, GF_SQL_DEFAULT_SYNC); - sql_conn->synchronous = gf_sql_str2sync_t (temp_str); - /*Apply synchronous to the sqlite db*/ - GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "synchronous", "%d", - sql_conn->synchronous, ret, out); - - - - /*Extract sql auto_vacuum from param_dict - * if not specified default value will be GF_SQL_DEFAULT_AUTO_VACUUM*/ - temp_str = NULL; - GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict, - GFDB_SQL_PARAM_AUTO_VACUUM, temp_str, - GF_SQL_DEFAULT_AUTO_VACUUM); - sql_conn->auto_vacuum = gf_sql_str2av_t (temp_str); - /*Apply auto_vacuum to the sqlite db*/ - GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "auto_vacuum", "%d", - sql_conn->auto_vacuum, ret, out); - - ret = 0; + GFDB_SQL_PARAM_WAL_AUTOCHECK, temp_str, + GF_SQL_DEFAULT_WAL_AUTOCHECKPOINT); + sql_conn->wal_autocheckpoint = atoi(temp_str); + /*Apply wal auto check point to the sqlite db*/ + GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "wal_autocheckpoint", "%zd", + sql_conn->wal_autocheckpoint, ret, out); + } + + /*Extract sql synchronous from param_dict + * if not specified default value will be GF_SQL_DEFAULT_SYNC*/ + temp_str = NULL; + GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict, + GFDB_SQL_PARAM_SYNC, temp_str, + GF_SQL_DEFAULT_SYNC); + sql_conn->synchronous = gf_sql_str2sync_t(temp_str); + /*Apply synchronous to the sqlite db*/ + GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "synchronous", "%d", + sql_conn->synchronous, ret, out); + + /*Extract sql auto_vacuum from param_dict + * if not specified default value will be GF_SQL_DEFAULT_AUTO_VACUUM*/ + temp_str = NULL; + GET_DB_PARAM_FROM_DICT_DEFAULT(GFDB_STR_SQLITE3, param_dict, + GFDB_SQL_PARAM_AUTO_VACUUM, temp_str, + GF_SQL_DEFAULT_AUTO_VACUUM); + sql_conn->auto_vacuum = gf_sql_str2av_t(temp_str); + /*Apply auto_vacuum to the sqlite db*/ + GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, "auto_vacuum", "%d", + sql_conn->auto_vacuum, ret, out); + + ret = 0; out: - return ret; + return ret; } - - int -gf_sqlite3_init (dict_t *args, void **db_conn) { - int ret = -1; - gf_sql_connection_t *sql_conn = NULL; - struct stat stbuf = {0,}; - gf_boolean_t is_dbfile_exist = _gf_false; - char *temp_str = NULL; - - GF_ASSERT (args); - GF_ASSERT (db_conn); - - if (*db_conn != NULL) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_CONNECTION_ERROR, "DB Connection is not " - "empty!"); - return 0; - } - - if (!sqlite3_threadsafe ()) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_NOT_MULTITHREAD_MODE, - "sqlite3 is not in multithreaded mode"); - goto out; - } - - sql_conn = gf_sql_connection_init (); - if (!sql_conn) { - goto out; - } - - /*Extract sql db path from args*/ - temp_str = NULL; - GET_DB_PARAM_FROM_DICT(GFDB_STR_SQLITE3, args, - GFDB_SQL_PARAM_DBPATH, temp_str, out); - strncpy(sql_conn->sqlite3_db_path, temp_str, PATH_MAX-1); - sql_conn->sqlite3_db_path[PATH_MAX-1] = 0; - - is_dbfile_exist = (sys_stat (sql_conn->sqlite3_db_path, &stbuf) == 0) ? - _gf_true : _gf_false; - - /*Creates DB if not created*/ - sql_conn->sqlite3_db_conn = gf_open_sqlite3_conn ( - sql_conn->sqlite3_db_path, - SQLITE_OPEN_READWRITE | - SQLITE_OPEN_CREATE); - if (!sql_conn->sqlite3_db_conn) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_CONNECTION_ERROR, - "Failed creating db connection"); - goto out; - } - - /* If the file exist we skip the config part - * and creation of the schema */ - if (is_dbfile_exist) - goto db_exists; - - - /*Apply sqlite3 params to database*/ - ret = apply_sql_params_db (sql_conn, args); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_SET_PARAM_FAILED, "Failed applying sql params" - " to %s", sql_conn->sqlite3_db_path); - goto out; - } - - /*Create the schema if NOT present*/ - ret = create_filetable (sql_conn->sqlite3_db_conn); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_CREATE_FAILED, "Failed Creating %s Table", - GF_FILE_TABLE); - goto out; - } +gf_sqlite3_init(dict_t *args, void **db_conn) +{ + int ret = -1; + gf_sql_connection_t *sql_conn = NULL; + struct stat stbuf = { + 0, + }; + gf_boolean_t is_dbfile_exist = _gf_false; + char *temp_str = NULL; + + GF_ASSERT(args); + GF_ASSERT(db_conn); + + if (*db_conn != NULL) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CONNECTION_ERROR, + "DB Connection is not " + "empty!"); + return 0; + } + + if (!sqlite3_threadsafe()) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_NOT_MULTITHREAD_MODE, + "sqlite3 is not in multithreaded mode"); + goto out; + } + + sql_conn = gf_sql_connection_init(); + if (!sql_conn) { + goto out; + } + + /*Extract sql db path from args*/ + temp_str = NULL; + GET_DB_PARAM_FROM_DICT(GFDB_STR_SQLITE3, args, GFDB_SQL_PARAM_DBPATH, + temp_str, out); + strncpy(sql_conn->sqlite3_db_path, temp_str, PATH_MAX - 1); + sql_conn->sqlite3_db_path[PATH_MAX - 1] = 0; + + is_dbfile_exist = (sys_stat(sql_conn->sqlite3_db_path, &stbuf) == 0) + ? _gf_true + : _gf_false; + + /*Creates DB if not created*/ + sql_conn->sqlite3_db_conn = gf_open_sqlite3_conn( + sql_conn->sqlite3_db_path, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE); + if (!sql_conn->sqlite3_db_conn) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CONNECTION_ERROR, + "Failed creating db connection"); + goto out; + } + + /* If the file exist we skip the config part + * and creation of the schema */ + if (is_dbfile_exist) + goto db_exists; + + /*Apply sqlite3 params to database*/ + ret = apply_sql_params_db(sql_conn, args); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_SET_PARAM_FAILED, + "Failed applying sql params" + " to %s", + sql_conn->sqlite3_db_path); + goto out; + } + + /*Create the schema if NOT present*/ + ret = create_filetable(sql_conn->sqlite3_db_conn); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED, + "Failed Creating %s Table", GF_FILE_TABLE); + goto out; + } db_exists: - ret = 0; + ret = 0; out: - if (ret) { - gf_sqlite3_fini ((void **)&sql_conn); - } + if (ret) { + gf_sqlite3_fini((void **)&sql_conn); + } - *db_conn = sql_conn; + *db_conn = sql_conn; - return ret; + return ret; } - int -gf_sqlite3_fini (void **db_conn) +gf_sqlite3_fini(void **db_conn) { - int ret = -1; - gf_sql_connection_t *sql_conn = NULL; - - GF_ASSERT (db_conn); - sql_conn = *db_conn; - - if (sql_conn) { - if (sql_conn->sqlite3_db_conn) { - ret = gf_close_sqlite3_conn (sql_conn->sqlite3_db_conn); - if (ret) { - /*Logging of error done in - * gf_close_sqlite3_conn()*/ - goto out; - } - sql_conn->sqlite3_db_conn = NULL; - } - gf_sql_connection_fini (&sql_conn); + int ret = -1; + gf_sql_connection_t *sql_conn = NULL; + + GF_ASSERT(db_conn); + sql_conn = *db_conn; + + if (sql_conn) { + if (sql_conn->sqlite3_db_conn) { + ret = gf_close_sqlite3_conn(sql_conn->sqlite3_db_conn); + if (ret) { + /*Logging of error done in + * gf_close_sqlite3_conn()*/ + goto out; + } + sql_conn->sqlite3_db_conn = NULL; } - *db_conn = sql_conn; - ret = 0; + gf_sql_connection_fini(&sql_conn); + } + *db_conn = sql_conn; + ret = 0; out: - return ret; + return ret; } /****************************************************************************** @@ -520,79 +497,84 @@ out: * * ***************************************************************************/ -int gf_sqlite3_insert(void *db_conn, gfdb_db_record_t *gfdb_db_record) +int +gf_sqlite3_insert(void *db_conn, gfdb_db_record_t *gfdb_db_record) { - int ret = -1; - gf_sql_connection_t *sql_conn = db_conn; - - CHECK_SQL_CONN(sql_conn, out); - GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out); + int ret = -1; + gf_sql_connection_t *sql_conn = db_conn; + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out); - switch (gfdb_db_record->gfdb_fop_path) { + switch (gfdb_db_record->gfdb_fop_path) { case GFDB_FOP_WIND: - ret = gf_sql_insert_wind (sql_conn, gfdb_db_record); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, _gfdb_log_level (GF_LOG_ERROR, - gfdb_db_record->ignore_errors), 0, - LG_MSG_INSERT_FAILED, "Failed wind insert"); - goto out; - } - break; + ret = gf_sql_insert_wind(sql_conn, gfdb_db_record); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, + _gfdb_log_level(GF_LOG_ERROR, + gfdb_db_record->ignore_errors), + 0, LG_MSG_INSERT_FAILED, "Failed wind insert"); + goto out; + } + break; case GFDB_FOP_UNWIND: - ret = gf_sql_insert_unwind (sql_conn, gfdb_db_record); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, _gfdb_log_level (GF_LOG_ERROR, - gfdb_db_record->ignore_errors), 0, - LG_MSG_INSERT_FAILED, "Failed unwind insert"); - goto out; - } - break; + ret = gf_sql_insert_unwind(sql_conn, gfdb_db_record); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, + _gfdb_log_level(GF_LOG_ERROR, + gfdb_db_record->ignore_errors), + 0, LG_MSG_INSERT_FAILED, "Failed unwind insert"); + goto out; + } + break; case GFDB_FOP_WDEL: - ret = gf_sql_update_delete_wind (sql_conn, gfdb_db_record); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, _gfdb_log_level (GF_LOG_ERROR, - gfdb_db_record->ignore_errors), 0, - LG_MSG_UPDATE_FAILED, "Failed updating delete " - "during wind"); - goto out; - } - break; + ret = gf_sql_update_delete_wind(sql_conn, gfdb_db_record); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, + _gfdb_log_level(GF_LOG_ERROR, + gfdb_db_record->ignore_errors), + 0, LG_MSG_UPDATE_FAILED, + "Failed updating delete " + "during wind"); + goto out; + } + break; case GFDB_FOP_UNDEL: case GFDB_FOP_UNDEL_ALL: - ret = gf_sql_delete_unwind (sql_conn, gfdb_db_record); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, _gfdb_log_level (GF_LOG_ERROR, - gfdb_db_record->ignore_errors), 0, - LG_MSG_DELETE_FAILED, "Failed deleting"); - goto out; - } - break; + ret = gf_sql_delete_unwind(sql_conn, gfdb_db_record); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, + _gfdb_log_level(GF_LOG_ERROR, + gfdb_db_record->ignore_errors), + 0, LG_MSG_DELETE_FAILED, "Failed deleting"); + goto out; + } + break; case GFDB_FOP_INVALID: default: - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_INVALID_FOP, - "Cannot record to DB: Invalid FOP"); - goto out; - } + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_INVALID_FOP, + "Cannot record to DB: Invalid FOP"); + goto out; + } - ret = 0; + ret = 0; out: - return ret; + return ret; } int gf_sqlite3_delete(void *db_conn, gfdb_db_record_t *gfdb_db_record) { - int ret = -1; - gf_sql_connection_t *sql_conn = db_conn; + int ret = -1; + gf_sql_connection_t *sql_conn = db_conn; - CHECK_SQL_CONN(sql_conn, out); - GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out); + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out); - ret = 0; + ret = 0; out: - return ret; + return ret; } /****************************************************************************** @@ -603,27 +585,24 @@ out: * ***************************************************************************/ static int -gf_get_basic_query_stmt (char **out_stmt) +gf_get_basic_query_stmt(char **out_stmt) { - int ret = -1; - ret = gf_asprintf (out_stmt, "select GF_FILE_TB.GF_ID," - "GF_FLINK_TB.GF_PID ," - "GF_FLINK_TB.FNAME " - "from GF_FLINK_TB, GF_FILE_TB " - "where " - "GF_FILE_TB.GF_ID = GF_FLINK_TB.GF_ID "); - if (ret <= 0) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, - "Failed to create base query statement"); - *out_stmt = NULL; - } - return ret; + int ret = -1; + ret = gf_asprintf(out_stmt, + "select GF_FILE_TB.GF_ID," + "GF_FLINK_TB.GF_PID ," + "GF_FLINK_TB.FNAME " + "from GF_FLINK_TB, GF_FILE_TB " + "where " + "GF_FILE_TB.GF_ID = GF_FLINK_TB.GF_ID "); + if (ret <= 0) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, + "Failed to create base query statement"); + *out_stmt = NULL; + } + return ret; } - - - - /* * Find All files recorded in the DB * Input: @@ -631,71 +610,65 @@ gf_get_basic_query_stmt (char **out_stmt) * result records from the query * */ int -gf_sqlite3_find_all (void *db_conn, gf_query_callback_t query_callback, - void *query_cbk_args, - int query_limit) +gf_sqlite3_find_all(void *db_conn, gf_query_callback_t query_callback, + void *query_cbk_args, int query_limit) { - int ret = -1; - char *query_str = NULL; - gf_sql_connection_t *sql_conn = db_conn; - sqlite3_stmt *prep_stmt = NULL; - char *limit_query = NULL; - char *query = NULL; - - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out); + int ret = -1; + char *query_str = NULL; + gf_sql_connection_t *sql_conn = db_conn; + sqlite3_stmt *prep_stmt = NULL; + char *limit_query = NULL; + char *query = NULL; - ret = gf_get_basic_query_stmt (&query_str); - if (ret <= 0) { - goto out; - } + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out); - query = query_str; - - if (query_limit > 0) { - ret = gf_asprintf (&limit_query, "%s LIMIT %d", - query, query_limit); - if (ret < 0) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_QUERY_FAILED, - "Failed creating limit query statement"); - limit_query = NULL; - goto out; - } + ret = gf_get_basic_query_stmt(&query_str); + if (ret <= 0) { + goto out; + } - query = limit_query; - } + query = query_str; - ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, query, -1, - &prep_stmt, 0); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, - "Failed to prepare statement %s: %s", query, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - ret = gf_sql_query_function (prep_stmt, query_callback, query_cbk_args); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, - "Failed Query %s", query); - goto out; - } - - ret = 0; + if (query_limit > 0) { + ret = gf_asprintf(&limit_query, "%s LIMIT %d", query, query_limit); + if (ret < 0) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, + "Failed creating limit query statement"); + limit_query = NULL; + goto out; + } + + query = limit_query; + } + + ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, query, -1, &prep_stmt, 0); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Failed to prepare statement %s: %s", query, + sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + ret = gf_sql_query_function(prep_stmt, query_callback, query_cbk_args); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, + "Failed Query %s", query); + goto out; + } + + ret = 0; out: - sqlite3_finalize (prep_stmt); - GF_FREE (query_str); + sqlite3_finalize(prep_stmt); + GF_FREE(query_str); - if (limit_query) - GF_FREE (limit_query); + if (limit_query) + GF_FREE(limit_query); - return ret; + return ret; } - /* * Find recently changed files from the DB * Input: @@ -705,97 +678,101 @@ out: * */ int gf_sqlite3_find_recently_changed_files(void *db_conn, - gf_query_callback_t query_callback, - void *query_cbk_args, - gfdb_time_t *from_time) + gf_query_callback_t query_callback, + void *query_cbk_args, + gfdb_time_t *from_time) { - int ret = -1; - char *query_str = NULL; - gf_sql_connection_t *sql_conn = db_conn; - sqlite3_stmt *prep_stmt = NULL; - uint64_t from_time_usec = 0; - char *base_query_str = NULL; - - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out); - - ret = gf_get_basic_query_stmt (&base_query_str); - if (ret <= 0) { - goto out; - } - - ret = gf_asprintf (&query_str, "%s AND" - /*First condition: For writes*/ - "( ((" GF_COL_TB_WSEC " * " TOSTRING(GFDB_MICROSEC) " + " - GF_COL_TB_WMSEC ") >= ? )" - " OR " - /*Second condition: For reads*/ - "((" GF_COL_TB_RWSEC " * " TOSTRING(GFDB_MICROSEC) " + " - GF_COL_TB_RWMSEC ") >= ?) )" - /* Order by write wind time in a descending order - * i.e most hot files w.r.t to write */ - " ORDER BY GF_FILE_TB.W_SEC DESC", - base_query_str); - - if (ret < 0) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, - "Failed creating query statement"); - query_str = NULL; - goto out; - } - - from_time_usec = gfdb_time_2_usec (from_time); - - ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, query_str, -1, - &prep_stmt, 0); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, "Failed to prepare statement %s :" - " %s", query_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind write wind time*/ - ret = sqlite3_bind_int64 (prep_stmt, 1, from_time_usec); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed to bind from_time_usec " - "%"PRIu64" : %s", from_time_usec, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind read wind time*/ - ret = sqlite3_bind_int64 (prep_stmt, 2, from_time_usec); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed to bind from_time_usec " - "%"PRIu64" : %s ", from_time_usec, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Execute the query*/ - ret = gf_sql_query_function (prep_stmt, query_callback, query_cbk_args); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, - "Failed Query %s", query_str); - goto out; - } - - ret = 0; + int ret = -1; + char *query_str = NULL; + gf_sql_connection_t *sql_conn = db_conn; + sqlite3_stmt *prep_stmt = NULL; + uint64_t from_time_usec = 0; + char *base_query_str = NULL; + + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out); + + ret = gf_get_basic_query_stmt(&base_query_str); + if (ret <= 0) { + goto out; + } + + ret = gf_asprintf( + &query_str, + "%s AND" + /*First condition: For writes*/ + "( ((" GF_COL_TB_WSEC " * " TOSTRING( + GFDB_MICROSEC) " + " GF_COL_TB_WMSEC + ") >= ? )" + " OR " + /*Second condition: For reads*/ + "((" GF_COL_TB_RWSEC " * " TOSTRING( + GFDB_MICROSEC) " + " GF_COL_TB_RWMSEC + ") >= ?) )" + /* Order by write wind time in a + * descending order i.e most hot + * files w.r.t to write */ + " ORDER BY GF_FILE_TB.W_SEC DESC", + base_query_str); + + if (ret < 0) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, + "Failed creating query statement"); + query_str = NULL; + goto out; + } + + from_time_usec = gfdb_time_2_usec(from_time); + + ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, query_str, -1, &prep_stmt, + 0); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Failed to prepare statement %s :" + " %s", + query_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind write wind time*/ + ret = sqlite3_bind_int64(prep_stmt, 1, from_time_usec); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed to bind from_time_usec " + "%" PRIu64 " : %s", + from_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind read wind time*/ + ret = sqlite3_bind_int64(prep_stmt, 2, from_time_usec); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed to bind from_time_usec " + "%" PRIu64 " : %s ", + from_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Execute the query*/ + ret = gf_sql_query_function(prep_stmt, query_callback, query_cbk_args); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, + "Failed Query %s", query_str); + goto out; + } + + ret = 0; out: - sqlite3_finalize (prep_stmt); - GF_FREE (base_query_str); - GF_FREE (query_str); - return ret; + sqlite3_finalize(prep_stmt); + GF_FREE(base_query_str); + GF_FREE(query_str); + return ret; } - /* * Find unchanged files from a specified time from the DB * Input: @@ -804,101 +781,101 @@ out: * for_time : Time from where the file/s are not changed * */ int -gf_sqlite3_find_unchanged_for_time (void *db_conn, - gf_query_callback_t query_callback, - void *query_cbk_args, - gfdb_time_t *for_time) +gf_sqlite3_find_unchanged_for_time(void *db_conn, + gf_query_callback_t query_callback, + void *query_cbk_args, gfdb_time_t *for_time) { - int ret = -1; - char *query_str = NULL; - gf_sql_connection_t *sql_conn = db_conn; - sqlite3_stmt *prep_stmt = NULL; - uint64_t for_time_usec = 0; - char *base_query_str = NULL; - - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out); - - ret = gf_get_basic_query_stmt (&base_query_str); - if (ret <= 0) { - goto out; - } - - ret = gf_asprintf (&query_str, "%s AND " - /*First condition: For writes*/ - "( ((" GF_COL_TB_WSEC " * " TOSTRING(GFDB_MICROSEC) " + " - GF_COL_TB_WMSEC ") <= ? )" - " AND " - /*Second condition: For reads*/ - "((" GF_COL_TB_RWSEC " * " TOSTRING(GFDB_MICROSEC) " + " - GF_COL_TB_RWMSEC ") <= ?) )" - /* Order by write wind time in a ascending order - * i.e most cold files w.r.t to write */ - " ORDER BY GF_FILE_TB.W_SEC ASC", - base_query_str); - - if (ret < 0) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, - "Failed to create query statement"); - query_str = NULL; - goto out; - } - - for_time_usec = gfdb_time_2_usec (for_time); - - ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, query_str, -1, - &prep_stmt, 0); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, "Failed to prepare statement %s :" - " %s", query_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind write wind time*/ - ret = sqlite3_bind_int64 (prep_stmt, 1, for_time_usec); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec " - "%"PRIu64" : %s", for_time_usec, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind read wind time*/ - ret = sqlite3_bind_int64 (prep_stmt, 2, for_time_usec); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec " - "%"PRIu64" : %s", for_time_usec, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Execute the query*/ - ret = gf_sql_query_function (prep_stmt, query_callback, query_cbk_args); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, - "Failed Query %s", query_str); - goto out; - } - - ret = 0; + int ret = -1; + char *query_str = NULL; + gf_sql_connection_t *sql_conn = db_conn; + sqlite3_stmt *prep_stmt = NULL; + uint64_t for_time_usec = 0; + char *base_query_str = NULL; + + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out); + + ret = gf_get_basic_query_stmt(&base_query_str); + if (ret <= 0) { + goto out; + } + + ret = gf_asprintf( + &query_str, + "%s AND " + /*First condition: For writes*/ + "( ((" GF_COL_TB_WSEC " * " TOSTRING( + GFDB_MICROSEC) " + " GF_COL_TB_WMSEC + ") <= ? )" + " AND " + /*Second condition: For reads*/ + "((" GF_COL_TB_RWSEC " * " TOSTRING( + GFDB_MICROSEC) " + " GF_COL_TB_RWMSEC + ") <= ?) )" + /* Order by write wind time in a + * ascending order i.e most cold + * files w.r.t to write */ + " ORDER BY GF_FILE_TB.W_SEC ASC", + base_query_str); + + if (ret < 0) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, + "Failed to create query statement"); + query_str = NULL; + goto out; + } + + for_time_usec = gfdb_time_2_usec(for_time); + + ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, query_str, -1, &prep_stmt, + 0); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Failed to prepare statement %s :" + " %s", + query_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind write wind time*/ + ret = sqlite3_bind_int64(prep_stmt, 1, for_time_usec); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed to bind for_time_usec " + "%" PRIu64 " : %s", + for_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind read wind time*/ + ret = sqlite3_bind_int64(prep_stmt, 2, for_time_usec); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed to bind for_time_usec " + "%" PRIu64 " : %s", + for_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Execute the query*/ + ret = gf_sql_query_function(prep_stmt, query_callback, query_cbk_args); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, + "Failed Query %s", query_str); + goto out; + } + + ret = 0; out: - sqlite3_finalize (prep_stmt); - GF_FREE (base_query_str); - GF_FREE (query_str); - return ret; + sqlite3_finalize(prep_stmt); + GF_FREE(base_query_str); + GF_FREE(query_str); + return ret; } - - - - /* * Find recently changed files with a specific frequency from the DB * Input: @@ -911,140 +888,144 @@ out: * clear_counters : Clear counters (r/w) for all inodes in DB * */ int -gf_sqlite3_find_recently_changed_files_freq (void *db_conn, - gf_query_callback_t query_callback, - void *query_cbk_args, - gfdb_time_t *from_time, - int freq_write_cnt, - int freq_read_cnt, - gf_boolean_t clear_counters) +gf_sqlite3_find_recently_changed_files_freq( + void *db_conn, gf_query_callback_t query_callback, void *query_cbk_args, + gfdb_time_t *from_time, int freq_write_cnt, int freq_read_cnt, + gf_boolean_t clear_counters) { - int ret = -1; - char *query_str = NULL; - gf_sql_connection_t *sql_conn = db_conn; - sqlite3_stmt *prep_stmt = NULL; - uint64_t from_time_usec = 0; - char *base_query_str = NULL; - - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out); - - ret = gf_get_basic_query_stmt (&base_query_str); - if (ret <= 0) { - goto out; - } - ret = gf_asprintf (&query_str, "%s AND " - /*First condition: For Writes*/ - "( ( ((" GF_COL_TB_WSEC " * " TOSTRING(GFDB_MICROSEC) " + " - GF_COL_TB_WMSEC ") >= ? )" - " AND "" (" GF_COL_TB_WFC " >= ? ) )" - " OR " - /*Second condition: For Reads */ - "( ((" GF_COL_TB_RWSEC " * " TOSTRING(GFDB_MICROSEC) " + " - GF_COL_TB_RWMSEC ") >= ?)" - " AND "" (" GF_COL_TB_RFC " >= ? ) ) )" - /* Order by write wind time and write freq in a descending order - * i.e most hot files w.r.t to write */ - " ORDER BY GF_FILE_TB.W_SEC DESC, " - "GF_FILE_TB.WRITE_FREQ_CNTR DESC", - base_query_str); - - if (ret < 0) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, - "Failed to create query statement"); - query_str = NULL; - goto out; - } - - from_time_usec = gfdb_time_2_usec (from_time); - - ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, query_str, -1, - &prep_stmt, 0); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, "Failed to prepare statement %s :" - " %s", query_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind write wind time*/ - ret = sqlite3_bind_int64 (prep_stmt, 1, from_time_usec); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed to bind from_time_usec " - "%"PRIu64" : %s", from_time_usec, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind write frequency thresold*/ - ret = sqlite3_bind_int (prep_stmt, 2, freq_write_cnt); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed to bind freq_write_cnt " - "%d : %s", freq_write_cnt, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - - /*Bind read wind time*/ - ret = sqlite3_bind_int64 (prep_stmt, 3, from_time_usec); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed to bind from_time_usec " - "%"PRIu64" : %s", from_time_usec, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind read frequency thresold*/ - ret = sqlite3_bind_int (prep_stmt, 4, freq_read_cnt); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed to bind freq_read_cnt " - "%d : %s", freq_read_cnt, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Execute the query*/ - ret = gf_sql_query_function (prep_stmt, query_callback, query_cbk_args); + int ret = -1; + char *query_str = NULL; + gf_sql_connection_t *sql_conn = db_conn; + sqlite3_stmt *prep_stmt = NULL; + uint64_t from_time_usec = 0; + char *base_query_str = NULL; + + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out); + + ret = gf_get_basic_query_stmt(&base_query_str); + if (ret <= 0) { + goto out; + } + ret = gf_asprintf( + &query_str, + "%s AND " + /*First condition: For Writes*/ + "( ( ((" GF_COL_TB_WSEC " * " TOSTRING( + GFDB_MICROSEC) " + " GF_COL_TB_WMSEC + ") >= ? )" + " AND " + " (" GF_COL_TB_WFC + " >= ? ) )" + " OR " + /*Second condition: For Reads */ + "( ((" GF_COL_TB_RWSEC " * " TOSTRING( + GFDB_MICROSEC) " + " GF_COL_TB_RWMSEC + ") >= ?)" + " AND " + " (" GF_COL_TB_RFC + " >= ? ) ) )" + /* Order by write wind time and + * write freq in a descending + * order + * i.e most hot files w.r.t to + * write */ + " ORDER BY GF_FILE_TB.W_SEC " + "DESC, " + "GF_FILE_TB.WRITE_FREQ_CNTR DESC", + base_query_str); + + if (ret < 0) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, + "Failed to create query statement"); + query_str = NULL; + goto out; + } + + from_time_usec = gfdb_time_2_usec(from_time); + + ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, query_str, -1, &prep_stmt, + 0); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Failed to prepare statement %s :" + " %s", + query_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind write wind time*/ + ret = sqlite3_bind_int64(prep_stmt, 1, from_time_usec); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed to bind from_time_usec " + "%" PRIu64 " : %s", + from_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind write frequency thresold*/ + ret = sqlite3_bind_int(prep_stmt, 2, freq_write_cnt); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed to bind freq_write_cnt " + "%d : %s", + freq_write_cnt, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind read wind time*/ + ret = sqlite3_bind_int64(prep_stmt, 3, from_time_usec); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed to bind from_time_usec " + "%" PRIu64 " : %s", + from_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind read frequency thresold*/ + ret = sqlite3_bind_int(prep_stmt, 4, freq_read_cnt); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed to bind freq_read_cnt " + "%d : %s", + freq_read_cnt, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Execute the query*/ + ret = gf_sql_query_function(prep_stmt, query_callback, query_cbk_args); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, + "Failed Query %s", query_str); + goto out; + } + + /*Clear counters*/ + if (clear_counters) { + ret = gf_sql_clear_counters(sql_conn); if (ret) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, - "Failed Query %s", query_str); - goto out; - } - - - - /*Clear counters*/ - if (clear_counters) { - ret = gf_sql_clear_counters (sql_conn); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_CLEAR_COUNTER_FAILED, "Failed to clear" - " counters!"); - goto out; - } - } - ret = 0; + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, + LG_MSG_CLEAR_COUNTER_FAILED, + "Failed to clear" + " counters!"); + goto out; + } + } + ret = 0; out: - sqlite3_finalize (prep_stmt); - GF_FREE (base_query_str); - GF_FREE (query_str); - return ret; + sqlite3_finalize(prep_stmt); + GF_FREE(base_query_str); + GF_FREE(query_str); + return ret; } - - - /* * Find unchanged files from a specified time, w.r.t to frequency, from the DB * Input: @@ -1056,30 +1037,29 @@ out: * clear_counters : Clear counters (r/w) for all inodes in DB * */ int -gf_sqlite3_find_unchanged_for_time_freq (void *db_conn, +gf_sqlite3_find_unchanged_for_time_freq(void *db_conn, gf_query_callback_t query_callback, void *query_cbk_args, gfdb_time_t *for_time, - int freq_write_cnt, - int freq_read_cnt, + int freq_write_cnt, int freq_read_cnt, gf_boolean_t clear_counters) { - int ret = -1; - char *query_str = NULL; - gf_sql_connection_t *sql_conn = db_conn; - sqlite3_stmt *prep_stmt = NULL; - uint64_t for_time_usec = 0; - char *base_query_str = NULL; - - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out); - - ret = gf_get_basic_query_stmt (&base_query_str); - if (ret <= 0) { - goto out; - } - - ret = gf_asprintf (&query_str, "%s AND " + int ret = -1; + char *query_str = NULL; + gf_sql_connection_t *sql_conn = db_conn; + sqlite3_stmt *prep_stmt = NULL; + uint64_t for_time_usec = 0; + char *base_query_str = NULL; + + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out); + + ret = gf_get_basic_query_stmt(&base_query_str); + if (ret <= 0) { + goto out; + } + + ret = gf_asprintf (&query_str, "%s AND " /*First condition: For Writes * Files that have write wind time smaller than for_time * OR @@ -1109,145 +1089,141 @@ gf_sqlite3_find_unchanged_for_time_freq (void *db_conn, "GF_FILE_TB.WRITE_FREQ_CNTR ASC", base_query_str); - if (ret < 0) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, - "Failed to create query statement"); - query_str = NULL; - goto out; - } - - for_time_usec = gfdb_time_2_usec (for_time); - - ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, query_str, -1, - &prep_stmt, 0); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, "Failed to prepare delete " - "statement %s : %s", query_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind write wind time*/ - ret = sqlite3_bind_int64 (prep_stmt, 1, for_time_usec); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec " - "%"PRIu64" : %s", for_time_usec, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind write frequency thresold*/ - ret = sqlite3_bind_int (prep_stmt, 2, freq_write_cnt); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed to bind freq_write_cnt" - " %d : %s", freq_write_cnt, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind write wind time*/ - ret = sqlite3_bind_int64 (prep_stmt, 3, for_time_usec); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec " - "%"PRIu64" : %s", for_time_usec, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - - - /*Bind read wind time*/ - ret = sqlite3_bind_int64 (prep_stmt, 4, for_time_usec); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec " - "%"PRIu64" : %s", for_time_usec, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind read frequency thresold*/ - ret = sqlite3_bind_int (prep_stmt, 5, freq_read_cnt); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed to bind freq_read_cnt " - "%d : %s", freq_read_cnt, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind read wind time*/ - ret = sqlite3_bind_int64 (prep_stmt, 6, for_time_usec); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed to bind for_time_usec " - "%"PRIu64" : %s", for_time_usec, - sqlite3_errmsg(sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Execute the query*/ - ret = gf_sql_query_function (prep_stmt, query_callback, query_cbk_args); + if (ret < 0) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, + "Failed to create query statement"); + query_str = NULL; + goto out; + } + + for_time_usec = gfdb_time_2_usec(for_time); + + ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, query_str, -1, &prep_stmt, + 0); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Failed to prepare delete " + "statement %s : %s", + query_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind write wind time*/ + ret = sqlite3_bind_int64(prep_stmt, 1, for_time_usec); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed to bind for_time_usec " + "%" PRIu64 " : %s", + for_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind write frequency thresold*/ + ret = sqlite3_bind_int(prep_stmt, 2, freq_write_cnt); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed to bind freq_write_cnt" + " %d : %s", + freq_write_cnt, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind write wind time*/ + ret = sqlite3_bind_int64(prep_stmt, 3, for_time_usec); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed to bind for_time_usec " + "%" PRIu64 " : %s", + for_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind read wind time*/ + ret = sqlite3_bind_int64(prep_stmt, 4, for_time_usec); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed to bind for_time_usec " + "%" PRIu64 " : %s", + for_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind read frequency thresold*/ + ret = sqlite3_bind_int(prep_stmt, 5, freq_read_cnt); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed to bind freq_read_cnt " + "%d : %s", + freq_read_cnt, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind read wind time*/ + ret = sqlite3_bind_int64(prep_stmt, 6, for_time_usec); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed to bind for_time_usec " + "%" PRIu64 " : %s", + for_time_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Execute the query*/ + ret = gf_sql_query_function(prep_stmt, query_callback, query_cbk_args); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, + "Failed Query %s", query_str); + goto out; + } + + /*Clear counters*/ + if (clear_counters) { + ret = gf_sql_clear_counters(sql_conn); if (ret) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, - "Failed Query %s", query_str); - goto out; - } - - - /*Clear counters*/ - if (clear_counters) { - ret = gf_sql_clear_counters (sql_conn); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_CLEAR_COUNTER_FAILED, "Failed to clear " - "counters!"); - goto out; - } + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, + LG_MSG_CLEAR_COUNTER_FAILED, + "Failed to clear " + "counters!"); + goto out; } + } - ret = 0; + ret = 0; out: - sqlite3_finalize (prep_stmt); - GF_FREE (base_query_str); - GF_FREE (query_str); - return ret; + sqlite3_finalize(prep_stmt); + GF_FREE(base_query_str); + GF_FREE(query_str); + return ret; } - int -gf_sqlite3_clear_files_heat (void *db_conn) +gf_sqlite3_clear_files_heat(void *db_conn) { - int ret = -1; - gf_sql_connection_t *sql_conn = db_conn; + int ret = -1; + gf_sql_connection_t *sql_conn = db_conn; - CHECK_SQL_CONN (sql_conn, out); + CHECK_SQL_CONN(sql_conn, out); - ret = gf_sql_clear_counters (sql_conn); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_CLEAR_COUNTER_FAILED, "Failed to clear " - "files heat"); - goto out; - } + ret = gf_sql_clear_counters(sql_conn); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CLEAR_COUNTER_FAILED, + "Failed to clear " + "files heat"); + goto out; + } - ret = 0; + ret = 0; out: - return ret; + return ret; } - /* Function to extract version of sqlite db * Input: * void *db_conn : Sqlite connection @@ -1260,48 +1236,45 @@ out: * On failure return -1 * */ int -gf_sqlite3_version (void *db_conn, char **version) +gf_sqlite3_version(void *db_conn, char **version) { - int ret = -1; - gf_sql_connection_t *sql_conn = db_conn; - sqlite3_stmt *pre_stmt = NULL; - - CHECK_SQL_CONN (sql_conn, out); - - ret = sqlite3_prepare_v2 (sql_conn->sqlite3_db_conn, - "SELECT SQLITE_VERSION()", - -1, &pre_stmt, 0); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, "Failed init prepare stmt %s", - sqlite3_errmsg (db_conn)); - ret = -1; - goto out; - } - - ret = sqlite3_step(pre_stmt); - if (ret != SQLITE_ROW) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_GET_RECORD_FAILED, "Failed to get records " - "from db : %s", sqlite3_errmsg (db_conn)); - ret = -1; - goto out; - } - - ret = gf_asprintf (version, "%s", sqlite3_column_text (pre_stmt, 0)); - if (ret <= 0) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, - "Failed extracting version"); - } + int ret = -1; + gf_sql_connection_t *sql_conn = db_conn; + sqlite3_stmt *pre_stmt = NULL; + + CHECK_SQL_CONN(sql_conn, out); + + ret = sqlite3_prepare_v2(sql_conn->sqlite3_db_conn, + "SELECT SQLITE_VERSION()", -1, &pre_stmt, 0); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Failed init prepare stmt %s", sqlite3_errmsg(db_conn)); + ret = -1; + goto out; + } + + ret = sqlite3_step(pre_stmt); + if (ret != SQLITE_ROW) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_GET_RECORD_FAILED, + "Failed to get records " + "from db : %s", + sqlite3_errmsg(db_conn)); + ret = -1; + goto out; + } + + ret = gf_asprintf(version, "%s", sqlite3_column_text(pre_stmt, 0)); + if (ret <= 0) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, + "Failed extracting version"); + } out: - sqlite3_finalize (pre_stmt); + sqlite3_finalize(pre_stmt); - return ret; + return ret; } - - /* Function to extract PRAGMA from sqlite db * Input: * void *db_conn : Sqlite connection @@ -1315,59 +1288,57 @@ out: * On failure return -1 * */ int -gf_sqlite3_pragma (void *db_conn, char *pragma_key, char **pragma_value) +gf_sqlite3_pragma(void *db_conn, char *pragma_key, char **pragma_value) { - int ret = -1; - gf_sql_connection_t *sql_conn = db_conn; - sqlite3_stmt *pre_stmt = NULL; - char *sqlstring = NULL; - - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pragma_key, out); - - ret = gf_asprintf (&sqlstring, "PRAGMA %s;", pragma_key); + int ret = -1; + gf_sql_connection_t *sql_conn = db_conn; + sqlite3_stmt *pre_stmt = NULL; + char *sqlstring = NULL; + + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, pragma_key, out); + + ret = gf_asprintf(&sqlstring, "PRAGMA %s;", pragma_key); + if (ret <= 0) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Failed allocating memory"); + goto out; + } + + ret = sqlite3_prepare_v2(sql_conn->sqlite3_db_conn, sqlstring, -1, + &pre_stmt, 0); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Failed init prepare stmt %s", sqlite3_errmsg(db_conn)); + ret = -1; + goto out; + } + + ret = sqlite3_step(pre_stmt); + if (ret != SQLITE_ROW) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_GET_RECORD_FAILED, + "Failed to get records " + "from db : %s", + sqlite3_errmsg(db_conn)); + ret = -1; + goto out; + } + + if (pragma_value) { + ret = gf_asprintf(pragma_value, "%s", sqlite3_column_text(pre_stmt, 0)); if (ret <= 0) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, "Failed allocating memory"); - goto out; + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, + "Failed to get %s from db", pragma_key); } + } - ret = sqlite3_prepare_v2 (sql_conn->sqlite3_db_conn, - sqlstring, -1, &pre_stmt, 0); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, "Failed init prepare stmt %s", - sqlite3_errmsg (db_conn)); - ret = -1; - goto out; - } - - ret = sqlite3_step (pre_stmt); - if (ret != SQLITE_ROW) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_GET_RECORD_FAILED, "Failed to get records " - "from db : %s", sqlite3_errmsg (db_conn)); - ret = -1; - goto out; - } - - if (pragma_value) { - ret = gf_asprintf (pragma_value, "%s", - sqlite3_column_text (pre_stmt, 0)); - if (ret <= 0) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_QUERY_FAILED, "Failed to get %s from db", - pragma_key); - } - } - - ret = 0; + ret = 0; out: - GF_FREE (sqlstring); + GF_FREE(sqlstring); - sqlite3_finalize (pre_stmt); + sqlite3_finalize(pre_stmt); - return ret; + return ret; } /* Function to set PRAGMA to sqlite db @@ -1380,35 +1351,34 @@ out: * On failure return -1 * */ int -gf_sqlite3_set_pragma (void *db_conn, char *pragma_key, char *pragma_value) +gf_sqlite3_set_pragma(void *db_conn, char *pragma_key, char *pragma_value) { - int ret = -1; - gf_sql_connection_t *sql_conn = db_conn; - char sqlstring[GF_NAME_MAX] = ""; - char *db_pragma_value = NULL; + int ret = -1; + gf_sql_connection_t *sql_conn = db_conn; + char sqlstring[GF_NAME_MAX] = ""; + char *db_pragma_value = NULL; - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pragma_key, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pragma_value, out); + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, pragma_key, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, pragma_value, out); - GF_SQLITE3_SET_PRAGMA(sqlstring, pragma_key, "%s", - pragma_value, ret, out); + GF_SQLITE3_SET_PRAGMA(sqlstring, pragma_key, "%s", pragma_value, ret, out); - ret = gf_sqlite3_pragma (db_conn, pragma_key, &db_pragma_value); - if (ret < 0) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, - "Failed to get %s pragma", pragma_key); - } else { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_TRACE, 0, 0, - "Value set on DB %s : %s", pragma_key, db_pragma_value); - } - GF_FREE (db_pragma_value); + ret = gf_sqlite3_pragma(db_conn, pragma_key, &db_pragma_value); + if (ret < 0) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_QUERY_FAILED, + "Failed to get %s pragma", pragma_key); + } else { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_TRACE, 0, 0, "Value set on DB %s : %s", + pragma_key, db_pragma_value); + } + GF_FREE(db_pragma_value); - ret = 0; + ret = 0; out: - return ret; + return ret; } /* Function to vacuum of sqlite db @@ -1421,167 +1391,152 @@ out: * On failure return -1 * */ int -gf_sqlite3_vacuum (void *db_conn, gf_boolean_t compact_active, - gf_boolean_t compact_mode_switched) +gf_sqlite3_vacuum(void *db_conn, gf_boolean_t compact_active, + gf_boolean_t compact_mode_switched) { - int ret = -1; - gf_sql_connection_t *sql_conn = db_conn; - char *sqlstring = NULL; - char *sql_strerror = NULL; - gf_boolean_t changing_pragma = _gf_true; - - CHECK_SQL_CONN (sql_conn, out); - - if (GF_SQL_COMPACT_DEF == GF_SQL_COMPACT_NONE) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_INFO, 0, - LG_MSG_COMPACT_STATUS, - "VACUUM type is off: no VACUUM to do"); - goto out; - } - - if (compact_mode_switched) { - if (compact_active) { /* Then it was OFF before. - So turn everything on */ - ret = 0; - switch (GF_SQL_COMPACT_DEF) { - case GF_SQL_COMPACT_FULL: - ret = gf_sqlite3_set_pragma (db_conn, - "auto_vacuum", - GF_SQL_AV_FULL); - break; - case GF_SQL_COMPACT_INCR: - ret = gf_sqlite3_set_pragma (db_conn, - "auto_vacuum", - GF_SQL_AV_INCR); - break; - case GF_SQL_COMPACT_MANUAL: - changing_pragma = _gf_false; - break; - default: - ret = -1; - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_COMPACT_FAILED, - "VACUUM type undefined"); - goto out; - break; - } - - } else { /* Then it was ON before, so turn it all off */ - if (GF_SQL_COMPACT_DEF == GF_SQL_COMPACT_FULL || - GF_SQL_COMPACT_DEF == GF_SQL_COMPACT_INCR) { - ret = gf_sqlite3_set_pragma (db_conn, - "auto_vacuum", - GF_SQL_AV_NONE); - } else { - changing_pragma = _gf_false; - } - } - - if (ret) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_TRACE, 0, - LG_MSG_PREPARE_FAILED, - "Failed to set the pragma"); - goto out; - } + int ret = -1; + gf_sql_connection_t *sql_conn = db_conn; + char *sqlstring = NULL; + char *sql_strerror = NULL; + gf_boolean_t changing_pragma = _gf_true; - gf_msg (GFDB_STR_SQLITE3, GF_LOG_INFO, 0, - LG_MSG_COMPACT_STATUS, "Turning compaction %i", - GF_SQL_COMPACT_DEF); - - /* If we move from an auto_vacuum scheme to off, */ - /* or vice-versa, we must VACUUM to save the change. */ - /* In the case of a manual VACUUM scheme, we might as well */ - /* run a manual VACUUM now if we */ - if (changing_pragma || compact_active) { - ret = gf_asprintf (&sqlstring, "VACUUM;"); - if (ret <= 0) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, - "Failed allocating memory"); - goto out; - } - gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, - LG_MSG_COMPACT_STATUS, "Sealed with a VACUUM"); - } - } else { /* We are active, so it's time to VACUUM */ - if (!compact_active) { /* Did we somehow enter an inconsistent - state? */ - ret = -1; - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, - "Tried to VACUUM when compaction inactive"); - goto out; - } + CHECK_SQL_CONN(sql_conn, out); - gf_msg(GFDB_STR_SQLITE3, GF_LOG_TRACE, 0, - LG_MSG_COMPACT_STATUS, - "Doing regular vacuum of type %i", GF_SQL_COMPACT_DEF); - - switch (GF_SQL_COMPACT_DEF) { - case GF_SQL_COMPACT_INCR: /* INCR auto_vacuum */ - ret = gf_asprintf(&sqlstring, - "PRAGMA incremental_vacuum;"); - if (ret <= 0) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, - "Failed allocating memory"); - goto out; - } - gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, - LG_MSG_COMPACT_STATUS, - "Will commence an incremental VACUUM"); - break; - /* (MANUAL) Invoke the VACUUM command */ - case GF_SQL_COMPACT_MANUAL: - ret = gf_asprintf(&sqlstring, "VACUUM;"); - if (ret <= 0) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, - "Failed allocating memory"); - goto out; - } - gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, - LG_MSG_COMPACT_STATUS, - "Will commence a VACUUM"); - break; - /* (FULL) The database does the compaction itself. */ - /* We cannot do anything else, so we can leave */ - /* without sending anything to the database */ + if (GF_SQL_COMPACT_DEF == GF_SQL_COMPACT_NONE) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, LG_MSG_COMPACT_STATUS, + "VACUUM type is off: no VACUUM to do"); + goto out; + } + + if (compact_mode_switched) { + if (compact_active) { /* Then it was OFF before. + So turn everything on */ + ret = 0; + switch (GF_SQL_COMPACT_DEF) { case GF_SQL_COMPACT_FULL: - ret = 0; - goto success; - /* Any other state must be an error. Note that OFF */ - /* cannot hit this statement since we immediately leave */ - /* in that case */ + ret = gf_sqlite3_set_pragma(db_conn, "auto_vacuum", + GF_SQL_AV_FULL); + break; + case GF_SQL_COMPACT_INCR: + ret = gf_sqlite3_set_pragma(db_conn, "auto_vacuum", + GF_SQL_AV_INCR); + break; + case GF_SQL_COMPACT_MANUAL: + changing_pragma = _gf_false; + break; default: - ret = -1; - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_COMPACT_FAILED, - "VACUUM type undefined"); - goto out; - break; - } + ret = -1; + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, + LG_MSG_COMPACT_FAILED, "VACUUM type undefined"); + goto out; + break; + } + + } else { /* Then it was ON before, so turn it all off */ + if (GF_SQL_COMPACT_DEF == GF_SQL_COMPACT_FULL || + GF_SQL_COMPACT_DEF == GF_SQL_COMPACT_INCR) { + ret = gf_sqlite3_set_pragma(db_conn, "auto_vacuum", + GF_SQL_AV_NONE); + } else { + changing_pragma = _gf_false; + } } - gf_msg(GFDB_STR_SQLITE3, GF_LOG_TRACE, 0, LG_MSG_COMPACT_STATUS, - "SQLString == %s", sqlstring); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_TRACE, 0, LG_MSG_PREPARE_FAILED, + "Failed to set the pragma"); + goto out; + } - ret = sqlite3_exec(sql_conn->sqlite3_db_conn, sqlstring, NULL, NULL, - &sql_strerror); + gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, LG_MSG_COMPACT_STATUS, + "Turning compaction %i", GF_SQL_COMPACT_DEF); + + /* If we move from an auto_vacuum scheme to off, */ + /* or vice-versa, we must VACUUM to save the change. */ + /* In the case of a manual VACUUM scheme, we might as well */ + /* run a manual VACUUM now if we */ + if (changing_pragma || compact_active) { + ret = gf_asprintf(&sqlstring, "VACUUM;"); + if (ret <= 0) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Failed allocating memory"); + goto out; + } + gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, LG_MSG_COMPACT_STATUS, + "Sealed with a VACUUM"); + } + } else { /* We are active, so it's time to VACUUM */ + if (!compact_active) { /* Did we somehow enter an inconsistent + state? */ + ret = -1; + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Tried to VACUUM when compaction inactive"); + goto out; + } - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_GET_RECORD_FAILED, "Failed to vacuum " - "the db : %s", sqlite3_errmsg (db_conn)); + gf_msg(GFDB_STR_SQLITE3, GF_LOG_TRACE, 0, LG_MSG_COMPACT_STATUS, + "Doing regular vacuum of type %i", GF_SQL_COMPACT_DEF); + + switch (GF_SQL_COMPACT_DEF) { + case GF_SQL_COMPACT_INCR: /* INCR auto_vacuum */ + ret = gf_asprintf(&sqlstring, "PRAGMA incremental_vacuum;"); + if (ret <= 0) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, + LG_MSG_PREPARE_FAILED, "Failed allocating memory"); + goto out; + } + gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, LG_MSG_COMPACT_STATUS, + "Will commence an incremental VACUUM"); + break; + /* (MANUAL) Invoke the VACUUM command */ + case GF_SQL_COMPACT_MANUAL: + ret = gf_asprintf(&sqlstring, "VACUUM;"); + if (ret <= 0) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, + LG_MSG_PREPARE_FAILED, "Failed allocating memory"); + goto out; + } + gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, LG_MSG_COMPACT_STATUS, + "Will commence a VACUUM"); + break; + /* (FULL) The database does the compaction itself. */ + /* We cannot do anything else, so we can leave */ + /* without sending anything to the database */ + case GF_SQL_COMPACT_FULL: + ret = 0; + goto success; + /* Any other state must be an error. Note that OFF */ + /* cannot hit this statement since we immediately leave */ + /* in that case */ + default: ret = -1; + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_COMPACT_FAILED, + "VACUUM type undefined"); goto out; + break; } + } + + gf_msg(GFDB_STR_SQLITE3, GF_LOG_TRACE, 0, LG_MSG_COMPACT_STATUS, + "SQLString == %s", sqlstring); + + ret = sqlite3_exec(sql_conn->sqlite3_db_conn, sqlstring, NULL, NULL, + &sql_strerror); + + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_GET_RECORD_FAILED, + "Failed to vacuum " + "the db : %s", + sqlite3_errmsg(db_conn)); + ret = -1; + goto out; + } success: - gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, LG_MSG_COMPACT_STATUS, - compact_mode_switched ? "Successfully changed VACUUM on/off" - : "DB successfully VACUUM"); + gf_msg(GFDB_STR_SQLITE3, GF_LOG_INFO, 0, LG_MSG_COMPACT_STATUS, + compact_mode_switched ? "Successfully changed VACUUM on/off" + : "DB successfully VACUUM"); out: - GF_FREE(sqlstring); + GF_FREE(sqlstring); - return ret; + return ret; } diff --git a/libglusterfs/src/gfdb/gfdb_sqlite3_helper.c b/libglusterfs/src/gfdb/gfdb_sqlite3_helper.c index b2c3392f45a..60dd5e25e66 100644 --- a/libglusterfs/src/gfdb/gfdb_sqlite3_helper.c +++ b/libglusterfs/src/gfdb/gfdb_sqlite3_helper.c @@ -10,7 +10,6 @@ #include "gfdb_sqlite3_helper.h" - #define GFDB_SQL_STMT_SIZE 256 /***************************************************************************** @@ -21,711 +20,653 @@ * ****************************************************************************/ static int -gf_sql_delete_all (gf_sql_connection_t *sql_conn, - char *gfid, - gf_boolean_t ignore_errors) +gf_sql_delete_all(gf_sql_connection_t *sql_conn, char *gfid, + gf_boolean_t ignore_errors) { - int ret = -1; - sqlite3_stmt *delete_file_stmt = NULL; - sqlite3_stmt *delete_link_stmt = NULL; - char *delete_link_str = "DELETE FROM " - GF_FILE_LINK_TABLE - " WHERE GF_ID = ? ;"; - char *delete_file_str = "DELETE FROM " - GF_FILE_TABLE - " WHERE GF_ID = ? ;"; - - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out); - - /* - * Delete all links associated with this GFID - * - * */ - /*Prepare statement for delete all links*/ - ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, delete_link_str, -1, - &delete_link_stmt, 0); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, "Failed preparing delete " - "statement %s : %s", delete_link_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind gfid*/ - ret = sqlite3_bind_text (delete_link_stmt, 1, gfid, -1, NULL); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s", - gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - - /*Execute the prepare statement*/ - if (sqlite3_step (delete_link_stmt) != SQLITE_DONE) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0, - LG_MSG_EXEC_FAILED, - "Failed executing the prepared stmt %s : %s", - delete_link_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - - /* - * Delete entry from file table associated with this GFID - * - * */ - /*Prepare statement for delete all links*/ - ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, delete_file_str, -1, - &delete_file_stmt, 0); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, "Failed preparing delete " - "statement %s : %s", delete_file_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind gfid*/ - ret = sqlite3_bind_text (delete_file_stmt, 1, gfid, -1, NULL); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s", - gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Execute the prepare statement*/ - if (sqlite3_step (delete_file_stmt) != SQLITE_DONE) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0, - LG_MSG_EXEC_FAILED, - "Failed executing the prepared stmt %s : %s", - delete_file_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } + int ret = -1; + sqlite3_stmt *delete_file_stmt = NULL; + sqlite3_stmt *delete_link_stmt = NULL; + char *delete_link_str = "DELETE FROM " GF_FILE_LINK_TABLE + " WHERE GF_ID = ? ;"; + char *delete_file_str = "DELETE FROM " GF_FILE_TABLE " WHERE GF_ID = ? ;"; + + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfid, out); + + /* + * Delete all links associated with this GFID + * + * */ + /*Prepare statement for delete all links*/ + ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, delete_link_str, -1, + &delete_link_stmt, 0); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Failed preparing delete " + "statement %s : %s", + delete_link_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind gfid*/ + ret = sqlite3_bind_text(delete_link_stmt, 1, gfid, -1, NULL); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding gfid %s : %s", gfid, + sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Execute the prepare statement*/ + if (sqlite3_step(delete_link_stmt) != SQLITE_DONE) { + gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors), + 0, LG_MSG_EXEC_FAILED, + "Failed executing the prepared stmt %s : %s", delete_link_str, + sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /* + * Delete entry from file table associated with this GFID + * + * */ + /*Prepare statement for delete all links*/ + ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, delete_file_str, -1, + &delete_file_stmt, 0); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Failed preparing delete " + "statement %s : %s", + delete_file_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind gfid*/ + ret = sqlite3_bind_text(delete_file_stmt, 1, gfid, -1, NULL); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding gfid %s : %s", gfid, + sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Execute the prepare statement*/ + if (sqlite3_step(delete_file_stmt) != SQLITE_DONE) { + gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors), + 0, LG_MSG_EXEC_FAILED, + "Failed executing the prepared stmt %s : %s", delete_file_str, + sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } out: - /*Free prepared statement*/ - sqlite3_finalize (delete_file_stmt); - sqlite3_finalize (delete_link_stmt); - return ret; + /*Free prepared statement*/ + sqlite3_finalize(delete_file_stmt); + sqlite3_finalize(delete_link_stmt); + return ret; } static int -gf_sql_delete_link (gf_sql_connection_t *sql_conn, - char *gfid, - char *pargfid, - char *basename, - gf_boolean_t ignore_errors) +gf_sql_delete_link(gf_sql_connection_t *sql_conn, char *gfid, char *pargfid, + char *basename, gf_boolean_t ignore_errors) { - int ret = -1; - sqlite3_stmt *delete_stmt = NULL; - char *delete_str = "DELETE FROM " - GF_FILE_LINK_TABLE - " WHERE GF_ID = ? AND GF_PID = ?" - " AND FNAME = ?;"; - - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pargfid, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, basename, out); - - /*Prepare statement*/ - ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, delete_str, -1, - &delete_stmt, 0); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, "Failed preparing delete " - "statement %s : %s", delete_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind gfid*/ - ret = sqlite3_bind_text (delete_stmt, 1, gfid, -1, NULL); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, - "Failed binding gfid %s : %s", gfid, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind pargfid*/ - ret = sqlite3_bind_text (delete_stmt, 2, pargfid, -1, NULL); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed binding parent gfid %s " - ": %s", pargfid, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind basename*/ - ret = sqlite3_bind_text (delete_stmt, 3, basename, -1, NULL); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed binding basename %s : " - "%s", basename, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Execute the prepare statement*/ - if (sqlite3_step(delete_stmt) != SQLITE_DONE) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0, - LG_MSG_EXEC_FAILED, - "Failed executing the prepared stmt %s : %s", - delete_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - - ret = 0; + int ret = -1; + sqlite3_stmt *delete_stmt = NULL; + char *delete_str = "DELETE FROM " GF_FILE_LINK_TABLE + " WHERE GF_ID = ? AND GF_PID = ?" + " AND FNAME = ?;"; + + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfid, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, pargfid, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, basename, out); + + /*Prepare statement*/ + ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, delete_str, -1, + &delete_stmt, 0); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Failed preparing delete " + "statement %s : %s", + delete_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind gfid*/ + ret = sqlite3_bind_text(delete_stmt, 1, gfid, -1, NULL); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding gfid %s : %s", gfid, + sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind pargfid*/ + ret = sqlite3_bind_text(delete_stmt, 2, pargfid, -1, NULL); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding parent gfid %s " + ": %s", + pargfid, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind basename*/ + ret = sqlite3_bind_text(delete_stmt, 3, basename, -1, NULL); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding basename %s : " + "%s", + basename, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Execute the prepare statement*/ + if (sqlite3_step(delete_stmt) != SQLITE_DONE) { + gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors), + 0, LG_MSG_EXEC_FAILED, + "Failed executing the prepared stmt %s : %s", delete_str, + sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + ret = 0; out: - /*Free prepared statement*/ - sqlite3_finalize (delete_stmt); - return ret; + /*Free prepared statement*/ + sqlite3_finalize(delete_stmt); + return ret; } - - static int -gf_sql_update_link_flags (gf_sql_connection_t *sql_conn, - char *gfid, - char *pargfid, - char *basename, - int update_flag, - gf_boolean_t is_update_or_delete, - gf_boolean_t ignore_errors) +gf_sql_update_link_flags(gf_sql_connection_t *sql_conn, char *gfid, + char *pargfid, char *basename, int update_flag, + gf_boolean_t is_update_or_delete, + gf_boolean_t ignore_errors) { - int ret = -1; - sqlite3_stmt *update_stmt = NULL; - char *update_column = NULL; - char update_str[1024] = ""; - - - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pargfid, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, basename, out); - - update_column = (is_update_or_delete) ? "LINK_UPDATE" : "W_DEL_FLAG"; - - sprintf (update_str, "UPDATE " - GF_FILE_LINK_TABLE - " SET %s = ?" - " WHERE GF_ID = ? AND GF_PID = ? AND FNAME = ?;", - update_column); - - /*Prepare statement*/ - ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, update_str, -1, - &update_stmt, 0); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, "Failed preparing update " - "statement %s : %s", update_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - - /*Bind link_update*/ - ret = sqlite3_bind_int (update_stmt, 1, update_flag); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed binding update_flag %d " - ": %s", update_flag, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind gfid*/ - ret = sqlite3_bind_text (update_stmt, 2, gfid, -1, NULL); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s", - gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind pargfid*/ - ret = sqlite3_bind_text (update_stmt, 3, pargfid, -1, NULL); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed binding parent gfid %s " - ": %s", pargfid, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind basename*/ - ret = sqlite3_bind_text (update_stmt, 4, basename, -1, NULL); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed binding basename %s : " - "%s", basename, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - - /*Execute the prepare statement*/ - if (sqlite3_step(update_stmt) != SQLITE_DONE) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0, - LG_MSG_EXEC_FAILED, - "Failed executing the prepared stmt %s : %s", - update_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - ret = 0; + int ret = -1; + sqlite3_stmt *update_stmt = NULL; + char *update_column = NULL; + char update_str[1024] = ""; + + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfid, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, pargfid, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, basename, out); + + update_column = (is_update_or_delete) ? "LINK_UPDATE" : "W_DEL_FLAG"; + + sprintf(update_str, + "UPDATE " GF_FILE_LINK_TABLE + " SET %s = ?" + " WHERE GF_ID = ? AND GF_PID = ? AND FNAME = ?;", + update_column); + + /*Prepare statement*/ + ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, update_str, -1, + &update_stmt, 0); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Failed preparing update " + "statement %s : %s", + update_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind link_update*/ + ret = sqlite3_bind_int(update_stmt, 1, update_flag); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding update_flag %d " + ": %s", + update_flag, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind gfid*/ + ret = sqlite3_bind_text(update_stmt, 2, gfid, -1, NULL); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding gfid %s : %s", gfid, + sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind pargfid*/ + ret = sqlite3_bind_text(update_stmt, 3, pargfid, -1, NULL); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding parent gfid %s " + ": %s", + pargfid, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind basename*/ + ret = sqlite3_bind_text(update_stmt, 4, basename, -1, NULL); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding basename %s : " + "%s", + basename, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Execute the prepare statement*/ + if (sqlite3_step(update_stmt) != SQLITE_DONE) { + gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors), + 0, LG_MSG_EXEC_FAILED, + "Failed executing the prepared stmt %s : %s", update_str, + sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + ret = 0; out: - /*Free prepared statement*/ - sqlite3_finalize (update_stmt); - return ret; + /*Free prepared statement*/ + sqlite3_finalize(update_stmt); + return ret; } - static int -gf_sql_insert_link (gf_sql_connection_t *sql_conn, - char *gfid, - char *pargfid, - char *basename, - gf_boolean_t link_consistency, - gf_boolean_t ignore_errors) +gf_sql_insert_link(gf_sql_connection_t *sql_conn, char *gfid, char *pargfid, + char *basename, gf_boolean_t link_consistency, + gf_boolean_t ignore_errors) { - int ret = -1; - sqlite3_stmt *insert_stmt = NULL; - char insert_str[GFDB_SQL_STMT_SIZE] = ""; - - sprintf (insert_str, "INSERT INTO " - GF_FILE_LINK_TABLE - " (GF_ID, GF_PID, FNAME," - " W_DEL_FLAG, LINK_UPDATE) " - " VALUES (?, ?, ?, 0, %d);", - link_consistency); - - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pargfid, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, basename, out); - - /*Prepare statement*/ - ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, insert_str, -1, - &insert_stmt, 0); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, - "Failed preparing insert " - "statement %s : %s", insert_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind gfid*/ - ret = sqlite3_bind_text (insert_stmt, 1, gfid, -1, NULL); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, - "Failed binding gfid %s : %s", - gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind pargfid*/ - ret = sqlite3_bind_text (insert_stmt, 2, pargfid, -1, NULL); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, - 0, LG_MSG_BINDING_FAILED, - "Failed binding parent gfid %s " - ": %s", pargfid, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind basename*/ - ret = sqlite3_bind_text (insert_stmt, 3, basename, -1, NULL); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, - 0, LG_MSG_BINDING_FAILED, - "Failed binding basename %s : %s", basename, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Execute the prepare statement*/ - if (sqlite3_step (insert_stmt) != SQLITE_DONE) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, ignore_errors), - 0, LG_MSG_EXEC_FAILED, - "Failed executing the prepared " - "stmt %s %s %s %s : %s", - gfid, pargfid, basename, insert_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - ret = 0; + int ret = -1; + sqlite3_stmt *insert_stmt = NULL; + char insert_str[GFDB_SQL_STMT_SIZE] = ""; + + sprintf(insert_str, + "INSERT INTO " GF_FILE_LINK_TABLE + " (GF_ID, GF_PID, FNAME," + " W_DEL_FLAG, LINK_UPDATE) " + " VALUES (?, ?, ?, 0, %d);", + link_consistency); + + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfid, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, pargfid, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, basename, out); + + /*Prepare statement*/ + ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, insert_str, -1, + &insert_stmt, 0); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Failed preparing insert " + "statement %s : %s", + insert_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind gfid*/ + ret = sqlite3_bind_text(insert_stmt, 1, gfid, -1, NULL); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding gfid %s : %s", gfid, + sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind pargfid*/ + ret = sqlite3_bind_text(insert_stmt, 2, pargfid, -1, NULL); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding parent gfid %s " + ": %s", + pargfid, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind basename*/ + ret = sqlite3_bind_text(insert_stmt, 3, basename, -1, NULL); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding basename %s : %s", basename, + sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Execute the prepare statement*/ + if (sqlite3_step(insert_stmt) != SQLITE_DONE) { + gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors), + 0, LG_MSG_EXEC_FAILED, + "Failed executing the prepared " + "stmt %s %s %s %s : %s", + gfid, pargfid, basename, insert_str, + sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + ret = 0; out: - /*Free prepared statement*/ - sqlite3_finalize (insert_stmt); - return ret; + /*Free prepared statement*/ + sqlite3_finalize(insert_stmt); + return ret; } - static int -gf_sql_update_link (gf_sql_connection_t *sql_conn, - char *gfid, - char *pargfid, - char *basename, - char *old_pargfid, - char *old_basename, - gf_boolean_t link_consistency, - gf_boolean_t ignore_errors) +gf_sql_update_link(gf_sql_connection_t *sql_conn, char *gfid, char *pargfid, + char *basename, char *old_pargfid, char *old_basename, + gf_boolean_t link_consistency, gf_boolean_t ignore_errors) { - int ret = -1; - sqlite3_stmt *insert_stmt = NULL; - char insert_str[GFDB_SQL_STMT_SIZE] = ""; - - sprintf (insert_str, "INSERT INTO " - GF_FILE_LINK_TABLE - " (GF_ID, GF_PID, FNAME," - " W_DEL_FLAG, LINK_UPDATE) " - " VALUES (? , ?, ?, 0, %d);", - link_consistency); - - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pargfid, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, basename, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, old_pargfid, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, old_basename, out); - - /* - * - * Delete the old link - * - * */ - ret = gf_sql_delete_link (sql_conn, gfid, old_pargfid, - old_basename, ignore_errors); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0, - LG_MSG_DELETE_FAILED, "Failed deleting old link"); - goto out; - } - - /* - * - * insert new link - * - * */ - /*Prepare statement*/ - ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, insert_str, -1, - &insert_stmt, 0); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, "Failed preparing insert " - "statement %s : %s", insert_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind gfid*/ - ret = sqlite3_bind_text (insert_stmt, 1, gfid, -1, NULL); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s", - gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind new pargfid*/ - ret = sqlite3_bind_text (insert_stmt, 2, pargfid, -1, NULL); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed binding parent gfid %s " - ": %s", pargfid, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind new basename*/ - ret = sqlite3_bind_text (insert_stmt, 3, basename, -1, NULL); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed binding basename %s : " - "%s", basename, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Execute the prepare statement*/ - if (sqlite3_step (insert_stmt) != SQLITE_DONE) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0, - LG_MSG_EXEC_FAILED, - "Failed executing the prepared stmt %s : %s", - insert_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - - - ret = 0; + int ret = -1; + sqlite3_stmt *insert_stmt = NULL; + char insert_str[GFDB_SQL_STMT_SIZE] = ""; + + sprintf(insert_str, + "INSERT INTO " GF_FILE_LINK_TABLE + " (GF_ID, GF_PID, FNAME," + " W_DEL_FLAG, LINK_UPDATE) " + " VALUES (? , ?, ?, 0, %d);", + link_consistency); + + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfid, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, pargfid, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, basename, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, old_pargfid, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, old_basename, out); + + /* + * + * Delete the old link + * + * */ + ret = gf_sql_delete_link(sql_conn, gfid, old_pargfid, old_basename, + ignore_errors); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors), + 0, LG_MSG_DELETE_FAILED, "Failed deleting old link"); + goto out; + } + + /* + * + * insert new link + * + * */ + /*Prepare statement*/ + ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, insert_str, -1, + &insert_stmt, 0); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Failed preparing insert " + "statement %s : %s", + insert_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind gfid*/ + ret = sqlite3_bind_text(insert_stmt, 1, gfid, -1, NULL); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding gfid %s : %s", gfid, + sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind new pargfid*/ + ret = sqlite3_bind_text(insert_stmt, 2, pargfid, -1, NULL); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding parent gfid %s " + ": %s", + pargfid, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind new basename*/ + ret = sqlite3_bind_text(insert_stmt, 3, basename, -1, NULL); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding basename %s : " + "%s", + basename, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Execute the prepare statement*/ + if (sqlite3_step(insert_stmt) != SQLITE_DONE) { + gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors), + 0, LG_MSG_EXEC_FAILED, + "Failed executing the prepared stmt %s : %s", insert_str, + sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + ret = 0; out: - /*Free prepared statement*/ - sqlite3_finalize (insert_stmt); - return ret; + /*Free prepared statement*/ + sqlite3_finalize(insert_stmt); + return ret; } static int -gf_sql_insert_write_wind_time (gf_sql_connection_t *sql_conn, - char *gfid, - gfdb_time_t *wind_time, - gf_boolean_t ignore_errors) +gf_sql_insert_write_wind_time(gf_sql_connection_t *sql_conn, char *gfid, + gfdb_time_t *wind_time, + gf_boolean_t ignore_errors) { - int ret = -1; - sqlite3_stmt *insert_stmt = NULL; - char *insert_str = "INSERT INTO " - GF_FILE_TABLE - "(GF_ID, W_SEC, W_MSEC, UW_SEC, UW_MSEC)" - " VALUES (?, ?, ?, 0, 0);"; - - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, wind_time, out); - - - /*Prepare statement*/ - ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, insert_str, -1, - &insert_stmt, 0); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, "Failed preparing insert " - "statement %s : %s", insert_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind gfid*/ - ret = sqlite3_bind_text (insert_stmt, 1, gfid, -1, NULL); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s", - gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind wind secs*/ - ret = sqlite3_bind_int (insert_stmt, 2, wind_time->tv_sec); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed binding parent wind " - "secs %ld : %s", wind_time->tv_sec, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind wind msecs*/ - ret = sqlite3_bind_int (insert_stmt, 3, wind_time->tv_usec); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed binding parent wind " - "msecs %ld : %s", wind_time->tv_usec, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Execute the prepare statement*/ - if (sqlite3_step (insert_stmt) != SQLITE_DONE) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0, - LG_MSG_EXEC_FAILED, - "Failed executing the prepared stmt GFID:%s %s : %s", - gfid, insert_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - ret = 0; + int ret = -1; + sqlite3_stmt *insert_stmt = NULL; + char *insert_str = "INSERT INTO " GF_FILE_TABLE + "(GF_ID, W_SEC, W_MSEC, UW_SEC, UW_MSEC)" + " VALUES (?, ?, ?, 0, 0);"; + + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfid, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, wind_time, out); + + /*Prepare statement*/ + ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, insert_str, -1, + &insert_stmt, 0); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Failed preparing insert " + "statement %s : %s", + insert_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind gfid*/ + ret = sqlite3_bind_text(insert_stmt, 1, gfid, -1, NULL); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding gfid %s : %s", gfid, + sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind wind secs*/ + ret = sqlite3_bind_int(insert_stmt, 2, wind_time->tv_sec); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding parent wind " + "secs %ld : %s", + wind_time->tv_sec, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind wind msecs*/ + ret = sqlite3_bind_int(insert_stmt, 3, wind_time->tv_usec); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding parent wind " + "msecs %ld : %s", + wind_time->tv_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Execute the prepare statement*/ + if (sqlite3_step(insert_stmt) != SQLITE_DONE) { + gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors), + 0, LG_MSG_EXEC_FAILED, + "Failed executing the prepared stmt GFID:%s %s : %s", gfid, + insert_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + ret = 0; out: - /*Free prepared statement*/ - sqlite3_finalize (insert_stmt); - return ret; + /*Free prepared statement*/ + sqlite3_finalize(insert_stmt); + return ret; } - - /*Update write/read times for both wind and unwind*/ static int -gf_update_time (gf_sql_connection_t *sql_conn, - char *gfid, - gfdb_time_t *update_time, - gf_boolean_t record_counter, - gf_boolean_t is_wind, - gf_boolean_t is_read, - gf_boolean_t ignore_errors) +gf_update_time(gf_sql_connection_t *sql_conn, char *gfid, + gfdb_time_t *update_time, gf_boolean_t record_counter, + gf_boolean_t is_wind, gf_boolean_t is_read, + gf_boolean_t ignore_errors) { - int ret = -1; - sqlite3_stmt *update_stmt = NULL; - char update_str[1024] = ""; - char *freq_cntr_str = NULL; - - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, update_time, out); - - /* - * Constructing the prepare statement string. - * - * */ - /*For write time*/ - if (!is_read) { - if (is_wind) { - /*if record counter is on*/ - freq_cntr_str = (record_counter) ? - ", WRITE_FREQ_CNTR = WRITE_FREQ_CNTR + 1" : ""; - - /*Perfectly safe as we will not go array of bound*/ - sprintf (update_str, "UPDATE " - GF_FILE_TABLE - " SET W_SEC = ?, W_MSEC = ? " - " %s"/*place for read freq counters*/ - " WHERE GF_ID = ? ;", freq_cntr_str); - } else { - /*Perfectly safe as we will not go array of bound*/ - sprintf (update_str, "UPDATE " - GF_FILE_TABLE - " SET UW_SEC = ?, UW_MSEC = ? ;"); - } + int ret = -1; + sqlite3_stmt *update_stmt = NULL; + char update_str[1024] = ""; + char *freq_cntr_str = NULL; + + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfid, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, update_time, out); + + /* + * Constructing the prepare statement string. + * + * */ + /*For write time*/ + if (!is_read) { + if (is_wind) { + /*if record counter is on*/ + freq_cntr_str = (record_counter) + ? ", WRITE_FREQ_CNTR = WRITE_FREQ_CNTR + 1" + : ""; + + /*Perfectly safe as we will not go array of bound*/ + sprintf(update_str, + "UPDATE " GF_FILE_TABLE + " SET W_SEC = ?, W_MSEC = ? " + " %s" /*place for read freq counters*/ + " WHERE GF_ID = ? ;", + freq_cntr_str); + } else { + /*Perfectly safe as we will not go array of bound*/ + sprintf(update_str, + "UPDATE " GF_FILE_TABLE " SET UW_SEC = ?, UW_MSEC = ? ;"); } - /*For Read Time update*/ - else { - if (is_wind) { - /*if record counter is on*/ - freq_cntr_str = (record_counter) ? - ", READ_FREQ_CNTR = READ_FREQ_CNTR + 1" : ""; - - /*Perfectly safe as we will not go array of bound*/ - sprintf (update_str, "UPDATE " - GF_FILE_TABLE - " SET W_READ_SEC = ?, W_READ_MSEC = ? " - " %s"/*place for read freq counters*/ - " WHERE GF_ID = ? ;", freq_cntr_str); - } else { - /*Perfectly safe as we will not go array of bound*/ - sprintf (update_str, "UPDATE " - GF_FILE_TABLE + } + /*For Read Time update*/ + else { + if (is_wind) { + /*if record counter is on*/ + freq_cntr_str = (record_counter) + ? ", READ_FREQ_CNTR = READ_FREQ_CNTR + 1" + : ""; + + /*Perfectly safe as we will not go array of bound*/ + sprintf(update_str, + "UPDATE " GF_FILE_TABLE + " SET W_READ_SEC = ?, W_READ_MSEC = ? " + " %s" /*place for read freq counters*/ + " WHERE GF_ID = ? ;", + freq_cntr_str); + } else { + /*Perfectly safe as we will not go array of bound*/ + sprintf(update_str, "UPDATE " GF_FILE_TABLE " SET UW_READ_SEC = ?, UW_READ_MSEC = ? ;"); - } - } - - /*Prepare statement*/ - ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, update_str, -1, - &update_stmt, 0); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PREPARE_FAILED, "Failed preparing insert " - "statement %s : %s", update_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind time secs*/ - ret = sqlite3_bind_int (update_stmt, 1, update_time->tv_sec); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed binding parent wind " - "secs %ld : %s", update_time->tv_sec, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Bind time msecs*/ - ret = sqlite3_bind_int (update_stmt, 2, update_time->tv_usec); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed binding parent wind " - "msecs %ld : %s", update_time->tv_usec, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; } - - /*Bind gfid*/ - ret = sqlite3_bind_text (update_stmt, 3, gfid, -1, NULL); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s", - gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - /*Execute the prepare statement*/ - if (sqlite3_step (update_stmt) != SQLITE_DONE) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, ignore_errors), 0, - LG_MSG_EXEC_FAILED, - "Failed executing the prepared stmt %s : %s", - update_str, - sqlite3_errmsg (sql_conn->sqlite3_db_conn)); - ret = -1; - goto out; - } - - ret = 0; + } + + /*Prepare statement*/ + ret = sqlite3_prepare(sql_conn->sqlite3_db_conn, update_str, -1, + &update_stmt, 0); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PREPARE_FAILED, + "Failed preparing insert " + "statement %s : %s", + update_str, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind time secs*/ + ret = sqlite3_bind_int(update_stmt, 1, update_time->tv_sec); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding parent wind " + "secs %ld : %s", + update_time->tv_sec, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind time msecs*/ + ret = sqlite3_bind_int(update_stmt, 2, update_time->tv_usec); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding parent wind " + "msecs %ld : %s", + update_time->tv_usec, sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Bind gfid*/ + ret = sqlite3_bind_text(update_stmt, 3, gfid, -1, NULL); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_BINDING_FAILED, + "Failed binding gfid %s : %s", gfid, + sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + /*Execute the prepare statement*/ + if (sqlite3_step(update_stmt) != SQLITE_DONE) { + gf_msg(GFDB_STR_SQLITE3, _gfdb_log_level(GF_LOG_ERROR, ignore_errors), + 0, LG_MSG_EXEC_FAILED, + "Failed executing the prepared stmt %s : %s", update_str, + sqlite3_errmsg(sql_conn->sqlite3_db_conn)); + ret = -1; + goto out; + } + + ret = 0; out: - /*Free prepared statement*/ - sqlite3_finalize (update_stmt); - return ret; + /*Free prepared statement*/ + sqlite3_finalize(update_stmt); + return ret; } /****************************************************************************** @@ -736,394 +677,364 @@ out: * ****************************************************************************/ int -gf_sql_insert_wind (gf_sql_connection_t *sql_conn, - gfdb_db_record_t *gfdb_db_record) +gf_sql_insert_wind(gf_sql_connection_t *sql_conn, + gfdb_db_record_t *gfdb_db_record) { - int ret = -1; - gfdb_time_t *modtime = NULL; - char *pargfid_str = NULL; - char *gfid_str = NULL; - char *old_pargfid_str = NULL; - gf_boolean_t its_wind = _gf_true;/*remains true for this function*/ - - - - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfdb_db_record, out); - + int ret = -1; + gfdb_time_t *modtime = NULL; + char *pargfid_str = NULL; + char *gfid_str = NULL; + char *old_pargfid_str = NULL; + gf_boolean_t its_wind = _gf_true; /*remains true for this function*/ + + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out); + + gfid_str = gf_strdup(uuid_utoa(gfdb_db_record->gfid)); + if (!gfid_str) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED, + "Creating gfid string failed."); + goto out; + } + + modtime = &gfdb_db_record->gfdb_wind_change_time; + + /* handle all dentry based operations */ + if (isdentryfop(gfdb_db_record->gfdb_fop_type)) { + /*Parent GFID is always set*/ + pargfid_str = gf_strdup(uuid_utoa(gfdb_db_record->pargfid)); + if (!pargfid_str) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED, + "Creating gfid string " + "failed."); + goto out; + } - gfid_str = gf_strdup (uuid_utoa (gfdb_db_record->gfid)); - if (!gfid_str) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED, - "Creating gfid string failed."); + /* handle create, mknod */ + if (isdentrycreatefop(gfdb_db_record->gfdb_fop_type)) { + /*insert link*/ + ret = gf_sql_insert_link( + sql_conn, gfid_str, pargfid_str, gfdb_db_record->file_name, + gfdb_db_record->link_consistency, _gf_true); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, + _gfdb_log_level(GF_LOG_WARNING, + gfdb_db_record->ignore_errors), + 0, LG_MSG_INSERT_FAILED, + "Failed " + "inserting link in DB"); + /* Even if link creation is failed we + * continue with the creation of file record. + * This covers to cases + * 1) Lookup heal: If the file record from + * gf_file_tb is deleted but the link record + * still exist. Lookup heal will attempt a heal + * with create_wind set. The link heal will fail + * as there is already a record and if we don't + * ignore the error we will not heal the + * gf_file_tb. + * 2) Rename file in cold tier: During a rename + * of a file that is there in cold tier. We get + * an link record created in hot tier for the + * linkto file. When the file gets heated and + * moves to hot tier there will be attempt from + * ctr lookup heal to create link and file + * record and If we don't ignore the error we + * will not heal the gf_file_tb. + * */ + } + gfdb_db_record->islinkupdate = gfdb_db_record->link_consistency; + + /* + * Only for create/mknod insert wind time + * for the first time + * */ + ret = gf_sql_insert_write_wind_time(sql_conn, gfid_str, modtime, + gfdb_db_record->ignore_errors); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, + _gfdb_log_level(GF_LOG_ERROR, + gfdb_db_record->ignore_errors), + 0, LG_MSG_INSERT_FAILED, + "Failed inserting wind time in DB"); goto out; + } + goto out; } - - modtime = &gfdb_db_record->gfdb_wind_change_time; - - /* handle all dentry based operations */ - if (isdentryfop (gfdb_db_record->gfdb_fop_type)) { - /*Parent GFID is always set*/ - pargfid_str = gf_strdup (uuid_utoa (gfdb_db_record->pargfid)); - if (!pargfid_str) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, - 0, LG_MSG_CREATE_FAILED, "Creating gfid string " - "failed."); - goto out; - } - - /* handle create, mknod */ - if (isdentrycreatefop (gfdb_db_record->gfdb_fop_type)) { - /*insert link*/ - ret = gf_sql_insert_link(sql_conn, - gfid_str, pargfid_str, - gfdb_db_record->file_name, - gfdb_db_record->link_consistency, - _gf_true); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_WARNING, - gfdb_db_record->ignore_errors), - 0, - LG_MSG_INSERT_FAILED, "Failed " - "inserting link in DB"); - /* Even if link creation is failed we - * continue with the creation of file record. - * This covers to cases - * 1) Lookup heal: If the file record from - * gf_file_tb is deleted but the link record - * still exist. Lookup heal will attempt a heal - * with create_wind set. The link heal will fail - * as there is already a record and if we don't - * ignore the error we will not heal the - * gf_file_tb. - * 2) Rename file in cold tier: During a rename - * of a file that is there in cold tier. We get - * an link record created in hot tier for the - * linkto file. When the file gets heated and - * moves to hot tier there will be attempt from - * ctr lookup heal to create link and file - * record and If we don't ignore the error we - * will not heal the gf_file_tb. - * */ - } - gfdb_db_record->islinkupdate = gfdb_db_record-> - link_consistency; - - /* - * Only for create/mknod insert wind time - * for the first time - * */ - ret = gf_sql_insert_write_wind_time (sql_conn, gfid_str, - modtime, gfdb_db_record->ignore_errors); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, - gfdb_db_record->ignore_errors), - 0, LG_MSG_INSERT_FAILED, - "Failed inserting wind time in DB"); - goto out; - } - goto out; + /*handle rename, link */ + else { + /*rename*/ + if (strlen(gfdb_db_record->old_file_name) != 0) { + old_pargfid_str = gf_strdup( + uuid_utoa(gfdb_db_record->old_pargfid)); + if (!old_pargfid_str) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, + LG_MSG_CREATE_FAILED, + "Creating gfid string failed."); + goto out; } - /*handle rename, link */ - else { - /*rename*/ - if (strlen (gfdb_db_record->old_file_name) != 0) { - old_pargfid_str = gf_strdup (uuid_utoa ( - gfdb_db_record->old_pargfid)); - if (!old_pargfid_str) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, - 0, LG_MSG_CREATE_FAILED, - "Creating gfid string failed."); - goto out; - } - ret = gf_sql_update_link (sql_conn, gfid_str, - pargfid_str, - gfdb_db_record->file_name, - old_pargfid_str, - gfdb_db_record->old_file_name, - gfdb_db_record-> - link_consistency, - gfdb_db_record->ignore_errors); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, - gfdb_db_record->ignore_errors), - 0, LG_MSG_UPDATE_FAILED, - "Failed updating link"); - goto out; - } - gfdb_db_record->islinkupdate = gfdb_db_record-> - link_consistency; - } - /*link*/ - else { - ret = gf_sql_insert_link (sql_conn, - gfid_str, pargfid_str, - gfdb_db_record->file_name, - gfdb_db_record-> - link_consistency, - gfdb_db_record->ignore_errors); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, - gfdb_db_record->ignore_errors), - 0, LG_MSG_INSERT_FAILED, - "Failed inserting link in DB"); - goto out; - } - gfdb_db_record->islinkupdate = gfdb_db_record-> - link_consistency; - } + ret = gf_sql_update_link( + sql_conn, gfid_str, pargfid_str, gfdb_db_record->file_name, + old_pargfid_str, gfdb_db_record->old_file_name, + gfdb_db_record->link_consistency, + gfdb_db_record->ignore_errors); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, + _gfdb_log_level(GF_LOG_ERROR, + gfdb_db_record->ignore_errors), + 0, LG_MSG_UPDATE_FAILED, "Failed updating link"); + goto out; } - } - - /* update times only when said!*/ - if (gfdb_db_record->do_record_times) { - /*All fops update times read or write*/ - ret = gf_update_time (sql_conn, gfid_str, modtime, - gfdb_db_record->do_record_counters, - its_wind, - isreadfop (gfdb_db_record->gfdb_fop_type), - gfdb_db_record->ignore_errors); + gfdb_db_record->islinkupdate = gfdb_db_record->link_consistency; + } + /*link*/ + else { + ret = gf_sql_insert_link(sql_conn, gfid_str, pargfid_str, + gfdb_db_record->file_name, + gfdb_db_record->link_consistency, + gfdb_db_record->ignore_errors); if (ret) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, - gfdb_db_record->ignore_errors), 0, - LG_MSG_UPDATE_FAILED, "Failed update wind time" - " in DB"); - goto out; + gf_msg(GFDB_STR_SQLITE3, + _gfdb_log_level(GF_LOG_ERROR, + gfdb_db_record->ignore_errors), + 0, LG_MSG_INSERT_FAILED, + "Failed inserting link in DB"); + goto out; } + gfdb_db_record->islinkupdate = gfdb_db_record->link_consistency; + } + } + } + + /* update times only when said!*/ + if (gfdb_db_record->do_record_times) { + /*All fops update times read or write*/ + ret = gf_update_time(sql_conn, gfid_str, modtime, + gfdb_db_record->do_record_counters, its_wind, + isreadfop(gfdb_db_record->gfdb_fop_type), + gfdb_db_record->ignore_errors); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, + _gfdb_log_level(GF_LOG_ERROR, gfdb_db_record->ignore_errors), + 0, LG_MSG_UPDATE_FAILED, + "Failed update wind time" + " in DB"); + goto out; } + } - ret = 0; + ret = 0; out: - GF_FREE (gfid_str); - GF_FREE (pargfid_str); - GF_FREE (old_pargfid_str); - return ret; + GF_FREE(gfid_str); + GF_FREE(pargfid_str); + GF_FREE(old_pargfid_str); + return ret; } - - - int -gf_sql_insert_unwind (gf_sql_connection_t *sql_conn, - gfdb_db_record_t *gfdb_db_record) +gf_sql_insert_unwind(gf_sql_connection_t *sql_conn, + gfdb_db_record_t *gfdb_db_record) { - - int ret = -1; - gfdb_time_t *modtime = NULL; - gf_boolean_t its_wind = _gf_true;/*remains true for this function*/ - char *gfid_str = NULL; - char *pargfid_str = NULL; - - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfdb_db_record, out); - - gfid_str = gf_strdup (uuid_utoa(gfdb_db_record->gfid)); - if (!gfid_str) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_CREATE_FAILED, "Creating gfid string failed."); - goto out; + int ret = -1; + gfdb_time_t *modtime = NULL; + gf_boolean_t its_wind = _gf_true; /*remains true for this function*/ + char *gfid_str = NULL; + char *pargfid_str = NULL; + + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out); + + gfid_str = gf_strdup(uuid_utoa(gfdb_db_record->gfid)); + if (!gfid_str) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED, + "Creating gfid string failed."); + goto out; + } + + /*Only update if recording unwind is set*/ + if (gfdb_db_record->do_record_times && + gfdb_db_record->do_record_uwind_time) { + modtime = &gfdb_db_record->gfdb_unwind_change_time; + ret = gf_update_time(sql_conn, gfid_str, modtime, + gfdb_db_record->do_record_counters, (!its_wind), + isreadfop(gfdb_db_record->gfdb_fop_type), + gfdb_db_record->ignore_errors); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, + _gfdb_log_level(GF_LOG_ERROR, gfdb_db_record->ignore_errors), + 0, LG_MSG_UPDATE_FAILED, + "Failed update unwind " + "time in DB"); + goto out; } + } - /*Only update if recording unwind is set*/ - if (gfdb_db_record->do_record_times && - gfdb_db_record->do_record_uwind_time) { - modtime = &gfdb_db_record->gfdb_unwind_change_time; - ret = gf_update_time (sql_conn, gfid_str, modtime, - gfdb_db_record->do_record_counters, - (!its_wind), - isreadfop (gfdb_db_record->gfdb_fop_type), - gfdb_db_record->ignore_errors); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, - gfdb_db_record->ignore_errors), - 0, LG_MSG_UPDATE_FAILED, "Failed update unwind " - "time in DB"); - goto out; - } + /*For link creation and changes we use link updated*/ + if (gfdb_db_record->islinkupdate && + isdentryfop(gfdb_db_record->gfdb_fop_type)) { + pargfid_str = gf_strdup(uuid_utoa(gfdb_db_record->pargfid)); + if (!pargfid_str) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED, + "Creating pargfid_str string failed."); + goto out; } - /*For link creation and changes we use link updated*/ - if (gfdb_db_record->islinkupdate && - isdentryfop(gfdb_db_record->gfdb_fop_type)) { - - pargfid_str = gf_strdup(uuid_utoa(gfdb_db_record->pargfid)); - if (!pargfid_str) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, - 0, LG_MSG_CREATE_FAILED, - "Creating pargfid_str string failed."); - goto out; - } - - ret = gf_sql_update_link_flags (sql_conn, gfid_str, pargfid_str, - gfdb_db_record->file_name, 0, _gf_true, - gfdb_db_record->ignore_errors); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, - gfdb_db_record->ignore_errors), - 0, LG_MSG_UPDATE_FAILED, - "Failed updating link flags in unwind"); - goto out; - } + ret = gf_sql_update_link_flags(sql_conn, gfid_str, pargfid_str, + gfdb_db_record->file_name, 0, _gf_true, + gfdb_db_record->ignore_errors); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, + _gfdb_log_level(GF_LOG_ERROR, gfdb_db_record->ignore_errors), + 0, LG_MSG_UPDATE_FAILED, + "Failed updating link flags in unwind"); + goto out; } + } - ret = 0; + ret = 0; out: - GF_FREE (gfid_str); - GF_FREE (pargfid_str); - return ret; + GF_FREE(gfid_str); + GF_FREE(pargfid_str); + return ret; } - int -gf_sql_update_delete_wind (gf_sql_connection_t *sql_conn, - gfdb_db_record_t *gfdb_db_record) +gf_sql_update_delete_wind(gf_sql_connection_t *sql_conn, + gfdb_db_record_t *gfdb_db_record) { - int ret = -1; - char *gfid_str = NULL; - char *pargfid_str = NULL; - - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfdb_db_record, out); - - gfid_str = gf_strdup (uuid_utoa(gfdb_db_record->gfid)); - if (!gfid_str) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED, - "Creating gfid string failed."); - goto out; - } - - pargfid_str = gf_strdup (uuid_utoa(gfdb_db_record->pargfid)); - if (!pargfid_str) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, - 0, LG_MSG_CREATE_FAILED, "Creating pargfid_str " - "string failed."); - goto out; - } - - if (gfdb_db_record->link_consistency) { - ret = gf_sql_update_link_flags (sql_conn, gfid_str, pargfid_str, - gfdb_db_record->file_name, 1, - _gf_false, - gfdb_db_record->ignore_errors); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, - gfdb_db_record->ignore_errors), - 0, LG_MSG_UPDATE_FAILED, - "Failed updating link flags in wind"); - goto out; - } + int ret = -1; + char *gfid_str = NULL; + char *pargfid_str = NULL; + + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out); + + gfid_str = gf_strdup(uuid_utoa(gfdb_db_record->gfid)); + if (!gfid_str) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED, + "Creating gfid string failed."); + goto out; + } + + pargfid_str = gf_strdup(uuid_utoa(gfdb_db_record->pargfid)); + if (!pargfid_str) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED, + "Creating pargfid_str " + "string failed."); + goto out; + } + + if (gfdb_db_record->link_consistency) { + ret = gf_sql_update_link_flags(sql_conn, gfid_str, pargfid_str, + gfdb_db_record->file_name, 1, _gf_false, + gfdb_db_record->ignore_errors); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, + _gfdb_log_level(GF_LOG_ERROR, gfdb_db_record->ignore_errors), + 0, LG_MSG_UPDATE_FAILED, + "Failed updating link flags in wind"); + goto out; } + } - ret = 0; + ret = 0; out: - GF_FREE (gfid_str); - GF_FREE (pargfid_str); - return ret; + GF_FREE(gfid_str); + GF_FREE(pargfid_str); + return ret; } int -gf_sql_delete_unwind (gf_sql_connection_t *sql_conn, - gfdb_db_record_t *gfdb_db_record) +gf_sql_delete_unwind(gf_sql_connection_t *sql_conn, + gfdb_db_record_t *gfdb_db_record) { - int ret = -1; - char *gfid_str = NULL; - char *pargfid_str = NULL; - gfdb_time_t *modtime = NULL; - - CHECK_SQL_CONN (sql_conn, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfdb_db_record, out); - - gfid_str = gf_strdup (uuid_utoa(gfdb_db_record->gfid)); - if (!gfid_str) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED, - "Creating gfid string failed."); - goto out; + int ret = -1; + char *gfid_str = NULL; + char *pargfid_str = NULL; + gfdb_time_t *modtime = NULL; + + CHECK_SQL_CONN(sql_conn, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out); + + gfid_str = gf_strdup(uuid_utoa(gfdb_db_record->gfid)); + if (!gfid_str) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED, + "Creating gfid string failed."); + goto out; + } + + /*Nuke all the entries for this GFID from DB*/ + if (gfdb_db_record->gfdb_fop_path == GFDB_FOP_UNDEL_ALL) { + gf_sql_delete_all(sql_conn, gfid_str, gfdb_db_record->ignore_errors); + } + /*Remove link entries only*/ + else if (gfdb_db_record->gfdb_fop_path == GFDB_FOP_UNDEL) { + pargfid_str = gf_strdup(uuid_utoa(gfdb_db_record->pargfid)); + if (!pargfid_str) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_CREATE_FAILED, + "Creating pargfid_str " + "string failed."); + goto out; } - /*Nuke all the entries for this GFID from DB*/ - if (gfdb_db_record->gfdb_fop_path == GFDB_FOP_UNDEL_ALL) { - gf_sql_delete_all (sql_conn, gfid_str, - gfdb_db_record->ignore_errors); + /* Special performance case: + * Updating wind time in unwind for delete. This is done here + * as in the wind path we will not know whether its the last + * link or not. For a last link there is not use to update any + * wind or unwind time!*/ + if (gfdb_db_record->do_record_times) { + /*Update the wind write times*/ + modtime = &gfdb_db_record->gfdb_wind_change_time; + ret = gf_update_time(sql_conn, gfid_str, modtime, + gfdb_db_record->do_record_counters, _gf_true, + isreadfop(gfdb_db_record->gfdb_fop_type), + gfdb_db_record->ignore_errors); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, + _gfdb_log_level(GF_LOG_ERROR, + gfdb_db_record->ignore_errors), + 0, LG_MSG_UPDATE_FAILED, + "Failed update wind time in DB"); + goto out; + } } - /*Remove link entries only*/ - else if (gfdb_db_record->gfdb_fop_path == GFDB_FOP_UNDEL) { - - pargfid_str = gf_strdup(uuid_utoa(gfdb_db_record->pargfid)); - if (!pargfid_str) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, - 0, LG_MSG_CREATE_FAILED, "Creating pargfid_str " - "string failed."); - goto out; - } - - /* Special performance case: - * Updating wind time in unwind for delete. This is done here - * as in the wind path we will not know whether its the last - * link or not. For a last link there is not use to update any - * wind or unwind time!*/ - if (gfdb_db_record->do_record_times) { - /*Update the wind write times*/ - modtime = &gfdb_db_record->gfdb_wind_change_time; - ret = gf_update_time (sql_conn, gfid_str, modtime, - gfdb_db_record->do_record_counters, - _gf_true, - isreadfop (gfdb_db_record->gfdb_fop_type), - gfdb_db_record->ignore_errors); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, - gfdb_db_record->ignore_errors), - 0, LG_MSG_UPDATE_FAILED, - "Failed update wind time in DB"); - goto out; - } - } - modtime = &gfdb_db_record->gfdb_unwind_change_time; + modtime = &gfdb_db_record->gfdb_unwind_change_time; - ret = gf_sql_delete_link(sql_conn, gfid_str, pargfid_str, - gfdb_db_record->file_name, - gfdb_db_record->ignore_errors); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_DELETE_FAILED, "Failed deleting link"); - goto out; - } + ret = gf_sql_delete_link(sql_conn, gfid_str, pargfid_str, + gfdb_db_record->file_name, + gfdb_db_record->ignore_errors); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_DELETE_FAILED, + "Failed deleting link"); + goto out; + } - if (gfdb_db_record->do_record_times && - gfdb_db_record->do_record_uwind_time) { - ret = gf_update_time (sql_conn, gfid_str, modtime, - gfdb_db_record->do_record_counters, - _gf_false, - isreadfop(gfdb_db_record->gfdb_fop_type), - gfdb_db_record->ignore_errors); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, - _gfdb_log_level (GF_LOG_ERROR, - gfdb_db_record->ignore_errors), - 0, LG_MSG_UPDATE_FAILED, - "Failed update unwind time in DB"); - goto out; - } - } - } else { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, - 0, LG_MSG_INVALID_UPLINK, "Invalid unlink option"); + if (gfdb_db_record->do_record_times && + gfdb_db_record->do_record_uwind_time) { + ret = gf_update_time(sql_conn, gfid_str, modtime, + gfdb_db_record->do_record_counters, _gf_false, + isreadfop(gfdb_db_record->gfdb_fop_type), + gfdb_db_record->ignore_errors); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, + _gfdb_log_level(GF_LOG_ERROR, + gfdb_db_record->ignore_errors), + 0, LG_MSG_UPDATE_FAILED, + "Failed update unwind time in DB"); goto out; + } } - ret = 0; + } else { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_INVALID_UPLINK, + "Invalid unlink option"); + goto out; + } + ret = 0; out: - GF_FREE (gfid_str); - GF_FREE (pargfid_str); - return ret; + GF_FREE(gfid_str); + GF_FREE(pargfid_str); + return ret; } /****************************************************************************** @@ -1132,240 +1043,218 @@ out: * * ****************************************************************************/ int -gf_sql_query_function (sqlite3_stmt *prep_stmt, - gf_query_callback_t query_callback, - void *_query_cbk_args) +gf_sql_query_function(sqlite3_stmt *prep_stmt, + gf_query_callback_t query_callback, void *_query_cbk_args) { - int ret = -1; - gfdb_query_record_t *query_record = NULL; - char *text_column = NULL; - sqlite3 *db_conn = NULL; - uuid_t prev_gfid = {0}; - uuid_t curr_gfid = {0}; - uuid_t pgfid = {0}; - char *base_name = NULL; - gf_boolean_t is_first_record = _gf_true; - gf_boolean_t is_query_empty = _gf_true; - - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, prep_stmt, out); - GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, query_callback, out); - - db_conn = sqlite3_db_handle(prep_stmt); - - /* - * Loop to access queried rows - * Each db record will have 3 columns - * GFID, PGFID, FILE_NAME - * - * For file with multiple hard links we will get multiple query rows - * with the same GFID, but different PGID and FILE_NAME Combination - * For Example if a file with - * GFID = 00000000-0000-0000-0000-000000000006 - * has 3 hardlinks file1, file2 and file3 in 3 different folder - * with GFID's - * 00000000-0000-0000-0000-0000EFC00001, - * 00000000-0000-0000-0000-00000ABC0001 and - * 00000000-0000-0000-0000-00000ABC00CD - * Then there will be 3 records - * GFID : 00000000-0000-0000-0000-000000000006 - * PGFID : 00000000-0000-0000-0000-0000EFC00001 - * FILE_NAME : file1 - * - * GFID : 00000000-0000-0000-0000-000000000006 - * PGFID : 00000000-0000-0000-0000-00000ABC0001 - * FILE_NAME : file2 - * - * GFID : 00000000-0000-0000-0000-000000000006 - * PGFID : 00000000-0000-0000-0000-00000ABC00CD - * FILE_NAME : file3 - * - * This is retrieved and added to a single query_record - * - * query_record->gfid = 00000000-0000-0000-0000-000000000006 - * ->link_info = {00000000-0000-0000-0000-0000EFC00001, - * "file1"} - * | - * V - * link_info = {00000000-0000-0000-0000-00000ABC0001, - * "file2"} - * | - * V - * link_info = {00000000-0000-0000-0000-00000ABC0001, - * "file3", - * list} - * - * This query record is sent to the registered query_callback() - * - * */ - while ((ret = sqlite3_step (prep_stmt)) == SQLITE_ROW) { - - if (sqlite3_column_count(prep_stmt) > 0) { - - is_query_empty = _gf_false; - - /*Retrieving GFID - column index is 0*/ - text_column = (char *)sqlite3_column_text - (prep_stmt, 0); - if (!text_column) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_GET_ID_FAILED, "Failed to" - "retrieve GFID"); - goto out; - } - ret = gf_uuid_parse (text_column, curr_gfid); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PARSE_FAILED, "Failed to parse " - "GFID"); - goto out; - } - - /* - * if the previous record was not of the current gfid - * call the call_back function and send the - * query record, which will have all the link_info - * objects associated with this gfid - * - * */ - if (gf_uuid_compare (curr_gfid, prev_gfid) != 0) { - - /* If this is not the first record */ - if (!is_first_record) { - /*Call the call_back function provided*/ - ret = query_callback (query_record, - _query_cbk_args); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, - GF_LOG_ERROR, 0, - LG_MSG_QUERY_CALL_BACK_FAILED, - "Query call back " - "failed"); - goto out; - } - - } - - /*Clear the query record*/ - gfdb_query_record_free (query_record); - query_record = NULL; - query_record = gfdb_query_record_new (); - if (!query_record) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, - 0, LG_MSG_CREATE_FAILED, - "Failed to create " - "query_record"); - goto out; - } - - gf_uuid_copy(query_record->gfid, - curr_gfid); - gf_uuid_copy(prev_gfid, curr_gfid); - - } - - /* Get PGFID */ - text_column = (char *)sqlite3_column_text - (prep_stmt, 1); - if (!text_column) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_GET_ID_FAILED, "Failed to" - " retrieve GF_ID"); - goto out; - } - ret = gf_uuid_parse (text_column, pgfid); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_PARSE_FAILED, "Failed to parse " - "GF_ID"); - goto out; - } - - /* Get Base name */ - text_column = (char *)sqlite3_column_text - (prep_stmt, 2); - if (!text_column) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_GET_ID_FAILED, "Failed to" - " retrieve GF_ID"); - goto out; - } - base_name = text_column; - - - /* Add link info to the list */ - ret = gfdb_add_link_to_query_record (query_record, - pgfid, base_name); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_GET_ID_FAILED, "Failed to" - " add link info to query record"); - goto out; - } - - is_first_record = _gf_false; + int ret = -1; + gfdb_query_record_t *query_record = NULL; + char *text_column = NULL; + sqlite3 *db_conn = NULL; + uuid_t prev_gfid = {0}; + uuid_t curr_gfid = {0}; + uuid_t pgfid = {0}; + char *base_name = NULL; + gf_boolean_t is_first_record = _gf_true; + gf_boolean_t is_query_empty = _gf_true; + + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, prep_stmt, out); + GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, query_callback, out); + + db_conn = sqlite3_db_handle(prep_stmt); + + /* + * Loop to access queried rows + * Each db record will have 3 columns + * GFID, PGFID, FILE_NAME + * + * For file with multiple hard links we will get multiple query rows + * with the same GFID, but different PGID and FILE_NAME Combination + * For Example if a file with + * GFID = 00000000-0000-0000-0000-000000000006 + * has 3 hardlinks file1, file2 and file3 in 3 different folder + * with GFID's + * 00000000-0000-0000-0000-0000EFC00001, + * 00000000-0000-0000-0000-00000ABC0001 and + * 00000000-0000-0000-0000-00000ABC00CD + * Then there will be 3 records + * GFID : 00000000-0000-0000-0000-000000000006 + * PGFID : 00000000-0000-0000-0000-0000EFC00001 + * FILE_NAME : file1 + * + * GFID : 00000000-0000-0000-0000-000000000006 + * PGFID : 00000000-0000-0000-0000-00000ABC0001 + * FILE_NAME : file2 + * + * GFID : 00000000-0000-0000-0000-000000000006 + * PGFID : 00000000-0000-0000-0000-00000ABC00CD + * FILE_NAME : file3 + * + * This is retrieved and added to a single query_record + * + * query_record->gfid = 00000000-0000-0000-0000-000000000006 + * ->link_info = {00000000-0000-0000-0000-0000EFC00001, + * "file1"} + * | + * V + * link_info = {00000000-0000-0000-0000-00000ABC0001, + * "file2"} + * | + * V + * link_info = {00000000-0000-0000-0000-00000ABC0001, + * "file3", + * list} + * + * This query record is sent to the registered query_callback() + * + * */ + while ((ret = sqlite3_step(prep_stmt)) == SQLITE_ROW) { + if (sqlite3_column_count(prep_stmt) > 0) { + is_query_empty = _gf_false; + + /*Retrieving GFID - column index is 0*/ + text_column = (char *)sqlite3_column_text(prep_stmt, 0); + if (!text_column) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_GET_ID_FAILED, + "Failed to" + "retrieve GFID"); + goto out; + } + ret = gf_uuid_parse(text_column, curr_gfid); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PARSE_FAILED, + "Failed to parse " + "GFID"); + goto out; + } + + /* + * if the previous record was not of the current gfid + * call the call_back function and send the + * query record, which will have all the link_info + * objects associated with this gfid + * + * */ + if (gf_uuid_compare(curr_gfid, prev_gfid) != 0) { + /* If this is not the first record */ + if (!is_first_record) { + /*Call the call_back function provided*/ + ret = query_callback(query_record, _query_cbk_args); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, + LG_MSG_QUERY_CALL_BACK_FAILED, + "Query call back " + "failed"); + goto out; + } + } + /*Clear the query record*/ + gfdb_query_record_free(query_record); + query_record = NULL; + query_record = gfdb_query_record_new(); + if (!query_record) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, + LG_MSG_CREATE_FAILED, + "Failed to create " + "query_record"); + goto out; } - } + gf_uuid_copy(query_record->gfid, curr_gfid); + gf_uuid_copy(prev_gfid, curr_gfid); + } - if (ret != SQLITE_DONE) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_GET_RECORD_FAILED, "Failed to retrieve records " - "from db : %s", sqlite3_errmsg (db_conn)); - ret = -1; + /* Get PGFID */ + text_column = (char *)sqlite3_column_text(prep_stmt, 1); + if (!text_column) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_GET_ID_FAILED, + "Failed to" + " retrieve GF_ID"); goto out; - } - + } + ret = gf_uuid_parse(text_column, pgfid); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_PARSE_FAILED, + "Failed to parse " + "GF_ID"); + goto out; + } + + /* Get Base name */ + text_column = (char *)sqlite3_column_text(prep_stmt, 2); + if (!text_column) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_GET_ID_FAILED, + "Failed to" + " retrieve GF_ID"); + goto out; + } + base_name = text_column; + + /* Add link info to the list */ + ret = gfdb_add_link_to_query_record(query_record, pgfid, base_name); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_GET_ID_FAILED, + "Failed to" + " add link info to query record"); + goto out; + } - if (!is_query_empty) { - /* - * Call the call_back function for the last record from the - * Database - * */ - ret = query_callback (query_record, _query_cbk_args); - if (ret) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, - LG_MSG_QUERY_CALL_BACK_FAILED, - "Query call back failed"); - goto out; - } + is_first_record = _gf_false; } + } + + if (ret != SQLITE_DONE) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_GET_RECORD_FAILED, + "Failed to retrieve records " + "from db : %s", + sqlite3_errmsg(db_conn)); + ret = -1; + goto out; + } + + if (!is_query_empty) { + /* + * Call the call_back function for the last record from the + * Database + * */ + ret = query_callback(query_record, _query_cbk_args); + if (ret) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, + LG_MSG_QUERY_CALL_BACK_FAILED, "Query call back failed"); + goto out; + } + } - ret = 0; + ret = 0; out: - gfdb_query_record_free (query_record); - query_record = NULL; - return ret; + gfdb_query_record_free(query_record); + query_record = NULL; + return ret; } - - int -gf_sql_clear_counters (gf_sql_connection_t *sql_conn) +gf_sql_clear_counters(gf_sql_connection_t *sql_conn) { - int ret = -1; - char *sql_strerror = NULL; - char *query_str = NULL; - - CHECK_SQL_CONN (sql_conn, out); - - query_str = "UPDATE " - GF_FILE_TABLE - " SET " GF_COL_READ_FREQ_CNTR " = 0 , " - GF_COL_WRITE_FREQ_CNTR " = 0 ;"; - - ret = sqlite3_exec (sql_conn->sqlite3_db_conn, query_str, NULL, NULL, - &sql_strerror); - if (ret != SQLITE_OK) { - gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED, - "Failed to execute: %s : %s", - query_str, sql_strerror); - sqlite3_free (sql_strerror); - ret = -1; - goto out; - } - - ret = 0; + int ret = -1; + char *sql_strerror = NULL; + char *query_str = NULL; + + CHECK_SQL_CONN(sql_conn, out); + + query_str = "UPDATE " GF_FILE_TABLE " SET " GF_COL_READ_FREQ_CNTR + " = 0 , " GF_COL_WRITE_FREQ_CNTR " = 0 ;"; + + ret = sqlite3_exec(sql_conn->sqlite3_db_conn, query_str, NULL, NULL, + &sql_strerror); + if (ret != SQLITE_OK) { + gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED, + "Failed to execute: %s : %s", query_str, sql_strerror); + sqlite3_free(sql_strerror); + ret = -1; + goto out; + } + + ret = 0; out: - return ret; + return ret; } |