Struct MetricEngineInner 

struct MetricEngineInner {
    mito: MitoEngine,
    metadata_region: MetadataRegion,
    data_region: DataRegion,
    state: Arc<RwLock<MetricEngineState>>,
    config: EngineConfig,
    row_modifier: RowModifier,
    flush_task: RepeatedTask<Error>,
}

Fields

mito: MitoEngine

metadata_region: MetadataRegion

data_region: DataRegion

state: Arc<RwLock<MetricEngineState>>

config: EngineConfig

row_modifier: RowModifier

flush_task: RepeatedTask<Error>

Implementations

impl MetricEngineInner

pub async fn alter_regions( &self, requests: Vec<(RegionId, RegionAlterRequest)>, extension_return_value: &mut HashMap<String, Vec<u8>>, ) -> Result<AffectedRows>

fn group_logical_region_requests_by_physical_region_id( &self, requests: Vec<(RegionId, RegionAlterRequest)>, ) -> Result<HashMap<RegionId, Vec<(RegionId, RegionAlterRequest)>>>

Groups the alter logical region requests by physical region id.

pub async fn alter_logical_regions( &self, physical_region_id: RegionId, requests: Vec<(RegionId, RegionAlterRequest)>, extension_return_value: &mut HashMap<String, Vec<u8>>, ) -> Result<AffectedRows>

Alter multiple logical regions on the same physical region.

async fn alter_physical_region( &self, region_id: RegionId, request: RegionAlterRequest, ) -> Result<()>

impl MetricEngineInner

pub async fn catchup_region( &self, region_id: RegionId, req: RegionCatchupRequest, ) -> Result<AffectedRows>

impl MetricEngineInner

pub async fn close_region( &self, region_id: RegionId, _req: RegionCloseRequest, ) -> Result<AffectedRows>

pub(crate) async fn close_physical_region( &self, region_id: RegionId, ) -> Result<AffectedRows>

impl MetricEngineInner

pub async fn create_regions( &self, requests: Vec<(RegionId, RegionCreateRequest)>, extension_return_value: &mut HashMap<String, Vec<u8>>, ) -> Result<AffectedRows>

async fn create_physical_region( &self, region_id: RegionId, request: RegionCreateRequest, extension_return_value: &mut HashMap<String, Vec<u8>>, ) -> Result<()>

Initialize a physical metric region at given region id.

async fn create_logical_regions( &self, physical_region_id: RegionId, requests: Vec<(RegionId, RegionCreateRequest)>, extension_return_value: &mut HashMap<String, Vec<u8>>, ) -> Result<()>

Create multiple logical regions on the same physical region.

fn verify_region_create_request(request: &RegionCreateRequest) -> Result<()>

Check if

• internal columns are not occupied
• required table option is present ([PHYSICAL_TABLE_METADATA_KEY] or [LOGICAL_TABLE_METADATA_KEY])

fn transform_region_id(region_id: RegionId) -> (RegionId, RegionId)

Build data region id and metadata region id from the given region id.

Return value: (data_region_id, metadata_region_id)

pub fn create_request_for_metadata_region( &self, request: &RegionCreateRequest, ) -> RegionCreateRequest

Build [RegionCreateRequest] for metadata region

This method will append [METADATA_REGION_SUBDIR] to the given region_dir.

pub fn create_request_for_data_region( &self, request: &RegionCreateRequest, ) -> RegionCreateRequest

Convert [RegionCreateRequest] for data region.

All tag columns in the original request will be converted to value columns. Those columns real semantic type is stored in metadata region.

This will also add internal columns to the request.

fn internal_column_metadata() -> [ColumnMetadata; 2]

Generate internal column metadata.

Return [table_id_col, tsid_col]

impl MetricEngineInner

pub async fn drop_region( &self, region_id: RegionId, req: RegionDropRequest, ) -> Result<AffectedRows>

async fn drop_physical_region( &self, region_id: RegionId, ) -> Result<AffectedRows>

async fn drop_logical_region( &self, logical_region_id: RegionId, physical_region_id: RegionId, ) -> Result<AffectedRows>

impl MetricEngineInner

pub async fn flush_region( &self, region_id: RegionId, req: RegionFlushRequest, ) -> Result<AffectedRows>

impl MetricEngineInner

pub async fn handle_batch_open_requests( &self, parallelism: usize, requests: Vec<(RegionId, RegionOpenRequest)>, ) -> Result<BatchResponses>

async fn close_physical_region_on_recovery_failure( &self, physical_region_id: RegionId, )

