Struct Transaction 

pub struct Transaction {
    pub read_version: u64,
    pub uuid: String,
    pub operation: Operation,
    pub tag: Option<String>,
    pub transaction_properties: Option<Arc<HashMap<String, String>>>,
}

A change to a dataset that can be retried

This contains enough information to be able to build the next manifest, given the current manifest.

Fields

read_version: u64

The version of the table this transaction is based off of. If this is the first transaction, this should be 0.

uuid: String

operation: Operation

tag: Option<String>

transaction_properties: Option<Arc<HashMap<String, String>>>

Implementations

impl Transaction

pub fn new_from_version(read_version: u64, operation: Operation) -> Self

pub fn new(read_version: u64, operation: Operation, tag: Option<String>) -> Self

impl Transaction

pub fn prune_updated_fields_from_indices( indices: &mut [IndexMetadata], updated_fragments: &[Fragment], fields_modified: &[u32], )

If an operation modifies one or more fields in a fragment then we need to remove that fragment from any indices that cover one of the modified fields.

impl Transaction

pub async fn restore_old_manifest( object_store: &ObjectStore, commit_handler: &dyn CommitHandler, base_path: &Path, version: u64, config: &ManifestBuildConfig, tx_path: &str, current_manifest: &Manifest, ) -> Result<(Manifest, Vec<IndexMetadata>)>

pub fn logical_index_segments(indices: &[IndexMetadata]) -> LogicalIndexSegments

Every non-system logical index, mapped to what determines its coverage.

A logical index may be backed by several physical segments, so “did this index change” is a question about the whole set. Sorted by UUID so the two sides compare positionally.

pub fn apply_mem_wal_index_coverage( final_indices: &mut [IndexMetadata], segments_before: &LogicalIndexSegments, read_version_state: Option<ReadVersionState<'_>>, new_version: u64, ) -> Result<()>

Apply MemWAL index-coverage rules once the final index list is known.

Coverage records that a base-table index contains the rows a compaction copied in, and the WAL pod retires SSTables against it.

It is derived, not reported. An index covering every fragment live at the transaction’s read version holds every row compaction had copied in by then, so it is caught up to that version’s compacted_sstables. That is the only proof available: nothing maps a generation to the fragments its rows landed in, so covering the table as the transaction read it is how an index shows it covered those rows. Fragments appended since are a later gap.

Deriving rather than transmitting means no claim can go stale between inspection and commit, the answer survives rebase (read_version is fixed for a transaction’s life), and any operation can earn coverage – an ordinary reindex that fully covers no longer has to throw its work away and wait for a repair.

Only meaningful once catch-up is required, where a missing entry means “not caught up” and the SSTables stay. A legacy table reads a missing entry as “fully caught up”, so this leaves it untouched rather than making the table look more covered than it is.

pub fn withdraw_coverage_invalidated_after_build( indices: &mut [IndexMetadata], changed: &[String], new_version: u64, ) -> Result<()>

Drop coverage for indices a post-build_manifest step narrowed.

The derivation runs while the manifest is being built, but the index list is not final there: migrate_indices can recalculate a segment’s fragment bitmap and keep its UUID, so an index can narrow after its position was decided. It reports which ones it touched rather than the caller re-snapshotting every bitmap to find out. Only ever removes.

pub fn build_manifest( &self, current_manifest: Option<&Manifest>, current_indices: Vec<IndexMetadata>, transaction_file_path: &str, config: &ManifestBuildConfig, ) -> Result<(Manifest, Vec<IndexMetadata>)>

Create a new manifest from the current manifest and the transaction.

current_manifest should only be None if the dataset does not yet exist.

pub fn build_manifest_with_read_version( &self, current_manifest: Option<&Manifest>, current_indices: Vec<IndexMetadata>, transaction_file_path: &str, config: &ManifestBuildConfig, read_version_state: Option<ReadVersionState<'_>>, ) -> Result<(Manifest, Vec<IndexMetadata>)>

Self::build_manifest with the version this transaction read.

Supplied by the commit path, which already materializes that version. None where there is none to read – dataset creation and detached commits – in which case no index can be shown to cover it and coverage is left as the invalidation rules put it.

Trait Implementations

impl Clone for Transaction

fn clone(&self) -> Transaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Transaction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl DeepSizeOf for Transaction

fn deep_size_of_children(&self, __context: &mut Context) -> usize

fn deep_size_of(&self) -> usize

impl From<&Transaction> for Transaction

fn from(value: &Transaction) -> Self

Converts to this type from the input type.

impl From<&Transaction> for Transaction

fn from(value: &Transaction) -> Self

Converts to this type from the input type.

impl PartialEq for Transaction

fn eq(&self, other: &Transaction) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Transaction

impl TryFrom<Transaction> for Transaction

type Error = Error

The type returned in the event of a conversion error.

fn try_from(message: Transaction) -> Result<Self>

Performs the conversion.