Land part 2 of clang-format changes

Change-Id: Ia84cc24c8924e6d22d02ac15f611c10e26db99b4
Signed-off-by: Nigel Babu <nigelb@redhat.com>

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;
 }