async fn open_physical_region_with_results( &self, metadata_region_result: Option<Result<RegionResponse, BoxedError>>, data_region_result: Option<Result<RegionResponse, BoxedError>>, physical_region_id: RegionId, physical_region_options: PhysicalRegionOptions, ) -> Result<RegionResponse>

pub async fn open_region( &self, region_id: RegionId, request: RegionOpenRequest, ) -> Result<AffectedRows>

Open a metric region.

Only open requests to a physical region matter. Those to logical regions are actually an empty operation – it only check if the request is valid. Since logical regions are multiplexed over physical regions, they are always “open”.

If trying to open a logical region whose physical region is not open, metric engine will throw a RegionNotFound error.

fn transform_open_physical_region_request( &self, request: RegionOpenRequest, ) -> (RegionOpenRequest, RegionOpenRequest)

Transform the open request to open metadata region and data region.

Returns:

• The open request for metadata region.
• The open request for data region.

async fn open_physical_region( &self, region_id: RegionId, request: RegionOpenRequest, ) -> Result<AffectedRows>

Invokes mito engine to open physical regions (data and metadata).

pub(crate) async fn recover_states( &self, physical_region_id: RegionId, physical_region_options: PhysicalRegionOptions, ) -> Result<Vec<RegionId>>

Recovers MetricEngineState from physical region (idnefied by the given region id).

Includes:

• Record physical region’s column names
• Record the mapping between logical region id and physical region id

Returns new opened logical region ids.

impl MetricEngineInner

pub async fn put_region( &self, region_id: RegionId, request: RegionPutRequest, ) -> Result<AffectedRows>

Dispatch region put request

async fn put_logical_region( &self, logical_region_id: RegionId, request: RegionPutRequest, ) -> Result<AffectedRows>

async fn verify_put_request( &self, logical_region_id: RegionId, physical_region_id: RegionId, request: &RegionPutRequest, ) -> Result<()>

Verifies a put request for a logical region against its corresponding metadata region.

Includes:

• Check if the logical region exists
• Check if the columns exist

fn modify_rows( &self, physical_region_id: RegionId, table_id: TableId, rows: &mut Rows, encoding: PrimaryKeyEncoding, ) -> Result<()>

Perform metric engine specific logic to incoming rows.

• Add table_id column
• Generate tsid

impl MetricEngineInner

pub async fn read_region( &self, region_id: RegionId, request: ScanRequest, ) -> Result<RegionScannerRef>

async fn read_physical_region( &self, region_id: RegionId, request: ScanRequest, ) -> Result<RegionScannerRef>

Proxy the read request to underlying physical region (mito engine).

async fn read_logical_region( &self, logical_region_id: RegionId, request: ScanRequest, ) -> Result<RegionScannerRef>

pub async fn get_last_seq_num( &self, region_id: RegionId, ) -> Result<SequenceNumber>

pub async fn load_region_metadata( &self, region_id: RegionId, ) -> Result<RegionMetadataRef>

pub fn is_physical_region(&self, region_id: RegionId) -> bool

Returns true if it’s a physical region.

async fn get_physical_region_id( &self, logical_region_id: RegionId, ) -> Result<RegionId>

async fn transform_request( &self, physical_region_id: RegionId, logical_region_id: RegionId, request: ScanRequest, ) -> Result<ScanRequest>

Transform the [ScanRequest] from logical region to physical data region.

fn table_id_filter(&self, logical_region_id: RegionId) -> Expr

Generate a filter on the table id column.

pub async fn transform_projection( &self, physical_region_id: RegionId, logical_region_id: RegionId, origin_projection: &[usize], ) -> Result<Vec<usize>>

Transform the projection from logical region to physical region.

This method will not preserve internal columns.

pub async fn default_projection( &self, physical_region_id: RegionId, logical_region_id: RegionId, ) -> Result<Vec<usize>>

Default projection for a logical region. Includes non-internal columns

pub async fn logical_region_metadata( &self, physical_region_id: RegionId, logical_region_id: RegionId, ) -> Result<RegionMetadataRef>

impl MetricEngineInner

pub async fn load_logical_columns( &self, physical_region_id: RegionId, logical_region_id: RegionId, ) -> Result<Vec<ColumnMetadata>>

Load column metadata of a logical region.

The return value is ordered on column name.

pub async fn load_logical_column_names( &self, physical_region_id: RegionId, logical_region_id: RegionId, ) -> Result<Vec<String>>

Load logical column names of a logical region.

The return value is ordered on column name alphabetically.

impl MetricEngineInner

pub async fn sync_region( &self, region_id: RegionId, manifest_info: RegionManifestInfo, ) -> Result<SyncManifestResponse>