jbackend.h

Go to the documentation of this file.

/*
 * JULEA - Flexible storage framework
 * Copyright (C) 2017-2024 Michael Kuhn
 * Copyright (C) 2018-2019 Michael Straßberger
 * Copyright (C) 2019 Benjamin Warnke
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef JULEA_BACKEND_H
#define JULEA_BACKEND_H
 
#if !defined(JULEA_H) && !defined(JULEA_COMPILATION)
#error "Only <julea.h> can be included directly."
#endif
 
#include <glib.h>
#include <gmodule.h>
 
#include <bson.h>
 
#include <core/jsemantics.h>
 
G_BEGIN_DECLS
 
#define J_BACKEND_BSON_ERROR j_backend_bson_error_quark()
#define J_BACKEND_DB_ERROR j_backend_db_error_quark()
#define J_BACKEND_SQL_ERROR j_backend_sql_error_quark()
 
enum JBackendBSONError
{
    J_BACKEND_BSON_ERROR_FAILED,
    J_BACKEND_BSON_ERROR_BSON_APPEND_ARRAY_FAILED,
    J_BACKEND_BSON_ERROR_BSON_APPEND_DOCUMENT_FAILED,
    J_BACKEND_BSON_ERROR_BSON_APPEND_FAILED,
    J_BACKEND_BSON_ERROR_BSON_BUF_NULL,
    J_BACKEND_BSON_ERROR_BSON_COUNT_NULL,
    J_BACKEND_BSON_ERROR_BSON_HAS_FIELD_NULL,
    J_BACKEND_BSON_ERROR_BSON_INIT_FROM_JSON_FAILED,
    J_BACKEND_BSON_ERROR_BSON_JSON_NULL,
    J_BACKEND_BSON_ERROR_BSON_NAME_NULL,
    J_BACKEND_BSON_ERROR_BSON_NOT_ENOUGH_KEYS,
    J_BACKEND_BSON_ERROR_BSON_NULL,
    J_BACKEND_BSON_ERROR_BSON_VALUE_NULL,
    J_BACKEND_BSON_ERROR_ITER_EQUALS_NULL,
    J_BACKEND_BSON_ERROR_ITER_HAS_NEXT_NULL,
    J_BACKEND_BSON_ERROR_ITER_INIT,
    J_BACKEND_BSON_ERROR_ITER_INVALID_TYPE,
    J_BACKEND_BSON_ERROR_ITER_KEY_FOUND,
    J_BACKEND_BSON_ERROR_ITER_KEY_NOT_FOUND,
    J_BACKEND_BSON_ERROR_ITER_KEY_NULL,
    J_BACKEND_BSON_ERROR_ITER_NULL,
    J_BACKEND_BSON_ERROR_ITER_RECOURSE,
    J_BACKEND_BSON_ERROR_ITER_TYPE_NULL
};
 
typedef enum JBackendBSONError JBackendBSONError;
 
enum JBackendDBError
{
    J_BACKEND_DB_ERROR_FAILED,
    J_BACKEND_DB_ERROR_COMPARATOR_INVALID,
    J_BACKEND_DB_ERROR_DB_TYPE_INVALID,
    J_BACKEND_DB_ERROR_ITERATOR_INVALID,
    J_BACKEND_DB_ERROR_ITERATOR_NO_MORE_ELEMENTS,
    J_BACKEND_DB_ERROR_NO_VARIABLE_SET,
    J_BACKEND_DB_ERROR_OPERATOR_INVALID,
    J_BACKEND_DB_ERROR_SCHEMA_EMPTY,
    J_BACKEND_DB_ERROR_SCHEMA_NOT_FOUND,
    J_BACKEND_DB_ERROR_SELECTOR_EMPTY,
    J_BACKEND_DB_ERROR_THREADING_ERROR,
    J_BACKEND_DB_ERROR_VARIABLE_NOT_FOUND
};
 
typedef enum JBackendDBError JBackendDBError;
 
enum JBackendSQLError
{
    J_BACKEND_SQL_ERROR_FAILED,
    J_BACKEND_SQL_ERROR_BIND,
    J_BACKEND_SQL_ERROR_CONSTRAINT,
    J_BACKEND_SQL_ERROR_FINALIZE,
    J_BACKEND_SQL_ERROR_INVALID_TYPE,
    J_BACKEND_SQL_ERROR_PREPARE,
    J_BACKEND_SQL_ERROR_RESET,
    J_BACKEND_SQL_ERROR_STEP
};
 
typedef enum JBackendSQLError JBackendSQLError;
 
enum JBackendType
{
    J_BACKEND_TYPE_OBJECT,
    J_BACKEND_TYPE_KV,
    J_BACKEND_TYPE_DB
};
 
typedef enum JBackendType JBackendType;
 
enum JBackendComponent
{
    J_BACKEND_COMPONENT_CLIENT,
    J_BACKEND_COMPONENT_SERVER
};
 
typedef enum JBackendComponent JBackendComponent;
 
enum JBackendFlags
{
    J_BACKEND_FLAGS_DO_NOT_UNLOAD = 1 << 0
};
 
typedef enum JBackendFlags JBackendFlags;
 
struct JBackend
{
    JBackendType type;
    JBackendComponent component;
    JBackendFlags flags;
 
    gpointer data;
 
    union
    {
        struct
        {
            gboolean (*backend_init)(gchar const*, gpointer*);
            void (*backend_fini)(gpointer);
 
            gboolean (*backend_create)(gpointer, gchar const*, gchar const*, gpointer*);
            gboolean (*backend_open)(gpointer, gchar const*, gchar const*, gpointer*);
 
            gboolean (*backend_delete)(gpointer, gpointer);
            gboolean (*backend_close)(gpointer, gpointer);
 
            gboolean (*backend_status)(gpointer, gpointer, gint64*, guint64*);
            gboolean (*backend_sync)(gpointer, gpointer);
 
            gboolean (*backend_read)(gpointer, gpointer, gpointer, guint64, guint64, guint64*);
            gboolean (*backend_write)(gpointer, gpointer, gconstpointer, guint64, guint64, guint64*);
 
            gboolean (*backend_get_all)(gpointer, gchar const*, gpointer*);
            gboolean (*backend_get_by_prefix)(gpointer, gchar const*, gchar const*, gpointer*);
            gboolean (*backend_iterate)(gpointer, gpointer, gchar const**);
        } object;
 
        struct
        {
            gboolean (*backend_init)(gchar const*, gpointer*);
            void (*backend_fini)(gpointer);
 
            gboolean (*backend_batch_start)(gpointer, gchar const*, JSemantics*, gpointer*);
            gboolean (*backend_batch_execute)(gpointer, gpointer);
 
            gboolean (*backend_put)(gpointer, gpointer, gchar const*, gconstpointer, guint32);
            gboolean (*backend_delete)(gpointer, gpointer, gchar const*);
            gboolean (*backend_get)(gpointer, gpointer, gchar const*, gpointer*, guint32*);
 
            gboolean (*backend_get_all)(gpointer, gchar const*, gpointer*);
            gboolean (*backend_get_by_prefix)(gpointer, gchar const*, gchar const*, gpointer*);
            gboolean (*backend_iterate)(gpointer, gpointer, gchar const**, gconstpointer*, guint32*);
        } kv;
 
        struct
        {
            gboolean (*backend_init)(gchar const*, gpointer*);
            void (*backend_fini)(gpointer);
 
            gboolean (*backend_batch_start)(gpointer, gchar const*, JSemantics*, gpointer*, GError**);
            gboolean (*backend_batch_execute)(gpointer, gpointer, GError**);
 
            gboolean (*backend_schema_create)(gpointer, gpointer, gchar const*, bson_t const*, GError**);
 
            gboolean (*backend_schema_get)(gpointer, gpointer, gchar const*, bson_t*, GError**);
 
            gboolean (*backend_schema_delete)(gpointer, gpointer, gchar const*, GError**);
 
            gboolean (*backend_insert)(gpointer, gpointer, gchar const*, bson_t const*, bson_t*, GError**);
 
            gboolean (*backend_update)(gpointer, gpointer, gchar const*, bson_t const*, bson_t const*, GError**);
 
            gboolean (*backend_delete)(gpointer, gpointer, gchar const*, bson_t const*, GError**);
 
            gboolean (*backend_query)(gpointer, gpointer, gchar const*, bson_t const*, gpointer*, GError**);
 
            gboolean (*backend_iterate)(gpointer, gpointer, bson_t*, GError**);
        } db;
    };
};
 
typedef struct JBackend JBackend;
 
GQuark j_backend_bson_error_quark(void);
GQuark j_backend_db_error_quark(void);
GQuark j_backend_sql_error_quark(void);
 
JBackend* backend_info(void);
 
gboolean j_backend_load(gchar const*, JBackendComponent, JBackendType, GModule**, JBackend**);
gboolean j_backend_unload(JBackend*, GModule*);
 
gboolean j_backend_object_init(JBackend*, gchar const*);
void j_backend_object_fini(JBackend*);
 
gboolean j_backend_object_create(JBackend*, gchar const*, gchar const*, gpointer*);
gboolean j_backend_object_open(JBackend*, gchar const*, gchar const*, gpointer*);
 
gboolean j_backend_object_delete(JBackend*, gpointer);
gboolean j_backend_object_close(JBackend*, gpointer);
 
gboolean j_backend_object_status(JBackend*, gpointer, gint64*, guint64*);
gboolean j_backend_object_sync(JBackend*, gpointer);
 
gboolean j_backend_object_read(JBackend*, gpointer, gpointer, guint64, guint64, guint64*);
gboolean j_backend_object_write(JBackend*, gpointer, gconstpointer, guint64, guint64, guint64*);
 
gboolean j_backend_object_get_all(JBackend*, gchar const*, gpointer*);
gboolean j_backend_object_get_by_prefix(JBackend*, gchar const*, gchar const*, gpointer*);
gboolean j_backend_object_iterate(JBackend*, gpointer, gchar const**);
 
gboolean j_backend_kv_init(JBackend*, gchar const*);
void j_backend_kv_fini(JBackend*);
 
gboolean j_backend_kv_batch_start(JBackend*, gchar const*, JSemantics*, gpointer*);
gboolean j_backend_kv_batch_execute(JBackend*, gpointer);
 
gboolean j_backend_kv_put(JBackend*, gpointer, gchar const*, gconstpointer, guint32);
gboolean j_backend_kv_delete(JBackend*, gpointer, gchar const*);
gboolean j_backend_kv_get(JBackend*, gpointer, gchar const*, gpointer*, guint32*);
 
gboolean j_backend_kv_get_all(JBackend*, gchar const*, gpointer*);
gboolean j_backend_kv_get_by_prefix(JBackend*, gchar const*, gchar const*, gpointer*);
gboolean j_backend_kv_iterate(JBackend*, gpointer, gchar const**, gconstpointer*, guint32*);
 
gboolean j_backend_db_init(JBackend*, gchar const*);
void j_backend_db_fini(JBackend*);
 
gboolean j_backend_db_batch_start(JBackend*, gchar const*, JSemantics*, gpointer*, GError**);
gboolean j_backend_db_batch_execute(JBackend*, gpointer, GError**);
 
gboolean j_backend_db_schema_create(JBackend*, gpointer, gchar const*, bson_t const*, GError**);
gboolean j_backend_db_schema_get(JBackend*, gpointer, gchar const*, bson_t*, GError**);
gboolean j_backend_db_schema_delete(JBackend*, gpointer, gchar const*, GError**);
 
gboolean j_backend_db_insert(JBackend*, gpointer, gchar const*, bson_t const*, bson_t*, GError**);
gboolean j_backend_db_update(JBackend*, gpointer, gchar const*, bson_t const*, bson_t const*, GError**);
gboolean j_backend_db_delete(JBackend*, gpointer, gchar const*, bson_t const*, GError**);
 
gboolean j_backend_db_query(JBackend*, gpointer, gchar const*, bson_t const*, gpointer*, GError**);
gboolean j_backend_db_iterate(JBackend*, gpointer, bson_t*, GError**);
 
G_END_DECLS
 
#endif