Struct Catalog

Source

pub struct Catalog {
    state: CatalogState,
    plans: CatalogPlans,
    expr_cache_handle: Option<ExpressionCacheHandle>,
    storage: Arc<Mutex<Box<dyn DurableCatalogState>>>,
    transient_revision: u64,
}

Expand description

A Catalog keeps track of the SQL objects known to the planner.

For each object, it keeps track of both forward and reverse dependencies: i.e., which objects are depended upon by the object, and which objects depend upon the object. It enforces the SQL rules around dropping: an object cannot be dropped until all of the objects that depend upon it are dropped. It also enforces uniqueness of names.

SQL mandates a hierarchy of exactly three layers. A catalog contains databases, databases contain schemas, and schemas contain catalog items, like sources, sinks, view, and indexes.

To the outside world, databases, schemas, and items are all identified by name. Items can be referred to by their FullItemName, which fully and unambiguously specifies the item, or a PartialItemName, which can omit the database name and/or the schema name. Partial names can be converted into full names via a complicated resolution process documented by the CatalogState::resolve method.

The catalog also maintains special “ambient schemas”: virtual schemas, implicitly present in all databases, that house various system views. The big examples of ambient schemas are pg_catalog and mz_catalog.

Fields§

§state: CatalogState§plans: CatalogPlans§expr_cache_handle: Option<ExpressionCacheHandle>§storage: Arc<Mutex<Box<dyn DurableCatalogState>>>§transient_revision: u64

Struct CatalogCopy item path

Fields§

Implementations§

impl Catalog

pub fn render_notices( &self, df_meta: DataflowMetainfo<RawOptimizerNotice>, notice_ids: Vec<GlobalId>, item_id: Option<GlobalId>, ) -> DataflowMetainfo<Arc<OptimizerNotice>>

impl Catalog

pub async fn initialize_state<'a>( config: StateConfig, storage: &'a mut Box<dyn DurableCatalogState>, ) -> Result<InitializeStateResult, AdapterError>

pub fn open( config: Config<'_>, ) -> BoxFuture<'static, Result<OpenCatalogResult, AdapterError>>

async fn initialize_storage_state( &mut self, storage_collections: &Arc<dyn StorageCollections<Timestamp = Timestamp> + Send + Sync>, ) -> Result<(), CatalogError>

pub async fn initialize_controller( &mut self, config: ControllerConfig, envd_epoch: NonZeroI64, read_only: bool, ) -> Result<Controller<Timestamp>, CatalogError>

pub async fn expire(self)

impl Catalog

pub fn as_optimizer_catalog(self: Arc<Self>) -> Arc<dyn OptimizerCatalog>

impl Catalog

pub(crate) fn get_timeline_context(&self, id: CatalogItemId) -> TimelineContext

pub(crate) fn get_timeline_context_for_global_id( &self, id: GlobalId, ) -> TimelineContext

pub fn partition_ids_by_timeline_context( &self, id_bundle: &CollectionIdBundle, ) -> impl Iterator<Item = (TimelineContext, CollectionIdBundle)> + use<>

pub(crate) fn ids_in_timeline(&self, timeline: &Timeline) -> CollectionIdBundle

pub(crate) fn validate_timeline_context<I>( &self, ids: I, ) -> Result<TimelineContext, AdapterError>where I: IntoIterator<Item = GlobalId>,

fn get_timeline_contexts<I>(&self, ids: I) -> BTreeSet<TimelineContext>where I: IntoIterator<Item = CatalogItemId>,

impl Catalog

fn should_audit_log_item(item: &CatalogItem) -> bool

fn temporary_ids( &self, ops: &[Op], temporary_drops: BTreeSet<(&ConnectionId, String)>, ) -> Result<BTreeSet<CatalogItemId>, Error>

pub async fn transact( &mut self, storage_collections: Option<&mut Arc<dyn StorageCollections<Timestamp = Timestamp> + Send + Sync>>, oracle_write_ts: Timestamp, session: Option<&ConnMeta>, ops: Vec<Op>, ) -> Result<TransactionResult, AdapterError>

§Panics

fn log_update(state: &CatalogState, id: &CatalogItemId)

fn update_privilege_owners( privileges: &mut PrivilegeMap, old_owner: RoleId, new_owner: RoleId, )

impl Catalog

pub fn set_optimized_plan( &mut self, id: GlobalId, plan: DataflowDescription<OptimizedMirRelationExpr>, )

pub fn set_physical_plan( &mut self, id: GlobalId, plan: DataflowDescription<Plan>, )

pub fn try_get_optimized_plan( &self, id: &GlobalId, ) -> Option<&DataflowDescription<OptimizedMirRelationExpr>>

pub fn try_get_physical_plan( &self, id: &GlobalId, ) -> Option<&DataflowDescription<Plan>>

pub fn set_dataflow_metainfo( &mut self, id: GlobalId, metainfo: DataflowMetainfo<Arc<OptimizerNotice>>, )

pub fn try_get_dataflow_metainfo( &self, id: &GlobalId, ) -> Option<&DataflowMetainfo<Arc<OptimizerNotice>>>

pub fn drop_plans_and_metainfos( &mut self, drop_ids: &BTreeSet<GlobalId>, ) -> BTreeSet<Arc<OptimizerNotice>>

pub(crate) fn invalidate_for_index( &self, ons: impl Iterator<Item = GlobalId>, ) -> BTreeSet<GlobalId>

impl Catalog

pub fn transient_revision(&self) -> u64

pub async fn with_debug<F, Fut, T>(f: F) -> Twhere F: FnOnce(Catalog) -> Fut, Fut: Future<Output = T>,

pub async fn with_debug_in_bootstrap<F, Fut, T>(f: F) -> Twhere F: FnOnce(Catalog) -> Fut, Fut: Future<Output = T>,

pub async fn open_debug_catalog( persist_client: PersistClient, organization_id: Uuid, bootstrap_args: &BootstrapArgs, ) -> Result<Catalog, Error>

pub async fn open_debug_read_only_catalog( persist_client: PersistClient, organization_id: Uuid, bootstrap_args: &BootstrapArgs, ) -> Result<Catalog, Error>

pub fn for_session<'a>(&'a self, session: &'a Session) -> ConnCatalog<'a>

pub fn for_sessionless_user(&self, role_id: RoleId) -> ConnCatalog<'_>

pub fn for_system_session(&self) -> ConnCatalog<'_>

async fn storage<'a>(&'a self) -> MutexGuard<'a, Box<dyn DurableCatalogState>>

