libglusterfs: remove unused gfdb specific files from repo

Updates: bz#1193929
Change-Id: Idb98394c51917e9b132aeb32facccd112effe672
Signed-off-by: Amar Tumballi <amarts@gmail.com>

16 files changed, 1 insertions, 5647 deletions

diff --git a/.gitignore b/.gitignore
index 3508b50c55b..7437fc389d1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -86,7 +86,6 @@ glusterfsd/src/glusterfsd
 glusterfsd/src/gf_attach
 heal/src/glfsheal
 libgfchangelog.pc
-libgfdb.pc
 libglusterfs/src/graph.lex.c
 libglusterfs/src/y.tab.c
 libglusterfs/src/y.tab.h
diff --git a/libgfdb.pc.in b/libgfdb.pc.in
deleted file mode 100644
index 463e8becd3a..00000000000
--- a/libgfdb.pc.in
+++ /dev/null
@@ -1,12 +0,0 @@
-prefix=@prefix@
-exec_prefix=@exec_prefix@
-libdir=@libdir@
-includedir=@includedir@
-
-
-Name: libgfdb
-Description: GlusterFS Database Library
-Version: @LIBGFDB_VERSION@
-Libs: -L${libdir} -lgfchangedb -lglusterfs
-Cflags: -I${includedir}
-Requires: sqlite3 @PKGCONFIG_UUID@
diff --git a/libglusterfs/src/Makefile.am b/libglusterfs/src/Makefile.am
index df4c4678a6e..cd9d28e3cdc 100644
--- a/libglusterfs/src/Makefile.am
+++ b/libglusterfs/src/Makefile.am
@@ -78,8 +78,7 @@ noinst_HEADERS = unittest/unittest.h \
 	$(CONTRIBDIR)/userspace-rcu/wfcqueue.h \
 	$(CONTRIBDIR)/userspace-rcu/wfstack.h \
 	$(CONTRIBDIR)/userspace-rcu/static-wfcqueue.h \
-	$(CONTRIBDIR)/userspace-rcu/static-wfstack.h \
-	tier-ctr-interface.h
+	$(CONTRIBDIR)/userspace-rcu/static-wfstack.h
 
 eventtypes.h: $(top_srcdir)/events/eventskeygen.py
 	$(PYTHON) $(top_srcdir)/events/eventskeygen.py C_HEADER
