holochain_data 0.7.0-dev.13

Database abstraction layer for Holochain using sqlx
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use sqlx::{Executor, Sqlite};

use crate::models::wasm::{
    CoordinatorZomeModel, DnaDefModel, EntryDefModel, IntegrityZomeModel, WasmModel,
};

/// Check if WASM bytecode exists in the database.
pub(super) async fn wasm_exists<'e, E>(executor: E, hash: &[u8]) -> sqlx::Result<bool>
where
    E: Executor<'e, Database = Sqlite>,
{
    sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM Wasm WHERE hash = ?)")
        .bind(hash)
        .fetch_one(executor)
        .await
}

/// Get WASM bytecode by hash.
pub(super) async fn get_wasm<'e, E>(executor: E, hash: &[u8]) -> sqlx::Result<Option<WasmModel>>
where
    E: Executor<'e, Database = Sqlite>,
{
    sqlx::query_as("SELECT hash, code FROM Wasm WHERE hash = ?")
        .bind(hash)
        .fetch_optional(executor)
        .await
}

/// Check if a DNA definition exists in the database.
pub(super) async fn dna_def_exists<'e, E>(
    executor: E,
    dna_hash: &[u8],
    agent: &[u8],
) -> sqlx::Result<bool>
where
    E: Executor<'e, Database = Sqlite>,
{
    sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM DnaDef WHERE hash = ? AND agent = ?)")
        .bind(dna_hash)
        .bind(agent)
        .fetch_one(executor)
        .await
}

/// Get a single DNA definition row by hash and agent.
pub(super) async fn get_dna_def<'e, E>(
    executor: E,
    dna_hash: &[u8],
    agent: &[u8],
) -> sqlx::Result<Option<DnaDefModel>>
where
    E: Executor<'e, Database = Sqlite>,
{
    sqlx::query_as(
        "SELECT hash, agent, name, network_seed, properties, lineage FROM DnaDef WHERE hash = ? AND agent = ?",
    )
    .bind(dna_hash)
    .bind(agent)
    .fetch_optional(executor)
    .await
}

/// Get all integrity zome rows for a given DNA hash and agent.
pub(super) async fn get_integrity_zomes<'e, E>(
    executor: E,
    dna_hash: &[u8],
    agent: &[u8],
) -> sqlx::Result<Vec<IntegrityZomeModel>>
where
    E: Executor<'e, Database = Sqlite>,
{
    sqlx::query_as(
        "SELECT dna_hash, agent, zome_index, zome_name, wasm_hash, dependencies FROM IntegrityZome WHERE dna_hash = ? AND agent = ? ORDER BY zome_index",
    )
    .bind(dna_hash)
    .bind(agent)
    .fetch_all(executor)
    .await
}

/// Get all coordinator zome rows for a given DNA hash and agent.
pub(super) async fn get_coordinator_zomes<'e, E>(
    executor: E,
    dna_hash: &[u8],
    agent: &[u8],
) -> sqlx::Result<Vec<CoordinatorZomeModel>>
where
    E: Executor<'e, Database = Sqlite>,
{
    sqlx::query_as(
        "SELECT dna_hash, agent, zome_index, zome_name, wasm_hash, dependencies FROM CoordinatorZome WHERE dna_hash = ? AND agent = ? ORDER BY zome_index",
    )
    .bind(dna_hash)
    .bind(agent)
    .fetch_all(executor)
    .await
}

/// Check if an entry definition exists in the database.
pub(super) async fn entry_def_exists<'e, E>(executor: E, key: &[u8]) -> sqlx::Result<bool>
where
    E: Executor<'e, Database = Sqlite>,
{
    sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM EntryDef WHERE key = ?)")
        .bind(key)
        .fetch_one(executor)
        .await
}

/// Get a single entry definition row by key.
pub(super) async fn get_entry_def<'e, E>(
    executor: E,
    key: &[u8],
) -> sqlx::Result<Option<EntryDefModel>>
where
    E: Executor<'e, Database = Sqlite>,
{
    sqlx::query_as(
        "SELECT key, entry_def_id, entry_def_id_type, visibility, required_validations FROM EntryDef WHERE key = ?",
    )
    .bind(key)
    .fetch_optional(executor)
    .await
}

/// Get all entry definition rows.
pub(super) async fn get_all_entry_defs<'e, E>(executor: E) -> sqlx::Result<Vec<EntryDefModel>>
where
    E: Executor<'e, Database = Sqlite>,
{
    sqlx::query_as(
        "SELECT key, entry_def_id, entry_def_id_type, visibility, required_validations FROM EntryDef",
    )
    .fetch_all(executor)
    .await
}

/// Get all DNA definition rows (without zomes).
pub(super) async fn get_all_dna_defs<'e, E>(executor: E) -> sqlx::Result<Vec<DnaDefModel>>
where
    E: Executor<'e, Database = Sqlite>,
{
    sqlx::query_as("SELECT hash, agent, name, network_seed, properties, lineage FROM DnaDef")
        .fetch_all(executor)
        .await
}