1use std::sync::Arc;
16use std::sync::atomic::AtomicBool;
17
18use cache::{PARTITION_INFO_CACHE_NAME, TABLE_FLOWNODE_SET_CACHE_NAME, TABLE_ROUTE_CACHE_NAME};
19use catalog::CatalogManagerRef;
20use catalog::kvbackend::KvBackendCatalogManager;
21use catalog::process_manager::ProcessManagerRef;
22use catalog::system_schema::semantic_graph::EntityGraphProviderRef;
23use common_base::Plugins;
24use common_datasource::object_store::LocalFileAccess;
25use common_event_recorder::EventRecorderImpl;
26use common_meta::cache::{LayeredCacheRegistryRef, TableRouteCacheRef};
27use common_meta::cache_invalidator::{CacheInvalidatorRef, DummyCacheInvalidator};
28use common_meta::key::TableMetadataManager;
29use common_meta::key::flow::FlowMetadataManager;
30use common_meta::kv_backend::KvBackendRef;
31use common_meta::node_manager::NodeManagerRef;
32use common_meta::procedure_executor::ProcedureExecutorRef;
33use dashmap::DashMap;
34use operator::delete::Deleter;
35use operator::flow::FlowServiceOperator;
36use operator::insert::Inserter;
37use operator::procedure::ProcedureServiceOperator;
38use operator::request::Requester;
39#[cfg(feature = "enterprise")]
40use operator::statement::CreateDatabaseHandlerRef;
41use operator::statement::{
42 ExecutorConfigureContext, StatementExecutor, StatementExecutorConfiguratorRef,
43 StatementExecutorRef,
44};
45use operator::table::TableMutationOperator;
46use partition::cache::PartitionInfoCacheRef;
47use partition::manager::PartitionRuleManager;
48use pipeline::pipeline_operator::PipelineOperator;
49use query::QueryEngineFactory;
50use query::region_query::RegionQueryHandlerFactoryRef;
51use snafu::{OptionExt, ResultExt};
52
53use crate::error::{self, DataFusionSnafu, ExternalSnafu, Result};
54use crate::events::EventHandlerImpl;
55use crate::frontend::FrontendOptions;
56use crate::heartbeat::frontend_peer_addr;
57use crate::instance::Instance;
58use crate::instance::entity_graph::EntityGraphProviderImpl;
59use crate::instance::region_query::FrontendRegionQueryHandler;
60
61pub struct FrontendBuilder {
63 options: FrontendOptions,
64 kv_backend: KvBackendRef,
65 layered_cache_registry: LayeredCacheRegistryRef,
66 local_cache_invalidator: Option<CacheInvalidatorRef>,
67 catalog_manager: CatalogManagerRef,
68 node_manager: NodeManagerRef,
69 plugins: Option<Plugins>,
70 procedure_executor: ProcedureExecutorRef,
71 process_manager: ProcessManagerRef,
72 local_file_access: LocalFileAccess,
73}
74
75impl FrontendBuilder {
76 #[allow(clippy::too_many_arguments)]
77 pub fn new(
78 options: FrontendOptions,
79 kv_backend: KvBackendRef,
80 layered_cache_registry: LayeredCacheRegistryRef,
81 catalog_manager: CatalogManagerRef,
82 node_manager: NodeManagerRef,
83 procedure_executor: ProcedureExecutorRef,
84 process_manager: ProcessManagerRef,
85 ) -> Self {
86 Self {
87 options,
88 kv_backend,
89 layered_cache_registry,
90 local_cache_invalidator: None,
91 catalog_manager,
92 node_manager,
93 plugins: None,
94 procedure_executor,
95 process_manager,
96 local_file_access: LocalFileAccess::Disabled,
97 }
98 }
99
100 #[cfg(test)]
101 pub(crate) fn new_test(
102 options: &FrontendOptions,
103 meta_client: meta_client::MetaClientRef,
104 ) -> Self {
105 use cache::{build_fundamental_cache_registry, with_default_composite_cache_registry};
106 use common_meta::cache::LayeredCacheRegistryBuilder;
107 use common_meta::kv_backend::memory::MemoryKvBackend;
108
109 let kv_backend = Arc::new(MemoryKvBackend::new());
110
111 let layered_cache_builder = LayeredCacheRegistryBuilder::default();
113 let fundamental_cache_registry = build_fundamental_cache_registry(kv_backend.clone());
114 let layered_cache_registry = Arc::new(
115 with_default_composite_cache_registry(
116 layered_cache_builder.add_cache_registry(fundamental_cache_registry),
117 )
118 .unwrap()
119 .build(),
120 );
121
122 Self::new(
123 options.clone(),
124 kv_backend,
125 layered_cache_registry,
126 catalog::memory::MemoryCatalogManager::with_default_setup(),
127 Arc::new(client::client_manager::NodeClients::default()),
128 meta_client,
129 Arc::new(catalog::process_manager::ProcessManager::new(
130 "".to_string(),
131 None,
132 )),
133 )
134 }
135
136 pub fn with_local_cache_invalidator(self, cache_invalidator: CacheInvalidatorRef) -> Self {
137 Self {
138 local_cache_invalidator: Some(cache_invalidator),
139 ..self
140 }
141 }
142
143 pub fn with_local_file_access(mut self, local_file_access: LocalFileAccess) -> Self {
144 self.local_file_access = local_file_access;
145 self
146 }
147
148 pub fn options(&self) -> &FrontendOptions {
149 &self.options
150 }
151
152 pub fn kv_backend(&self) -> &KvBackendRef {
153 &self.kv_backend
154 }
155
156 pub fn layered_cache_registry(&self) -> &LayeredCacheRegistryRef {
157 &self.layered_cache_registry
158 }
159
160 pub fn catalog_manager(&self) -> &CatalogManagerRef {
161 &self.catalog_manager
162 }
163
164 pub fn node_manager(&self) -> &NodeManagerRef {
165 &self.node_manager
166 }
167
168 pub fn procedure_executor(&self) -> &ProcedureExecutorRef {
169 &self.procedure_executor
170 }
171
172 pub fn process_manager(&self) -> &ProcessManagerRef {
173 &self.process_manager
174 }
175
176 pub fn with_plugin(self, plugins: Plugins) -> Self {
177 Self {
178 plugins: Some(plugins),
179 ..self
180 }
181 }
182
183 pub async fn try_build(self) -> Result<Instance> {
184 let kv_backend = self.kv_backend;
185 let node_manager = self.node_manager;
186 let plugins = self.plugins.unwrap_or_default();
187 let process_manager = self.process_manager;
188 let table_route_cache: TableRouteCacheRef =
189 self.layered_cache_registry
190 .get()
191 .context(error::CacheRequiredSnafu {
192 name: TABLE_ROUTE_CACHE_NAME,
193 })?;
194 let partition_info_cache: PartitionInfoCacheRef = self
195 .layered_cache_registry
196 .get()
197 .context(error::CacheRequiredSnafu {
198 name: PARTITION_INFO_CACHE_NAME,
199 })?;
200 let partition_manager = Arc::new(PartitionRuleManager::new(
201 kv_backend.clone(),
202 table_route_cache.clone(),
203 partition_info_cache.clone(),
204 ));
205
206 let local_cache_invalidator = self
207 .local_cache_invalidator
208 .unwrap_or_else(|| Arc::new(DummyCacheInvalidator));
209
210 let region_query_handler =
211 if let Some(factory) = plugins.get::<RegionQueryHandlerFactoryRef>() {
212 factory.build(partition_manager.clone(), node_manager.clone())
213 } else {
214 FrontendRegionQueryHandler::arc(partition_manager.clone(), node_manager.clone())
215 };
216
217 let table_flownode_cache =
218 self.layered_cache_registry
219 .get()
220 .context(error::CacheRequiredSnafu {
221 name: TABLE_FLOWNODE_SET_CACHE_NAME,
222 })?;
223
224 let inserter = Arc::new(Inserter::new(
225 self.catalog_manager.clone(),
226 partition_manager.clone(),
227 node_manager.clone(),
228 table_flownode_cache,
229 self.options.auto_create_table,
230 ));
231 let deleter = Arc::new(Deleter::new(
232 self.catalog_manager.clone(),
233 partition_manager.clone(),
234 node_manager.clone(),
235 ));
236 let requester = Arc::new(Requester::new(
237 self.catalog_manager.clone(),
238 partition_manager.clone(),
239 node_manager.clone(),
240 ));
241 let table_mutation_handler = Arc::new(TableMutationOperator::new(
242 inserter.clone(),
243 deleter.clone(),
244 requester,
245 ));
246
247 let table_metadata_manager = Arc::new(TableMetadataManager::new(kv_backend.clone()));
248 let procedure_service_handler = Arc::new(ProcedureServiceOperator::new(
249 self.procedure_executor.clone(),
250 self.catalog_manager.clone(),
251 table_metadata_manager.clone(),
252 ));
253
254 let flow_metadata_manager: Arc<FlowMetadataManager> =
255 Arc::new(FlowMetadataManager::new(kv_backend.clone()));
256 let flow_service = FlowServiceOperator::new(flow_metadata_manager, node_manager.clone());
257
258 let mut query_options = self.options.query.clone();
259 query_options.enable_per_region_metrics = self.options.logging.enable_per_region_metrics;
260 let query_engine = QueryEngineFactory::try_new_with_plugins(
261 self.catalog_manager.clone(),
262 Some(partition_manager.clone()),
263 Some(region_query_handler.clone()),
264 Some(table_mutation_handler),
265 Some(procedure_service_handler),
266 Some(Arc::new(flow_service)),
267 true,
268 plugins.clone(),
269 query_options,
270 )
271 .context(DataFusionSnafu)?
272 .query_engine();
273
274 if let Some(kv_catalog) = self
279 .catalog_manager
280 .as_any()
281 .downcast_ref::<KvBackendCatalogManager>()
282 {
283 let provider: EntityGraphProviderRef = Arc::new(EntityGraphProviderImpl::new(
284 query_engine.clone(),
285 Arc::downgrade(&self.catalog_manager),
286 ));
287 kv_catalog.set_entity_graph_provider(provider);
288 }
289
290 let frontend_peer_addr = frontend_peer_addr(&self.options);
291 let statement_executor = StatementExecutor::new(
292 self.catalog_manager.clone(),
293 query_engine.clone(),
294 self.procedure_executor,
295 kv_backend.clone(),
296 local_cache_invalidator,
297 inserter.clone(),
298 partition_manager,
299 Some(process_manager.clone()),
300 frontend_peer_addr.clone(),
301 self.local_file_access,
302 );
303
304 let statement_executor =
305 if let Some(configurator) = plugins.get::<StatementExecutorConfiguratorRef>() {
306 let ctx = ExecutorConfigureContext {
307 kv_backend: kv_backend.clone(),
308 };
309 configurator
310 .configure(statement_executor, ctx)
311 .await
312 .context(ExternalSnafu)?
313 } else {
314 statement_executor
315 };
316
317 #[cfg(feature = "enterprise")]
318 let statement_executor = if let Some(handler) = plugins.get::<CreateDatabaseHandlerRef>() {
319 statement_executor.with_create_database_handler(handler)
320 } else {
321 statement_executor
322 };
323
324 let statement_executor = Arc::new(statement_executor);
325
326 let pipeline_operator = Arc::new(PipelineOperator::new(
327 inserter.clone(),
328 statement_executor.clone(),
329 self.catalog_manager.clone(),
330 query_engine.clone(),
331 ));
332
333 plugins.insert::<StatementExecutorRef>(statement_executor.clone());
334
335 let slow_query_recorder = Arc::new(EventRecorderImpl::new(Box::new(
336 EventHandlerImpl::new(statement_executor.clone(), self.options.slow_query.ttl),
337 )));
338 let event_recorder = Arc::new(EventRecorderImpl::with_event_type_filter(
339 Box::new(EventHandlerImpl::new(
340 statement_executor.clone(),
341 self.options.event_recorder.ttl,
342 )),
343 self.options.event_recorder.event_types.clone(),
344 ));
345
346 Ok(Instance {
347 frontend_peer_addr,
348 catalog_manager: self.catalog_manager,
349 pipeline_operator,
350 statement_executor,
351 query_engine,
352 plugins,
353 inserter,
354 deleter,
355 table_metadata_manager,
356 event_recorder,
357 slow_query_recorder,
358 process_manager,
359 otlp_metrics_table_legacy_cache: DashMap::new(),
360 slow_query_options: self.options.slow_query.clone(),
361 influxdb_default_merge_mode: self.options.influxdb.default_merge_mode,
362 trace_ingest_chunk_size: self.options.otlp.trace_ingest_chunk_size,
363 suspend: Arc::new(AtomicBool::new(false)),
364 })
365 }
366}