1use std::any::Any;
18use std::collections::HashMap;
19use std::fmt::{Debug, Display};
20use std::sync::{Arc, Mutex};
21use std::time::Instant;
22
23use api::greptime_proto::v1::meta::{GrantedRegion as PbGrantedRegion, RegionRole as PbRegionRole};
24use api::region::RegionResponse;
25use async_trait::async_trait;
26use common_error::ext::BoxedError;
27use common_recordbatch::adapter::RegionQueryStatCounters;
28use common_recordbatch::{EmptyRecordBatchStream, QueryMemoryTracker, SendableRecordBatchStream};
29use common_time::Timestamp;
30use datafusion_execution::memory_pool::{MemoryPool, UnboundedMemoryPool};
31use datafusion_physical_plan::metrics::ExecutionPlanMetricsSet;
32use datafusion_physical_plan::{DisplayAs, DisplayFormatType, PhysicalExpr};
33use datatypes::schema::SchemaRef;
34use futures::FutureExt;
35use futures::future::{BoxFuture, join_all};
36use serde::{Deserialize, Serialize};
37use tokio::sync::Semaphore;
38
39use crate::logstore::entry;
40use crate::metadata::RegionMetadataRef;
41use crate::region_request::{
42 BatchRegionDdlRequest, RegionCatchupRequest, RegionOpenRequest, RegionPutRequest, RegionRequest,
43};
44use crate::storage::{FileId, RegionId, ScanRequest, SequenceNumber};
45
46#[derive(Debug, PartialEq, Eq, Clone, Copy)]
48pub enum SettableRegionRoleState {
49 Follower,
50 DowngradingLeader,
51 Leader,
53 StagingLeader,
55}
56
57impl Display for SettableRegionRoleState {
58 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
59 match self {
60 SettableRegionRoleState::Follower => write!(f, "Follower"),
61 SettableRegionRoleState::DowngradingLeader => write!(f, "Leader(Downgrading)"),
62 SettableRegionRoleState::Leader => write!(f, "Leader"),
63 SettableRegionRoleState::StagingLeader => write!(f, "Leader(Staging)"),
64 }
65 }
66}
67
68impl From<SettableRegionRoleState> for RegionRole {
69 fn from(value: SettableRegionRoleState) -> Self {
70 match value {
71 SettableRegionRoleState::Follower => RegionRole::Follower,
72 SettableRegionRoleState::DowngradingLeader => RegionRole::DowngradingLeader,
73 SettableRegionRoleState::Leader => RegionRole::Leader,
74 SettableRegionRoleState::StagingLeader => RegionRole::StagingLeader,
75 }
76 }
77}
78
79#[derive(Debug, PartialEq, Eq)]
81pub struct SetRegionRoleStateRequest {
82 region_id: RegionId,
83 region_role_state: SettableRegionRoleState,
84}
85
86#[derive(Debug, PartialEq, Eq)]
88pub enum SetRegionRoleStateSuccess {
89 File,
90 Relational,
91 Mito {
92 last_entry_id: entry::Id,
93 },
94 Metric {
95 last_entry_id: entry::Id,
96 metadata_last_entry_id: entry::Id,
97 },
98}
99
100impl SetRegionRoleStateSuccess {
101 pub fn file() -> Self {
103 Self::File
104 }
105
106 pub fn relational() -> Self {
108 Self::Relational
109 }
110
111 pub fn mito(last_entry_id: entry::Id) -> Self {
113 SetRegionRoleStateSuccess::Mito { last_entry_id }
114 }
115
116 pub fn metric(last_entry_id: entry::Id, metadata_last_entry_id: entry::Id) -> Self {
118 SetRegionRoleStateSuccess::Metric {
119 last_entry_id,
120 metadata_last_entry_id,
121 }
122 }
123}
124
125impl SetRegionRoleStateSuccess {
126 pub fn last_entry_id(&self) -> Option<entry::Id> {
128 match self {
129 SetRegionRoleStateSuccess::File | SetRegionRoleStateSuccess::Relational => None,
130 SetRegionRoleStateSuccess::Mito { last_entry_id } => Some(*last_entry_id),
131 SetRegionRoleStateSuccess::Metric { last_entry_id, .. } => Some(*last_entry_id),
132 }
133 }
134
135 pub fn metadata_last_entry_id(&self) -> Option<entry::Id> {
137 match self {
138 SetRegionRoleStateSuccess::File | SetRegionRoleStateSuccess::Relational => None,
139 SetRegionRoleStateSuccess::Mito { .. } => None,
140 SetRegionRoleStateSuccess::Metric {
141 metadata_last_entry_id,
142 ..
143 } => Some(*metadata_last_entry_id),
144 }
145 }
146}
147
148#[derive(Debug)]
150pub enum SetRegionRoleStateResponse {
151 Success(SetRegionRoleStateSuccess),
152 NotFound,
153 InvalidTransition(BoxedError),
154}
155
156impl SetRegionRoleStateResponse {
157 pub fn success(success: SetRegionRoleStateSuccess) -> Self {
159 Self::Success(success)
160 }
161
162 pub fn invalid_transition(error: BoxedError) -> Self {
164 Self::InvalidTransition(error)
165 }
166
167 pub fn is_not_found(&self) -> bool {
169 matches!(self, SetRegionRoleStateResponse::NotFound)
170 }
171
172 pub fn is_invalid_transition(&self) -> bool {
174 matches!(self, SetRegionRoleStateResponse::InvalidTransition(_))
175 }
176}
177
178#[derive(Debug, Clone, PartialEq, Eq)]
179pub struct GrantedRegion {
180 pub region_id: RegionId,
181 pub region_role: RegionRole,
182 pub candidate_lease_id: Option<u64>,
186 pub extensions: HashMap<String, Vec<u8>>,
187}
188
189impl GrantedRegion {
190 pub fn new(region_id: RegionId, region_role: RegionRole) -> Self {
191 Self {
192 region_id,
193 region_role,
194 candidate_lease_id: None,
195 extensions: HashMap::new(),
196 }
197 }
198}
199
200impl From<GrantedRegion> for PbGrantedRegion {
201 fn from(value: GrantedRegion) -> Self {
202 PbGrantedRegion {
203 region_id: value.region_id.as_u64(),
204 role: PbRegionRole::from(value.region_role).into(),
205 candidate_lease_id: value.candidate_lease_id.unwrap_or_default(),
206 extensions: value.extensions,
207 }
208 }
209}
210
211impl From<PbGrantedRegion> for GrantedRegion {
212 fn from(value: PbGrantedRegion) -> Self {
213 GrantedRegion {
214 region_id: RegionId::from_u64(value.region_id),
215 region_role: value.role().into(),
216 candidate_lease_id: (value.candidate_lease_id != 0).then_some(value.candidate_lease_id),
218 extensions: value.extensions,
219 }
220 }
221}
222
223#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
226pub enum RegionRole {
227 Follower,
229 Leader,
231 StagingLeader,
236 DowngradingLeader,
240}
241
242impl Display for RegionRole {
243 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
244 match self {
245 RegionRole::Follower => write!(f, "Follower"),
246 RegionRole::Leader => write!(f, "Leader"),
247 RegionRole::StagingLeader => write!(f, "Leader(Staging)"),
248 RegionRole::DowngradingLeader => write!(f, "Leader(Downgrading)"),
249 }
250 }
251}
252
253impl RegionRole {
254 pub fn writable(&self) -> bool {
255 matches!(self, RegionRole::Leader | RegionRole::StagingLeader)
256 }
257}
258
259impl From<RegionRole> for PbRegionRole {
260 fn from(value: RegionRole) -> Self {
261 match value {
262 RegionRole::Follower => PbRegionRole::Follower,
263 RegionRole::Leader => PbRegionRole::Leader,
264 RegionRole::StagingLeader => PbRegionRole::StagingLeader,
265 RegionRole::DowngradingLeader => PbRegionRole::DowngradingLeader,
266 }
267 }
268}
269
270impl From<PbRegionRole> for RegionRole {
271 fn from(value: PbRegionRole) -> Self {
272 match value {
273 PbRegionRole::Leader => RegionRole::Leader,
274 PbRegionRole::StagingLeader => RegionRole::StagingLeader,
275 PbRegionRole::Follower => RegionRole::Follower,
276 PbRegionRole::DowngradingLeader => RegionRole::DowngradingLeader,
277 }
278 }
279}
280
281#[derive(Debug)]
283pub enum ScannerPartitioning {
284 Unknown(usize),
286}
287
288impl ScannerPartitioning {
289 pub fn num_partitions(&self) -> usize {
291 match self {
292 ScannerPartitioning::Unknown(num_partitions) => *num_partitions,
293 }
294 }
295}
296
297#[derive(Debug, Clone, Copy, PartialEq, Eq)]
299pub struct PartitionRange {
300 pub start: Timestamp,
302 pub end: Timestamp,
304 pub num_rows: usize,
306 pub identifier: usize,
308}
309
310#[derive(Debug, Default)]
312pub struct ScannerProperties {
313 pub partitions: Vec<Vec<PartitionRange>>,
318
319 append_mode: bool,
321
322 total_rows: usize,
325
326 total_rows_is_exact: bool,
328
329 pub distinguish_partition_range: bool,
331
332 target_partitions: usize,
334
335 logical_region: bool,
338
339 query_load_region_id: Option<RegionId>,
341 query_stat_counters: Option<RegionQueryStatCounters>,
343}
344
345impl ScannerProperties {
346 pub fn with_append_mode(mut self, append_mode: bool) -> Self {
348 self.append_mode = append_mode;
349 self
350 }
351
352 pub fn with_total_rows(mut self, total_rows: usize) -> Self {
354 self.total_rows = total_rows;
355 self
356 }
357
358 pub fn with_total_rows_is_exact(mut self, exact: bool) -> Self {
360 self.total_rows_is_exact = exact;
361 self
362 }
363
364 pub fn new(partitions: Vec<Vec<PartitionRange>>, append_mode: bool, total_rows: usize) -> Self {
366 Self {
367 partitions,
368 append_mode,
369 total_rows,
370 total_rows_is_exact: false,
371 distinguish_partition_range: false,
372 target_partitions: 0,
373 logical_region: false,
374 query_load_region_id: None,
375 query_stat_counters: None,
376 }
377 }
378
379 pub fn prepare(&mut self, request: PrepareRequest) {
381 if let Some(ranges) = request.ranges {
382 self.partitions = ranges;
383 }
384 if let Some(distinguish_partition_range) = request.distinguish_partition_range {
385 self.distinguish_partition_range = distinguish_partition_range;
386 }
387 if let Some(target_partitions) = request.target_partitions {
388 self.target_partitions = target_partitions;
389 }
390 }
391
392 pub fn num_partitions(&self) -> usize {
394 self.partitions.len()
395 }
396
397 pub fn append_mode(&self) -> bool {
398 self.append_mode
399 }
400
401 pub fn total_rows(&self) -> usize {
402 self.total_rows
403 }
404
405 pub fn total_rows_is_exact(&self) -> bool {
407 self.total_rows_is_exact
408 }
409
410 pub fn is_logical_region(&self) -> bool {
413 self.logical_region
414 }
415
416 pub fn target_partitions(&self) -> usize {
418 if self.target_partitions == 0 {
419 self.num_partitions()
420 } else {
421 self.target_partitions
422 }
423 }
424
425 pub fn set_logical_region(&mut self, logical_region: bool) {
427 self.logical_region = logical_region;
428 }
429
430 pub fn query_load_region_id(&self) -> Option<RegionId> {
432 self.query_load_region_id
433 }
434
435 pub fn query_stat_counters(&self) -> Option<RegionQueryStatCounters> {
437 self.query_stat_counters.clone()
438 }
439
440 pub fn set_query_load_region_id(&mut self, region_id: RegionId) {
442 self.query_load_region_id = Some(region_id);
443 }
444
445 pub fn set_query_stat_counters(&mut self, counters: RegionQueryStatCounters) {
447 self.query_stat_counters = Some(counters);
448 }
449}
450
451#[derive(Default)]
453pub struct PrepareRequest {
454 pub ranges: Option<Vec<Vec<PartitionRange>>>,
456 pub distinguish_partition_range: Option<bool>,
458 pub target_partitions: Option<usize>,
460}
461
462impl PrepareRequest {
463 pub fn with_ranges(mut self, ranges: Vec<Vec<PartitionRange>>) -> Self {
465 self.ranges = Some(ranges);
466 self
467 }
468
469 pub fn with_distinguish_partition_range(mut self, distinguish_partition_range: bool) -> Self {
471 self.distinguish_partition_range = Some(distinguish_partition_range);
472 self
473 }
474
475 pub fn with_target_partitions(mut self, target_partitions: usize) -> Self {
477 self.target_partitions = Some(target_partitions);
478 self
479 }
480}
481
482#[derive(Clone)]
486pub struct QueryScanContext {
487 pub explain_verbose: bool,
489 pub memory_pool: Arc<dyn MemoryPool>,
491}
492
493impl Default for QueryScanContext {
494 fn default() -> Self {
495 Self {
496 explain_verbose: false,
497 memory_pool: Arc::new(UnboundedMemoryPool::default()),
498 }
499 }
500}
501
502pub trait RegionScanner: Debug + DisplayAs + Send {
507 fn name(&self) -> &str;
508
509 fn properties(&self) -> &ScannerProperties;
511
512 fn schema(&self) -> SchemaRef;
514
515 fn metadata(&self) -> RegionMetadataRef;
517
518 fn prepare(&mut self, request: PrepareRequest) -> Result<(), BoxedError>;
522
523 fn scan_partition(
528 &self,
529 ctx: &QueryScanContext,
530 metrics_set: &ExecutionPlanMetricsSet,
531 partition: usize,
532 ) -> Result<SendableRecordBatchStream, BoxedError>;
533
534 fn has_predicate_without_region(&self) -> bool;
536
537 fn add_dyn_filter_to_predicate(
542 &mut self,
543 filter_exprs: Vec<Arc<dyn PhysicalExpr>>,
544 ) -> Vec<bool>;
545
546 fn reset_state(&mut self) {}
553
554 fn set_logical_region(&mut self, logical_region: bool);
557
558 fn set_query_load_region_id(&mut self, region_id: RegionId);
560
561 fn snapshot_sequence(&self) -> Option<SequenceNumber> {
562 None
563 }
564}
565
566pub type RegionScannerRef = Box<dyn RegionScanner>;
567
568pub type BatchResponses = Vec<(RegionId, Result<RegionResponse, BoxedError>)>;
569
570pub type BatchPutResponse = (
573 Vec<RegionId>,
574 BoxFuture<'static, Result<RegionResponse, BoxedError>>,
575);
576
577#[derive(Debug, Deserialize, Serialize, Default)]
579pub struct RegionStatistic {
580 #[serde(default)]
585 pub num_rows: u64,
586 pub memtable_size: u64,
588 pub wal_size: u64,
590 pub manifest_size: u64,
595 pub sst_size: u64,
599 pub sst_num: u64,
603 #[serde(default)]
607 pub index_size: u64,
608 #[serde(default)]
610 pub manifest: RegionManifestInfo,
611 #[serde(default)]
612 pub written_bytes: u64,
614 #[serde(default, alias = "flushed_parquet_bytes")]
621 pub ingested_parquet_bytes: u64,
622 #[serde(default)]
626 pub query_cpu_time: u64,
627 #[serde(default)]
629 pub query_scanned_bytes: u64,
630 #[serde(default)]
634 pub min_timestamp: Option<Timestamp>,
635 #[serde(default)]
637 pub max_timestamp: Option<Timestamp>,
638 #[serde(default)]
642 pub data_topic_latest_entry_id: u64,
643 #[serde(default)]
644 pub metadata_topic_latest_entry_id: u64,
645}
646
647#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
649pub enum RegionManifestInfo {
650 Mito {
651 manifest_version: u64,
652 flushed_entry_id: u64,
653 file_removed_cnt: u64,
655 },
656 Metric {
657 data_manifest_version: u64,
658 data_flushed_entry_id: u64,
659 metadata_manifest_version: u64,
660 metadata_flushed_entry_id: u64,
661 },
662}
663
664impl RegionManifestInfo {
665 pub fn mito(manifest_version: u64, flushed_entry_id: u64, file_removal_rate: u64) -> Self {
667 Self::Mito {
668 manifest_version,
669 flushed_entry_id,
670 file_removed_cnt: file_removal_rate,
671 }
672 }
673
674 pub fn metric(
676 data_manifest_version: u64,
677 data_flushed_entry_id: u64,
678 metadata_manifest_version: u64,
679 metadata_flushed_entry_id: u64,
680 ) -> Self {
681 Self::Metric {
682 data_manifest_version,
683 data_flushed_entry_id,
684 metadata_manifest_version,
685 metadata_flushed_entry_id,
686 }
687 }
688
689 pub fn is_mito(&self) -> bool {
691 matches!(self, RegionManifestInfo::Mito { .. })
692 }
693
694 pub fn is_metric(&self) -> bool {
696 matches!(self, RegionManifestInfo::Metric { .. })
697 }
698
699 pub fn data_flushed_entry_id(&self) -> u64 {
701 match self {
702 RegionManifestInfo::Mito {
703 flushed_entry_id, ..
704 } => *flushed_entry_id,
705 RegionManifestInfo::Metric {
706 data_flushed_entry_id,
707 ..
708 } => *data_flushed_entry_id,
709 }
710 }
711
712 pub fn data_manifest_version(&self) -> u64 {
714 match self {
715 RegionManifestInfo::Mito {
716 manifest_version, ..
717 } => *manifest_version,
718 RegionManifestInfo::Metric {
719 data_manifest_version,
720 ..
721 } => *data_manifest_version,
722 }
723 }
724
725 pub fn metadata_manifest_version(&self) -> Option<u64> {
727 match self {
728 RegionManifestInfo::Mito { .. } => None,
729 RegionManifestInfo::Metric {
730 metadata_manifest_version,
731 ..
732 } => Some(*metadata_manifest_version),
733 }
734 }
735
736 pub fn metadata_flushed_entry_id(&self) -> Option<u64> {
738 match self {
739 RegionManifestInfo::Mito { .. } => None,
740 RegionManifestInfo::Metric {
741 metadata_flushed_entry_id,
742 ..
743 } => Some(*metadata_flushed_entry_id),
744 }
745 }
746
747 pub fn encode_list(manifest_infos: &[(RegionId, Self)]) -> serde_json::Result<Vec<u8>> {
749 serde_json::to_vec(manifest_infos)
750 }
751
752 pub fn decode_list(value: &[u8]) -> serde_json::Result<Vec<(RegionId, Self)>> {
754 serde_json::from_slice(value)
755 }
756}
757
758impl Default for RegionManifestInfo {
759 fn default() -> Self {
760 Self::Mito {
761 manifest_version: 0,
762 flushed_entry_id: 0,
763 file_removed_cnt: 0,
764 }
765 }
766}
767
768impl RegionStatistic {
769 pub fn deserialize_from_slice(value: &[u8]) -> Option<RegionStatistic> {
773 serde_json::from_slice(value).ok()
774 }
775
776 pub fn serialize_to_vec(&self) -> Option<Vec<u8>> {
780 serde_json::to_vec(self).ok()
781 }
782}
783
784impl RegionStatistic {
785 pub fn estimated_disk_size(&self) -> u64 {
787 self.wal_size + self.sst_size + self.manifest_size + self.index_size
788 }
789}
790
791#[cfg(test)]
792mod tests {
793 use serde_json::json;
794
795 use super::*;
796
797 #[test]
798 fn test_legacy_granted_region_wire() {
799 use prost::Message;
800
801 let legacy_bytes: &[u8] = include_bytes!(
802 "../../../tests/compatibility/wire/candidate_lease_id/legacy_granted_region.pb"
803 );
804 let granted = GrantedRegion::from(PbGrantedRegion::decode(legacy_bytes).unwrap());
805 assert_eq!(
806 granted,
807 GrantedRegion {
808 candidate_lease_id: None,
809 extensions: HashMap::from([("plugin".to_string(), b"payload".to_vec())]),
810 ..GrantedRegion::new(RegionId::new(1024, 1), RegionRole::Follower)
811 }
812 );
813
814 assert_eq!(PbGrantedRegion::from(granted).encode_to_vec(), legacy_bytes);
815 }
816
817 #[test]
818 fn test_granted_region_candidate_lease_id_wire() {
819 use prost::Message;
820
821 let granted = GrantedRegion {
822 candidate_lease_id: Some(7),
823 ..GrantedRegion::new(RegionId::new(1024, 1), RegionRole::Follower)
824 };
825 let bytes: &[u8] = &[
828 0x08, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01, 0x10, 0x01, 0x18, 0x07,
829 ];
830 assert_eq!(
831 PbGrantedRegion::from(granted.clone()).encode_to_vec(),
832 bytes
833 );
834 assert_eq!(
835 GrantedRegion::from(PbGrantedRegion::decode(bytes).unwrap()),
836 granted
837 );
838 }
839
840 #[test]
841 fn region_statistic_flush_bytes_compatibility() {
842 let legacy_bytes = br#"{
843 "num_rows": 1,
844 "memtable_size": 2,
845 "wal_size": 3,
846 "manifest_size": 4,
847 "sst_size": 5,
848 "sst_num": 6,
849 "index_size": 7,
850 "manifest": {
851 "Mito": {
852 "manifest_version": 8,
853 "flushed_entry_id": 9,
854 "file_removed_cnt": 10
855 }
856 },
857 "written_bytes": 11
858 }"#;
859 let mut statistic = RegionStatistic::deserialize_from_slice(legacy_bytes).unwrap();
860 assert_eq!(statistic.ingested_parquet_bytes, 0);
861 statistic.ingested_parquet_bytes = 1234;
862 let encoded = statistic.serialize_to_vec().unwrap();
863 let decoded = RegionStatistic::deserialize_from_slice(&encoded).unwrap();
864 assert_eq!(decoded.ingested_parquet_bytes, 1234);
865 let legacy: serde_json::Value = serde_json::from_slice(legacy_bytes).unwrap();
866 let mut current: serde_json::Value = serde_json::from_slice(&encoded).unwrap();
867 assert_eq!(current["ingested_parquet_bytes"], 1234);
868 assert!(current.get("flushed_parquet_bytes").is_none());
869 let mut old_wire = current.clone();
870 let bytes = old_wire
871 .as_object_mut()
872 .unwrap()
873 .remove("ingested_parquet_bytes")
874 .unwrap();
875 old_wire["flushed_parquet_bytes"] = bytes;
876 assert_eq!(
877 serde_json::from_value::<RegionStatistic>(old_wire)
878 .unwrap()
879 .ingested_parquet_bytes,
880 1234
881 );
882 for (key, value) in legacy.as_object().unwrap() {
883 assert_eq!(¤t[key], value);
884 }
885 current
886 .as_object_mut()
887 .unwrap()
888 .remove("ingested_parquet_bytes");
889 assert_eq!(
890 serde_json::from_value::<RegionStatistic>(current)
891 .unwrap()
892 .ingested_parquet_bytes,
893 0
894 );
895 }
896
897 #[test]
898 fn region_statistic_deserializes_without_query_stats() {
899 let statistic: RegionStatistic = serde_json::from_value(json!({
900 "num_rows": 1,
901 "memtable_size": 2,
902 "wal_size": 3,
903 "manifest_size": 4,
904 "sst_size": 5,
905 "sst_num": 6,
906 "index_size": 7,
907 "manifest": {
908 "Mito": {
909 "manifest_version": 8,
910 "flushed_entry_id": 9,
911 "file_removed_cnt": 10
912 }
913 },
914 "written_bytes": 11
915 }))
916 .unwrap();
917
918 assert_eq!(statistic.query_cpu_time, 0);
919 assert_eq!(statistic.query_scanned_bytes, 0);
920 }
921}
922
923#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
925pub enum SyncRegionFromRequest {
926 FromManifest(RegionManifestInfo),
929 FromRegion {
935 source_region_id: RegionId,
937 parallelism: usize,
939 },
940}
941
942impl From<RegionManifestInfo> for SyncRegionFromRequest {
943 fn from(manifest_info: RegionManifestInfo) -> Self {
944 SyncRegionFromRequest::FromManifest(manifest_info)
945 }
946}
947
948impl SyncRegionFromRequest {
949 pub fn from_manifest(manifest_info: RegionManifestInfo) -> Self {
951 SyncRegionFromRequest::FromManifest(manifest_info)
952 }
953
954 pub fn from_region(source_region_id: RegionId, parallelism: usize) -> Self {
956 SyncRegionFromRequest::FromRegion {
957 source_region_id,
958 parallelism,
959 }
960 }
961
962 pub fn is_from_manifest(&self) -> bool {
964 matches!(self, SyncRegionFromRequest::FromManifest { .. })
965 }
966
967 pub fn into_region_manifest_info(self) -> Option<RegionManifestInfo> {
971 match self {
972 SyncRegionFromRequest::FromManifest(manifest_info) => Some(manifest_info),
973 SyncRegionFromRequest::FromRegion { .. } => None,
974 }
975 }
976}
977
978#[derive(Debug)]
980pub enum SyncRegionFromResponse {
981 NotSupported,
982 Mito {
983 synced: bool,
985 },
986 Metric {
987 metadata_synced: bool,
989 data_synced: bool,
991 new_opened_logical_region_ids: Vec<RegionId>,
994 },
995}
996
997impl SyncRegionFromResponse {
998 pub fn is_data_synced(&self) -> bool {
1000 match self {
1001 SyncRegionFromResponse::NotSupported => false,
1002 SyncRegionFromResponse::Mito { synced } => *synced,
1003 SyncRegionFromResponse::Metric { data_synced, .. } => *data_synced,
1004 }
1005 }
1006
1007 pub fn is_mito(&self) -> bool {
1009 matches!(self, SyncRegionFromResponse::Mito { .. })
1010 }
1011
1012 pub fn is_metric(&self) -> bool {
1014 matches!(self, SyncRegionFromResponse::Metric { .. })
1015 }
1016
1017 pub fn new_opened_logical_region_ids(self) -> Option<Vec<RegionId>> {
1019 match self {
1020 SyncRegionFromResponse::Metric {
1021 new_opened_logical_region_ids,
1022 ..
1023 } => Some(new_opened_logical_region_ids),
1024 _ => None,
1025 }
1026 }
1027}
1028
1029#[derive(Debug, Clone)]
1031pub struct RemapManifestsRequest {
1032 pub region_id: RegionId,
1034 pub input_regions: Vec<RegionId>,
1036 pub region_mapping: HashMap<RegionId, Vec<RegionId>>,
1038 pub new_partition_exprs: HashMap<RegionId, String>,
1040}
1041
1042#[derive(Debug, Clone)]
1044pub struct RemapManifestsResponse {
1045 pub manifest_paths: HashMap<RegionId, String>,
1050}
1051
1052#[derive(Debug, Clone)]
1054pub struct MitoCopyRegionFromRequest {
1055 pub source_region_id: RegionId,
1057 pub parallelism: usize,
1059}
1060
1061#[derive(Debug, Clone)]
1062pub struct MitoCopyRegionFromResponse {
1063 pub copied_file_ids: Vec<FileId>,
1068}
1069
1070#[async_trait]
1071pub trait RegionEngine: Send + Sync {
1072 fn name(&self) -> &str;
1074
1075 async fn handle_batch_open_requests(
1077 &self,
1078 parallelism: usize,
1079 requests: Vec<(RegionId, RegionOpenRequest)>,
1080 ) -> Result<BatchResponses, BoxedError> {
1081 let semaphore = Arc::new(Semaphore::new(parallelism));
1082 let mut tasks = Vec::with_capacity(requests.len());
1083
1084 for (region_id, request) in requests {
1085 let semaphore_moved = semaphore.clone();
1086
1087 tasks.push(async move {
1088 let _permit = semaphore_moved.acquire().await.unwrap();
1090 let result = self
1091 .handle_request(region_id, RegionRequest::Open(request))
1092 .await;
1093 (region_id, result)
1094 });
1095 }
1096
1097 Ok(join_all(tasks).await)
1098 }
1099
1100 async fn handle_batch_catchup_requests(
1101 &self,
1102 parallelism: usize,
1103 requests: Vec<(RegionId, RegionCatchupRequest)>,
1104 ) -> Result<BatchResponses, BoxedError> {
1105 let semaphore = Arc::new(Semaphore::new(parallelism));
1106 let mut tasks = Vec::with_capacity(requests.len());
1107
1108 for (region_id, request) in requests {
1109 let semaphore_moved = semaphore.clone();
1110
1111 tasks.push(async move {
1112 let _permit = semaphore_moved.acquire().await.unwrap();
1114 let result = self
1115 .handle_request(region_id, RegionRequest::Catchup(request))
1116 .await;
1117 (region_id, result)
1118 });
1119 }
1120
1121 Ok(join_all(tasks).await)
1122 }
1123
1124 fn handle_batch_put_requests(
1132 self: Arc<Self>,
1133 requests: Vec<(RegionId, RegionPutRequest)>,
1134 ) -> Vec<BatchPutResponse>
1135 where
1136 Self: 'static,
1137 {
1138 requests
1139 .into_iter()
1140 .map(|(region_id, request)| {
1141 let engine = self.clone();
1142 let response = async move {
1143 engine
1144 .handle_request(region_id, RegionRequest::Put(request))
1145 .await
1146 }
1147 .boxed();
1148 (vec![region_id], response)
1149 })
1150 .collect()
1151 }
1152
1153 async fn handle_batch_ddl_requests(
1154 &self,
1155 request: BatchRegionDdlRequest,
1156 ) -> Result<RegionResponse, BoxedError> {
1157 let requests = request.into_region_requests();
1158
1159 let mut affected_rows = 0;
1160 let mut extensions = HashMap::new();
1161
1162 for (region_id, request) in requests {
1163 let result = self.handle_request(region_id, request).await?;
1164 affected_rows += result.affected_rows;
1165 extensions.extend(result.extensions);
1166 }
1167
1168 Ok(RegionResponse {
1169 affected_rows,
1170 extensions,
1171 metadata: Vec::new(),
1172 })
1173 }
1174
1175 async fn handle_request(
1177 &self,
1178 region_id: RegionId,
1179 request: RegionRequest,
1180 ) -> Result<RegionResponse, BoxedError>;
1181
1182 async fn get_committed_sequence(
1184 &self,
1185 region_id: RegionId,
1186 ) -> Result<SequenceNumber, BoxedError>;
1187
1188 async fn handle_query(
1190 &self,
1191 region_id: RegionId,
1192 request: ScanRequest,
1193 ) -> Result<RegionScannerRef, BoxedError>;
1194
1195 fn query_memory_tracker(&self) -> Option<QueryMemoryTracker> {
1197 None
1198 }
1199
1200 async fn get_metadata(&self, region_id: RegionId) -> Result<RegionMetadataRef, BoxedError>;
1202
1203 fn region_statistic(&self, region_id: RegionId) -> Option<RegionStatistic>;
1205
1206 async fn stop(&self) -> Result<(), BoxedError>;
1208
1209 fn set_region_role(&self, region_id: RegionId, role: RegionRole) -> Result<(), BoxedError>;
1215
1216 fn set_region_role_with_lease(
1226 &self,
1227 region_id: RegionId,
1228 role: RegionRole,
1229 sent_at: Instant,
1230 deadline: Instant,
1231 candidate_lease_id: Option<u64>,
1232 ) -> Result<bool, BoxedError>;
1233
1234 async fn sync_region(
1236 &self,
1237 region_id: RegionId,
1238 request: SyncRegionFromRequest,
1239 ) -> Result<SyncRegionFromResponse, BoxedError>;
1240
1241 async fn remap_manifests(
1243 &self,
1244 request: RemapManifestsRequest,
1245 ) -> Result<RemapManifestsResponse, BoxedError>;
1246
1247 async fn set_region_role_state_gracefully(
1251 &self,
1252 region_id: RegionId,
1253 region_role_state: SettableRegionRoleState,
1254 ) -> Result<SetRegionRoleStateResponse, BoxedError>;
1255
1256 fn role(&self, region_id: RegionId) -> Option<RegionRole>;
1260
1261 fn as_any(&self) -> &dyn Any;
1262}
1263
1264pub type RegionEngineRef = Arc<dyn RegionEngine>;
1265
1266pub struct SinglePartitionScanner {
1268 stream: Mutex<Option<SendableRecordBatchStream>>,
1269 schema: SchemaRef,
1270 properties: ScannerProperties,
1271 metadata: RegionMetadataRef,
1272 snapshot_sequence: Option<SequenceNumber>,
1273}
1274
1275impl SinglePartitionScanner {
1276 pub fn new(
1278 stream: SendableRecordBatchStream,
1279 append_mode: bool,
1280 metadata: RegionMetadataRef,
1281 snapshot_sequence: Option<SequenceNumber>,
1282 ) -> Self {
1283 let schema = stream.schema();
1284 Self {
1285 stream: Mutex::new(Some(stream)),
1286 schema,
1287 properties: ScannerProperties::default().with_append_mode(append_mode),
1288 metadata,
1289 snapshot_sequence,
1290 }
1291 }
1292}
1293
1294impl Debug for SinglePartitionScanner {
1295 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1296 write!(f, "SinglePartitionScanner: <SendableRecordBatchStream>")
1297 }
1298}
1299
1300impl RegionScanner for SinglePartitionScanner {
1301 fn name(&self) -> &str {
1302 "SinglePartition"
1303 }
1304
1305 fn properties(&self) -> &ScannerProperties {
1306 &self.properties
1307 }
1308
1309 fn schema(&self) -> SchemaRef {
1310 self.schema.clone()
1311 }
1312
1313 fn prepare(&mut self, request: PrepareRequest) -> Result<(), BoxedError> {
1314 self.properties.prepare(request);
1315 Ok(())
1316 }
1317
1318 fn scan_partition(
1319 &self,
1320 _ctx: &QueryScanContext,
1321 _metrics_set: &ExecutionPlanMetricsSet,
1322 _partition: usize,
1323 ) -> Result<SendableRecordBatchStream, BoxedError> {
1324 let mut stream = self.stream.lock().unwrap();
1325 let result = stream
1326 .take()
1327 .or_else(|| Some(Box::pin(EmptyRecordBatchStream::new(self.schema.clone()))));
1328 Ok(result.unwrap())
1329 }
1330
1331 fn has_predicate_without_region(&self) -> bool {
1332 false
1333 }
1334
1335 fn add_dyn_filter_to_predicate(
1336 &mut self,
1337 filter_exprs: Vec<Arc<dyn datafusion_physical_plan::PhysicalExpr>>,
1338 ) -> Vec<bool> {
1339 vec![false; filter_exprs.len()]
1340 }
1341
1342 fn metadata(&self) -> RegionMetadataRef {
1343 self.metadata.clone()
1344 }
1345
1346 fn set_logical_region(&mut self, logical_region: bool) {
1347 self.properties.set_logical_region(logical_region);
1348 }
1349
1350 fn set_query_load_region_id(&mut self, region_id: RegionId) {
1351 self.properties.set_query_load_region_id(region_id);
1352 }
1353
1354 fn snapshot_sequence(&self) -> Option<SequenceNumber> {
1355 self.snapshot_sequence
1356 }
1357}
1358
1359impl DisplayAs for SinglePartitionScanner {
1360 fn fmt_as(&self, _t: DisplayFormatType, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1361 write!(f, "{:?}", self)
1362 }
1363}