Struct RegionServer 

pub struct RegionServer {
    inner: Arc<RegionServerInner>,
    flight_compression: FlightCompression,
    suspend: Arc<AtomicBool>,
}

Fields

inner: Arc<RegionServerInner>

flight_compression: FlightCompression

suspend: Arc<AtomicBool>

Implementations

impl RegionServer

pub async fn inspect_sst_manifest_provider( &self, ) -> Result<Arc<dyn TableProvider>>

Expose SSTs listed in Manifest as an in-memory table for inspection.

pub async fn inspect_sst_storage_provider( &self, ) -> Result<Arc<dyn TableProvider>>

Expose SSTs found in storage as an in-memory table for inspection.

pub async fn inspect_sst_index_meta_provider( &self, ) -> Result<Arc<dyn TableProvider>>

Expose index metadata across the engine as an in-memory table.

pub async fn inspect_region_info_provider( &self, ) -> Result<Arc<dyn TableProvider>>

Expose region info across the engine as an in-memory table.

impl RegionServer

pub fn install_remote_dyn_filter_receiver_injector(&self, plugins: &Plugins)

pub(super) fn register_initial_remote_dyn_filter_cleanup( &self, query_ctx: &QueryContextRef, region_id: RegionId, ) -> Option<RemoteDynFilterRegistrationGuard>

pub(super) async fn handle_remote_dyn_filter_request( &self, request: &RemoteDynFilterRequest, ) -> Result<RegionResponse>

async fn handle_remote_dyn_filter_update( &self, query_id: &QueryId, request: &RemoteDynFilterUpdate, ) -> Result<RegionResponse>

async fn handle_remote_dyn_filter_unregister( &self, query_id: &QueryId, request: &RemoteDynFilterUnregister, ) -> Result<RegionResponse>

fn log_remote_dyn_filter_update_outcome( &self, query_id: &QueryId, filter_id: &RemoteDynFilterId, outcome: RemoteDynFilterUpdateOutcome, )

impl RegionServer

pub fn new( query_engine: QueryEngineRef, runtime: Runtime, event_listener: RegionServerEventListenerRef, flight_compression: FlightCompression, ) -> Self

pub fn with_table_provider( query_engine: QueryEngineRef, runtime: Runtime, event_listener: RegionServerEventListenerRef, table_provider_factory: TableProviderFactoryRef, max_concurrent_queries: usize, concurrent_query_limiter_timeout: Duration, flight_compression: FlightCompression, ) -> Self

pub fn register_engine(&mut self, engine: RegionEngineRef)

Registers an engine.

pub fn set_topic_stats_reporter( &mut self, topic_stats_reporter: Box<dyn TopicStatsReporter>, )

Sets the topic stats.

pub fn find_engine( &self, region_id: RegionId, ) -> Result<Option<RegionEngineRef>>

Finds the region’s engine by its id. If the region is not ready, returns None.

pub fn mito_engine(&self) -> Option<MitoEngine>

Gets the MitoEngine if it’s registered.

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

pub async fn handle_batch_catchup_requests( &self, parallelism: usize, requests: Vec<(RegionId, RegionCatchupRequest)>, ) -> Result<Vec<(RegionId, Result<(), BoxedError>)>>

pub async fn handle_request( &self, region_id: RegionId, request: RegionRequest, ) -> Result<RegionResponse>

async fn table_provider( &self, region_id: RegionId, ctx: Option<QueryContextRef>, ) -> Result<Arc<dyn TableProvider>>

Returns a table provider for the region. Will set snapshot sequence if available in the context.

pub async fn handle_remote_read( &self, request: QueryRequest, query_ctx: QueryContextRef, ) -> Result<SendableRecordBatchStream>

Handle reads from remote. They’re often query requests received by our Arrow Flight service.

async fn handle_remote_read_inner( &self, request: QueryRequest, query_ctx: QueryContextRef, ) -> Result<SendableRecordBatchStream>

pub async fn handle_read( &self, request: QueryRequest, ) -> Result<SendableRecordBatchStream>

async fn handle_read_inner( &self, request: QueryRequest, ) -> Result<SendableRecordBatchStream>

pub fn reportable_regions(&self) -> Vec<RegionStat>

Returns all opened and reportable regions.

