@based/db 0.1.3 → 0.1.4

package/dist/lib/linux_aarch64/include/selva/db.h

@@ -0,0 +1,430 @@
+/*
+ * Copyright (c) 2024-2025 SAULX
+ * SPDX-License-Identifier: MIT
+ */
+#pragma once
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include "selva/_export.h"
+#include "selva/types.h"
+
+/*
+ * TODO Don't like this one but it compiles.
+ * We should have something with selva_hash_state;
+ */
+struct XXH3_state_s;
+
+struct selva_dump_common_data {
+    /**
+     * Pointer to data returned here when loading; Data read from here when saving.
+     */
+    const void *meta_data __pcounted_by(meta_len);
+    size_t meta_len;
+
+    /**
+     * Can be nullptr. Also set errlog_size to 0.
+     */
+    char *errlog_buf __pcounted_by(errlog_size);
+    size_t errlog_size;
+};
+
+/**
+ * Create a new DB instance.
+ */
+SELVA_EXPORT
+struct SelvaDb *selva_db_create(void);
+
+/**
+ * Destroy a DB instance.
+ */
+SELVA_EXPORT
+void selva_db_destroy(struct SelvaDb *db) __attribute__((nonnull));
+
+/**
+ * Create a new node type with a schema.
+ * @param type must not exist before.
+ */
+SELVA_EXPORT
+int selva_db_create_type(struct SelvaDb *db, node_type_t type, const uint8_t *schema_buf, size_t schema_len) __attribute__((nonnull));
+
+/**
+ * Save the common/shared data of the database.
+ */
+SELVA_EXPORT
+int selva_dump_save_common(struct SelvaDb *db, struct selva_dump_common_data *com, const char *filename) __attribute__((nonnull));
+
+/**
+ * Save a nodes block starting from start.
+ */
+SELVA_EXPORT
+int selva_dump_save_block(struct SelvaDb *db, struct SelvaTypeEntry *te, const char *filename, node_id_t start, selva_hash128_t *range_hash_out) __attribute__((nonnull));
+
+/**
+ * **Usage:**
+ * ```c
+ * struct SelvaDb *db = selva_db_create();
+ * selva_dump_load_common(db, filename_common);
+ * selva_dump_load_block(db, filename_range_n);
+ *  ```
+ */
+SELVA_EXPORT
+int selva_dump_load_common(struct SelvaDb *db, struct selva_dump_common_data *com, const char *filename) __attribute__((nonnull));
+
+SELVA_EXPORT
+int selva_dump_load_block(struct SelvaDb *db, const char *filename, char *errlog_buf, size_t errlog_size) __attribute__((nonnull));
+
+/**
+ * Find a type by type id.
+ */
+SELVA_EXPORT
+struct SelvaTypeEntry *selva_get_type_by_index(const struct SelvaDb *db, node_type_t type) __attribute__((nonnull));
+
+/**
+ * Get the type for node.
+ */
+SELVA_EXPORT
+struct SelvaTypeEntry *selva_get_type_by_node(const struct SelvaDb *db, struct SelvaNode *node) __attribute__((nonnull, pure));
+
+SELVA_EXPORT
+inline block_id_t selva_get_block_capacity(const struct SelvaTypeEntry *te)
+#ifndef __zig
+{
+    return te->blocks->block_capacity;
+}
+#else
+;
+#endif
+
+inline block_id_t selva_node_id2block_i3(block_id_t block_capacity, node_id_t node_id)
+{
+    assert(node_id > 0);
+    return ((node_id - 1) - ((node_id - 1) % block_capacity)) / block_capacity;
+}
+
+SELVA_EXPORT
+inline block_id_t selva_node_id2block_i(const struct SelvaTypeBlocks *blocks, node_id_t node_id)
+#ifndef __zig
+{
+    return selva_node_id2block_i3(blocks->block_capacity, node_id);
+}
+#else
+;
+#endif
+
+SELVA_EXPORT
+inline block_id_t selva_node_id2block_i2(const struct SelvaTypeEntry *te, node_id_t node_id)
+#ifndef __zig
+{
+    return selva_node_id2block_i(te->blocks, node_id);
+}
+#else
+;
+#endif
+
+/**
+ * Get the node schema for type.
+ */
+SELVA_EXPORT
+__attribute__((nonnull, pure))
+inline const struct SelvaNodeSchema *selva_get_ns_by_te(const struct SelvaTypeEntry *te)
+#ifndef __zig
+{
+    return &te->ns;
+}
+#else
+;
+#endif
+
+SELVA_EXPORT
+inline const struct SelvaFieldSchema *get_fs_by_fields_schema_field(const struct SelvaFieldsSchema *fields_schema, field_t field)
+#ifndef __zig
+{
+    if (!fields_schema || field >= fields_schema->nr_fields) {
+        return nullptr;
+    }
+
+    return &fields_schema->field_schemas[field];
+}
+#else
+;
+#endif
+
+/**
+ * Get the field schema for field.
+ */
+SELVA_EXPORT
+__attribute__((nonnull, pure))
+inline const struct SelvaFieldSchema *selva_get_fs_by_te_field(const struct SelvaTypeEntry *te, field_t field)
+#ifndef __zig
+{
+    return get_fs_by_fields_schema_field(&te->ns.fields_schema, field);
+}
+#else
+;
+#endif
+
+/**
+ * Get the field schema for field.
+ */
+SELVA_EXPORT
+__attribute__((nonnull, pure))
+inline const struct SelvaFieldSchema *selva_get_fs_by_ns_field(const struct SelvaNodeSchema *ns, field_t field)
+#ifndef __zig
+{
+    return get_fs_by_fields_schema_field(&ns->fields_schema, field);
+}
+#else
+;
+#endif
+
+/**
+ * Get the field schema for field.
+ */
+SELVA_EXPORT
+__attribute__((nonnull, pure))
+inline const struct SelvaFieldSchema *selva_get_fs_by_node(struct SelvaDb *db, struct SelvaNode *node, field_t field)
+#ifndef __zig
+{
+    struct SelvaTypeEntry *type;
+
+    type = selva_get_type_by_node(db, node);
+    if (!type) {
+        return nullptr;
+    }
+
+    return selva_get_fs_by_ns_field(&type->ns, field);
+}
+#else
+;
+#endif
+
+SELVA_EXPORT
+#if __has_c_attribute(reproducible)
+[[reproducible]]
+#endif
+inline enum SelvaFieldType selva_get_fs_type(const struct SelvaFieldSchema *fs)
+#ifndef __zig
+{
+    return fs->type;
+}
+#else
+;
+#endif
+
+/**
+ * Get the EdgeFieldConstraint from a ref field schema.
+ * struct EdgeFieldConstraint *efc = selva_get_edge_field_constraint(src_fs);
+ * struct SelvaTypeEntry *dst_type = selva_get_type_by_index(db, efc->dst_node_type);
+ * struct SelvaFieldSchema *dst_fs = selva_get_fs_by_node(db, dst, efc->inverse_field);
+ */
+SELVA_EXPORT
+__attribute__((returns_nonnull))
+__attribute__((nonnull))
+inline const struct EdgeFieldConstraint *selva_get_edge_field_constraint(const struct SelvaFieldSchema *fs)
+#ifndef __zig
+{
+    assert(fs->type == SELVA_FIELD_TYPE_REFERENCE ||
+           fs->type == SELVA_FIELD_TYPE_REFERENCES ||
+           fs->type == SELVA_FIELD_TYPE_WEAK_REFERENCE ||
+           fs->type == SELVA_FIELD_TYPE_WEAK_REFERENCES);
+    return &fs->edge_constraint;
+}
+#else
+;
+#endif
+
+SELVA_EXPORT
+inline const struct SelvaFieldsSchema *selva_get_edge_field_fields_schema(struct SelvaDb *db, const struct EdgeFieldConstraint *efc)
+#ifndef __zig
+{
+    struct SelvaTypeEntry *te = selva_get_type_by_index(db, efc->meta_node_type);
+
+    return (te) ? &selva_get_ns_by_te(te)->fields_schema : nullptr;
+}
+#else
+;
+#endif
+
+SELVA_EXPORT
+void selva_expire_node(struct SelvaDb *db, node_type_t type, node_id_t node_id, int64_t ts);
+
+SELVA_EXPORT
+void selva_expire_node_cancel(struct SelvaDb *db, node_type_t type, node_id_t node_id);
+
+SELVA_EXPORT
+void selva_db_expire_tick(struct SelvaDb *db, selva_dirty_node_cb_t dirty_cb, void *dirty_ctx, int64_t now);
+
+/**
+ * Delete a node.
+ * @param dirty_cb is called for any newly dirty nodes in addition to the node being deleted.
+ */
+SELVA_EXPORT
+void selva_del_node(struct SelvaDb *db, struct SelvaTypeEntry *type, struct SelvaNode *node, selva_dirty_node_cb_t dirty_cb, void *dirty_ctx) __attribute__((nonnull(1, 2, 3)));
+
+SELVA_EXPORT
+void selva_del_block(struct SelvaDb *db, struct SelvaTypeEntry *te, node_id_t start);
+
+/**
+ * Get a node by id.
+ */
+SELVA_EXPORT
+struct SelvaNode *selva_find_node(struct SelvaTypeEntry *type, node_id_t node_id) __attribute__((nonnull));
+
+/**
+ * Find the first node greater than or equal to the provided id, or NULL.
+ */
+SELVA_EXPORT
+struct SelvaNode *selva_nfind_node(struct SelvaTypeEntry *type, node_id_t node_id) __attribute__((nonnull));
+
+/**
+ * Get or create a node by id.
+ */
+SELVA_EXPORT
+struct SelvaNode *selva_upsert_node(struct SelvaTypeEntry *type, node_id_t node_id) __attribute__((nonnull));
+
+/**
+ * **Example**
+ * ```c
+ * for (struct SelvaNode *np = selva_min_node(type); np; np = selva_next_node(type, np))
+ * ```
+ */
+SELVA_EXPORT
+struct SelvaNode *selva_min_node(struct SelvaTypeEntry *type) __attribute__((nonnull));
+
+/**
+ * **Example**
+ * ```c
+ * for (struct SelvaNode *np = selva_max_node(type); np; np = selva_prev_node(type, np))
+ * ```
+ */
+SELVA_EXPORT
+struct SelvaNode *selva_max_node(struct SelvaTypeEntry *type) __attribute__((nonnull));
+
+/**
+ * Get previous node with a lower node id.
+ */
+SELVA_EXPORT
+struct SelvaNode *selva_prev_node(struct SelvaTypeEntry *type, struct SelvaNode *node) __attribute__((nonnull));
+
+/**
+ * Get next node with higher node id.
+ */
+SELVA_EXPORT
+struct SelvaNode *selva_next_node(struct SelvaTypeEntry *type, struct SelvaNode *node) __attribute__((nonnull));
+
+/**
+ * Total count of nodes of type.
+ */
+SELVA_EXPORT
+size_t selva_node_count(const struct SelvaTypeEntry *type) __attribute__((nonnull));
+
+/**
+ * Get the node id of of node.
+ */
+SELVA_EXPORT
+__attribute__((nonnull, pure))
+inline node_id_t selva_get_node_id(const struct SelvaNode *node)
+#ifndef __zig
+{
+    return node->node_id;
+}
+#else
+;
+#endif
+
+/**
+ * Get the type of of node.
+ */
+SELVA_EXPORT
+__attribute__((nonnull, pure))
+inline node_type_t selva_get_node_type(const struct SelvaNode *node)
+#ifndef __zig
+{
+    return node->type;
+}
+#else
+;
+#endif
+
+/**
+ * \addtogroup node_hash
+ * @{
+ */
+
+/**
+ * Calculate the node hash.
+ * Update node hash by using a temp hash state allocated earlier.
+ * @param tmp_hash_state is only used for computation and it's reset before use.
+ */
+SELVA_EXPORT
+selva_hash128_t selva_node_hash_update(struct SelvaDb *db, struct SelvaTypeEntry *type, struct SelvaNode *node, struct XXH3_state_s *tmp_hash_state);
+
+SELVA_EXPORT
+selva_hash128_t selva_node_hash(struct SelvaDb *db, struct SelvaTypeEntry *type, struct SelvaNode *node);
+
+SELVA_EXPORT
+int selva_node_hash_range(struct SelvaDb *db, struct SelvaTypeEntry *type, node_id_t start, node_id_t end, selva_hash128_t *hash_out) __attribute__((nonnull, warn_unused_result));
+
+/**
+ * @}
+ */
+
+/**
+ * Get the number of aliases under given type.
+ */
+SELVA_EXPORT
+size_t selva_alias_count(const struct SelvaAliases *aliases);
+
+/**
+ * Set new alias.
+ * @param name is copied.
+ * @returns the previous node_id the alias was pointing to; Otherwise 0.
+ */
+SELVA_EXPORT
+node_id_t selva_set_alias(struct SelvaAliases *aliases, node_id_t dest, const char *name_str, size_t name_len);
+
+/**
+ * Delete alias by name.
+ * @return the destination node_id the alias was pointing to; 0 if SELVA_ENOENT.
+ */
+SELVA_EXPORT
+node_id_t selva_del_alias_by_name(struct SelvaAliases *aliases, const char *name_str, size_t name_len);
+
+/**
+ * Delete all aliases pointing to dest.
+ */
+SELVA_EXPORT
+void selva_del_alias_by_dest(struct SelvaAliases *aliases, node_id_t dest);
+
+/**
+ * Get alias by name.
+ */
+SELVA_EXPORT
+struct SelvaNode *selva_get_alias(struct SelvaTypeEntry *type, struct SelvaAliases *aliases, const char *name_str, size_t name_len);
+
+/**
+ * Get alias by destination id.
+ * This may not seem very useful but this is actually the way that allows you to
+ * traverse all aliases to the given node_id by following the `next` pointer or
+ * by calling selva_get_next_alias().
+ */
+SELVA_EXPORT
+const struct SelvaAlias *selva_get_alias_by_dest(struct SelvaAliases *aliases, node_id_t dest);
+
+SELVA_EXPORT
+const struct SelvaAlias *selva_get_next_alias(const struct SelvaAlias *alias);
+
+SELVA_EXPORT
+const char *selva_get_alias_name(const struct SelvaAlias *alias, size_t *len) __attribute__((nonnull, pure));
+
+SELVA_EXPORT
+struct SelvaAliases *selva_get_aliases(struct SelvaTypeEntry *type, field_t field);
+
+/***
+ * Remove all aliases to the given node_id.
+ */
+SELVA_EXPORT
+void selva_remove_all_aliases(struct SelvaTypeEntry *type, node_id_t node_id);

