cobble-table 0.5.0

Schema and table APIs for Cobble
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use super::file_catalog::CatalogRuntimeContext;
use crate::TableSchema;
use serde::{Deserialize, Serialize};
use std::fmt::{Display, Formatter};
use std::sync::Arc;

/// Stable identity of a table, independent of its catalog name.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(transparent)]
pub struct TableId(u32);

impl TableId {
    pub(crate) fn new(value: u32) -> Self {
        Self(value)
    }

    pub fn as_u32(self) -> u32 {
        self.0
    }
}

impl Display for TableId {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
        Display::fmt(&self.0, formatter)
    }
}

/// Per-table catalog schema identity, starting at zero and increasing monotonically.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(transparent)]
pub struct CatalogSchemaId(u32);

impl CatalogSchemaId {
    pub(crate) const INITIAL: Self = Self(0);

    pub(crate) fn next(self) -> Option<Self> {
        self.0.checked_add(1).map(Self)
    }

    pub fn as_u32(self) -> u32 {
        self.0
    }
}

impl From<u32> for CatalogSchemaId {
    fn from(value: u32) -> Self {
        Self(value)
    }
}

impl Display for CatalogSchemaId {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
        Display::fmt(&self.0, formatter)
    }
}

/// A semantic table name with an extensible, multi-component namespace.
#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct TableIdentifier {
    namespace: Vec<String>,
    name: String,
}

impl TableIdentifier {
    pub fn new<I, S>(namespace: I, name: impl Into<String>) -> Self
    where
        I: IntoIterator<Item = S>,
        S: Into<String>,
    {
        Self {
            namespace: namespace.into_iter().map(Into::into).collect(),
            name: name.into(),
        }
    }

    pub fn namespace(&self) -> &[String] {
        &self.namespace
    }

    pub fn name(&self) -> &str {
        &self.name
    }

    pub(crate) fn renamed(&self, name: String) -> Self {
        Self {
            namespace: self.namespace.clone(),
            name,
        }
    }
}

/// Semantic table descriptor returned by a catalog.
#[derive(Clone)]
pub struct CatalogTable {
    pub(crate) identifier: TableIdentifier,
    pub(crate) table_id: TableId,
    pub(crate) catalog_schema_id: CatalogSchemaId,
    pub(crate) schema: TableSchema,
    pub(crate) runtime_context: Arc<CatalogRuntimeContext>,
}

impl std::fmt::Debug for CatalogTable {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
        formatter
            .debug_struct("CatalogTable")
            .field("identifier", &self.identifier)
            .field("table_id", &self.table_id)
            .field("catalog_schema_id", &self.catalog_schema_id)
            .field("schema", &self.schema)
            .finish()
    }
}

impl CatalogTable {
    pub fn identifier(&self) -> &TableIdentifier {
        &self.identifier
    }

    pub fn table_id(&self) -> TableId {
        self.table_id
    }

    pub fn catalog_schema_id(&self) -> CatalogSchemaId {
        self.catalog_schema_id
    }

    pub fn schema(&self) -> &TableSchema {
        &self.schema
    }
}