Struct TableSchema 

pub struct TableSchema {
    pub keyspace: String,
    pub table: String,
    pub partition_keys: Vec<KeyColumn>,
    pub clustering_keys: Vec<ClusteringColumn>,
    pub columns: Vec<Column>,
    pub comments: HashMap<String, String>,
    pub dropped_columns: HashMap<String, i64>,
}

Table schema definition loaded from JSON

Fields

keyspace: String

Keyspace name

table: String

Table name

partition_keys: Vec<KeyColumn>

Partition key columns (ordered)

clustering_keys: Vec<ClusteringColumn>

Clustering key columns (ordered)

columns: Vec<Column>

All columns in the table

comments: HashMap<String, String>

Optional metadata

dropped_columns: HashMap<String, i64>

Dropped-column drop times in microseconds (column name → drop_time_micros).

Populated from the schema-loading surface (JSON dropped_columns, or set programmatically) since drop times are assigned at DDL-execution by the cluster catalog (system_schema.dropped_columns) and are not recorded in local SSTable files or the CQL DROP COLUMN text. Used during compaction to discard cells of a dropped column whose timestamp ≤ the drop time (Cassandra cb34ad47). See issues #904 (this plumbing) and #847 (the merge-side filter).

Scope (#847): this map carries only the drop time, so the dropped column’s pre-drop cells are decoded using its CURRENT type in Self::columns (the decode contract enforced by Self::validate_dropped_columns). That is byte-correct when the column’s type is unchanged — the common case. A column dropped and later RE-ADDED with a DIFFERENT type is out of scope: the historical cells would be decoded with the new type and could misparse. Supporting per-version types requires carrying type metadata here (or decoding from the SSTable serialization-header type) and is follow-up work alongside the element-level representation in #899.

Filtering is also at row-timestamp granularity (the merge stream surfaces only the row write-time per cell); exact per-cell purging is tracked as follow-up #922.

Implementations

impl TableSchema

pub fn ordered_partition_keys(&self) -> Vec<&KeyColumn>

Get partition key columns ordered by position.

Returns the same order as a full sort_by_key(position) would, but skips the sort when the keys are already in ascending position order (the common case — see the module docs), so it is no longer re-sorted per call.

pub fn ordered_clustering_keys(&self) -> Vec<&ClusteringColumn>

Get clustering key columns ordered by position.

Same order as before; the sort is skipped when the keys are already ordered.

impl TableSchema

pub fn get_column_comparator(&self, column_name: &str) -> Result<ComparatorType>

Get ComparatorType for a specific column

pub fn get_all_comparators(&self) -> Result<HashMap<String, ComparatorType>>

Get ComparatorTypes for all columns

pub fn get_partition_key_comparators(&self) -> Result<Vec<ComparatorType>>

Get ComparatorTypes for partition key columns in order

pub fn get_clustering_key_comparators(&self) -> Result<Vec<ComparatorType>>

Get ComparatorTypes for clustering key columns in order

pub fn is_column_type_compatible( &self, column_name: &str, expected_type: &str, ) -> Result<bool>

Check if a column type is compatible with an expected type

impl TableSchema

pub fn from_sstable_header(header: &SSTableHeader) -> Result<Self>

Extract schema from SSTable header column metadata

This method constructs a TableSchema from the column information embedded in the SSTable header’s SerializationHeader.

pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self>

Load schema from JSON file

pub fn from_json(json: &str) -> Result<Self>

Parse schema from JSON string

pub fn to_file<P: AsRef<Path>>(&self, path: P) -> Result<()>

Save schema to JSON file

pub fn validate(&self) -> Result<()>

Validate schema consistency

pub fn for_compaction_output(&self, retained: &HashSet<String>) -> TableSchema

The post-drop schema that compaction uses to write its output.

The decode schema retains dropped columns (carrying their type) so input cells can be parsed and then purged by the merge filter (see Self::validate_dropped_columns). The compaction output must keep its serialization header / row column bitmap consistent with the cells that actually survive the merge:

• A dropped column with no surviving cells (all cells were at or before its drop time) is removed from columns so it does not appear in the output header. This lets a natural post-drop reader schema (which omits the column) read the output without the header-column / bitmap-index misalignment that retaining it would cause (roborev #847).
• A dropped column with surviving cells (re-added: cells written after drop_time) is RETAINED in columns, because the merge still emits those cells and the writer needs a matching header column — otherwise the cell would be serialized with no header entry and corrupt the row.

retained is the set of dropped-column names that had surviving cells (computed by compact_sstables from a merge pre-pass). The returned schema carries an empty dropped_columns map: the purge has already happened, so the output must not re-purge the surviving cells on a later compaction.

pub fn validate_dropped_columns(&self) -> Result<()>

Validate the dropped-column decode contract (#904/#847).

Dropped-column filtering during compaction discards a dropped column’s cells after they are decoded. The schema-driven reader only decodes a column whose name is present in Self::columns (it intersects the on-disk serialization-header columns with the schema); a column absent from columns is skipped without consuming its bytes, so its cells would never reach the filter and surrounding columns could misalign.

Therefore every column named in dropped_columns MUST remain declared in columns (carrying its type) so its cells decode and can be purged. This mirrors Cassandra retaining a dropped column’s type in system_schema.dropped_columns. Decoding a dropped column that is absent from columns (purely from header type metadata) is follow-up work related to #899 and intentionally out of scope here.

pub fn validate_udt_references(&self, registry: &UdtRegistry) -> Result<()>

Validate that every UDT referenced by a column exists in the registry.

This is a schema-load-time pass that fails fast with a schema-category error naming the missing UDT, instead of surfacing the problem later as a confusing parse/deserialization error (issue #761). Nested references are validated recursively: a UDT inside a collection, frozen<>, a tuple, or another UDT is checked just like a top-level reference.

UDTs are looked up in the schema’s own keyspace; the system keyspace is also consulted so built-in/system UDTs resolve regardless of the table’s keyspace.

pub fn get_column(&self, name: &str) -> Option<&Column>

Get column by name

pub fn is_partition_key(&self, name: &str) -> bool

Check if column is a partition key

pub fn is_clustering_key(&self, name: &str) -> bool

Check if column is a clustering key

Trait Implementations

impl Clone for TableSchema

fn clone(&self) -> TableSchema

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CqlVisitor<TableSchema> for SchemaBuilderVisitor

fn visit_statement(&mut self, statement: &CqlStatement) -> Result<TableSchema>

fn visit_create_table(&mut self, create: &CqlCreateTable) -> Result<TableSchema>

fn visit_select(&mut self, _select: &CqlSelect) -> Result<TableSchema>

fn visit_insert(&mut self, _insert: &CqlInsert) -> Result<TableSchema>

fn visit_update(&mut self, _update: &CqlUpdate) -> Result<TableSchema>

fn visit_delete(&mut self, _delete: &CqlDelete) -> Result<TableSchema>

fn visit_drop_table(&mut self, _drop: &CqlDropTable) -> Result<TableSchema>

fn visit_create_index( &mut self, _create: &CqlCreateIndex, ) -> Result<TableSchema>

fn visit_alter_table(&mut self, _alter: &CqlAlterTable) -> Result<TableSchema>

fn visit_data_type(&mut self, _data_type: &CqlDataType) -> Result<TableSchema>

fn visit_expression( &mut self, _expression: &CqlExpression, ) -> Result<TableSchema>

fn visit_identifier( &mut self, _identifier: &CqlIdentifier, ) -> Result<TableSchema>

fn visit_literal(&mut self, _literal: &CqlLiteral) -> Result<TableSchema>

impl Debug for TableSchema

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TableSchema

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TableSchema

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.