genegraph_storage/lancefmt/pb/

lance.table.rs

// This file is @generated by prost-build.
/// UUID type. encoded as 16 bytes.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Uuid {
    #[prost(bytes = "vec", tag = "1")]
// Includes lance.table (table.proto) and lance.transaction (transaction.proto),
    pub uuid: ::prost::alloc::vec::Vec<u8>,
}
/// Manifest is a global section shared between all the files.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Manifest {
    /// All fields of the dataset, including the nested fields.
    #[prost(message, repeated, tag = "1")]
    pub fields: ::prost::alloc::vec::Vec<super::file::Field>,
    /// Schema metadata.
    #[prost(map = "string, bytes", tag = "5")]
    pub schema_metadata: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::vec::Vec<u8>,
    >,
    /// Fragments of the dataset.
    #[prost(message, repeated, tag = "2")]
    pub fragments: ::prost::alloc::vec::Vec<DataFragment>,
    /// Snapshot version number.
    #[prost(uint64, tag = "3")]
    pub version: u64,
    /// The file position of the version auxiliary data.
    ///   * It is not inheritable between versions.
    ///   * It is not loaded by default during query.
    #[prost(uint64, tag = "4")]
    pub version_aux_data: u64,
    /// The version of the writer that created this file.
    ///
    /// This information may be used to detect whether the file may have known bugs
    /// associated with that writer.
    #[prost(message, optional, tag = "13")]
    pub writer_version: ::core::option::Option<manifest::WriterVersion>,
    /// If present, the file position of the index metadata.
    #[prost(uint64, optional, tag = "6")]
    pub index_section: ::core::option::Option<u64>,
    /// Version creation Timestamp, UTC timezone
    #[prost(message, optional, tag = "7")]
    pub timestamp: ::core::option::Option<::prost_types::Timestamp>,
    /// Optional version tag
    #[prost(string, tag = "8")]
    pub tag: ::prost::alloc::string::String,
    /// Feature flags for readers.
    ///
    /// A bitmap of flags that indicate which features are required to be able to
    /// read the table. If a reader does not recognize a flag that is set, it
    /// should not attempt to read the dataset.
    ///
    /// Known flags:
    /// * 1 << 0: deletion files are present
    /// * 1 << 1: row ids are stable and stored as part of the fragment metadata.
    /// * 1 << 2: use v2 format (deprecated)
    /// * 1 << 3: table config is present
    /// * 1 << 4: dataset uses multiple base paths
    /// * 1 << 5: transaction file writes are disabled
    /// * 1 << 6: data overlay files are present (see DataOverlayFile). Readers that do
    ///    not understand overlays must refuse the dataset, since ignoring an overlay
    ///    would silently return stale base values.
    /// * 1 << 7: some index declares covering columns, so IndexMetadata.fields means
    ///    the keyed columns followed by the carried ones named in covering_fields (see
    ///    IndexMetadata). Readers that do not understand it must refuse the dataset,
    ///    since selecting an index by membership of fields would answer a query on a
    ///    merely-carried column with an index keyed on a different column. Writers must
    ///    refuse it too: one that treats every entry of fields as keyed would maintain
    ///    the index against the wrong dependency set.
    #[prost(uint64, tag = "9")]
    pub reader_feature_flags: u64,
    /// Feature flags for writers.
    ///
    /// A bitmap of flags that indicate which features must be used when writing to the
    /// dataset. If a writer does not recognize a flag that is set, it should not attempt to
    /// write to the dataset.
    ///
    /// The flag identities are the same as for reader_feature_flags, but the values of
    /// reader_feature_flags and writer_feature_flags are not required to be identical.
    #[prost(uint64, tag = "10")]
    pub writer_feature_flags: u64,
    /// The highest fragment ID that has been used so far.
    ///
    /// This ID is not guaranteed to be present in the current version, but it may
    /// have been used in previous versions.
    ///
    /// For a single fragment, will be zero. For no fragments, will be absent.
    #[prost(uint32, optional, tag = "11")]
    pub max_fragment_id: ::core::option::Option<u32>,
    /// Path to the transaction file, relative to `{root}/_transactions`. The file at that
    /// location contains a wire-format serialized Transaction message representing the
    /// transaction that created this version.
    ///
    /// This string field "transaction_file" may be empty if no transaction file was written.
    ///
    /// The path format is "{read_version}-{uuid}.txn" where {read_version} is the version of
    /// the table the transaction read from (serialized to decimal with no padding digits),
    /// and {uuid} is a hyphen-separated UUID.
    #[prost(string, tag = "12")]
    pub transaction_file: ::prost::alloc::string::String,
    /// The file position of the transaction content. None if transaction is empty
    /// This transaction content begins with the transaction content length as u32
    /// If the transaction proto message has a length of `len`, the message ends at `len` + 4
    #[prost(uint64, optional, tag = "21")]
    pub transaction_section: ::core::option::Option<u64>,
    /// The next unused row id. If zero, then the table does not have any rows.
    ///
    /// This is only used if the "stable_row_ids" feature flag is set.
    #[prost(uint64, tag = "14")]
    pub next_row_id: u64,
    /// The data storage format
    ///
    /// This specifies what format is used to store the data files.
    #[prost(message, optional, tag = "15")]
    pub data_format: ::core::option::Option<manifest::DataStorageFormat>,
    /// Table config.
    ///
    /// Keys with the prefix "lance." are reserved for the Lance library. Other
    /// libraries may wish to similarly prefix their configuration keys
    /// appropriately.
    #[prost(map = "string, string", tag = "16")]
    pub config: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Metadata associated with the table.
    ///
    /// This is a key-value map that can be used to store arbitrary metadata
    /// associated with the table.
    ///
    /// This is different than configuration, which is used to tell libraries how
    /// to read, write, or manage the table.
    ///
    /// This is different than schema metadata, which is used to describe the
    /// data itself and is attached to the output schema of scans.
    #[prost(map = "string, string", tag = "19")]
    pub table_metadata: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// The base paths of data files.
    ///
    /// This is used to determine the base path of a data file. In common cases data file paths are under current dataset base path.
    /// But for shallow cloning, importing file and other multi-tier storage cases, the actual data files could be outside of the current dataset.
    /// This field is used with the `base_id` in `lance.file.File` and `lance.file.DeletionFile`.
    ///
    /// For example, if we have a dataset with base path `s3://bucket/dataset`, we have a DataFile with base_id 0, we get the actual data file path by:
    /// base_paths\[id = 0\] + /data/ + file.path
    /// the key(a.k.a index) starts from 0, increased by 1 for each new base path.
    #[prost(message, repeated, tag = "18")]
    pub base_paths: ::prost::alloc::vec::Vec<BasePath>,
    /// The branch of the dataset. None means main branch.
    #[prost(string, optional, tag = "20")]
    pub branch: ::core::option::Option<::prost::alloc::string::String>,
}
/// Nested message and enum types in `Manifest`.
pub mod manifest {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct WriterVersion {
        /// The name of the library that created this file.
        #[prost(string, tag = "1")]
        pub library: ::prost::alloc::string::String,
        /// The version of the library that created this file. Because we cannot assume
        /// that the library is semantically versioned, this is a string. However, if it
        /// is semantically versioned, it should be a valid semver string without any 'v'
        /// prefix. For example: `2.0.0`, `2.0.0-rc.1`.
        ///
        /// For forward compatibility with older readers, when writing new manifests this
        /// field should contain only the core version (major.minor.patch) without any
        /// prerelease or build metadata. The prerelease/build info should be stored in
        /// the separate prerelease and build_metadata fields instead.
        #[prost(string, tag = "2")]
        pub version: ::prost::alloc::string::String,
        /// Optional semver prerelease identifier.
        ///
        /// This field stores the prerelease portion of a semantic version separately
        /// from the core version number. For example, if the full version is "2.0.0-rc.1",
        /// the version field would contain "2.0.0" and prerelease would contain "rc.1".
        ///
        /// This separation ensures forward compatibility: older readers can parse the
        /// clean version field without errors, while newer readers can reconstruct the
        /// full semantic version by combining version, prerelease, and build_metadata.
        ///
        /// If absent, the version field is used as-is.
        #[prost(string, optional, tag = "3")]
        pub prerelease: ::core::option::Option<::prost::alloc::string::String>,
        /// Optional semver build metadata.
        ///
        /// This field stores the build metadata portion of a semantic version separately
        /// from the core version number. For example, if the full version is
        /// "2.0.0-rc.1+build.123", the version field would contain "2.0.0", prerelease
        /// would contain "rc.1", and build_metadata would contain "build.123".
        ///
        /// If absent, no build metadata is present.
        #[prost(string, optional, tag = "4")]
        pub build_metadata: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct DataStorageFormat {
        /// The format of the data files (e.g. "lance")
        #[prost(string, tag = "1")]
        pub file_format: ::prost::alloc::string::String,
        /// The max format version of the data files. The format of the version can vary by
        /// file_format and is not required to follow semver.
        ///
        /// Every file in this version of the dataset has the same file_format version.
        #[prost(string, tag = "2")]
        pub version: ::prost::alloc::string::String,
    }
}
/// external dataset base path
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BasePath {
    #[prost(uint32, tag = "1")]
    pub id: u32,
    /// This is an alias name of the base path, it is optional.
    /// When we use shallow clone and the target version is a tag, the tag name will be set here.
    #[prost(string, optional, tag = "2")]
    pub name: ::core::option::Option<::prost::alloc::string::String>,
    /// Flag indicating whether this path is a dataset root path or file directory:
    /// - true:  Path is a dataset root (actual files under subdirectories like `data`, '_deletions')
    /// - false: Path is a direct file directory (scenario like importing files)
    #[prost(bool, tag = "3")]
    pub is_dataset_root: bool,
    /// Note: This absolute path will be directly used by Path:parse(),
    #[prost(string, tag = "4")]
    pub path: ::prost::alloc::string::String,
}
/// Auxiliary Data attached to a version.
/// Only load on-demand.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VersionAuxData {
    /// key-value metadata.
    #[prost(map = "string, bytes", tag = "3")]
    pub metadata: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::vec::Vec<u8>,
    >,
}
/// Metadata describing an index.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IndexMetadata {
    /// Unique ID of an index. It is unique across all the dataset versions.
    #[prost(message, optional, tag = "1")]
    pub uuid: ::core::option::Option<Uuid>,
    /// The columns to build the index. These refer to file.Field.id.
    ///
    /// fields\[0\] is always a column the index is keyed on. Trailing entries may
    /// instead be merely carried, not keyed on -- see `covering_fields` below.
    #[prost(int32, repeated, tag = "2")]
    pub fields: ::prost::alloc::vec::Vec<i32>,
    /// Index name. Must be unique within one dataset version.
    #[prost(string, tag = "3")]
    pub name: ::prost::alloc::string::String,
    /// The version of the dataset this index was built from.
    #[prost(uint64, tag = "4")]
    pub dataset_version: u64,
    /// A bitmap of the included fragment ids.
    ///
    /// This may by used to determine how much of the dataset is covered by the
    /// index. This information can be retrieved from the dataset by looking at
    /// the dataset at `dataset_version`. However, since the old version may be
    /// deleted while the index is still in use, this information is also stored
    /// in the index.
    ///
    /// The bitmap is stored as a 32-bit Roaring bitmap.
    #[prost(bytes = "vec", tag = "5")]
    pub fragment_bitmap: ::prost::alloc::vec::Vec<u8>,
    /// Details, specific to the index type, which are needed to load / interpret the index
    ///
    /// Indices should avoid putting large amounts of information in this field, as it will
    /// bloat the manifest.
    ///
    /// Indexes are plugins, and so the format of the details message is flexible and not fully
    /// defined by the table format.  However, there are some conventions that should be followed:
    ///
    /// - When Lance APIs refer to indexes they will use the type URL of the index details as the
    ///    identifier for the index type.  If a user provides a simple string identifier like
    ///    "btree" then it will be converted to "/lance.table.BTreeIndexDetails"
    /// - Type URLs comparisons are case-insensitive.  Thereform an index must have a unique type
    ///    URL ignoring case.
    #[prost(message, optional, tag = "6")]
    pub index_details: ::core::option::Option<::prost_types::Any>,
    /// The minimum lance version that this index is compatible with.
    #[prost(int32, optional, tag = "7")]
    pub index_version: ::core::option::Option<i32>,
    /// Timestamp when the index was created (UTC timestamp in milliseconds since epoch)
    ///
    /// This field is optional for backward compatibility. For existing indices created before
    /// this field was added, this will be None/null.
    #[prost(uint64, optional, tag = "8")]
    pub created_at: ::core::option::Option<u64>,
    /// The base path index of the data file. Used when the file is imported or referred from another dataset.
    /// Lance use it as key of the base_paths field in Manifest to determine the actual base path of the data file.
    #[prost(uint32, optional, tag = "9")]
    pub base_id: ::core::option::Option<u32>,
    /// List of files and their sizes for this index segment.
    /// This enables skipping HEAD calls when opening indices and allows reporting
    /// of index sizes without extra IO.
    /// If this is empty, the index files sizes are unknown.
    #[prost(message, repeated, tag = "10")]
    pub files: ::prost::alloc::vec::Vec<IndexFile>,
    /// The subset of `fields` whose values this index co-locates alongside its own
    /// data, so a query projecting only those columns can be answered from the
    /// index without a take against the base table.
    ///
    /// Must be a suffix of `fields`: the columns the index is keyed on come first,
    /// the columns it merely carries come last, and at least one keyed column
    /// always remains. Empty for an index that carries no extra columns, which is
    /// every index written before this field existed.
    ///
    /// Carried columns are listed in `fields` as well. That is deliberate: every
    /// consumer that reads `fields` as the index's dependency set -- staleness,
    /// commit conflict detection, schema evolution guards -- then covers them with
    /// no change and no way to forget one.
    ///
    /// This declaration is not authoritative for what the segment can actually
    /// serve. The segment's own storage schema is: a reader must confirm the
    /// storage carries a column before answering a query from it, and fall back to
    /// a take against the base table otherwise. A declaration naming columns the
    /// storage does not hold is a legal state, not corruption -- a maintenance
    /// operation that cannot carry the values through a rebuild is permitted to
    /// withdraw the payload while leaving this declaration in place.
    #[prost(int32, repeated, tag = "11")]
    pub covering_fields: ::prost::alloc::vec::Vec<i32>,
}
/// Metadata about a single file within an index segment.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct IndexFile {
    /// Path relative to the index directory (e.g., "index.idx", "auxiliary.idx")
    #[prost(string, tag = "1")]
    pub path: ::prost::alloc::string::String,
    /// Size of the file in bytes
    #[prost(uint64, tag = "2")]
    pub size_bytes: u64,
}
/// Index Section, containing a list of index metadata for one dataset version.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IndexSection {
    #[prost(message, repeated, tag = "1")]
    pub indices: ::prost::alloc::vec::Vec<IndexMetadata>,
}
/// A DataFragment is a set of files which represent the different columns of the same
/// rows. If column exists in the schema of a dataset, but the file for that column does
/// not exist within a DataFragment of that dataset, that column consists entirely of
/// nulls.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DataFragment {
    /// The ID of a DataFragment is unique within a dataset.
    #[prost(uint64, tag = "1")]
    pub id: u64,
    #[prost(message, repeated, tag = "2")]
    pub files: ::prost::alloc::vec::Vec<DataFile>,
    /// Optional overlay files for this fragment, which supply new values for a
    /// subset of cells without rewriting the base data files. This MUST be empty
    /// if the data overlay files feature flag (64) is not set in the manifest.
    ///
    /// Order is significant: a later entry is newer than an earlier one. When two
    /// overlays cover the same (offset, field) and share a `committed_version`, the
    /// later entry wins. See DataOverlayFile for the full resolution rules.
    #[prost(message, repeated, tag = "11")]
    pub overlays: ::prost::alloc::vec::Vec<DataOverlayFile>,
    /// File that indicates which rows, if any, should be considered deleted.
    #[prost(message, optional, tag = "3")]
    pub deletion_file: ::core::option::Option<DeletionFile>,
    /// Number of original rows in the fragment, this includes rows that are now marked with
    /// deletion tombstones. To compute the current number of rows, subtract
    /// `deletion_file.num_deleted_rows` from this value.
    #[prost(uint64, tag = "4")]
    pub physical_rows: u64,
    /// A serialized RowIdSequence message (see rowids.proto).
    ///
    /// These are the row ids for the fragment, in order of the rows as they appear.
    /// That is, if a fragment has 3 rows, and the row ids are \[1, 42, 3\], then the
    /// first row is row 1, the second row is row 42, and the third row is row 3.
    #[prost(oneof = "data_fragment::RowIdSequence", tags = "5, 6")]
    pub row_id_sequence: ::core::option::Option<data_fragment::RowIdSequence>,
    #[prost(oneof = "data_fragment::LastUpdatedAtVersionSequence", tags = "7, 8")]
    pub last_updated_at_version_sequence: ::core::option::Option<
        data_fragment::LastUpdatedAtVersionSequence,
    >,
    #[prost(oneof = "data_fragment::CreatedAtVersionSequence", tags = "9, 10")]
    pub created_at_version_sequence: ::core::option::Option<
        data_fragment::CreatedAtVersionSequence,
    >,
}
/// Nested message and enum types in `DataFragment`.
pub mod data_fragment {
    /// A serialized RowIdSequence message (see rowids.proto).
    ///
    /// These are the row ids for the fragment, in order of the rows as they appear.
    /// That is, if a fragment has 3 rows, and the row ids are \[1, 42, 3\], then the
    /// first row is row 1, the second row is row 42, and the third row is row 3.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum RowIdSequence {
        /// If small (< 200KB), the row ids are stored inline.
        #[prost(bytes, tag = "5")]
        InlineRowIds(::prost::alloc::vec::Vec<u8>),
        /// Otherwise, stored as part of a file.
        #[prost(message, tag = "6")]
        ExternalRowIds(super::ExternalFile),
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum LastUpdatedAtVersionSequence {
        /// If small (< 200KB), the row latest updated versions are stored inline.
        #[prost(bytes, tag = "7")]
        InlineLastUpdatedAtVersions(::prost::alloc::vec::Vec<u8>),
        /// Otherwise, stored as part of a file.
        #[prost(message, tag = "8")]
        ExternalLastUpdatedAtVersions(super::ExternalFile),
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum CreatedAtVersionSequence {
        /// If small (< 200KB), the row created at versions are stored inline.
        #[prost(bytes, tag = "9")]
        InlineCreatedAtVersions(::prost::alloc::vec::Vec<u8>),
        /// Otherwise, stored as part of a file.
        #[prost(message, tag = "10")]
        ExternalCreatedAtVersions(super::ExternalFile),
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DataFile {
    /// Path to the root relative to the dataset's URI.
    #[prost(string, tag = "1")]
    pub path: ::prost::alloc::string::String,
    /// The ids of the fields/columns in this file.
    ///
    /// When a DataFile object is created in memory, every value in fields is assigned -1 by
    /// default. An object with a value in fields of -1 must not be stored to disk. -2 is
    /// used for "tombstoned", meaning a field that is no longer in use. This is often
    /// because the original field id was reassigned to a different data file.
    ///
    /// In Lance v1 IDs are assigned based on position in the file, offset by the max
    /// existing field id in the table (if any already). So when a fragment is first created
    /// with one file of N columns, the field ids will be 1, 2, ..., N. If a second fragment
    /// is created with M columns, the field ids will be N+1, N+2, ..., N+M.
    ///
    /// In Lance v1 there is one field for each field in the input schema, this includes
    /// nested fields (both struct and list).  Fixed size list fields have only a single
    /// field id (these are not considered nested fields in Lance v1).
    ///
    /// This allows column indices to be calculated from field IDs and the input schema.
    ///
    /// In Lance v2 the field IDs generally follow the same pattern but there is no
    /// way to calculate the column index from the field ID.  This is because a given
    /// field could be encoded in many different ways, some of which occupy a different
    /// number of columns.  For example, a struct field could be encoded into N + 1 columns
    /// or it could be encoded into a single packed column.  To determine column indices
    /// the column_indices property should be used instead.
    ///
    /// In Lance v1 these ids must be sorted but might not always be contiguous.
    #[prost(int32, repeated, tag = "2")]
    pub fields: ::prost::alloc::vec::Vec<i32>,
    /// The top-level column indices for each field in the file.
    ///
    /// If the data file is version 1 then this property will be empty
    ///
    /// Otherwise there must be one entry for each field in `fields`.
    ///
    /// Some fields may not correspond to a top-level column in the file.  In these cases
    /// the index will -1.
    ///
    /// For example, consider the schema:
    ///
    /// - dimension: packed-struct (0):
    ///    - x: u32 (1)
    ///    - y: u32 (2)
    /// - path: `list<u32>` (3)
    /// - embedding: `fsl<768>` (4)
    ///    - fp64
    /// - borders: `fsl<4>` (5)
    ///    - simple-struct (6)
    ///      - margin: fp64 (7)
    ///      - padding: fp64 (8)
    ///
    /// One possible column indices array could be:
    /// \[0, -1, -1, 1, 3, 4, 5, 6, 7\]
    ///
    /// This reflects quite a few phenomenon:
    /// - The packed struct is encoded into a single column and there is no top-level column
    ///    for the x or y fields
    /// - The variable sized list is encoded into two columns
    /// - The embedding is encoded into a single column (common for FSL of primitive) and there
    ///    is not "FSL column"
    /// - The borders field actually does have an "FSL column"
    ///
    /// The column indices table may not have duplicates (other than -1)
    #[prost(int32, repeated, tag = "3")]
    pub column_indices: ::prost::alloc::vec::Vec<i32>,
    /// The major file version used to create the file
    #[prost(uint32, tag = "4")]
    pub file_major_version: u32,
    /// The minor file version used to create the file
    ///
    /// If both `file_major_version` and `file_minor_version` are set to 0,
    /// then this is a version 0.1 or version 0.2 file.
    #[prost(uint32, tag = "5")]
    pub file_minor_version: u32,
    /// The known size of the file on disk in bytes.
    ///
    /// This is used to quickly find the footer of the file.
    ///
    /// When this is zero, it should be interpreted as "unknown".
    #[prost(uint64, tag = "6")]
    pub file_size_bytes: u64,
    /// The base path index of the data file. Used when the file is imported or referred from another dataset.
    /// Lance use it as key of the base_paths field in Manifest to determine the actual base path of the data file.
    #[prost(uint32, optional, tag = "7")]
    pub base_id: ::core::option::Option<u32>,
}
/// An overlay file supplies new values for a subset of (row offset, field) cells
/// within a fragment, without rewriting the fragment's base data files. It is
/// used for efficient updates when only a small fraction of rows and/or columns
/// change.
///
/// On read, a cell is resolved by consulting the fragment's overlays from newest
/// to oldest: the first overlay that covers that (offset, field) wins; if none
/// cover it, the value falls through to the base data file. Because deletions
/// take precedence over overlays, an overlay value for an offset that is also
/// marked deleted is dead and is ignored.
///
/// The overlay's data file does NOT store a row-offset key column. Within a value
/// column, the position of a covered offset's value is the rank (0-based count of
/// set bits below it) of that offset within the field's coverage bitmap. Because
/// fields may cover different offset sets, the value columns of a single overlay
/// data file may have different lengths (which the Lance file format permits).
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DataOverlayFile {
    /// The data file storing the overlay's new cell values, one value column per
    /// field in `data_file.fields`. No row-offset key column is stored.
    #[prost(message, optional, tag = "1")]
    pub data_file: ::core::option::Option<DataFile>,
    /// The dataset version at which this overlay became effective: the version of
    /// the commit that introduced it, NOT the version it was read from. It is
    /// stamped at commit time and re-stamped if the commit is retried, in the same
    /// way as the created-at / last-updated-at version sequences.
    ///
    /// This drives two orderings:
    ///   * Versus index builds: an index whose `dataset_version` >= this value
    ///     already incorporates this overlay. Otherwise the overlay's covered cells
    ///     are excluded from index results for the affected fields and re-evaluated
    ///     against their current values (see the Data Overlay Files specification).
    ///   * Versus other overlays: when two overlays cover the same (offset, field),
    ///     the one with the higher `committed_version` wins. Overlays that share a
    ///     `committed_version` are ordered by their position in
    ///     `DataFragment.overlays`, where a later entry is newer and wins.
    #[prost(uint64, tag = "3")]
    pub committed_version: u64,
    /// Which (offset, field) cells this overlay provides values for.
    #[prost(oneof = "data_overlay_file::Coverage", tags = "2, 4")]
    pub coverage: ::core::option::Option<data_overlay_file::Coverage>,
}
/// Nested message and enum types in `DataOverlayFile`.
pub mod data_overlay_file {
    /// Which (offset, field) cells this overlay provides values for.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Coverage {
        /// A single 32-bit Roaring bitmap of physical row offsets that applies to
        /// every field in `data_file.fields` (a "dense" / rectangular overlay).
        /// Every covered offset has a value for every field. This is the common case
        /// for a plain UPDATE, where one SET list is applied to one set of rows.
        #[prost(bytes, tag = "2")]
        SharedOffsetBitmap(::prost::alloc::vec::Vec<u8>),
        /// Per-field coverage for a "sparse" overlay, used when different fields cover
        /// different offset sets (e.g. a MERGE with multiple WHEN MATCHED branches).
        #[prost(message, tag = "4")]
        FieldCoverage(super::FieldCoverage),
    }
}
/// Per-field coverage for a sparse overlay.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FieldCoverage {
    /// One entry per field in the overlay's `data_file.fields`, in the same order.
    /// Each is a 32-bit Roaring bitmap of the physical row offsets covered for that
    /// field. An offset present in a field's bitmap but mapped to a NULL value
    /// means the cell is overridden to NULL (distinct from an offset that is absent,
    /// which falls through to the base data file).
    #[prost(bytes = "vec", repeated, tag = "1")]
    pub offset_bitmaps: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
}
/// Deletion File
///
/// The path of the deletion file is constructed as:
///    {root}/_deletions/{fragment_id}-{read_version}-{id}.{extension}
/// where {extension} depends on DeletionFileType.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeletionFile {
    /// Type of deletion file.
    #[prost(enumeration = "deletion_file::DeletionFileType", tag = "1")]
    pub file_type: i32,
    /// The version of the dataset this deletion file was built from.
    #[prost(uint64, tag = "2")]
    pub read_version: u64,
    /// An opaque id used to differentiate this file from others written by concurrent
    /// writers.
    #[prost(uint64, tag = "3")]
    pub id: u64,
    /// The number of rows that are marked as deleted.
    #[prost(uint64, tag = "4")]
    pub num_deleted_rows: u64,
    /// The base path index of the deletion file. Used when the file is imported or referred from another
    /// dataset. Lance uses it as key of the base_paths field in Manifest to determine the actual base
    /// path of the deletion file.
    #[prost(uint32, optional, tag = "7")]
    pub base_id: ::core::option::Option<u32>,
}
/// Nested message and enum types in `DeletionFile`.
pub mod deletion_file {
    /// Type of deletion file, intended as a way to increase efficiency of the storage of deleted row
    /// offsets. If there are sparsely deleted rows, then ARROW_ARRAY is the most efficient. If there
    /// are densely deleted rows, then BITMAP is the most efficient.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum DeletionFileType {
        /// A single Int32Array of deleted row offsets, stored as an Arrow IPC file with one batch and
        /// one column. Has a .arrow extension.
        ArrowArray = 0,
        /// A Roaring Bitmap of deleted row offsets. Has a .bin extension.
        Bitmap = 1,
    }
    impl DeletionFileType {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::ArrowArray => "ARROW_ARRAY",
                Self::Bitmap => "BITMAP",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ARROW_ARRAY" => Some(Self::ArrowArray),
                "BITMAP" => Some(Self::Bitmap),
                _ => None,
            }
        }
    }
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExternalFile {
    /// Path to the file, relative to the root of the table.
    #[prost(string, tag = "1")]
    pub path: ::prost::alloc::string::String,
    /// The byte offset in the file where the data starts.
    #[prost(uint64, tag = "2")]
    pub offset: u64,
    /// The size of the data in the file, in bytes.
    #[prost(uint64, tag = "3")]
    pub size: u64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FragmentReuseIndexDetails {
    #[prost(oneof = "fragment_reuse_index_details::Content", tags = "1, 2")]
    pub content: ::core::option::Option<fragment_reuse_index_details::Content>,
}
/// Nested message and enum types in `FragmentReuseIndexDetails`.
pub mod fragment_reuse_index_details {
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct InlineContent {
        #[prost(message, repeated, tag = "1")]
        pub versions: ::prost::alloc::vec::Vec<Version>,
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct FragmentDigest {
        #[prost(uint64, tag = "1")]
        pub id: u64,
        #[prost(uint64, tag = "2")]
        pub physical_rows: u64,
        #[prost(uint64, tag = "3")]
        pub num_deleted_rows: u64,
    }
    /// A summarized version of the RewriteGroup information in a Rewrite transaction
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Group {
        /// A roaring treemap of the changed row addresses.
        /// When combined with the old fragment IDs and new fragment IDs,
        /// it can recover the full mapping of old row addresses to either new row addresses or deleted.
        /// this mapping can then be used to remap indexes or satisfy index queries for the new unindexed fragments.
        #[prost(bytes = "vec", tag = "1")]
        pub changed_row_addrs: ::prost::alloc::vec::Vec<u8>,
        #[prost(message, repeated, tag = "2")]
        pub old_fragments: ::prost::alloc::vec::Vec<FragmentDigest>,
        #[prost(message, repeated, tag = "3")]
        pub new_fragments: ::prost::alloc::vec::Vec<FragmentDigest>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Version {
        /// The dataset_version at the time the index adds this version entry
        #[prost(uint64, tag = "1")]
        pub dataset_version: u64,
        #[prost(message, repeated, tag = "3")]
        pub groups: ::prost::alloc::vec::Vec<Group>,
    }
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Content {
        /// if < 200KB, store the content inline, otherwise store the InlineContent bytes in external file
        #[prost(message, tag = "1")]
        Inline(InlineContent),
        #[prost(message, tag = "2")]
        External(super::ExternalFile),
    }
}
/// Shard manifest containing epoch-based fencing and WAL state.
/// Each shard has exactly one active writer at any time.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ShardManifest {
    /// Shard identifier (UUID v4).
    #[prost(message, optional, tag = "11")]
    pub shard_id: ::core::option::Option<Uuid>,
    /// Manifest version number.
    /// Matches the version encoded in the filename.
    #[prost(uint64, tag = "1")]
    pub version: u64,
    /// Shard spec ID this shard was created with.
    /// Set at shard creation and immutable thereafter.
    /// A value of 0 indicates a manually-created shard not governed by any spec.
    #[prost(uint32, tag = "10")]
    pub shard_spec_id: u32,
    /// Computed shard field values as raw Arrow scalar bytes, keyed by shard
    /// field id. The byte encoding follows Arrow's little-endian convention:
    /// int32 is 4 LE bytes, utf8 is raw UTF-8 bytes, etc. The receiver looks
    /// up the result_type from the ShardingSpec to interpret each value.
    #[prost(message, repeated, tag = "14")]
    pub shard_field_entries: ::prost::alloc::vec::Vec<ShardFieldEntry>,
    /// Writer fencing token - monotonically increasing.
    /// A writer must increment this when claiming the shard.
    #[prost(uint64, tag = "2")]
    pub writer_epoch: u64,
    /// The most recent WAL entry position that has been flushed to a MemTable.
    /// During recovery, replay starts from replay_after_wal_entry_position + 1.
    /// WAL positions are 1-based, so the default value 0 unambiguously means
    /// "no flush has ever stamped this shard" and recovery replays from 1.
    #[prost(uint64, tag = "3")]
    pub replay_after_wal_entry_position: u64,
    /// The most recent WAL entry position observed at the time the manifest was
    /// updated. WAL positions are 1-based; default 0 means no entry has been
    /// written yet. This is a hint, not authoritative - recovery must list
    /// files to find actual state.
    #[prost(uint64, tag = "4")]
    pub wal_entry_position_last_seen: u64,
    /// Generation to assign to the next SSTable (incremented after each MemTable flush).
    #[prost(uint64, tag = "6")]
    pub current_generation: u64,
    /// List of SSTables created by flushing MemTables and their directory paths.
    #[prost(message, repeated, tag = "8")]
    pub sstables: ::prost::alloc::vec::Vec<SsTable>,
    /// Lifecycle status. Default ACTIVE; SEALED marks an in-flight drop
    /// (drop-table 2PC). A SEALED manifest refuses claims at claim_epoch.
    #[prost(enumeration = "ShardStatus", tag = "15")]
    pub status: i32,
}
/// A shard field value stored as raw Arrow scalar bytes.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ShardFieldEntry {
    /// Shard field id (matches ShardingField.field_id in the ShardingSpec).
    #[prost(string, tag = "1")]
    pub field_id: ::prost::alloc::string::String,
    /// Raw Arrow scalar value bytes in little-endian encoding.
    /// The data type is determined by the result_type of the matching ShardingField.
    #[prost(bytes = "vec", tag = "2")]
    pub value: ::prost::alloc::vec::Vec<u8>,
}
/// An SSTable: the immutable result of flushing a MemTable, stored as a Lance dataset.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SsTable {
    /// Generation number identifying this SSTable.
    #[prost(uint64, tag = "1")]
    pub generation: u64,
    /// Directory name relative to the shard directory.
    #[prost(string, tag = "2")]
    pub path: ::prost::alloc::string::String,
}
/// A pointer to the latest SSTable compacted for a shard.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CompactedSsTable {
    /// Shard identifier (UUID v4).
    #[prost(message, optional, tag = "1")]
    pub shard_id: ::core::option::Option<Uuid>,
    /// Generation of the latest SSTable compacted into the base table for this shard.
    #[prost(uint64, tag = "2")]
    pub generation: u64,
}
/// Tracks which compacted SSTable generation a base table index has been rebuilt to cover.
/// Used to determine whether to read from SSTable indexes or base table.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IndexCatchupProgress {
    /// Name of the base table index (must match an entry in maintained_indexes).
    #[prost(string, tag = "1")]
    pub index_name: ::prost::alloc::string::String,
    /// Per-shard progress: the generation up to which this index covers.
    ///
    /// An absent shard means *unknown*: this index has recorded no catch-up for
    /// that shard, so its SSTables must be retained and a repair scheduled.
    #[prost(message, repeated, tag = "2")]
    pub caught_up_generations: ::prost::alloc::vec::Vec<CompactedSsTable>,
}
/// Index details for MemWAL Index, stored in IndexMetadata.index_details.
/// This is the centralized structure for all MemWAL metadata:
/// - Configuration (sharding specs, indexes to maintain)
/// - SSTable compaction progress
/// - Shard state snapshots
///
/// Writers read this index to get configuration before writing.
/// Readers may use shard snapshots in this index as a point-in-time
/// optimization. Readers that need the latest shard set should list shard
/// directories in storage and read each shard's latest manifest.
/// A background process updates the index periodically to keep shard snapshots current.
///
/// Shard snapshots are stored as a Lance file with one row per shard.
/// The schema records shard discovery fields. Full mutable shard state remains
/// authoritative in the shard manifest files.
///    shard_id: utf8
///    shard_spec_id: uint32
///    shard_field_{field_id}: typed per the matching ShardingField.result_type
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MemWalIndexDetails {
    /// Snapshot timestamp (Unix timestamp in milliseconds).
    #[prost(int64, tag = "1")]
    pub snapshot_ts_millis: i64,
    /// Number of shards in the snapshot.
    /// Used to determine storage format without reading the snapshot data.
    #[prost(uint32, tag = "2")]
    pub num_shards: u32,
    /// Inline shard snapshots for small shard counts.
    /// When num_shards <= threshold (implementation-defined, e.g., 100),
    /// snapshots are stored inline as serialized bytes.
    /// Format: Lance file bytes with the shard snapshot schema.
    #[prost(bytes = "vec", optional, tag = "3")]
    pub inline_snapshots: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
    /// Sharding specs defining how to derive shard identifiers.
    /// This configuration determines how rows are partitioned into shards.
    #[prost(message, repeated, tag = "7")]
    pub sharding_specs: ::prost::alloc::vec::Vec<ShardingSpec>,
    /// Indexes from the base table to maintain in MemTables.
    /// These are index names referencing indexes defined on the base table.
    /// The primary key btree index is always maintained implicitly and
    /// should not be listed here.
    ///
    /// For vector indexes, MemTables inherit quantization parameters (PQ codebook,
    /// SQ params) from the base table index to ensure distance comparability.
    #[prost(string, repeated, tag = "8")]
    pub maintained_indexes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Latest SSTable compacted into the base table for each shard.
    /// This is updated atomically with merge-insert data commits, enabling
    /// conflict resolution when multiple compactors operate concurrently.
    ///
    /// Note: This is separate from shard snapshots because:
    /// 1. compacted_sstables is updated by compactors (atomic with data commit)
    /// 2. shard snapshots are updated by background index builder
    #[prost(message, repeated, tag = "9")]
    pub compacted_sstables: ::prost::alloc::vec::Vec<CompactedSsTable>,
    /// Per-index catchup progress tracking.
    /// When data is compacted into the base table, base table indexes are rebuilt
    /// asynchronously. This field tracks which generation each index covers.
    ///
    /// For indexed queries, if an index's caught_up_generation < compacted_generation,
    /// readers should use SSTable indexes for the gap instead of
    /// scanning unindexed data in the base table.
    ///
    /// An index absent from this list has recorded no catch-up, so the SSTables it
    /// would need stay live until a repair records it. Only the dedicated WAL
    /// index-repair path may add entries here;
    /// ordinary index operations have their entry removed automatically when they
    /// change an index, since they do not report what the new index covers.
    #[prost(message, repeated, tag = "10")]
    pub index_catchup: ::prost::alloc::vec::Vec<IndexCatchupProgress>,
    /// Default ShardWriter configuration values for this MemWAL index.
    ///
    /// A free-form string map persisted so that every writer — across
    /// processes and restarts — starts from the same default writer
    /// configuration. These are defaults only: an individual writer may
    /// still override any value at runtime in its own ShardWriterConfig
    /// (which is not persisted).
    #[prost(map = "string, string", tag = "11")]
    pub writer_config_defaults: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Sharding spec definition.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ShardingSpec {
    /// Unique identifier for this spec within the index.
    /// IDs are never reused.
    #[prost(uint32, tag = "1")]
    pub spec_id: u32,
    /// Sharding field definitions that determine how to compute shard identifiers.
    #[prost(message, repeated, tag = "2")]
    pub fields: ::prost::alloc::vec::Vec<ShardingField>,
}
/// Sharding field definition.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ShardingField {
    /// Unique string identifier for this shard field.
    #[prost(string, tag = "1")]
    pub field_id: ::prost::alloc::string::String,
    /// Field IDs referencing source columns in the schema.
    #[prost(int32, repeated, tag = "2")]
    pub source_ids: ::prost::alloc::vec::Vec<i32>,
    /// Well-known shard transform name (e.g., "identity", "year", "bucket").
    /// Mutually exclusive with expression.
    #[prost(string, optional, tag = "3")]
    pub transform: ::core::option::Option<::prost::alloc::string::String>,
    /// DataFusion SQL expression for custom logic.
    /// Mutually exclusive with transform.
    #[prost(string, optional, tag = "4")]
    pub expression: ::core::option::Option<::prost::alloc::string::String>,
    /// Output type of the shard value (Arrow type name).
    #[prost(string, tag = "5")]
    pub result_type: ::prost::alloc::string::String,
    /// Transform parameters (e.g., num_buckets for bucket transform).
    #[prost(map = "string, string", tag = "6")]
    pub parameters: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Lifecycle status of a WAL shard. Drives drop-table two-phase commit:
/// a SEALED shard refuses new writer claims (reversible) until the drop
/// commits (the shard dir is deleted) or rolls back (status -> ACTIVE).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ShardStatus {
    /// Normal: the shard accepts writer claims.
    Active = 0,
    /// A drop is in flight: claims are refused. Reversible to ACTIVE.
    Sealed = 1,
}
impl ShardStatus {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Active => "ACTIVE",
            Self::Sealed => "SEALED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "ACTIVE" => Some(Self::Active),
            "SEALED" => Some(Self::Sealed),
            _ => None,
        }
    }
}
/// A transaction represents the changes to a dataset.
///
/// This has two purposes:
/// 1. When retrying a commit, the transaction can be used to re-build an updated
///     manifest.
/// 2. When there's a conflict, this can be used to determine whether the other
///     transaction is compatible with this one.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Transaction {
    /// The version of the dataset this transaction was built from.
    ///
    /// For example, for a delete transaction this means the version of the dataset
    /// that was read from while evaluating the deletion predicate.
    #[prost(uint64, tag = "1")]
    pub read_version: u64,
    /// The UUID that unique identifies a transaction.
    #[prost(string, tag = "2")]
    pub uuid: ::prost::alloc::string::String,
    /// Optional version tag.
    #[prost(string, tag = "3")]
    pub tag: ::prost::alloc::string::String,
    /// Optional properties for the transaction
    /// __lance_commit_message is a reserved key
    #[prost(map = "string, string", tag = "4")]
    pub transaction_properties: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// The operation of this transaction.
    #[prost(
        oneof = "transaction::Operation",
        tags = "100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115"
    )]
    pub operation: ::core::option::Option<transaction::Operation>,
}
/// Nested message and enum types in `Transaction`.
pub mod transaction {
    /// Add new rows to the dataset.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Append {
        /// The new fragments to append.
        ///
        /// Fragment IDs are not yet assigned.
        #[prost(message, repeated, tag = "1")]
        pub fragments: ::prost::alloc::vec::Vec<super::DataFragment>,
    }
    /// Mark rows as deleted.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Delete {
        /// The fragments to update
        ///
        /// The fragment IDs will match existing fragments in the dataset.
        #[prost(message, repeated, tag = "1")]
        pub updated_fragments: ::prost::alloc::vec::Vec<super::DataFragment>,
        /// The fragments to delete entirely.
        #[prost(uint64, repeated, tag = "2")]
        pub deleted_fragment_ids: ::prost::alloc::vec::Vec<u64>,
        /// The predicate that was evaluated
        ///
        /// This may be used to determine whether the delete would have affected
        /// files written by a concurrent transaction.
        #[prost(string, tag = "3")]
        pub predicate: ::prost::alloc::string::String,
    }
    /// Create or overwrite the entire dataset.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Overwrite {
        /// The new fragments
        ///
        /// Fragment IDs are not yet assigned.
        #[prost(message, repeated, tag = "1")]
        pub fragments: ::prost::alloc::vec::Vec<super::DataFragment>,
        /// The new schema
        #[prost(message, repeated, tag = "2")]
        pub schema: ::prost::alloc::vec::Vec<super::super::file::Field>,
        /// Schema metadata.
        #[prost(map = "string, bytes", tag = "3")]
        pub schema_metadata: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::vec::Vec<u8>,
        >,
        /// Key-value pairs to merge with existing config.
        #[prost(map = "string, string", tag = "4")]
        pub config_upsert_values: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
        /// The base paths to be added for the initial dataset creation
        #[prost(message, repeated, tag = "5")]
        pub initial_bases: ::prost::alloc::vec::Vec<super::BasePath>,
    }
    /// Add or replace a new secondary index.
    ///
    /// This is also used to remove an index (we are replacing it with nothing)
    ///
    /// - new_indices: the modified indices, empty if dropping indices only
    /// - removed_indices: the indices that are being replaced
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct CreateIndex {
        #[prost(message, repeated, tag = "1")]
        pub new_indices: ::prost::alloc::vec::Vec<super::IndexMetadata>,
        #[prost(message, repeated, tag = "2")]
        pub removed_indices: ::prost::alloc::vec::Vec<super::IndexMetadata>,
    }
    /// An operation that rewrites but does not change the data in the table. These
    /// kinds of operations just rearrange data.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Rewrite {
        /// The old fragments that are being replaced
        ///
        /// DEPRECATED: use groups instead.
        ///
        /// These should all have existing fragment IDs.
        #[prost(message, repeated, tag = "1")]
        pub old_fragments: ::prost::alloc::vec::Vec<super::DataFragment>,
        /// The new fragments
        ///
        /// DEPRECATED: use groups instead.
        ///
        /// These fragments IDs are not yet assigned.
        #[prost(message, repeated, tag = "2")]
        pub new_fragments: ::prost::alloc::vec::Vec<super::DataFragment>,
        /// Groups of files that have been rewritten
        #[prost(message, repeated, tag = "3")]
        pub groups: ::prost::alloc::vec::Vec<rewrite::RewriteGroup>,
        /// Indices that have been rewritten
        #[prost(message, repeated, tag = "4")]
        pub rewritten_indices: ::prost::alloc::vec::Vec<rewrite::RewrittenIndex>,
    }
    /// Nested message and enum types in `Rewrite`.
    pub mod rewrite {
        /// During a rewrite an index may be rewritten.  We only serialize the UUID
        /// since a rewrite should not change the other index parameters.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct RewrittenIndex {
            /// The id of the index that will be replaced
            #[prost(message, optional, tag = "1")]
            pub old_id: ::core::option::Option<super::super::Uuid>,
            /// the id of the new index
            #[prost(message, optional, tag = "2")]
            pub new_id: ::core::option::Option<super::super::Uuid>,
            /// the new index details
            #[prost(message, optional, tag = "3")]
            pub new_index_details: ::core::option::Option<::prost_types::Any>,
            /// the version of the new index
            #[prost(uint32, tag = "4")]
            pub new_index_version: u32,
            /// Files in the new index with their sizes.
            /// Empty if file sizes are not available (e.g. older writers).
            #[prost(message, repeated, tag = "5")]
            pub new_index_files: ::prost::alloc::vec::Vec<super::super::IndexFile>,
        }
        /// A group of rewrite files that are all part of the same rewrite.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct RewriteGroup {
            /// The old fragment that is being replaced
            ///
            /// This should have an existing fragment ID.
            #[prost(message, repeated, tag = "1")]
            pub old_fragments: ::prost::alloc::vec::Vec<super::super::DataFragment>,
            /// The new fragment
            ///
            /// The ID should have been reserved by an earlier
            /// reserve operation
            #[prost(message, repeated, tag = "2")]
            pub new_fragments: ::prost::alloc::vec::Vec<super::super::DataFragment>,
        }
    }
    /// An operation that merges in a new column, altering the schema.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Merge {
        /// The updated fragments
        ///
        /// These should all have existing fragment IDs.
        #[prost(message, repeated, tag = "1")]
        pub fragments: ::prost::alloc::vec::Vec<super::DataFragment>,
        /// The new schema
        #[prost(message, repeated, tag = "2")]
        pub schema: ::prost::alloc::vec::Vec<super::super::file::Field>,
        /// Schema metadata.
        #[prost(map = "string, bytes", tag = "3")]
        pub schema_metadata: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::vec::Vec<u8>,
        >,
        /// Set when this merge makes no nullability-affecting schema change: it
        /// introduces no field that data staged against an earlier schema could
        /// not safely omit. Without the assertion (including transactions written
        /// before this field existed) the merge conservatively conflicts with
        /// concurrent value-writes, which can only cause a retry.
        #[prost(bool, tag = "4")]
        pub preserves_nullability: bool,
    }
    /// An operation that projects a subset of columns, altering the schema.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Project {
        /// The new schema
        #[prost(message, repeated, tag = "1")]
        pub schema: ::prost::alloc::vec::Vec<super::super::file::Field>,
        /// Set when this projection makes no nullability-affecting schema change,
        /// as a rename or a drop does not. Without the assertion (including
        /// transactions written before this field existed) the projection
        /// conservatively conflicts with concurrent value-writes, which can only
        /// cause a retry. A nullability tightening must not set this.
        #[prost(bool, tag = "2")]
        pub preserves_nullability: bool,
    }
    /// An operation that restores a dataset to a previous version.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Restore {
        /// The version to restore to
        #[prost(uint64, tag = "1")]
        pub version: u64,
    }
    /// An operation that reserves fragment ids for future use in
    /// a rewrite operation.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ReserveFragments {
        #[prost(uint32, tag = "1")]
        pub num_fragments: u32,
    }
    /// An operation that clones a dataset.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Clone {
        /// - true:  Performs a metadata-only clone (copies manifest without data files).
        ///           The cloned dataset references original data through `base_paths`,
        ///           suitable for experimental scenarios or rapid metadata migration.
        /// - false: Performs a full deep clone using the underlying object storage's native
        ///           copy API (e.g., S3 CopyObject, GCS rewrite). This leverages server-side
        ///           bulk copy operations to bypass download/upload bottlenecks, achieving
        ///           near-linear speedup for large datasets (typically 3-10x faster than
        ///           manual file transfers). The operation maintains atomicity and data
        ///           integrity guarantees provided by the storage backend.
        #[prost(bool, tag = "1")]
        pub is_shallow: bool,
        /// the reference name in the source dataset
        /// in most cases it should be the branch or tag name in the source dataset
        #[prost(string, optional, tag = "2")]
        pub ref_name: ::core::option::Option<::prost::alloc::string::String>,
        /// the version of the source dataset for cloning
        #[prost(uint64, tag = "3")]
        pub ref_version: u64,
        /// the absolute base path of the source dataset for cloning
        #[prost(string, tag = "4")]
        pub ref_path: ::prost::alloc::string::String,
        /// if the target dataset is a branch, this is the branch name of the target dataset
        #[prost(string, optional, tag = "5")]
        pub branch_name: ::core::option::Option<::prost::alloc::string::String>,
    }
    /// Exact set of key hashes for conflict detection.
    /// Used when the number of inserted rows is small.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ExactKeySetFilter {
        /// 64-bit hashes of the inserted row keys.
        #[prost(uint64, repeated, tag = "1")]
        pub key_hashes: ::prost::alloc::vec::Vec<u64>,
    }
    /// Bloom filter for key existence tests.
    /// Used when the number of rows is large.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct BloomFilter {
        /// Bitset backing the bloom filter (SBBF format).
        #[prost(bytes = "vec", tag = "1")]
        pub bitmap: ::prost::alloc::vec::Vec<u8>,
        /// Number of bits in the bitmap.
        #[prost(uint32, tag = "2")]
        pub num_bits: u32,
        /// Number of items the filter was sized for.
        /// Used for intersection validation (filters with different sizes cannot be compared).
        /// Default: 8192
        #[prost(uint64, tag = "3")]
        pub number_of_items: u64,
        /// False positive probability the filter was sized for.
        /// Used for intersection validation (filters with different parameters cannot be compared).
        /// Default: 0.00057
        #[prost(double, tag = "4")]
        pub probability: f64,
    }
    /// A filter for checking key existence in set of rows inserted by a merge insert operation.
    /// Only created when the merge insert's ON columns match the schema's unenforced primary key.
    /// The presence of this filter indicates strict primary key conflict detection should be used.
    /// Can use either an exact set (for small row counts) or a Bloom filter (for large row counts).
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct KeyExistenceFilter {
        /// Field IDs of columns participating in the key (must match unenforced primary key).
        #[prost(int32, repeated, tag = "1")]
        pub field_ids: ::prost::alloc::vec::Vec<i32>,
        /// The underlying data structure storing the key hashes.
        #[prost(oneof = "key_existence_filter::Data", tags = "2, 3")]
        pub data: ::core::option::Option<key_existence_filter::Data>,
    }
    /// Nested message and enum types in `KeyExistenceFilter`.
    pub mod key_existence_filter {
        /// The underlying data structure storing the key hashes.
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum Data {
            /// Exact set of key hashes (used for small number of rows).
            #[prost(message, tag = "2")]
            Exact(super::ExactKeySetFilter),
            /// Bloom filter (used for large number of rows).
            #[prost(message, tag = "3")]
            Bloom(super::BloomFilter),
        }
    }
    /// Serialized as sorted distinct local physical row offsets within the fragment (0-based).
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct UInt32List {
        #[prost(uint32, repeated, tag = "1")]
        pub values: ::prost::alloc::vec::Vec<u32>,
    }
    /// An operation that updates rows but does not add or remove rows.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Update {
        /// The fragments that have been removed. These are fragments where all rows
        /// have been updated and moved to a new fragment.
        #[prost(uint64, repeated, tag = "1")]
        pub removed_fragment_ids: ::prost::alloc::vec::Vec<u64>,
        /// The fragments that have been updated.
        #[prost(message, repeated, tag = "2")]
        pub updated_fragments: ::prost::alloc::vec::Vec<super::DataFragment>,
        /// The new fragments where updated rows have been moved to.
        #[prost(message, repeated, tag = "3")]
        pub new_fragments: ::prost::alloc::vec::Vec<super::DataFragment>,
        /// The ids of the fields that have been modified.
        #[prost(uint32, repeated, tag = "4")]
        pub fields_modified: ::prost::alloc::vec::Vec<u32>,
        /// / SSTables to mark as compacted after this transaction.
        #[prost(message, repeated, tag = "5")]
        pub compacted_sstables: ::prost::alloc::vec::Vec<super::CompactedSsTable>,
        /// / The fields that used to judge whether to preserve the new frag's id into
        /// / the frag bitmap of the specified indices.
        #[prost(uint32, repeated, tag = "6")]
        pub fields_for_preserving_frag_bitmap: ::prost::alloc::vec::Vec<u32>,
        /// The mode of update
        #[prost(enumeration = "UpdateMode", tag = "7")]
        pub update_mode: i32,
        /// Filter for checking existence of keys in newly inserted rows, used for conflict detection.
        /// Only tracks keys from INSERT operations during merge insert, not updates.
        #[prost(message, optional, tag = "8")]
        pub inserted_rows: ::core::option::Option<KeyExistenceFilter>,
        /// Per-fragment physical row offsets that matched an update_columns hash join (RewriteColumns).
        /// Deprecated: use updated_fragment_offset_bitmaps (field 10) instead.
        #[prost(map = "uint64, message", tag = "9")]
        pub updated_fragment_offsets: ::std::collections::HashMap<u64, UInt32List>,
        /// Per-fragment matched offsets as portable RoaringBitmap bytes (replaces field 9).
        /// Writers emit field 10 only. Readers prefer field 10; fall back to field 9 for
        /// manifests written before this change.
        #[prost(map = "uint64, bytes", tag = "10")]
        pub updated_fragment_offset_bitmaps: ::std::collections::HashMap<
            u64,
            ::prost::alloc::vec::Vec<u8>,
        >,
    }
    /// An entry for a map update. If value is not set, the key will be removed from the map.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct UpdateMapEntry {
        /// The key of the map entry to update.
        #[prost(string, tag = "1")]
        pub key: ::prost::alloc::string::String,
        /// The value to set for the key.
        #[prost(string, optional, tag = "2")]
        pub value: ::core::option::Option<::prost::alloc::string::String>,
    }
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct UpdateMap {
        #[prost(message, repeated, tag = "1")]
        pub update_entries: ::prost::alloc::vec::Vec<UpdateMapEntry>,
        /// If true, the map will be replaced entirely with the new entries.
        /// If false, the new entries will be merged with the existing map.
        #[prost(bool, tag = "2")]
        pub replace: bool,
    }
    /// An operation that updates the table config, table metadata, schema metadata,
    /// or field metadata.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct UpdateConfig {
        #[prost(message, optional, tag = "6")]
        pub config_updates: ::core::option::Option<UpdateMap>,
        #[prost(message, optional, tag = "7")]
        pub table_metadata_updates: ::core::option::Option<UpdateMap>,
        #[prost(message, optional, tag = "8")]
        pub schema_metadata_updates: ::core::option::Option<UpdateMap>,
        #[prost(map = "int32, message", tag = "9")]
        pub field_metadata_updates: ::std::collections::HashMap<i32, UpdateMap>,
        /// Deprecated -------------------------------
        #[prost(map = "string, string", tag = "1")]
        pub upsert_values: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
        #[prost(string, repeated, tag = "2")]
        pub delete_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        #[prost(map = "string, string", tag = "3")]
        pub schema_metadata: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
        #[prost(map = "uint32, message", tag = "4")]
        pub field_metadata: ::std::collections::HashMap<
            u32,
            update_config::FieldMetadataUpdate,
        >,
    }
    /// Nested message and enum types in `UpdateConfig`.
    pub mod update_config {
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct FieldMetadataUpdate {
            #[prost(map = "string, string", tag = "5")]
            pub metadata: ::std::collections::HashMap<
                ::prost::alloc::string::String,
                ::prost::alloc::string::String,
            >,
        }
    }
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct DataReplacementGroup {
        #[prost(uint64, tag = "1")]
        pub fragment_id: u64,
        #[prost(message, optional, tag = "2")]
        pub new_file: ::core::option::Option<super::DataFile>,
    }
    /// An operation that replaces the data in a region of the table with new data.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DataReplacement {
        #[prost(message, repeated, tag = "1")]
        pub replacements: ::prost::alloc::vec::Vec<DataReplacementGroup>,
    }
    /// Overlay files to append to a single fragment, in order (the last entry is
    /// newest). The overlays are appended to the fragment's existing `overlays`
    /// list; they do not replace it, so overlays written by concurrent commits are
    /// preserved.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DataOverlayGroup {
        #[prost(uint64, tag = "1")]
        pub fragment_id: u64,
        /// Each DataOverlayFile.committed_version is left 0 by the writer and stamped
        /// to the new dataset version at commit time (re-stamped on retry), in the
        /// same way as the created-at / last-updated-at version sequences. The fields
        /// touched are read from each overlay's `data_file.fields`.
        #[prost(message, repeated, tag = "2")]
        pub overlays: ::prost::alloc::vec::Vec<super::DataOverlayFile>,
    }
    /// Attach overlay files to fragments, supplying new values for a subset of
    /// (row offset, field) cells without rewriting the fragments' base data files.
    /// See the DataOverlayFile message in table.proto for resolution, coverage, and
    /// versioning rules, and the Data Overlay Files and Transactions specifications
    /// for the (intentionally permissive) conflict semantics.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct DataOverlay {
        #[prost(message, repeated, tag = "1")]
        pub groups: ::prost::alloc::vec::Vec<DataOverlayGroup>,
    }
    /// Update SSTable compaction progress in the MemWAL index.
    /// This operation is used during merge-insert to atomically record which
    /// SSTables have been compacted into the base table.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct UpdateMemWalState {
        /// SSTables being marked as compacted.
        #[prost(message, repeated, tag = "1")]
        pub compacted_sstables: ::prost::alloc::vec::Vec<super::CompactedSsTable>,
    }
    /// An operation that updates base paths in the dataset.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct UpdateBases {
        /// The new base paths to add to the manifest.
        #[prost(message, repeated, tag = "1")]
        pub new_bases: ::prost::alloc::vec::Vec<super::BasePath>,
    }
    /// The mode of update operation
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum UpdateMode {
        /// / rows are deleted in current fragments and rewritten in new fragments.
        /// / This is most optimal when the majority of columns are being rewritten
        /// / or only a few rows are being updated.
        RewriteRows = 0,
        /// / within each fragment, columns are fully rewritten and inserted as new data files.
        /// / Old versions of columns are tombstoned. This is most optimal when most rows are affected
        /// / but a small subset of columns are affected.
        RewriteColumns = 1,
    }
    impl UpdateMode {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::RewriteRows => "REWRITE_ROWS",
                Self::RewriteColumns => "REWRITE_COLUMNS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "REWRITE_ROWS" => Some(Self::RewriteRows),
                "REWRITE_COLUMNS" => Some(Self::RewriteColumns),
                _ => None,
            }
        }
    }
    /// The operation of this transaction.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Operation {
        #[prost(message, tag = "100")]
        Append(Append),
        #[prost(message, tag = "101")]
        Delete(Delete),
        #[prost(message, tag = "102")]
        Overwrite(Overwrite),
        #[prost(message, tag = "103")]
        CreateIndex(CreateIndex),
        #[prost(message, tag = "104")]
        Rewrite(Rewrite),
        #[prost(message, tag = "105")]
        Merge(Merge),
        #[prost(message, tag = "106")]
        Restore(Restore),
        #[prost(message, tag = "107")]
        ReserveFragments(ReserveFragments),
        #[prost(message, tag = "108")]
        Update(Update),
        #[prost(message, tag = "109")]
        Project(Project),
        #[prost(message, tag = "110")]
        UpdateConfig(UpdateConfig),
        #[prost(message, tag = "111")]
        DataReplacement(DataReplacement),
        #[prost(message, tag = "112")]
        UpdateMemWalState(UpdateMemWalState),
        #[prost(message, tag = "113")]
        Clone(Clone),
        #[prost(message, tag = "114")]
        UpdateBases(UpdateBases),
        #[prost(message, tag = "115")]
        DataOverlay(DataOverlay),
    }
}