linkrs-core 0.1.0

use crate::error::StorageResult;
use crate::types::{LabelId, Timestamp, VertexId};
use crate::Value;

use std::sync::Arc;

use super::redo::{
    AddEdgePropRedo, AddVertexPropRedo, ClearSpaceRedo, CreateEdgeIndexRedo, CreateEdgeTypeRedo,
    CreateMacroRedo, CreateSpaceRedo, CreateTagIndexRedo, CreateTypeAliasRedo, CreateVertexTypeRedo,
    DeleteEdgePropRedo, DeleteEdgeRedo, DeleteEdgeTypeRedo, DeleteVertexPropRedo,
    DeleteVertexPropsRedo, DeleteVertexTypeRedo, DropEdgeIndexRedo, DropMacroRedo, DropSpaceRedo,
    DropTagIndexRedo, DropTypeAliasRedo, InsertEdgeRedo, RenameEdgePropRedo, RenameEdgeTypeRedo,
    RenameTagRedo, RenameVertexPropRedo, UpdateEdgePropRedo, UpdateSequenceRedo,
};
use super::types::{WalOpType, WalResult};

pub trait WalWriter: Send + Sync {
    fn open(&mut self) -> WalResult<()>;
    fn close(&mut self);
    fn append(&mut self, data: &[u8]) -> WalResult<()>;

    fn append_entry(
        &mut self,
        op_type: WalOpType,
        timestamp: Timestamp,
        payload: &[u8],
    ) -> WalResult<()>;
    fn sync(&self) -> WalResult<()>;

    fn wait_for_durable(&self, _appended_lsn: u64) -> WalResult<()> {
        self.sync()
    }
}

pub trait RecoveryApplier {
    // Data Operations
    fn replay_insert_vertex(
        &self,
        label: LabelId,
        vid: VertexId,
        properties: &[(Arc<str>, Value)],
        ts: Timestamp,
    ) -> StorageResult<()>;

    fn replay_insert_edge(&self, redo: &InsertEdgeRedo, ts: Timestamp) -> StorageResult<()>;

    fn replay_update_vertex_prop(
        &self,
        label: LabelId,
        vid: VertexId,
        prop_name: &str,
        value: &Value,
        ts: Timestamp,
    ) -> StorageResult<()>;

    fn replay_update_edge_prop(
        &self,
        redo: &UpdateEdgePropRedo,
        ts: Timestamp,
    ) -> StorageResult<()>;

    fn replay_delete_vertex(
        &self,
        label: LabelId,
        vid: VertexId,
        ts: Timestamp,
    ) -> StorageResult<()>;

    fn replay_delete_edge(&self, redo: &DeleteEdgeRedo, ts: Timestamp) -> StorageResult<()>;

    fn replay_delete_vertex_props(
        &self,
        redo: &DeleteVertexPropsRedo,
        ts: Timestamp,
    ) -> StorageResult<()> {
        let _ = (redo, ts);
        Ok(())
    }

    // Schema Operations
    fn replay_create_space(&self, redo: &CreateSpaceRedo, ts: Timestamp) -> StorageResult<()>;

    fn replay_drop_space(&self, redo: &DropSpaceRedo, ts: Timestamp) -> StorageResult<()>;

    fn replay_clear_space(&self, redo: &ClearSpaceRedo, ts: Timestamp) -> StorageResult<()>;

    fn replay_create_vertex_type(
        &self,
        redo: &CreateVertexTypeRedo,
        ts: Timestamp,
    ) -> StorageResult<()>;

    fn replay_create_edge_type(
        &self,
        redo: &CreateEdgeTypeRedo,
        ts: Timestamp,
    ) -> StorageResult<()>;

    fn replay_delete_vertex_type(
        &self,
        redo: &DeleteVertexTypeRedo,
        ts: Timestamp,
    ) -> StorageResult<()>;

    fn replay_delete_edge_type(
        &self,
        redo: &DeleteEdgeTypeRedo,
        ts: Timestamp,
    ) -> StorageResult<()>;

    fn replay_add_vertex_prop(&self, redo: &AddVertexPropRedo, ts: Timestamp) -> StorageResult<()>;

    fn replay_add_edge_prop(&self, redo: &AddEdgePropRedo, ts: Timestamp) -> StorageResult<()>;

    fn replay_delete_vertex_prop(
        &self,
        redo: &DeleteVertexPropRedo,
        ts: Timestamp,
    ) -> StorageResult<()>;

    fn replay_delete_edge_prop(
        &self,
        redo: &DeleteEdgePropRedo,
        ts: Timestamp,
    ) -> StorageResult<()>;

    fn replay_rename_vertex_prop(
        &self,
        redo: &RenameVertexPropRedo,
        ts: Timestamp,
    ) -> StorageResult<()>;

    fn replay_rename_edge_prop(
        &self,
        redo: &RenameEdgePropRedo,
        ts: Timestamp,
    ) -> StorageResult<()>;

    fn replay_rename_tag(&self, redo: &RenameTagRedo, ts: Timestamp) -> StorageResult<()>;

    fn replay_rename_edge_type(
        &self,
        redo: &RenameEdgeTypeRedo,
        ts: Timestamp,
    ) -> StorageResult<()>;

    // System Operations
    fn replay_create_tag_index(
        &self,
        redo: &CreateTagIndexRedo,
        ts: Timestamp,
    ) -> StorageResult<()>;

    fn replay_drop_tag_index(&self, redo: &DropTagIndexRedo, ts: Timestamp) -> StorageResult<()>;

    fn replay_create_edge_index(
        &self,
        redo: &CreateEdgeIndexRedo,
        ts: Timestamp,
    ) -> StorageResult<()>;

    fn replay_drop_edge_index(&self, redo: &DropEdgeIndexRedo, ts: Timestamp) -> StorageResult<()>;

    fn replay_compact(&self, _ts: Timestamp) -> StorageResult<()> {
        Ok(())
    }

    fn replay_update_sequence(
        &self,
        redo: &UpdateSequenceRedo,
        ts: Timestamp,
    ) -> StorageResult<()> {
        let _ = (redo, ts);
        Ok(())
    }

    fn replay_create_macro(&self, redo: &CreateMacroRedo, ts: Timestamp) -> StorageResult<()> {
        let _ = (redo, ts);
        Ok(())
    }

    fn replay_drop_macro(&self, redo: &DropMacroRedo, ts: Timestamp) -> StorageResult<()> {
        let _ = (redo, ts);
        Ok(())
    }

    fn replay_create_type_alias(
        &self,
        redo: &CreateTypeAliasRedo,
        ts: Timestamp,
    ) -> StorageResult<()> {
        let _ = (redo, ts);
        Ok(())
    }

    fn replay_drop_type_alias(&self, redo: &DropTypeAliasRedo, ts: Timestamp) -> StorageResult<()> {
        let _ = (redo, ts);
        Ok(())
    }
}