diff --git a/libglusterfs/src/gfdb/Makefile.am b/libglusterfs/src/gfdb/Makefile.am
deleted file mode 100644
index 3931e694c24..00000000000
--- a/libglusterfs/src/gfdb/Makefile.am
+++ /dev/null
@@ -1,37 +0,0 @@
-libgfdb_la_CFLAGS = -Wall $(GF_CFLAGS) $(GF_DARWIN_LIBGLUSTERFS_CFLAGS) \
-	$(SQLITE_CFLAGS) -DDATADIR=\"$(localstatedir)\"
-
-libgfdb_la_CPPFLAGS = $(GF_CPPFLAGS) -D__USE_FILE_OFFSET64 -fpic \
-	-I$(top_srcdir)/libglusterfs/src \
-	-I$(top_srcdir)/rpc/xdr/src \
-	-I$(top_builddir)/rpc/xdr/src \
-	-DDATADIR=\"$(localstatedir)\"
-
-libgfdb_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \
-	$(SQLITE_LIBS) $(UUID_LIBS)
-
-libgfdb_la_LDFLAGS = $(GF_LDFLAGS) -version-info $(LIBGLUSTERFS_LT_VERSION)
-
-libgfdbdir = $(includedir)/glusterfs/gfdb
-
-if BUILD_GFDB
- lib_LTLIBRARIES = libgfdb.la
-endif
-
-CONTRIB_BUILDDIR = $(top_builddir)/contrib
-
-libgfdb_la_SOURCES = gfdb_data_store.c gfdb_data_store_helper.c \
-	gfdb_sqlite3_helper.c gfdb_sqlite3.c
-
-noinst_HEADERS =  gfdb_data_store.h gfdb_data_store_types.h \
-	gfdb_sqlite3_helper.h gfdb_sqlite3.h gfdb_mem-types.h \
-	gfdb_data_store_helper.h
-
-libgfdb_HEADERS = gfdb_data_store.h gfdb_data_store_types.h \
-	gfdb_data_store_helper.h gfdb_sqlite3.h gfdb_mem-types.h \
-	gfdb_sqlite3_helper.h
-
-CLEANFILES =
-
-$(top_builddir)/libglusterfs/src/libglusterfs.la:
-	$(MAKE) -C $(top_builddir)/libglusterfs/src/ all
diff --git a/libglusterfs/src/gfdb/gfdb_data_store.c b/libglusterfs/src/gfdb/gfdb_data_store.c
deleted file mode 100644
index 02894cf7785..00000000000
--- a/libglusterfs/src/gfdb/gfdb_data_store.c
+++ /dev/null
@@ -1,802 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-
-#include "gfdb_sqlite3.h"
-#include "gfdb_data_store.h"
-#include "glusterfs/list.h"
-#include "glusterfs/libglusterfs-messages.h"
-
-/******************************************************************************
- *
- *                     Database Connection utils/internals
- *
- * ****************************************************************************/
-
-/* GFDB Connection Node:
- * ~~~~~~~~~~~~~~~~~~~~
- * Represents the connection to the database while using libgfdb
- * The connection node is not thread safe as far as fini_db is concerned.
- * You can use a single connection node
- * to do multithreaded db operations like insert/delete/find of records.
- * But you need to wait for all the operating threads to complete i.e
- * pthread_join() and then do fini_db() to kill the connection node.
- * gfdb_conn_node_t is an opaque structure.
- * */
-struct gfdb_conn_node_t {
-    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
- *
- * */
-static gfdb_conn_node_t *db_conn_list;
-
-/*
- * db_conn_mutex is the mutex for 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)
-
-/* 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)
-
-/*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)
-
-/*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)
-
-/*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;
-out:
-    return ret;
-}
-
-/*Internal Function:
- * Delete connection node from the list*/
-static int
-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;
-    }
-
-    /*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;
-out:
-    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)
-{
-    int ret = -1;
-
-    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) {
-        case GFDB_SQLITE3:
-            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;
-        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;
-}
-
-/******************************************************************************
- *
- *                      LIBGFDB API Functions
- *
- * ****************************************************************************/
-
-/*Libgfdb API Function: Used to initialize a db connection
- *                      (Constructor function for db connection object)
- * Arguments:
- *      args         :  Dictionary containing database specific parameters
- *                      eg: For sqlite3, pagesize, cachesize, db name, db path
-                        etc
- *      gfdb_db_type :  Type of data base used i.e sqlite or hyperdex etc
- * 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)
-{
-    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;
-
-    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*/
-_conn_failed:
-    GF_FREE(_conn_node);
-    /*if allocation failed*/
-alloc_failed:
-    return NULL;
-    /*****Error Handling********/
-}
-
-/*Libgfdb API Function: Used to terminate/de-initialize db connection
- *                      (Destructor function for db connection object)
- * Arguments:
- *      _conn_node  :  GFDB Connection node
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-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");
-    }
-empty:
-    ret = 0;
-out:
-    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
- *                      gfdb_fop_path to GFDB_FOP_UNDEL to delete the
- *                      link of inode from GF_FLINK_TB and
- *                      GFDB_FOP_UNDEL_ALL to delete all the records from
- *                      GF_FLINK_TB and GF_FILE_TB.
- *                      TODO: Should separate this function into the
- *                      delete_record function
- *                      Refer CTR Xlator features/changetimerecorder for usage
- * Arguments:
- *      _conn_node     :  GFDB Connection node
- *      gfdb_db_record :  Record to be inserted/updated
- * 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)
-{
-    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->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;
-}
-
-/*Libgfdb API Function: Used to delete record from the database
- *                      NOTE: In the current gfdb_sqlite3 plugin
- *                      implementation this function is dummy.
- *                      Use the insert_record function.
- *                      Refer CTR Xlator features/changetimerecorder for usage
- * Arguments:
- *      _conn_node     :  GFDB Connection node
- *      gfdb_db_record :  Record to be deleted
- * 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)
-{
-    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->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;
-}
-
-/*Libgfdb API Function: Compact the database.
- *
- * Arguments:
- *      _conn_node                      :  GFDB Connection node
- *      _compact_active                 :  Is compaction currently on?
- *      _compact_mode_switched          :  Was the compaction switch flipped?
- * 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)
-{
-    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->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;
-}
-
-/*Libgfdb API Function: Query all the records from the database
- * Arguments:
- *      _conn_node      : GFDB Connection node
- *      query_callback  : Call back function that will be called
- *                        for every record found
- *      _query_cbk_args : Custom argument passed for the call back
- *                        function query_callback
- *      query_limit     : number to limit number of rows returned by the query
- * 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)
-{
-    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");
-        }
-    }
-
-    return ret;
-}
-
-/*Libgfdb API Function: Query records/files that have not changed/accessed
- *                      from a time in past to current time
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _query_cbk_args         : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are not
- *                                changed/accessed
- * 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)
-{
-    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) {
-        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;
-}
-
-/*Libgfdb API Function: Query records/files that have changed/accessed from a
- *                      time in past to current time
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _query_cbk_args         : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are
- *                                changed/accessed
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-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)
-{
-    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_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;
-}
-
-/*Libgfdb API Function: Query records/files that have not changed/accessed
- *                      from a time in past to current time, with
- *                      a desired frequency
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _query_cbk_args         : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are not
- *                                changed/accessed
- *      write_freq_thresold     : Desired Write Frequency lower limit
- *      read_freq_thresold      : Desired Read Frequency lower limit
- *      _clear_counters         : If true, Clears all the frequency counters of
- *                                all files.
- * Returns : if successful return 0 or
- *          -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)
-{
-    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_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;
-}
-
-/*Libgfdb API Function: Query records/files that have changed/accessed from a
- *                      time in past to current time, with
- *                      a desired frequency
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _query_cbk_args         : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are
- *                                changed/accessed
- *      write_freq_thresold     : Desired Write Frequency lower limit
- *      read_freq_thresold      : Desired Read Frequency lower limit
- *      _clear_counters         : If true, Clears all the frequency counters of
- *                                all files.
- * Returns : if successful return 0 or
- *          -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)
-{
-    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_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;
-}
-
-/*Libgfdb API Function: Clear the heat for all the files
- *
- *  Arguments:
- *    conn_node              : GFDB Connection node
- *
- * Returns : if successful return 0 or
- *           -ve value in case of failure
- **/
-
-int
-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");
-        }
-    }
-
-    return ret;
-}
-
-/* Libgfdb API Function: Function to extract version of the db
- * Input:
- * gfdb_conn_node_t *conn_node        : GFDB Connection node
- * char **version  : the version is extracted as a string and will be stored in
- *                   this variable. The freeing of the memory should be done by
- *                   the caller.
- * Return:
- *      On success return the length of the version string that is
- *      extracted.
- *      On failure return -1
- * */
-int
-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");
-        }
-    }
-
-    return ret;
-}
-
-int
-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");
-        }
-    }
-
-    return ret;
-}
-
-int
-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");
-        }
-    }
-
-    return ret;
-}
-
-static const char *
-get_db_path_key()
-{
-    return GFDB_SQL_PARAM_DBPATH;
-}
-
-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;
-}
diff --git a/libglusterfs/src/gfdb/gfdb_data_store.h b/libglusterfs/src/gfdb/gfdb_data_store.h
deleted file mode 100644
index 55b2fb1bc55..00000000000
--- a/libglusterfs/src/gfdb/gfdb_data_store.h
+++ /dev/null
@@ -1,331 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-#ifndef __GFDB_DATA_STORE_H
-#define __GFDB_DATA_STORE_H
-
-#include "glusterfs/glusterfs.h"
-#include "glusterfs/xlator.h"
-#include "glusterfs/logging.h"
-#include "glusterfs/common-utils.h"
-#include <time.h>
-#include <sys/time.h>
-
-#include "gfdb_data_store_types.h"
-
-/* GFDB Connection Node:
- * ~~~~~~~~~~~~~~~~~~~~
- * Represents the connection to the database while using libgfdb
- * The connection node is not thread safe as far as fini_db is concerned.
- * You can use a single connection node
- * to do multithreaded db operations like insert/delete/find of records.
- * But you need to wait for all the operating threads to complete i.e
- * pthread_join() and then do fini_db() to kill the connection node.
- * gfdb_conn_node_t is an opaque structure.
- * */
-typedef struct gfdb_conn_node_t gfdb_conn_node_t;
-
-/*Libgfdb API Function: Used to initialize db connection
- * Arguments:
- *      args         :  Dictionary containing database specific parameters
- *                      eg: For sqlite3, pagesize, cachesize, db name, db path
-                        etc
- *      gfdb_db_type :  Type of data base used i.e sqlite or hyperdex etc
- * Returns : if successful return the GFDB Connection Node to the caller or
- *          NULL value in case of failure*/
-gfdb_conn_node_t *
-init_db(dict_t *arg, gfdb_db_type_t db_type);
-
-typedef gfdb_conn_node_t *(*init_db_t)(dict_t *args,
-                                       gfdb_db_type_t gfdb_db_type);
-
-/*Libgfdb API Function: Used to terminate/de-initialize db connection
- *                      (Destructor function for db connection object)
- * Arguments:
- *      _conn_node  :  DB Connection Index of the DB Connection
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-fini_db(gfdb_conn_node_t *);
-
-typedef int (*fini_db_t)(gfdb_conn_node_t *_conn_node);
-
-/*Libgfdb API Function: Used to insert/updated records in the database
- *                      NOTE: In current gfdb_sqlite plugin we use that
- *                      same function to delete the record. Set the
- *                      gfdb_fop_path to GFDB_FOP_UNDEL to delete the
- *                      link of inode from GF_FLINK_TB and
- *                      GFDB_FOP_UNDEL_ALL to delete all the records from
- *                      GF_FLINK_TB and GF_FILE_TB.
- *                      TODO: Should separate this function into the
- *                      delete_record function
- *                      Refer CTR Xlator features/changetimerecorder for usage
- * Arguments:
- *      _conn_node     :  GFDB Connection node
- *      gfdb_db_record :  Record to be inserted/updated
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-insert_record(gfdb_conn_node_t *, gfdb_db_record_t *gfdb_db_record);
-
-/*Libgfdb API Function: Used to delete record from the database
- *                      NOTE: In the current gfdb_sqlite3 plugin
- *                      implementation this function is dummy.
- *                      Use the insert_record function.
- *                      Refer CTR Xlator features/changetimerecorder for usage
- * Arguments:
- *      _conn_node     :  GFDB Connection node
- *      gfdb_db_record :  Record to be deleted
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-delete_record(gfdb_conn_node_t *, gfdb_db_record_t *gfdb_db_record);
-
-/*Libgfdb API Function: Query all the records from the database
- * Arguments:
- *      _conn_node      : GFDB Connection node
- *      query_callback  : Call back function that will be called
- *                        for every record found
- *      _query_cbk_args : Custom argument passed for the call back
- *                        function query_callback
- *      query_limit     : 0 - umlimited,
- *                        any positive value - adds the LIMIT clause
- *                        to the SQL query
- *
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-find_all(gfdb_conn_node_t *, gf_query_callback_t query_callback,
-         void *_query_cbk_args, int query_limit);
-
-typedef int (*find_all_t)(gfdb_conn_node_t *,
-                          gf_query_callback_t query_callback,
-                          void *_query_cbk_args, int query_limit);
-
-/*Libgfdb API Function: Query records/files that have not changed/accessed
- *                      from a time in past to current time
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _query_cbk_args         : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are not
- *                                changed/accessed
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-find_unchanged_for_time(gfdb_conn_node_t *, gf_query_callback_t query_callback,
-                        void *_query_cbk_args, gfdb_time_t *for_time);
-
-typedef int (*find_unchanged_for_time_t)(gfdb_conn_node_t *_conn_node,
-                                         gf_query_callback_t query_callback,
-                                         void *_query_cbk_args,
-                                         gfdb_time_t *for_time);
-
-/*Libgfdb API Function: Query records/files that have changed/accessed from a
- *                      time in past to current time
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _query_cbk_args         : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are
- *                                changed/accessed
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-find_recently_changed_files(gfdb_conn_node_t *_conn,
-                            gf_query_callback_t query_callback,
-                            void *_query_cbk_args, gfdb_time_t *from_time);
-
-typedef int (*find_recently_changed_files_t)(gfdb_conn_node_t *_conn_node,
-                                             gf_query_callback_t query_callback,
-                                             void *_query_cbk_args,
-                                             gfdb_time_t *from_time);
-
-/*Libgfdb API Function: Query records/files that have not changed/accessed
- *                      from a time in past to current time, with
- *                      a desired frequency
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _query_cbk_args         : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are not
- *                                changed/accessed
- *      write_freq_thresold     : Desired Write Frequency lower limit
- *      read_freq_thresold      : Desired Read Frequency lower limit
- *      _clear_counters         : If true, Clears all the frequency counters of
- *                                all files.
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-find_unchanged_for_time_freq(gfdb_conn_node_t *_conn,
-                             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);
-
-typedef int (*find_unchanged_for_time_freq_t)(
-    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);
-
-/*Libgfdb API Function: Query records/files that have changed/accessed from a
- *                      time in past to current time, with
- *                      a desired frequency
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _query_cbk_args         : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are
- *                                changed/accessed
- *      write_freq_thresold     : Desired Write Frequency lower limit
- *      read_freq_thresold      : Desired Read Frequency lower limit
- *      _clear_counters         : If true, Clears all the frequency counters of
- *                                all files.
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-int
-find_recently_changed_files_freq(gfdb_conn_node_t *_conn,
-                                 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);
-
-typedef int (*find_recently_changed_files_freq_t)(
-    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);
-
-typedef const char *(*get_db_path_key_t)();
-
-/*Libgfdb API Function: Clear the heat for all the files
- *
- * Arguments:
- *      _conn_node              : GFDB Connection node
- *
- * Returns : if successful return 0 or
- *          -ve value in case of failure
- **/
-int
-clear_files_heat(gfdb_conn_node_t *_conn_node);
-
-typedef int (*clear_files_heat_t)(gfdb_conn_node_t *_conn_node);
-
-/* Libgfdb API Function: Function to extract version of the db
- *  Arguments:
- *      gfdb_conn_node_t *_conn_node        : GFDB Connection node
- *      char **version  : the version is extracted as a string
- *                   and will be stored in this variable.
- *                   The freeing of the memory should be done by the caller.
- * Return:
- *      On success return the length of the version string that is
- *      extracted.
- *      On failure return -1
- * */
-int
-get_db_version(gfdb_conn_node_t *_conn_node, char **version);
-
-typedef int (*get_db_version_t)(gfdb_conn_node_t *_conn_node, char **version);
-
-/* Libgfdb API Function: Function to extract param from the db
- *  Arguments:
- *      gfdb_conn_node_t *_conn_node        : GFDB Connection node
- *      char *param_key     : param to be extracted
- *      char **param_value  : the value of the param that is
- *                       extracted. This function will allocate memory
- *                       to pragma_value. The caller should free the memory.
- * Return:
- *      On success return the length of the param value that is
- *      extracted.
- *      On failure return -1
- * */
-int
-get_db_params(gfdb_conn_node_t *_conn_node, char *param_key,
-              char **param_value);
-
-typedef int (*get_db_params_t)(gfdb_conn_node_t *db_conn, char *param_key,
-                               char **param_value);
-
-/* Libgfdb API Function: Function to set db params
- * Arguments:
- *      gfdb_conn_node_t *_conn_node        : GFDB Connection node
- *      char *param_key     : param to be set
- * char *param_value  : param value
- * Return:
- *      On success return 0
- *      On failure return -1
- * */
-int
-set_db_params(gfdb_conn_node_t *_conn_node, char *param_key, char *param_value);
-
-typedef int (*set_db_params_t)(gfdb_conn_node_t *db_conn, char *param_key,
-                               char *param_value);
-
-/*Libgfdb API Function: Compact the database.
- *
- * Arguments:
- *      _conn_node                      :  GFDB Connection node
- *      _compact_active                 :  Is compaction currently on?
- *      _compact_mode_switched          :  Was the compaction switch flipped?
- * 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);
-
-typedef int (*compact_db_t)(gfdb_conn_node_t *db_conn,
-                            gf_boolean_t compact_active,
-                            gf_boolean_t compact_mode_switched);
-
-typedef struct gfdb_methods_s {
-    init_db_t init_db;
-    fini_db_t fini_db;
-    find_all_t find_all;
-    find_unchanged_for_time_t find_unchanged_for_time;
-    find_recently_changed_files_t find_recently_changed_files;
-    find_unchanged_for_time_freq_t find_unchanged_for_time_freq;
-    find_recently_changed_files_freq_t find_recently_changed_files_freq;
-    clear_files_heat_t clear_files_heat;
-    get_db_version_t get_db_version;
-    get_db_params_t get_db_params;
-    set_db_params_t set_db_params;
-    /* Do not expose dbpath directly. Expose it via an */
-    /* access function: get_db_path_key(). */
-    char *dbpath;
-    get_db_path_key_t get_db_path_key;
-
-    /* Query Record related functions */
-    gfdb_query_record_new_t gfdb_query_record_new;
-    gfdb_query_record_free_t gfdb_query_record_free;
-    gfdb_add_link_to_query_record_t gfdb_add_link_to_query_record;
-    gfdb_write_query_record_t gfdb_write_query_record;
-    gfdb_read_query_record_t gfdb_read_query_record;
-
-    /* Link info related functions */
-    gfdb_link_info_new_t gfdb_link_info_new;
-    gfdb_link_info_free_t gfdb_link_info_free;
-
-    /* Compaction related functions */
-    compact_db_t compact_db;
-} gfdb_methods_t;
-
-void
-get_gfdb_methods(gfdb_methods_t *methods);
-
-typedef void (*get_gfdb_methods_t)(gfdb_methods_t *methods);
-
-#endif
diff --git a/libglusterfs/src/gfdb/gfdb_data_store_helper.c b/libglusterfs/src/gfdb/gfdb_data_store_helper.c
deleted file mode 100644
index 5f33312ad9b..00000000000
--- a/libglusterfs/src/gfdb/gfdb_data_store_helper.c
+++ /dev/null
@@ -1,588 +0,0 @@
-
-#include "gfdb_data_store_helper.h"
-#include "glusterfs/syscall.h"
-
-/******************************************************************************
- *
- *                       Query record related functions
- *
- * ****************************************************************************/
-
-/*Create a single link info structure*/
-gfdb_link_info_t *
-gfdb_link_info_new()
-{
-    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;
-    }
-
-    INIT_LIST_HEAD(&link_info->list);
-
-out:
-
-    return link_info;
-}
-
-/*Destroy a link info structure*/
-void
-gfdb_link_info_free(gfdb_link_info_t *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;
-    }
-
-    INIT_LIST_HEAD(&query_record->link_list);
-
-    ret = 0;
-out:
-    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)
-{
-    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;
-out:
-    return;
-}
-
-/*Function to destroy link_info list*/
-void
-gfdb_free_link_info_list(gfdb_query_record_t *query_record)
-{
-    gfdb_link_info_t *link_info = NULL;
-    gfdb_link_info_t *temp = NULL;
-
-    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;
-    }
-
-out:
-    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)
-{
-    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);
-
-    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';
-
-    list_add_tail(&link_info->list, &query_record->link_list);
-
-    query_record->link_count++;
-
-    ret = 0;
-out:
-    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);
-    }
-}
-
-/******************************************************************************
-                SERIALIZATION/DE-SERIALIZATION OF QUERY RECORD
-*******************************************************************************/
-/******************************************************************************
- The on disk format of query record is as follows,
-
-+---------------------------------------------------------------------------+
-| Length of serialized query record |       Serialized Query Record         |
-+---------------------------------------------------------------------------+
-             4 bytes                     Length of serialized query record
-                                                      |
-                                                      |
-     -------------------------------------------------|
-     |
-     |
-     V
-   Serialized Query Record Format:
-   +---------------------------------------------------------------------------+
-   | GFID |  Link count   |  <LINK INFO>  |.....                      | FOOTER |
-   +---------------------------------------------------------------------------+
-     16 B        4 B         Link Length                                  4 B
-                                |                                          |
-                                |                                          |
-   -----------------------------|                                          |
-   |                                                                       |
-   |                                                                       |
-   V                                                                       |
-   Each <Link Info> will be serialized as                                  |
-   +-----------------------------------------------+                       |
-   | PGID | BASE_NAME_LENGTH |      BASE_NAME      |                       |
-   +-----------------------------------------------+                       |
-     16 B       4 B             BASE_NAME_LENGTH                           |
-                                                                           |
-                                                                           |
-   ------------------------------------------------------------------------|
-   |
-   |
-   V
-   FOOTER is a magic number 0xBAADF00D indicating the end of the record.
-   This also serves as a serialized schema validator.
- * ****************************************************************************/
-
-#define GFDB_QUERY_RECORD_FOOTER 0xBAADF00D
-#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)
-{
-    int32_t len = -1;
-    gfdb_link_info_t *link_info = NULL;
-
-    GF_VALIDATE_OR_GOTO(GFDB_DATA_STORE, query_record, out);
-
-    /* Length of GFID */
-    len = UUID_LEN;
-
-    /* length of number of links*/
-    len += sizeof(int32_t);
-
-    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);
-
-        /* Length of base_name */
-        len += strlen(link_info->file_name);
-    }
-
-    /* length of footer */
-    len += sizeof(int32_t);
-out:
-    return len;
-}
-
-/* Function for serializing query record.
- *
- * Query Record Serialization Format
- * +---------------------------------------------------------------------------+
- * | GFID |  Link count   |  <LINK INFO>  |.....                      | FOOTER |
- * +---------------------------------------------------------------------------+
- *   16 B        4 B         Link Length                                  4 B
- *
- *
- * Each <Link Info> will be serialized as
- * +-----------------------------------------------+
- * | PGID | BASE_NAME_LENGTH |      BASE_NAME      |
- * +-----------------------------------------------+
- *   16 B       4 B             BASE_NAME_LENGTH
- *
- *
- * FOOTER is a magic number 0xBAADF00D indicating the end of the record.
- * This also serves as a serialized schema validator.
- *
- * The function will allocate memory to the serialized buffer,
- * the caller needs to free it.
- * Returns the length of the serialized buffer on success
- * or -1 on failure.
- *
- * */
-static int
-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);
-    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);
-
-        /* 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));
-    count += sizeof(int32_t);
-
-out:
-    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;
-out:
-    return ret;
-}
-
-static int
-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;
-    }
-
-    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;
-        }
-
-        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;
-}
-
-/* Function to write query record to file
- *
- * Disk format
- * +---------------------------------------------------------------------------+
- * | Length of serialized query record |       Serialized Query Record         |
- * +---------------------------------------------------------------------------+
- *            4 bytes                     Length of serialized query record
- *
- * Please refer gfdb_query_record_serialize () for format of
- * Serialized Query Record
- *
- * */
-int
-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));
-    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, errno, LG_MSG_DB_ERROR,
-                   "Failed to write serialized "
-                   "query record to file");
-            goto out;
-        }
-
-        write_buffer += ret;
-        write_len -= ret;
-    }
-
-    ret = 0;
-out:
-    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
- * Return -1 when failed.
- * Return 0 when reached EOF.
- * */
-int
-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));
-    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, 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;
-out:
-    GF_FREE(buffer);
-    return ret;
-}
diff --git a/libglusterfs/src/gfdb/gfdb_data_store_helper.h b/libglusterfs/src/gfdb/gfdb_data_store_helper.h
deleted file mode 100644
index 3c4499bdd3b..00000000000
--- a/libglusterfs/src/gfdb/gfdb_data_store_helper.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-#ifndef __GFDB_DATA_STORE_HELPER_H
-#define __GFDB_DATA_STORE_HELPER_H
-
-#include <time.h>
-#include <sys/time.h>
-#include <string.h>
-#include <fcntl.h>
-
-#include "glusterfs/common-utils.h"
-#include "glusterfs/compat-uuid.h"
-#include "gfdb_mem-types.h"
-#include "glusterfs/dict.h"
-#include "glusterfs/byte-order.h"
-#include "glusterfs/libglusterfs-messages.h"
-
-#define GFDB_DATA_STORE "gfdbdatastore"
-
-/*******************************************************************************
- *
- *                     Query related data structure and functions
- *
- * ****************************************************************************/
-
-#ifdef NAME_MAX
-#define GF_NAME_MAX NAME_MAX
-#else
-#define GF_NAME_MAX 255
-#endif
-
-/*Structure to hold the link information*/
-typedef struct gfdb_link_info {
-    uuid_t pargfid;
-    char file_name[GF_NAME_MAX];
-    struct list_head list;
-} gfdb_link_info_t;
-
-/*Structure used for querying purpose*/
-typedef struct gfdb_query_record {
-    uuid_t gfid;
-    /*This is the hardlink list*/
-    struct list_head link_list;
-    int link_count;
-} gfdb_query_record_t;
-
-/*Create a single link info structure*/
-gfdb_link_info_t *
-gfdb_link_info_new();
-typedef gfdb_link_info_t *(*gfdb_link_info_new_t)();
-
-/*Destroy a link info structure*/
-void
-gfdb_link_info_free(gfdb_link_info_t *gfdb_link_info);
-typedef void (*gfdb_link_info_free_t)(gfdb_link_info_t *gfdb_link_info);
-
-/* Function to create the query_record */
-gfdb_query_record_t *
-gfdb_query_record_new();
-typedef gfdb_query_record_t *(*gfdb_query_record_new_t)();
-
-/* Function to add linkinfo to query record */
-int
-gfdb_add_link_to_query_record(gfdb_query_record_t *gfdb_query_record,
-                              uuid_t pgfid, char *base_name);
-typedef int (*gfdb_add_link_to_query_record_t)(gfdb_query_record_t *, uuid_t,
-                                               char *);
-
-/*Function to destroy query record*/
-void
-gfdb_query_record_free(gfdb_query_record_t *gfdb_query_record);
-typedef void (*gfdb_query_record_free_t)(gfdb_query_record_t *);
-
-/* Function to write query record to file */
-int
-gfdb_write_query_record(int fd, gfdb_query_record_t *gfdb_query_record);
-typedef int (*gfdb_write_query_record_t)(int, gfdb_query_record_t *);
-
-/* Function to read query record from file.
- * Allocates memory to query record and return 0 when successful
- * Return -1 when failed.
- * Return 0 when EOF.
- * */
-int
-gfdb_read_query_record(int fd, gfdb_query_record_t **gfdb_query_record);
-typedef int (*gfdb_read_query_record_t)(int, gfdb_query_record_t **);
-
-#endif
\ No newline at end of file
diff --git a/libglusterfs/src/gfdb/gfdb_data_store_types.h b/libglusterfs/src/gfdb/gfdb_data_store_types.h
deleted file mode 100644
index 5ee050d4fab..00000000000
--- a/libglusterfs/src/gfdb/gfdb_data_store_types.h
+++ /dev/null
@@ -1,532 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-#ifndef __GFDB_DATA_STORE_TYPE_H
-#define __GFDB_DATA_STORE_TYPE_H
-
-#include "gfdb_data_store_helper.h"
-
-/*
- * Helps in dynamically choosing log level
- * */
-static inline gf_loglevel_t
-_gfdb_log_level(gf_loglevel_t given_level, gf_boolean_t ignore_level)
-{
-    return (ignore_level) ? GF_LOG_DEBUG : given_level;
-}
-
-typedef enum gf_db_operation {
-    GFDB_INVALID_DB_OP = -1,
-    /* Query DB OPS : All the Query DB_OP should be added */
-    /* in between START and END */
-    GFDB_QUERY_DB_OP_START, /* Start of Query DB_OP  */
-    GFDB_QUERY_DB_OP,
-    GF_FTABLE_EXISTS_DB_OP,
-    GFDB_QUERY_DB_OP_END, /* End of Query DB_OP */
-    /* Non-Query DB OPS */
-    GFDB_DB_CREATE_DB_OP,
-    GFDB_GFID_EXIST_DB_OP,
-    GFDB_W_INSERT_DB_OP,
-    GFDB_WU_INSERT_DB_OP,
-    GFDB_W_UPDATE_DB_OP,
-    GFDB_WU_UPDATE_DB_OP,
-    GFDB_W_DELETE_DB_OP,
-    GFDB_UW_DELETE_DB_OP,
-    GFDB_WFC_UPDATE_DB_OP,
-    GFDB_RFC_UPDATE_DB_OP,
-    GFDB_DB_COMPACT_DB_OP /* Added for VACUUM/manual compaction support */
-} gf_db_operation_t;
-
-#define GF_COL_MAX_NUM 2
-#define GF_COL_ALL " * "
-
-/* Column/fields names used in the DB.
- * If any new field is added should be updated here*/
-#define GF_COL_GF_ID "GF_ID"
-#define GF_COL_GF_PID "GF_PID"
-#define GF_COL_FILE_NAME "FNAME"
-#define GF_COL_WSEC "W_SEC"
-#define GF_COL_WMSEC "W_MSEC"
-#define GF_COL_UWSEC "UW_SEC"
-#define GF_COL_UWMSEC "UW_MSEC"
-#define GF_COL_WSEC_READ "W_READ_SEC"
-#define GF_COL_WMSEC_READ "W_READ_MSEC"
-#define GF_COL_UWSEC_READ "UW_READ_SEC"
-#define GF_COL_UWMSEC_READ "UW_READ_MSEC"
-#define GF_COL_WDEL_FLAG "W_DEL_FLAG"
-#define GF_COL_WRITE_FREQ_CNTR "WRITE_FREQ_CNTR"
-#define GF_COL_READ_FREQ_CNTR "READ_FREQ_CNTR"
-#define GF_COL_LINK_UPDATE "LINK_UPDATE"
-
-/***********************Time related********************************/
-/*1 sec = 1000000 microsec*/
-#define GFDB_MICROSEC 1000000
-
-/*All the gfdb times are represented using this structure*/
-typedef struct timeval gfdb_time_t;
-
-/*Convert time into  seconds*/
-static inline uint64_t
-gfdb_time_2_usec(gfdb_time_t *gfdb_time)
-{
-    GF_ASSERT(gfdb_time);
-    return ((uint64_t)gfdb_time->tv_sec * GFDB_MICROSEC) + gfdb_time->tv_usec;
-}
-
-/******************************************************************************
- *
- *              Insert/Update Record related data structures/functions
- *
- * ****************************************************************************/
-
-/*Indicated a generic synchronous write to the db
- * This may or may not be implemented*/
-typedef enum gfdb_sync_type {
-    GFDB_INVALID_SYNC = -1,
-    GFDB_DB_ASYNC,
-    GFDB_DB_SYNC
-} gfdb_sync_type_t;
-
-/*Strings related to the abvove sync type*/
-#define GFDB_STR_DB_ASYNC "async"
-#define GFDB_STR_DB_SYNC "sync"
-
-/*To convert sync type from string to gfdb_sync_type_t*/
-static inline int
-gf_string2gfdbdbsync(char *sync_option)
-{
-    int ret = -1;
-
-    if (!sync_option)
-        goto out;
-    if (strcmp(sync_option, GFDB_STR_DB_ASYNC) == 0) {
-        ret = GFDB_DB_ASYNC;
-    } else if (strcmp(sync_option, GFDB_STR_DB_SYNC) == 0) {
-        ret = GFDB_DB_SYNC;
-    }
-out:
-    return ret;
-}
-
-/*Indicated different types of db*/
-typedef enum gfdb_db_type {
-    GFDB_INVALID_DB = -1,
-    GFDB_HASH_FILE_STORE,
-    GFDB_ROCKS_DB,
-    GFDB_SQLITE3,
-    GFDB_HYPERDEX,
-    GFDB_DB_END /*Add DB type Entries above this only*/
-} gfdb_db_type_t;
-
-/*String related to the db types*/
-#define GFDB_STR_HASH_FILE_STORE "hashfile"
-#define GFDB_STR_ROCKS_DB "rocksdb"
-#define GFDB_STR_SQLITE3 "sqlite3"
-#define GFDB_STR_HYPERDEX "hyperdex"
-
-/*Convert db type in string to gfdb_db_type_t*/
-static inline int
-gf_string2gfdbdbtype(char *db_option)
-{
-    int ret = -1;
-
-    if (!db_option)
-        goto out;
-    if (strcmp(db_option, GFDB_STR_HASH_FILE_STORE) == 0) {
-        ret = GFDB_HASH_FILE_STORE;
-    } else if (strcmp(db_option, GFDB_STR_ROCKS_DB) == 0) {
-        ret = GFDB_ROCKS_DB;
-    } else if (strcmp(db_option, GFDB_STR_SQLITE3) == 0) {
-        ret = GFDB_SQLITE3;
-    } else if (strcmp(db_option, GFDB_STR_HYPERDEX) == 0) {
-        ret = GFDB_HYPERDEX;
-    }
-out:
-    return ret;
-}
-
-/*Tells the path of the fop*/
-typedef enum gfdb_fop_path {
-    GFDB_FOP_INVALID = -1,
-    /*Filler value for zero*/
-    GFDB_FOP_PATH_ZERO = 0,
-    /*have wind path below this*/
-    GFDB_FOP_WIND = 1,
-    GFDB_FOP_WDEL = 2,
-    /*have unwind path below this*/
-    GFDB_FOP_UNWIND = 4,
-    /*Delete unwind path*/
-    GFDB_FOP_UNDEL = 8,
-    GFDB_FOP_UNDEL_ALL = 16
-} gfdb_fop_path_t;
-/*Strings related to the above fop path*/
-#define GFDB_STR_FOP_INVALID "INVALID"
-#define GFDB_STR_FOP_WIND "ENTRY"
-#define GFDB_STR_FOP_UNWIND "EXIT"
-#define GFDB_STR_FOP_WDEL "WDEL"
-#define GFDB_STR_FOP_UNDEL "UNDEL"
-
-static inline gf_boolean_t
-iswindpath(gfdb_fop_path_t gfdb_fop_path)
-{
-    return ((gfdb_fop_path == GFDB_FOP_WIND) ||
-            (gfdb_fop_path == GFDB_FOP_WDEL))
-               ? _gf_true
-               : _gf_false;
-}
-
-static inline gf_boolean_t
-isunwindpath(gfdb_fop_path_t gfdb_fop_path)
-{
-    return (gfdb_fop_path >= GFDB_FOP_UNWIND) ? _gf_true : _gf_false;
-}
-
-/*Tell what type of fop it was
- * Like whether a dentry fop or a inode fop
- * Read fop or a write fop etc*/
-typedef enum gfdb_fop_type {
-    GFDB_FOP_INVALID_OP = -1,
-    /*Filler value for zero*/
-    GFDB_FOP_TYPE_ZERO = 0,
-    GFDB_FOP_DENTRY_OP = 1,
-    GFDB_FOP_DENTRY_CREATE_OP = 2,
-    GFDB_FOP_INODE_OP = 4,
-    GFDB_FOP_WRITE_OP = 8,
-    GFDB_FOP_READ_OP = 16
-} gfdb_fop_type_t;
-
-#define GFDB_FOP_INODE_WRITE (GFDB_FOP_INODE_OP | GFDB_FOP_WRITE_OP)
-
-#define GFDB_FOP_DENTRY_WRITE (GFDB_FOP_DENTRY_OP | GFDB_FOP_WRITE_OP)
-
-#define GFDB_FOP_CREATE_WRITE (GFDB_FOP_DENTRY_CREATE_OP | GFDB_FOP_WRITE_OP)
-
-#define GFDB_FOP_INODE_READ (GFDB_FOP_INODE_OP | GFDB_FOP_READ_OP)
-
-static inline gf_boolean_t
-isreadfop(gfdb_fop_type_t fop_type)
-{
-    return (fop_type & GFDB_FOP_READ_OP) ? _gf_true : _gf_false;
-}
-
-static inline gf_boolean_t
-isdentryfop(gfdb_fop_type_t fop_type)
-{
-    return ((fop_type & GFDB_FOP_DENTRY_OP) ||
-            (fop_type & GFDB_FOP_DENTRY_CREATE_OP))
-               ? _gf_true
-               : _gf_false;
-}
-
-static inline gf_boolean_t
-isdentrycreatefop(gfdb_fop_type_t fop_type)
-{
-    return (fop_type & GFDB_FOP_DENTRY_CREATE_OP) ? _gf_true : _gf_false;
-}
-
-/*The structure that is used to send insert/update the databases
- * using insert_db api*/
-typedef struct gfdb_db_record {
-    /* GFID */
-    uuid_t gfid;
-    /* Used during a rename refer ctr_rename() in changetimerecorder
-     * xlator*/
-    uuid_t old_gfid;
-    /* Parent GFID */
-    uuid_t pargfid;
-    uuid_t old_pargfid;
-    /* File names */
-    char file_name[GF_NAME_MAX + 1];
-    char old_file_name[GF_NAME_MAX + 1];
-    /* FOP type and FOP path*/
-    gfdb_fop_type_t gfdb_fop_type;
-    gfdb_fop_path_t gfdb_fop_path;
-    /*Time of change or access*/
-    gfdb_time_t gfdb_wind_change_time;
-    gfdb_time_t gfdb_unwind_change_time;
-    /* For crash consistency while inserting/updating hard links */
-    gf_boolean_t islinkupdate;
-    /* For link consistency we do a double update i.e mark the link
-     * during the wind and during the unwind we update/delete the link.
-     * This has a performance hit. We give a choice here whether we need
-     * link consistency to be spoton or not using link_consistency flag.
-     * This will have only one link update */
-    gf_boolean_t link_consistency;
-    /* For dentry fops we can choose to ignore recording of unwind time */
-    /* For inode fops "record_exit" volume option does the trick,       */
-    /* but for dentry fops we update the LINK_UPDATE, so an extra       */
-    /* flag is provided to ignore the recording of the unwind time.     */
-    gf_boolean_t do_record_uwind_time;
-    /* Global flag to record or not record counters */
-    gf_boolean_t do_record_counters;
-    /* Global flag to Record/Not Record wind or wind time.
-     * This flag will overrule do_record_uwind_time*/
-    gf_boolean_t do_record_times;
-    /* Ignoring errors while inserting.
-     * */
-    gf_boolean_t ignore_errors;
-} gfdb_db_record_t;
-
-/*******************************************************************************
- *
- *                           Signatures for the plugin functions
- *                           i.e Any plugin should implementment
- *                           these functions to integrate with
- *                           libgfdb.
- *
- * ****************************************************************************/
-
-/*Call back function for querying the database*/
-typedef int (*gf_query_callback_t)(gfdb_query_record_t *, void *);
-
-/* Used to initialize db connection
- * Arguments:
- *      args         : Dictionary containing database specific parameters
- *      db_conn      : pointer to plugin specific data base connection
- *                     that will be created. If the call is successful
- *                     db_conn will contain the plugin specific connection
- *                     If call is unsuccessful will have NULL.
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int (*gfdb_init_db_t)(dict_t *args, void **db_conn);
-
-/* Used to terminate/de-initialize db connection
- *                      (Destructor function for db connection object)
- * Arguments:
- *      db_conn        : plugin specific data base connection
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int (*gfdb_fini_db_t)(void **db_conn);
-
-/*Used to insert/updated records in the database
- * Arguments:
- *      db_conn        : plugin specific data base connection
- *      gfdb_db_record :  Record to be inserted/updated
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int (*gfdb_insert_record_t)(void *db_conn, gfdb_db_record_t *db_record);
-
-/*Used to delete record from the database
- * Arguments:
- *      db_conn        : plugin specific data base connection
- *      gfdb_db_record :  Record to be deleted
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int (*gfdb_delete_record_t)(void *db_conn, gfdb_db_record_t *db_record);
-
-/*Used to compact the database
- * Arguments:
- *      db_conn                        :  GFDB Connection node
- *      compact_active                 :  Is compaction currently on?
- *      compact_mode_switched          :  Was the compaction switch flipped?
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int (*gfdb_compact_db_t)(void *db_conn, gf_boolean_t compact_active,
-                                 gf_boolean_t compact_mode_switched);
-
-/* Query all the records from the database
- * Arguments:
- *      db_conn        : plugin specific data base connection
- *      query_callback  : Call back function that will be called
- *                        for every record found
- *      _query_cbk_args : Custom argument passed for the call back
- *                        function query_callback
- *      query_limit     : 0 - list all files
- *                        positive value - add the LIMIT clause to
- *                        the SQL query to limit the number of records
- *                        returned
- *
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int (*gfdb_find_all_t)(void *db_conn,
-                               gf_query_callback_t query_callback,
-                               void *_cbk_args, int query_limit);
-
-/* Query records/files that have not changed/accessed
- *                      from a time in past to current time
- * Arguments:
- *      db_conn                 : plugin specific data base connection
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _cbk_args               : Custom argument passed for the call back
- *                                function query_callback
- *      for_time                : Time from where the file/s are not
- *                                changed/accessed
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int (*gfdb_find_unchanged_for_time_t)(
-    void *db_conn, gf_query_callback_t query_callback, void *_cbk_args,
-    gfdb_time_t *_time);
-
-/* Query records/files that have changed/accessed from a
- *                      time in past to current time
- * Arguments:
- *      db_conn                 : plugin specific data base connection
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _cbk_args               : Custom argument passed for the call back
- *                                function query_callback
- *      _time                   : Time from where the file/s are
- *                                changed/accessed
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int (*gfdb_find_recently_changed_files_t)(
-    void *db_conn, gf_query_callback_t query_callback, void *_cbk_args,
-    gfdb_time_t *_time);
-
-/* Query records/files that have not changed/accessed
- * from a time in past to current time, with
- * a desired frequency
- *
- * Arguments:
- *      db_conn                 : plugin specific data base connection
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _cbk_args               : Custom argument passed for the call back
- *                                function query_callback
- *      _time                   : Time from where the file/s are not
- *                                changed/accessed
- *      _write_freq             : Desired Write Frequency lower limit
- *      _read_freq              : Desired Read Frequency lower limit
- *      _clear_counters         : If true, Clears all the frequency counters of
- *                                all files.
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int (*gfdb_find_unchanged_for_time_freq_t)(
-    void *db_conn, gf_query_callback_t query_callback, void *_cbk_args,
-    gfdb_time_t *_time, int _write_freq, int _read_freq,
-    gf_boolean_t _clear_counters);
-
-/* Query records/files that have changed/accessed from a
- * time in past to current time, with a desired frequency
- * Arguments:
- *      db_conn                 : plugin specific data base connection
- *      query_callback          : Call back function that will be called
- *                                for every record found
- *      _cbk_args               : Custom argument passed for the call back
- *                                function query_callback
- *      _time                   : Time from where the file/s are
- *                                changed/accessed
- *      _write_freq             : Desired Write Frequency lower limit
- *      _read_freq              : Desired Read Frequency lower limit
- *      _clear_counters         : If true, Clears all the frequency counters of
- *                                all files.
- * Returns : if successful return 0 or
- *          -ve value in case of failure*/
-typedef int (*gfdb_find_recently_changed_files_freq_t)(
-    void *db_conn, gf_query_callback_t query_callback, void *_cbk_args,
-    gfdb_time_t *_time, int _write_freq, int _read_freq,
-    gf_boolean_t _clear_counters);
-
-typedef int (*gfdb_clear_files_heat_t)(void *db_conn);
-
-typedef int (*gfdb_get_db_version_t)(void *db_conn, char **version);
-
-typedef int (*gfdb_get_db_params_t)(void *db_conn, char *param_key,
-                                    char **param_value);
-
-typedef int (*gfdb_set_db_params_t)(void *db_conn, char *param_key,
-                                    char *param_value);
-
-/*Data structure holding all the above plugin function pointers*/
-typedef struct gfdb_db_operations {
-    gfdb_init_db_t init_db_op;
-    gfdb_fini_db_t fini_db_op;
-    gfdb_insert_record_t insert_record_op;
-    gfdb_delete_record_t delete_record_op;
-    gfdb_compact_db_t compact_db_op;
-    gfdb_find_all_t find_all_op;
-    gfdb_find_unchanged_for_time_t find_unchanged_for_time_op;
-    gfdb_find_recently_changed_files_t find_recently_changed_files_op;
-    gfdb_find_unchanged_for_time_freq_t find_unchanged_for_time_freq_op;
-    gfdb_find_recently_changed_files_freq_t find_recently_changed_files_freq_op;
-    gfdb_clear_files_heat_t clear_files_heat_op;
-    gfdb_get_db_version_t get_db_version;
-    gfdb_get_db_params_t get_db_params;
-    gfdb_set_db_params_t set_db_params;
-} gfdb_db_operations_t;
-
-/*******************************************************************************
- *
- * Database connection object: This objected is maitained by libgfdb for each
- * database connection created.
- * gf_db_connection     : DB connection specific to the plugin
- * gfdb_db_operations   : Contains all the libgfdb API implementation
- *                        from the plugin.
- * gfdb_db_type         : Type of database
- *
- * ****************************************************************************/
-
-typedef struct gfdb_connection {
-    void *gf_db_connection;
-    gfdb_db_operations_t gfdb_db_operations;
-    gfdb_db_type_t gfdb_db_type;
-} gfdb_connection_t;
-
-/*******************************************************************************
- *
- *                    Macros for get and set db options
- *
- * ****************************************************************************/
-
-/*Set param_key : str_value into param_dict*/
-#define SET_DB_PARAM_TO_DICT(comp_name, params_dict, param_key, str_value,     \
-                             ret, error)                                       \
-    do {                                                                       \
-        data_t *data = NULL;                                                   \
-        data = str_to_data(str_value);                                         \
-        if (!data)                                                             \
-            goto error;                                                        \
-        ret = dict_add(params_dict, param_key, data);                          \
-        if (ret) {                                                             \
-            gf_msg(comp_name, GF_LOG_ERROR, 0, LG_MSG_SET_PARAM_FAILED,        \
-                   "Failed setting %s "                                        \
-                   "to params dictionary",                                     \
-                   param_key);                                                 \
-            data_destroy(data);                                                \
-            goto error;                                                        \
-        };                                                                     \
-    } while (0)
-
-/*get str_value of param_key from param_dict*/
-#define GET_DB_PARAM_FROM_DICT(comp_name, params_dict, param_key, str_value,   \
-                               error)                                          \
-    do {                                                                       \
-        data_t *data = NULL;                                                   \
-        data = dict_get(params_dict, param_key);                               \
-        if (!data) {                                                           \
-            gf_msg(comp_name, GF_LOG_ERROR, 0, LG_MSG_GET_PARAM_FAILED,        \
-                   "Failed to retrieve "                                       \
-                   "%s from params",                                           \
-                   param_key);                                                 \
-            goto error;                                                        \
-        } else {                                                               \
-            str_value = data->data;                                            \
-        };                                                                     \
-    } while (0)
-
-/*get str_value of param_key from param_dict. if param_key is not present
- * set _default_v to str_value */
-#define GET_DB_PARAM_FROM_DICT_DEFAULT(comp_name, params_dict, param_key,      \
-                                       str_value, _default_v)                  \
-    do {                                                                       \
-        data_t *data = NULL;                                                   \
-        data = dict_get(params_dict, param_key);                               \
-        if (!data) {                                                           \
-            str_value = _default_v;                                            \
-            gf_msg(comp_name, GF_LOG_TRACE, 0, LG_MSG_GET_PARAM_FAILED,        \
-                   "Failed to retrieve "                                       \
-                   "%s from params.Assigning default value: %s",               \
-                   param_key, _default_v);                                     \
-        } else {                                                               \
-            str_value = data->data;                                            \
-        };                                                                     \
-    } while (0)
-
-#endif
diff --git a/libglusterfs/src/gfdb/gfdb_mem-types.h b/libglusterfs/src/gfdb/gfdb_mem-types.h
deleted file mode 100644
index b97cdf89446..00000000000
--- a/libglusterfs/src/gfdb/gfdb_mem-types.h
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
-  Copyright (c) 2008-2015 Red Hat, Inc. <http://www.redhat.com>
-  This file is part of GlusterFS.
-
-  This file is licensed to you under your choice of the GNU Lesser
-  General Public License, version 3 or any later version (LGPLv3 or
-  later), or the GNU General Public License, version 2 (GPLv2), in all
-  cases as published by the Free Software Foundation.
-*/
-
-#ifndef __GFDB_MEM_TYPES_H__
-#define __GFDB_MEM_TYPES_H__
-
-#include "glusterfs/mem-types.h"
-
-enum gfdb_mem_types_ { gfdb_mtstart = gf_common_mt_end + 1, gfdb_mt_end };
-#endif
diff --git a/libglusterfs/src/gfdb/gfdb_sqlite3.c b/libglusterfs/src/gfdb/gfdb_sqlite3.c
deleted file mode 100644
index 98232d5e379..00000000000
--- a/libglusterfs/src/gfdb/gfdb_sqlite3.c
+++ /dev/null
@@ -1,1542 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-
-#include "gfdb_sqlite3.h"
-#include "gfdb_sqlite3_helper.h"
-#include "glusterfs/libglusterfs-messages.h"
-#include "glusterfs/syscall.h"
-
-/******************************************************************************
- *
- *                      Util functions
- *
- * ***************************************************************************/
-gf_sql_connection_t *
-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 ");
-    }
-
-    return gf_sql_conn;
-}
-
-void
-gf_sql_connection_fini(gf_sql_connection_t **sql_connection)
-{
-    if (!sql_connection)
-        return;
-    GF_FREE(*sql_connection);
-    *sql_connection = NULL;
-}
-
-const char *
-gf_sql_jm2str(gf_sql_journal_mode_t jm)
-{
-    switch (jm) {
-        case gf_sql_jm_delete:
-            return GF_SQL_JM_DELETE;
-        case gf_sql_jm_truncate:
-            return GF_SQL_JM_TRUNCATE;
-        case gf_sql_jm_persist:
-            return GF_SQL_JM_PERSIST;
-        case gf_sql_jm_memory:
-            return GF_SQL_JM_MEMORY;
-        case gf_sql_jm_wal:
-            return GF_SQL_JM_WAL;
-        case gf_sql_jm_off:
-            return GF_SQL_JM_OFF;
-        case gf_sql_jm_invalid:
-            break;
-    }
-    return NULL;
-}
-
-gf_sql_journal_mode_t
-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;
-    }
-    return gf_sql_jm_invalid;
-}
-
-const char *
-gf_sql_av_t2str(gf_sql_auto_vacuum_t sql_av)
-{
-    switch (sql_av) {
-        case gf_sql_av_none:
-            return GF_SQL_AV_NONE;
-        case gf_sql_av_full:
-            return GF_SQL_AV_FULL;
-        case gf_sql_av_incr:
-            return GF_SQL_AV_INCR;
-        case gf_sql_av_invalid:
-            break;
-    }
-    return NULL;
-}
-
-gf_sql_auto_vacuum_t
-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;
-    }
-    return gf_sql_av_invalid;
-}
-
-const char *
-gf_sync_t2str(gf_sql_sync_t sql_sync)
-{
-    switch (sql_sync) {
-        case gf_sql_sync_off:
-            return GF_SQL_SYNC_OFF;
-        case gf_sql_sync_normal:
-            return GF_SQL_SYNC_NORMAL;
-        case gf_sql_sync_full:
-            return GF_SQL_SYNC_FULL;
-        case gf_sql_sync_invalid:
-            break;
-    }
-    return NULL;
-}
-
-gf_sql_sync_t
-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;
-    }
-    return gf_sql_sync_invalid;
-}
-
-/*TODO replace GF_CALLOC by mem_pool or iobuff if required for performance */
-static char *
-sql_stmt_init()
-{
-    char *sql_stmt = NULL;
-
-    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;
-    }
-out:
-    return sql_stmt;
-}
-
-/*TODO replace GF_FREE by mem_pool or iobuff if required for performance */
-static void
-sql_stmt_fini(char **sql_stmt)
-{
-    GF_FREE(*sql_stmt);
-}
-
-/******************************************************************************
- *                      DB Essential functions used by
- *                      > gf_open_sqlite3_conn ()
- *                      > gf_close_sqlite3_conn ()
- * ***************************************************************************/
-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;
-}
-
-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;
-out:
-    return ret;
-}
-
-/******************************************************************************
- *
- *                      Database init / fini / create table
- *
- * ***************************************************************************/
-
-/*Function to fill db operations*/
-void
-gf_sqlite3_fill_db_operations(gfdb_db_operations_t *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->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->clear_files_heat_op = gf_sqlite3_clear_files_heat;
-
-    gfdb_db_ops->get_db_version = gf_sqlite3_version;
-
-    gfdb_db_ops->get_db_params = gf_sqlite3_pragma;
-
-    gfdb_db_ops->set_db_params = gf_sqlite3_set_pragma;
-}
-
-static int
-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;
-out:
-    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,
-     * 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_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;
-out:
-    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;
-    }
-
-db_exists:
-    ret = 0;
-out:
-    if (ret) {
-        gf_sqlite3_fini((void **)&sql_conn);
-    }
-
-    *db_conn = sql_conn;
-
-    return ret;
-}
-
-int
-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);
-    }
-    *db_conn = sql_conn;
-    ret = 0;
-out:
-    return ret;
-}
-
-/******************************************************************************
- *
- *                      INSERT/UPDATE/DELETE Operations
- *
- *
- * ***************************************************************************/
-
-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);
-
-    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;
-        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;
-
-        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;
-        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;
-        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;
-    }
-
-    ret = 0;
-out:
-    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;
-
-    CHECK_SQL_CONN(sql_conn, out);
-    GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, gfdb_db_record, out);
-
-    ret = 0;
-out:
-    return ret;
-}
-
-/******************************************************************************
- *
- *                      SELECT QUERY FUNCTIONS
- *
- *
- * ***************************************************************************/
-
-static int
-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;
-}
-
-/*
- * Find All files recorded in the DB
- * Input:
- *      query_callback  :       query callback function to handle
- *                              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)
-{
-    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);
-
-    ret = gf_get_basic_query_stmt(&query_str);
-    if (ret <= 0) {
-        goto 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;
-        }
-
-        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);
-
-    if (limit_query)
-        GF_FREE(limit_query);
-
-    return ret;
-}
-
-/*
- * Find recently changed files from the DB
- * Input:
- *      query_callback  :       query callback function to handle
- *                              result records from the query
- *      from_time       :       Time to define what is recent
- * */
-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)
-{
-    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;
-}
-
-/*
- * Find unchanged files from a specified time from the DB
- * Input:
- *      query_callback  :       query callback function to handle
- *                              result records from the query
- *      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)
-{
-    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;
-}
-
-/*
- * Find recently changed files with a specific frequency from the DB
- * Input:
- *      db_conn         :       db connection object
- *      query_callback  :       query callback function to handle
- *                              result records from the query
- *      from_time       :       Time to define what is recent
- *      freq_write_cnt  :       Frequency thresold for write
- *      freq_read_cnt   :       Frequency thresold for read
- *      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)
-{
-    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_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;
-}
-
-/*
- * Find unchanged files from a specified time, w.r.t to frequency, from the DB
- * Input:
- *      query_callback  :       query callback function to handle
- *                              result records from the query
- *      for_time       :        Time from where the file/s are not changed
- *      freq_write_cnt  :       Frequency thresold for write
- *      freq_read_cnt   :       Frequency thresold for read
- *      clear_counters  :       Clear counters (r/w) for all inodes in DB
- * */
-int
-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,
-                                        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 "
-                /*First condition: For Writes
-                 * Files that have write wind time smaller than for_time
-                 * OR
-                 * File that have write wind time greater than for_time,
-                 * but write_frequency less than freq_write_cnt*/
-                "( ( ((" GF_COL_TB_WSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_WMSEC ") < ? )"
-                " OR "
-                "( (" GF_COL_TB_WFC " < ? ) AND"
-                "((" GF_COL_TB_WSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_WMSEC ") >= ? ) ) )"
-                " AND "
-                /*Second condition: For Reads
-                 * Files that have read wind time smaller than for_time
-                 * OR
-                 * File that have read wind time greater than for_time,
-                 * but read_frequency less than freq_read_cnt*/
-                "( ((" GF_COL_TB_RWSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_RWMSEC ") < ? )"
-                " OR "
-                "( (" GF_COL_TB_RFC " < ? ) AND"
-                "((" GF_COL_TB_RWSEC " * " TOSTRING(GFDB_MICROSEC) " + "
-                GF_COL_TB_RWMSEC ") >= ? ) ) ) )"
-                /* Order by write wind time and write freq in ascending order
-                 * i.e most cold files w.r.t to write */
-                " ORDER BY GF_FILE_TB.W_SEC ASC, "
-                "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) {
-        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;
-out:
-    sqlite3_finalize(prep_stmt);
-    GF_FREE(base_query_str);
-    GF_FREE(query_str);
-    return ret;
-}
-
-int
-gf_sqlite3_clear_files_heat(void *db_conn)
-{
-    int ret = -1;
-    gf_sql_connection_t *sql_conn = db_conn;
-
-    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 = 0;
-out:
-    return ret;
-}
-
-/* Function to extract version of sqlite db
- * Input:
- * void *db_conn        : Sqlite connection
- * char **version  : the version is extracted as a string and will be stored in
- *                   this variable. The freeing of the memory should be done by
- *                   the caller.
- * Return:
- *      On success return the length of the version string that is
- *      extracted.
- *      On failure return -1
- * */
-int
-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");
-    }
-
-out:
-    sqlite3_finalize(pre_stmt);
-
-    return ret;
-}
-
-/* Function to extract PRAGMA from sqlite db
- * Input:
- * void *db_conn        : Sqlite connection
- * char *pragma_key     : PRAGMA or setting to be extracted
- * char **pragma_value  : the value of the PRAGMA or setting that is
- *                        extracted. This function will allocate memory
- *                        to pragma_value. The caller should free the memory
- * Return:
- *      On success return the length of the pragma/setting value that is
- *      extracted.
- *      On failure return -1
- * */
-int
-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);
-    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_QUERY_FAILED,
-                   "Failed to get %s from db", pragma_key);
-        }
-    }
-
-    ret = 0;
-out:
-    GF_FREE(sqlstring);
-
-    sqlite3_finalize(pre_stmt);
-
-    return ret;
-}
-
-/* Function to set PRAGMA to sqlite db
- * Input:
- * void *db_conn        : Sqlite connection
- * char *pragma_key     : PRAGMA to be set
- * char *pragma_value   : the value of the PRAGMA
- * Return:
- *      On success return 0
- *      On failure return -1
- * */
-int
-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;
-
-    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);
-
-    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;
-
-out:
-
-    return ret;
-}
-
-/* Function to vacuum of sqlite db
- * Input:
- * void *db_conn                      : Sqlite connection
- * gf_boolean_t compact_active        : Is compaction on?
- * gf_boolean_t compact_mode_switched : Did we just flip the compaction switch?
- * Return:
- *      On success return 0
- *      On failure return -1
- * */
-int
-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;
-        }
-
-        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;
-        }
-
-        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");
-out:
-    GF_FREE(sqlstring);
-
-    return ret;
-}
diff --git a/libglusterfs/src/gfdb/gfdb_sqlite3.h b/libglusterfs/src/gfdb/gfdb_sqlite3.h
deleted file mode 100644
index d8240e905f7..00000000000
--- a/libglusterfs/src/gfdb/gfdb_sqlite3.h
+++ /dev/null
@@ -1,328 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-#ifndef __GFDB_SQLITE3_H
-#define __GFDB_SQLITE3_H
-
-/*Sqlite3 header file*/
-#include <sqlite3.h>
-
-#include "glusterfs/logging.h"
-#include "gfdb_data_store_types.h"
-#include "gfdb_mem-types.h"
-#include "glusterfs/libglusterfs-messages.h"
-
-#define GF_STMT_SIZE_MAX 2048
-
-#define GF_DB_NAME "gfdb.db"
-#define GF_FILE_TABLE "GF_FILE_TB"
-#define GF_FILE_LINK_TABLE "GF_FLINK_TB"
-#define GF_MASTER_TABLE "sqlite_master"
-
-/*Since we have multiple tables to be created we put it in a transaction*/
-#define GF_CREATE_STMT(out_str)                                                \
-    do {                                                                       \
-        sprintf(out_str, "BEGIN; CREATE TABLE IF NOT EXISTS " GF_FILE_TABLE    \
-                         "(GF_ID TEXT PRIMARY KEY NOT NULL, "                  \
-                         "W_SEC INTEGER NOT NULL DEFAULT 0, "                  \
-                         "W_MSEC INTEGER NOT NULL DEFAULT 0, "                 \
-                         "UW_SEC INTEGER NOT NULL DEFAULT 0, "                 \
-                         "UW_MSEC INTEGER NOT NULL DEFAULT 0, "                \
-                         "W_READ_SEC INTEGER NOT NULL DEFAULT 0, "             \
-                         "W_READ_MSEC INTEGER NOT NULL DEFAULT 0, "            \
-                         "UW_READ_SEC INTEGER NOT NULL DEFAULT 0, "            \
-                         "UW_READ_MSEC INTEGER NOT NULL DEFAULT 0, "           \
-                         "WRITE_FREQ_CNTR INTEGER NOT NULL DEFAULT 1, "        \
-                         "READ_FREQ_CNTR INTEGER NOT NULL DEFAULT 1); "        \
-                         "CREATE TABLE IF NOT EXISTS " GF_FILE_LINK_TABLE      \
-                         "(GF_ID TEXT NOT NULL, "                              \
-                         "GF_PID TEXT NOT NULL, "                              \
-                         "FNAME TEXT NOT NULL, "                               \
-                         "W_DEL_FLAG INTEGER NOT NULL DEFAULT 0, "             \
-                         "LINK_UPDATE INTEGER NOT NULL DEFAULT 0, "            \
-                         "PRIMARY KEY ( GF_ID, GF_PID, FNAME) "                \
-                         ");"                                                  \
-                         "COMMIT;");                                           \
-        ;                                                                      \
-    } while (0)
-
-#define GF_COL_TB_WSEC GF_FILE_TABLE "." GF_COL_WSEC
-#define GF_COL_TB_WMSEC GF_FILE_TABLE "." GF_COL_WMSEC
-#define GF_COL_TB_UWSEC GF_FILE_TABLE "." GF_COL_UWSEC
-#define GF_COL_TB_UWMSEC GF_FILE_TABLE "." GF_COL_UWMSEC
-#define GF_COL_TB_RWSEC GF_FILE_TABLE "." GF_COL_WSEC_READ
-#define GF_COL_TB_RWMSEC GF_FILE_TABLE "." GF_COL_WMSEC_READ
-#define GF_COL_TB_RUWSEC GF_FILE_TABLE "." GF_COL_UWSEC_READ
-#define GF_COL_TB_RUWMSEC GF_FILE_TABLE "." GF_COL_UWMSEC_READ
-#define GF_COL_TB_WFC GF_FILE_TABLE "." GF_COL_WRITE_FREQ_CNTR
-#define GF_COL_TB_RFC GF_FILE_TABLE "." GF_COL_READ_FREQ_CNTR
-
-/*******************************************************************************
- *                      SQLITE3 Connection details and PRAGMA
- * ****************************************************************************/
-
-#define GF_SQL_AV_NONE "none"
-#define GF_SQL_AV_FULL "full"
-#define GF_SQL_AV_INCR "incremental"
-
-#define GF_SQL_SYNC_OFF "off"
-#define GF_SQL_SYNC_NORMAL "normal"
-#define GF_SQL_SYNC_FULL "full"
-
-#define GF_SQL_JM_DELETE "delete"
-#define GF_SQL_JM_TRUNCATE "truncate"
-#define GF_SQL_JM_PERSIST "persist"
-#define GF_SQL_JM_MEMORY "memory"
-#define GF_SQL_JM_WAL "wal"
-#define GF_SQL_JM_OFF "off"
-
-#define GF_SQL_COMPACT_NONE 0
-#define GF_SQL_COMPACT_FULL 1
-#define GF_SQL_COMPACT_INCR 2
-#define GF_SQL_COMPACT_MANUAL 3
-
-#define GF_SQL_COMPACT_DEF GF_SQL_COMPACT_INCR
-typedef enum gf_sql_auto_vacuum {
-    gf_sql_av_none = 0,
-    gf_sql_av_full,
-    gf_sql_av_incr,
-    gf_sql_av_invalid
-} gf_sql_auto_vacuum_t;
-
-typedef enum gf_sql_sync {
-    gf_sql_sync_off = 0,
-    gf_sql_sync_normal,
-    gf_sql_sync_full,
-    gf_sql_sync_invalid
-} gf_sql_sync_t;
-
-typedef enum gf_sql_journal_mode {
-    gf_sql_jm_wal = 0,
-    gf_sql_jm_delete,
-    gf_sql_jm_truncate,
-    gf_sql_jm_persist,
-    gf_sql_jm_memory,
-    gf_sql_jm_off,
-    gf_sql_jm_invalid
-} gf_sql_journal_mode_t;
-
-typedef struct gf_sql_connection {
-    char sqlite3_db_path[PATH_MAX];
-    sqlite3 *sqlite3_db_conn;
-    ssize_t cache_size;
-    ssize_t page_size;
-    ssize_t wal_autocheckpoint;
-    gf_sql_journal_mode_t journal_mode;
-    gf_sql_sync_t synchronous;
-    gf_sql_auto_vacuum_t auto_vacuum;
-} gf_sql_connection_t;
-
-#define CHECK_SQL_CONN(sql_conn, out)                                          \
-    do {                                                                       \
-        GF_VALIDATE_OR_GOTO(GFDB_STR_SQLITE3, sql_conn, out);                  \
-        if (!sql_conn->sqlite3_db_conn) {                                      \
-            gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,                          \
-                   LG_MSG_CONNECTION_INIT_FAILED,                              \
-                   "sqlite3 connection not initialized");                      \
-            goto out;                                                          \
-        };                                                                     \
-    } while (0)
-
-#define GF_SQLITE3_SET_PRAGMA(sqlite3_config_str, param_key, format, value,    \
-                              ret, error)                                      \
-    do {                                                                       \
-        sprintf(sqlite3_config_str, "PRAGMA %s = " format, param_key, value);  \
-        ret = sqlite3_exec(sql_conn->sqlite3_db_conn, sqlite3_config_str,      \
-                           NULL, NULL, NULL);                                  \
-        if (ret != SQLITE_OK) {                                                \
-            gf_msg(GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED,      \
-                   "Failed executing: %s : %s", sqlite3_config_str,            \
-                   sqlite3_errmsg(sql_conn->sqlite3_db_conn));                 \
-            ret = -1;                                                          \
-            goto error;                                                        \
-        };                                                                     \
-    } while (0)
-
-/************************SQLITE3 PARAMS KEYS***********************************/
-#define GFDB_SQL_PARAM_DBPATH "sql-db-path"
-#define GFDB_SQL_PARAM_CACHE_SIZE "sql-db-cachesize"
-#define GFDB_SQL_PARAM_PAGE_SIZE "sql-db-pagesize"
-#define GFDB_SQL_PARAM_JOURNAL_MODE "sql-db-journalmode"
-#define GFDB_SQL_PARAM_WAL_AUTOCHECK "sql-db-wal-autocheckpoint"
-#define GFDB_SQL_PARAM_SYNC "sql-db-sync"
-#define GFDB_SQL_PARAM_AUTO_VACUUM "sql-db-autovacuum"
-
-#define GF_SQL_DEFAULT_DBPATH ""
-#define GF_SQL_DEFAULT_PAGE_SIZE "4096"
-#define GF_SQL_DEFAULT_CACHE_SIZE "12500"
-#define GF_SQL_DEFAULT_WAL_AUTOCHECKPOINT "25000"
-#define GF_SQL_DEFAULT_JOURNAL_MODE GF_SQL_JM_WAL
-#define GF_SQL_DEFAULT_SYNC GF_SQL_SYNC_OFF
-#define GF_SQL_DEFAULT_AUTO_VACUUM GF_SQL_AV_NONE
-
-/* Defines the indexs for sqlite params
- * The order should be maintained*/
-typedef enum sqlite_param_index {
-    sql_dbpath_ix = 0,
-    sql_pagesize_ix,
-    sql_cachesize_ix,
-    sql_journalmode_ix,
-    sql_walautocheck_ix,
-    sql_dbsync_ix,
-    sql_autovacuum_ix,
-    /*This should be in the end*/
-    sql_index_max
-} sqlite_param_index_t;
-
-/* Array to hold the sqlite param keys
- * The order should be maintained as sqlite_param_index_t*/
-static char *sqlite_params_keys[] = {
-    GFDB_SQL_PARAM_DBPATH,        GFDB_SQL_PARAM_PAGE_SIZE,
-    GFDB_SQL_PARAM_CACHE_SIZE,    GFDB_SQL_PARAM_JOURNAL_MODE,
-    GFDB_SQL_PARAM_WAL_AUTOCHECK, GFDB_SQL_PARAM_SYNC,
-    GFDB_SQL_PARAM_AUTO_VACUUM};
-
-/* Array of default values for sqlite params
- * The order should be maintained as sqlite_param_index_t*/
-static char *sqlite_params_default_value[] = {GF_SQL_DEFAULT_DBPATH,
-                                              GF_SQL_DEFAULT_PAGE_SIZE,
-                                              GF_SQL_DEFAULT_CACHE_SIZE,
-                                              GF_SQL_DEFAULT_JOURNAL_MODE,
-                                              GF_SQL_DEFAULT_WAL_AUTOCHECKPOINT,
-                                              GF_SQL_DEFAULT_SYNC,
-                                              GF_SQL_DEFAULT_AUTO_VACUUM};
-
-/*Extract sql params from page_size to auto_vacumm
- * The dbpath is extracted in a different way*/
-static inline int
-gfdb_set_sql_params(char *comp_name, dict_t *from_dict, dict_t *to_dict)
-{
-    sqlite_param_index_t sql_index = sql_pagesize_ix;
-    char *_val_str = NULL;
-    int ret = -1;
-
-    GF_ASSERT(comp_name);
-    GF_ASSERT(from_dict);
-    GF_ASSERT(to_dict);
-
-    /*Extract and Set of the sql params from page_size*/
-    for (sql_index = sql_pagesize_ix; sql_index < sql_index_max; sql_index++) {
-        _val_str = NULL;
-        GET_DB_PARAM_FROM_DICT_DEFAULT(comp_name, from_dict,
-                                       sqlite_params_keys[sql_index], _val_str,
-                                       sqlite_params_default_value[sql_index]);
-        SET_DB_PARAM_TO_DICT(comp_name, to_dict, sqlite_params_keys[sql_index],
-                             _val_str, ret, out);
-    }
-out:
-    return ret;
-}
-
-/*************************SQLITE3 GFDB PLUGINS*********************************/
-
-/*Db init and fini modules*/
-int
-gf_sqlite3_fini(void **db_conn);
-int
-gf_sqlite3_init(dict_t *args, void **db_conn);
-
-/*insert/update/delete modules*/
-int
-gf_sqlite3_insert(void *db_conn, gfdb_db_record_t *);
-int
-gf_sqlite3_delete(void *db_conn, gfdb_db_record_t *);
-
-/*querying modules*/
-int
-gf_sqlite3_find_all(void *db_conn, gf_query_callback_t, void *_query_cbk_args,
-                    int query_limit);
-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);
-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);
-int
-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 write_freq_cnt, int read_freq_cnt,
-                                        gf_boolean_t clear_counters);
-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 write_freq_cnt, int read_freq_cnt,
-    gf_boolean_t clear_counters);
-
-int
-gf_sqlite3_clear_files_heat(void *db_conn);
-
-/* Function to extract version of sqlite db
- * Input:
- * void *db_conn        : Sqlite connection
- * char **version  : the version is extracted as a string and will be stored in
- *                   this variable. The freeing of the memory should be done by
- *                   the caller.
- * Return:
- *      On success return the length of the version string that is
- *      extracted.
- *      On failure return -1
- * */
-int
-gf_sqlite3_version(void *db_conn, char **version);
-
-/* Function to extract PRAGMA or setting from sqlite db
- * Input:
- * void *db_conn        : Sqlite connection
- * char *pragma_key     : PRAGMA or setting to be extracted
- * char **pragma_value  : the value of the PRAGMA or setting that is
- *                        extracted. This function will allocate memory
- *                        to pragma_value. The caller should free the memory
- * Return:
- *      On success return the length of the pragma/setting value that is
- *      extracted.
- *      On failure return -1
- * */
-int
-gf_sqlite3_pragma(void *db_conn, char *pragma_key, char **pragma_value);
-
-/* Function to set PRAGMA to sqlite db
- * Input:
- * void *db_conn        : Sqlite connection
- * char *pragma_key     : PRAGMA to be set
- * char *pragma_value   : the value of the PRAGMA
- * Return:
- *      On success return 0
- *      On failure return -1
- * */
-int
-gf_sqlite3_set_pragma(void *db_conn, char *pragma_key, char *pragma_value);
-
-/* Function to vacuum of sqlite db
- * Input:
- * void *db_conn                      : Sqlite connection
- * gf_boolean_t compact_active        : Is compaction on?
- * gf_boolean_t compact_mode_switched : Did we just flip the compaction switch?
- * Return:
- *      On success return 0
- *      On failure return -1
- * */
-int
-gf_sqlite3_vacuum(void *db_conn, gf_boolean_t compact_active,
-                  gf_boolean_t compact_mode_switched);
-
-void
-gf_sqlite3_fill_db_operations(gfdb_db_operations_t *gfdb_db_ops);
-
-#endif
diff --git a/libglusterfs/src/gfdb/gfdb_sqlite3_helper.c b/libglusterfs/src/gfdb/gfdb_sqlite3_helper.c
deleted file mode 100644
index 60dd5e25e66..00000000000
--- a/libglusterfs/src/gfdb/gfdb_sqlite3_helper.c
+++ /dev/null
@@ -1,1260 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-
-#include "gfdb_sqlite3_helper.h"
-
-#define GFDB_SQL_STMT_SIZE 256
-
-/*****************************************************************************
- *
- *                 Helper function to execute actual sql queries
- *
- *
- * ****************************************************************************/
-
-static int
-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;
-    }
-
-out:
-    /*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)
-{
-    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;
-}
-
-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)
-{
-    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;
-}
-
-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)
-{
-    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;
-}
-
-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)
-{
-    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;
-}
-
-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)
-{
-    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;
-}
-
-/*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)
-{
-    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
-                                " 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;
-out:
-    /*Free prepared statement*/
-    sqlite3_finalize(update_stmt);
-    return ret;
-}
-
-/******************************************************************************
- *
- *                      Helper functions for gf_sqlite3_insert()
- *
- *
- * ****************************************************************************/
-
-int
-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);
-
-    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;
-        }
-
-        /* 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;
-                }
-                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;
-            }
-        }
-    }
-
-    /* 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;
-out:
-    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)
-{
-    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;
-        }
-    }
-
-    /*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 = 0;
-out:
-    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)
-{
-    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;
-out:
-    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)
-{
-    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;
-        }
-
-        /* 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;
-
-        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");
-        goto out;
-    }
-    ret = 0;
-out:
-    GF_FREE(gfid_str);
-    GF_FREE(pargfid_str);
-    return ret;
-}
-
-/******************************************************************************
- *
- *                      Find/Query helper functions
- *
- * ****************************************************************************/
-int
-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;
-        }
-    }
-
-    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;
-out:
-    gfdb_query_record_free(query_record);
-    query_record = NULL;
-    return ret;
-}
-
-int
-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;
-out:
-    return ret;
-}
diff --git a/libglusterfs/src/gfdb/gfdb_sqlite3_helper.h b/libglusterfs/src/gfdb/gfdb_sqlite3_helper.h
deleted file mode 100644
index f19344a353c..00000000000
--- a/libglusterfs/src/gfdb/gfdb_sqlite3_helper.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
-   Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
-   This file is part of GlusterFS.
-
-   This file is licensed to you under your choice of the GNU Lesser
-   General Public License, version 3 or any later version (LGPLv3 or
-   later), or the GNU General Public License, version 2 (GPLv2), in all
-   cases as published by the Free Software Foundation.
-*/
-#ifndef __GFDB_SQLITE3_HELPER_H
-#define __GFDB_SQLITE3_HELPER_H
-
-#include "gfdb_sqlite3.h"
-
-/******************************************************************************
- *
- *                      Helper functions for gf_sqlite3_insert()
- *
- * ****************************************************************************/
-
-int
-gf_sql_insert_wind(gf_sql_connection_t *sql_conn,
-                   gfdb_db_record_t *gfdb_db_record);
-
-int
-gf_sql_insert_unwind(gf_sql_connection_t *sql_conn,
-                     gfdb_db_record_t *gfdb_db_record);
-
-int
-gf_sql_update_delete_wind(gf_sql_connection_t *sql_conn,
-                          gfdb_db_record_t *gfdb_db_record);
-
-int
-gf_sql_delete_unwind(gf_sql_connection_t *sql_conn,
-                     gfdb_db_record_t *gfdb_db_record);
-
-/******************************************************************************
- *
- *                      Find/Query helper functions
- *
- * ****************************************************************************/
-
-int
-gf_sql_query_function(sqlite3_stmt *prep_stmt,
-                      gf_query_callback_t query_callback,
-                      void *_query_cbk_args);
-
-int
-gf_sql_clear_counters(gf_sql_connection_t *sql_conn);
-
-#endif
diff --git a/libglusterfs/src/glusterfs/mem-types.h b/libglusterfs/src/glusterfs/mem-types.h
index 832f68c968e..36cf7820ad5 100644
--- a/libglusterfs/src/glusterfs/mem-types.h
+++ b/libglusterfs/src/glusterfs/mem-types.h
@@ -101,11 +101,6 @@ enum gf_common_mem_types_ {
     gf_common_mt_dnscache_entry,     /* used only in one location */
     gf_common_mt_parser_t,           /* used only in one location */
     gf_common_quota_meta_t,
-    /*related to gfdb library*/
-    gf_mt_gfdb_link_info_t, /* used only in one location */
-    gf_mt_sql_connection_t, /* used only in one location */
-    gf_mt_db_conn_node_t,   /* used only in one location */
-    /*related to gfdb library*/
     gf_common_mt_rbuf_t,  /* used only in one location */
     gf_common_mt_rlist_t, /* used only in one location */
     gf_common_mt_rvec_t,  /* used only in one location */
diff --git a/libglusterfs/src/tier-ctr-interface.h b/libglusterfs/src/tier-ctr-interface.h
deleted file mode 100644
index 19680aa3bea..00000000000
--- a/libglusterfs/src/tier-ctr-interface.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef _TIER_CTR_INTERFACE_H_
-#define _TIER_CTR_INTERFACE_H_
-
-#include "glusterfs/common-utils.h"
-#include "gfdb_data_store_types.h"
-
-#define GFDB_IPC_CTR_KEY "gfdb.ipc-ctr-op"
-
-/*
- * CTR IPC OPERATIONS
- *
- *
- */
-#define GFDB_IPC_CTR_QUERY_OPS "gfdb.ipc-ctr-query-op"
-#define GFDB_IPC_CTR_CLEAR_OPS "gfdb.ipc-ctr-clear-op"
-#define GFDB_IPC_CTR_GET_DB_PARAM_OPS "gfdb.ipc-ctr-get-db-parm"
-#define GFDB_IPC_CTR_GET_DB_VERSION_OPS "gfdb.ipc-ctr-get-db-version"
-#define GFDB_IPC_CTR_SET_COMPACT_PRAGMA "gfdb.ipc-ctr-set-compact-pragma"
-/*
- * CTR IPC INPUT/OUTPUT
- *
- *
- */
-#define GFDB_IPC_CTR_GET_QFILE_PATH "gfdb.ipc-ctr-get-qfile-path"
-#define GFDB_IPC_CTR_GET_QUERY_PARAMS "gfdb.ipc-ctr-get-query-parms"
-#define GFDB_IPC_CTR_RET_QUERY_COUNT "gfdb.ipc-ctr-ret-rec-count"
-#define GFDB_IPC_CTR_GET_DB_KEY "gfdb.ipc-ctr-get-params-key"
-#define GFDB_IPC_CTR_RET_DB_VERSION "gfdb.ipc-ctr-ret-db-version"
-
-/*
- * gfdb ipc ctr params for query
- *
- *
- */
-typedef struct gfdb_ipc_ctr_params {
-    gf_boolean_t is_promote;
-    int write_freq_threshold;
-    int read_freq_threshold;
-    gfdb_time_t time_stamp;
-    int query_limit;
-    gf_boolean_t emergency_demote;
-} gfdb_ipc_ctr_params_t;
-
-#endif