lsup_rdf/include/store_mdb.h

/** @file store_mdb.h
 *
 * @brief LMDB graph store backend.
 *
 * This module stores triples in a LMDB embedded store, optionally organized
 * into named graphs. The store is optimized and indexed for fast lookup of any
 * number of bound terms.
 *
 * The store must be first initialized once, to create the environment files
 * and folders as well as the internal databases, then it must be opened once
 * per session. Within that session multiple R/W operations can be performed
 * using transactions.
 *
 * Note that, even though the terms "graph", "context", etc. are used, no code
 * in this module checks for valid RDF data. In theory any term can be any
 * binary data. This allows using the store for non-RDF graph data.
 *
 * TODO more doc
 */


#ifndef _LSUP_STORE_MDB_H
#define _LSUP_STORE_MDB_H

#include "lmdb.h"
#include "triple.h"

typedef char DbLabel[8];
typedef struct MDBStore LSUP_MDBStore;
typedef struct MDBIterator LSUP_MDBIterator;

typedef LSUP_rc (*store_match_fn_t)(const LSUP_TripleKey spok, void *data);

// TODO Introduce compile-time LSUP_BIG_STORE option to define two store
// options: false: 64-bit hashes, uint32 keys, max 4G entries; true:
// 128-bit hashes, size_t keys, max MAX_SIZE entries, larger and slower.
// Ideally this could be specified at runtime to handle different stores with
// different sizes, but code could become more complex.


/** @brief Create the MDB environment and databases on disk.
 *
 * This function takes care of creaating the environment path if not existing,
 * and checking that it's a writable directory. If the path is not specified
 * in the LSUP_STORE_PATH environment variable, a default directory is used.
 *
 * TODO Add clear parameter.
 *
 * @param[in,out] path Path of the suggested directory to use. It may be NULL,
 *  in which case it will be set either to the environment variable
 *  LSUP_STORE_PATH, or if that is not set, a default local path.
 */
LSUP_rc LSUP_mdbstore_setup(char **path/*, bool clear*/);


/** @brief Open an MDB store.
 *
 * The store must have been set up with #LSUP_mdbstore_setup.
 *
 * Some environment variables affect various store parameters:
 *
 * - LSUP_MDB_MAPSIZE Long int specifying the size of the memory map. Usually
 *   it is not necessary to modify this, unless one is operating under memory
 *   and disk constraints. The default map size is 1Tb.
 *
 * @param[in,out] store Uninitialized store struct pointer.
 *
 * @param[in] path MDB environment path. This must be the path given by
 * #LSUP_mdbstore_setup.
 *
 * @param[in] default_ctx Serialized URI to be used as a default context for
 *  triples inserted without a context specified. If NULL, the store operates
 *  in triple mode.
 */
LSUP_MDBStore *
LSUP_mdbstore_new(const char *path, const LSUP_Buffer *default_ctx);


/** @brief Close a store and free its handle.
 *
 * @param[in] store Store pointer.
 *
 */
void LSUP_mdbstore_free(LSUP_MDBStore *store);


/** @brief Print stats about a store and its databases.
 *
 * TODO
 *
 * @param store[in] The store to get stats for.
 */
LSUP_rc LSUP_mdbstore_stats(LSUP_MDBStore *store);


/** @brief Store size.
 *
 * @param store[in] The store to calculate size of.
 *
 * @return Number of stored SPO triples across all contexts.
 */
size_t LSUP_mdbstore_size(LSUP_MDBStore *store);


/** @brief Initialize bulk triple load.
 *
 * This is the first step of a bulk load. It is best used when the data at hand
 * need to be pre-processed, which can be done in the same loop as the next
 * step to keep memory usage low.
 *
 * @param store[in] The store to add to.
 *
 * @param sc[in] Context as a serialized term. If this is NULL, and the
 *  default context is not NULL, triples will be added to the default context
 *  for the store, If the default context for the store is NULL, regardless of
 *  the value of sc, triples will be added with no context.
 *
 * @param it[out] Pointer to an iterator pointer to be passed to the following
 *  load steps.
 */
LSUP_MDBIterator *
LSUP_mdbstore_add_init(LSUP_MDBStore *store, const LSUP_Buffer *sc);


/** @brief Add one triple into the store.
 *
 * This must be called after #LSUP_mdbstore_add_init, using the iterator
 * yielded by that function. It may be called multiple times and must be
 * followed by #LSUP_mdbstore_add_done.
 *
 * @param it[in] Iterator obtained by #LSUP_mdbstore_add_init.
 *
 * @param sspo[in] Serialized triple to be added.
 */
LSUP_rc
LSUP_mdbstore_add_iter(struct MDBIterator *it, const LSUP_SerTriple *sspo);


/** @brief Finalize an add loop.
 *
 * This must be called after #LSUP_mdbstore_add_iter.
 *
 * @param it[in] Iterator obtained by #LSUP_mdbstore_add_init.
 *
 * @param inserted[out] If not NULL this is populated with the number of
 *  triples effectively inserted.
 */
