Skip to main content

cozo/runtime/db/
mod.rs

1/*
2 * Copyright 2022, The Cozo Project Authors.
3 *
4 * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
5 * If a copy of the MPL was not distributed with this file,
6 * You can obtain one at https://mozilla.org/MPL/2.0/.
7 */
8
9mod backup;
10mod eval;
11mod execute;
12mod explain;
13mod import_export;
14mod multi_tx;
15mod named_rows;
16mod registry;
17mod running;
18mod sys_ops;
19
20use std::collections::BTreeMap;
21use std::fmt::{Debug, Formatter};
22#[allow(unused_imports)]
23use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
24use std::sync::{Arc, Mutex};
25
26use crossbeam::sync::ShardedLock;
27use miette::{Diagnostic, Result};
28use smartstring::{LazyCompact, SmartString};
29use thiserror::Error;
30
31use crate::data::functions::current_validity;
32use crate::data::tuple::{Tuple, TupleT};
33use crate::data::value::{DataValue, ValidityTs};
34use crate::fixed_rule::DEFAULT_FIXED_RULES;
35use crate::fts::TokenizerCache;
36use crate::parse::{parse_script, CozoScript};
37#[allow(unused_imports)]
38use crate::runtime::callback::EventCallbackRegistry;
39use crate::runtime::relation::RelationId;
40use crate::runtime::transact::SessionTx;
41use crate::storage::temp::TempStorage;
42use crate::storage::Storage;
43use crate::FixedRule;
44
45// Re-exports: keep the public / crate-level paths identical to the old `db.rs`
46pub use eval::{evaluate_expressions, get_variables};
47pub use named_rows::{NamedRows, Payload, TransactionPayload};
48pub use running::Poison;
49#[allow(unused_imports)]
50pub(crate) use running::{seconds_since_the_epoch, RunningQueryCleanup, RunningQueryHandle};
51
52#[derive(serde_derive::Serialize, serde_derive::Deserialize)]
53pub struct DbManifest {
54    pub storage_version: u64,
55}
56
57/// Whether a script is mutable or immutable.
58#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
59pub enum ScriptMutability {
60    /// The script is mutable.
61    Mutable,
62    /// The script is immutable.
63    Immutable,
64}
65
66/// The database object of Cozo.
67#[derive(Clone)]
68pub struct Db<S> {
69    pub(crate) db: S,
70    temp_db: TempStorage,
71    relation_store_id: Arc<AtomicU64>,
72    pub(crate) queries_count: Arc<AtomicU64>,
73    pub(crate) running_queries: Arc<Mutex<BTreeMap<u64, RunningQueryHandle>>>,
74    pub(crate) fixed_rules: Arc<ShardedLock<BTreeMap<String, Arc<Box<dyn FixedRule>>>>>,
75    pub(crate) tokenizers: Arc<TokenizerCache>,
76    #[cfg(not(target_arch = "wasm32"))]
77    callback_count: Arc<AtomicU32>,
78    #[cfg(not(target_arch = "wasm32"))]
79    pub(crate) event_callbacks: Arc<ShardedLock<EventCallbackRegistry>>,
80    relation_locks: Arc<ShardedLock<BTreeMap<SmartString<LazyCompact>, Arc<ShardedLock<()>>>>>,
81}
82
83impl<S> Debug for Db<S> {
84    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
85        write!(f, "Db")
86    }
87}
88
89#[derive(Debug, Diagnostic, Error)]
90#[error("Initialization of database failed")]
91#[diagnostic(code(db::init))]
92pub(crate) struct BadDbInit(#[help] pub(crate) String);
93
94#[derive(Debug, Error, Diagnostic)]
95#[error("Cannot import data into relation {0} as it is an index")]
96#[diagnostic(code(tx::import_into_index))]
97pub(crate) struct ImportIntoIndex(pub(crate) String);
98
99impl<'s, S: Storage<'s>> Db<S> {
100    /// Create a new database object with the given storage.
101    /// You must call [`initialize`](Self::initialize) immediately after creation.
102    /// Due to lifetime restrictions we are not able to call that for you automatically.
103    pub fn new(storage: S) -> Result<Self> {
104        let ret = Self {
105            db: storage,
106            temp_db: Default::default(),
107            relation_store_id: Default::default(),
108            queries_count: Default::default(),
109            running_queries: Default::default(),
110            fixed_rules: Arc::new(ShardedLock::new(DEFAULT_FIXED_RULES.clone())),
111            tokenizers: Arc::new(Default::default()),
112            #[cfg(not(target_arch = "wasm32"))]
113            callback_count: Default::default(),
114            // callback_receiver: Arc::new(receiver),
115            #[cfg(not(target_arch = "wasm32"))]
116            event_callbacks: Default::default(),
117            relation_locks: Default::default(),
118        };
119        Ok(ret)
120    }
121
122    /// Must be called after creation of the database to initialize the runtime state.
123    pub fn initialize(&'s self) -> Result<()> {
124        self.load_last_ids()?;
125        Ok(())
126    }
127
128    /// This returns the set of fixed rule implementations for this specific backend.
129    pub fn get_fixed_rules(&'s self) -> BTreeMap<String, Arc<Box<dyn FixedRule>>> {
130        return self.fixed_rules.read().unwrap().clone();
131    }
132
133    /// Run the CozoScript passed in. The `params` argument is a map of parameters.
134    pub fn run_script(
135        &'s self,
136        payload: &str,
137        params: BTreeMap<String, DataValue>,
138        mutability: ScriptMutability,
139    ) -> Result<NamedRows> {
140        self.run_script_ast(
141            parse_script(
142                payload,
143                &params,
144                &self.get_fixed_rules(),
145                current_validity(),
146            )?,
147            current_validity(),
148            mutability,
149        )
150    }
151
152    /// Run the CozoScript passed in. The `params` argument is a map of parameters.
153    pub fn run_script_read_only(
154        &'s self,
155        payload: &str,
156        params: BTreeMap<String, DataValue>,
157    ) -> Result<NamedRows> {
158        self.run_script(payload, params, ScriptMutability::Immutable)
159    }
160
161    /// Run the AST CozoScript passed in.
162    pub fn run_script_ast(
163        &'s self,
164        payload: CozoScript,
165        cur_vld: ValidityTs,
166        mutability: ScriptMutability,
167    ) -> Result<NamedRows> {
168        let read_only = mutability == ScriptMutability::Immutable;
169        match payload {
170            CozoScript::Single(p) => self.execute_single(cur_vld, p, read_only),
171            CozoScript::Imperative(ps) => self.execute_imperative(cur_vld, &ps, read_only),
172            CozoScript::Sys(op) => self.run_sys_op(op, read_only),
173        }
174    }
175
176    fn compact_relation(&'s self) -> Result<()> {
177        let l = Tuple::default().encode_as_key(RelationId(0));
178        let u = vec![DataValue::Bot].encode_as_key(RelationId(u64::MAX));
179        self.db.range_compact(&l, &u)?;
180        Ok(())
181    }
182
183    fn load_last_ids(&'s self) -> Result<()> {
184        let mut tx = self.transact_write()?;
185        self.relation_store_id
186            .store(tx.init_storage()?.0, Ordering::Release);
187        tx.commit_tx()?;
188        Ok(())
189    }
190
191    pub(crate) fn transact(&'s self) -> Result<SessionTx<'_>> {
192        let ret = SessionTx {
193            store_tx: Box::new(self.db.transact(false)?),
194            temp_store_tx: self.temp_db.transact(true)?,
195            relation_store_id: self.relation_store_id.clone(),
196            temp_store_id: Default::default(),
197            tokenizers: self.tokenizers.clone(),
198        };
199        Ok(ret)
200    }
201
202    pub(crate) fn transact_write(&'s self) -> Result<SessionTx<'_>> {
203        let ret = SessionTx {
204            store_tx: Box::new(self.db.transact(true)?),
205            temp_store_tx: self.temp_db.transact(true)?,
206            relation_store_id: self.relation_store_id.clone(),
207            temp_store_id: Default::default(),
208            tokenizers: self.tokenizers.clone(),
209        };
210        Ok(ret)
211    }
212}