sqlite_checkpoint.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/graph/checkpoint.h>
#include <chrono>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
 
// Forward-declare so this header doesn't drag the sqlite3 C header
// into every TU that includes it.
struct sqlite3;
 
namespace neograph::graph {
 
class NEOGRAPH_API SqliteCheckpointStore : public CheckpointStore {
public:
    // Called after BEGIN IMMEDIATE has acquired the SQLite writer and before
    // any checkpoint mutation. Throw to roll the transaction back. The guard
    // may inspect this connection but must not start another transaction.
    using WriteGuard = std::function<void(sqlite3*, const std::string& thread_id)>;
    explicit SqliteCheckpointStore(const std::string& db_path);
    SqliteCheckpointStore(const std::string& db_path,
                          std::chrono::milliseconds busy_timeout);
    SqliteCheckpointStore(const std::string& db_path,
                          std::chrono::milliseconds busy_timeout,
                          WriteGuard write_guard);
 
    ~SqliteCheckpointStore() override;
 
    // sqlite3* is a unique resource — no copying or moving.
    SqliteCheckpointStore(const SqliteCheckpointStore&) = delete;
    SqliteCheckpointStore& operator=(const SqliteCheckpointStore&) = delete;
 
    void save(const Checkpoint& cp) override;
    std::optional<Checkpoint> load_latest(const std::string& thread_id) override;
    std::optional<Checkpoint> load_by_id(const std::string& id) override;
    std::vector<Checkpoint> list(const std::string& thread_id,
                                  int limit = 100) override;
    void delete_thread(const std::string& thread_id) override;
 
    void put_writes(const std::string& thread_id,
                    const std::string& parent_checkpoint_id,
                    const PendingWrite& write) override;
    std::vector<PendingWrite> get_writes(
        const std::string& thread_id,
        const std::string& parent_checkpoint_id) override;
    void clear_writes(const std::string& thread_id,
                      const std::string& parent_checkpoint_id) override;
 
    bool requires_managed_budget(const std::string& thread_id) override;
    asio::awaitable<bool> requires_managed_budget_async(std::string thread_id) override;
 
    std::shared_ptr<OwnedManagedBudgetLease> acquire_managed_budget_lease(
        const ManagedBudgetLeaseScope& scope, const std::string& expected_checkpoint_id,
        const std::string& expected_checkpoint_commitment) override;
    asio::awaitable<std::shared_ptr<OwnedManagedBudgetLease>> acquire_managed_budget_lease_async(
        ManagedBudgetLeaseScope scope, std::string expected_checkpoint_id,
        std::string expected_checkpoint_commitment) override;
    ManagedBudgetEffectReceipt begin_managed_budget_effect(
        const std::shared_ptr<OwnedManagedBudgetLease>& lease, const std::string& effect_id,
        std::uint64_t exact_claim_amount, const std::string& prepared_request_digest) override;
    asio::awaitable<ManagedBudgetEffectReceipt> begin_managed_budget_effect_async(
        std::shared_ptr<OwnedManagedBudgetLease> lease, std::string effect_id,
        std::uint64_t exact_claim_amount, std::string prepared_request_digest) override;
    void settle_managed_budget_effect(
        const std::shared_ptr<OwnedManagedBudgetLease>& lease,
        const ManagedBudgetEffectReceipt& effect, sp::runtime::Result genuine_outcome,
        const UsageAccumulator::AuthoritySnapshot& authority) override;
    asio::awaitable<void> settle_managed_budget_effect_async(
        std::shared_ptr<OwnedManagedBudgetLease> lease, ManagedBudgetEffectReceipt effect,
        sp::runtime::Result genuine_outcome, UsageAccumulator::AuthoritySnapshot authority) override;
    void publish_managed_budget_checkpoint(
        const std::shared_ptr<OwnedManagedBudgetLease>& lease, const Checkpoint& checkpoint) override;
    asio::awaitable<void> publish_managed_budget_checkpoint_async(
        std::shared_ptr<OwnedManagedBudgetLease> lease, Checkpoint checkpoint) override;
    void release_managed_budget_lease(
        const std::shared_ptr<OwnedManagedBudgetLease>& lease) override;
    asio::awaitable<void> release_managed_budget_lease_async(
        std::shared_ptr<OwnedManagedBudgetLease> lease) override;
 
    void drop_schema();
 
    size_t blob_count();
 
private:
    void ensure_schema();
    void exec_ddl(const char* sql);
    void save_locked(const Checkpoint& checkpoint);
 
    sqlite3* db_ = nullptr;
    std::mutex db_mutex_;
    WriteGuard write_guard_;
};
 
} // namespace neograph::graph