Skip to main content

common_meta/ddl/drop_table/
executor.rs

1// Copyright 2023 Greptime Team
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use 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/// [Control] indicated to the caller whether to go to the next step.
47#[derive(Debug)]
48pub enum Control<T> {
49    Continue(T),
50    Stop,
51}
52
53impl<T> Control<T> {
54    /// Returns true if it's [Control::Stop].
55    pub fn stop(&self) -> bool {
56        matches!(self, Control::Stop)
57    }
58}
59
60impl DropTableExecutor {
61    /// Returns the [DropTableExecutor].
62    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
71/// [DropTableExecutor] performs:
72/// - Drops the metadata of the table.
73/// - Invalidates the cache on the Frontend nodes.
74/// - Drops the regions on the Datanode nodes.
75pub struct DropTableExecutor {
76    table: TableName,
77    table_id: TableId,
78    drop_if_exists: bool,
79}
80
81impl DropTableExecutor {
82    /// Checks whether table exists.
83    /// - Early returns if table not exists and `drop_if_exists` is `true`.
84    /// - Throws an error if table not exists and `drop_if_exists` is `false`.
85    /// - Rejects dropping a recreated live table while an older tombstone still owns the same
86    ///   fully qualified name.
87    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    /// Deletes the table metadata **logically**.
130    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    /// Deletes the table metadata tombstone **permanently**.
147    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    /// Deletes metadata for table **permanently**.
164    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            // Safety: checked.
181            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    /// Restores the table metadata.
191    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    /// Invalidates caches for the table.
208    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    /// Drops regions on datanodes.
232    ///
233    /// Arguments:
234    /// - `node_manager`: resolves datanode clients from peers in `region_routes`.
235    /// - `leader_region_registry`: tracks in-flight leader region operations.
236    /// - `region_routes`: table region placement; leaders receive drop requests and followers
237    ///   receive close requests.
238    /// - `fast_path`: forwards to datanode drop requests to skip extra cleanup when safe.
239    /// - `force`: forwards to datanode drop requests to allow forced region removal.
240    /// - `partial_drop`: forwards to datanode drop requests for partial table/region drops.
241    #[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        // Drops leader regions on datanodes.
252        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        // Drops follower regions on datanodes.
297        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        // Failure to close follower regions is not critical.
333        // When a leader region is dropped, follower regions will be unable to renew their leases via metasrv.
334        // Eventually, these follower regions will be automatically closed by the region livekeeper.
335        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        // Deletes the leader region from registry.
344        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    /// Closes all table regions on datanodes without deleting region files or metadata tombstones.
351    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        // Drops if exists
465        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        // Drops a non-exists table
476        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        // Drops a exists table
485        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}