Notes: except all metrics regions.

pub fn topic_stats(&self) -> Vec<TopicStat>

Returns the reportable topics.

pub fn is_region_leader(&self, region_id: RegionId) -> Option<bool>

pub fn set_region_role( &self, region_id: RegionId, role: RegionRole, ) -> Result<()>

pub async fn set_region_role_state_gracefully( &self, region_id: RegionId, state: SettableRegionRoleState, ) -> Result<SetRegionRoleStateResponse>

Set region role state gracefully.

For [SettableRegionRoleState::Follower]: After the call returns, the engine ensures that no further write or flush operations will succeed in this region.

For [SettableRegionRoleState::DowngradingLeader]: After the call returns, the engine ensures that no further write operations will succeed in this region.

pub fn runtime(&self) -> Runtime

pub fn region_statistic(&self, region_id: RegionId) -> Option<RegionStatistic>

pub async fn stop(&self) -> Result<()>

Stop the region server.

async fn handle_batch_ddl_requests( &self, request: Body, ) -> Result<RegionResponse>

async fn handle_requests_in_parallel( &self, request: Body, ) -> Result<RegionResponse>

async fn handle_requests_in_serial( &self, request: Body, ) -> Result<RegionResponse>

async fn try_handle_metric_batch_puts( &self, requests: Vec<(RegionId, RegionRequest)>, ) -> Result<Either<RegionResponse, Vec<(RegionId, RegionRequest)>>>

Attempts to optimize batch Put requests for metric engine.

Returns Either::Left(response) if optimization succeeded, or Either::Right(original_requests) to fall back to parallel processing.

This avoids cloning requests when optimization cannot be applied.

async fn try_handle_mito_batch_puts( &self, requests: Vec<(RegionId, RegionRequest)>, ) -> Result<Either<RegionResponse, Vec<(RegionId, RegionRequest)>>>

Puts into ready mito regions together through [RegionEngine::handle_batch_put_requests], so that each mito worker gets the puts of the request to its regions at once and writes them in one batch. One ingest task awaits every response at once and accounts each, for the regions it answers, as the per-region path does; it hands the first error back at once and keeps accounting the rest, also when the caller goes away.

Returns Either::Right(original_requests) unless mito_engine_for_batch_puts accepts the requests.

fn mito_engine_for_batch_puts( &self, requests: &[(RegionId, RegionRequest)], ) -> Option<RegionEngineRef>

Returns the mito engine when there are at least two requests, every one a put into a ready mito region.

async fn handle_sync_region_request( &self, request: &SyncRequest, ) -> Result<RegionResponse>

async fn handle_list_metadata_request( &self, request: &ListMetadataRequest, ) -> Result<RegionResponse>

Handles the ListMetadata request and retrieves metadata for specified regions.

Returns the results as a JSON-serialized list in the [RegionResponse]. It serializes non-existing regions as null.

pub async fn sync_region( &self, region_id: RegionId, request: SyncRegionFromRequest, ) -> Result<()>

Sync region manifest and registers new opened logical regions.

pub async fn remap_manifests( &self, request: RemapManifestsRequest, ) -> Result<RemapManifestsResponse>

Remaps manifests from old regions to new regions.

fn is_suspended(&self) -> bool

pub(crate) fn suspend_state(&self) -> Arc<AtomicBool>

Trait Implementations

impl Clone for RegionServer

fn clone(&self) -> RegionServer

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl FlightCraft for RegionServer

fn do_get<'life0, 'async_trait>( &'life0 self, request: Request<Ticket>, ) -> Pin<Box<dyn Future<Output = TonicResult<Response<TonicStream<FlightData>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn do_put<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<FlightData>>, ) -> Pin<Box<dyn Future<Output = Result<Response<Pin<Box<dyn Stream<Item = Result<PutResult, Status>> + Send>>>, Status>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

impl RegionServerHandler for RegionServer

fn handle_region_request<'life0, 'async_trait>( &'life0 self, request: RegionRequestV1, ) -> Pin<Box<dyn Future<Output = ServerResult<RegionResponseV1>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn handle<'life0, 'async_trait>( &'life0 self, request: Body, ) -> Pin<Box<dyn Future<Output = ServerResult<RegionResponseV1>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,