package/dist/lib/linux_aarch64/include/selva/endian.h

@@ -0,0 +1,301 @@
+/*
+ * Copyright (c) 2022-2024 SAULX
+ * SPDX-License-Identifier: MIT
+ */
+#pragma once
+#ifndef _SELVA_ENDIAN_H_
+#define _SELVA_ENDIAN_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+/*
+ * NOTICE
+ * This header conflicts with `endian.h` on Linux/glibc and gets included at
+ * least by `sys/types.h`. This is not a big problem because we implement the
+ * same functionality + some extras.
+ * The original header could be included with `#include_next`. Isn't it pretty
+ * stupid that we can override system headers included by system headers in
+ * this way?
+ */
+
+_Static_assert(sizeof(double) == 8, "Only 64bit doubles are supported");
+
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+
+#ifndef htobe16
+#define htobe16(x) __builtin_bswap16(x)
+#define htole16(x) (x)
+#define be16toh(x) __builtin_bswap16(x)
+#define le16toh(x) (x)
+#endif
+
+#ifndef htobe32
+#define htobe32(x) __builtin_bswap32(x)
+#define htole32(x) (x)
+#define be32toh(x) __builtin_bswap32(x)
+#define le32toh(x) (x)
+#endif
+
+#ifndef htobe64
+#define htobe64(x) __builtin_bswap64(x)
+#define htole64(x) (x)
+#define be64toh(x) __builtin_bswap64(x)
+#define le64toh(x) (x)
+#endif
+
+static inline void htoledouble(char buf[8], double x) {
+#if __FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__
+    /*
+     * x: 4 5 6 7  0 1 2 3
+     *    0 1 2 3  4 5 6 7
+     */
+    char s[8];
+
+    __builtin_memcpy(s, &x, 8);
+    buf[0] = s[4];
+    buf[1] = s[5];
+    buf[2] = s[6];
+    buf[3] = s[7];
+    buf[4] = s[0];
+    buf[5] = s[1];
+    buf[6] = s[2];
+    buf[7] = s[3];
+#else
+    __builtin_memcpy(buf, &x, 8);
+#endif
+}
+
+static inline double ledoubletoh(const char buf[8]) {
+#if __FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__
+    char s[8];
+    double x;
+
+    s[0] = buf[4];
+    s[1] = buf[5];
+    s[2] = buf[6];
+    s[3] = buf[7];
+    s[4] = buf[0];
+    s[5] = buf[1];
+    s[6] = buf[2];
+    s[7] = buf[3];
+
+    __builtin_memcpy(&x, s, sizeof(double));
+    return x;
+#else
+    double x;
+
+    __builtin_memcpy(&x, buf, sizeof(double));
+
+    return x;
+#endif
+}
+
+#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+
+#ifndef htobe16
+#define htobe16(x) (x)
+#define htole16(x) __builtin_bswap16(x)
+#define be16toh(x) (x)
+#define le16toh(x) __builtin_bswap16(x)
+#endif
+
+#ifndef htobe32
+#define htobe32(x) (x)
+#define htole32(x) __builtin_bswap32(x)
+#define be32toh(x) (x)
+#define le32toh(x) __builtin_bswap32(x)
+#endif
+
+#ifndef htobe64
+#define htobe64(x) (x)
+#define htole64(x) __builtin_bswap64(x)
+#define be64toh(x) (x)
+#define le64toh(x) __builtin_bswap64(x)
+#endif
+
+static inline void htoledouble(char buf[8], double x) {
+#if __FLOAT_WORD_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    /*
+     * x: 3 2 1 0  7 6 5 4
+     * s: 0 1 2 3  4 5 6 7
+     */
+    char s[8];
+
+    __builtin_memcpy(s, &x, 8);
+    buf[0] = s[3];
+    buf[1] = s[2];
+    buf[2] = s[1];
+    buf[3] = s[0];
+    buf[4] = s[7];
+    buf[5] = s[6];
+    buf[6] = s[5];
+    buf[7] = s[4];
+#else
+    /*
+     * x: 7 6 5 4  3 2 1 0
+     * s: 0 1 2 3  4 5 6 7
+     */
+    char s[8];
+
+    __builtin_memcpy(s, &x, 8);
+    buf[0] = s[7];
+    buf[1] = s[6];
+    buf[2] = s[5];
+    buf[3] = s[4];
+    buf[4] = s[3];
+    buf[5] = s[2];
+    buf[6] = s[1];
+    buf[7] = s[0];
+#endif
+}
+
+static inline double ledoubletoh(const char buf[8]) {
+    char s[8];
+    double x;
+
+#if __FLOAT_WORD_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    s[0] = buf[3];
+    s[1] = buf[2];
+    s[2] = buf[1];
+    s[3] = buf[0];
+    s[4] = buf[7];
+    s[5] = buf[6];
+    s[6] = buf[5];
+    s[7] = buf[4];
+#else
+    s[0] = buf[7];
+    s[1] = buf[6];
+    s[2] = buf[5];
+    s[3] = buf[4];
+    s[4] = buf[3];
+    s[5] = buf[2];
+    s[6] = buf[1];
+    s[7] = buf[0];
+#endif
+
+    __builtin_memcpy(&x, s, sizeof(double));
+    return x;
+}
+
+#else
+#error "Machine byte order not supported"
+#endif
+
+#if __linux__
+
+/**
+ * Type generic Host to BE.
+ */
+#define htobe(v) _Generic((v), \
+        uint16_t: htobe16(v), \
+        int16_t: (int16_t)htobe16(v), \
+        uint32_t: htobe32(v), \
+        int32_t: (int32_t)htobe32(v), \
+        uint64_t: htobe64(v), \
+        int64_t: (int64_t)htobe64(v), \
+        unsigned long long: (unsigned long long)htobe64(v), \
+        long long: (int64_t)htobe64(v))
+
+/**
+ * Type generic Host to LE.
+ */
+#define htole(v) _Generic((v), \
+        uint16_t: htole16(v), \
+        int16_t: (int16_t)htole16(v), \
+        uint32_t: htole32(v), \
+        int32_t: (int32_t)htole32(v), \
+        uint64_t: htole64(v), \
+        int64_t: (int64_t)htole64(v), \
+        unsigned long long: (unsigned long long)htole64(v), \
+        long long: (int64_t)htole64(v))
+
+/**
+ * Type generic LE to Host.
+ */
+#define letoh(v) _Generic((v), \
+        uint16_t: le16toh(v), \
+        int16_t: (int16_t)le16toh(v), \
+        uint32_t: le32toh(v), \
+        int32_t: (int32_t)le32toh(v), \
+        uint64_t: le64toh(v), \
+        int64_t: (int64_t)le64toh(v), \
+        unsigned long long: (unsigned long long)le64toh(v), \
+        long long: (int64_t)le64toh(v))
+
+/**
+ * Type generic BE to Host.
+ */
+#define betoh(v) _Generic((v), \
+        uint16_t: be16toh(v), \
+        int16_t: (int16_t)be16toh(v), \
+        uint32_t: be32toh(v), \
+        int32_t: (int32_t)be32toh(v), \
+        uint64_t: be64toh(v), \
+        int64_t: (int64_t)be64toh(v), \
+        unsigned long long: (unsigned long long)be64toh(v), \
+        long long: (int64_t)be64toh(v))
+
+/* 128-bit machines not supported atm. */
+static_assert(sizeof(long long) == sizeof(uint64_t));
+
+#else
+
+/**
+ * Type generic Host to BE.
+ */
+#define htobe(v) _Generic((v), \
+        uint16_t: htobe16(v), \
+        int16_t: (int16_t)htobe16(v), \
+        uint32_t: htobe32(v), \
+        int32_t: (int32_t)htobe32(v), \
+        uint64_t: htobe64(v), \
+        size_t: htobe64(v), \
+        ssize_t: htobe64(v), \
+        int64_t: (int64_t)htobe64(v))
+
+/**
+ * Type generic Host to LE.
+ */
+#define htole(v) _Generic((v), \
+        uint16_t: htole16(v), \
+        int16_t: (int16_t)htole16(v), \
+        uint32_t: htole32(v), \
+        int32_t: (int32_t)htole32(v), \
+        uint64_t: htole64(v), \
+        size_t: htole64(v), \
+        ssize_t: htole64(v), \
+        int64_t: (int64_t)htole64(v))
+
+/**
+ * Type generic LE to Host.
+ */
+#define letoh(v) _Generic((v), \
+        uint16_t: le16toh(v), \
+        int16_t: (int16_t)le16toh(v), \
+        uint32_t: le32toh(v), \
+        int32_t: (int32_t)le32toh(v), \
+        uint64_t: le64toh(v), \
+        size_t: le64toh(v), \
+        ssize_t: le64toh(v), \
+        int64_t: (int64_t)le64toh(v))
+
+/**
+ * Type generic BE to Host.
+ */
+#define betoh(v) _Generic((v), \
+        uint16_t: be16toh(v), \
+        int16_t: (int16_t)be16toh(v), \
+        uint32_t: be32toh(v), \
+        int32_t: (int32_t)be32toh(v), \
+        uint64_t: be64toh(v), \
+        size_t: be64toh(v), \
+        ssize_t: be64toh(v), \
+        int64_t: (int64_t)be64toh(v))
+
+#endif
+
+/* If this fails then htole and letoh will need some adjustment. */
+static_assert(sizeof(size_t) == sizeof(uint64_t));
+
+#endif /* _SELVA_ENDIAN_H_ */