supertable-core 0.1.0

Core library for SuperTable, a next-generation open table format
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

//! # SuperTable High-Level Table API
//!
//! This module provides the `Table` struct, which is the primary entry point
//! for interacting with SuperTable. It combines metadata management, storage access,
//! and transactional consistency.

use crate::catalog::{Catalog, TableIdentifier};
use crate::metadata::TableMetadata;
use crate::storage::Storage;
use crate::transaction::Transaction;
use std::sync::Arc;

/// A high-level representation of a SuperTable.
#[allow(unused)]
#[derive(Clone)]
pub struct Table {
    pub(crate) identifier: String,
    pub(crate) catalog: Arc<dyn Catalog>,
    pub(crate) metadata: TableMetadata,
    pub(crate) storage: Storage,
}

impl std::fmt::Debug for Table {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Table")
            .field("identifier", &self.identifier)
            .field("metadata", &self.metadata)
            .finish()
    }
}

impl Table {
    /// Creates a new table instance.
    pub fn new(
        identifier: impl Into<String>,
        catalog: Arc<dyn Catalog>,
        metadata: TableMetadata,
        storage: Storage,
    ) -> Self {
        Self {
            identifier: identifier.into(),
            catalog,
            metadata,
            storage,
        }
    }

    /// Returns the table metadata.
    pub fn metadata(&self) -> &TableMetadata {
        &self.metadata
    }

    /// Returns the table storage.
    pub fn storage(&self) -> &Storage {
        &self.storage
    }

    /// Returns the table identifier.
    pub fn identifier(&self) -> &str {
        &self.identifier
    }

    /// Starts a new transaction on this table.
    pub fn new_transaction(&self) -> Transaction {
        Transaction::new(self.metadata.clone())
    }

    /// Returns a view of the table at a specific snapshot.
    pub fn at_snapshot(&self, snapshot_id: i64) -> anyhow::Result<Table> {
        let snapshot = self
            .metadata
            .snapshot(snapshot_id)
            .ok_or_else(|| anyhow::anyhow!("Snapshot {} not found", snapshot_id))?;

        let mut metadata = self.metadata.clone();
        metadata.current_snapshot_id = Some(snapshot.snapshot_id);

        Ok(Table::new(
            self.identifier.clone(),
            self.catalog.clone(),
            metadata,
            self.storage.clone(),
        ))
    }

    /// Returns a view of the table as of a specific timestamp.
    pub fn as_of(&self, timestamp_ms: i64) -> anyhow::Result<Table> {
        let snapshot = self
            .metadata
            .snapshot_at(timestamp_ms)
            .ok_or_else(|| anyhow::anyhow!("No snapshot found at or before {}", timestamp_ms))?;

        self.at_snapshot(snapshot.snapshot_id)
    }

    /// Refreshes the table metadata from the catalog.
    pub async fn refresh(&mut self) -> anyhow::Result<()> {
        let identifier = TableIdentifier::parse(&self.identifier);
        let new_metadata = self.catalog.load_table(&identifier).await?;
        self.metadata = new_metadata;
        Ok(())
    }

    /// Creates a new scan planner for this table's current snapshot.
    pub fn new_scan(&self) -> crate::scan::ScanPlanner<'_> {
        let snapshot = self
            .metadata
            .current_snapshot()
            .expect("Table must have a snapshot to scan");
        crate::scan::ScanPlanner::new(snapshot, &self.storage)
    }

    // TODO: Implement high-level refresh(), commit(), etc.
}