From 1945b1438aa5dddf331957f1fd65cb21d2cadf0a Mon Sep 17 00:00:00 2001 From: Parker Timmerman Date: Fri, 25 Oct 2024 12:42:47 -0400 Subject: [PATCH] alter_table: Durable Catalog Migration (#30163) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This PR re-keys everything in the durable Catalog on `CatalogItemId` instead of `GlobalId`, and shims everything above the durable Catalog objects using two new methods `GlobalId::to_item_id()`, and `CatalogItemId::to_global_id()`. Now every item in the Catalog has the following fields: * `id: CatalogItemId`, a stable _external_ identifier (i.e. in Catalog tables like `mz_objects`) that is the same for the entire lifetime of the object. * `global_id: GlobalId`, a stable _internal_ identifier for this object that can be used by storage and compute. * `extra_versions: BTreeMap`, mapping of versions of an object to the `GlobalId`s used by compute and storage to refer to a specific version. This de-coupling of `CatalogItemId` and `GlobalId` achieves two things: 1. Externally objects have a stable identifier, even as they are `ALTER`-ed. This is required for external tools like dbt and Terraform that track objects by ID. 2. Internally a `GlobalId` always refers to the same `RelationDesc` + Persist Shard, this maintains the concept from the formalism that a `GlobalId` is never re-assigned to a new pTVC. The implementation of `ALTER TABLE ... ADD COLUMN ...` will thus allocate a new `GlobalId` which will immutably refer to that specific version of the table. #### Other Changes Along with `ItemKey` and `ItemValue` I updated the following Catalog types: * `GidMappingValue`: replaced the `id` field with `catalog_id` and `global_id`, used to identify builtin catalog objects. * `ClusterIntrospectionSourceIndexValue`: replaced the `index_id` field with `catalog_id` and `global_id`, used to identify builtin introspection source indexes. * `CommentKey`: replaced `GlobalId` with `CatalogItemId`, used to identify comments on objects. * `SourceReferencesKey`: replaced `GlobalId` with `CatalogItemId`, used to track references between a Source and the subsources/tables that read from it. #### Partial Progress Today `CatalogItemId` is 1:1 with `GlobalId`, this allows us to implement the `to_item_id` and `to_global_id` shim methods. Until we support `ALTER TABLE ... ADD COLUMN ...` we can freely convert between the two. This allows us to break this change up among multiple PRs instead of a single massive change. #### Initial Migration Because `CatalogItemId` and `GlobalId` are currently 1:1, this allows us to migrate the raw values of the IDs, e.g. `GlobalId::User(42)` becomes `CatalogItemId::User(42)`, which is exactly what this PR does. ### Motivation Progress towards https://github.com/MaterializeInc/database-issues/issues/8233 Implements changes described in https://github.com/MaterializeInc/materialize/pull/30019 ### Tips for reviewer This PR is split into two commits: 1. The durable catalog migration, and updates to durable Catalog objects. I would appreciate the most thorough reviews on this commit. 4. Shimming all calling code to convert between `CatalogItemId` and `GlobalId`. ### Checklist - [ ] This PR has adequate test coverage / QA involvement has been duly considered. ([trigger-ci for additional test/nightly runs](https://trigger-ci.dev.materialize.com/)) - [ ] This PR has an associated up-to-date [design doc](https://github.com/MaterializeInc/materialize/blob/main/doc/developer/design/README.md), is a design doc ([template](https://github.com/MaterializeInc/materialize/blob/main/doc/developer/design/00000000_template.md)), or is sufficiently small to not require a design. - [ ] If this PR evolves [an existing `$T ⇔ Proto$T` mapping](https://github.com/MaterializeInc/materialize/blob/main/doc/developer/command-and-response-binary-encoding.md) (possibly in a backwards-incompatible way), then it is tagged with a `T-proto` label. - [ ] If this PR will require changes to cloud orchestration or tests, there is a companion cloud PR to account for those changes that is tagged with the release-blocker label ([example](https://github.com/MaterializeInc/cloud/pull/5021)). - [ ] If this PR includes major [user-facing behavior changes](https://github.com/MaterializeInc/materialize/blob/main/doc/developer/guide-changes.md#what-changes-require-a-release-note), I have pinged the relevant PM to schedule a changelog post. --- src/adapter/src/catalog/apply.rs | 58 +- src/adapter/src/catalog/consistency.rs | 24 +- src/adapter/src/catalog/migrate.rs | 11 +- src/adapter/src/catalog/open.rs | 13 +- .../catalog/open/builtin_item_migration.rs | 3 +- src/adapter/src/catalog/state.rs | 29 +- src/buf.yaml | 2 + src/catalog/build.rs | 1 + src/catalog/protos/hashes.json | 6 +- src/catalog/protos/objects.proto | 63 +- src/catalog/protos/objects_v68.proto | 984 ++++++++++++++++++ src/catalog/src/durable/objects.rs | 122 ++- .../src/durable/objects/serialization.rs | 149 ++- src/catalog/src/durable/transaction.rs | 77 +- src/catalog/src/durable/upgrade.rs | 6 +- .../durable/upgrade/snapshots/objects_v68.txt | 100 ++ src/catalog/src/durable/upgrade/v67_to_v68.rs | 311 ++++++ src/catalog/src/memory/objects.rs | 7 +- src/catalog/tests/read-write.rs | 14 +- src/repr/src/catalog_item_id.rs | 13 + src/repr/src/global_id.rs | 14 + src/repr/src/relation.rs | 33 +- src/sql/src/names.rs | 53 +- src/sql/src/plan/statement/ddl.rs | 48 +- 24 files changed, 1940 insertions(+), 201 deletions(-) create mode 100644 src/catalog/protos/objects_v68.proto create mode 100644 src/catalog/src/durable/upgrade/snapshots/objects_v68.txt create mode 100644 src/catalog/src/durable/upgrade/v67_to_v68.rs diff --git a/src/adapter/src/catalog/apply.rs b/src/adapter/src/catalog/apply.rs index 04a82303557f0..9c84f1d1b925c 100644 --- a/src/adapter/src/catalog/apply.rs +++ b/src/adapter/src/catalog/apply.rs @@ -516,7 +516,7 @@ impl CatalogState { diff: StateDiff, retractions: &mut InProgressRetractions, ) { - let id = system_object_mapping.unique_identifier.id; + let id = system_object_mapping.unique_identifier.global_id; if system_object_mapping.unique_identifier.runtime_alterable() { // Runtime-alterable system objects have real entries in the items @@ -871,13 +871,15 @@ impl CatalogState { StateDiff::Addition => { let key = item.key(); let mz_catalog::durable::Item { - id, + id: _, oid, schema_id, name, create_sql, owner_id, privileges, + global_id, + extra_versions: _, } = item; let schema = self.find_non_temp_schema(&schema_id); let name = QualifiedItemName { @@ -889,18 +891,23 @@ impl CatalogState { }; let entry = match retractions.items.remove(&key) { Some(mut retraction) => { - assert_eq!(retraction.id, item.id); + // TODO(alter_table): Switch this to CatalogItemId. + assert_eq!(retraction.id, item.global_id); // We only reparse the SQL if it's changed. Otherwise, we use the existing // item. This is a performance optimization and not needed for correctness. // This makes it difficult to use the `UpdateFrom` trait, but the structure // is still the same as the trait. + // + // TODO(alter_table): Switch this to CatalogItemId. if retraction.create_sql() != create_sql { - let item = self.deserialize_item(id, &create_sql).unwrap_or_else(|e| { - panic!("{e:?}: invalid persisted SQL: {create_sql}") - }); + let item = self + .deserialize_item(global_id, &create_sql) + .unwrap_or_else(|e| { + panic!("{e:?}: invalid persisted SQL: {create_sql}") + }); retraction.item = item; } - retraction.id = id; + retraction.id = global_id; retraction.oid = oid; retraction.name = name; retraction.owner_id = owner_id; @@ -909,15 +916,17 @@ impl CatalogState { retraction } None => { - let catalog_item = - self.deserialize_item(id, &create_sql).unwrap_or_else(|e| { + // TODO(alter_table): Switch this to CatalogItemId. + let catalog_item = self + .deserialize_item(global_id, &create_sql) + .unwrap_or_else(|e| { panic!("{e:?}: invalid persisted SQL: {create_sql}") }); CatalogEntry { item: catalog_item, referenced_by: Vec::new(), used_by: Vec::new(), - id, + id: global_id, oid, name, owner_id, @@ -939,7 +948,8 @@ impl CatalogState { self.insert_entry(entry); } StateDiff::Retraction => { - let entry = self.drop_item(item.id); + // TODO(alter_table): Switch this to CatalogItemId. + let entry = self.drop_item(item.global_id); let key = item.into_key_value().0; retractions.items.insert(key, entry); } @@ -990,16 +1000,19 @@ impl CatalogState { ) { match diff { StateDiff::Addition => { - let prev = self - .source_references - .insert(source_references.source_id, source_references.into()); + let prev = self.source_references.insert( + source_references.source_id.to_global_id(), + source_references.into(), + ); assert!( prev.is_none(), "values must be explicitly retracted before inserting a new value: {prev:?}" ); } StateDiff::Retraction => { - let prev = self.source_references.remove(&source_references.source_id); + let prev = self + .source_references + .remove(&source_references.source_id.to_global_id()); assert!( prev.is_some(), "retraction for a non-existent existing value: {source_references:?}" @@ -1121,13 +1134,13 @@ impl CatalogState { // items collection and so get handled through the normal // `StateUpdateKind::Item`.` if !system_object_mapping.unique_identifier.runtime_alterable() { - self.pack_item_update(system_object_mapping.unique_identifier.id, diff) + self.pack_item_update(system_object_mapping.unique_identifier.global_id, diff) } else { vec![] } } StateUpdateKind::TemporaryItem(item) => self.pack_item_update(item.id, diff), - StateUpdateKind::Item(item) => self.pack_item_update(item.id, diff), + StateUpdateKind::Item(item) => self.pack_item_update(item.global_id, diff), StateUpdateKind::Comment(comment) => vec![self.pack_comment_update( comment.object_id, comment.sub_component, @@ -1720,7 +1733,8 @@ fn sort_updates_inner(updates: Vec) -> Vec { if item.create_sql.starts_with("CREATE SINK") { GlobalId::User(u64::MAX) } else { - item.id + // TODO(alter_table): Switch this to CatalogItemId. + item.global_id } }) .collect() @@ -1757,14 +1771,16 @@ fn sort_updates_inner(updates: Vec) -> Vec { while let (Some((item, _, _)), Some((temp_item, _, _))) = (item_updates.front(), temp_item_updates.front()) { - if item.id < temp_item.id { + // TODO(alter_table): Switch this to CatalogItemId. + if item.global_id < temp_item.id { let (item, ts, diff) = item_updates.pop_front().expect("non-empty"); state_updates.push(StateUpdate { kind: StateUpdateKind::Item(item), ts, diff, }); - } else if item.id > temp_item.id { + // TODO(alter_table): Switch this to CatalogItemId. + } else if item.global_id > temp_item.id { let (temp_item, ts, diff) = temp_item_updates.pop_front().expect("non-empty"); state_updates.push(StateUpdate { kind: StateUpdateKind::TemporaryItem(temp_item), @@ -2009,5 +2025,5 @@ fn lookup_builtin_view_addition( let (_, builtin) = BUILTIN_LOOKUP .get(&system_object_mapping.description) .expect("missing builtin view"); - (*builtin, system_object_mapping.unique_identifier.id) + (*builtin, system_object_mapping.unique_identifier.global_id) } diff --git a/src/adapter/src/catalog/consistency.rs b/src/adapter/src/catalog/consistency.rs index eb6f3a89520ac..97828303832f0 100644 --- a/src/adapter/src/catalog/consistency.rs +++ b/src/adapter/src/catalog/consistency.rs @@ -234,18 +234,18 @@ impl CatalogState { let mut comment_inconsistencies = Vec::new(); for (comment_object_id, col_pos, _comment) in self.comments.iter() { match comment_object_id { - CommentObjectId::Table(global_id) - | CommentObjectId::View(global_id) - | CommentObjectId::MaterializedView(global_id) - | CommentObjectId::Source(global_id) - | CommentObjectId::Sink(global_id) - | CommentObjectId::Index(global_id) - | CommentObjectId::Func(global_id) - | CommentObjectId::Connection(global_id) - | CommentObjectId::Type(global_id) - | CommentObjectId::Secret(global_id) - | CommentObjectId::ContinualTask(global_id) => { - let entry = self.entry_by_id.get(&global_id); + CommentObjectId::Table(item_id) + | CommentObjectId::View(item_id) + | CommentObjectId::MaterializedView(item_id) + | CommentObjectId::Source(item_id) + | CommentObjectId::Sink(item_id) + | CommentObjectId::Index(item_id) + | CommentObjectId::Func(item_id) + | CommentObjectId::Connection(item_id) + | CommentObjectId::Type(item_id) + | CommentObjectId::Secret(item_id) + | CommentObjectId::ContinualTask(item_id) => { + let entry = self.entry_by_id.get(&item_id.to_global_id()); match entry { None => comment_inconsistencies .push(CommentInconsistency::Dangling(comment_object_id)), diff --git a/src/adapter/src/catalog/migrate.rs b/src/adapter/src/catalog/migrate.rs index 51dfc557fa85c..7fc2dead8a47f 100644 --- a/src/adapter/src/catalog/migrate.rs +++ b/src/adapter/src/catalog/migrate.rs @@ -36,11 +36,12 @@ where for mut item in tx.get_items() { let mut stmt = mz_sql::parse::parse(&item.create_sql)?.into_element().ast; - f(tx, item.id, &mut stmt).await?; + // TODO(alter_table): Switch this to CatalogItemId. + f(tx, item.global_id, &mut stmt).await?; item.create_sql = stmt.to_ast_string_stable(); - updated_items.insert(item.id, item); + updated_items.insert(item.global_id, item); } tx.update_items(updated_items)?; Ok(()) @@ -63,12 +64,12 @@ where let items = tx.get_items(); for mut item in items { let mut stmt = mz_sql::parse::parse(&item.create_sql)?.into_element().ast; - - f(tx, &cat, item.id, &mut stmt).await?; + // TODO(alter_table): Switch this to CatalogItemId. + f(tx, &cat, item.global_id, &mut stmt).await?; item.create_sql = stmt.to_ast_string_stable(); - updated_items.insert(item.id, item); + updated_items.insert(item.global_id, item); } tx.update_items(updated_items)?; Ok(()) diff --git a/src/adapter/src/catalog/open.rs b/src/adapter/src/catalog/open.rs index f77851771d44b..6b7ef4ce67cda 100644 --- a/src/adapter/src/catalog/open.rs +++ b/src/adapter/src/catalog/open.rs @@ -664,7 +664,8 @@ impl Catalog { object_name: entry.name().item.clone(), }, unique_identifier: SystemObjectUniqueIdentifier { - id: new_id, + catalog_id: new_id.to_item_id(), + global_id: new_id, fingerprint: fingerprint.clone(), }, }, @@ -949,7 +950,7 @@ fn add_new_remove_old_builtin_items_migration( !builtin.runtime_alterable(), "setting the runtime alterable flag on an existing object is not permitted" ); - migrated_builtin_ids.push(system_object_mapping.unique_identifier.id); + migrated_builtin_ids.push(system_object_mapping.unique_identifier.global_id); } } @@ -961,7 +962,11 @@ fn add_new_remove_old_builtin_items_migration( object_type: builtin.catalog_item_type(), object_name: builtin.name().to_string(), }, - unique_identifier: SystemObjectUniqueIdentifier { id, fingerprint }, + unique_identifier: SystemObjectUniqueIdentifier { + catalog_id: id.to_item_id(), + global_id: id, + fingerprint, + }, }); // Runtime-alterable system objects are durably recorded to the @@ -1004,7 +1009,7 @@ fn add_new_remove_old_builtin_items_migration( for (_, mapping) in system_object_mappings { deleted_system_objects.insert(mapping.description); if mapping.unique_identifier.fingerprint == RUNTIME_ALTERABLE_FINGERPRINT_SENTINEL { - deleted_runtime_alterable_system_ids.insert(mapping.unique_identifier.id); + deleted_runtime_alterable_system_ids.insert(mapping.unique_identifier.global_id); } } // If you are 100% positive that it is safe to delete a system object outside any of the diff --git a/src/adapter/src/catalog/open/builtin_item_migration.rs b/src/adapter/src/catalog/open/builtin_item_migration.rs index fb0c014fe06d2..6f5d5594d98cb 100644 --- a/src/adapter/src/catalog/open/builtin_item_migration.rs +++ b/src/adapter/src/catalog/open/builtin_item_migration.rs @@ -211,7 +211,8 @@ async fn migrate_builtin_items_0dt( object_name: entry.name().item.clone(), }, unique_identifier: SystemObjectUniqueIdentifier { - id: *id, + catalog_id: id.to_item_id(), + global_id: *id, fingerprint: fingerprint.clone(), }, }, diff --git a/src/adapter/src/catalog/state.rs b/src/adapter/src/catalog/state.rs index cc7d281d59aa2..abb7949c1e3b3 100644 --- a/src/adapter/src/catalog/state.rs +++ b/src/adapter/src/catalog/state.rs @@ -1742,20 +1742,19 @@ impl CatalogState { match object_id { ObjectId::Item(global_id) => { let entry = self.get_entry(&global_id); + let item_id = global_id.to_item_id(); match entry.item_type() { - CatalogItemType::Table => CommentObjectId::Table(global_id), - CatalogItemType::Source => CommentObjectId::Source(global_id), - CatalogItemType::Sink => CommentObjectId::Sink(global_id), - CatalogItemType::View => CommentObjectId::View(global_id), - CatalogItemType::MaterializedView => { - CommentObjectId::MaterializedView(global_id) - } - CatalogItemType::Index => CommentObjectId::Index(global_id), - CatalogItemType::Func => CommentObjectId::Func(global_id), - CatalogItemType::Connection => CommentObjectId::Connection(global_id), - CatalogItemType::Type => CommentObjectId::Type(global_id), - CatalogItemType::Secret => CommentObjectId::Secret(global_id), - CatalogItemType::ContinualTask => CommentObjectId::ContinualTask(global_id), + CatalogItemType::Table => CommentObjectId::Table(item_id), + CatalogItemType::Source => CommentObjectId::Source(item_id), + CatalogItemType::Sink => CommentObjectId::Sink(item_id), + CatalogItemType::View => CommentObjectId::View(item_id), + CatalogItemType::MaterializedView => CommentObjectId::MaterializedView(item_id), + CatalogItemType::Index => CommentObjectId::Index(item_id), + CatalogItemType::Func => CommentObjectId::Func(item_id), + CatalogItemType::Connection => CommentObjectId::Connection(item_id), + CatalogItemType::Type => CommentObjectId::Type(item_id), + CatalogItemType::Secret => CommentObjectId::Secret(item_id), + CatalogItemType::ContinualTask => CommentObjectId::ContinualTask(item_id), } } ObjectId::Role(role_id) => CommentObjectId::Role(role_id), @@ -2135,7 +2134,7 @@ impl CatalogState { | CommentObjectId::Connection(id) | CommentObjectId::Type(id) | CommentObjectId::Secret(id) - | CommentObjectId::ContinualTask(id) => Some(*id), + | CommentObjectId::ContinualTask(id) => Some(id.to_global_id()), CommentObjectId::Role(_) | CommentObjectId::Database(_) | CommentObjectId::Schema(_) @@ -2165,7 +2164,7 @@ impl CatalogState { | CommentObjectId::Type(id) | CommentObjectId::Secret(id) | CommentObjectId::ContinualTask(id) => { - let item = self.get_entry(&id); + let item = self.get_entry(&id.to_global_id()); let name = self.resolve_full_name(item.name(), Some(conn_id)); name.to_string() } diff --git a/src/buf.yaml b/src/buf.yaml index 230dfc6ee9f8a..9bf13f00cba57 100644 --- a/src/buf.yaml +++ b/src/buf.yaml @@ -34,6 +34,8 @@ breaking: # reason: does currently not require backward-compatibility - catalog/protos/objects_v67.proto # reason: does currently not require backward-compatibility + - catalog/protos/objects_v68.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/build.rs b/src/catalog/build.rs index 717eb6039dc82..eac6ddaf5678f 100644 --- a/src/catalog/build.rs +++ b/src/catalog/build.rs @@ -148,6 +148,7 @@ fn main() -> anyhow::Result<()> { .enum_attribute("CatalogItem.value", ATTR) .enum_attribute("ClusterConfig.variant", ATTR) .enum_attribute("GlobalId.value", ATTR) + .enum_attribute("CatalogItemId.value", ATTR) .enum_attribute("ClusterId.value", ATTR) .enum_attribute("DatabaseId.value", ATTR) .enum_attribute("SchemaId.value", ATTR) diff --git a/src/catalog/protos/hashes.json b/src/catalog/protos/hashes.json index ea233c6b29eac..742c53e2cc273 100644 --- a/src/catalog/protos/hashes.json +++ b/src/catalog/protos/hashes.json @@ -1,7 +1,7 @@ [ { "name": "objects.proto", - "md5": "64474ac4b2cf2f9aca7a0d772c4548e6" + "md5": "b023c4e7ca71ae263d80a609dd586c72" }, { "name": "objects_v60.proto", @@ -34,5 +34,9 @@ { "name": "objects_v67.proto", "md5": "ce8acf8bc724dc3121e3014555f00250" + }, + { + "name": "objects_v68.proto", + "md5": "f9ae9b93103620bce86b07c0a35b9c6d" } ] diff --git a/src/catalog/protos/objects.proto b/src/catalog/protos/objects.proto index 1e38107fca93d..41bc20c4059d2 100644 --- a/src/catalog/protos/objects.proto +++ b/src/catalog/protos/objects.proto @@ -52,8 +52,12 @@ message GidMappingKey { } message GidMappingValue { + // TODO(parkmycar): Ideally this is a SystemCatalogItemId but making this change panics 0dt + // upgrades if there were new builtin objects added since the older version of Materialize + // doesn't know how to read the new SystemCatalogItemId type. uint64 id = 1; string fingerprint = 2; + SystemGlobalId global_id = 3; } message ClusterKey { @@ -74,8 +78,12 @@ message ClusterIntrospectionSourceIndexKey { } message ClusterIntrospectionSourceIndexValue { + // TODO(parkmycar): Ideally this is a SystemCatalogItemId but making this change panics 0dt + // upgrades if there were new builtin objects added since the older version of Materialize + // doesn't know how to read the new SystemCatalogItemId type. uint64 index_id = 1; uint32 oid = 2; + SystemGlobalId global_id = 3; } message ClusterReplicaKey { @@ -113,7 +121,7 @@ message SchemaValue { } message ItemKey { - GlobalId gid = 1; + CatalogItemId id = 1; } message ItemValue { @@ -123,6 +131,13 @@ message ItemValue { RoleId owner_id = 4; repeated MzAclItem privileges = 5; uint32 oid = 6; + GlobalId global_id = 7; + repeated ItemVersion extra_versions = 8; +} + +message ItemVersion { + GlobalId global_id = 1; + Version version = 2; } message RoleKey { @@ -153,17 +168,17 @@ message AuditLogKey { 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; - GlobalId continual_task = 17; + CatalogItemId table = 1; + CatalogItemId view = 2; + CatalogItemId materialized_view = 4; + CatalogItemId source = 5; + CatalogItemId sink = 6; + CatalogItemId index = 7; + CatalogItemId func = 8; + CatalogItemId connection = 9; + CatalogItemId type = 10; + CatalogItemId secret = 11; + CatalogItemId continual_task = 17; RoleId role = 12; DatabaseId database = 13; ResolvedSchema schema = 14; @@ -180,7 +195,7 @@ message CommentValue { } message SourceReferencesKey { - GlobalId source = 1; + CatalogItemId source = 1; } message SourceReferencesValue { @@ -245,6 +260,10 @@ message Timestamp { uint64 internal = 1; } +message Version { + uint64 value = 2; +} + enum CatalogItemType { CATALOG_ITEM_TYPE_UNKNOWN = 0; CATALOG_ITEM_TYPE_TABLE = 1; @@ -270,6 +289,19 @@ message CatalogItem { } } +message CatalogItemId { + oneof value { + uint64 system = 1; + uint64 user = 2; + uint64 transient = 3; + } +} + +/// A newtype wrapper for a `CatalogItemId` that is always in the "system" namespace. +message SystemCatalogItemId { + uint64 value = 1; +} + message GlobalId { oneof value { uint64 system = 1; @@ -279,6 +311,11 @@ message GlobalId { } } +/// A newtype wrapper for a `GlobalId` that is always in the "system" namespace. +message SystemGlobalId { + uint64 value = 1; +} + message ClusterId { oneof value { uint64 system = 1; diff --git a/src/catalog/protos/objects_v68.proto b/src/catalog/protos/objects_v68.proto new file mode 100644 index 0000000000000..44b249c12f69c --- /dev/null +++ b/src/catalog/protos/objects_v68.proto @@ -0,0 +1,984 @@ +// 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_v68; + +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 { + // TODO(parkmycar): Ideally this is a SystemCatalogItemId but making this change panics 0dt + // upgrades if there were new builtin objects added since the older version of Materialize + // doesn't know how to read the new SystemCatalogItemId type. + uint64 id = 1; + string fingerprint = 2; + SystemGlobalId global_id = 3; +} + +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 { + // TODO(parkmycar): Ideally this is a SystemCatalogItemId but making this change panics 0dt + // upgrades if there were new builtin objects added since the older version of Materialize + // doesn't know how to read the new SystemCatalogItemId type. + uint64 index_id = 1; + uint32 oid = 2; + SystemGlobalId global_id = 3; +} + +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 { + CatalogItemId id = 1; +} + +message ItemValue { + SchemaId schema_id = 1; + string name = 2; + CatalogItem definition = 3; + RoleId owner_id = 4; + repeated MzAclItem privileges = 5; + uint32 oid = 6; + GlobalId global_id = 7; + repeated ItemVersion extra_versions = 8; +} + +message ItemVersion { + GlobalId global_id = 1; + Version version = 2; +} + +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 { + CatalogItemId table = 1; + CatalogItemId view = 2; + CatalogItemId materialized_view = 4; + CatalogItemId source = 5; + CatalogItemId sink = 6; + CatalogItemId index = 7; + CatalogItemId func = 8; + CatalogItemId connection = 9; + CatalogItemId type = 10; + CatalogItemId secret = 11; + CatalogItemId continual_task = 17; + 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 { + CatalogItemId 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; +} + +message Version { + uint64 value = 2; +} + +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; + CATALOG_ITEM_TYPE_CONTINUAL_TASK = 11; +} + +message CatalogItem { + message V1 { + string create_sql = 1; + } + + oneof value { + V1 v1 = 1; + } +} + +message CatalogItemId { + oneof value { + uint64 system = 1; + uint64 user = 2; + uint64 transient = 3; + } +} + +/// A newtype wrapper for a `CatalogItemId` that is always in the "system" namespace. +message SystemCatalogItemId { + uint64 value = 1; +} + +message GlobalId { + oneof value { + uint64 system = 1; + uint64 user = 2; + uint64 transient = 3; + Empty explain = 4; + } +} + +/// A newtype wrapper for a `GlobalId` that is always in the "system" namespace. +message SystemGlobalId { + uint64 value = 1; +} + +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; + OBJECT_TYPE_CONTINUAL_TASK = 16; +} + +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; + OBJECT_TYPE_CONTINUAL_TASK = 17; + } + + 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 CreateSourceSinkV4 { + string id = 1; + StringWrapper cluster_id = 2; + FullNameV1 name = 3; + string external_type = 4; + } + + message CreateIndexV1 { + string id = 1; + string cluster_id = 2; + FullNameV1 name = 3; + } + + message CreateMaterializedViewV1 { + string id = 1; + string cluster_id = 2; + FullNameV1 name = 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: 40 + 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; + CreateSourceSinkV4 create_source_sink_v4 = 38; + CreateIndexV1 create_index_v1 = 39; + CreateMaterializedViewV1 create_materialized_view_v1 = 40; + } +} + +// Wrapper of key-values used by the persist implementation to serialize the catalog. +message StateUpdateKind { + reserved "Epoch"; + + 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 FenceToken { + uint64 deploy_generation = 1; + int64 epoch = 2; + } + + 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"; + reserved 8; + reserved "epoch"; + + 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; + 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; + FenceToken fence_token = 25; + } +} diff --git a/src/catalog/src/durable/objects.rs b/src/catalog/src/durable/objects.rs index 9f7503b2c7f66..0e56dc925bc7f 100644 --- a/src/catalog/src/durable/objects.rs +++ b/src/catalog/src/durable/objects.rs @@ -37,7 +37,7 @@ use mz_controller_types::{ClusterId, ReplicaId}; use mz_persist_types::ShardId; use mz_repr::adt::mz_acl_item::{AclMode, MzAclItem}; use mz_repr::role_id::RoleId; -use mz_repr::GlobalId; +use mz_repr::{CatalogItemId, GlobalId, RelationVersion}; use mz_sql::catalog::{ CatalogItemType, DefaultPrivilegeAclItem, DefaultPrivilegeObject, ObjectType, RoleAttributes, RoleMembership, RoleVars, @@ -275,6 +275,7 @@ pub struct ClusterVariantManaged { pub struct IntrospectionSourceIndex { pub cluster_id: ClusterId, pub name: String, + pub item_id: CatalogItemId, pub index_id: GlobalId, pub oid: u32, } @@ -284,25 +285,20 @@ impl DurableType for IntrospectionSourceIndex { type Value = ClusterIntrospectionSourceIndexValue; fn into_key_value(self) -> (Self::Key, Self::Value) { - let index_id = match self.index_id { - GlobalId::System(id) => id, - GlobalId::User(_) => { - unreachable!("cluster introspection source index mapping cannot use a User ID") - } - GlobalId::Transient(_) => { - unreachable!("cluster introspection source index mapping cannot use a Transient ID") - } - GlobalId::Explain => { - unreachable!("cluster introspection source index mapping cannot use an Explain ID") - } - }; ( ClusterIntrospectionSourceIndexKey { cluster_id: self.cluster_id, name: self.name, }, ClusterIntrospectionSourceIndexValue { - index_id, + catalog_id: self + .item_id + .try_into() + .expect("cluster introspection source index mapping must be a System ID"), + global_id: self + .index_id + .try_into() + .expect("cluster introspection source index mapping must be a System ID"), oid: self.oid, }, ) @@ -312,7 +308,8 @@ impl DurableType for IntrospectionSourceIndex { Self { cluster_id: key.cluster_id, name: key.name, - index_id: GlobalId::System(value.index_id), + item_id: value.catalog_id.into(), + index_id: value.global_id.into(), oid: value.oid, } } @@ -457,13 +454,15 @@ impl From for ReplicaLocation { #[derive(Debug, Clone, Ord, PartialOrd, PartialEq, Eq)] pub struct Item { - pub id: GlobalId, + pub id: CatalogItemId, pub oid: u32, + pub global_id: GlobalId, pub schema_id: SchemaId, pub name: String, pub create_sql: String, pub owner_id: RoleId, pub privileges: Vec, + pub extra_versions: BTreeMap, } impl DurableType for Item { @@ -472,38 +471,42 @@ impl DurableType for Item { fn into_key_value(self) -> (Self::Key, Self::Value) { ( - ItemKey { gid: self.id }, + ItemKey { id: self.id }, ItemValue { oid: self.oid, + global_id: self.global_id, schema_id: self.schema_id, name: self.name, create_sql: self.create_sql, owner_id: self.owner_id, privileges: self.privileges, + extra_versions: self.extra_versions, }, ) } fn from_key_value(key: Self::Key, value: Self::Value) -> Self { Self { - id: key.gid, + id: key.id, oid: value.oid, + global_id: value.global_id, schema_id: value.schema_id, name: value.name, create_sql: value.create_sql, owner_id: value.owner_id, privileges: value.privileges, + extra_versions: value.extra_versions, } } fn key(&self) -> Self::Key { - ItemKey { gid: self.id } + ItemKey { id: self.id } } } #[derive(Debug, Clone, Ord, PartialOrd, PartialEq, Eq)] pub struct SourceReferences { - pub source_id: GlobalId, + pub source_id: CatalogItemId, pub updated_at: u64, pub references: Vec, } @@ -546,6 +549,51 @@ impl DurableType for SourceReferences { } } +/// A newtype wrapper for [`CatalogItemId`] that is only for the "system" namespace. +#[derive(Debug, Copy, Clone, Ord, PartialOrd, PartialEq, Eq)] +pub struct SystemCatalogItemId(u64); + +impl TryFrom for SystemCatalogItemId { + type Error = &'static str; + + fn try_from(val: CatalogItemId) -> Result { + match val { + CatalogItemId::System(x) => Ok(SystemCatalogItemId(x)), + CatalogItemId::User(_) => Err("user"), + CatalogItemId::Transient(_) => Err("transient"), + } + } +} + +impl From for CatalogItemId { + fn from(val: SystemCatalogItemId) -> Self { + CatalogItemId::System(val.0) + } +} + +/// A newtype wrapper for [`GlobalId`] that is only for the "system" namespace. +#[derive(Debug, Copy, Clone, Ord, PartialOrd, PartialEq, Eq)] +pub struct SystemGlobalId(u64); + +impl TryFrom for SystemGlobalId { + type Error = &'static str; + + fn try_from(val: GlobalId) -> Result { + match val { + GlobalId::System(x) => Ok(SystemGlobalId(x)), + GlobalId::User(_) => Err("user"), + GlobalId::Transient(_) => Err("transient"), + GlobalId::Explain => Err("explain"), + } + } +} + +impl From for GlobalId { + fn from(val: SystemGlobalId) -> Self { + GlobalId::System(val.0) + } +} + #[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)] pub struct SystemObjectDescription { pub schema_name: String, @@ -555,7 +603,8 @@ pub struct SystemObjectDescription { #[derive(Debug, Clone, Ord, PartialOrd, PartialEq, Eq)] pub struct SystemObjectUniqueIdentifier { - pub id: GlobalId, + pub catalog_id: CatalogItemId, + pub global_id: GlobalId, pub fingerprint: String, } @@ -590,12 +639,16 @@ impl DurableType for SystemObjectMapping { object_name: self.description.object_name, }, GidMappingValue { - id: match self.unique_identifier.id { - GlobalId::System(id) => id, - GlobalId::User(_) => unreachable!("GID mapping cannot use a User ID"), - GlobalId::Transient(_) => unreachable!("GID mapping cannot use a Transient ID"), - GlobalId::Explain => unreachable!("GID mapping cannot use an Explain ID"), - }, + catalog_id: self + .unique_identifier + .catalog_id + .try_into() + .expect("catalog_id to be in the system namespace"), + global_id: self + .unique_identifier + .global_id + .try_into() + .expect("collection_id to be in the system namespace"), fingerprint: self.unique_identifier.fingerprint, }, ) @@ -609,7 +662,8 @@ impl DurableType for SystemObjectMapping { object_name: key.object_name, }, unique_identifier: SystemObjectUniqueIdentifier { - id: GlobalId::System(value.id), + catalog_id: value.catalog_id.into(), + global_id: value.global_id.into(), fingerprint: value.fingerprint, }, } @@ -1039,7 +1093,8 @@ pub struct GidMappingKey { #[derive(Debug, Clone, PartialOrd, PartialEq, Eq, Ord)] pub struct GidMappingValue { - pub(crate) id: u64, + pub(crate) catalog_id: SystemCatalogItemId, + pub(crate) global_id: SystemGlobalId, pub(crate) fingerprint: String, } @@ -1064,7 +1119,8 @@ pub struct ClusterIntrospectionSourceIndexKey { #[derive(Debug, Clone, PartialOrd, PartialEq, Eq, Ord)] pub struct ClusterIntrospectionSourceIndexValue { - pub(crate) index_id: u64, + pub(crate) catalog_id: SystemCatalogItemId, + pub(crate) global_id: SystemGlobalId, pub(crate) oid: u32, } @@ -1096,7 +1152,7 @@ pub struct DatabaseValue { #[derive(Clone, Copy, Debug, PartialOrd, PartialEq, Eq, Ord, Hash, Arbitrary)] pub struct SourceReferencesKey { - pub(crate) source_id: GlobalId, + pub(crate) source_id: CatalogItemId, } #[derive(Clone, Debug, PartialOrd, PartialEq, Eq, Ord, Arbitrary)] @@ -1121,7 +1177,7 @@ pub struct SchemaValue { #[derive(Clone, PartialOrd, PartialEq, Eq, Ord, Hash, Debug, Arbitrary)] pub struct ItemKey { - pub(crate) gid: GlobalId, + pub(crate) id: CatalogItemId, } #[derive(Clone, Debug, PartialOrd, PartialEq, Eq, Ord, Arbitrary)] @@ -1132,6 +1188,8 @@ pub struct ItemValue { pub(crate) owner_id: RoleId, pub(crate) privileges: Vec, pub(crate) oid: u32, + pub(crate) global_id: GlobalId, + pub(crate) extra_versions: BTreeMap, } impl ItemValue { diff --git a/src/catalog/src/durable/objects/serialization.rs b/src/catalog/src/durable/objects/serialization.rs index 991810857e6e5..c814011a9322b 100644 --- a/src/catalog/src/durable/objects/serialization.rs +++ b/src/catalog/src/durable/objects/serialization.rs @@ -9,6 +9,8 @@ //! This module is responsible for serializing catalog objects into Protobuf. +use std::time::Duration; + use mz_audit_log::{ AlterDefaultPrivilegeV1, AlterRetainHistoryV1, AlterSetClusterV1, AlterSourceSinkV1, CreateClusterReplicaV1, CreateClusterReplicaV2, CreateIndexV1, CreateMaterializedViewV1, @@ -26,7 +28,7 @@ use mz_ore::cast::CastFrom; use mz_proto::{IntoRustIfSome, ProtoMapEntry, ProtoType, RustType, TryFromProtoError}; use mz_repr::adt::mz_acl_item::{AclMode, MzAclItem}; use mz_repr::role_id::RoleId; -use mz_repr::{GlobalId, Timestamp}; +use mz_repr::{CatalogItemId, GlobalId, RelationVersion, Timestamp}; use mz_sql::catalog::{CatalogItemType, ObjectType, RoleAttributes, RoleMembership, RoleVars}; use mz_sql::names::{ CommentObjectId, DatabaseId, ResolvedDatabaseSpecifier, SchemaId, SchemaSpecifier, @@ -34,7 +36,6 @@ use mz_sql::names::{ use mz_sql::plan::ClusterSchedule; use mz_sql::session::vars::OwnedVarInput; use mz_storage_types::instances::StorageInstanceId; -use std::time::Duration; use crate::durable::objects::serialization::proto::{ cluster_schedule, ClusterScheduleRefreshOptions, Empty, @@ -48,7 +49,8 @@ use crate::durable::objects::{ ItemValue, RoleKey, RoleValue, SchemaKey, SchemaValue, ServerConfigurationKey, ServerConfigurationValue, SettingKey, SettingValue, SourceReference, SourceReferencesKey, SourceReferencesValue, StorageCollectionMetadataKey, StorageCollectionMetadataValue, - SystemPrivilegesKey, SystemPrivilegesValue, TxnWalShardValue, UnfinalizedShardKey, + SystemCatalogItemId, SystemGlobalId, SystemPrivilegesKey, SystemPrivilegesValue, + TxnWalShardValue, UnfinalizedShardKey, }; use crate::durable::{ ClusterConfig, ClusterVariant, ClusterVariantManaged, ReplicaConfig, ReplicaLocation, @@ -326,14 +328,18 @@ impl RustType for GidMappingKey { impl RustType for GidMappingValue { fn into_proto(&self) -> proto::GidMappingValue { proto::GidMappingValue { - id: self.id, + id: self.catalog_id.0, + global_id: Some(self.global_id.into_proto()), fingerprint: self.fingerprint.to_string(), } } fn from_proto(proto: proto::GidMappingValue) -> Result { Ok(GidMappingValue { - id: proto.id, + catalog_id: SystemCatalogItemId(proto.id), + global_id: proto + .global_id + .into_rust_if_some("GidMappingValue::global_id")?, fingerprint: proto.fingerprint, }) } @@ -398,7 +404,8 @@ impl RustType { fn into_proto(&self) -> proto::ClusterIntrospectionSourceIndexValue { proto::ClusterIntrospectionSourceIndexValue { - index_id: self.index_id, + index_id: self.catalog_id.0, + global_id: Some(self.global_id.into_proto()), oid: self.oid, } } @@ -407,7 +414,10 @@ impl RustType proto: proto::ClusterIntrospectionSourceIndexValue, ) -> Result { Ok(ClusterIntrospectionSourceIndexValue { - index_id: proto.index_id, + catalog_id: SystemCatalogItemId(proto.index_id), + global_id: proto + .global_id + .into_rust_if_some("ClusterIntrospectionSourceIndexValue::global_id")?, oid: proto.oid, }) } @@ -528,13 +538,13 @@ impl RustType for SchemaValue { impl RustType for ItemKey { fn into_proto(&self) -> proto::ItemKey { proto::ItemKey { - gid: Some(self.gid.into_proto()), + id: Some(self.id.into_proto()), } } fn from_proto(proto: proto::ItemKey) -> Result { Ok(ItemKey { - gid: proto.gid.into_rust_if_some("ItemKey::gid")?, + id: proto.id.into_rust_if_some("ItemKey::id")?, }) } } @@ -553,6 +563,15 @@ impl RustType for ItemValue { owner_id: Some(self.owner_id.into_proto()), privileges: self.privileges.into_proto(), oid: self.oid, + global_id: Some(self.global_id.into_proto()), + extra_versions: self + .extra_versions + .iter() + .map(|(version, global_id)| proto::ItemVersion { + global_id: Some(global_id.into_proto()), + version: Some(version.into_proto()), + }) + .collect(), } } @@ -565,6 +584,19 @@ impl RustType for ItemValue { let create_sql = match create_sql_value { proto::catalog_item::Value::V1(c) => c.create_sql, }; + let extra_versions = proto + .extra_versions + .into_iter() + .map(|item_version| { + let version = item_version + .version + .into_rust_if_some("ItemVersion::version")?; + let global_id = item_version + .global_id + .into_rust_if_some("ItemVersion::global_id")?; + Ok::<_, TryFromProtoError>((version, global_id)) + }) + .collect::>()?; Ok(ItemValue { schema_id: proto.schema_id.into_rust_if_some("ItemValue::schema_id")?, name: proto.name, @@ -572,10 +604,24 @@ impl RustType for ItemValue { owner_id: proto.owner_id.into_rust_if_some("ItemValue::owner_id")?, privileges: proto.privileges.into_rust()?, oid: proto.oid, + global_id: proto.global_id.into_rust_if_some("ItemValue::global_id")?, + extra_versions, }) } } +impl RustType for RelationVersion { + fn into_proto(&self) -> proto::Version { + proto::Version { + value: self.into_raw(), + } + } + + fn from_proto(proto: proto::Version) -> Result { + Ok(RelationVersion::from_raw(proto.value)) + } +} + impl RustType for CommentKey { fn into_proto(&self) -> proto::CommentKey { let sub_component = match &self.sub_component { @@ -1373,38 +1419,38 @@ impl RustType for CommentObjectId { fn from_proto(proto: proto::comment_key::Object) -> Result { let id = match proto { - proto::comment_key::Object::Table(global_id) => { - CommentObjectId::Table(global_id.into_rust()?) + proto::comment_key::Object::Table(item_id) => { + CommentObjectId::Table(item_id.into_rust()?) } - proto::comment_key::Object::View(global_id) => { - CommentObjectId::View(global_id.into_rust()?) + proto::comment_key::Object::View(item_id) => { + CommentObjectId::View(item_id.into_rust()?) } - proto::comment_key::Object::MaterializedView(global_id) => { - CommentObjectId::MaterializedView(global_id.into_rust()?) + proto::comment_key::Object::MaterializedView(item_id) => { + CommentObjectId::MaterializedView(item_id.into_rust()?) } - proto::comment_key::Object::Source(global_id) => { - CommentObjectId::Source(global_id.into_rust()?) + proto::comment_key::Object::Source(item_id) => { + CommentObjectId::Source(item_id.into_rust()?) } - proto::comment_key::Object::Sink(global_id) => { - CommentObjectId::Sink(global_id.into_rust()?) + proto::comment_key::Object::Sink(item_id) => { + CommentObjectId::Sink(item_id.into_rust()?) } - proto::comment_key::Object::Index(global_id) => { - CommentObjectId::Index(global_id.into_rust()?) + proto::comment_key::Object::Index(item_id) => { + CommentObjectId::Index(item_id.into_rust()?) } - proto::comment_key::Object::Func(global_id) => { - CommentObjectId::Func(global_id.into_rust()?) + proto::comment_key::Object::Func(item_id) => { + CommentObjectId::Func(item_id.into_rust()?) } - proto::comment_key::Object::Connection(global_id) => { - CommentObjectId::Connection(global_id.into_rust()?) + proto::comment_key::Object::Connection(item_id) => { + CommentObjectId::Connection(item_id.into_rust()?) } - proto::comment_key::Object::Type(global_id) => { - CommentObjectId::Type(global_id.into_rust()?) + proto::comment_key::Object::Type(item_id) => { + CommentObjectId::Type(item_id.into_rust()?) } - proto::comment_key::Object::Secret(global_id) => { - CommentObjectId::Secret(global_id.into_rust()?) + proto::comment_key::Object::Secret(item_id) => { + CommentObjectId::Secret(item_id.into_rust()?) } - proto::comment_key::Object::ContinualTask(global_id) => { - CommentObjectId::ContinualTask(global_id.into_rust()?) + proto::comment_key::Object::ContinualTask(item_id) => { + CommentObjectId::ContinualTask(item_id.into_rust()?) } proto::comment_key::Object::Role(role_id) => { CommentObjectId::Role(role_id.into_rust()?) @@ -1460,6 +1506,37 @@ impl RustType for Timestamp { } } +impl RustType for CatalogItemId { + fn into_proto(&self) -> proto::CatalogItemId { + proto::CatalogItemId { + value: Some(match self { + CatalogItemId::System(x) => proto::catalog_item_id::Value::System(*x), + CatalogItemId::User(x) => proto::catalog_item_id::Value::User(*x), + CatalogItemId::Transient(x) => proto::catalog_item_id::Value::Transient(*x), + }), + } + } + + fn from_proto(proto: proto::CatalogItemId) -> Result { + match proto.value { + Some(proto::catalog_item_id::Value::System(x)) => Ok(CatalogItemId::System(x)), + Some(proto::catalog_item_id::Value::User(x)) => Ok(CatalogItemId::User(x)), + Some(proto::catalog_item_id::Value::Transient(x)) => Ok(CatalogItemId::Transient(x)), + None => Err(TryFromProtoError::missing_field("CatalogItemId::kind")), + } + } +} + +impl RustType for SystemCatalogItemId { + fn into_proto(&self) -> proto::SystemCatalogItemId { + proto::SystemCatalogItemId { value: self.0 } + } + + fn from_proto(proto: proto::SystemCatalogItemId) -> Result { + Ok(SystemCatalogItemId(proto.value)) + } +} + impl RustType for GlobalId { fn into_proto(&self) -> proto::GlobalId { proto::GlobalId { @@ -1483,6 +1560,16 @@ impl RustType for GlobalId { } } +impl RustType for SystemGlobalId { + fn into_proto(&self) -> proto::SystemGlobalId { + proto::SystemGlobalId { value: self.0 } + } + + fn from_proto(proto: proto::SystemGlobalId) -> Result { + Ok(SystemGlobalId(proto.value)) + } +} + impl RustType for VersionedEvent { fn into_proto(&self) -> proto::audit_log_key::Event { match self { diff --git a/src/catalog/src/durable/transaction.rs b/src/catalog/src/durable/transaction.rs index 514c3935cc6f6..ec3ba7e31f186 100644 --- a/src/catalog/src/durable/transaction.rs +++ b/src/catalog/src/durable/transaction.rs @@ -183,7 +183,9 @@ impl<'a> Transaction<'a> { } pub fn get_item(&self, id: &GlobalId) -> Option { - let key = ItemKey { gid: *id }; + let key = ItemKey { + id: id.to_item_id(), + }; self.items .get(&key) .map(|v| DurableType::from_key_value(key, v.clone())) @@ -437,6 +439,7 @@ impl<'a> Transaction<'a> { let introspection_source_index = IntrospectionSourceIndex { cluster_id, name: builtin.name.to_string(), + item_id: index_id.to_item_id(), index_id, oid, }; @@ -567,6 +570,7 @@ impl<'a> Transaction<'a> { let introspection_source_index = IntrospectionSourceIndex { cluster_id, name, + item_id: index_id.to_item_id(), index_id, oid, }; @@ -614,7 +618,9 @@ impl<'a> Transaction<'a> { privileges: Vec, ) -> Result<(), CatalogError> { match self.items.insert( - ItemKey { gid: id }, + ItemKey { + id: id.to_item_id(), + }, ItemValue { schema_id, name: item_name.to_string(), @@ -622,6 +628,8 @@ impl<'a> Transaction<'a> { owner_id, privileges, oid, + global_id: id, + extra_versions: BTreeMap::new(), }, self.op_id, ) { @@ -939,7 +947,12 @@ impl<'a> Transaction<'a> { pub fn remove_source_references(&mut self, source_id: GlobalId) -> Result<(), CatalogError> { let deleted = self .source_references - .delete_by_key(SourceReferencesKey { source_id }, self.op_id) + .delete_by_key( + SourceReferencesKey { + source_id: source_id.to_item_id(), + }, + self.op_id, + ) .is_some(); if deleted { Ok(()) @@ -1089,7 +1102,13 @@ impl<'a> Transaction<'a> { /// Runtime is linear with respect to the total number of items in the catalog. /// DO NOT call this function in a loop, use [`Self::remove_items`] instead. pub fn remove_item(&mut self, id: GlobalId) -> Result<(), CatalogError> { - let prev = self.items.set(ItemKey { gid: id }, None, self.op_id)?; + let prev = self.items.set( + ItemKey { + id: id.to_item_id(), + }, + None, + self.op_id, + )?; if prev.is_some() { Ok(()) } else { @@ -1108,12 +1127,23 @@ impl<'a> Transaction<'a> { return Ok(()); } - let ks: Vec<_> = ids.clone().into_iter().map(|gid| ItemKey { gid }).collect(); + let ks: Vec<_> = ids + .clone() + .into_iter() + .map(|id| ItemKey { + id: id.to_item_id(), + }) + .collect(); let n = self.items.delete_by_keys(ks, self.op_id).len(); if n == ids.len() { Ok(()) } else { - let item_gids = self.items.items().keys().map(|k| k.gid).collect(); + let item_gids = self + .items + .items() + .keys() + .map(|k| k.id.to_global_id()) + .collect(); let mut unknown = ids.difference(&item_gids); Err(SqlCatalogError::UnknownItem(unknown.join(", ")).into()) } @@ -1213,9 +1243,13 @@ impl<'a> Transaction<'a> { /// Runtime is linear with respect to the total number of items in the catalog. /// DO NOT call this function in a loop, use [`Self::update_items`] instead. pub fn update_item(&mut self, id: GlobalId, item: Item) -> Result<(), CatalogError> { - let updated = - self.items - .update_by_key(ItemKey { gid: id }, item.into_key_value().1, self.op_id)?; + let updated = self.items.update_by_key( + ItemKey { + id: id.to_item_id(), + }, + item.into_key_value().1, + self.op_id, + )?; if updated { Ok(()) } else { @@ -1239,14 +1273,26 @@ impl<'a> Transaction<'a> { let kvs: Vec<_> = items .clone() .into_iter() - .map(|(gid, item)| (ItemKey { gid }, item.into_key_value().1)) + .map(|(id, item)| { + ( + ItemKey { + id: id.to_item_id(), + }, + item.into_key_value().1, + ) + }) .collect(); let n = self.items.update_by_keys(kvs, self.op_id)?; let n = usize::try_from(n).expect("Must be positive and fit in usize"); if n == update_ids.len() { Ok(()) } else { - let item_ids: BTreeSet<_> = self.items.items().keys().map(|k| k.gid).collect(); + let item_ids: BTreeSet<_> = self + .items + .items() + .keys() + .map(|k| k.id.to_global_id()) + .collect(); let mut unknown = update_ids.difference(&item_ids); Err(SqlCatalogError::UnknownItem(unknown.join(", ")).into()) } @@ -1313,7 +1359,7 @@ impl<'a> Transaction<'a> { let n = self.system_gid_mapping.update( |_k, v| { - if let Some(mapping) = mappings.get(&GlobalId::System(v.id)) { + if let Some(mapping) = mappings.get(&GlobalId::from(v.global_id)) { let (_, new_value) = mapping.clone().into_key_value(); Some(new_value) } else { @@ -1537,6 +1583,7 @@ impl<'a> Transaction<'a> { |((cluster_id, name, index_id), oid)| IntrospectionSourceIndex { cluster_id, name, + item_id: index_id.to_item_id(), index_id, oid, }, @@ -1717,7 +1764,9 @@ impl<'a> Transaction<'a> { references: Vec, updated_at: u64, ) -> Result<(), CatalogError> { - let key = SourceReferencesKey { source_id }; + let key = SourceReferencesKey { + source_id: source_id.to_item_id(), + }; let value = SourceReferencesValue { references, updated_at, @@ -1811,7 +1860,7 @@ impl<'a> Transaction<'a> { .items() .into_iter() .filter(|(k, _v)| k.cluster_id == cluster_id) - .map(|(k, v)| (k.name, (GlobalId::System(v.index_id), v.oid))) + .map(|(k, v)| (k.name, (v.global_id.into(), v.oid))) .collect() } diff --git a/src/catalog/src/durable/upgrade.rs b/src/catalog/src/durable/upgrade.rs index 81c00e34eb9a1..7971a712dad5a 100644 --- a/src/catalog/src/durable/upgrade.rs +++ b/src/catalog/src/durable/upgrade.rs @@ -181,14 +181,14 @@ macro_rules! objects { } } -objects!(v60, v61, v62, v63, v64, v65, v66, v67); +objects!(v60, v61, v62, v63, v64, v65, v66, v67, v68); /// 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 = 67; +pub const CATALOG_VERSION: u64 = 68; /// The minimum `Catalog` version number that we support migrating from. /// @@ -207,6 +207,7 @@ mod v63_to_v64; mod v64_to_v65; mod v65_to_v66; mod v66_to_v67; +mod v67_to_v68; /// Describes a single action to take during a migration from `V1` to `V2`. #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] @@ -292,6 +293,7 @@ async fn run_upgrade( 64 => run_versioned_upgrade(unopened_catalog_state, version, v64_to_v65::upgrade).await, 65 => run_versioned_upgrade(unopened_catalog_state, version, v65_to_v66::upgrade).await, 66 => run_versioned_upgrade(unopened_catalog_state, version, v66_to_v67::upgrade).await, + 67 => run_versioned_upgrade(unopened_catalog_state, version, v67_to_v68::upgrade).await, // Up-to-date, no migration needed! CATALOG_VERSION => Ok(CATALOG_VERSION), diff --git a/src/catalog/src/durable/upgrade/snapshots/objects_v68.txt b/src/catalog/src/durable/upgrade/snapshots/objects_v68.txt new file mode 100644 index 0000000000000..a2ca05378383d --- /dev/null +++ b/src/catalog/src/durable/upgrade/snapshots/objects_v68.txt @@ -0,0 +1,100 @@ +CiwKKroBJwoJCgNrZXkSAggEChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +CsIBCr8BugG7AQqkAQoDa2V5EpwBugGYAQqVAQoFZXZlbnQSiwG6AYcBCoQBCgJWMRJ+ugF7Cg0KB2RldGFpbHMSAggEChgKCmV2ZW50X3R5cGUSCsIBBwoFUSEjg1wKFgoCaWQSEMIBDQoLAVKQF5AWQyFyhowKGQoLb2JqZWN0X3R5cGUSCsIBBwoFcQghNIwKEQoLb2NjdXJyZWRfYXQSAggECgoKBHVzZXISAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +CncKdboBcgo2CgNrZXkSL7oBLAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwocCgV2YWx1ZRITugEQCg4KCGFjbF9tb2RlEgIIBA== +CjcKNboBMgoJCgNrZXkSAggEChgKBGtpbmQSEEIOQ2x1c3RlclJlcGxpY2EKCwoFdmFsdWUSAggE +CkgKRroBQwoJCgNrZXkSAggECikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleAoLCgV2YWx1ZRICCAQ= +CmUKY7oBYAo/CgNrZXkSOLoBNQozCgNrZXkSLEIq8JuwhPCfnL/vv5p7OidF8JuygdGoWD1y8J66hybhnITRqGPRqPCRtKM8ChAKBGtpbmQSCEIGQ29uZmlnCgsKBXZhbHVlEgIIBA== +ClwKWroBVwolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBR3cmU5d2GWBibAoYCgVlcG9jaBIPwgEMCgo1E5NHZpOJMGecChQKBGtpbmQSDEIKRmVuY2VUb2tlbg== +CkYKRLoBQQoiCgNrZXkSG7oBGAoWCgJpZBIQugENCgsKBXZhbHVlEgIIBAoOCgRraW5kEgZCBEl0ZW0KCwoFdmFsdWUSAggE +CrQBCrEBugGtAQpHCgNrZXkSQLoBPQo7CgRuYW1lEjNCMWDIusOD8J6AsPCRqYA/aXtrMnzwkJa4Ljzitqngpqrwlr+j8J2ZukXwn6KxMT3qmoAKEQoEa2luZBIJQgdTZXR0aW5nCk8KBXZhbHVlEka6AUMKQQoFdmFsdWUSOEI2WmDgtY5cJSciNi/vv70pe/CRu7d8762vPHvigpTwnY2w0agv4K2iYn3wkL+E77mC4KybPCI9 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 +CjkKN7oBNAoJCgNrZXkSAggEChoKBGtpbmQSEkIQU291cmNlUmVmZXJlbmNlcwoLCgV2YWx1ZRICCAQ= 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 +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +Cl4KXLoBWQorCgNrZXkSJLoBIQofCgRuYW1lEhdCFfCbhabwnoWB766eQfCQlpXwkbCBIQodCgRraW5kEhVCE1NlcnZlckNvbmZpZ3VyYXRpb24KCwoFdmFsdWUSAggE +CmcKZboBYgolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBJCJoAZBIg0YiLAojCgVlcG9jaBIawgEXCgoEWEclRIJFEkY9EP///////////wEKFAoEa2luZBIMQgpGZW5jZVRva2Vu +CmoKaLoBZQpECgNrZXkSPboBOgo4CgNrZXkSMUIvIFzhiqjIulIwJOCjmj4/UiMvZiThv6Pwn5W04bykIiV4Tkgm4Z+w4rWwdiLgoI8KEAoEa2luZBIIQgZDb25maWcKCwoFdmFsdWUSAggE +Ci8KLboBKgoJCgNrZXkSAggEChAKBGtpbmQSCEIGQ29uZmlnCgsKBXZhbHVlEgIIBA== +CmsKaboBZgpFCgNrZXkSProBOwo5CgNrZXkSMkIw8Jarg3vwnriD4L6b77+9eyXRqCPwkbWB4rSJPj3RqGLwn52QLyZ7KuGegTzhiox3ChAKBGtpbmQSCEIGQ29uZmlnCgsKBXZhbHVlEgIIBA== +Ci0KK7oBKAoJCgNrZXkSAggECg4KBGtpbmQSBkIEUm9sZQoLCgV2YWx1ZRICCAQ= +CpYBCpMBugGPAQpqCgNrZXkSY7oBYAotCgtvYmplY3RfbmFtZRIeQhw/WyXDne+ussKy8J+VtDLgqoFg8J+VtCRg4bOWChoKC29iamVjdF90eXBlEgvCAQgKBgFVZDEETQoTCgtzY2hlbWFfbmFtZRIEQgIgJAoUCgRraW5kEgxCCkdpZE1hcHBpbmcKCwoFdmFsdWUSAggE +CjkKN7oBNAoJCgNrZXkSAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwoLCgV2YWx1ZRICCAQ= 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 +CqwBCqkBugGlAQp6CgNrZXkSc7oBcAo1CgdncmFudGVlEiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKCmAShjlnBpJollwKNwoHZ3JhbnRvchIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCkdVRUk3kYAJV2wKGgoEa2luZBISQhBTeXN0ZW1Qcml2aWxlZ2VzCgsKBXZhbHVlEgIIBA== +CqgBCqUBugGhAQp1CgNrZXkSbroBawofCgtkYXRhYmFzZV9pZBIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudGVlEgIIBAoZCgtvYmplY3RfdHlwZRIKwgEHCgUTEoVIjAoNCgdyb2xlX2lkEgIIBAoPCglzY2hlbWFfaWQSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKCwoFdmFsdWUSAggE +CukBCuYBugHiAQqEAQoDa2V5En26AXoKHwoLZGF0YWJhc2VfaWQSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRlZRICCAQKGgoLb2JqZWN0X3R5cGUSC8IBCAoGAVFxWJY9Cg0KB3JvbGVfaWQSAggECh0KCXNjaGVtYV9pZBIQugENCgsKBXZhbHVlEgIIBAobCgRraW5kEhNCEURlZmF1bHRQcml2aWxlZ2VzCjwKBXZhbHVlEjO6ATAKLgoKcHJpdmlsZWdlcxIgugEdChsKCGJpdGZsYWdzEg/CAQwKCkcZAlSIlZGReHw= +CowBCokBugGFAQoJCgNrZXkSAggECikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleApNCgV2YWx1ZRJEugFBCg8KCWdsb2JhbF9pZBICCAQKGwoIaW5kZXhfaWQSD8IBDAoKA5VJgzOCkFVGHAoRCgNvaWQSCsIBBwoFOGCHJmw= +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwoLCgV2YWx1ZRICCAQ= +ClsKWboBVgokChFkZXBsb3lfZ2VuZXJhdGlvbhIPwgEMCgoBcIgnc1iFVyiMChgKBWVwb2NoEg/CAQwKCkMQEzlXRpNTdowKFAoEa2luZBIMQgpGZW5jZVRva2Vu +CkgKRroBQwoJCgNrZXkSAggECikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleAoLCgV2YWx1ZRICCAQ= +CpQBCpEBugGNAQpoCgNrZXkSYboBXgoYCgtvYmplY3RfbmFtZRIJQgfwlr6eYG4nCiQKC29iamVjdF90eXBlEhXCARIKBRRhM4d8EP///////////wEKHAoLc2NoZW1hX25hbWUSDUILwqXCpdGozpzivpwKFAoEa2luZBIMQgpHaWRNYXBwaW5nCgsKBXZhbHVlEgIIBA== +CmQKYroBXwoxCgNrZXkSKroBJwolCgRuYW1lEh1CGyrwnoCeIuGfpz3guqVgKOG9m3JWwqVp8JCosgodCgRraW5kEhVCE1NlcnZlckNvbmZpZ3VyYXRpb24KCwoFdmFsdWUSAggE +ClYKVLoBUQomCgNrZXkSH7oBHAoaCgZzb3VyY2USELoBDQoLCgV2YWx1ZRICCAQKGgoEa2luZBISQhBTb3VyY2VSZWZlcmVuY2VzCgsKBXZhbHVlEgIIBA== +CmsKaboBZgoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudApGCgV2YWx1ZRI9ugE6CjgKB2NvbW1lbnQSLUIrXE8mPfCeo4slc8K4LnvwkKKrIsi66qmTNOCstyTwnoCEdGk8YDot8JGwiw== +CoQBCoEBugF+CkEKA2tleRI6ugE3CjUKA2tleRIuQix+4am/IMKlQi978J+eoOGitkk2J8OK8J+VtHrCu+CqgT3itLUk4Ki+77+9PQoQCgRraW5kEghCBkNvbmZpZwonCgV2YWx1ZRIeugEbChkKBXZhbHVlEhDCAQ0KCwE1dXdoQwBWiCKc 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 +CooBCocBugGDAQpOCgNrZXkSR7oBRApCCgRuYW1lEjpCOOCysC86IXtgRCLwnZKm8JGKhsi68JGIkMOjb0/vv7088JC/o2okcyrgpbcyP+C7hvCRoKzwkby/ChEKBGtpbmQSCUIHU2V0dGluZwoeCgV2YWx1ZRIVugESChAKBXZhbHVlEgdCBVzhioxt +Ci0KK7oBKAoJCgNrZXkSAggECg4KBGtpbmQSBkIEUm9sZQoLCgV2YWx1ZRICCAQ= +CnYKdLoBcQpGCgNrZXkSP7oBPAo6CgZzb3VyY2USMLoBLQorCgV2YWx1ZRIiugEfCh0KCVRyYW5zaWVudBIQwgENCgsBAkcImUk2k4RYTAoaCgRraW5kEhJCEFNvdXJjZVJlZmVyZW5jZXMKCwoFdmFsdWUSAggE +CkgKRroBQwoJCgNrZXkSAggECikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleAoLCgV2YWx1ZRICCAQ= +Cq0eCqoeugGmHgoJCgNrZXkSAggECg4KBGtpbmQSBkIESXRlbQqIHgoFdmFsdWUS/h26AfodChAKCmRlZmluaXRpb24SAggECpYQCg5leHRyYV92ZXJzaW9ucxKDELIB/w8KI7oBIAoPCglnbG9iYWxfaWQSAggECg0KB3ZlcnNpb24SAggECiO6ASAKDwoJZ2xvYmFsX2lkEgIIBAoNCgd2ZXJzaW9uEgIIBApougFlCjkKCWdsb2JhbF9pZBIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCjRDSUlxMFE4BpwKKAoHdmVyc2lvbhIdugEaChgKBXZhbHVlEg/CAQwKCmQSdClEBZAFMFwKI7oBIAoPCglnbG9iYWxfaWQSAggECg0KB3ZlcnNpb24SAggECj+6ATwKDwoJZ2xvYmFsX2lkEgIIBAopCgd2ZXJzaW9uEh66ARsKGQoFdmFsdWUSEMIBDQoLASiVFzaUg4ZjgHwKUboBTgo9CglnbG9iYWxfaWQSMLoBLQorCgV2YWx1ZRIiugEfCh0KCVRyYW5zaWVudBIQwgENCgsBKDcplGJ3VZMJXAoNCgd2ZXJzaW9uEgIIBAoxugEuCh0KCWdsb2JhbF9pZBIQugENCgsKBXZhbHVlEgIIBAoNCgd2ZXJzaW9uEgIIBApNugFKCh0KCWdsb2JhbF9pZBIQugENCgsKBXZhbHVlEgIIBAopCgd2ZXJzaW9uEh66ARsKGQoFdmFsdWUSEMIBDQoLAUgwUVIIdjCJNBwKMboBLgodCglnbG9iYWxfaWQSELoBDQoLCgV2YWx1ZRICCAQKDQoHdmVyc2lvbhICCAQKTboBSgodCglnbG9iYWxfaWQSELoBDQoLCgV2YWx1ZRICCAQKKQoHdmVyc2lvbhIeugEbChkKBXZhbHVlEhDCAQ0KCwEkgVYIY2lgCGOcCj+6ATwKDwoJZ2xvYmFsX2lkEgIIBAopCgd2ZXJzaW9uEh66ARsKGQoFdmFsdWUSEMIBDQoLATViM0QTlDEEYYwKMboBLgodCglnbG9iYWxfaWQSELoBDQoLCgV2YWx1ZRICCAQKDQoHdmVyc2lvbhICCAQKI7oBIAoPCglnbG9iYWxfaWQSAggECg0KB3ZlcnNpb24SAggECnG6AW4KNwoJZ2xvYmFsX2lkEiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKClgzlkgzlANWaSwKMwoHdmVyc2lvbhIougElCiMKBXZhbHVlEhrCARcKCgZ4lRQnKGhjKEwQ////////////AQpCugE/Ci4KCWdsb2JhbF9pZBIhugEeChwKBXZhbHVlEhO6ARAKDgoHRXhwbGFpbhIDugEACg0KB3ZlcnNpb24SAggECiO6ASAKDwoJZ2xvYmFsX2lkEgIIBAoNCgd2ZXJzaW9uEgIIBAoxugEuCh0KCWdsb2JhbF9pZBIQugENCgsKBXZhbHVlEgIIBAoNCgd2ZXJzaW9uEgIIBApNugFKCjkKCWdsb2JhbF9pZBIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCgOSBXhFBGk5ICwKDQoHdmVyc2lvbhICCAQKSLoBRQoPCglnbG9iYWxfaWQSAggECjIKB3ZlcnNpb24SJ7oBJAoiCgV2YWx1ZRIZwgEWCgl5ACU5h2YXJmwQ////////////AQpOugFLCjoKCWdsb2JhbF9pZBItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwE4hIJFMYc2eUVMCg0KB3ZlcnNpb24SAggEClu6AVgKRwoJZ2xvYmFsX2lkEjq6ATcKNQoFdmFsdWUSLLoBKQonCglUcmFuc2llbnQSGsIBFwoKA1knGVklFnURLBD///////////8BCg0KB3ZlcnNpb24SAggECl66AVsKLgoJZ2xvYmFsX2lkEiG6AR4KHAoFdmFsdWUSE7oBEAoOCgdFeHBsYWluEgO6AQAKKQoHdmVyc2lvbhIeugEbChkKBXZhbHVlEhDCAQ0KCwEElFKRFWYHUAU8Ck26AUoKHQoJZ2xvYmFsX2lkEhC6AQ0KCwoFdmFsdWUSAggECikKB3ZlcnNpb24SHroBGwoZCgV2YWx1ZRIQwgENCgsBVIAJUGIYVmMVHApLugFICjcKCWdsb2JhbF9pZBIqugEnCiUKBXZhbHVlEhy6ARkKFwoEVXNlchIPwgEMCgoEQBQVAwc3RZRsCg0KB3ZlcnNpb24SAggECle6AVQKHQoJZ2xvYmFsX2lkEhC6AQ0KCwoFdmFsdWUSAggECjMKB3ZlcnNpb24SKLoBJQojCgV2YWx1ZRIawgEXCgoHGHCXAHcmMkRcEP///////////wEKI7oBIAoPCglnbG9iYWxfaWQSAggECg0KB3ZlcnNpb24SAggECjG6AS4KHQoJZ2xvYmFsX2lkEhC6AQ0KCwoFdmFsdWUSAggECg0KB3ZlcnNpb24SAggECl66AVsKLgoJZ2xvYmFsX2lkEiG6AR4KHAoFdmFsdWUSE7oBEAoOCgdFeHBsYWluEgO6AQAKKQoHdmVyc2lvbhIeugEbChkKBXZhbHVlEhDCAQ0KCwFTAmYkhpZVIQAsCmy6AWkKPQoJZ2xvYmFsX2lkEjC6AS0KKwoFdmFsdWUSIroBHwodCglUcmFuc2llbnQSEMIBDQoLATJWGCkUVDFRkXwKKAoHdmVyc2lvbhIdugEaChgKBXZhbHVlEg/CAQwKCmNXKWBgFDdZOTwKI7oBIAoPCglnbG9iYWxfaWQSAggECg0KB3ZlcnNpb24SAggECg8KCWdsb2JhbF9pZBICCAQKMgoEbmFtZRIqQijgq4vqp5HijJ5iPFLguoLtnr/DuS/wkY2nwqXgur0nNToh4Leyw4osChIKA29pZBILwgEICgYEFWNAQCwKLAoIb3duZXJfaWQSILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACosMCgpwcml2aWxlZ2VzEvwLsgH4CwquAboBqgEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoklgOEiAkUcGmcCjYKB2dyYW50ZWUSK7oBKAomCgV2YWx1ZRIdugEaChgKBFVzZXISEMIBDQoLASWZEzYjgzeDQRwKQgoHZ3JhbnRvchI3ugE0CjIKBXZhbHVlEim6ASYKJAoGU3lzdGVtEhrCARcKCgKUEpkZOXB2SXwQ////////////AQpNugFKCg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKbLoBaQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFYOIFZVmJiCTFMChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBApaugFXCjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKCHRSgzNUFJNQPBD///////////8BCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECk+6AUwKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqSd4ExIURRN3hMCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECk26AUoKDgoIYWNsX21vZGUSAggEChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAp7ugF4CiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKmVh5JndjFIVmLAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECisKB2dyYW50b3ISILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACl26AVoKDgoIYWNsX21vZGUSAggEChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKKwoHZ3JhbnRvchIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKpAG6AaABCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAYFJaZEYkHBjeFwKNwoHZ3JhbnRlZRIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKChYwiESFGWlyF5wKNgoHZ3JhbnRvchIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBIYYHEJiARROAnApdugFaCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKM4I5hmdlBUQmHAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECj+6ATwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKYLoBXQoOCghhY2xfbW9kZRICCAQKPAoHZ3JhbnRlZRIxugEuCiwKBXZhbHVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBSCVWCXhZlnOIjAoNCgdncmFudG9yEgIIBApuugFrCg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECjwKB2dyYW50b3ISMboBLgosCgV2YWx1ZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLASk5d4AnSZUUN5wKMboBLgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKOAoJc2NoZW1hX2lkEiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwFhSIZ4gwY3dhJ8 +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudAoLCgV2YWx1ZRICCAQ= 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 +Ck0KS7oBSAoUCgNrZXkSDboBCgoICgJpZBICCAQKIwoEa2luZBIbQhlTdG9yYWdlQ29sbGVjdGlvbk1ldGFkYXRhCgsKBXZhbHVlEgIIBA== +Cn8KfboBegoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudApaCgV2YWx1ZRJRugFOCkwKB2NvbW1lbnQSQUI/8JC6sDw68JuxlHYx8J+VtCXwnqWf6qWzNe+4hmBNZcO+8J+VtDDwnYGqLi/wkIyc4K6S8J64osKsXC9uPUpZ +CqYBCqMBugGfAQpECgNrZXkSPboBOgobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKGgoEa2luZBISQhBTeXN0ZW1Qcml2aWxlZ2VzCjsKBXZhbHVlEjK6AS8KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBhEOWUlRmZZiSnA== +CkYKRLoBQQoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwohCgV2YWx1ZRIYugEVChMKBXZhbHVlEgpCCPCRkZ4i4ruS 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 +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudAoLCgV2YWx1ZRICCAQ= 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 +CjIKMLoBLQoXCgNrZXkSELoBDQoLCgVldmVudBICCAQKEgoEa2luZBIKQghBdWRpdExvZw== +CpkBCpYBugGSAQpWCgNrZXkST7oBTAo7CgdncmFudGVlEjC6AS0KKwoFdmFsdWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCkaUUGdlMygDMRwKDQoHZ3JhbnRvchICCAQKGgoEa2luZBISQhBTeXN0ZW1Qcml2aWxlZ2VzChwKBXZhbHVlEhO6ARAKDgoIYWNsX21vZGUSAggE +CjMKMboBLgoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= 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 +CoMBCoABugF9ClsKA2tleRJUugFRCjoKBm9iamVjdBIwugEtCisKBlNjaGVtYRIhugEeCg4KCGRhdGFiYXNlEgIIBAoMCgZzY2hlbWESAggEChMKDXN1Yl9jb21wb25lbnQSAggEChEKBGtpbmQSCUIHQ29tbWVudAoLCgV2YWx1ZRICCAQ= +CkIKQLoBPQoUCgNrZXkSDboBCgoICgJpZBICCAQKGAoEa2luZBIQQg5DbHVzdGVyUmVwbGljYQoLCgV2YWx1ZRICCAQ= +CksKSboBRgoVCgRraW5kEg1CC1R4bldhbFNoYXJkCi0KBXZhbHVlEiS6ASEKHwoFc2hhcmQSFkIU8Jq/te+5sD1Lw5Y9762AKi5UYG0= +CjIKMLoBLQoXCgNrZXkSELoBDQoLCgVldmVudBICCAQKEgoEa2luZBIKQghBdWRpdExvZw== +CkoKSLoBRQoJCgNrZXkSAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwocCgV2YWx1ZRITugEQCg4KCGFjbF9tb2RlEgIIBA== +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +CikKJ7oBJAoVCgRraW5kEg1CC1R4bldhbFNoYXJkCgsKBXZhbHVlEgIIBA== +CnUKc7oBcApSCgNrZXkSS7oBSApGCgVzaGFyZBI9Qjsn0ahQ8J+AlzYkQ/Cjk7Mu8J65vuGnk1zwnrSyc8KgYfCfn7DCpVLwkbKw8JG/pnMr8J+bsntp8J65mQoaCgRraW5kEhJCEFVuZmluYWxpemVkU2hhcmQ= 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 +CnIKcLoBbQowCgNrZXkSKboBJgokCgNrZXkSHUIb8JGMlO+/vVB7eiou4Z2z4aSLKuCnl9Go4oObChAKBGtpbmQSCEIGQ29uZmlnCicKBXZhbHVlEh66ARsKGQoFdmFsdWUSEMIBDQoLAWBniZYokhAycGw= +CiwKKroBJwoJCgNrZXkSAggEChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +CjwKOroBNwoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgoLCgV2YWx1ZRICCAQ= +ClYKVLoBUQomCgNrZXkSH7oBHAoaCgZzb3VyY2USELoBDQoLCgV2YWx1ZRICCAQKGgoEa2luZBISQhBTb3VyY2VSZWZlcmVuY2VzCgsKBXZhbHVlEgIIBA== +CpgBCpUBugGRAQpVCgNrZXkSTroBSwpJCgNrZXkSQkJA77+mwrc9LCd6yLoi15/wq52kXPCRgo/Dg8i6Ly7wnbynQjwm8JC8nfCeublcJS8uKPCfobvitJph8JCWu+CuowoQCgRraW5kEghCBkNvbmZpZwomCgV2YWx1ZRIdugEaChgKBXZhbHVlEg/CAQwKCoCWFwN1IHc0UXw= +CikKJ7oBJAoVCgRraW5kEg1CC1R4bldhbFNoYXJkCgsKBXZhbHVlEgIIBA== +CjgKNroBMwoUCgNrZXkSDboBCgoICgJpZBICCAQKDgoEa2luZBIGQgRJdGVtCgsKBXZhbHVlEgIIBA== +CmUKY7oBYAouCgNrZXkSJ7oBJAoiCgRuYW1lEhpCGD/IuvCdopvgqI8n77+9359QyLo9LuKCtQoRCgRraW5kEglCB1NldHRpbmcKGwoFdmFsdWUSEroBDwoNCgV2YWx1ZRIEQgLRqA== +CoUBCoIBugF/Cl0KA2tleRJWugFTClEKBG5hbWUSSUJH4aWA8JGmpy3wn5W04KuHIlwk8JGFkTjwn5W0VPCRtLo6ffCbsoFc8JGnni/grpMvdjzwkYiR4YmNNvCQhpU98JGKgvCepZcKEQoEa2luZBIJQgdTZXR0aW5nCgsKBXZhbHVlEgIIBA== +CkgKRroBQwoJCgNrZXkSAggECikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleAoLCgV2YWx1ZRICCAQ= +CjoKOLoBNQoUCgNrZXkSDboBCgoICgJpZBICCAQKEAoEa2luZBIIQgZTY2hlbWEKCwoFdmFsdWUSAggE +CmAKXroBWwoJCgNrZXkSAggECiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQopCgV2YWx1ZRIgugEdChsKBXNoYXJkEhJCEC44KVlww6llP8KsTGnCpUg= +CqIBCp8BugGbAQpUCgNrZXkSTboBSgpICgRuYW1lEkBCPvCRjbF3WfCeuqnwn5W0J/CyjKXtn4VQPybwkIaU8JGkmzgm4qOEPjw/KuKClGjRqO+tgXtgJPCdkqZqInM8Ch0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgokCgV2YWx1ZRIbugEYChYKBXZhbHVlEg1CC/CbgLdLMvCQoLx8 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 +Ci8KLboBKgoJCgNrZXkSAggEChAKBGtpbmQSCEIGU2NoZW1hCgsKBXZhbHVlEgIIBA== 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 +CikKJ7oBJAoVCgRraW5kEg1CC1R4bldhbFNoYXJkCgsKBXZhbHVlEgIIBA== +ClwKWroBVwolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBIgBmRxZwaHWVHAoYCgVlcG9jaBIPwgEMCgpykDmCJUAHKHJMChQKBGtpbmQSDEIKRmVuY2VUb2tlbg== +CjMKMboBLgoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= +ClsKWboBVgokChFkZXBsb3lfZ2VuZXJhdGlvbhIPwgEMCgqWhTCWlxckY3FcChgKBWVwb2NoEg/CAQwKCjNJVDUlhiaRYmwKFAoEa2luZBIMQgpGZW5jZVRva2Vu +CnQKcroBbwpNCgNrZXkSRroBQwoMCgZvYmplY3QSAggECjMKDXN1Yl9jb21wb25lbnQSIroBHwodCglDb2x1bW5Qb3MSEMIBDQoLAVlHdHaSEThXCFwKEQoEa2luZBIJQgdDb21tZW50CgsKBXZhbHVlEgIIBA== +CnIKcLoBbQoxCgNrZXkSKroBJwolCgNrZXkSHkIcKci68JCuq1PwkbCFNyYn6qmqLkMi8JGMq9GoegoQCgRraW5kEghCBkNvbmZpZwomCgV2YWx1ZRIdugEaChgKBXZhbHVlEg/CAQwKChIXeJGWNkkWkzw= +ClUKU7oBUAovCgNrZXkSKLoBJQojCgNrZXkSHEIaw67wnoCkPTpj4rWv8JGMuColdFwvw5YlRFwKEAoEa2luZBIIQgZDb25maWcKCwoFdmFsdWUSAggE +CjkKN7oBNAoJCgNrZXkSAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwoLCgV2YWx1ZRICCAQ= +CjkKN7oBNAoJCgNrZXkSAggEChoKBGtpbmQSEkIQU291cmNlUmVmZXJlbmNlcwoLCgV2YWx1ZRICCAQ= +CkIKQLoBPQofCgNrZXkSGLoBFQoTCgVzaGFyZBIKQggq8J2VgdGodgoaCgRraW5kEhJCEFVuZmluYWxpemVkU2hhcmQ= +CjEKL7oBLAoJCgNrZXkSAggEChIKBGtpbmQSCkIIRGF0YWJhc2UKCwoFdmFsdWUSAggE +CikKJ7oBJAoVCgRraW5kEg1CC1R4bldhbFNoYXJkCgsKBXZhbHVlEgIIBA== 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 +CroBCrcBugGzAQqNAQoDa2V5EoUBugGBAQojCgtvYmplY3RfbmFtZRIUQhI/8JGysvCWrZZY4YyVyLo8wrkKGQoLb2JqZWN0X3R5cGUSCsIBBwoFYzgxA10KPwoLc2NoZW1hX25hbWUSMEIu4LqJJXvvv709PCJdOjw8L8KlPVomPPCWvoU28JCpqCIpUfCQqLBFXuS+uOGMrAoUCgRraW5kEgxCCkdpZE1hcHBpbmcKCwoFdmFsdWUSAggE +ClcKVboBUgowCgNrZXkSKboBJgokCgRuYW1lEhxCGiU/8J2UvvCfnqgiXPCRgovgqoNE8J+VtMOkChEKBGtpbmQSCUIHU2V0dGluZwoLCgV2YWx1ZRICCAQ= +Ck0KS7oBSAoUCgNrZXkSDboBCgoICgJpZBICCAQKIwoEa2luZBIbQhlTdG9yYWdlQ29sbGVjdGlvbk1ldGFkYXRhCgsKBXZhbHVlEgIIBA== +CmsKaboBZgosCgNrZXkSJboBIgoQCgpjbHVzdGVyX2lkEgIIBAoOCgRuYW1lEgZCBPCWqb0KKQoEa2luZBIhQh9DbHVzdGVySW50cm9zcGVjdGlvblNvdXJjZUluZGV4CgsKBXZhbHVlEgIIBA== +CkgKRroBQwoYCgNrZXkSEboBDgoMCgZzb3VyY2USAggEChoKBGtpbmQSEkIQU291cmNlUmVmZXJlbmNlcwoLCgV2YWx1ZRICCAQ= +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= diff --git a/src/catalog/src/durable/upgrade/v67_to_v68.rs b/src/catalog/src/durable/upgrade/v67_to_v68.rs new file mode 100644 index 0000000000000..2a097a6dcb1e1 --- /dev/null +++ b/src/catalog/src/durable/upgrade/v67_to_v68.rs @@ -0,0 +1,311 @@ +// 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 mz_proto::wire_compatible; +use mz_proto::wire_compatible::WireCompatible; + +use crate::durable::upgrade::MigrationAction; +use crate::durable::upgrade::{objects_v67 as v67, objects_v68 as v68}; + +wire_compatible!(v67::GlobalId with v68::GlobalId); +wire_compatible!(v67::CatalogItem with v68::CatalogItem); +wire_compatible!(v67::SchemaId with v68::SchemaId); +wire_compatible!(v67::CommentValue with v68::CommentValue); +wire_compatible!(v67::RoleId with v68::RoleId); +wire_compatible!(v67::MzAclItem with v68::MzAclItem); +wire_compatible!(v67::DatabaseId with v68::DatabaseId); +wire_compatible!(v67::ResolvedSchema with v68::ResolvedSchema); +wire_compatible!(v67::ClusterId with v68::ClusterId); +wire_compatible!(v67::ClusterReplicaId with v68::ClusterReplicaId); +wire_compatible!(v67::SourceReferencesValue with v68::SourceReferencesValue); +wire_compatible!(v67::GidMappingKey with v68::GidMappingKey); +wire_compatible!(v67::ClusterIntrospectionSourceIndexKey with v68::ClusterIntrospectionSourceIndexKey); + +/// In v68 we switched catalog items to be keyed on a `CatalogItemId`, this required a few changes: +/// +/// * `ItemKey` switched from containing a single `GlobalId` to a `CatalogItemId`. +/// * `ItemValue` added `global_id: GlobalId` and `extra_versions: BTreeMap` fields. +/// * `CommentKey` switched from using `GlobalId` to `CatalogItemId`. +/// * `SourceReferencesKey` switched from `GlobalId` to `CatalogItemId` +/// * `GidMappingValue` switched from using raw `uint64` for an id to newtype +/// `SystemCatalogItemId` and `SystemGlobalId` wrappers. +/// +/// All switches from `GlobalId` to `CatalogItemId` we re-use the inner value of the ID. +pub fn upgrade( + snapshot: Vec, +) -> Vec> { + snapshot + .iter() + .filter_map(|update| match &update.kind { + Some(v67::state_update_kind::Kind::Item(old_item)) => { + // ** MIGRATION ** + let new_item = v68::state_update_kind::Item::from(old_item.clone()); + + let old_item = v67::StateUpdateKind { + kind: Some(v67::state_update_kind::Kind::Item(old_item.clone())), + }; + let new_item = v68::StateUpdateKind { + kind: Some(v68::state_update_kind::Kind::Item(new_item)), + }; + + Some(MigrationAction::Update(old_item, new_item)) + } + Some(v67::state_update_kind::Kind::Comment(old_comment)) => { + // ** MIGRATION ** + let new_comment = v68::state_update_kind::Comment::from(old_comment.clone()); + + let old_comment = v67::StateUpdateKind { + kind: Some(v67::state_update_kind::Kind::Comment(old_comment.clone())), + }; + let new_comment = v68::StateUpdateKind { + kind: Some(v68::state_update_kind::Kind::Comment(new_comment.clone())), + }; + + Some(MigrationAction::Update(old_comment, new_comment)) + } + Some(v67::state_update_kind::Kind::SourceReferences(old_reference)) => { + // ** MIGRATION ** + let new_reference = + v68::state_update_kind::SourceReferences::from(old_reference.clone()); + + let old_reference = v67::StateUpdateKind { + kind: Some(v67::state_update_kind::Kind::SourceReferences( + old_reference.clone(), + )), + }; + let new_reference = v68::StateUpdateKind { + kind: Some(v68::state_update_kind::Kind::SourceReferences( + new_reference, + )), + }; + + Some(MigrationAction::Update(old_reference, new_reference)) + } + Some(v67::state_update_kind::Kind::GidMapping(old_mapping)) => { + let new_mapping = v68::state_update_kind::GidMapping { + key: old_mapping.key.as_ref().map(v68::GidMappingKey::convert), + // ** MIGRATION ** + value: old_mapping + .value + .as_ref() + .map(|old| v68::GidMappingValue::from(old.clone())), + }; + + let old_mapping = v67::StateUpdateKind { + kind: Some(v67::state_update_kind::Kind::GidMapping( + old_mapping.clone(), + )), + }; + let new_mapping = v68::StateUpdateKind { + kind: Some(v68::state_update_kind::Kind::GidMapping(new_mapping)), + }; + + Some(MigrationAction::Update(old_mapping, new_mapping)) + } + Some(v67::state_update_kind::Kind::ClusterIntrospectionSourceIndex(old_index)) => { + let new_index = v68::state_update_kind::ClusterIntrospectionSourceIndex { + key: old_index + .key + .as_ref() + .map(v68::ClusterIntrospectionSourceIndexKey::convert), + value: old_index + .value + .as_ref() + .map(|old| v68::ClusterIntrospectionSourceIndexValue::from(old.clone())), + }; + + let old_index = v67::StateUpdateKind { + kind: Some( + v67::state_update_kind::Kind::ClusterIntrospectionSourceIndex( + old_index.clone(), + ), + ), + }; + let new_index = v68::StateUpdateKind { + kind: Some( + v68::state_update_kind::Kind::ClusterIntrospectionSourceIndex(new_index), + ), + }; + + Some(MigrationAction::Update(old_index, new_index)) + } + _ => None, + }) + .collect() +} + +impl From for v68::state_update_kind::Item { + fn from(value: v67::state_update_kind::Item) -> Self { + let new_key = value.key.map(|k| v68::ItemKey { + id: k.gid.map(v68::CatalogItemId::from), + }); + let new_val = value.value.map(|val| v68::ItemValue { + global_id: value + .key + .as_ref() + .and_then(|k| k.gid) + .map(|gid| v68::GlobalId::convert(&gid)), + schema_id: val.schema_id.map(|id| v68::SchemaId::convert(&id)), + definition: val.definition.map(|def| v68::CatalogItem::convert(&def)), + name: val.name, + owner_id: val.owner_id.map(|id| v68::RoleId::convert(&id)), + privileges: val + .privileges + .into_iter() + .map(|item| v68::MzAclItem::convert(&item)) + .collect(), + oid: val.oid, + // Nothing supports extra versions yet, but with ALTER TABLE we will. + extra_versions: Vec::new(), + }); + + v68::state_update_kind::Item { + key: new_key, + value: new_val, + } + } +} + +impl From for v68::state_update_kind::Comment { + fn from(value: v67::state_update_kind::Comment) -> Self { + let new_key = value.key.map(|k| v68::CommentKey { + object: k.object.map(v68::comment_key::Object::from), + sub_component: k.sub_component.map(v68::comment_key::SubComponent::from), + }); + let new_val = value.value.map(|v| v68::CommentValue::convert(&v)); + + v68::state_update_kind::Comment { + key: new_key, + value: new_val, + } + } +} + +impl From for v68::comment_key::Object { + fn from(value: v67::comment_key::Object) -> Self { + match value { + v67::comment_key::Object::Table(global_id) => { + v68::comment_key::Object::Table(v68::CatalogItemId::from(global_id)) + } + v67::comment_key::Object::View(global_id) => { + v68::comment_key::Object::View(v68::CatalogItemId::from(global_id)) + } + v67::comment_key::Object::MaterializedView(global_id) => { + v68::comment_key::Object::MaterializedView(v68::CatalogItemId::from(global_id)) + } + v67::comment_key::Object::Source(global_id) => { + v68::comment_key::Object::Source(v68::CatalogItemId::from(global_id)) + } + v67::comment_key::Object::Sink(global_id) => { + v68::comment_key::Object::Sink(v68::CatalogItemId::from(global_id)) + } + v67::comment_key::Object::Index(global_id) => { + v68::comment_key::Object::Index(v68::CatalogItemId::from(global_id)) + } + v67::comment_key::Object::Func(global_id) => { + v68::comment_key::Object::Func(v68::CatalogItemId::from(global_id)) + } + v67::comment_key::Object::Connection(global_id) => { + v68::comment_key::Object::Connection(v68::CatalogItemId::from(global_id)) + } + v67::comment_key::Object::Type(global_id) => { + v68::comment_key::Object::Type(v68::CatalogItemId::from(global_id)) + } + v67::comment_key::Object::Secret(global_id) => { + v68::comment_key::Object::Secret(v68::CatalogItemId::from(global_id)) + } + v67::comment_key::Object::ContinualTask(global_id) => { + v68::comment_key::Object::ContinualTask(v68::CatalogItemId::from(global_id)) + } + v67::comment_key::Object::Role(role_id) => { + v68::comment_key::Object::Role(v68::RoleId::convert(&role_id)) + } + v67::comment_key::Object::Database(database_id) => { + v68::comment_key::Object::Database(v68::DatabaseId::convert(&database_id)) + } + v67::comment_key::Object::Schema(resolved_schema) => { + v68::comment_key::Object::Schema(v68::ResolvedSchema::convert(&resolved_schema)) + } + v67::comment_key::Object::Cluster(cluster_id) => { + v68::comment_key::Object::Cluster(v68::ClusterId::convert(&cluster_id)) + } + v67::comment_key::Object::ClusterReplica(cluster_replica_id) => { + v68::comment_key::Object::ClusterReplica(v68::ClusterReplicaId::convert( + &cluster_replica_id, + )) + } + } + } +} + +impl From for v68::comment_key::SubComponent { + fn from(value: v67::comment_key::SubComponent) -> Self { + match value { + v67::comment_key::SubComponent::ColumnPos(x) => { + v68::comment_key::SubComponent::ColumnPos(x) + } + } + } +} + +impl From for v68::CatalogItemId { + fn from(id: v67::GlobalId) -> Self { + let value = match id.value { + Some(v67::global_id::Value::System(x)) => Some(v68::catalog_item_id::Value::System(x)), + Some(v67::global_id::Value::User(x)) => Some(v68::catalog_item_id::Value::User(x)), + Some(v67::global_id::Value::Transient(x)) => { + Some(v68::catalog_item_id::Value::Transient(x)) + } + None => None, + Some(v67::global_id::Value::Explain(_)) => unreachable!("shouldn't persist Explain"), + }; + v68::CatalogItemId { value } + } +} + +impl From for v68::state_update_kind::SourceReferences { + fn from(old: v67::state_update_kind::SourceReferences) -> Self { + v68::state_update_kind::SourceReferences { + key: old.key.map(|old| old.into()), + value: old.value.map(|old| WireCompatible::convert(&old)), + } + } +} + +impl From for v68::SourceReferencesKey { + fn from(value: v67::SourceReferencesKey) -> Self { + let source = match value.source { + Some(gid) => Some(gid.into()), + None => None, + }; + v68::SourceReferencesKey { source } + } +} + +impl From for v68::GidMappingValue { + fn from(value: v67::GidMappingValue) -> Self { + v68::GidMappingValue { + id: value.id, + global_id: Some(v68::SystemGlobalId { value: value.id }), + fingerprint: value.fingerprint, + } + } +} + +impl From for v68::ClusterIntrospectionSourceIndexValue { + fn from(value: v67::ClusterIntrospectionSourceIndexValue) -> Self { + v68::ClusterIntrospectionSourceIndexValue { + index_id: value.index_id, + global_id: Some(v68::SystemGlobalId { + value: value.index_id, + }), + oid: value.oid, + } + } +} diff --git a/src/catalog/src/memory/objects.rs b/src/catalog/src/memory/objects.rs index 654f1d73d2107..3ee460782e3f9 100644 --- a/src/catalog/src/memory/objects.rs +++ b/src/catalog/src/memory/objects.rs @@ -511,7 +511,7 @@ impl From for durable::SourceReference { impl SourceReferences { pub fn to_durable(self, source_id: GlobalId) -> durable::SourceReferences { durable::SourceReferences { - source_id, + source_id: source_id.to_item_id(), updated_at: self.updated_at, references: self.references.into_iter().map(Into::into).collect(), } @@ -622,14 +622,17 @@ pub enum CatalogItem { impl From for durable::Item { fn from(entry: CatalogEntry) -> durable::Item { + let global_id = entry.id(); durable::Item { - id: entry.id, + id: global_id.to_item_id(), oid: entry.oid, schema_id: entry.name.qualifiers.schema_spec.into(), name: entry.name.item, create_sql: entry.item.into_serialized(), owner_id: entry.owner_id, privileges: entry.privileges.into_all_values().collect(), + global_id, + extra_versions: BTreeMap::new(), } } } diff --git a/src/catalog/tests/read-write.rs b/src/catalog/tests/read-write.rs index bb510b8d0a1b1..b003be1625dfa 100644 --- a/src/catalog/tests/read-write.rs +++ b/src/catalog/tests/read-write.rs @@ -7,6 +7,8 @@ // the Business Source License, use of this software will be governed // by the Apache License, Version 2.0. +use std::collections::BTreeMap; + use insta::assert_debug_snapshot; use itertools::Itertools; use mz_audit_log::{EventDetails, EventType, EventV1, IdNameV1, VersionedEvent}; @@ -22,7 +24,7 @@ use mz_ore::now::SYSTEM_TIME; use mz_persist_client::PersistClient; use mz_proto::RustType; use mz_repr::role_id::RoleId; -use mz_repr::GlobalId; +use mz_repr::{CatalogItemId, GlobalId}; use mz_sql::catalog::{RoleAttributes, RoleMembership, RoleVars}; use mz_sql::names::{DatabaseId, ResolvedDatabaseSpecifier, SchemaId}; @@ -199,22 +201,26 @@ async fn test_items(state_builder: TestCatalogStateBuilder) { let state_builder = state_builder.with_default_deploy_generation(); let items = [ Item { - id: GlobalId::User(100), + id: CatalogItemId::User(100), oid: 20_000, + global_id: GlobalId::User(100), schema_id: SchemaId::User(1), name: "foo".to_string(), create_sql: "CREATE VIEW v AS SELECT 1".to_string(), owner_id: RoleId::User(1), privileges: vec![], + extra_versions: BTreeMap::new(), }, Item { - id: GlobalId::User(200), + id: CatalogItemId::User(200), oid: 20_001, + global_id: GlobalId::User(200), schema_id: SchemaId::User(1), name: "bar".to_string(), create_sql: "CREATE MATERIALIZED VIEW mv AS SELECT 2".to_string(), owner_id: RoleId::User(2), privileges: vec![], + extra_versions: BTreeMap::new(), }, ]; @@ -232,7 +238,7 @@ async fn test_items(state_builder: TestCatalogStateBuilder) { let mut txn = state.transaction().await.unwrap(); for item in &items { txn.insert_item( - item.id, + item.global_id, item.oid, item.schema_id, &item.name, diff --git a/src/repr/src/catalog_item_id.rs b/src/repr/src/catalog_item_id.rs index 28012c8f8d1be..562ffb3e2edc8 100644 --- a/src/repr/src/catalog_item_id.rs +++ b/src/repr/src/catalog_item_id.rs @@ -16,6 +16,8 @@ use mz_proto::{RustType, TryFromProtoError}; use proptest_derive::Arbitrary; use serde::{Deserialize, Serialize}; +use crate::GlobalId; + include!(concat!(env!("OUT_DIR"), "/mz_repr.catalog_item_id.rs")); /// The identifier for an item within the Catalog. @@ -57,6 +59,17 @@ impl CatalogItemId { pub fn is_transient(&self) -> bool { matches!(self, CatalogItemId::Transient(_)) } + + /// Converts a [`CatalogItemId`] to a [`GlobalId`]. + /// + /// TODO(alter_table): Remove this method. + pub fn to_global_id(&self) -> GlobalId { + match self { + CatalogItemId::User(x) => GlobalId::User(*x), + CatalogItemId::System(x) => GlobalId::System(*x), + CatalogItemId::Transient(x) => GlobalId::Transient(*x), + } + } } impl FromStr for CatalogItemId { diff --git a/src/repr/src/global_id.rs b/src/repr/src/global_id.rs index 12dc3a44b0a4f..b71984f474b56 100644 --- a/src/repr/src/global_id.rs +++ b/src/repr/src/global_id.rs @@ -18,6 +18,8 @@ use mz_proto::{RustType, TryFromProtoError}; use proptest_derive::Arbitrary; use serde::{Deserialize, Serialize}; +use crate::CatalogItemId; + include!(concat!(env!("OUT_DIR"), "/mz_repr.global_id.rs")); /// The identifier for an item/object. @@ -75,6 +77,18 @@ impl GlobalId { pub fn is_transient(&self) -> bool { matches!(self, GlobalId::Transient(_)) } + + /// Converts a [`GlobalId`] to a [`CatalogItemId`]. + /// + /// TODO(alter_table): Remove this method. + pub fn to_item_id(&self) -> CatalogItemId { + match self { + GlobalId::User(x) => CatalogItemId::User(*x), + GlobalId::System(x) => CatalogItemId::System(*x), + GlobalId::Transient(x) => CatalogItemId::Transient(*x), + GlobalId::Explain => panic!("'Explain' IDs cannot be stored in the Catalog"), + } + } } impl FromStr for GlobalId { diff --git a/src/repr/src/relation.rs b/src/repr/src/relation.rs index 7f58ff1d3c56e..3d8b679312233 100644 --- a/src/repr/src/relation.rs +++ b/src/repr/src/relation.rs @@ -369,7 +369,18 @@ static_assertions::assert_not_impl_all!(ColumnIndex: Arbitrary); /// The version a given column was added at. #[derive( - Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize, Hash, MzReflect, + Clone, + Copy, + Debug, + Eq, + PartialEq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Hash, + MzReflect, + Arbitrary, )] pub struct RelationVersion(u64); @@ -387,6 +398,26 @@ impl RelationVersion { .expect("added more than u64::MAX columns?"); RelationVersion(next_version) } + + /// Consume a [`RelationVersion`] returning the raw value. + /// + /// Should __only__ be used for serialization. + pub fn into_raw(self) -> u64 { + self.0 + } + + /// Create a [`RelationVersion`] from a raw value. + /// + /// Should __only__ be used for serialization. + pub fn from_raw(val: u64) -> RelationVersion { + RelationVersion(val) + } +} + +impl fmt::Display for RelationVersion { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "v{}", self.0) + } } impl From for mz_sql_parser::ast::Version { diff --git a/src/sql/src/names.rs b/src/sql/src/names.rs index b8de3440e223e..e5b7e30d5b765 100644 --- a/src/sql/src/names.rs +++ b/src/sql/src/names.rs @@ -21,7 +21,7 @@ use mz_ore::assert_none; use mz_ore::cast::CastFrom; use mz_ore::str::StrExt; use mz_repr::role_id::RoleId; -use mz_repr::GlobalId; +use mz_repr::{CatalogItemId, GlobalId}; use mz_repr::{ColumnName, RelationVersionSelector}; use mz_sql_parser::ast::{CreateContinualTaskStatement, Expr, Version}; use mz_sql_parser::ident; @@ -1137,17 +1137,17 @@ impl From<&GlobalId> for ObjectId { impl From for ObjectId { fn from(id: CommentObjectId) -> Self { match id { - CommentObjectId::Table(global_id) - | CommentObjectId::View(global_id) - | CommentObjectId::MaterializedView(global_id) - | CommentObjectId::Source(global_id) - | CommentObjectId::Sink(global_id) - | CommentObjectId::Index(global_id) - | CommentObjectId::Func(global_id) - | CommentObjectId::Connection(global_id) - | CommentObjectId::Type(global_id) - | CommentObjectId::Secret(global_id) - | CommentObjectId::ContinualTask(global_id) => ObjectId::Item(global_id), + CommentObjectId::Table(item_id) + | CommentObjectId::View(item_id) + | CommentObjectId::MaterializedView(item_id) + | CommentObjectId::Source(item_id) + | CommentObjectId::Sink(item_id) + | CommentObjectId::Index(item_id) + | CommentObjectId::Func(item_id) + | CommentObjectId::Connection(item_id) + | CommentObjectId::Type(item_id) + | CommentObjectId::Secret(item_id) + | CommentObjectId::ContinualTask(item_id) => ObjectId::Item(item_id.to_global_id()), CommentObjectId::Role(id) => ObjectId::Role(id), CommentObjectId::Database(id) => ObjectId::Database(id), CommentObjectId::Schema(id) => ObjectId::Schema(id), @@ -1185,22 +1185,23 @@ impl From for SystemObjectId { } /// Comments can be applied to multiple kinds of objects (e.g. Tables and Role), so we need a way -/// to represent these different types and their IDs (e.g. [`GlobalId`] and [`RoleId`]), as well as -/// the inner kind of object that is represented, e.g. [`GlobalId`] is used to identify both Tables -/// and Views. No other kind of ID encapsulates all of this, hence this new "*Id" type. +/// to represent these different types and their IDs (e.g. [`CatalogItemId`] and [`RoleId`]), as +/// well as the inner kind of object that is represented, e.g. [`CatalogItemId`] is used to +/// identify both Tables and Views. No other kind of ID encapsulates all of this, hence this new +/// "*Id" type. #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize)] pub enum CommentObjectId { - Table(GlobalId), - View(GlobalId), - MaterializedView(GlobalId), - Source(GlobalId), - Sink(GlobalId), - Index(GlobalId), - Func(GlobalId), - Connection(GlobalId), - Type(GlobalId), - Secret(GlobalId), - ContinualTask(GlobalId), + Table(CatalogItemId), + View(CatalogItemId), + MaterializedView(CatalogItemId), + Source(CatalogItemId), + Sink(CatalogItemId), + Index(CatalogItemId), + Func(CatalogItemId), + Connection(CatalogItemId), + Type(CatalogItemId), + Secret(CatalogItemId), + ContinualTask(CatalogItemId), Role(RoleId), Database(DatabaseId), Schema((ResolvedDatabaseSpecifier, SchemaSpecifier)), diff --git a/src/sql/src/plan/statement/ddl.rs b/src/sql/src/plan/statement/ddl.rs index 7c7dd99726480..c74ff054e8f35 100644 --- a/src/sql/src/plan/statement/ddl.rs +++ b/src/sql/src/plan/statement/ddl.rs @@ -6860,34 +6860,37 @@ pub fn plan_comment( let item = scx.get_item_by_resolved_name(name)?; match (com_ty, item.item_type()) { (CommentObjectType::Table { .. }, CatalogItemType::Table) => { - (CommentObjectId::Table(item.id()), None) + (CommentObjectId::Table(item.id().to_item_id()), None) } (CommentObjectType::View { .. }, CatalogItemType::View) => { - (CommentObjectId::View(item.id()), None) + (CommentObjectId::View(item.id().to_item_id()), None) } (CommentObjectType::MaterializedView { .. }, CatalogItemType::MaterializedView) => { - (CommentObjectId::MaterializedView(item.id()), None) + ( + CommentObjectId::MaterializedView(item.id().to_item_id()), + None, + ) } (CommentObjectType::Index { .. }, CatalogItemType::Index) => { - (CommentObjectId::Index(item.id()), None) + (CommentObjectId::Index(item.id().to_item_id()), None) } (CommentObjectType::Func { .. }, CatalogItemType::Func) => { - (CommentObjectId::Func(item.id()), None) + (CommentObjectId::Func(item.id().to_item_id()), None) } (CommentObjectType::Connection { .. }, CatalogItemType::Connection) => { - (CommentObjectId::Connection(item.id()), None) + (CommentObjectId::Connection(item.id().to_item_id()), None) } (CommentObjectType::Source { .. }, CatalogItemType::Source) => { - (CommentObjectId::Source(item.id()), None) + (CommentObjectId::Source(item.id().to_item_id()), None) } (CommentObjectType::Sink { .. }, CatalogItemType::Sink) => { - (CommentObjectId::Sink(item.id()), None) + (CommentObjectId::Sink(item.id().to_item_id()), None) } (CommentObjectType::Secret { .. }, CatalogItemType::Secret) => { - (CommentObjectId::Secret(item.id()), None) + (CommentObjectId::Secret(item.id().to_item_id()), None) } (CommentObjectType::ContinualTask { .. }, CatalogItemType::ContinualTask) => { - (CommentObjectId::ContinualTask(item.id()), None) + (CommentObjectId::ContinualTask(item.id().to_item_id()), None) } (com_ty, cat_ty) => { let expected_type = match com_ty { @@ -6919,20 +6922,31 @@ pub fn plan_comment( if !modifiers.is_empty() { sql_bail!("cannot comment on type with modifiers"); } - (CommentObjectId::Type(*id), None) + (CommentObjectId::Type(id.to_item_id()), None) } ResolvedDataType::Error => unreachable!("should have been caught in name resolution"), }, CommentObjectType::Column { name } => { let (item, pos) = scx.get_column_by_resolved_name(name)?; match item.item_type() { - CatalogItemType::Table => (CommentObjectId::Table(item.id()), Some(pos + 1)), - CatalogItemType::Source => (CommentObjectId::Source(item.id()), Some(pos + 1)), - CatalogItemType::View => (CommentObjectId::View(item.id()), Some(pos + 1)), - CatalogItemType::MaterializedView => { - (CommentObjectId::MaterializedView(item.id()), Some(pos + 1)) + CatalogItemType::Table => ( + CommentObjectId::Table(item.id().to_item_id()), + Some(pos + 1), + ), + CatalogItemType::Source => ( + CommentObjectId::Source(item.id().to_item_id()), + Some(pos + 1), + ), + CatalogItemType::View => { + (CommentObjectId::View(item.id().to_item_id()), Some(pos + 1)) + } + CatalogItemType::MaterializedView => ( + CommentObjectId::MaterializedView(item.id().to_item_id()), + Some(pos + 1), + ), + CatalogItemType::Type => { + (CommentObjectId::Type(item.id().to_item_id()), Some(pos + 1)) } - CatalogItemType::Type => (CommentObjectId::Type(item.id()), Some(pos + 1)), r => { return Err(PlanError::Unsupported { feature: format!("Specifying comments on a column of {r}"),