LSUP_rc
LSUP_mdbstore_add_done(LSUP_MDBIterator *it, size_t *inserted);


/** @brief Add a batch of triples with optional context to the store.
 *
 * This is a shortcut for calling #LSUP_mdbstore_add_init,
 * #LSUP_mdbstore_add_iter and #LSUP_mdbstore_add_done in a sequence
 * when an array of pre-serialized triples is available.
 *
 * @param store[in] The store to add to.
 *
 * @param sc[in] Context as a serialized term. If this is NULL, and the
 *  default context is not NULL, triples will be added to the default context
 *  for the store. If the default context for the store is NULL, regardless of
 *  the value of sc, triples will be added with no context.

 * @param data[in] Triples to be inserted as a 2D array of triples in the shape
 * of data[n][3], where n is the value of data_size.
 *
 * @param inserted[out] If not NULL, it will be filled with the count of
 *  effectively inserted triples.
 *
 * @param data_size[in] Number of triples to be inserted.
 */
LSUP_rc LSUP_mdbstore_add(
        struct MDBStore *store, const LSUP_Buffer *sc,
        const LSUP_SerTriple strp[], const size_t ct, size_t *inserted);


LSUP_rc
LSUP_mdbstore_remove(
        LSUP_MDBStore *store, const LSUP_SerTriple *sspo,
        const LSUP_Buffer *sc, size_t *ct);


/** @brief Look up matching triples and optional context.
 *
 * This function may return a count of matches and/or an iterator of results as
 * serialized triples.
 *
 * @param store[in] The store to be queried.
 *
 * @param sspo Serialized triple representing the s, p, o
 * terms. Any and all of these may be NULL, which indicates an unbound query
 * term. Stores with context not set will always ignore the fourth term.
 *
 * @param sc Serialized context to limit search to. It may be NULL, in which
 *  case search is done in all contexts. Note that triples inserted without
 *  context are assigned the *default* context, indicated by the "default_ctx"
 *  member of the store struct.
 *
 * @param it[out] Pointer to a pointer to an #LSUP_MDBIterator that will be
 * populated with a result iterator. This is always created even if no matches
 * are found and must be freed with #LSUP_mdbiter_free after use. If matches
 * are found, the iterator points to the first result which can be retrieved
 * with #LSUP_mdbiter_next.
 *
 * @param ct[out] If not NULL, this will be populated with the number of
 *  entries found. It is very inexpensive to set for lookups without context,
 *  much less so for 1-bound and 2-bound context lookups, in which cases it
 *  should be set only if needed.
 *
 * @return LSUP_OK if entries were found, LSUP_NORESULT if none were found.
 */
LSUP_MDBIterator *
LSUP_mdbstore_lookup(
        LSUP_MDBStore *store, const LSUP_SerTriple *sspo,
        const LSUP_Buffer *sc, size_t *ct);


/** @brief Yield the matching triples and advance the iterator.
 *
 * This function also checks if the matching triple is associated with a
 * context, if one was specified. If no associated contexts are found, the next
 * triple is searched, until the end of the results.
 *
 * NOTE: Iterators keep LMDB cursors and (read only) transactions open. Don't
 * hold on to them longer than necessary.
 *
 * NOTE: The memory pointed to by the individual LSUP_Buffer pointers is
 * owned by the database. It must not be written to or freed. To modify
 * the data or use them beyond the caller's scope, this memory must be copied.
 *
 * @param it[in] Opaque iterator handle obtained with #LSUP_mdbstore_lookup.
 *
 * @param sspo[out] #LSUP_SerTriple to be populated with three serialized terms
 * if found, NULL if not found. Internal callers may pass NULL if they don't
 * need the serialized triples.
 *
 * @return LSUP_OK if results were found; LSUP_END if no (more) results were
 * found; LSUP_DB_ERR if a MDB_* error occurred.
 */
LSUP_rc LSUP_mdbiter_next(LSUP_MDBIterator *it, LSUP_SerTriple *sspo);


/** @brief Free an iterator allocated by a lookup.
 *
 * @param it[in] Iterator pointer. It will be set to NULL after freeing.
 */
void LSUP_mdbiter_free(struct MDBIterator *it);


/** @brief Contexts that a triple key appears in.
 *
 * This function is most conveniently used by a callback to #LSUP_mdbstore_lookup
 * because it handles triple keys.
 *
 * @param store[in] The store to be queried.
 *
 * @param spok[in] Triple key to look up.
 *
 * @param ck[out] Pointer to an array of contexts. Memory is allocated by this
 * function and must be freed by the caller.
 *
 * @param ct[out] Number of contexts found.
 */
LSUP_rc LSUP_mdbstore_triple_contexts(
        LSUP_MDBStore *store, LSUP_Key spok[], LSUP_Key **ck, size_t *ct);

#endif