common_meta/ddl/drop_table/
executor.rs1use std::collections::{HashMap, HashSet};
16
17use api::v1::region::{
18 CloseRequest as PbCloseRegionRequest, DropRequest as PbDropRegionRequest, RegionRequest,
19 RegionRequestHeader, region_request,
20};
21use common_error::ext::ErrorExt;
22use common_error::status_code::StatusCode;
23use common_telemetry::tracing_context::TracingContext;
24use common_telemetry::{debug, error};
25use common_wal::options::WalOptions;
26use futures::future::join_all;
27use snafu::ensure;
28use store_api::storage::{RegionId, RegionNumber};
29use table::metadata::TableId;
30use table::table_name::TableName;
31
32use crate::cache_invalidator::Context;
33use crate::ddl::DdlContext;
34use crate::ddl::utils::{add_peer_context_if_needed, convert_region_routes_to_detecting_regions};
35use crate::error::{self, Result};
36use crate::instruction::CacheIdent;
37use crate::key::table_name::TableNameKey;
38use crate::key::table_route::TableRouteValue;
39use crate::node_manager::NodeManagerRef;
40use crate::region_registry::LeaderRegionRegistryRef;
41use crate::rpc::router::{
42 RegionRoute, find_follower_regions, find_followers, find_leader_regions, find_leaders,
43 operating_leader_regions,
44};
45
46#[derive(Debug)]
48pub enum Control<T> {
49 Continue(T),
50 Stop,
51}
52
53impl<T> Control<T> {
54 pub fn stop(&self) -> bool {
56 matches!(self, Control::Stop)
57 }
58}
59
60impl DropTableExecutor {
61 pub fn new(table: TableName, table_id: TableId, drop_if_exists: bool) -> Self {
63 Self {
64 table,
65 table_id,
66 drop_if_exists,
67 }
68 }
69}
70
71pub struct DropTableExecutor {
76 table: TableName,
77 table_id: TableId,
78 drop_if_exists: bool,
79}
80
81impl DropTableExecutor {
82 pub async fn on_prepare(&self, ctx: &DdlContext) -> Result<Control<()>> {
88 let table_ref = self.table.table_ref();
89
90 let exist = ctx
91 .table_metadata_manager
92 .table_name_manager()
93 .exists(TableNameKey::new(
94 table_ref.catalog,
95 table_ref.schema,
96 table_ref.table,
97 ))
98 .await?;
99
100 if !exist && self.drop_if_exists {
101 return Ok(Control::Stop);
102 }
103
104 ensure!(
105 exist,
106 error::TableNotFoundSnafu {
107 table_name: table_ref.to_string()
108 }
109 );
110
111 if ctx.soft_drop_enabled
112 && let Some(dropped_table) = ctx
113 .table_metadata_manager
114 .get_dropped_table(&self.table)
115 .await?
116 && dropped_table.table_id != self.table_id
117 {
118 return error::TableNameTombstoneConflictSnafu {
119 table_name: table_ref.to_string(),
120 existing_table_id: dropped_table.table_id,
121 dropping_table_id: self.table_id,
122 }
123 .fail();
124 }
125
126 Ok(Control::Continue(()))
127 }
128
129 pub async fn on_delete_metadata(
131 &self,
132 ctx: &DdlContext,
133 table_route_value: &TableRouteValue,
134 region_wal_options: &HashMap<RegionNumber, WalOptions>,
135 ) -> Result<()> {
136 ctx.table_metadata_manager
137 .delete_table_metadata(
138 self.table_id,
139 &self.table,
140 table_route_value,
141 region_wal_options,
142 )
143 .await
144 }
145
146 pub async fn on_delete_metadata_tombstone(
148 &self,
149 ctx: &DdlContext,
150 table_route_value: &TableRouteValue,
151 region_wal_options: &HashMap<u32, WalOptions>,
152 ) -> Result<()> {
153 ctx.table_metadata_manager
154 .delete_table_metadata_tombstone(
155 self.table_id,
156 &self.table,
157 table_route_value,
158 region_wal_options,
159 )
160 .await
161 }
162
163 pub async fn on_destroy_metadata(
165 &self,
166 ctx: &DdlContext,
167 table_route_value: &TableRouteValue,
168 region_wal_options: &HashMap<u32, WalOptions>,
169 ) -> Result<()> {
170 ctx.table_metadata_manager
171 .destroy_table_metadata(
172 self.table_id,
173 &self.table,
174 table_route_value,
175 region_wal_options,
176 )
177 .await?;
178
179 let detecting_regions = if table_route_value.is_physical() {
180 let regions = table_route_value.region_routes().unwrap();
182 convert_region_routes_to_detecting_regions(regions)
183 } else {
184 vec![]
185 };
186 ctx.deregister_failure_detectors(detecting_regions).await;
187 Ok(())
188 }
189
190 pub async fn on_restore_metadata(
192 &self,
193 ctx: &DdlContext,
194 table_route_value: &TableRouteValue,
195 region_wal_options: &HashMap<u32, WalOptions>,
196 ) -> Result<()> {
197 ctx.table_metadata_manager
198 .restore_table_metadata(
199 self.table_id,
200 &self.table,
201 table_route_value,
202 region_wal_options,
203 )
204 .await
205 }
206
207 pub async fn invalidate_table_cache(&self, ctx: &DdlContext) -> Result<()> {
209 let cache_invalidator = &ctx.cache_invalidator;
210 let ctx = Context {
211 subject: Some(format!(
212 "Invalidate table cache by dropping table {}, table_id: {}",
213 self.table.table_ref(),
214 self.table_id,
215 )),
216 };
217
218 cache_invalidator
219 .invalidate(
220 &ctx,
221 &[
222 CacheIdent::TableName(self.table.table_ref().into()),
223 CacheIdent::TableId(self.table_id),
224 ],
225 )
226 .await?;
227
228 Ok(())
229 }
230
231 #[allow(clippy::too_many_arguments)]
242 pub async fn on_drop_regions(
243 &self,
244 node_manager: &NodeManagerRef,
245 leader_region_registry: &LeaderRegionRegistryRef,
246 region_routes: &[RegionRoute],
247 fast_path: bool,
248 force: bool,
249 partial_drop: bool,
250 ) -> Result<()> {
251 let leaders = find_leaders(region_routes);
253 let mut drop_region_tasks = Vec::with_capacity(leaders.len());
254 let table_id = self.table_id;
255 for datanode in leaders {
256 let requester = node_manager.datanode(&datanode).await;
257 let regions = find_leader_regions(region_routes, &datanode);
258 let region_ids = regions
259 .iter()
260 .map(|region_number| RegionId::new(table_id, *region_number))
261 .collect::<Vec<_>>();
262
263 for region_id in region_ids {
264 debug!("Dropping region {region_id} on Datanode {datanode:?}");
265 let request = RegionRequest {
266 header: Some(RegionRequestHeader {
267 tracing_context: TracingContext::from_current_span().to_w3c(),
268 ..Default::default()
269 }),
270 body: Some(region_request::Body::Drop(PbDropRegionRequest {
271 region_id: region_id.as_u64(),
272 fast_path,
273 force,
274 partial_drop,
275 soft_drop: false,
276 })),
277 };
278 let datanode = datanode.clone();
279 let requester = requester.clone();
280 drop_region_tasks.push(async move {
281 if let Err(err) = requester.handle(request).await
282 && err.status_code() != StatusCode::RegionNotFound
283 {
284 return Err(add_peer_context_if_needed(datanode)(err));
285 }
286 Ok(())
287 });
288 }
289 }
290
291 join_all(drop_region_tasks)
292 .await
293 .into_iter()
294 .collect::<Result<Vec<_>>>()?;
295
296 let followers = find_followers(region_routes);
298 let mut close_region_tasks = Vec::with_capacity(followers.len());
299 for datanode in followers {
300 let requester = node_manager.datanode(&datanode).await;
301 let regions = find_follower_regions(region_routes, &datanode);
302 let region_ids = regions
303 .iter()
304 .map(|region_number| RegionId::new(table_id, *region_number))
305 .collect::<Vec<_>>();
306
307 for region_id in region_ids {
308 debug!("Closing region {region_id} on Datanode {datanode:?}");
309 let request = RegionRequest {
310 header: Some(RegionRequestHeader {
311 tracing_context: TracingContext::from_current_span().to_w3c(),
312 ..Default::default()
313 }),
314 body: Some(region_request::Body::Close(PbCloseRegionRequest {
315 region_id: region_id.as_u64(),
316 })),
317 };
318
319 let datanode = datanode.clone();
320 let requester = requester.clone();
321 close_region_tasks.push(async move {
322 if let Err(err) = requester.handle(request).await
323 && err.status_code() != StatusCode::RegionNotFound
324 {
325 return Err(add_peer_context_if_needed(datanode)(err));
326 }
327 Ok(())
328 });
329 }
330 }
331
332 if let Err(err) = join_all(close_region_tasks)
336 .await
337 .into_iter()
338 .collect::<Result<Vec<_>>>()
339 {
340 error!(err; "Failed to close follower regions on datanodes, table_id: {}", table_id);
341 }
342
343 let region_ids = operating_leader_regions(region_routes);
345 leader_region_registry.batch_delete(region_ids.into_iter().map(|(region_id, _)| region_id));
346
347 Ok(())
348 }
349
350 pub async fn on_close_regions(
352 &self,
353 node_manager: &NodeManagerRef,
354 leader_region_registry: &LeaderRegionRegistryRef,
355 region_routes: &[RegionRoute],
356 ) -> Result<()> {
357 let table_id = self.table_id;
358 let mut seen_peer_ids = HashSet::new();
359 let peers = find_leaders(region_routes)
360 .into_iter()
361 .chain(find_followers(region_routes))
362 .filter(|peer| seen_peer_ids.insert(peer.id));
363 let mut close_region_tasks = Vec::new();
364
365 for datanode in peers {
366 let requester = node_manager.datanode(&datanode).await;
367 let region_ids = find_leader_regions(region_routes, &datanode)
368 .into_iter()
369 .chain(find_follower_regions(region_routes, &datanode))
370 .map(|region_number| RegionId::new(table_id, region_number));
371
372 for region_id in region_ids {
373 debug!("Closing region {region_id} on Datanode {datanode:?}");
374 let request = RegionRequest {
375 header: Some(RegionRequestHeader {
376 tracing_context: TracingContext::from_current_span().to_w3c(),
377 ..Default::default()
378 }),
379 body: Some(region_request::Body::Close(PbCloseRegionRequest {
380 region_id: region_id.as_u64(),
381 })),
382 };
383
384 let datanode = datanode.clone();
385 let requester = requester.clone();
386 close_region_tasks.push(async move {
387 if let Err(err) = requester.handle(request).await
388 && err.status_code() != StatusCode::RegionNotFound
389 {
390 return Err(add_peer_context_if_needed(datanode)(err));
391 }
392 Ok(())
393 });
394 }
395 }
396
397 join_all(close_region_tasks)
398 .await
399 .into_iter()
400 .collect::<Result<Vec<_>>>()?;
401
402 let region_ids = operating_leader_regions(region_routes);
403 leader_region_registry.batch_delete(region_ids.into_iter().map(|(region_id, _)| region_id));
404
405 Ok(())
406 }
407}
408
409#[cfg(test)]
410mod tests {
411 use std::assert_matches;
412 use std::collections::HashMap;
413 use std::sync::Arc;
414
415 use api::v1::{ColumnDataType, SemanticType};
416 use common_catalog::consts::{DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME};
417 use table::metadata::TableInfo;
418 use table::table_name::TableName;
419
420 use super::*;
421 use crate::ddl::test_util::columns::TestColumnDefBuilder;
422 use crate::ddl::test_util::create_table::{
423 TestCreateTableExprBuilder, build_raw_table_info_from_expr,
424 };
425 use crate::key::table_route::TableRouteValue;
426 use crate::test_util::{MockDatanodeManager, new_ddl_context};
427
428 fn test_create_raw_table_info(name: &str) -> TableInfo {
429 let create_table = TestCreateTableExprBuilder::default()
430 .column_defs([
431 TestColumnDefBuilder::default()
432 .name("ts")
433 .data_type(ColumnDataType::TimestampMillisecond)
434 .semantic_type(SemanticType::Timestamp)
435 .build()
436 .unwrap()
437 .into(),
438 TestColumnDefBuilder::default()
439 .name("host")
440 .data_type(ColumnDataType::String)
441 .semantic_type(SemanticType::Tag)
442 .build()
443 .unwrap()
444 .into(),
445 TestColumnDefBuilder::default()
446 .name("cpu")
447 .data_type(ColumnDataType::Float64)
448 .semantic_type(SemanticType::Field)
449 .build()
450 .unwrap()
451 .into(),
452 ])
453 .time_index("ts")
454 .primary_keys(["host".into()])
455 .table_name(name)
456 .build()
457 .unwrap()
458 .into();
459 build_raw_table_info_from_expr(&create_table)
460 }
461
462 #[tokio::test]
463 async fn test_on_prepare() {
464 let node_manager = Arc::new(MockDatanodeManager::new(()));
466 let ctx = new_ddl_context(node_manager);
467 let executor = DropTableExecutor::new(
468 TableName::new(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, "my_table"),
469 1024,
470 true,
471 );
472 let ctrl = executor.on_prepare(&ctx).await.unwrap();
473 assert!(ctrl.stop());
474
475 let executor = DropTableExecutor::new(
477 TableName::new(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, "my_table"),
478 1024,
479 false,
480 );
481 let err = executor.on_prepare(&ctx).await.unwrap_err();
482 assert_matches!(err, error::Error::TableNotFound { .. });
483
484 let executor = DropTableExecutor::new(
486 TableName::new(DEFAULT_CATALOG_NAME, DEFAULT_SCHEMA_NAME, "my_table"),
487 1024,
488 false,
489 );
490 let raw_table_info = test_create_raw_table_info("my_table");
491 ctx.table_metadata_manager
492 .create_table_metadata(
493 raw_table_info,
494 TableRouteValue::physical(vec![]),
495 HashMap::new(),
496 )
497 .await
498 .unwrap();
499 let ctrl = executor.on_prepare(&ctx).await.unwrap();
500 assert!(!ctrl.stop());
501 }
502}