reifydb-engine 0.9.0

Query execution and processing engine for ReifyDB
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

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 ReifyDB

use std::sync::Arc;

use reifydb_auth::registry::AuthenticationRegistry;
use reifydb_catalog::{
	catalog::Catalog,
	metrics::storage::metrics::MetricsReader,
	vtable::{system::operator_libary::OperatorLibrary, user::registry::UserVTableRegistry},
};
use reifydb_core::util::ioc::IocContainer;
use reifydb_extension::transform::registry::Transforms;
#[cfg(test)]
use reifydb_routine::{
	function::default_in_process_functions, monoid::default_in_process_monoids,
	procedure::default_in_process_procedures,
};
use reifydb_routine_abi::{Procedure, registry::Routines};
use reifydb_rql::compiler::Compiler;
use reifydb_runtime::context::RuntimeContext;
#[cfg(test)]
use reifydb_runtime::context::clock::Clock;
use reifydb_store_single::SingleStore;
use reifydb_transaction::transaction::Transaction;
use reifydb_value::value::sumtype::VariantRef;

#[cfg(not(reifydb_single_threaded))]
use crate::remote::RemoteRegistry;
use crate::vm::flow_lineage::ViewLineage;

pub struct EngineConfig {
	pub runtime_context: RuntimeContext,
	pub routines: Routines,
	pub transforms: Transforms,
	pub ioc: IocContainer,
	#[cfg(not(reifydb_single_threaded))]
	pub remote_registry: Option<RemoteRegistry>,
}

pub struct Services {
	pub catalog: Catalog,
	pub runtime_context: RuntimeContext,
	pub compiler: Compiler,
	pub routines: Routines,
	pub transforms: Transforms,
	pub operators: OperatorLibrary,
	pub virtual_table_registry: UserVTableRegistry,
	pub metrics_reader: MetricsReader<SingleStore>,
	pub ioc: IocContainer,
	pub auth_registry: AuthenticationRegistry,
	pub view_lineage: ViewLineage,
	#[cfg(not(reifydb_single_threaded))]
	pub remote_registry: Option<RemoteRegistry>,
}

impl Services {
	pub fn new(
		catalog: Catalog,
		config: EngineConfig,
		operator_store: OperatorLibrary,
		metrics_reader: MetricsReader<SingleStore>,
	) -> Self {
		let auth_registry = AuthenticationRegistry::new(config.runtime_context.clock.clone());
		Self {
			compiler: Compiler::new(catalog.clone()),
			catalog,
			runtime_context: config.runtime_context,
			routines: config.routines,
			transforms: config.transforms,
			operators: operator_store,
			virtual_table_registry: UserVTableRegistry::new(),
			metrics_reader,
			ioc: config.ioc,
			auth_registry,
			view_lineage: ViewLineage::default(),
			#[cfg(not(reifydb_single_threaded))]
			remote_registry: config.remote_registry,
		}
	}

	pub fn get_handlers(&self, txn: &mut Transaction<'_>, variant: VariantRef) -> Vec<Arc<dyn Procedure>> {
		self.routines.get_handlers(&self.catalog, txn, variant)
	}

	pub fn get_procedure(&self, name: &str) -> Option<Arc<dyn Procedure>> {
		self.routines.get_procedure(name)
	}

	#[cfg(test)]
	pub fn testing() -> Arc<Self> {
		let store = SingleStore::testing_memory();

		let routines_builder = Routines::builder();
		let routines_builder = default_in_process_functions(routines_builder);
		let routines_builder = default_in_process_procedures(routines_builder);
		let routines_builder = default_in_process_monoids(routines_builder);
		let routines = routines_builder.configure();

		let mut services = Self::new(
			Catalog::testing(),
			EngineConfig {
				runtime_context: RuntimeContext::with_clock(Clock::Real),
				routines,
				transforms: Transforms::empty(),
				ioc: IocContainer::new(),
				#[cfg(not(reifydb_single_threaded))]
				remote_registry: None,
			},
			OperatorLibrary::new(),
			MetricsReader::new(store),
		);
		services.auth_registry = AuthenticationRegistry::default();
		Arc::new(services)
	}
}