From a055e35ee7c1182d1e01a8b47625012f0617e315 Mon Sep 17 00:00:00 2001 From: Roshan Jobanputra Date: Fri, 23 Aug 2024 12:07:23 -0700 Subject: [PATCH] Introduce the Source References internal table, durably stored in the catalog --- .../content/sql/system-catalog/mz_internal.md | 2 + src/adapter/src/catalog/apply.rs | 24 + .../src/catalog/builtin_table_updates.rs | 49 +- src/adapter/src/catalog/open.rs | 1 + src/buf.yaml | 2 + src/catalog-debug/src/main.rs | 11 +- src/catalog/protos/hashes.json | 6 +- src/catalog/protos/objects.proto | 21 + src/catalog/protos/objects_v63.proto | 914 ++++++++++++++++++ src/catalog/src/builtin.rs | 25 + src/catalog/src/durable.rs | 4 +- src/catalog/src/durable/debug.rs | 11 + src/catalog/src/durable/objects.rs | 57 ++ .../src/durable/objects/serialization.rs | 65 +- .../src/durable/objects/state_update.rs | 28 + src/catalog/src/durable/persist.rs | 6 + src/catalog/src/durable/transaction.rs | 15 +- src/catalog/src/durable/upgrade.rs | 15 +- .../durable/upgrade/snapshots/objects_v63.txt | 100 ++ src/catalog/src/durable/upgrade/v62_to_v63.rs | 18 + src/catalog/src/memory/objects.rs | 8 + src/catalog/tests/debug.rs | 2 + src/catalog/tests/open.rs | 2 + .../tests/snapshots/debug__opened_trace.snap | 3 + .../snapshots/open__initial_snapshot.snap | 1 + src/environmentd/tests/testdata/http/ws | 4 +- src/pgrepr-consts/src/oid.rs | 1 + .../autogenerated/mz_internal.slt | 1 + .../information_schema_tables.slt | 4 + test/sqllogictest/oid.slt | 1 + test/testdrive/catalog.td | 3 +- 31 files changed, 1384 insertions(+), 20 deletions(-) create mode 100644 src/catalog/protos/objects_v63.proto create mode 100644 src/catalog/src/durable/upgrade/snapshots/objects_v63.txt create mode 100644 src/catalog/src/durable/upgrade/v62_to_v63.rs diff --git a/doc/user/content/sql/system-catalog/mz_internal.md b/doc/user/content/sql/system-catalog/mz_internal.md index 8f1184d741db8..f26e9714731df 100644 --- a/doc/user/content/sql/system-catalog/mz_internal.md +++ b/doc/user/content/sql/system-catalog/mz_internal.md @@ -923,6 +923,8 @@ The `mz_source_statistics` view contains statistics about each source. + + ### Counters `messages_received`, `messages_staged`, `updates_staged`, and `updates_committed` are all counters that monotonically increase. They are _only useful for calculating rates_, to understand the general performance of your source. diff --git a/src/adapter/src/catalog/apply.rs b/src/adapter/src/catalog/apply.rs index 38a9f6016be80..a1bb42cf0cd80 100644 --- a/src/adapter/src/catalog/apply.rs +++ b/src/adapter/src/catalog/apply.rs @@ -231,6 +231,9 @@ impl CatalogState { StateUpdateKind::Comment(comment) => { self.apply_comment_update(comment, diff, retractions); } + StateUpdateKind::SourceReferences(source_reference) => { + self.apply_source_references_update(source_reference, diff, retractions); + } StateUpdateKind::AuditLog(_audit_log) => { // Audit logs are not stored in-memory. } @@ -935,6 +938,23 @@ impl CatalogState { } } + #[instrument(level = "debug")] + fn apply_source_references_update( + &mut self, + _source_references: mz_catalog::durable::SourceReferences, + diff: StateDiff, + _retractions: &mut InProgressRetractions, + ) { + match diff { + StateDiff::Addition => { + unimplemented!("source references are not yet implemented"); + } + StateDiff::Retraction => { + unimplemented!("source references are not yet implemented"); + } + } + } + #[instrument(level = "debug")] fn apply_storage_collection_metadata_update( &mut self, @@ -1061,6 +1081,9 @@ impl CatalogState { &comment.comment, diff, )], + StateUpdateKind::SourceReferences(source_references) => { + self.pack_source_references_update(&source_references, diff) + } StateUpdateKind::AuditLog(audit_log) => { vec![self .pack_audit_log_update(&audit_log.event, diff) @@ -1562,6 +1585,7 @@ fn sort_updates_inner(updates: Vec) -> Vec { &mut item_additions, ), StateUpdateKind::Comment(_) + | StateUpdateKind::SourceReferences(_) | StateUpdateKind::AuditLog(_) | StateUpdateKind::StorageCollectionMetadata(_) | StateUpdateKind::UnfinalizedShard(_) => push_update( diff --git a/src/adapter/src/catalog/builtin_table_updates.rs b/src/adapter/src/catalog/builtin_table_updates.rs index 83475749c49ce..fd1fc85fe5e90 100644 --- a/src/adapter/src/catalog/builtin_table_updates.rs +++ b/src/adapter/src/catalog/builtin_table_updates.rs @@ -25,11 +25,12 @@ use mz_catalog::builtin::{ MZ_MATERIALIZED_VIEWS, MZ_MATERIALIZED_VIEW_REFRESH_STRATEGIES, MZ_MYSQL_SOURCE_TABLES, MZ_OBJECT_DEPENDENCIES, MZ_OPERATORS, MZ_PENDING_CLUSTER_REPLICAS, MZ_POSTGRES_SOURCES, MZ_POSTGRES_SOURCE_TABLES, MZ_PSEUDO_TYPES, MZ_ROLES, MZ_ROLE_MEMBERS, MZ_ROLE_PARAMETERS, - MZ_SCHEMAS, MZ_SECRETS, MZ_SESSIONS, MZ_SINKS, MZ_SOURCES, MZ_SSH_TUNNEL_CONNECTIONS, - MZ_STORAGE_USAGE_BY_SHARD, MZ_SUBSCRIPTIONS, MZ_SYSTEM_PRIVILEGES, MZ_TABLES, MZ_TYPES, - MZ_TYPE_PG_METADATA, MZ_VIEWS, MZ_WEBHOOKS_SOURCES, + MZ_SCHEMAS, MZ_SECRETS, MZ_SESSIONS, MZ_SINKS, MZ_SOURCES, MZ_SOURCE_REFERENCES, + MZ_SSH_TUNNEL_CONNECTIONS, MZ_STORAGE_USAGE_BY_SHARD, MZ_SUBSCRIPTIONS, MZ_SYSTEM_PRIVILEGES, + MZ_TABLES, MZ_TYPES, MZ_TYPE_PG_METADATA, MZ_VIEWS, MZ_WEBHOOKS_SOURCES, }; use mz_catalog::config::AwsPrincipalContext; +use mz_catalog::durable::SourceReferences; use mz_catalog::memory::error::{Error, ErrorKind}; use mz_catalog::memory::objects::{ CatalogItem, ClusterReplicaProcessStatus, ClusterVariant, Connection, DataSourceDesc, Func, @@ -1993,4 +1994,46 @@ impl CatalogState { diff, } } + + pub fn pack_source_references_update( + &self, + source_references: &SourceReferences, + diff: Diff, + ) -> Vec> { + let source_id = source_references.source_id.to_string(); + let updated_at = &source_references.updated_at; + source_references + .references + .iter() + .map(|reference| { + let mut row = Row::default(); + let mut packer = row.packer(); + packer.extend([ + Datum::String(&source_id), + reference + .namespace + .as_ref() + .map(|s| Datum::String(s)) + .unwrap_or(Datum::Null), + Datum::String(&reference.name), + Datum::TimestampTz( + mz_ore::now::to_datetime(*updated_at) + .try_into() + .expect("must fit"), + ), + ]); + if reference.columns.len() > 0 { + packer.push_list(reference.columns.iter().map(|col| Datum::String(col))); + } else { + packer.push(Datum::Null); + } + + BuiltinTableUpdate { + id: &*MZ_SOURCE_REFERENCES, + row, + diff, + } + }) + .collect() + } } diff --git a/src/adapter/src/catalog/open.rs b/src/adapter/src/catalog/open.rs index 9db810e444a6c..80d9180e4bbf9 100644 --- a/src/adapter/src/catalog/open.rs +++ b/src/adapter/src/catalog/open.rs @@ -374,6 +374,7 @@ impl Catalog { BootstrapStateUpdateKind::Comment(_) | BootstrapStateUpdateKind::AuditLog(_) | BootstrapStateUpdateKind::StorageCollectionMetadata(_) + | BootstrapStateUpdateKind::SourceReferences(_) | BootstrapStateUpdateKind::UnfinalizedShard(_) => { post_item_updates.push(StateUpdate { kind: kind.into(), diff --git a/src/buf.yaml b/src/buf.yaml index 8468fc2c527b7..c537ee91180f4 100644 --- a/src/buf.yaml +++ b/src/buf.yaml @@ -24,6 +24,8 @@ breaking: # reason: does currently not require backward-compatibility - catalog/protos/objects_v62.proto # reason: does currently not require backward-compatibility + - catalog/protos/objects_v63.proto + # reason: does currently not require backward-compatibility - cluster-client/src/client.proto # reason: does currently not require backward-compatibility - compute-client/src/logging.proto diff --git a/src/catalog-debug/src/main.rs b/src/catalog-debug/src/main.rs index 760f4331e617a..293eb39acc801 100644 --- a/src/catalog-debug/src/main.rs +++ b/src/catalog-debug/src/main.rs @@ -30,7 +30,7 @@ use mz_catalog::durable::debug::{ ClusterReplicaCollection, Collection, CollectionTrace, CollectionType, CommentCollection, ConfigCollection, DatabaseCollection, DebugCatalogState, DefaultPrivilegeCollection, IdAllocatorCollection, ItemCollection, RoleCollection, SchemaCollection, SettingCollection, - StorageCollectionMetadataCollection, SystemConfigurationCollection, + SourceReferencesCollection, StorageCollectionMetadataCollection, SystemConfigurationCollection, SystemItemMappingCollection, SystemPrivilegeCollection, Trace, TxnWalShardCollection, UnfinalizedShardsCollection, }; @@ -257,6 +257,7 @@ macro_rules! for_collection { CollectionType::Role => $fn::($($arg),*).await?, CollectionType::Schema => $fn::($($arg),*).await?, CollectionType::Setting => $fn::($($arg),*).await?, + CollectionType::SourceReferences => $fn::($($arg),*).await?, CollectionType::SystemConfiguration => $fn::($($arg),*).await?, CollectionType::SystemGidMapping => $fn::($($arg),*).await?, CollectionType::SystemPrivileges => $fn::($($arg),*).await?, @@ -392,6 +393,7 @@ async fn dump( roles, schemas, settings, + source_references, system_object_mappings, system_configurations, system_privileges, @@ -437,6 +439,13 @@ async fn dump( dump_col(&mut data, roles, &ignore, stats_only, consolidate); dump_col(&mut data, schemas, &ignore, stats_only, consolidate); dump_col(&mut data, settings, &ignore, stats_only, consolidate); + dump_col( + &mut data, + source_references, + &ignore, + stats_only, + consolidate, + ); dump_col( &mut data, system_configurations, diff --git a/src/catalog/protos/hashes.json b/src/catalog/protos/hashes.json index a178537763242..6f05d06a3b12f 100644 --- a/src/catalog/protos/hashes.json +++ b/src/catalog/protos/hashes.json @@ -1,7 +1,7 @@ [ { "name": "objects.proto", - "md5": "e3f60c6fc3338952772fdb5f1778afee" + "md5": "5fb24f4ff7e8c4d96910a52cfb6cce4c" }, { "name": "objects_v60.proto", @@ -14,5 +14,9 @@ { "name": "objects_v62.proto", "md5": "287d592a5e3f2e4d0f06663880a10031" + }, + { + "name": "objects_v63.proto", + "md5": "5539fa20fcf47ac0e9ca9053427ebdde" } ] diff --git a/src/catalog/protos/objects.proto b/src/catalog/protos/objects.proto index f0a8206bfcce6..8095196666462 100644 --- a/src/catalog/protos/objects.proto +++ b/src/catalog/protos/objects.proto @@ -178,6 +178,21 @@ message CommentValue { string comment = 1; } +message SourceReferencesKey { + GlobalId source = 1; +} + +message SourceReferencesValue { + repeated SourceReference references = 1; + EpochMillis updated_at = 2; +} + +message SourceReference { + string name = 1; + optional string namespace = 2; + repeated string columns = 3; +} + message StorageCollectionMetadataKey { GlobalId id = 1; } @@ -838,6 +853,11 @@ message StateUpdateKind { ServerConfigurationValue value = 2; } + message SourceReferences { + SourceReferencesKey key = 1; + SourceReferencesValue value = 2; + } + message GidMapping { GidMappingKey key = 1; GidMappingValue value = 2; @@ -889,5 +909,6 @@ message StateUpdateKind { StorageCollectionMetadata storage_collection_metadata = 20; UnfinalizedShard unfinalized_shard = 21; TxnWalShard txn_wal_shard = 23; + SourceReferences source_references = 24; } } diff --git a/src/catalog/protos/objects_v63.proto b/src/catalog/protos/objects_v63.proto new file mode 100644 index 0000000000000..6c0ae6d92cc03 --- /dev/null +++ b/src/catalog/protos/objects_v63.proto @@ -0,0 +1,914 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +// This protobuf file defines the types we store in the Stash. +// +// Before and after modifying this file, make sure you have a snapshot of the before version, +// e.g. a copy of this file named 'objects_v{CATALOG_VERSION}.proto', and a snapshot of the file +// after your modifications, e.g. 'objects_v{CATALOG_VERSION + 1}.proto'. Then you can write a +// migration using these two files, and no matter how the types change in the future, we'll always +// have these snapshots to facilitate the migration. + +// buf breaking: ignore (does currently not require backward-compatibility) + +syntax = "proto3"; + +package objects_v63; + +message ConfigKey { + string key = 1; +} + +message ConfigValue { + uint64 value = 1; +} + +message SettingKey { + string name = 1; +} + +message SettingValue { + string value = 1; +} + +message IdAllocKey { + string name = 1; +} + +message IdAllocValue { + uint64 next_id = 1; +} + +message GidMappingKey { + string schema_name = 1; + CatalogItemType object_type = 2; + string object_name = 3; +} + +message GidMappingValue { + uint64 id = 1; + string fingerprint = 2; +} + +message ClusterKey { + ClusterId id = 1; +} + +message ClusterValue { + reserved 2; + string name = 1; + RoleId owner_id = 3; + repeated MzAclItem privileges = 4; + ClusterConfig config = 5; +} + +message ClusterIntrospectionSourceIndexKey { + ClusterId cluster_id = 1; + string name = 2; +} + +message ClusterIntrospectionSourceIndexValue { + uint64 index_id = 1; + uint32 oid = 2; +} + +message ClusterReplicaKey { + ReplicaId id = 1; +} + +message ClusterReplicaValue { + ClusterId cluster_id = 1; + string name = 2; + ReplicaConfig config = 3; + RoleId owner_id = 4; +} + +message DatabaseKey { + DatabaseId id = 1; +} + +message DatabaseValue { + string name = 1; + RoleId owner_id = 2; + repeated MzAclItem privileges = 3; + uint32 oid = 4; +} + +message SchemaKey { + SchemaId id = 1; +} + +message SchemaValue { + DatabaseId database_id = 1; + string name = 2; + RoleId owner_id = 3; + repeated MzAclItem privileges = 4; + uint32 oid = 5; +} + +message ItemKey { + GlobalId gid = 1; +} + +message ItemValue { + SchemaId schema_id = 1; + string name = 2; + CatalogItem definition = 3; + RoleId owner_id = 4; + repeated MzAclItem privileges = 5; + uint32 oid = 6; +} + +message RoleKey { + RoleId id = 1; +} + +message RoleValue { + string name = 1; + RoleAttributes attributes = 2; + RoleMembership membership = 3; + RoleVars vars = 4; + uint32 oid = 5; +} + +message ServerConfigurationKey { + string name = 1; +} + +message ServerConfigurationValue { + string value = 1; +} + +message AuditLogKey { + oneof event { + AuditLogEventV1 v1 = 1; + } +} + +message CommentKey { + oneof object { + GlobalId table = 1; + GlobalId view = 2; + GlobalId materialized_view = 4; + GlobalId source = 5; + GlobalId sink = 6; + GlobalId index = 7; + GlobalId func = 8; + GlobalId connection = 9; + GlobalId type = 10; + GlobalId secret = 11; + RoleId role = 12; + DatabaseId database = 13; + ResolvedSchema schema = 14; + ClusterId cluster = 15; + ClusterReplicaId cluster_replica = 16; + } + oneof sub_component { + uint64 column_pos = 3; + } +} + +message CommentValue { + string comment = 1; +} + +message SourceReferencesKey { + GlobalId source = 1; +} + +message SourceReferencesValue { + repeated SourceReference references = 1; + EpochMillis updated_at = 2; +} + +message SourceReference { + string name = 1; + optional string namespace = 2; + repeated string columns = 3; +} + +message StorageCollectionMetadataKey { + GlobalId id = 1; +} + +// This value is stored transparently, however, it should only ever be +// manipulated by the storage controller. +message StorageCollectionMetadataValue { + string shard = 1; +} + +// This value is stored transparently, however, it should only ever be +// manipulated by the storage controller. +message UnfinalizedShardKey { + string shard = 1; +} + +// This value is stored transparently, however, it should only ever be +// manipulated by the storage controller. +message TxnWalShardValue { + string shard = 1; +} + +// ---- Common Types +// +// Note: Normally types like this would go in some sort of `common.proto` file, but we want to keep +// our proto definitions in a single file to make snapshotting easier, hence them living here. + +message Empty {/* purposefully empty */} + +// In protobuf a "None" string is the same thing as an empty string. To get the same semantics of +// an `Option` from Rust, we need to wrap a string in a message. +message StringWrapper { + string inner = 1; +} + +message Duration { + uint64 secs = 1; + uint32 nanos = 2; +} + +message EpochMillis { + uint64 millis = 1; +} + +// Opaque timestamp type that is specific to Materialize. +message Timestamp { + uint64 internal = 1; +} + +enum CatalogItemType { + CATALOG_ITEM_TYPE_UNKNOWN = 0; + CATALOG_ITEM_TYPE_TABLE = 1; + CATALOG_ITEM_TYPE_SOURCE = 2; + CATALOG_ITEM_TYPE_SINK = 3; + CATALOG_ITEM_TYPE_VIEW = 4; + CATALOG_ITEM_TYPE_MATERIALIZED_VIEW = 5; + CATALOG_ITEM_TYPE_INDEX = 6; + CATALOG_ITEM_TYPE_TYPE = 7; + CATALOG_ITEM_TYPE_FUNC = 8; + CATALOG_ITEM_TYPE_SECRET = 9; + CATALOG_ITEM_TYPE_CONNECTION = 10; +} + +message CatalogItem { + message V1 { + string create_sql = 1; + } + + oneof value { + V1 v1 = 1; + } +} + +message GlobalId { + oneof value { + uint64 system = 1; + uint64 user = 2; + uint64 transient = 3; + Empty explain = 4; + } +} + +message ClusterId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message DatabaseId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message ResolvedDatabaseSpecifier { + oneof spec { + Empty ambient = 1; + DatabaseId id = 2; + } +} + +message SchemaId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message SchemaSpecifier { + oneof spec { + Empty temporary = 1; + SchemaId id = 2; + } +} + +message ResolvedSchema { + ResolvedDatabaseSpecifier database = 1; + SchemaSpecifier schema = 2; +} + +message ReplicaId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message ClusterReplicaId { + ClusterId cluster_id = 1; + ReplicaId replica_id = 2; +} + +message ReplicaLogging { + bool log_logging = 1; + Duration interval = 2; +} + +message OptimizerFeatureOverride { + string name = 1; + string value = 2; +} + +message ClusterScheduleRefreshOptions { + Duration rehydration_time_estimate = 1; +} + +message ClusterSchedule { + oneof value { + Empty manual = 1; + ClusterScheduleRefreshOptions refresh = 2; + } +} + +message ClusterConfig { + message ManagedCluster { + string size = 1; + uint32 replication_factor = 2; + repeated string availability_zones = 3; + ReplicaLogging logging = 4; + bool disk = 6; + repeated OptimizerFeatureOverride optimizer_feature_overrides = 7; + ClusterSchedule schedule = 8; + } + + oneof variant { + Empty unmanaged = 1; + ManagedCluster managed = 2; + } + optional string workload_class = 3; +} + +message ReplicaConfig { + message UnmanagedLocation { + repeated string storagectl_addrs = 1; + repeated string storage_addrs = 2; + repeated string computectl_addrs = 3; + repeated string compute_addrs = 4; + uint64 workers = 5; + } + + message ManagedLocation { + string size = 1; + optional string availability_zone = 2; + bool disk = 4; + bool internal = 5; + optional string billed_as = 6; + bool pending = 7; + } + + oneof location { + UnmanagedLocation unmanaged = 1; + ManagedLocation managed = 2; + } + ReplicaLogging logging = 3; +} + +message RoleId { + oneof value { + uint64 system = 1; + uint64 user = 2; + Empty public = 3; + uint64 predefined = 4; + } +} + +message RoleAttributes { + bool inherit = 1; +} + +message RoleMembership { + message Entry { + RoleId key = 1; + RoleId value = 2; + } + + repeated Entry map = 1; +} + +message RoleVars { + message SqlSet { + repeated string entries = 1; + } + + message Entry { + string key = 1; + oneof val { + string flat = 2; + SqlSet sql_set = 3; + } + } + + repeated Entry entries = 1; +} + +message AclMode { + // A bit flag representing all the privileges that can be granted to a role. + uint64 bitflags = 1; +} + +message MzAclItem { + RoleId grantee = 1; + RoleId grantor = 2; + AclMode acl_mode = 3; +} + +enum ObjectType { + OBJECT_TYPE_UNKNOWN = 0; + OBJECT_TYPE_TABLE = 1; + OBJECT_TYPE_VIEW = 2; + OBJECT_TYPE_MATERIALIZED_VIEW = 3; + OBJECT_TYPE_SOURCE = 4; + OBJECT_TYPE_SINK = 5; + OBJECT_TYPE_INDEX = 6; + OBJECT_TYPE_TYPE = 7; + OBJECT_TYPE_ROLE = 8; + OBJECT_TYPE_CLUSTER = 9; + OBJECT_TYPE_CLUSTER_REPLICA = 10; + OBJECT_TYPE_SECRET = 11; + OBJECT_TYPE_CONNECTION = 12; + OBJECT_TYPE_DATABASE = 13; + OBJECT_TYPE_SCHEMA = 14; + OBJECT_TYPE_FUNC = 15; +} + +message DefaultPrivilegesKey { + RoleId role_id = 1; + DatabaseId database_id = 2; + SchemaId schema_id = 3; + ObjectType object_type = 4; + RoleId grantee = 5; +} + +message DefaultPrivilegesValue { + AclMode privileges = 1; +} + +message SystemPrivilegesKey { + RoleId grantee = 1; + RoleId grantor = 2; +} + +message SystemPrivilegesValue { + AclMode acl_mode = 1; +} + +message AuditLogEventV1 { + enum EventType { + EVENT_TYPE_UNKNOWN = 0; + EVENT_TYPE_CREATE = 1; + EVENT_TYPE_DROP = 2; + EVENT_TYPE_ALTER = 3; + EVENT_TYPE_GRANT = 4; + EVENT_TYPE_REVOKE = 5; + EVENT_TYPE_COMMENT = 6; + } + + enum ObjectType { + OBJECT_TYPE_UNKNOWN = 0; + OBJECT_TYPE_CLUSTER = 1; + OBJECT_TYPE_CLUSTER_REPLICA = 2; + OBJECT_TYPE_CONNECTION = 3; + OBJECT_TYPE_DATABASE = 4; + OBJECT_TYPE_FUNC = 5; + OBJECT_TYPE_INDEX = 6; + OBJECT_TYPE_MATERIALIZED_VIEW = 7; + OBJECT_TYPE_ROLE = 8; + OBJECT_TYPE_SECRET = 9; + OBJECT_TYPE_SCHEMA = 10; + OBJECT_TYPE_SINK = 11; + OBJECT_TYPE_SOURCE = 12; + OBJECT_TYPE_TABLE = 13; + OBJECT_TYPE_TYPE = 14; + OBJECT_TYPE_VIEW = 15; + OBJECT_TYPE_SYSTEM = 16; + } + + message IdFullNameV1 { + string id = 1; + FullNameV1 name = 2; + } + + message FullNameV1 { + string database = 1; + string schema = 2; + string item = 3; + } + + message IdNameV1 { + string id = 1; + string name = 2; + } + + message RenameClusterV1 { + string id = 1; + string old_name = 2; + string new_name = 3; + } + + message RenameClusterReplicaV1 { + string cluster_id = 1; + string replica_id = 2; + string old_name = 3; + string new_name = 4; + } + + message RenameItemV1 { + string id = 1; + FullNameV1 old_name = 2; + FullNameV1 new_name = 3; + } + + message CreateClusterReplicaV1 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + string logical_size = 5; + bool disk = 6; + optional string billed_as = 7; + bool internal = 8; + } + + message CreateClusterReplicaV2 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + string logical_size = 5; + bool disk = 6; + optional string billed_as = 7; + bool internal = 8; + CreateOrDropClusterReplicaReasonV1 reason = 9; + SchedulingDecisionsWithReasonsV1 scheduling_policies = 10; + } + + message DropClusterReplicaV1 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + } + + message DropClusterReplicaV2 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + CreateOrDropClusterReplicaReasonV1 reason = 5; + SchedulingDecisionsWithReasonsV1 scheduling_policies = 6; + } + + message CreateOrDropClusterReplicaReasonV1 { + oneof reason { + Empty Manual = 1; + Empty Schedule = 2; + Empty System = 3; + } + } + + message SchedulingDecisionsWithReasonsV1 { + RefreshDecisionWithReasonV1 on_refresh = 1; + } + + message RefreshDecisionWithReasonV1 { + oneof decision { + Empty On = 1; + Empty Off = 2; + } + repeated string objects_needing_refresh = 3; + string rehydration_time_estimate = 4; + } + + message CreateSourceSinkV1 { + string id = 1; + FullNameV1 name = 2; + StringWrapper size = 3; + } + + message CreateSourceSinkV2 { + string id = 1; + FullNameV1 name = 2; + StringWrapper size = 3; + string external_type = 4; + } + + message CreateSourceSinkV3 { + string id = 1; + FullNameV1 name = 2; + string external_type = 3; + } + + message AlterSourceSinkV1 { + string id = 1; + FullNameV1 name = 2; + StringWrapper old_size = 3; + StringWrapper new_size = 4; + } + + message AlterSetClusterV1 { + string id = 1; + FullNameV1 name = 2; + StringWrapper old_cluster = 3; + StringWrapper new_cluster = 4; + } + + message GrantRoleV1 { + string role_id = 1; + string member_id = 2; + string grantor_id = 3; + } + + message GrantRoleV2 { + string role_id = 1; + string member_id = 2; + string grantor_id = 3; + string executed_by = 4; + } + + message RevokeRoleV1 { + string role_id = 1; + string member_id = 2; + } + + message RevokeRoleV2 { + string role_id = 1; + string member_id = 2; + string grantor_id = 3; + string executed_by = 4; + } + + message UpdatePrivilegeV1 { + string object_id = 1; + string grantee_id = 2; + string grantor_id = 3; + string privileges = 4; + } + + message AlterDefaultPrivilegeV1 { + string role_id = 1; + StringWrapper database_id = 2; + StringWrapper schema_id = 3; + string grantee_id = 4; + string privileges = 5; + } + + message UpdateOwnerV1 { + string object_id = 1; + string old_owner_id = 2; + string new_owner_id = 3; + } + + message SchemaV1 { + string id = 1; + string name = 2; + string database_name = 3; + } + + message SchemaV2 { + string id = 1; + string name = 2; + StringWrapper database_name = 3; + } + + message RenameSchemaV1 { + string id = 1; + optional string database_name = 2; + string old_name = 3; + string new_name = 4; + } + + message UpdateItemV1 { + string id = 1; + FullNameV1 name = 2; + } + + message AlterRetainHistoryV1 { + string id = 1; + optional string old_history = 2; + optional string new_history = 3; + } + + message ToNewIdV1 { + string id = 1; + string new_id = 2; + } + + message FromPreviousIdV1 { + string id = 1; + string previous_id = 2; + } + + message SetV1 { + string name = 1; + optional string value = 2; + } + + message RotateKeysV1 { + string id = 1; + string name = 2; + } + + uint64 id = 1; + EventType event_type = 2; + ObjectType object_type = 3; + StringWrapper user = 4; + EpochMillis occurred_at = 5; + + // next-id: 33 + oneof details { + CreateClusterReplicaV1 create_cluster_replica_v1 = 6; + CreateClusterReplicaV2 create_cluster_replica_v2 = 33; + DropClusterReplicaV1 drop_cluster_replica_v1 = 7; + DropClusterReplicaV2 drop_cluster_replica_v2 = 34; + CreateSourceSinkV1 create_source_sink_v1 = 8; + CreateSourceSinkV2 create_source_sink_v2 = 9; + AlterSourceSinkV1 alter_source_sink_v1 = 10; + AlterSetClusterV1 alter_set_cluster_v1 = 25; + GrantRoleV1 grant_role_v1 = 11; + GrantRoleV2 grant_role_v2 = 12; + RevokeRoleV1 revoke_role_v1 = 13; + RevokeRoleV2 revoke_role_v2 = 14; + UpdatePrivilegeV1 update_privilege_v1 = 22; + AlterDefaultPrivilegeV1 alter_default_privilege_v1 = 23; + UpdateOwnerV1 update_owner_v1 = 24; + IdFullNameV1 id_full_name_v1 = 15; + RenameClusterV1 rename_cluster_v1 = 20; + RenameClusterReplicaV1 rename_cluster_replica_v1 = 21; + RenameItemV1 rename_item_v1 = 16; + IdNameV1 id_name_v1 = 17; + SchemaV1 schema_v1 = 18; + SchemaV2 schema_v2 = 19; + RenameSchemaV1 rename_schema_v1 = 27; + UpdateItemV1 update_item_v1 = 26; + CreateSourceSinkV3 create_source_sink_v3 = 29; + AlterRetainHistoryV1 alter_retain_history_v1 = 30; + ToNewIdV1 to_new_id_v1 = 31; + FromPreviousIdV1 from_previous_id_v1 = 32; + SetV1 set_v1 = 35; + Empty reset_all_v1 = 36; + RotateKeysV1 rotate_keys_v1 = 37; + } +} + +// Wrapper of key-values used by the persist implementation to serialize the catalog. +message StateUpdateKind { + message AuditLog { + AuditLogKey key = 1; + } + + message Cluster { + ClusterKey key = 1; + ClusterValue value = 2; + } + + message ClusterReplica { + ClusterReplicaKey key = 1; + ClusterReplicaValue value = 2; + } + + message Comment { + CommentKey key = 1; + CommentValue value = 2; + } + + message Config { + ConfigKey key = 1; + ConfigValue value = 2; + } + + message Database { + DatabaseKey key = 1; + DatabaseValue value = 2; + } + + message DefaultPrivileges { + DefaultPrivilegesKey key = 1; + DefaultPrivilegesValue value = 2; + } + + message Epoch { + int64 epoch = 1; + } + + message IdAlloc { + IdAllocKey key = 1; + IdAllocValue value = 2; + } + + message ClusterIntrospectionSourceIndex { + ClusterIntrospectionSourceIndexKey key = 1; + ClusterIntrospectionSourceIndexValue value = 2; + } + + message Item { + ItemKey key = 1; + ItemValue value = 2; + } + + message Role { + RoleKey key = 1; + RoleValue value = 2; + } + + message Schema { + SchemaKey key = 1; + SchemaValue value = 2; + } + + message Setting { + SettingKey key = 1; + SettingValue value = 2; + } + + message ServerConfiguration { + ServerConfigurationKey key = 1; + ServerConfigurationValue value = 2; + } + + message SourceReferences { + SourceReferencesKey key = 1; + SourceReferencesValue value = 2; + } + + message GidMapping { + GidMappingKey key = 1; + GidMappingValue value = 2; + } + + message SystemPrivileges { + SystemPrivilegesKey key = 1; + SystemPrivilegesValue value = 2; + } + + message StorageCollectionMetadata { + StorageCollectionMetadataKey key = 1; + StorageCollectionMetadataValue value = 2; + } + + message UnfinalizedShard { + UnfinalizedShardKey key = 1; + } + + message TxnWalShard { + TxnWalShardValue value = 1; + } + + reserved 15; + reserved "storage_usage"; + reserved 19; + reserved "timestamp"; + reserved 22; + reserved "persist_txn_shard"; + + oneof kind { + AuditLog audit_log = 1; + Cluster cluster = 2; + ClusterReplica cluster_replica = 3; + Comment comment = 4; + Config config = 5; + Database database = 6; + DefaultPrivileges default_privileges = 7; + Epoch epoch = 8; + IdAlloc id_alloc = 9; + ClusterIntrospectionSourceIndex cluster_introspection_source_index = 10; + Item item = 11; + Role role = 12; + Schema schema = 13; + Setting setting = 14; + ServerConfiguration server_configuration = 16; + GidMapping gid_mapping = 17; + SystemPrivileges system_privileges = 18; + StorageCollectionMetadata storage_collection_metadata = 20; + UnfinalizedShard unfinalized_shard = 21; + TxnWalShard txn_wal_shard = 23; + SourceReferences source_references = 24; + } +} diff --git a/src/catalog/src/builtin.rs b/src/catalog/src/builtin.rs index 2bd7d9799144d..9a625c0f151de 100644 --- a/src/catalog/src/builtin.rs +++ b/src/catalog/src/builtin.rs @@ -3314,6 +3314,30 @@ pub static MZ_COMMENTS: LazyLock = LazyLock::new(|| BuiltinTable { access: vec![PUBLIC_SELECT], }); +pub static MZ_SOURCE_REFERENCES: LazyLock = LazyLock::new(|| BuiltinTable { + name: "mz_source_references", + schema: MZ_INTERNAL_SCHEMA, + oid: oid::TABLE_MZ_SOURCE_REFERENCES_OID, + desc: RelationDesc::empty() + .with_column("source_id", ScalarType::String.nullable(false)) + .with_column("namespace", ScalarType::String.nullable(true)) + .with_column("name", ScalarType::String.nullable(false)) + .with_column( + "updated_at", + ScalarType::TimestampTz { precision: None }.nullable(false), + ) + .with_column( + "columns", + ScalarType::List { + element_type: Box::new(ScalarType::String), + custom_id: None, + } + .nullable(true), + ), + is_retained_metrics_object: false, + access: vec![PUBLIC_SELECT], +}); + pub static MZ_WEBHOOKS_SOURCES: LazyLock = LazyLock::new(|| BuiltinTable { name: "mz_webhook_sources", schema: MZ_INTERNAL_SCHEMA, @@ -7928,6 +7952,7 @@ pub static BUILTINS_STATIC: LazyLock>> = LazyLock::ne Builtin::Table(&MZ_INDEX_COLUMNS), Builtin::Table(&MZ_TABLES), Builtin::Table(&MZ_SOURCES), + Builtin::Table(&MZ_SOURCE_REFERENCES), Builtin::Table(&MZ_POSTGRES_SOURCES), Builtin::Table(&MZ_POSTGRES_SOURCE_TABLES), Builtin::Table(&MZ_MYSQL_SOURCE_TABLES), diff --git a/src/catalog/src/durable.rs b/src/catalog/src/durable.rs index 3eda7a4976846..32150a75ccac6 100644 --- a/src/catalog/src/durable.rs +++ b/src/catalog/src/durable.rs @@ -33,8 +33,8 @@ use crate::durable::objects::Snapshot; pub use crate::durable::objects::{ Cluster, ClusterConfig, ClusterReplica, ClusterVariant, ClusterVariantManaged, Comment, Database, DefaultPrivilege, IntrospectionSourceIndex, Item, ReplicaConfig, ReplicaLocation, - Role, Schema, StorageCollectionMetadata, SystemConfiguration, SystemObjectDescription, - SystemObjectMapping, UnfinalizedShard, + Role, Schema, SourceReferences, StorageCollectionMetadata, SystemConfiguration, + SystemObjectDescription, SystemObjectMapping, UnfinalizedShard, }; pub use crate::durable::persist::builtin_migration_shard_id; use crate::durable::persist::{Timestamp, UnopenedPersistCatalogState}; diff --git a/src/catalog/src/durable/debug.rs b/src/catalog/src/durable/debug.rs index 2d01d760494b6..ac71496c9b11c 100644 --- a/src/catalog/src/durable/debug.rs +++ b/src/catalog/src/durable/debug.rs @@ -66,6 +66,7 @@ pub enum CollectionType { Role, Schema, Setting, + SourceReferences, SystemConfiguration, SystemGidMapping, SystemPrivileges, @@ -221,6 +222,14 @@ collection_impl!({ trace_field: settings, update: StateUpdateKind::Setting, }); +collection_impl!({ + name: SourceReferencesCollection, + key: proto::SourceReferencesKey, + value: proto::SourceReferencesValue, + collection_type: CollectionType::SourceReferences, + trace_field: source_references, + update: StateUpdateKind::SourceReferences, +}); collection_impl!({ name: SystemConfigurationCollection, key: proto::ServerConfigurationKey, @@ -302,6 +311,7 @@ pub struct Trace { pub roles: CollectionTrace, pub schemas: CollectionTrace, pub settings: CollectionTrace, + pub source_references: CollectionTrace, pub system_object_mappings: CollectionTrace, pub system_configurations: CollectionTrace, pub system_privileges: CollectionTrace, @@ -326,6 +336,7 @@ impl Trace { roles: CollectionTrace::new(), schemas: CollectionTrace::new(), settings: CollectionTrace::new(), + source_references: CollectionTrace::new(), system_object_mappings: CollectionTrace::new(), system_configurations: CollectionTrace::new(), system_privileges: CollectionTrace::new(), diff --git a/src/catalog/src/durable/objects.rs b/src/catalog/src/durable/objects.rs index 7210468d14f82..cecabbb931c0c 100644 --- a/src/catalog/src/durable/objects.rs +++ b/src/catalog/src/durable/objects.rs @@ -499,6 +499,51 @@ impl DurableType for Item { } } +#[derive(Debug, Clone, Ord, PartialOrd, PartialEq, Eq)] +pub struct SourceReferences { + pub source_id: GlobalId, + pub updated_at: u64, + pub references: Vec, +} + +#[derive(Debug, Clone, Ord, PartialOrd, PartialEq, Eq, Arbitrary)] +pub struct SourceReference { + pub name: String, + pub namespace: Option, + pub columns: Vec, +} + +impl DurableType for SourceReferences { + type Key = SourceReferencesKey; + type Value = SourceReferencesValue; + + fn into_key_value(self) -> (Self::Key, Self::Value) { + ( + SourceReferencesKey { + source_id: self.source_id, + }, + SourceReferencesValue { + updated_at: self.updated_at, + references: self.references, + }, + ) + } + + fn from_key_value(key: Self::Key, value: Self::Value) -> Self { + Self { + source_id: key.source_id, + updated_at: value.updated_at, + references: value.references, + } + } + + fn key(&self) -> Self::Key { + SourceReferencesKey { + source_id: self.source_id, + } + } +} + #[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)] pub struct SystemObjectDescription { pub schema_name: String, @@ -925,6 +970,7 @@ pub struct Snapshot { pub system_configurations: BTreeMap, pub default_privileges: BTreeMap, + pub source_references: BTreeMap, pub system_privileges: BTreeMap, pub storage_collection_metadata: BTreeMap, @@ -1022,6 +1068,17 @@ pub struct DatabaseValue { pub(crate) oid: u32, } +#[derive(Clone, Copy, Debug, PartialOrd, PartialEq, Eq, Ord, Hash, Arbitrary)] +pub struct SourceReferencesKey { + pub(crate) source_id: GlobalId, +} + +#[derive(Clone, Debug, PartialOrd, PartialEq, Eq, Ord, Arbitrary)] +pub struct SourceReferencesValue { + pub(crate) references: Vec, + pub(crate) updated_at: u64, +} + #[derive(Clone, Copy, Debug, PartialOrd, PartialEq, Eq, Ord, Hash, Arbitrary)] pub struct SchemaKey { pub(crate) id: SchemaId, diff --git a/src/catalog/src/durable/objects/serialization.rs b/src/catalog/src/durable/objects/serialization.rs index b019178e408a7..cf839adc47a6d 100644 --- a/src/catalog/src/durable/objects/serialization.rs +++ b/src/catalog/src/durable/objects/serialization.rs @@ -45,9 +45,9 @@ use crate::durable::objects::{ ConfigKey, ConfigValue, DatabaseKey, DatabaseValue, DefaultPrivilegesKey, DefaultPrivilegesValue, GidMappingKey, GidMappingValue, IdAllocKey, IdAllocValue, ItemKey, ItemValue, RoleKey, RoleValue, SchemaKey, SchemaValue, ServerConfigurationKey, - ServerConfigurationValue, SettingKey, SettingValue, StorageCollectionMetadataKey, - StorageCollectionMetadataValue, SystemPrivilegesKey, SystemPrivilegesValue, TxnWalShardValue, - UnfinalizedShardKey, + ServerConfigurationValue, SettingKey, SettingValue, SourceReference, SourceReferencesKey, + SourceReferencesValue, StorageCollectionMetadataKey, StorageCollectionMetadataValue, + SystemPrivilegesKey, SystemPrivilegesValue, TxnWalShardValue, UnfinalizedShardKey, }; use crate::durable::{ ClusterConfig, ClusterVariant, ClusterVariantManaged, ReplicaConfig, ReplicaLocation, @@ -775,6 +775,65 @@ impl RustType for ServerConfigurationValue { } } +impl RustType for SourceReferencesKey { + fn into_proto(&self) -> proto::SourceReferencesKey { + proto::SourceReferencesKey { + source: Some(self.source_id.into_proto()), + } + } + fn from_proto(proto: proto::SourceReferencesKey) -> Result { + Ok(SourceReferencesKey { + source_id: proto + .source + .into_rust_if_some("SourceReferencesKey::source_id")?, + }) + } +} + +impl RustType for SourceReferencesValue { + fn into_proto(&self) -> proto::SourceReferencesValue { + proto::SourceReferencesValue { + updated_at: Some(proto::EpochMillis { + millis: self.updated_at, + }), + references: self + .references + .iter() + .map(|reference| reference.into_proto()) + .collect(), + } + } + fn from_proto(proto: proto::SourceReferencesValue) -> Result { + Ok(SourceReferencesValue { + updated_at: proto + .updated_at + .into_rust_if_some("SourceReferencesValue::updated_at")?, + references: proto + .references + .into_iter() + .map(|reference| reference.into_rust()) + .collect::>()?, + }) + } +} + +impl RustType for SourceReference { + fn into_proto(&self) -> proto::SourceReference { + proto::SourceReference { + name: self.name.clone(), + namespace: self.namespace.clone(), + columns: self.columns.clone(), + } + } + fn from_proto(proto: proto::SourceReference) -> Result { + Ok(SourceReference { + name: proto.name, + namespace: proto.namespace, + columns: proto.columns, + }) + } +} + impl RustType for DefaultPrivilegesKey { fn into_proto(&self) -> proto::DefaultPrivilegesKey { proto::DefaultPrivilegesKey { diff --git a/src/catalog/src/durable/objects/state_update.rs b/src/catalog/src/durable/objects/state_update.rs index 5ec75d0f9a06e..9ed20e34e7da3 100644 --- a/src/catalog/src/durable/objects/state_update.rs +++ b/src/catalog/src/durable/objects/state_update.rs @@ -222,6 +222,7 @@ pub enum StateUpdateKind { Role(proto::RoleKey, proto::RoleValue), Schema(proto::SchemaKey, proto::SchemaValue), Setting(proto::SettingKey, proto::SettingValue), + SourceReferences(proto::SourceReferencesKey, proto::SourceReferencesValue), SystemConfiguration( proto::ServerConfigurationKey, proto::ServerConfigurationValue, @@ -255,6 +256,7 @@ impl StateUpdateKind { StateUpdateKind::Role(_, _) => Some(CollectionType::Role), StateUpdateKind::Schema(_, _) => Some(CollectionType::Schema), StateUpdateKind::Setting(_, _) => Some(CollectionType::Setting), + StateUpdateKind::SourceReferences(_, _) => Some(CollectionType::SourceReferences), StateUpdateKind::SystemConfiguration(_, _) => Some(CollectionType::SystemConfiguration), StateUpdateKind::SystemObjectMapping(_, _) => Some(CollectionType::SystemGidMapping), StateUpdateKind::SystemPrivilege(_, _) => Some(CollectionType::SystemPrivileges), @@ -376,6 +378,12 @@ impl TryFrom<&StateUpdateKind> for Option { let schema = into_durable(key, value)?; Some(memory::objects::StateUpdateKind::Schema(schema)) } + StateUpdateKind::SourceReferences(key, value) => { + let source_references = into_durable(key, value)?; + Some(memory::objects::StateUpdateKind::SourceReferences( + source_references, + )) + } StateUpdateKind::StorageCollectionMetadata(key, value) => { let storage_collection_metadata = into_durable(key, value)?; Some(memory::objects::StateUpdateKind::StorageCollectionMetadata( @@ -547,6 +555,14 @@ impl RustType for StateUpdateKind { value: Some(value), }) } + StateUpdateKind::SourceReferences(key, value) => { + proto::state_update_kind::Kind::SourceReferences( + proto::state_update_kind::SourceReferences { + key: Some(key), + value: Some(value), + }, + ) + } StateUpdateKind::SystemConfiguration(key, value) => { proto::state_update_kind::Kind::ServerConfiguration( proto::state_update_kind::ServerConfiguration { @@ -817,6 +833,18 @@ impl RustType for StateUpdateKind { TryFromProtoError::missing_field("state_update_kind::TxnWalShard::value") })?, ), + proto::state_update_kind::Kind::SourceReferences( + proto::state_update_kind::SourceReferences { key, value }, + ) => StateUpdateKind::SourceReferences( + key.ok_or_else(|| { + TryFromProtoError::missing_field("state_update_kind::SourceReferences::key") + })?, + value.ok_or_else(|| { + TryFromProtoError::missing_field( + "state_update_kind::SourceReferences::value", + ) + })?, + ), }, ) } diff --git a/src/catalog/src/durable/persist.rs b/src/catalog/src/durable/persist.rs index f2502b4c94528..2854ea1d7018a 100644 --- a/src/catalog/src/durable/persist.rs +++ b/src/catalog/src/durable/persist.rs @@ -625,6 +625,9 @@ impl> PersistHandle { StateUpdateKind::Setting(key, value) => { apply(&mut snapshot.settings, key, value, diff); } + StateUpdateKind::SourceReferences(key, value) => { + apply(&mut snapshot.source_references, key, value, diff); + } StateUpdateKind::SystemConfiguration(key, value) => { apply(&mut snapshot.system_configurations, key, value, diff); } @@ -1618,6 +1621,9 @@ impl Trace { StateUpdateKind::Role(k, v) => trace.roles.values.push(((k, v), ts, diff)), StateUpdateKind::Schema(k, v) => trace.schemas.values.push(((k, v), ts, diff)), StateUpdateKind::Setting(k, v) => trace.settings.values.push(((k, v), ts, diff)), + StateUpdateKind::SourceReferences(k, v) => { + trace.source_references.values.push(((k, v), ts, diff)) + } StateUpdateKind::SystemConfiguration(k, v) => { trace.system_configurations.values.push(((k, v), ts, diff)) } diff --git a/src/catalog/src/durable/transaction.rs b/src/catalog/src/durable/transaction.rs index 40b581386a9cf..d11ab53b7cd1f 100644 --- a/src/catalog/src/durable/transaction.rs +++ b/src/catalog/src/durable/transaction.rs @@ -48,9 +48,9 @@ use crate::durable::objects::{ DurableType, GidMappingKey, GidMappingValue, IdAllocKey, IdAllocValue, IntrospectionSourceIndex, Item, ItemKey, ItemValue, ReplicaConfig, Role, RoleKey, RoleValue, Schema, SchemaKey, SchemaValue, ServerConfigurationKey, ServerConfigurationValue, SettingKey, - SettingValue, StorageCollectionMetadataKey, StorageCollectionMetadataValue, - SystemObjectDescription, SystemObjectMapping, SystemPrivilegesKey, SystemPrivilegesValue, - TxnWalShardValue, UnfinalizedShardKey, + SettingValue, SourceReferencesKey, SourceReferencesValue, StorageCollectionMetadataKey, + StorageCollectionMetadataValue, SystemObjectDescription, SystemObjectMapping, + SystemPrivilegesKey, SystemPrivilegesValue, TxnWalShardValue, UnfinalizedShardKey, }; use crate::durable::{ CatalogError, DefaultPrivilege, DurableCatalogError, DurableCatalogState, Snapshot, @@ -85,6 +85,7 @@ pub struct Transaction<'a> { system_gid_mapping: TableTransaction, system_configurations: TableTransaction, default_privileges: TableTransaction, + source_references: TableTransaction, system_privileges: TableTransaction, storage_collection_metadata: TableTransaction, @@ -114,6 +115,7 @@ impl<'a> Transaction<'a> { id_allocator, configs, settings, + source_references, system_object_mappings, system_configurations, default_privileges, @@ -150,6 +152,7 @@ impl<'a> Transaction<'a> { id_allocator: TableTransaction::new(id_allocator, |_a, _b| false)?, configs: TableTransaction::new(configs, |_a, _b| false)?, settings: TableTransaction::new(settings, |_a, _b| false)?, + source_references: TableTransaction::new(source_references, |_a, _b| false)?, system_gid_mapping: TableTransaction::new(system_object_mappings, |_a, _b| false)?, system_configurations: TableTransaction::new(system_configurations, |_a, _b| false)?, default_privileges: TableTransaction::new(default_privileges, |_a, _b| false)?, @@ -1830,6 +1833,7 @@ impl<'a> Transaction<'a> { system_gid_mapping, system_configurations, default_privileges, + source_references, system_privileges, audit_log_updates, storage_collection_metadata, @@ -1904,6 +1908,11 @@ impl<'a> Transaction<'a> { StateUpdateKind::Comment, self.op_id, )) + .chain(get_collection_op_updates( + source_references, + StateUpdateKind::SourceReferences, + self.op_id, + )) .chain(get_collection_op_updates( storage_collection_metadata, StateUpdateKind::StorageCollectionMetadata, diff --git a/src/catalog/src/durable/upgrade.rs b/src/catalog/src/durable/upgrade.rs index 25bdb32b97622..23bfeb6eafe29 100644 --- a/src/catalog/src/durable/upgrade.rs +++ b/src/catalog/src/durable/upgrade.rs @@ -40,11 +40,14 @@ //! `objects_v15.proto` and `objects_v16.proto`. In this migration code you __should not__ //! import any defaults or constants from elsewhere in the codebase, because then a future //! change could then impact a previous migration. -//! 9. Call your upgrade function in [`run_upgrade()`]. -//! 10. Generate a test file for the new version: +//! 9. Add an import for your new module to this file: mod v_to_v; +//! 10. Call your upgrade function in [`run_upgrade()`]. +//! 11. Generate a test file for the new version: //! ```ignore //! cargo test --package mz-catalog --lib durable::upgrade::tests::generate_missing_encodings -- --ignored //! ``` +//! You'll need to update the hashes in `src/catalog/protos/hashes.json` based on the results +//! of that command, and add a new one for the new version. //! //! When in doubt, reach out to the Surfaces team, and we'll be more than happy to help :) @@ -176,14 +179,14 @@ macro_rules! objects { } } -objects!(v60, v61, v62); +objects!(v60, v61, v62, v63); /// The current version of the `Catalog`. /// /// We will initialize new `Catalog`es with this version, and migrate existing `Catalog`es to this /// version. Whenever the `Catalog` changes, e.g. the protobufs we serialize in the `Catalog` /// change, we need to bump this version. -pub const CATALOG_VERSION: u64 = 62; +pub const CATALOG_VERSION: u64 = 63; /// The minimum `Catalog` version number that we support migrating from. /// @@ -197,6 +200,7 @@ const FUTURE_VERSION: u64 = CATALOG_VERSION + 1; mod v60_to_v61; mod v61_to_v62; +mod v62_to_v63; /// Describes a single action to take during a migration from `V1` to `V2`. #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] @@ -283,6 +287,9 @@ async fn run_upgrade( 61 => { run_versioned_upgrade(unopened_catalog_state, mode, version, v61_to_v62::upgrade).await } + 62 => { + run_versioned_upgrade(unopened_catalog_state, mode, version, v62_to_v63::upgrade).await + } // Up-to-date, no migration needed! CATALOG_VERSION => Ok(CATALOG_VERSION), diff --git a/src/catalog/src/durable/upgrade/snapshots/objects_v63.txt b/src/catalog/src/durable/upgrade/snapshots/objects_v63.txt new file mode 100644 index 0000000000000..779e625acf4bd --- /dev/null +++ b/src/catalog/src/durable/upgrade/snapshots/objects_v63.txt @@ -0,0 +1,100 @@ +ClQKUroBTwoJCgNrZXkSAggECiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQodCgV2YWx1ZRIUugERCg8KBXNoYXJkEgZCBPCQp4U= +CpkBCpYBugGSAQoJCgNrZXkSAggEChgKBGtpbmQSEEIOQ2x1c3RlclJlcGxpY2EKawoFdmFsdWUSYroBXwoQCgpjbHVzdGVyX2lkEgIIBAoMCgZjb25maWcSAggECi0KBG5hbWUSJUIj8J6kmvCRv4B48J6Eu2MiWCbwkYOf8J+giOG8mn578J2InScKDgoIb3duZXJfaWQSAggE +CtkBCtYBugHSAQqSAQoDa2V5EooBugGGAQoRCgtkYXRhYmFzZV9pZBICCAQKDQoHZ3JhbnRlZRICCAQKGQoLb2JqZWN0X3R5cGUSCsIBBwoFQYQ1QH0KNgoHcm9sZV9pZBIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBF0IjOCE0FScnHAoPCglzY2hlbWFfaWQSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKHgoFdmFsdWUSFboBEgoQCgpwcml2aWxlZ2VzEgIIBA== +CkIKQLoBPQoJCgNrZXkSAggECiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQoLCgV2YWx1ZRICCAQ= +CkQKQroBPwodCgNrZXkSFroBEwoRCgRuYW1lEglCB/CeuYlGV0gKEQoEa2luZBIJQgdJZEFsbG9jCgsKBXZhbHVlEgIIBA== +CnAKbroBawpJCgNrZXkSQroBPwo9CgRuYW1lEjVCM04iLsKl8JGWl/CWvoVy8J2UjT0kRzpvcuC6kOGpmzrvv70vTSciyLo9InTwkLKrJD0kWAoRCgRraW5kEglCB0lkQWxsb2MKCwoFdmFsdWUSAggE +Cj4KPLoBOQoXCgNrZXkSELoBDQoLCgRuYW1lEgNCATwKEQoEa2luZBIJQgdJZEFsbG9jCgsKBXZhbHVlEgIIBA== +CrIKCq8KugGrCgoJCgNrZXkSAggEChAKBGtpbmQSCEIGU2NoZW1hCosKCgV2YWx1ZRKBCroB/QkKOgoLZGF0YWJhc2VfaWQSK7oBKAomCgV2YWx1ZRIdugEaChgKBFVzZXISEMIBDQoLAXIAKVchB0ciQZwKEwoEbmFtZRILQglrMnzwkJa4LjwKHAoDb2lkEhXCARIKBRdRaWBcEP///////////wEKHAoIb3duZXJfaWQSELoBDQoLCgV2YWx1ZRICCAQK7QgKCnByaXZpbGVnZXMS3giyAdoICj+6ATwKDgoIYWNsX21vZGUSAggEChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRvchICCAQKjQG6AYkBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLATI0hyElJTZwUYwKOwoHZ3JhbnRlZRIwugEtCisKBXZhbHVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgppRTSJRQMDKSGMChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKbroBawotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFYgFdVlZJCN0gsCisKB2dyYW50ZWUSILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACg0KB2dyYW50b3ISAggECly6AVkKDgoIYWNsX21vZGUSAggECjgKB2dyYW50ZWUSLboBKgooCgV2YWx1ZRIfugEcChoKBlN5c3RlbRIQwgENCgsBBSYWCTV3AIRYPAoNCgdncmFudG9yEgIIBApQugFNCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAUSCGFJ0CWN0CEwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKXroBWwotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFUBwMIchlWWDk8Cg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKkAG6AYwBCjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKFDkjBomAUQIUfBD///////////8BCkIKB2dyYW50ZWUSN7oBNAoyCgV2YWx1ZRIpugEmCiQKBlN5c3RlbRIawgEXCgoEFRkSQXOARyaMEP///////////wEKDQoHZ3JhbnRvchICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAp+ugF7CiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKFEQRMQgXKHM5LAoNCgdncmFudGVlEgIIBAo8CgdncmFudG9yEjG6AS4KLAoFdmFsdWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEXdCcxMBFBmFYsCj+6ATwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKMboBLgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBA== +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ2x1c3RlcgoLCgV2YWx1ZRICCAQ= +CmIKYLoBXQo8CgNrZXkSNboBMgowCgJpZBIqugEnCiUKBXZhbHVlEhy6ARkKFwoEVXNlchIPwgEMCgpRQSl0RwABIkM8ChAKBGtpbmQSCEIGU2NoZW1hCgsKBXZhbHVlEgIIBA== +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudAoLCgV2YWx1ZRICCAQ= +CjcKNboBMgoJCgNrZXkSAggEChgKBGtpbmQSEEIOQ2x1c3RlclJlcGxpY2EKCwoFdmFsdWUSAggE +CjwKOroBNwoZCgNrZXkSEroBDwoNCgVzaGFyZBIEQgI/PwoaCgRraW5kEhJCEFVuZmluYWxpemVkU2hhcmQ= +CscBCsQBugHAAQqaAQoDa2V5EpIBugGOAQorCgtvYmplY3RfbmFtZRIcQhrwkbS6dVgqyLpg8JGKilHwnZSc4LCj8JC9hAoaCgtvYmplY3RfdHlwZRILwgEICgYBKTYVBh0KQwoLc2NoZW1hX25hbWUSNEIyYyRzT/CRjIvgspDCpUov8JGymT/goLDwkYu2JeCqrT3gprInKuCquCYmP3tySU8kKi4KFAoEa2luZBIMQgpHaWRNYXBwaW5nCgsKBXZhbHVlEgIIBA== +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +Cr0BCroBugG2AQpKCgNrZXkSQ7oBQAoeCgpjbHVzdGVyX2lkEhC6AQ0KCwoFdmFsdWUSAggECh4KBG5hbWUSFkIUaSlHaj9hOip7OlFg8JGQuD/vv70KKQoEa2luZBIhQh9DbHVzdGVySW50cm9zcGVjdGlvblNvdXJjZUluZGV4Cj0KBXZhbHVlEjS6ATEKHAoIaW5kZXhfaWQSEMIBDQoLAXgzYwcxMgJkJRwKEQoDb2lkEgrCAQcKBWc3NQls +CkoKSLoBRQoJCgNrZXkSAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwocCgV2YWx1ZRITugEQCg4KCGFjbF9tb2RlEgIIBA== +CkIKQLoBPQoUCgNrZXkSDboBCgoICgJpZBICCAQKGAoEa2luZBIQQg5DbHVzdGVyUmVwbGljYQoLCgV2YWx1ZRICCAQ= +CjcKNboBMgoJCgNrZXkSAggEChgKBGtpbmQSEEIOQ2x1c3RlclJlcGxpY2EKCwoFdmFsdWUSAggE +CkIKQLoBPQoJCgNrZXkSAggECiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQoLCgV2YWx1ZRICCAQ= +CowBCokBugGFAQoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgpZCgV2YWx1ZRJQugFNCksKBXZhbHVlEkJCQPCeuZ/hg4dHJlYiTfCehY5SX9S28J6lmCLIujxN8JatnzxR4a2E4LKAduelmuK2tvCflbTIujHIujHwn5W0UTw= +CjAKLroBKwoYCgVlcG9jaBIPwgEMCgpZAykyc3M4AhZcCg8KBGtpbmQSB0IFRXBvY2g= +CjkKN7oBNAoJCgNrZXkSAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwoLCgV2YWx1ZRICCAQ= +CiwKKroBJwoJCgNrZXkSAggEChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +CikKJ7oBJAoVCgRraW5kEg1CC1R4bldhbFNoYXJkCgsKBXZhbHVlEgIIBA== +CpgCCpUCugGRAgqzAQoDa2V5EqsBugGnAQo8CgtkYXRhYmFzZV9pZBItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwEyUkRDCYFyg0V8CisKB2dyYW50ZWUSILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEAChoKC29iamVjdF90eXBlEgvCAQgKBgFEiUaSfQoNCgdyb2xlX2lkEgIIBAoPCglzY2hlbWFfaWQSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKPAoFdmFsdWUSM7oBMAouCgpwcml2aWxlZ2VzEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKkzOHl0lUgYaVfA== +CrcBCrQBugGwAQpXCgNrZXkSULoBTQoNCgdncmFudGVlEgIIBAo8CgdncmFudG9yEjG6AS4KLAoFdmFsdWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwE5iZAXQiSDiBBsChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwo5CgV2YWx1ZRIwugEtCisKCGFjbF9tb2RlEh+6ARwKGgoIYml0ZmxhZ3MSDsIBCwoJl3NFcHYgIHGc +CkIKQLoBPQoUCgNrZXkSDboBCgoICgJpZBICCAQKGAoEa2luZBIQQg5DbHVzdGVyUmVwbGljYQoLCgV2YWx1ZRICCAQ= +CjkKN7oBNAoVCgNrZXkSDroBCwoJCgNnaWQSAggECg4KBGtpbmQSBkIESXRlbQoLCgV2YWx1ZRICCAQ= +Cl8KXboBWgoeCgNrZXkSF7oBFAoSCgNrZXkSC0IJLz86P/CQlrd7ChAKBGtpbmQSCEIGQ29uZmlnCiYKBXZhbHVlEh26ARoKGAoFdmFsdWUSD8IBDAoKRoIwkDkkEQdkfA== +CkMKQboBPgogCgNrZXkSGboBFgoUCgVzaGFyZBILQgllbF3hp5h7Jz0KGgoEa2luZBISQhBVbmZpbmFsaXplZFNoYXJk +CkAKProBOwoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudAobCgV2YWx1ZRISugEPCg0KB2NvbW1lbnQSAkIA +CnoKeLoBdQpTCgNrZXkSTLoBSQpHCgRuYW1lEj9CPS8mP8i68JG1lPCRi449zrPRqD50KiY/8J2UmfCfg49w4LufPfCfgrJ7JOGcpMOyXF7vv7128JGNjfCRjYAKEQoEa2luZBIJQgdTZXR0aW5nCgsKBXZhbHVlEgIIBA== +CkYKRLoBQQoiCgNrZXkSG7oBGAoWCgJpZBIQugENCgsKBXZhbHVlEgIIBAoOCgRraW5kEgZCBFJvbGUKCwoFdmFsdWUSAggE +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +ClsKWboBVgoVCgRraW5kEg1CC1R4bldhbFNoYXJkCj0KBXZhbHVlEjS6ATEKLwoFc2hhcmQSJkIkZ+KRgemAhVXhpLXwkZGfQCRfMvCQoq0/Jy7DuC4qPX5beWEm +CpULCpILugGOCwoVCgNrZXkSDroBCwoJCgNnaWQSAggECg4KBGtpbmQSBkIESXRlbQrkCgoFdmFsdWUS2gq6AdYKChAKCmRlZmluaXRpb24SAggEChwKBG5hbWUSFEISJOGonj1c4oCB0ajvv73wm4SyChEKA29pZBIKwgEHCgVXWZUlTAocCghvd25lcl9pZBIQugENCgsKBXZhbHVlEgIIBArhCQoKcHJpdmlsZWdlcxLSCbIBzgkKP7oBPAoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBAqGAboBggEKNwoIYWNsX21vZGUSK7oBKAomCghiaXRmbGFncxIawgEXCgoBg2YpYXgUJ3I8EP///////////wEKDQoHZ3JhbnRlZRICCAQKOAoHZ3JhbnRvchItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFJUZdwkwMAcJJ8Cl26AVoKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqGcWEIGSaJRVCcCg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKWroBVwoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKNgoHZ3JhbnRvchIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBKHAjdkUUYzhxnApgugFdCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAo8CgdncmFudG9yEjG6AS4KLAoFdmFsdWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEHQHBoFJAYJCJMCk+6AUwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECisKB2dyYW50b3ISILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACnu6AXgKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBUARQEZmDk2c0XAo4CgdncmFudGVlEi26ASoKKAoFdmFsdWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLARdTVllhkSJHBSwKDQoHZ3JhbnRvchICCAQKWroBVwo3CghhY2xfbW9kZRIrugEoCiYKCGJpdGZsYWdzEhrCARcKCgd1eVJoIycGVUwQ////////////AQoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApbugFYCg4KCGFjbF9tb2RlEgIIBAo3CgdncmFudGVlEiy6ASkKJwoFdmFsdWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKJUICEBchVgQQbAoNCgdncmFudG9yEgIIBAo/ugE8Cg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECmi6AWUKDgoIYWNsX21vZGUSAggEChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKNgoHZ3JhbnRvchIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBEzJzE4VXQgRDLAqyAboBrgEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoZIYglNSmGNUYcCkUKB2dyYW50ZWUSOroBNwo1CgV2YWx1ZRIsugEpCicKClByZWRlZmluZWQSGcIBFgoJRQMEMZcmaTZ8EP///////////wEKNwoHZ3JhbnRvchIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKChUYcICJQVFRcowKDwoJc2NoZW1hX2lkEgIIBA== +CiwKKroBJwoJCgNrZXkSAggEChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +CjAKLroBKwoYCgVlcG9jaBIPwgEMCgpVdXaQVgQzIQU8Cg8KBGtpbmQSB0IFRXBvY2g= +Ck0KS7oBSAoJCgNrZXkSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKHgoFdmFsdWUSFboBEgoQCgpwcml2aWxlZ2VzEgIIBA== +CnsKeboBdgpCCgNrZXkSO7oBOAo2CgJpZBIwugEtCisKBXZhbHVlEiK6AR8KHQoJVHJhbnNpZW50EhDCAQ0KCwECU0REl5UzAiecCiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQoLCgV2YWx1ZRICCAQ= +CrYBCrMBugGvAQoiCgNrZXkSG7oBGAoWCgJpZBIQugENCgsKBXZhbHVlEgIIBAoOCgRraW5kEgZCBFJvbGUKeQoFdmFsdWUScLoBbQoQCgphdHRyaWJ1dGVzEgIIBAoQCgptZW1iZXJzaGlwEgIIBAonCgRuYW1lEh9CHSbit41SXOCpiPCRq7Ekw4PgvrkiLuG4ldiGOjIqChIKA29pZBILwgEICgYBFFN2mGwKCgoEdmFycxICCAQ= +CiwKKroBJwoJCgNrZXkSAggEChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +CsABCr0BugG5AQqTAQoDa2V5EosBugGHAQpUCgtvYmplY3RfbmFtZRJFQkMpOT/wmr+zePCRpIBUOsKl4KiD8JG1lS8u8JC8j3tKdPCRqYbhqqFL8Jarhifvv70l1L7wnaqtLOGyh3Tvt7HgrqowChoKC29iamVjdF90eXBlEgvCAQgKBgFJWTdoHAoTCgtzY2hlbWFfbmFtZRIEQgIuSwoUCgRraW5kEgxCCkdpZE1hcHBpbmcKCwoFdmFsdWUSAggE +CjkKN7oBNAoJCgNrZXkSAggEChoKBGtpbmQSEkIQU291cmNlUmVmZXJlbmNlcwoLCgV2YWx1ZRICCAQ= +ClEKT7oBTAoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwosCgV2YWx1ZRIjugEgCh4KBXZhbHVlEhVCE1x7TVbwrbKR8J6EjT/wkKi5wqU= +Ci8KLboBKgoXCgVlcG9jaBIOwgELCglgYjc3YzcVWHwKDwoEa2luZBIHQgVFcG9jaA== +CtwBCtkBugHVAQqvAQoDa2V5EqcBugGjAQpUCgtvYmplY3RfbmFtZRJFQkPwnZKmL++/vTxMeMKzYPCRjYzgro5n8J6Ao0lS4aS48JGiscOt8JGNgteFM/CQqI598J2LoVXwn6+077+94L+D77+9ChoKC29iamVjdF90eXBlEgvCAQgKBgFUlwgmbAovCgtzY2hlbWFfbmFtZRIgQh7vsZbgrYvctmgk8J6jivCfiYNCSci676y+U/CRvLQKFAoEa2luZBIMQgpHaWRNYXBwaW5nCgsKBXZhbHVlEgIIBA== +Ck0KS7oBSAoJCgNrZXkSAggEChEKBGtpbmQSCUIHSWRBbGxvYwooCgV2YWx1ZRIfugEcChoKB25leHRfaWQSD8IBDAoKZJMikHWUNAZ1nA== +CkEKP7oBPAoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudAocCgV2YWx1ZRITugEQCg4KB2NvbW1lbnQSA0IBOg== +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudAoLCgV2YWx1ZRICCAQ= +CpwBCpkBugGVAQpwCgNrZXkSaboBZgouCgtvYmplY3RfbmFtZRIfQh3wkZGd8J65iSXigZTDivCdlJg60ajgq60nPyYsJgoZCgtvYmplY3RfdHlwZRIKwgEHCgVWZJSWPQoZCgtzY2hlbWFfbmFtZRIKQgjgrLDhrLJ4PQoUCgRraW5kEgxCCkdpZE1hcHBpbmcKCwoFdmFsdWUSAggE +CjIKMLoBLQoXCgNrZXkSELoBDQoLCgVldmVudBICCAQKEgoEa2luZBIKQghBdWRpdExvZw== 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 +CuEBCt4BugHaAQqtAQoDa2V5EqUBugGhAQo8CgtkYXRhYmFzZV9pZBItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFJZkE4WUOThIUsCg0KB2dyYW50ZWUSAggECiQKC29iamVjdF90eXBlEhXCARIKBRJ4I1c9EP///////////wEKDQoHcm9sZV9pZBICCAQKHQoJc2NoZW1hX2lkEhC6AQ0KCwoFdmFsdWUSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKCwoFdmFsdWUSAggE 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 +CvABCu0BugHpAQqWAQoDa2V5Eo4BugGKAQo9CgtvYmplY3RfbmFtZRIuQiwuKibCpTjhial18JGMs/CQo7Rz3YE/MicnYPCRrIMu8JCtqyTYliviqaMvKgoZCgtvYmplY3RfdHlwZRIKwgEHCgVYFBMiHAouCgtzY2hlbWFfbmFtZRIfQh0kOirgsJ/wn5W0cuGdqsOc4K6DKOCuqCfjg5FSegoUCgRraW5kEgxCCkdpZE1hcHBpbmcKOAoFdmFsdWUSL7oBLAoTCgtmaW5nZXJwcmludBIEQgImPgoVCgJpZBIPwgEMCgqBWHiEkgdYCAJs +CikKJ7oBJAoVCgRraW5kEg1CC1R4bldhbFNoYXJkCgsKBXZhbHVlEgIIBA== +Ct0GCtoGugHWBgpJCgNrZXkSQroBPwo9CgJpZBI3ugE0CjIKBXZhbHVlEim6ASYKJAoGU3lzdGVtEhrCARcKChJUJUASUnJBeYwQ////////////AQoQCgRraW5kEghCBlNjaGVtYQr2BQoFdmFsdWUS7AW6AegFChEKC2RhdGFiYXNlX2lkEgIIBApNCgRuYW1lEkVCQ/CQhZ7gqZ4ufDVg4KiqMy7wkZqm8JGEm/CdkqvqpI5k8JCohT0qdPCfm6XwkZml4KuQ4KWfLmNXYOGdi+GfsvCQpI4KEgoDb2lkEgvCAQgKBgOWcWFJbAosCghvd25lcl9pZBIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKwQQKCnByaXZpbGVnZXMSsgSyAa4ECn66AXsKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBUFZ4ByMEcTcBbAoNCgdncmFudGVlEgIIBAo7CgdncmFudG9yEjC6AS0KKwoFdmFsdWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKClghlIZTBxISNDwKXroBWwotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwE5UBAjJBVQJUVsChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRvchICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBApPugFMCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAorCgdncmFudG9yEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAApbugFYCg4KCGFjbF9tb2RlEgIIBAo3CgdncmFudGVlEiy6ASkKJwoFdmFsdWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKJCKWQTYGEYQhLAoNCgdncmFudG9yEgIIBApdugFaCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKYHgHQllGOWEpTAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggE +CsoBCscBugHDAQpfCgNrZXkSWLoBVQoRCgtvYmplY3RfbmFtZRICQgAKGgoLb2JqZWN0X3R5cGUSC8IBCAoGATdyB5CNCiQKC3NjaGVtYV9uYW1lEhVCE3E6wqUnPH7Woz/wn6CA8J6AqEgKFAoEa2luZBIMQgpHaWRNYXBwaW5nCkoKBXZhbHVlEkG6AT4KGgoLZmluZ2VycHJpbnQSC0IJ8JCnsUfwkZyMCiAKAmlkEhrCARcKChFYhDVVZBGXQWwQ////////////AQ== +CjAKLroBKwoYCgVlcG9jaBIPwgEMCgqFdhFkAlmTlyZ8Cg8KBGtpbmQSB0IFRXBvY2g= +Cp4BCpsBugGXAQpYCgNrZXkSUboBTgpMCgRuYW1lEkRCQlUtwqXgvaLgp7Ja8J6FjvCRsJXDifCbhLJ8dyTwkZKZ4aCK8J6ijPCWvpQ477+9R/CRhYfhg4cuKvCflbQlYCcuLgoRCgRraW5kEglCB0lkQWxsb2MKKAoFdmFsdWUSH7oBHAoaCgduZXh0X2lkEg/CAQwKCiFAAkcXFXBXcUw= +CjAKLroBKwoYCgVlcG9jaBIPwgEMCgpnYJKGQVd0CShNCg8KBGtpbmQSB0IFRXBvY2g= +CjcKNboBMgoJCgNrZXkSAggEChgKBGtpbmQSEEIOQ2x1c3RlclJlcGxpY2EKCwoFdmFsdWUSAggE +CjkKN7oBNAoJCgNrZXkSAggEChoKBGtpbmQSEkIQU291cmNlUmVmZXJlbmNlcwoLCgV2YWx1ZRICCAQ= +CkgKRroBQwoJCgNrZXkSAggECikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleAoLCgV2YWx1ZRICCAQ= +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudAoLCgV2YWx1ZRICCAQ= +CjMKMboBLgoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= +CmkKZ7oBZAo2CgNrZXkSL7oBLAoqCgRuYW1lEiJCIOCxmVgve0rguqvwkIC1Lm950ajwkJa78LCSgkrgq5AqCh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgoLCgV2YWx1ZRICCAQ= +ClQKUroBTwoJCgNrZXkSAggECiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQodCgV2YWx1ZRIUugERCg8KBXNoYXJkEgZCBCrgrII= +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ2x1c3RlcgoLCgV2YWx1ZRICCAQ= +CjMKMboBLgoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= +CjsKOboBNgoUCgNrZXkSDboBCgoICgJpZBICCAQKEQoEa2luZBIJQgdDbHVzdGVyCgsKBXZhbHVlEgIIBA== +CrsCCrgCugG0Agq8AQoDa2V5ErQBugGwAQo9CgtvYmplY3RfbmFtZRIuQizwnYK5JvCQsITwkYyyL0/hm4vwkaWB7Z+p4raU4LezLeCpjDVvejbJnWA6OgoZCgtvYmplY3RfdHlwZRIKwgEHCgUCkSlYLApUCgtzY2hlbWFfbmFtZRJFQkMvwqVQYPCeubtH4YCm4K+Q8J2cnO+svuqpr283LkPwn5W04auGOnU/4KeD8JCSqSTwmr+yJM6M4LiXfFrwkYqaJdiaChQKBGtpbmQSDEIKR2lkTWFwcGluZwpdCgV2YWx1ZRJUugFRCjgKC2ZpbmdlcnByaW50EilCJyUv4pGD0aglYPCRioJgPyfCsDxq8J+IuOC7iPCRl4fho6UuIu+/qwoVCgJpZBIPwgEMCgp2QnYGZZlIEhAc +Ci8KLboBKgoJCgNrZXkSAggEChAKBGtpbmQSCEIGU2NoZW1hCgsKBXZhbHVlEgIIBA== +CjAKLroBKwoYCgVlcG9jaBIPwgEMCgolApRlV2QGmQGNCg8KBGtpbmQSB0IFRXBvY2g= +Cs0DCsoDugHGAwqvAwoDa2V5EqcDugGjAwqgAwoFZXZlbnQSlgO6AZIDCo8DCgJWMRKIA7oBhAMKrgEKB2RldGFpbHMSogG6AZ4BCpsBCgtHcmFudFJvbGVWMRKLAboBhwEKGAoKZ3JhbnRvcl9pZBIKQgjvv7088JGNoQo3CgltZW1iZXJfaWQSKkIo0ahg8JGTl/CfnonWtWFde/CQjZsqcPCflbTwkJa1w6N9e/CflbTRqAoyCgdyb2xlX2lkEidCJfCek6LwkbWS8JCurPCQnaDRqD3wn5W0JT19aGrwkYScLzJnYT8KGQoKZXZlbnRfdHlwZRILwgEICgYBeHNUAk0KFQoCaWQSD8IBDAoKkhQIlHlmJIYRfAoaCgtvYmplY3RfdHlwZRILwgEICgYBGTKQCWwKLgoLb2NjdXJyZWRfYXQSH7oBHAoaCgZtaWxsaXMSEMIBDQoLAXVXB5eFg5EkYpwKUwoEdXNlchJLugFICkYKBWlubmVyEj1COz/wnrqEIiI2e/CQobnYjCc28JCkjeGKtSci4aOae/CbsYbwnrmJL+CoueqnsCVNeu+slyJrbVzqrIZdChIKBGtpbmQSCkIIQXVkaXRMb2c= +Cl0KW7oBWAoqCgNrZXkSI7oBIAoeCgRuYW1lEhZCFHIlPGJIOuCtiDzwnZO9bfCRoLJaCh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgoLCgV2YWx1ZRICCAQ= +CjoKOLoBNQoJCgNrZXkSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKCwoFdmFsdWUSAggE +CjkKN7oBNAoVCgNrZXkSDroBCwoJCgNnaWQSAggECg4KBGtpbmQSBkIESXRlbQoLCgV2YWx1ZRICCAQ= +CqUBCqIBugGeAQpNCgNrZXkSRroBQwoMCgZvYmplY3QSAggECjMKDXN1Yl9jb21wb25lbnQSIroBHwodCglDb2x1bW5Qb3MSEMIBDQoLAXZRUhdZgFYWZnwKEQoEa2luZBIJQgdDb21tZW50CjoKBXZhbHVlEjG6AS4KLAoHY29tbWVudBIhQh828JGIlu+/vS/ita8/dfCQurBYKD0/KiHRqDov4b+Z +Ci0KK7oBKAoJCgNrZXkSAggECg4KBGtpbmQSBkIESXRlbQoLCgV2YWx1ZRICCAQ= +CnsKeboBdgoUCgNrZXkSDboBCgoICgJpZBICCAQKIwoEa2luZBIbQhlTdG9yYWdlQ29sbGVjdGlvbk1ldGFkYXRhCjkKBXZhbHVlEjC6AS0KKwoFc2hhcmQSIkIgXC4y8JCtk0Jd8JCohk7qpqMx8Jy8sVwsWuChifCflbQ= +CjMKMboBLgoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= +ClQKUroBTwotCgNrZXkSJroBIwoMCgZvYmplY3QSAggEChMKDXN1Yl9jb21wb25lbnQSAggEChEKBGtpbmQSCUIHQ29tbWVudAoLCgV2YWx1ZRICCAQ= +Ci8KLboBKgoJCgNrZXkSAggEChAKBGtpbmQSCEIGU2NoZW1hCgsKBXZhbHVlEgIIBA== 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 +CnkKd7oBdApGCgNrZXkSP7oBPAo6CgRuYW1lEjJCME3gt7PIujwnyLrhipnwkIC8avCQvbfRqOCwmt+B0ahKXOGvsvCdmIguJEkuJeOIiAodCgRraW5kEhVCE1NlcnZlckNvbmZpZ3VyYXRpb24KCwoFdmFsdWUSAggE +CkIKQLoBPQoUCgNrZXkSDboBCgoICgJpZBICCAQKGAoEa2luZBIQQg5DbHVzdGVyUmVwbGljYQoLCgV2YWx1ZRICCAQ= +Cm8KbboBagoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudApKCgV2YWx1ZRJBugE+CjwKB2NvbW1lbnQSMUIv77+9WmrIui/gs5bDkT8qX2/iuZ1gOsOq4KaPL+Cvl1Lgr4h54KuIO/CQgYw6QD0= +CjEKL7oBLAoJCgNrZXkSAggEChIKBGtpbmQSCkIIRGF0YWJhc2UKCwoFdmFsdWUSAggE +CngKdroBcwo/CgNrZXkSOLoBNQozCgJpZBItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwEUVlAoMDRHmRFsCiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQoLCgV2YWx1ZRICCAQ= +CjkKN7oBNAoJCgNrZXkSAggEChoKBGtpbmQSEkIQU291cmNlUmVmZXJlbmNlcwoLCgV2YWx1ZRICCAQ= +CjwKOroBNwoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgoLCgV2YWx1ZRICCAQ= +Cm4KbLoBaQpICgNrZXkSQboBPgo8CgNrZXkSNUIz8J+VtGngupA88J+tmPCQpL/RqCjwnrmdw5skdCYvOsKrW9Go4Kit8JGIjeC0gUkl77+iChAKBGtpbmQSCEIGQ29uZmlnCgsKBXZhbHVlEgIIBA== +CkkKR7oBRAoiCgNrZXkSG7oBGAoWCgJpZBIQugENCgsKBXZhbHVlEgIIBAoRCgRraW5kEglCB0NsdXN0ZXIKCwoFdmFsdWUSAggE +ClwKWroBVwo1CgNrZXkSLroBKwopCgRuYW1lEiFCHy176qmNPGrvv73wnZKe6qC3wqXwlqud8J65ofCRjYgKEQoEa2luZBIJQgdTZXR0aW5nCgsKBXZhbHVlEgIIBA== +CjoKOLoBNQoiCgVlcG9jaBIZwgEWCgmEIERkCZhjUkwQ/v//////////AQoPCgRraW5kEgdCBUVwb2No +Co8BCowBugGIAQoUCgNrZXkSDboBCgoICgJpZBICCAQKIwoEa2luZBIbQhlTdG9yYWdlQ29sbGVjdGlvbk1ldGFkYXRhCksKBXZhbHVlEkK6AT8KPQoFc2hhcmQSNEIyPUbwn56dW+C6hOCuleqshi41762DbT1yJFwnJi9ge2Z7KybCpfCfm7sqee2fuifgspA= +ClAKTroBSwoiCgNrZXkSG7oBGAoWCgJpZBIQugENCgsKBXZhbHVlEgIIBAoYCgRraW5kEhBCDkNsdXN0ZXJSZXBsaWNhCgsKBXZhbHVlEgIIBA== diff --git a/src/catalog/src/durable/upgrade/v62_to_v63.rs b/src/catalog/src/durable/upgrade/v62_to_v63.rs new file mode 100644 index 0000000000000..34add93d24b64 --- /dev/null +++ b/src/catalog/src/durable/upgrade/v62_to_v63.rs @@ -0,0 +1,18 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +use crate::durable::upgrade::MigrationAction; +use crate::durable::upgrade::{objects_v62 as v62, objects_v63 as v63}; + +/// In v63, we added the SourceReferences object kind. +pub fn upgrade( + _snapshot: Vec, +) -> Vec> { + vec![] +} diff --git a/src/catalog/src/memory/objects.rs b/src/catalog/src/memory/objects.rs index 6be3995254fae..c90c04977bee3 100644 --- a/src/catalog/src/memory/objects.rs +++ b/src/catalog/src/memory/objects.rs @@ -2457,6 +2457,7 @@ pub enum StateUpdateKind { Cluster(durable::objects::Cluster), IntrospectionSourceIndex(durable::objects::IntrospectionSourceIndex), ClusterReplica(durable::objects::ClusterReplica), + SourceReferences(durable::objects::SourceReferences), SystemObjectMapping(durable::objects::SystemObjectMapping), // Temporary items are not actually updated via the durable catalog, but this allows us to // model them the same way as all other items. @@ -2532,6 +2533,7 @@ pub enum BootstrapStateUpdateKind { Cluster(durable::objects::Cluster), IntrospectionSourceIndex(durable::objects::IntrospectionSourceIndex), ClusterReplica(durable::objects::ClusterReplica), + SourceReferences(durable::objects::SourceReferences), SystemObjectMapping(durable::objects::SystemObjectMapping), Item(durable::objects::Item), Comment(durable::objects::Comment), @@ -2556,6 +2558,9 @@ impl From for StateUpdateKind { BootstrapStateUpdateKind::SystemConfiguration(kind) => { StateUpdateKind::SystemConfiguration(kind) } + BootstrapStateUpdateKind::SourceReferences(kind) => { + StateUpdateKind::SourceReferences(kind) + } BootstrapStateUpdateKind::Cluster(kind) => StateUpdateKind::Cluster(kind), BootstrapStateUpdateKind::IntrospectionSourceIndex(kind) => { StateUpdateKind::IntrospectionSourceIndex(kind) @@ -2601,6 +2606,9 @@ impl TryFrom for BootstrapStateUpdateKind { StateUpdateKind::ClusterReplica(kind) => { Ok(BootstrapStateUpdateKind::ClusterReplica(kind)) } + StateUpdateKind::SourceReferences(kind) => { + Ok(BootstrapStateUpdateKind::SourceReferences(kind)) + } StateUpdateKind::SystemObjectMapping(kind) => { Ok(BootstrapStateUpdateKind::SystemObjectMapping(kind)) } diff --git a/src/catalog/tests/debug.rs b/src/catalog/tests/debug.rs index 465e4b7b1436d..5d5f49674df2a 100644 --- a/src/catalog/tests/debug.rs +++ b/src/catalog/tests/debug.rs @@ -59,6 +59,7 @@ impl Debug for HiddenUserVersionTrace<'_> { roles, schemas, settings, + source_references, system_object_mappings, system_configurations, system_privileges, @@ -88,6 +89,7 @@ impl Debug for HiddenUserVersionTrace<'_> { .field("roles", roles) .field("schemas", schemas) .field("settings", settings) + .field("source_references", source_references) .field("system_object_mappings", system_object_mappings) .field("system_configurations", system_configurations) .field("system_privileges", system_privileges) diff --git a/src/catalog/tests/open.rs b/src/catalog/tests/open.rs index 6a78a194143b6..e26984b45991b 100644 --- a/src/catalog/tests/open.rs +++ b/src/catalog/tests/open.rs @@ -61,6 +61,7 @@ impl Debug for HiddenUserVersionSnapshot<'_> { id_allocator, configs, settings, + source_references, system_object_mappings, system_configurations, default_privileges, @@ -83,6 +84,7 @@ impl Debug for HiddenUserVersionSnapshot<'_> { .field("id_allocator", id_allocator) .field("configs", &configs) .field("settings", settings) + .field("source_references", source_references) .field("system_object_mappings", system_object_mappings) .field("system_configurations", system_configurations) .field("default_privileges", default_privileges) diff --git a/src/catalog/tests/snapshots/debug__opened_trace.snap b/src/catalog/tests/snapshots/debug__opened_trace.snap index 49dcbf1b1a42c..a1a5e66e8d1bc 100644 --- a/src/catalog/tests/snapshots/debug__opened_trace.snap +++ b/src/catalog/tests/snapshots/debug__opened_trace.snap @@ -2173,6 +2173,9 @@ Trace { ), ], }, + source_references: CollectionTrace { + values: [], + }, system_object_mappings: CollectionTrace { values: [], }, diff --git a/src/catalog/tests/snapshots/open__initial_snapshot.snap b/src/catalog/tests/snapshots/open__initial_snapshot.snap index 317753e746f88..4773630dc013e 100644 --- a/src/catalog/tests/snapshots/open__initial_snapshot.snap +++ b/src/catalog/tests/snapshots/open__initial_snapshot.snap @@ -1380,6 +1380,7 @@ Snapshot { value: "0.0.0", }, }, + source_references: {}, system_object_mappings: {}, system_configurations: {}, default_privileges: { diff --git a/src/environmentd/tests/testdata/http/ws b/src/environmentd/tests/testdata/http/ws index 1ef51da0075c1..ebc16b8d19ec4 100644 --- a/src/environmentd/tests/testdata/http/ws +++ b/src/environmentd/tests/testdata/http/ws @@ -402,7 +402,7 @@ ws-text ws-text {"query": "SELECT 1 FROM mz_sources LIMIT 1"} ---- -{"type":"Notice","payload":{"message":"{\n \"plans\": {\n \"raw\": {\n \"text\": \"Finish limit=1 output=[#0]\\n Project (#15)\\n Map (1)\\n Get mz_catalog.mz_sources\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"Project\": {\n \"input\": {\n \"Map\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"System\": 459\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"Oid\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": {\n \"Array\": \"MzAclItem\"\n },\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n }\n ],\n \"keys\": [\n [\n 0\n ],\n [\n 1\n ]\n ]\n }\n }\n },\n \"scalars\": [\n {\n \"Literal\": [\n {\n \"data\": [\n 42,\n 1\n ]\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ]\n }\n },\n \"outputs\": [\n 15\n ]\n }\n }\n },\n \"optimized\": {\n \"global\": {\n \"text\": \"t72:\\n Finish limit=1 output=[#0]\\n ArrangeBy keys=[[#0]]\\n ReadGlobalFromSameDataflow t71\\n\\nt71:\\n Project (#15)\\n Map (1)\\n ReadIndex on=mz_sources mz_sources_ind=[*** full scan ***]\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"plans\": [\n {\n \"id\": \"t72\",\n \"plan\": {\n \"ArrangeBy\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"Transient\": 71\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ],\n \"keys\": []\n },\n \"access_strategy\": \"SameDataflow\"\n }\n },\n \"keys\": [\n [\n {\n \"Column\": 0\n }\n ]\n ]\n }\n }\n },\n {\n \"id\": \"t71\",\n \"plan\": {\n \"Project\": {\n \"input\": {\n \"Map\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"System\": 459\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"Oid\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": {\n \"Array\": \"MzAclItem\"\n },\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n }\n ],\n \"keys\": [\n [\n 0\n ],\n [\n 1\n ]\n ]\n },\n \"access_strategy\": {\n \"Index\": [\n [\n {\n \"System\": 714\n },\n \"FullScan\"\n ]\n ]\n }\n }\n },\n \"scalars\": [\n {\n \"Literal\": [\n {\n \"Ok\": {\n \"data\": [\n 42,\n 1\n ]\n }\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ]\n }\n },\n \"outputs\": [\n 15\n ]\n }\n }\n }\n ],\n \"sources\": []\n }\n },\n \"fast_path\": {\n \"text\": \"Explained Query (fast path):\\n Finish limit=1 output=[#0]\\n Project (#15)\\n Map (1)\\n ReadIndex on=mz_catalog.mz_sources mz_sources_ind=[*** full scan ***]\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"plans\": [\n {\n \"id\": \"Explained Query (fast path)\",\n \"plan\": {\n \"PeekExisting\": [\n {\n \"System\": 459\n },\n {\n \"System\": 714\n },\n null,\n {\n \"mfp\": {\n \"expressions\": [\n {\n \"Literal\": [\n {\n \"Ok\": {\n \"data\": [\n 42,\n 1\n ]\n }\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ],\n \"predicates\": [],\n \"projection\": [\n 15\n ],\n \"input_arity\": 15\n }\n }\n ]\n }\n }\n ],\n \"sources\": []\n }\n }\n }\n },\n \"insights\": {\n \"imports\": {\n \"s714\": {\n \"name\": {\n \"schema\": \"mz_catalog\",\n \"item\": \"mz_sources_ind\"\n },\n \"type\": \"compute\"\n }\n },\n \"fast_path_clusters\": {},\n \"fast_path_limit\": null,\n \"persist_count\": []\n },\n \"cluster\": {\n \"name\": \"mz_catalog_server\",\n \"id\": {\n \"System\": 2\n }\n },\n \"redacted_sql\": \"SELECT '' FROM [s459 AS mz_catalog.mz_sources] LIMIT ''\"\n}","code":"MZ001","severity":"notice"}} +{"type":"Notice","payload":{"message":"{\n \"plans\": {\n \"raw\": {\n \"text\": \"Finish limit=1 output=[#0]\\n Project (#15)\\n Map (1)\\n Get mz_catalog.mz_sources\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"Project\": {\n \"input\": {\n \"Map\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"System\": 459\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"Oid\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": {\n \"Array\": \"MzAclItem\"\n },\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n }\n ],\n \"keys\": [\n [\n 0\n ],\n [\n 1\n ]\n ]\n }\n }\n },\n \"scalars\": [\n {\n \"Literal\": [\n {\n \"data\": [\n 42,\n 1\n ]\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ]\n }\n },\n \"outputs\": [\n 15\n ]\n }\n }\n },\n \"optimized\": {\n \"global\": {\n \"text\": \"t72:\\n Finish limit=1 output=[#0]\\n ArrangeBy keys=[[#0]]\\n ReadGlobalFromSameDataflow t71\\n\\nt71:\\n Project (#15)\\n Map (1)\\n ReadIndex on=mz_sources mz_sources_ind=[*** full scan ***]\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"plans\": [\n {\n \"id\": \"t72\",\n \"plan\": {\n \"ArrangeBy\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"Transient\": 71\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ],\n \"keys\": []\n },\n \"access_strategy\": \"SameDataflow\"\n }\n },\n \"keys\": [\n [\n {\n \"Column\": 0\n }\n ]\n ]\n }\n }\n },\n {\n \"id\": \"t71\",\n \"plan\": {\n \"Project\": {\n \"input\": {\n \"Map\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"System\": 459\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"Oid\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": {\n \"Array\": \"MzAclItem\"\n },\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n }\n ],\n \"keys\": [\n [\n 0\n ],\n [\n 1\n ]\n ]\n },\n \"access_strategy\": {\n \"Index\": [\n [\n {\n \"System\": 715\n },\n \"FullScan\"\n ]\n ]\n }\n }\n },\n \"scalars\": [\n {\n \"Literal\": [\n {\n \"Ok\": {\n \"data\": [\n 42,\n 1\n ]\n }\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ]\n }\n },\n \"outputs\": [\n 15\n ]\n }\n }\n }\n ],\n \"sources\": []\n }\n },\n \"fast_path\": {\n \"text\": \"Explained Query (fast path):\\n Finish limit=1 output=[#0]\\n Project (#15)\\n Map (1)\\n ReadIndex on=mz_catalog.mz_sources mz_sources_ind=[*** full scan ***]\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"plans\": [\n {\n \"id\": \"Explained Query (fast path)\",\n \"plan\": {\n \"PeekExisting\": [\n {\n \"System\": 459\n },\n {\n \"System\": 715\n },\n null,\n {\n \"mfp\": {\n \"expressions\": [\n {\n \"Literal\": [\n {\n \"Ok\": {\n \"data\": [\n 42,\n 1\n ]\n }\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ],\n \"predicates\": [],\n \"projection\": [\n 15\n ],\n \"input_arity\": 15\n }\n }\n ]\n }\n }\n ],\n \"sources\": []\n }\n }\n }\n },\n \"insights\": {\n \"imports\": {\n \"s715\": {\n \"name\": {\n \"schema\": \"mz_catalog\",\n \"item\": \"mz_sources_ind\"\n },\n \"type\": \"compute\"\n }\n },\n \"fast_path_clusters\": {},\n \"fast_path_limit\": null,\n \"persist_count\": []\n },\n \"cluster\": {\n \"name\": \"mz_catalog_server\",\n \"id\": {\n \"System\": 2\n }\n },\n \"redacted_sql\": \"SELECT '' FROM [s459 AS mz_catalog.mz_sources] LIMIT ''\"\n}","code":"MZ001","severity":"notice"}} {"type":"CommandStarting","payload":{"has_rows":true,"is_streaming":false}} {"type":"Rows","payload":{"columns":[{"name":"?column?","type_oid":23,"type_len":4,"type_mod":-1}]}} {"type":"Row","payload":["1"]} @@ -412,7 +412,7 @@ ws-text ws-text {"query": "SELECT 1 / 0 FROM mz_sources LIMIT 1"} ---- -{"type":"Notice","payload":{"message":"{\n \"plans\": {\n \"raw\": {\n \"text\": \"Finish limit=1 output=[#0]\\n Project (#15)\\n Map ((1 / 0))\\n Get mz_catalog.mz_sources\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"Project\": {\n \"input\": {\n \"Map\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"System\": 459\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"Oid\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": {\n \"Array\": \"MzAclItem\"\n },\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n }\n ],\n \"keys\": [\n [\n 0\n ],\n [\n 1\n ]\n ]\n }\n }\n },\n \"scalars\": [\n {\n \"CallBinary\": {\n \"func\": \"DivInt32\",\n \"expr1\": {\n \"Literal\": [\n {\n \"data\": [\n 42,\n 1\n ]\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n },\n \"expr2\": {\n \"Literal\": [\n {\n \"data\": [\n 41\n ]\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n }\n }\n ]\n }\n },\n \"outputs\": [\n 15\n ]\n }\n }\n },\n \"optimized\": {\n \"global\": {\n \"text\": \"t75:\\n Finish limit=1 output=[#0]\\n ArrangeBy keys=[[#0]]\\n ReadGlobalFromSameDataflow t74\\n\\nt74:\\n Map (error(\\\"division by zero\\\"))\\n Project ()\\n ReadIndex on=mz_sources mz_sources_ind=[*** full scan ***]\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"plans\": [\n {\n \"id\": \"t75\",\n \"plan\": {\n \"ArrangeBy\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"Transient\": 74\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ],\n \"keys\": []\n },\n \"access_strategy\": \"SameDataflow\"\n }\n },\n \"keys\": [\n [\n {\n \"Column\": 0\n }\n ]\n ]\n }\n }\n },\n {\n \"id\": \"t74\",\n \"plan\": {\n \"Map\": {\n \"input\": {\n \"Project\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"System\": 459\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"Oid\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": {\n \"Array\": \"MzAclItem\"\n },\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n }\n ],\n \"keys\": [\n [\n 0\n ],\n [\n 1\n ]\n ]\n },\n \"access_strategy\": {\n \"Index\": [\n [\n {\n \"System\": 714\n },\n \"FullScan\"\n ]\n ]\n }\n }\n },\n \"outputs\": []\n }\n },\n \"scalars\": [\n {\n \"Literal\": [\n {\n \"Err\": \"DivisionByZero\"\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ]\n }\n }\n }\n ],\n \"sources\": []\n }\n },\n \"fast_path\": {\n \"text\": \"Explained Query (fast path):\\n Finish limit=1 output=[#0]\\n Project (#15)\\n Map (error(\\\"division by zero\\\"))\\n ReadIndex on=mz_catalog.mz_sources mz_sources_ind=[*** full scan ***]\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"plans\": [\n {\n \"id\": \"Explained Query (fast path)\",\n \"plan\": {\n \"PeekExisting\": [\n {\n \"System\": 459\n },\n {\n \"System\": 714\n },\n null,\n {\n \"mfp\": {\n \"expressions\": [\n {\n \"Literal\": [\n {\n \"Err\": \"DivisionByZero\"\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ],\n \"predicates\": [],\n \"projection\": [\n 15\n ],\n \"input_arity\": 15\n }\n }\n ]\n }\n }\n ],\n \"sources\": []\n }\n }\n }\n },\n \"insights\": {\n \"imports\": {\n \"s714\": {\n \"name\": {\n \"schema\": \"mz_catalog\",\n \"item\": \"mz_sources_ind\"\n },\n \"type\": \"compute\"\n }\n },\n \"fast_path_clusters\": {},\n \"fast_path_limit\": null,\n \"persist_count\": []\n },\n \"cluster\": {\n \"name\": \"mz_catalog_server\",\n \"id\": {\n \"System\": 2\n }\n },\n \"redacted_sql\": \"SELECT '' / '' FROM [s459 AS mz_catalog.mz_sources] LIMIT ''\"\n}","code":"MZ001","severity":"notice"}} +{"type":"Notice","payload":{"message":"{\n \"plans\": {\n \"raw\": {\n \"text\": \"Finish limit=1 output=[#0]\\n Project (#15)\\n Map ((1 / 0))\\n Get mz_catalog.mz_sources\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"Project\": {\n \"input\": {\n \"Map\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"System\": 459\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"Oid\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": {\n \"Array\": \"MzAclItem\"\n },\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n }\n ],\n \"keys\": [\n [\n 0\n ],\n [\n 1\n ]\n ]\n }\n }\n },\n \"scalars\": [\n {\n \"CallBinary\": {\n \"func\": \"DivInt32\",\n \"expr1\": {\n \"Literal\": [\n {\n \"data\": [\n 42,\n 1\n ]\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n },\n \"expr2\": {\n \"Literal\": [\n {\n \"data\": [\n 41\n ]\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n }\n }\n ]\n }\n },\n \"outputs\": [\n 15\n ]\n }\n }\n },\n \"optimized\": {\n \"global\": {\n \"text\": \"t75:\\n Finish limit=1 output=[#0]\\n ArrangeBy keys=[[#0]]\\n ReadGlobalFromSameDataflow t74\\n\\nt74:\\n Map (error(\\\"division by zero\\\"))\\n Project ()\\n ReadIndex on=mz_sources mz_sources_ind=[*** full scan ***]\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"plans\": [\n {\n \"id\": \"t75\",\n \"plan\": {\n \"ArrangeBy\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"Transient\": 74\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ],\n \"keys\": []\n },\n \"access_strategy\": \"SameDataflow\"\n }\n },\n \"keys\": [\n [\n {\n \"Column\": 0\n }\n ]\n ]\n }\n }\n },\n {\n \"id\": \"t74\",\n \"plan\": {\n \"Map\": {\n \"input\": {\n \"Project\": {\n \"input\": {\n \"Get\": {\n \"id\": {\n \"Global\": {\n \"System\": 459\n }\n },\n \"typ\": {\n \"column_types\": [\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"Oid\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": false\n },\n {\n \"scalar_type\": {\n \"Array\": \"MzAclItem\"\n },\n \"nullable\": false\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n },\n {\n \"scalar_type\": \"String\",\n \"nullable\": true\n }\n ],\n \"keys\": [\n [\n 0\n ],\n [\n 1\n ]\n ]\n },\n \"access_strategy\": {\n \"Index\": [\n [\n {\n \"System\": 715\n },\n \"FullScan\"\n ]\n ]\n }\n }\n },\n \"outputs\": []\n }\n },\n \"scalars\": [\n {\n \"Literal\": [\n {\n \"Err\": \"DivisionByZero\"\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ]\n }\n }\n }\n ],\n \"sources\": []\n }\n },\n \"fast_path\": {\n \"text\": \"Explained Query (fast path):\\n Finish limit=1 output=[#0]\\n Project (#15)\\n Map (error(\\\"division by zero\\\"))\\n ReadIndex on=mz_catalog.mz_sources mz_sources_ind=[*** full scan ***]\\n\\nTarget cluster: mz_catalog_server\\n\",\n \"json\": {\n \"plans\": [\n {\n \"id\": \"Explained Query (fast path)\",\n \"plan\": {\n \"PeekExisting\": [\n {\n \"System\": 459\n },\n {\n \"System\": 715\n },\n null,\n {\n \"mfp\": {\n \"expressions\": [\n {\n \"Literal\": [\n {\n \"Err\": \"DivisionByZero\"\n },\n {\n \"scalar_type\": \"Int32\",\n \"nullable\": false\n }\n ]\n }\n ],\n \"predicates\": [],\n \"projection\": [\n 15\n ],\n \"input_arity\": 15\n }\n }\n ]\n }\n }\n ],\n \"sources\": []\n }\n }\n }\n },\n \"insights\": {\n \"imports\": {\n \"s715\": {\n \"name\": {\n \"schema\": \"mz_catalog\",\n \"item\": \"mz_sources_ind\"\n },\n \"type\": \"compute\"\n }\n },\n \"fast_path_clusters\": {},\n \"fast_path_limit\": null,\n \"persist_count\": []\n },\n \"cluster\": {\n \"name\": \"mz_catalog_server\",\n \"id\": {\n \"System\": 2\n }\n },\n \"redacted_sql\": \"SELECT '' / '' FROM [s459 AS mz_catalog.mz_sources] LIMIT ''\"\n}","code":"MZ001","severity":"notice"}} {"type":"CommandStarting","payload":{"has_rows":false,"is_streaming":false}} {"type":"Error","payload":{"message":"division by zero","code":"XX000"}} {"type":"ReadyForQuery","payload":"I"} diff --git a/src/pgrepr-consts/src/oid.rs b/src/pgrepr-consts/src/oid.rs index 12701e24b081a..075d82ffc8429 100644 --- a/src/pgrepr-consts/src/oid.rs +++ b/src/pgrepr-consts/src/oid.rs @@ -734,3 +734,4 @@ pub const INDEX_MZ_OBJECTS_IND_OID: u32 = 17011; pub const INDEX_MZ_COLUMNS_IND_OID: u32 = 17012; pub const INDEX_MZ_SECRETS_IND_OID: u32 = 17013; pub const INDEX_MZ_VIEWS_IND_OID: u32 = 17014; +pub const TABLE_MZ_SOURCE_REFERENCES_OID: u32 = 17015; diff --git a/test/sqllogictest/autogenerated/mz_internal.slt b/test/sqllogictest/autogenerated/mz_internal.slt index c0d9461d3a25b..3d48bc270a133 100644 --- a/test/sqllogictest/autogenerated/mz_internal.slt +++ b/test/sqllogictest/autogenerated/mz_internal.slt @@ -653,6 +653,7 @@ mz_sink_statistics mz_sink_statistics_raw mz_sink_status_history mz_sink_statuses +mz_source_references mz_source_statistics mz_source_statistics_raw mz_source_statistics_with_history diff --git a/test/sqllogictest/information_schema_tables.slt b/test/sqllogictest/information_schema_tables.slt index 1688e3432cf81..15ecf7445ffdb 100644 --- a/test/sqllogictest/information_schema_tables.slt +++ b/test/sqllogictest/information_schema_tables.slt @@ -593,6 +593,10 @@ mz_sink_statuses VIEW materialize mz_internal +mz_source_references +BASE TABLE +materialize +mz_internal mz_source_statistics VIEW materialize diff --git a/test/sqllogictest/oid.slt b/test/sqllogictest/oid.slt index c2e0813d39154..1443a70c278fd 100644 --- a/test/sqllogictest/oid.slt +++ b/test/sqllogictest/oid.slt @@ -1120,3 +1120,4 @@ SELECT oid, name FROM mz_objects WHERE id LIKE 's%' AND oid < 20000 ORDER BY oid 17012 mz_columns_ind 17013 mz_secrets_ind 17014 mz_views_ind +17015 mz_source_references diff --git a/test/testdrive/catalog.td b/test/testdrive/catalog.td index 730d17f666886..0efbcc182fd36 100644 --- a/test/testdrive/catalog.td +++ b/test/testdrive/catalog.td @@ -603,6 +603,7 @@ mz_optimizer_notices "" mz_postgres_sources "" mz_postgres_source_tables "" mz_sessions "" +mz_source_references "" mz_storage_usage_by_shard "" mz_subscriptions "" mz_type_pg_metadata "" @@ -769,7 +770,7 @@ test_table "" # `SHOW TABLES` and `mz_tables` should agree. > SELECT COUNT(*) FROM mz_tables WHERE id LIKE 's%' -56 +57 # There is one entry in mz_indexes for each field_number/expression of the index. > SELECT COUNT(id) FROM mz_indexes WHERE id LIKE 's%'