Struct RegionServer

pub struct RegionServer {
    inner: Arc<RegionServerInner>,
}

Fields

inner: Arc<RegionServerInner>

Implementations

impl RegionServer

pub fn new( query_engine: QueryEngineRef, runtime: Runtime, event_listener: RegionServerEventListenerRef, ) -> 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, ) -> Self

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

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 async fn handle_batch_open_requests( &self, parallelism: usize, requests: Vec<(RegionId, RegionOpenRequest)>, ) -> Result<Vec<RegionId>>

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

async fn table_provider( &self, region_id: RegionId, ctx: Option<&QueryContext>, ) -> 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, ) -> Result<SendableRecordBatchStream>

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

pub async fn handle_read( &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 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 handle_sync_region_request( &self, request: &SyncRequest, ) -> Result<RegionResponse>

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

Sync region manifest and registers new opened logical regions.

Trait Implementations

impl Clone for RegionServer

fn clone(&self) -> RegionServer

Returns a copy 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<'life0, 'async_trait>( &'life0 self, request: Body, ) -> Pin<Box<dyn Future<Output = ServerResult<RegionResponseV1>> + Send + 'async_trait>>

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