Struct AlterTableProcedure

pub struct AlterTableProcedure {
    context: DdlContext,
    data: AlterTableData,
    new_table_info: Option<TableInfo>,
    executor: AlterTableExecutor,
}

The alter table procedure

Fields

context: DdlContext

The runtime context.

data: AlterTableData

The serialized data.

new_table_info: Option<TableInfo>

Cached new table metadata in the prepare step. If we recover the procedure from json, then the table info value is not cached. But we already validated it in the prepare step.

executor: AlterTableExecutor

The alter table executor.

Implementations

impl AlterTableProcedure

pub(crate) async fn fill_table_info(&mut self) -> Result<()>

Fetches the table info.

impl AlterTableProcedure

pub(crate) fn make_region_alter_kind(&self) -> Result<Option<Kind>>

Makes alter kind proto that all regions can reuse. Region alter request always add columns if not exist.

impl AlterTableProcedure

pub const TYPE_NAME: &'static str = "metasrv-procedure::AlterTable"

pub fn new( table_id: TableId, task: AlterTableTask, context: DdlContext, ) -> Result<Self>

pub fn from_json(json: &str, context: DdlContext) -> ProcedureResult<Self>

pub(crate) async fn on_prepare(&mut self) -> Result<Status>

fn table_poison_key(&self) -> PoisonKey

async fn put_poison( &self, ctx_provider: &dyn ContextProvider, procedure_id: ProcedureId, ) -> Result<()>

pub async fn submit_alter_region_requests( &mut self, procedure_id: ProcedureId, ctx_provider: &dyn ContextProvider, ) -> Result<Status>

fn handle_alter_region_response( &mut self, results: Vec<RegionResponse>, ) -> Result<()>

async fn submit_sync_region_requests( &mut self, results: &[RegionResponse], region_routes: &[RegionRoute], )

pub(crate) async fn on_update_metadata(&mut self) -> Result<Status>

Update table metadata.

async fn on_broadcast(&mut self) -> Result<Status>

Broadcasts the invalidating table cache instructions.

fn lock_key_inner(&self) -> Vec<StringKey>

Trait Implementations

impl Procedure for AlterTableProcedure

fn type_name(&self) -> &str

Type name of the procedure.

fn execute<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 ProcedureContext, ) -> Pin<Box<dyn Future<Output = ProcedureResult<Status>> + Send + 'async_trait>>

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

Execute the procedure.

fn dump(&self) -> ProcedureResult<String>

Dump the state of the procedure to a string.

fn lock_key(&self) -> LockKey

Returns the LockKey that this procedure needs to acquire.

fn poison_keys(&self) -> PoisonKeys

Returns the PoisonKeys that may cause this procedure to become poisoned during execution.

fn rollback<'life0, 'life1, 'async_trait>( &'life0 mut self, _: &'life1 Context, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Rollback the failed procedure.

fn rollback_supported(&self) -> bool

Indicates whether it supports rolling back the procedure.

fn recover(&mut self) -> Result<(), Error>

The hook is called after the procedure recovery.

fn user_metadata(&self) -> Option<UserMetadata>

Returns the user metadata of the procedure. If the metadata contains the eventable object, you can use UserMetadata::to_event to get the event and emit it to the event recorder.