pub async fn current_upper(&self) -> Timestamp

pub async fn allocate_user_id( &self, commit_ts: Timestamp, ) -> Result<(CatalogItemId, GlobalId), Error>

pub async fn allocate_user_ids( &self, amount: u64, commit_ts: Timestamp, ) -> Result<Vec<(CatalogItemId, GlobalId)>, Error>

pub async fn allocate_user_id_for_test( &self, ) -> Result<(CatalogItemId, GlobalId), Error>

pub async fn get_next_user_item_id(&self) -> Result<u64, Error>

pub async fn get_next_system_item_id(&self) -> Result<u64, Error>

pub async fn allocate_user_cluster_id( &self, commit_ts: Timestamp, ) -> Result<ClusterId, Error>

pub async fn get_next_system_replica_id(&self) -> Result<u64, Error>

pub async fn get_next_user_replica_id(&self) -> Result<u64, Error>

pub fn resolve_database( &self, database_name: &str, ) -> Result<&Database, SqlCatalogError>

pub fn resolve_schema( &self, current_database: Option<&DatabaseId>, database_name: Option<&str>, schema_name: &str, conn_id: &ConnectionId, ) -> Result<&Schema, SqlCatalogError>

pub fn resolve_schema_in_database( &self, database_spec: &ResolvedDatabaseSpecifier, schema_name: &str, conn_id: &ConnectionId, ) -> Result<&Schema, SqlCatalogError>

pub fn resolve_replica_in_cluster( &self, cluster_id: &ClusterId, replica_name: &str, ) -> Result<&ClusterReplica, SqlCatalogError>

pub fn resolve_system_schema(&self, name: &'static str) -> SchemaId

pub fn resolve_search_path( &self, session: &Session, ) -> Vec<(ResolvedDatabaseSpecifier, SchemaSpecifier)>

pub fn resolve_entry( &self, current_database: Option<&DatabaseId>, search_path: &Vec<(ResolvedDatabaseSpecifier, SchemaSpecifier)>, name: &PartialItemName, conn_id: &ConnectionId, ) -> Result<&CatalogEntry, SqlCatalogError>

pub fn resolve_builtin_table( &self, builtin: &'static BuiltinTable, ) -> CatalogItemId

pub fn resolve_builtin_log(&self, builtin: &'static BuiltinLog) -> CatalogItemId

pub fn resolve_builtin_storage_collection( &self, builtin: &'static BuiltinSource, ) -> CatalogItemId

pub fn resolve_function( &self, current_database: Option<&DatabaseId>, search_path: &Vec<(ResolvedDatabaseSpecifier, SchemaSpecifier)>, name: &PartialItemName, conn_id: &ConnectionId, ) -> Result<&CatalogEntry, SqlCatalogError>

pub fn resolve_type( &self, current_database: Option<&DatabaseId>, search_path: &Vec<(ResolvedDatabaseSpecifier, SchemaSpecifier)>, name: &PartialItemName, conn_id: &ConnectionId, ) -> Result<&CatalogEntry, SqlCatalogError>

pub fn resolve_cluster(&self, name: &str) -> Result<&Cluster, SqlCatalogError>

pub fn resolve_builtin_cluster(&self, cluster: &BuiltinCluster) -> &Cluster

§Panics

pub fn get_mz_catalog_server_cluster_id(&self) -> &ClusterId

pub fn resolve_target_cluster( &self, target_cluster: TargetCluster, session: &Session, ) -> Result<&Cluster, AdapterError>

pub fn active_cluster( &self, session: &Session, ) -> Result<&Cluster, AdapterError>

pub fn state(&self) -> &CatalogState

pub fn resolve_full_name( &self, name: &QualifiedItemName, conn_id: Option<&ConnectionId>, ) -> FullItemName

pub fn try_get_entry(&self, id: &CatalogItemId) -> Option<&CatalogEntry>

pub fn try_get_entry_by_global_id(&self, id: &GlobalId) -> Option<&CatalogEntry>

pub fn get_entry(&self, id: &CatalogItemId) -> &CatalogEntry

pub fn get_entry_by_global_id(&self, id: &GlobalId) -> CatalogCollectionEntry

pub fn get_global_ids<'a>( &'a self, id: &CatalogItemId, ) -> impl Iterator<Item = GlobalId> + use<'a>

Struct Catalog

pub(crate) fn validate_timeline_context<I>( &self, ids: I, ) -> Result<TimelineContext, AdapterError>
where I: IntoIterator<Item = GlobalId>,

fn get_timeline_contexts<I>(&self, ids: I) -> BTreeSet<TimelineContext>
where I: IntoIterator<Item = CatalogItemId>,

pub async fn with_debug<F, Fut, T>(f: F) -> T
where F: FnOnce(Catalog) -> Fut, Fut: Future<Output = T>,

pub async fn with_debug_in_bootstrap<F, Fut, T>(f: F) -> T
where F: FnOnce(Catalog) -> Fut, Fut: Future<Output = T>,