1mod 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
45pub 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#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
59pub enum ScriptMutability {
60 Mutable,
62 Immutable,
64}
65
66#[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 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 #[cfg(not(target_arch = "wasm32"))]
116 event_callbacks: Default::default(),
117 relation_locks: Default::default(),
118 };
119 Ok(ret)
120 }
121
122 pub fn initialize(&'s self) -> Result<()> {
124 self.load_last_ids()?;
125 Ok(())
126 }
127
128 pub fn get_fixed_rules(&'s self) -> BTreeMap<String, Arc<Box<dyn FixedRule>>> {
130 return self.fixed_rules.read().unwrap().clone();
131 }
132
133 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 ¶ms,
144 &self.get_fixed_rules(),
145 current_validity(),
146 )?,
147 current_validity(),
148 mutability,
149 )
150 }
151
152 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 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}