diff --git a/Cargo.lock b/Cargo.lock index 8a488ba4b23ff..3001555a16df5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6538,6 +6538,7 @@ dependencies = [ "serde_json", "serde_repr", "similar-asserts", + "uuid", ] [[package]] diff --git a/doc/developer/design/20260706_sql_150_durable_temporary_objects.md b/doc/developer/design/20260706_sql_150_durable_temporary_objects.md index 979c1fe1203c5..e72ef7a060795 100644 --- a/doc/developer/design/20260706_sql_150_durable_temporary_objects.md +++ b/doc/developer/design/20260706_sql_150_durable_temporary_objects.md @@ -8,7 +8,7 @@ Temporary views and tables live only in per-envd in-memory state. See `temporary This blocks converting `mz_views` and `mz_tables` into materialized views over `mz_catalog_raw`, because such a view would silently drop every temp item. PR #35807 attempted the conversion and was closed for this reason. -It also causes bugs. `minimal_qualification` at `src/adapter/src/catalog.rs` is documented as broken for temp objects, with a workaround. Related bugs: database-issues #9973, #9974, #9975, #9976. +It also causes bugs. `minimal_qualification` at `src/adapter/src/catalog.rs` is documented as broken for temp objects, with a workaround. Related bugs: database-issues #9973, #9974, #9975, #9976. This change does not fix that bug family. Its root cause is name resolution, not storage. A temp qualified name carries `(Ambient, Temporary)` qualifiers that do not identify the owning session, so humanizing another session's temp object cannot resolve it (the repro in `temporary_objects.slt`, where one connection's DROP error must name another connection's temp view), and two sessions' same-named temp objects compare equal as `QualifiedItemName`s. The follow-up section describes the structural fix. In a multi-envd world (one of the motivations for SQL-118), the problem compounds. If sessions can hop between envds, per-envd in-memory temp state cannot follow. @@ -18,6 +18,7 @@ In a multi-envd world (one of the motivations for SQL-118), the problem compound - `mz_views` and `mz_tables` can be converted to `BuiltinMaterializedView`s over `mz_catalog_raw`. - The design works with N envds running concurrently. - Both graceful session close and envd crash lead to eventual cleanup of orphaned temp items. +- Session connect and disconnect do not write the catalog shard, so connection churn neither blocks on nor contends with DDL. - dbt-adapter and `pg_views` behave as they do today. ## Out of Scope @@ -27,27 +28,25 @@ In a multi-envd world (one of the motivations for SQL-118), the problem compound ## Solution Proposal -Two additions to the durable catalog. -(1) Durable session records: a new `StateUpdateKind::Session { uuid, deploy_generation, connection_id, role_id, client_ip, connected_at }`. The envd owning a session writes this on connect and deletes it on graceful close. This lets `mz_sessions` become a catalog-derived MV, and gives GC the durable session inventory it needs. +An ephemeral-owner field on items: `ephemeral_owner_session: Option` on `ItemValue` in `src/catalog-protos`. `None` means a normal durable item. `Some(uuid)` means a temp item, visible only to the session with that UUID. -Only one envd serves an environment at a time today, fenced by `deploy_generation: u64` (see `FenceToken` at `src/catalog/src/durable/objects.rs:1319`). So `deploy_generation` is enough to identify which envd incarnation owns a given session. When multi-envd (SQL-118) lands and multiple envds serve one environment at once, we'll add a per-process envd identifier next to `deploy_generation`. `EnvironmentId` (`src/sql/src/catalog.rs:1278`, exposed as `mz_environment_id()`) is not that identifier. It names the environment, which every envd serving that environment shares. +Durable temp items all reference the shared sentinel schema id `SchemaId::User(0)`, the id `SchemaSpecifier::Temporary` maps to. Because every session's temp items live under that one schema id, durable item name uniqueness is scoped by `(schema_id, name, ephemeral_owner_session)` rather than `(schema_id, name)`. -(2) An ephemeral-owner field on items: `ephemeral_owner_session: Option` on `ItemValue` and `SchemaValue` in `src/catalog-protos`. `None` means a normal durable item. `Some(uuid)` means a temp item, visible only to the session with that UUID. +Temp schemas themselves stay per-connection in-memory objects (`temporary_schemas` at `src/adapter/src/catalog/state.rs`) and get no durable record. A temp schema is derived state. Its name is always `mz_temp`, its owner is the session's role, and its contents are exactly the durable items tagged with the session's UUID, so any envd can synthesize it on demand. Durably recording it would buy a self-describing shard (no sentinel), which the follow-up section takes up. ### Cost -Session writes move shards, they don't multiply. Today, opening a session writes one row into the builtin `mz_sessions` shard, and closing it writes a delete. With this change the same two writes go to the catalog shard instead, and the `mz_sessions` shard disappears once it becomes an MV over the catalog. Total persist writes per session lifecycle are the same. +Temp DDL writes zero persist bytes today (all temp state is in memory) but will cost one catalog write per create/drop, and now contends with real DDL for the catalog shard's single writer. This should be small in practice, since a session issues far fewer temp DDLs than queries. -Two second-order costs to flag. First, temp DDL writes zero persist bytes today (all temp state is in memory) but will cost one catalog write per create/drop. Second, the catalog shard has a single writer, so temp DDL now contends with real DDL for that writer. Both should be small in practice, since a session issues far fewer temp DDLs than queries. Worth benchmarking though. ### Write path -`sequence_create_table` at `src/adapter/src/coord/sequencer/inner.rs:990` already branches on `table.temporary`. Also read `session.uuid()` and pass it to `Op::CreateItem`. Same shape for `sequence_create_view` and `create_temporary_schema`. Existing `Catalog::transact` handles atomicity. +`sequence_create_table` at `src/adapter/src/coord/sequencer/inner.rs:990` already branches on `table.temporary`. Also read `session.uuid()` and pass it to `Op::CreateItem`. Same shape for `sequence_create_view`. Existing `Catalog::transact` handles atomicity. Temporary schemas will still be in memory and created lazily on creation of the first temporary item in a session. ### Read path -`resolve()` at `src/adapter/src/catalog/state.rs:2131` uses one uniform rule. `ephemeral_owner_session = None` is visible to everyone. `Some(uuid) = session.uuid()` is visible to that session. Otherwise the item is hidden. The current `SchemaSpecifier::Temporary` branching goes away. +`resolve()` at `src/adapter/src/catalog/state.rs:2131` applies one rule to items. `ephemeral_owner_session = None` is visible to everyone. `Some(uuid) = session.uuid()` is visible to that session. Otherwise the item is hidden. Schema resolution keeps the current `SchemaSpecifier::Temporary` branching, since temp schemas remain in-memory per-connection objects. ### `mz_views` / `mz_tables` MV shape @@ -55,14 +54,56 @@ The MV shows every item, regardless of `ephemeral_owner_session`. Session-scoped ### GC -Graceful close: the session-close hook at `src/adapter/src/coord/command_handler.rs:1988` issues one `Catalog::transact` that drops the session record and every item with `ephemeral_owner_session = session.uuid()`. +Graceful close: the session-close hook at `src/adapter/src/coord/command_handler.rs:1988` issues one `Catalog::transact` that drops every item with `ephemeral_owner_session = session.uuid()`. + +The UUID comes from the in-memory connection metadata, no durable session record is needed. An envd becomes the live owner of the catalog on promotion, not on startup. At that moment the newly-promoted envd can drop every temp-object entry from the catalog. Any session that owned them is necessarily dead by then. Multi-envd cleanup is follow-up work. Once several envds can run concurrently, we will need a durable envd-heartbeat table so any envd can identify dead peers and drop temp items owned by their sessions. +### Follow-up: Multi-writer `mz_sessions` + +With N envds, several processes append to the `mz_sessions` shard concurrently. Concurrent inserts are fine because the txn-wal protocol already supports this: commits are compare-and-appends against the txns shard, and a conflicting committer retries at a fresh timestamp. + +Each session record will need to be partitioned by a per-envd identifier and need a durable envd-heartbeat table. This is to identify rows left by dead processes for cleanup. We need a durable heartbeat to tell a crashed peer from a live one. + +## Follow-up: durable per-session temporary schemas + +The plan is to adopt Postgres's model, where each backend's temp +namespace is a real catalog object with a distinct name (`pg_temp_` in +Postgres, with `pg_temp` as an alias resolving to your own). Adapted here: + +- A session's first temp DDL durably creates its temp schema with a real + allocated `SchemaId` and OID and a per-session-unique name (`mz_temp_`). + `mz_temp` becomes a resolution alias for the session's own schema. The + choice of `N` is open. Deriving it from the session UUID needs no + allocation and lets any envd reconstruct the name from a durable item's + owner field, but produces long names in error messages. An allocated + counter reads better but adds a per-session allocation. +- That migration adds `ephemeral_owner_session` on `SchemaValue`, together + with the code that reads it: owner-scoped GC (graceful session close), + resolve-time visibility, and the `mz_schemas` shape decision. Postgres + shows `pg_temp_N` rows in `pg_namespace`. Filtering `mz_schemas` on + `ephemeral_owner_session IS NULL` instead preserves its current temp-free + contents. +- `SchemaSpecifier::Temporary` and the `SchemaId::User(0)` sentinel retire in + favor of the real ids (the TODO at `src/sql/src/names.rs` anticipates + this). That deletes the `minimal_qualification` workaround, since + cross-session names like `mz_temp_.v1` become resolvable, mirroring + Postgres's `pg_temp_3.v1` error output. Item name uniqueness can then drop + its `ephemeral_owner_session` term, because per-session schema ids already + isolate names. +- It also needs an access-denial rule for other sessions' temp objects once + they become resolvable (today privacy is enforced by unresolvability), and + an audit of literal `mz_temp` assumptions: the DDL special cases in + `src/sql/src/plan/statement/ddl.rs`, normalized `create_sql`, SHOW output, + `pg_views`, dbt, and `find_temp_schema` at + `src/adapter/src/catalog/state.rs`. + ## Alternatives +- Durable session records in the catalog shard: a `StateUpdateKind::Session` written on connect and deleted on close, with `mz_sessions` as an MV over `mz_catalog_raw`. This was implemented and then rejected for performance. Connect could not complete before the session record's catalog compare-and-append was durable, and connection churn contended with real DDL for the catalog shard's single writer. - Keep temp objects in memory and expose them via a per-envd runtime side-channel. This breaks multi-envd from the start: sessions can only see one envd's temp items. - Pin sessions to a single envd so they cannot hop. Rules out cross-envd session hop as a future option. - Use `ConnectionId` as the durable owner key. Does not work: `ConnectionId` is a per-envd `u32` (`src/adapter-types/src/connection.rs:18`), not durable, and can be reused. diff --git a/doc/developer/guide-adapter.md b/doc/developer/guide-adapter.md index 5f33d134329df..95fd16397350b 100644 --- a/doc/developer/guide-adapter.md +++ b/doc/developer/guide-adapter.md @@ -307,3 +307,32 @@ real, but the solution must maintain strict serializability. Correct alternative might include: reducing oracle round-trip latency, colocating the oracle, using the batching oracle's existing mechanism to serve more callers per batch, or relaxing the isolation level for queries that opt in. + +### Session records in the durable catalog + +**What:** Write a durable catalog record (`StateUpdateKind::Session`) on every +session connect and delete it on close, so that `mz_sessions` becomes a +materialized view over `mz_catalog_raw` and cleanup logic has a durable +session inventory. + +**Why it was rejected:** Connection lifecycle events are far more frequent +than DDL, and the catalog shard has a single writer. Every connect became a +timestamp oracle round-trip plus a compare-and-append against the catalog +shard, serialized on the coordinator loop. Startup could not respond before +the record was durable (otherwise temp DDL could race its own session +record), so connect latency was coupled to catalog commit latency, and +connection churn queued real DDL behind session commits. Batching session ops +into shared catalog transactions and bounding the flush rate reduced the +commit count but kept both couplings. + +The durable records also bought nothing for garbage collection in the +single-envd world. Cleanup at promotion deletes all ephemeral rows, justified +by the deploy-generation fence alone, and graceful session close knows the +session UUID from in-memory connection metadata. + +**The general lesson:** high-frequency per-connection state belongs in builtin +tables written through group commit, which is fire-and-forget from the +coordinator loop, batched with all other builtin writes, and never touches +the catalog shard. Reserve durable catalog writes for state that must be +transactional with DDL. See +`doc/developer/design/20260706_sql_150_durable_temporary_objects.md`. diff --git a/src/adapter/src/catalog.rs b/src/adapter/src/catalog.rs index c66df7dd95262..4a104d3979045 100644 --- a/src/adapter/src/catalog.rs +++ b/src/adapter/src/catalog.rs @@ -59,7 +59,6 @@ use mz_ore::result::ResultExt as _; use mz_persist_client::PersistClient; use mz_repr::adt::mz_acl_item::{AclMode, PrivilegeMap}; use mz_repr::explain::ExprHumanizer; -use mz_repr::namespaces::MZ_TEMP_SCHEMA; use mz_repr::network_policy_id::NetworkPolicyId; use mz_repr::optimize::OptimizerFeatures; use mz_repr::role_id::RoleId; @@ -1163,35 +1162,35 @@ impl Catalog { self.state.try_get_role_auth_by_id(id) } - /// Creates a new schema in the `Catalog` for temporary items - /// indicated by the TEMPORARY or TEMP keywords. - pub fn create_temporary_schema( - &mut self, - conn_id: &ConnectionId, - owner_id: RoleId, - ) -> Result<(), Error> { - self.state.create_temporary_schema(conn_id, owner_id) + /// Registers the connection's temporary namespace: the `uuid` <-> + /// `conn_id` mapping used to stamp and apply durable temporary items + /// owned by the session. The `mz_temp` schema itself is created when + /// the first temporary item is applied. + /// + /// The coordinator calls this at a session's first temporary-item + /// creation, strictly before the transaction that persists the item, and + /// guards on [`CatalogState::has_temporary_namespace`], so registering + /// an already-registered namespace is a bug. + pub fn register_temporary_namespace(&mut self, conn_id: &ConnectionId, uuid: Uuid) { + self.state + .temporary_namespaces + .register(conn_id.clone(), uuid); } fn item_exists_in_temp_schemas(&self, conn_id: &ConnectionId, item_name: &str) -> bool { - // Temporary schemas are created lazily, so it's valid for one to not exist yet. + // A temporary namespace is registered at the connection's first + // temporary-item creation, so it's valid for one to not exist yet. self.state - .temporary_schemas - .get(conn_id) + .temporary_namespaces + .schema(conn_id) .map(|schema| schema.items.contains_key(item_name)) .unwrap_or(false) } - /// Drops schema for connection if it exists. Returns an error if it exists and has items. - /// Returns Ok if conn_id's temp schema does not exist. - pub fn drop_temporary_schema(&mut self, conn_id: &ConnectionId) -> Result<(), Error> { - let Some(schema) = self.state.temporary_schemas.remove(conn_id) else { - return Ok(()); - }; - if !schema.items.is_empty() { - return Err(Error::new(ErrorKind::SchemaNotEmpty(MZ_TEMP_SCHEMA.into()))); - } - Ok(()) + /// Removes the connection's temporary namespace, if it has one. Returns + /// Ok if none exists. + pub fn drop_temporary_namespace(&mut self, conn_id: &ConnectionId) -> Result<(), Error> { + self.state.temporary_namespaces.unregister(conn_id) } pub(crate) fn object_dependents( @@ -2036,7 +2035,7 @@ impl SessionCatalog for ConnCatalog<'_> { self.state .ambient_schemas_by_id .values() - .chain(self.state.temporary_schemas.values()) + .chain(self.state.temporary_namespaces.schemas()) .map(|schema| schema as &dyn CatalogSchema), ) .collect() @@ -2789,17 +2788,17 @@ mod tests { conn_catalog.effective_search_path(true), conn_catalog.search_path ); + // Because we lazily initialize the `mz_temp` schema, + // an explicit `mz_temp` search path before the first + // temporary item creation gets filtered out in + // `effective_search_path`. assert_eq!( conn_catalog.effective_search_path(false), - vec![ - mz_catalog_schema.clone(), - pg_catalog_schema.clone(), - mz_temp_schema.clone() - ] + vec![mz_catalog_schema.clone(), pg_catalog_schema.clone(),] ); assert_eq!( conn_catalog.effective_search_path(true), - vec![mz_catalog_schema, pg_catalog_schema, mz_temp_schema] + vec![mz_temp_schema, mz_catalog_schema, pg_catalog_schema] ); catalog.expire().await; }) diff --git a/src/adapter/src/catalog/apply.rs b/src/adapter/src/catalog/apply.rs index 8f964df74c402..59256bad2b923 100644 --- a/src/adapter/src/catalog/apply.rs +++ b/src/adapter/src/catalog/apply.rs @@ -33,7 +33,7 @@ use mz_catalog::memory::error::{Error, ErrorKind}; use mz_catalog::memory::objects::{ CatalogEntry, CatalogItem, Cluster, ClusterReplica, Database, Func, Index, Log, NetworkPolicy, Role, RoleAuth, Schema, Source, StateDiff, StateUpdate, StateUpdateKind, Table, - TableDataSource, TemporaryItem, Type, UpdateFrom, + TableDataSource, Type, UpdateFrom, }; use mz_compute_types::config::ComputeReplicaConfig; use mz_compute_types::dataflows::DataflowDescription; @@ -90,7 +90,6 @@ struct InProgressRetractions { clusters: BTreeMap, network_policies: BTreeMap, items: BTreeMap, - temp_items: BTreeMap, introspection_source_indexes: BTreeMap, system_object_mappings: BTreeMap, } @@ -155,11 +154,7 @@ impl CatalogState { // Clean up plans and optimizer notices for items that // were retracted but not replaced (i.e., truly dropped). - let dropped_entries: Vec = retractions - .items - .into_values() - .chain(retractions.temp_items.into_values()) - .collect(); + let dropped_entries: Vec = retractions.items.into_values().collect(); if !dropped_entries.is_empty() { let dropped_notices = self.drop_optimizer_notices(dropped_entries); if self.system_config().enable_mz_notices() { @@ -226,6 +221,19 @@ impl CatalogState { let mut catalog_updates = Vec::new(); for state_update in updates { + // Applying a temporary item whose owning session is not connected + // to this process must be a complete no-op. This + // covers read-only catalog followers during zero-downtime + // deployments, which observe the live writer's temporary items but + // serve none of its sessions. + if self.is_nonlocal_ephemeral_item_update(&state_update) { + tracing::debug!( + ?state_update, + "skipping ephemeral item update for non-local session" + ); + continue; + } + if matches!(state_update.kind, StateUpdateKind::SystemConfiguration(_)) { update_system_config = true; } @@ -359,9 +367,6 @@ impl CatalogState { local_expression_cache, ); } - StateUpdateKind::TemporaryItem(item) => { - self.apply_temporary_item_update(item, diff, retractions, local_expression_cache); - } StateUpdateKind::Item(item) => { self.apply_item_update(item, diff, retractions, local_expression_cache)?; } @@ -1149,47 +1154,83 @@ impl CatalogState { } } + /// Whether `update` concerns an ephemeral item whose owning session is not + /// connected to this process, in which case applying it must be a no-op. + fn is_nonlocal_ephemeral_item_update(&self, update: &StateUpdate) -> bool { + let StateUpdateKind::Item(item) = &update.kind else { + return false; + }; + // Only ephemeral items have ephemeral_owner_session + let Some(owner) = item.ephemeral_owner_session else { + return false; + }; + match update.diff { + // An addition is local when the owning session is connected here. + StateDiff::Addition => !self.temporary_namespaces.contains_uuid(&owner), + // A retraction must be applied iff the matching addition above + // was applied here, and entry presence records exactly that. + StateDiff::Retraction => !self.entry_by_id.contains_key(&item.id), + } + } + #[instrument(level = "debug")] - fn apply_temporary_item_update( + fn apply_item_update( &mut self, - temporary_item: TemporaryItem, + item: mz_catalog::durable::Item, diff: StateDiff, retractions: &mut InProgressRetractions, local_expression_cache: &mut LocalExpressionCache, - ) { + ) -> Result<(), CatalogError> { match diff { StateDiff::Addition => { - let TemporaryItem { + let key = item.key(); + let mz_catalog::durable::Item { id, oid, global_id, schema_id, name, - conn_id, create_sql, owner_id, privileges, extra_versions, - } = temporary_item; - // Lazily create the temporary schema if it doesn't exist yet. - // We need the conn_id to create the schema, and it should always be Some for temp items. - let temp_conn_id = conn_id - .as_ref() - .expect("temporary items must have a connection id"); - if !self.temporary_schemas.contains_key(temp_conn_id) { - self.create_temporary_schema(temp_conn_id, owner_id) - .expect("failed to create temporary schema"); - } - let schema = self.find_temp_schema(&schema_id); - let name = QualifiedItemName { - qualifiers: ItemQualifiers { - database_spec: schema.database().clone(), - schema_spec: schema.id().clone(), + ephemeral_owner_session, + } = item; + + // Temporary items live in the temporary schema of the owning + // session's connection, not in the schema named by + // `schema_id` (which is the temporary schema sentinel). + // Updates for sessions not connected to this process are + // filtered out in `apply_updates_inner`, so the mapping must + // exist here. + let conn_id = ephemeral_owner_session.map(|owner| { + self.temporary_namespaces + .conn_for_uuid(&owner) + .cloned() + .unwrap_or_else(|| { + panic!("no session record applied for temporary item owner {owner}") + }) + }); + let name = match &conn_id { + Some(_) => QualifiedItemName { + qualifiers: ItemQualifiers { + database_spec: ResolvedDatabaseSpecifier::Ambient, + schema_spec: SchemaSpecifier::Temporary, + }, + item: name.clone(), }, - item: name.clone(), + None => { + let schema = self.find_non_temp_schema(&schema_id); + QualifiedItemName { + qualifiers: ItemQualifiers { + database_spec: schema.database().clone(), + schema_spec: schema.id().clone(), + }, + item: name.clone(), + } + } }; - - let entry = match retractions.temp_items.remove(&id) { + let entry = match retractions.items.remove(&key) { Some(mut retraction) => { assert_eq!(retraction.id, id); @@ -1209,24 +1250,28 @@ impl CatalogState { .unwrap_or_else(|e| { panic!("{e:?}: invalid persisted SQL: {create_sql}") }); - // Have to patch up the item because parsing doesn't - // take into account temporary schemas/conn_id. - // NOTE(aljoscha): I don't like how we're patching - // this in here, but it's but one of the ways in - // which temporary items are a bit weird. So, here - // we are ... - catalog_item.set_conn_id(conn_id); - // Deserializing replans the SQL, and the planner's - // canonical printing can differ from `create_sql`, - // for example when a feature flag changed how - // references are printed since `create_sql` was - // produced. Keep the exact input. A later op in the - // same transaction retracts this item by - // re-serializing it, and that retraction must - // cancel byte-for-byte against this addition during - // consolidation, else two retractions of the same - // id survive and applying them panics. - catalog_item.set_create_sql(create_sql); + if conn_id.is_some() { + // Have to patch up the item because parsing + // doesn't take into account temporary + // schemas/conn_id. + // NOTE(aljoscha): I don't like how we're patching + // this in here, but it's but one of the ways in + // which temporary items are a bit weird. So, here + // we are ... + catalog_item.set_conn_id(conn_id.clone()); + // Deserializing replans the SQL, and the + // planner's canonical printing can differ from + // `create_sql`, for example when a feature flag + // changed how references are printed since + // `create_sql` was produced. Keep the exact + // input. A later op in the same transaction + // retracts this item by re-serializing it, and + // that retraction must cancel byte-for-byte + // against this addition during consolidation, + // else two retractions of the same id survive + // and applying them panics. + catalog_item.set_create_sql(create_sql); + } retraction.item = catalog_item; } @@ -1250,106 +1295,12 @@ impl CatalogState { panic!("{e:?}: invalid persisted SQL: {create_sql}") }); - // Have to patch up the item because parsing doesn't - // take into account temporary schemas/conn_id. - // NOTE(aljoscha): I don't like how we're patching this - // in here, but it's but one of the ways in which - // temporary items are a bit weird. So, here we are ... - catalog_item.set_conn_id(conn_id); - // Keep the exact input create_sql, not the replanned - // printing. See the comment on the reparse above. - catalog_item.set_create_sql(create_sql); - - CatalogEntry { - item: catalog_item, - referenced_by: Vec::new(), - used_by: Vec::new(), - id, - oid, - name, - owner_id, - privileges: PrivilegeMap::from_mz_acl_items(privileges), + if conn_id.is_some() { + // See the patch-up comments on the reparse above. + catalog_item.set_conn_id(conn_id.clone()); + catalog_item.set_create_sql(create_sql); } - } - }; - self.insert_entry(entry); - } - StateDiff::Retraction => { - let entry = self.drop_item(temporary_item.id); - retractions.temp_items.insert(temporary_item.id, entry); - } - } - } - - #[instrument(level = "debug")] - fn apply_item_update( - &mut self, - item: mz_catalog::durable::Item, - diff: StateDiff, - retractions: &mut InProgressRetractions, - local_expression_cache: &mut LocalExpressionCache, - ) -> Result<(), CatalogError> { - match diff { - StateDiff::Addition => { - let key = item.key(); - let mz_catalog::durable::Item { - id, - oid, - global_id, - schema_id, - name, - create_sql, - owner_id, - privileges, - extra_versions, - } = item; - let schema = self.find_non_temp_schema(&schema_id); - let name = QualifiedItemName { - qualifiers: ItemQualifiers { - database_spec: schema.database().clone(), - schema_spec: schema.id().clone(), - }, - item: name.clone(), - }; - let entry = match retractions.items.remove(&key) { - Some(retraction) => { - assert_eq!(retraction.id, item.id); - let item = self - .deserialize_item( - global_id, - &create_sql, - &extra_versions, - local_expression_cache, - Some(retraction.item), - ) - .unwrap_or_else(|e| { - panic!("{e:?}: invalid persisted SQL: {create_sql}") - }); - - CatalogEntry { - item, - id, - oid, - name, - owner_id, - privileges: PrivilegeMap::from_mz_acl_items(privileges), - referenced_by: retraction.referenced_by, - used_by: retraction.used_by, - } - } - None => { - let catalog_item = self - .deserialize_item( - global_id, - &create_sql, - &extra_versions, - local_expression_cache, - None, - ) - .unwrap_or_else(|e| { - panic!("{e:?}: invalid persisted SQL: {create_sql}") - }); CatalogEntry { item: catalog_item, referenced_by: Vec::new(), @@ -1531,7 +1482,6 @@ impl CatalogState { vec![] } } - StateUpdateKind::TemporaryItem(item) => self.pack_item_update(item.id, diff), StateUpdateKind::Item(item) => self.pack_item_update(item.id, diff), StateUpdateKind::Comment(_) => Vec::new(), StateUpdateKind::SourceReferences(source_references) => { @@ -1738,8 +1688,8 @@ impl CatalogState { // Keep in sync with `get_schemas` match (database_spec, schema_spec) { (ResolvedDatabaseSpecifier::Ambient, SchemaSpecifier::Temporary) => self - .temporary_schemas - .get_mut(conn_id) + .temporary_namespaces + .schema_mut(conn_id) .expect("catalog out of sync"), (ResolvedDatabaseSpecifier::Ambient, SchemaSpecifier::Id(id)) => self .ambient_schemas_by_id @@ -2046,11 +1996,9 @@ impl CatalogState { let conn_id = entry.item().conn_id().unwrap_or(&SYSTEM_CONN_ID); // Lazily create the temporary schema if this is a temporary item and the schema // doesn't exist yet. - if entry.name().qualifiers.schema_spec == SchemaSpecifier::Temporary - && !self.temporary_schemas.contains_key(conn_id) - { - self.create_temporary_schema(conn_id, entry.owner_id) - .expect("failed to create temporary schema"); + if entry.name().qualifiers.schema_spec == SchemaSpecifier::Temporary { + self.temporary_namespaces + .ensure_schema(conn_id, entry.owner_id); } let schema = self.get_schema_mut( &entry.name().qualifiers.database_spec, @@ -2281,8 +2229,6 @@ fn sort_updates(updates: Vec) -> Vec { let mut builtin_item_updates = Vec::new(); let mut item_retractions = Vec::new(); let mut item_additions = Vec::new(); - let mut temp_item_retractions = Vec::new(); - let mut temp_item_additions = Vec::new(); let mut post_item_retractions = Vec::new(); let mut post_item_additions = Vec::new(); for update in updates { @@ -2314,12 +2260,6 @@ fn sort_updates(updates: Vec) -> Vec { StateUpdateKind::SystemObjectMapping(system_object_mapping) => { builtin_item_updates.push((system_object_mapping, update.ts, update.diff)) } - StateUpdateKind::TemporaryItem(item) => push_update( - (item, update.ts, update.diff), - diff, - &mut temp_item_retractions, - &mut temp_item_additions, - ), StateUpdateKind::Item(item) => push_update( (item, update.ts, update.diff), diff, @@ -2478,107 +2418,23 @@ fn sort_updates(updates: Vec) -> Vec { .collect() } - let item_retractions = sort_item_updates(item_retractions); - let item_additions = sort_item_updates(item_additions); - - /// Sort temporary item updates by dependency. - /// - /// The logic of this function should match [`sort_item_updates`]. - fn sort_temp_item_updates( - temp_item_updates: Vec<(TemporaryItem, Timestamp, StateDiff)>, - ) -> VecDeque<(TemporaryItem, Timestamp, StateDiff)> { - // Partition items into groups s.t. each item in one group has a predefined order with all - // items in other groups. For example, all sinks are ordered greater than all tables. - let mut types = Vec::new(); - // N.B. Functions can depend on system tables, but not user tables. - let mut funcs = Vec::new(); - let mut secrets = Vec::new(); - let mut connections = Vec::new(); - let mut sources = Vec::new(); - let mut tables = Vec::new(); - let mut derived_items = Vec::new(); - let mut sinks = Vec::new(); - for update in temp_item_updates { - match update.0.item_type() { - CatalogItemType::Type => types.push(update), - CatalogItemType::Func => funcs.push(update), - CatalogItemType::Secret => secrets.push(update), - CatalogItemType::Connection => connections.push(update), - CatalogItemType::Source => sources.push(update), - CatalogItemType::Table => tables.push(update), - CatalogItemType::View - | CatalogItemType::MaterializedView - | CatalogItemType::Index => derived_items.push(update), - CatalogItemType::Sink => sinks.push(update), - } - } - - // Within each group, sort by ID. - for group in [ - &mut types, - &mut funcs, - &mut secrets, - &mut connections, - &mut sources, - &mut tables, - &mut derived_items, - &mut sinks, - ] { - group.sort_by_key(|(item, _, _)| item.id); - } - - iter::empty() - .chain(types) - .chain(funcs) - .chain(secrets) - .chain(connections) - .chain(sources) - .chain(tables) - .chain(derived_items) - .chain(sinks) - .collect() - } - let temp_item_retractions = sort_temp_item_updates(temp_item_retractions); - let temp_item_additions = sort_temp_item_updates(temp_item_additions); - - /// Concatenate sorted persistent and temporary item updates, persistent - /// first. - /// - /// Both inputs are already in dependency (type-group) order internally. A - /// non-temporary item can never depend on a temporary one (enforced at - /// creation, see `ErrorKind::InvalidTemporaryDependency`), so emitting every - /// persistent item before every temporary item keeps dependencies ahead of - /// dependents for additions. (Retractions reuse this via a reversal by the - /// caller, which puts temporary items first. Also, a retraction only drops - /// the item and does not re-resolve `create_sql`.) - /// - /// NOTE: Do not interleave the two by raw id. The inputs are ordered by - /// dependency group, which is not id order, so an id merge can place a - /// temporary dependent ahead of the persistent item it references and panic - /// apply with an unresolvable id. - fn merge_item_updates( + // Temporary and non-temporary items sort together: the type groups order + // cross-type dependencies and the topological sorts order dependencies + // within a group, regardless of which items are temporary. + fn into_state_updates( item_updates: VecDeque<(mz_catalog::durable::Item, Timestamp, StateDiff)>, - temp_item_updates: VecDeque<(TemporaryItem, Timestamp, StateDiff)>, ) -> Vec { - let mut state_updates = Vec::with_capacity(item_updates.len() + temp_item_updates.len()); - for (item, ts, diff) in item_updates { - state_updates.push(StateUpdate { + item_updates + .into_iter() + .map(|(item, ts, diff)| StateUpdate { kind: StateUpdateKind::Item(item), ts, diff, - }); - } - for (temp_item, ts, diff) in temp_item_updates { - state_updates.push(StateUpdate { - kind: StateUpdateKind::TemporaryItem(temp_item), - ts, - diff, - }); - } - state_updates + }) + .collect() } - let item_retractions = merge_item_updates(item_retractions, temp_item_retractions); - let item_additions = merge_item_updates(item_additions, temp_item_additions); + let item_retractions = into_state_updates(sort_item_updates(item_retractions)); + let item_additions = into_state_updates(sort_item_updates(item_additions)); // Put everything back together. iter::empty() @@ -2627,7 +2483,7 @@ impl ApplyState { Self::BuiltinViewAdditions(vec![view_addition]) } - IntrospectionSourceIndex(_) | SystemObjectMapping(_) | TemporaryItem(_) | Item(_) => { + IntrospectionSourceIndex(_) | SystemObjectMapping(_) | Item(_) => { Self::Items(vec![update]) } diff --git a/src/adapter/src/catalog/migrate.rs b/src/adapter/src/catalog/migrate.rs index 4adedbc22f2dc..e5b0014066c55 100644 --- a/src/adapter/src/catalog/migrate.rs +++ b/src/adapter/src/catalog/migrate.rs @@ -15,7 +15,7 @@ use maplit::btreeset; use mz_catalog::builtin::{BUILTINS, BuiltinTable}; use mz_catalog::durable::objects::{SystemObjectDescription, SystemObjectMapping}; use mz_catalog::durable::{MOCK_AUTHENTICATION_NONCE_KEY, Transaction}; -use mz_catalog::memory::objects::{BootstrapStateUpdateKind, StateUpdate}; +use mz_catalog::memory::objects::{StateUpdate, StateUpdateKind}; use mz_ore::collections::CollectionExt; use mz_ore::now::NowFn; use mz_persist_types::ShardId; @@ -121,7 +121,7 @@ where pub(crate) struct MigrateResult { pub(crate) builtin_table_updates: Vec>, pub(crate) catalog_updates: Vec, - pub(crate) post_item_updates: Vec<(BootstrapStateUpdateKind, Timestamp, Diff)>, + pub(crate) post_item_updates: Vec<(StateUpdateKind, Timestamp, Diff)>, } /// Migrates all user items and loads them into `state`. @@ -176,14 +176,12 @@ pub(crate) async fn migrate( .into_iter() // The only post-item update kind we currently generate is to // update storage collection metadata. - .partition(|(kind, _, _)| { - matches!(kind, BootstrapStateUpdateKind::StorageCollectionMetadata(_)) - }); + .partition(|(kind, _, _)| matches!(kind, StateUpdateKind::StorageCollectionMetadata(_))); let item_updates = item_updates .into_iter() .map(|(kind, ts, diff)| StateUpdate { - kind: kind.into(), + kind, ts, diff: diff.try_into().expect("valid diff"), }) diff --git a/src/adapter/src/catalog/open.rs b/src/adapter/src/catalog/open.rs index afe4f8f1729c7..60960d8e21804 100644 --- a/src/adapter/src/catalog/open.rs +++ b/src/adapter/src/catalog/open.rs @@ -25,7 +25,6 @@ use mz_audit_log::{ CreateOrDropClusterReplicaReasonV1, EventDetails, EventType, ObjectType, VersionedEvent, }; use mz_auth::hash::scram256_hash; -use mz_catalog::SYSTEM_CONN_ID; use mz_catalog::builtin::{ BUILTIN_CLUSTERS, BUILTIN_PREFIXES, BUILTIN_ROLES, BUILTINS, Builtin, Fingerprint, MZ_CATALOG_RAW, RUNTIME_ALTERABLE_FINGERPRINT_SENTINEL, @@ -43,7 +42,7 @@ use mz_catalog::expr_cache::{ }; use mz_catalog::memory::error::{Error, ErrorKind}; use mz_catalog::memory::objects::{ - BootstrapStateUpdateKind, CommentsMap, DefaultPrivileges, RoleAuth, StateUpdate, + CommentsMap, DefaultPrivileges, RoleAuth, StateUpdate, StateUpdateKind, }; use mz_controller::clusters::ReplicaLogging; use mz_controller_types::ClusterId; @@ -155,7 +154,7 @@ impl Catalog { comments: Arc::new(CommentsMap::default()), source_references: imbl::OrdMap::new(), storage_metadata: Arc::new(StorageMetadata::default()), - temporary_schemas: imbl::OrdMap::new(), + temporary_namespaces: Default::default(), mock_authentication_nonce: Default::default(), config: mz_sql::catalog::CatalogConfig { start_time: to_datetime((config.now)()), @@ -249,7 +248,6 @@ impl Catalog { Err(e) => return Err(e.into()), }; } - state.create_temporary_schema(&SYSTEM_CONN_ID, MZ_SYSTEM_ROLE_ID)?; } // Make life easier by consolidating all updates, so that we end up with only positive @@ -268,46 +266,44 @@ impl Catalog { let mut audit_log_updates = Vec::new(); for (kind, ts, diff) in updates { match kind { - BootstrapStateUpdateKind::Role(_) - | BootstrapStateUpdateKind::RoleAuth(_) - | BootstrapStateUpdateKind::Database(_) - | BootstrapStateUpdateKind::Schema(_) - | BootstrapStateUpdateKind::DefaultPrivilege(_) - | BootstrapStateUpdateKind::SystemPrivilege(_) - | BootstrapStateUpdateKind::SystemConfiguration(_) - | BootstrapStateUpdateKind::ClusterSystemConfiguration(_) - | BootstrapStateUpdateKind::ReplicaSystemConfiguration(_) - | BootstrapStateUpdateKind::Cluster(_) - | BootstrapStateUpdateKind::NetworkPolicy(_) - | BootstrapStateUpdateKind::ClusterReplica(_) => { - pre_item_updates.push(StateUpdate { - kind: kind.into(), - ts, - diff: diff.try_into().expect("valid diff"), - }) - } - BootstrapStateUpdateKind::IntrospectionSourceIndex(_) - | BootstrapStateUpdateKind::SystemObjectMapping(_) => { + StateUpdateKind::Role(_) + | StateUpdateKind::RoleAuth(_) + | StateUpdateKind::Database(_) + | StateUpdateKind::Schema(_) + | StateUpdateKind::DefaultPrivilege(_) + | StateUpdateKind::SystemPrivilege(_) + | StateUpdateKind::SystemConfiguration(_) + | StateUpdateKind::ClusterSystemConfiguration(_) + | StateUpdateKind::ReplicaSystemConfiguration(_) + | StateUpdateKind::Cluster(_) + | StateUpdateKind::NetworkPolicy(_) + | StateUpdateKind::ClusterReplica(_) => pre_item_updates.push(StateUpdate { + kind, + ts, + diff: diff.try_into().expect("valid diff"), + }), + StateUpdateKind::IntrospectionSourceIndex(_) + | StateUpdateKind::SystemObjectMapping(_) => { system_item_updates.push(StateUpdate { - kind: kind.into(), + kind, ts, diff: diff.try_into().expect("valid diff"), }) } - BootstrapStateUpdateKind::Item(_) => item_updates.push(StateUpdate { - kind: kind.into(), + StateUpdateKind::Item(_) => item_updates.push(StateUpdate { + kind, ts, diff: diff.try_into().expect("valid diff"), }), - BootstrapStateUpdateKind::Comment(_) - | BootstrapStateUpdateKind::StorageCollectionMetadata(_) - | BootstrapStateUpdateKind::SourceReferences(_) - | BootstrapStateUpdateKind::UnfinalizedShard(_) => { + StateUpdateKind::Comment(_) + | StateUpdateKind::StorageCollectionMetadata(_) + | StateUpdateKind::SourceReferences(_) + | StateUpdateKind::UnfinalizedShard(_) => { post_item_updates.push((kind, ts, diff)); } - BootstrapStateUpdateKind::AuditLog(_) => { + StateUpdateKind::AuditLog(_) => { audit_log_updates.push(StateUpdate { - kind: kind.into(), + kind, ts, diff: diff.try_into().expect("valid diff"), }); @@ -488,7 +484,7 @@ impl Catalog { let post_item_updates = post_item_updates .into_iter() .map(|(kind, ts, diff)| StateUpdate { - kind: kind.into(), + kind, ts, diff: diff.try_into().expect("valid diff"), }) @@ -865,6 +861,7 @@ fn add_new_remove_old_builtin_items_migration( *c.owner_id, acl_items, versions, + None, )?; true } @@ -1524,32 +1521,18 @@ impl BuiltinBootstrapClusterConfigMap { /// Convert `updates` into a `Vec` that can be consolidated by doing the following: /// -/// - Convert each update into a type that implements [`std::cmp::Ord`]. /// - Update the timestamp of each update to the same value. /// - Convert the diff of each update to a type that implements /// [`differential_dataflow::difference::Semigroup`]. /// -/// [`mz_catalog::memory::objects::StateUpdateKind`] does not implement [`std::cmp::Ord`] only -/// because it contains a variant for temporary items, which do not implement [`std::cmp::Ord`]. -/// However, we know that during bootstrap no temporary items exist, because they are not persisted -/// and are only created after bootstrap is complete. So we forcibly convert each -/// [`mz_catalog::memory::objects::StateUpdateKind`] into an [`BootstrapStateUpdateKind`], which is -/// identical to [`mz_catalog::memory::objects::StateUpdateKind`] except it doesn't have a -/// temporary item variant and does implement [`std::cmp::Ord`]. -/// /// WARNING: Do not call outside of startup. pub(crate) fn into_consolidatable_updates_startup( updates: Vec, ts: Timestamp, -) -> Vec<(BootstrapStateUpdateKind, Timestamp, Diff)> { +) -> Vec<(StateUpdateKind, Timestamp, Diff)> { updates .into_iter() - .map(|StateUpdate { kind, ts: _, diff }| { - let kind: BootstrapStateUpdateKind = kind - .try_into() - .unwrap_or_else(|e| panic!("temporary items do not exist during bootstrap: {e:?}")); - (kind, ts, Diff::from(diff)) - }) + .map(|StateUpdate { kind, ts: _, diff }| (kind, ts, Diff::from(diff))) .collect() } diff --git a/src/adapter/src/catalog/state.rs b/src/adapter/src/catalog/state.rs index 15ba6a27bcb39..ba8ac1bd746d0 100644 --- a/src/adapter/src/catalog/state.rs +++ b/src/adapter/src/catalog/state.rs @@ -93,6 +93,7 @@ use serde::Serialize; use timely::progress::Antichain; use tokio::sync::mpsc; use tracing::{debug, warn}; +use uuid::Uuid; // DO NOT add any more imports from `crate` outside of `crate::catalog`. use crate::AdapterError; @@ -167,7 +168,7 @@ pub struct CatalogState { // read-only catalog opened by Testdrive's consistency check has no // active connections, so this must be `#[serde(skip)]`. #[serde(skip)] - pub(super) temporary_schemas: imbl::OrdMap, + pub(super) temporary_namespaces: TemporaryNamespaces, // Read-only state not derived from the durable catalog. #[serde(skip)] @@ -188,6 +189,138 @@ pub struct CatalogState { pub(super) license_key: ValidatedLicenseKey, } +/// The temporary namespaces of the sessions connected to this process: for +/// each session that has created a temporary item, the ephemeral-owner +/// mapping between the session's UUID (stamped on its durable temporary +/// items) and its connection, together with the session's `mz_temp` +/// [`Schema`] once it has materialized. +/// +/// The coordinator registers a namespace at a session's first +/// temporary-item creation, and unregisters it when the session terminates. +#[derive(Debug, Clone, Default)] +pub(super) struct TemporaryNamespaces { + by_conn: imbl::OrdMap, + // For resolving a durable item's owner UUID to its connection in + // the apply path. + conns_by_uuid: imbl::OrdMap, +} + +#[derive(Debug, Clone)] +struct TemporaryNamespace { + uuid: Uuid, + // Instantiated by `ensure_schema` at the first applied temporary item + schema: Option, +} + +impl TemporaryNamespaces { + /// Registers `conn_id` as the connection of the session `uuid`. + /// + /// Callers guard on [`CatalogState::has_temporary_namespace`], so + /// registering an already-registered connection is a bug. + pub(super) fn register(&mut self, conn_id: ConnectionId, uuid: Uuid) { + let prev_conn = self.conns_by_uuid.insert(uuid, conn_id.clone()); + mz_ore::soft_assert_or_log!( + prev_conn.is_none(), + "duplicate temporary namespace registration for {uuid}" + ); + let prev_ns = self + .by_conn + .insert(conn_id, TemporaryNamespace { uuid, schema: None }); + mz_ore::soft_assert_or_log!( + prev_ns.is_none(), + "duplicate temporary namespace registration for the connection of {uuid}" + ); + } + + /// Returns `conn_id`'s `mz_temp` schema, creating an empty one owned by + /// `owner_id` if one hasn't been instantiated yet. + pub(super) fn ensure_schema( + &mut self, + conn_id: &ConnectionId, + owner_id: RoleId, + ) -> &mut Schema { + let namespace = self + .by_conn + .get_mut(conn_id) + .expect("temporary namespace must be registered before items are applied"); + namespace.schema.get_or_insert_with(|| { + // Temporary schema OIDs are never used, and it's therefore wasteful to go to the + // durable catalog to allocate a new OID for every temporary schema. Instead, we give + // them all the same invalid OID. This matches the semantics of temporary schema + // `GlobalId`s which are all -1. + let oid = INVALID_OID; + Schema { + name: QualifiedSchemaName { + database: ResolvedDatabaseSpecifier::Ambient, + schema: MZ_TEMP_SCHEMA.into(), + }, + id: SchemaSpecifier::Temporary, + oid, + items: BTreeMap::new(), + functions: BTreeMap::new(), + types: BTreeMap::new(), + owner_id, + privileges: PrivilegeMap::from_mz_acl_items(vec![rbac::owner_privilege( + mz_sql::catalog::ObjectType::Schema, + owner_id, + )]), + } + }) + } + + /// Removes `conn_id`'s temporary namespace. + pub(super) fn unregister(&mut self, conn_id: &ConnectionId) -> Result<(), Error> { + let Some(namespace) = self.by_conn.get(conn_id) else { + return Ok(()); + }; + if namespace + .schema + .as_ref() + .is_some_and(|schema| !schema.items.is_empty()) + { + return Err(Error::new(ErrorKind::SchemaNotEmpty(MZ_TEMP_SCHEMA.into()))); + } + let uuid = namespace.uuid; + self.by_conn.remove(conn_id); + self.conns_by_uuid.remove(&uuid); + Ok(()) + } + + pub(super) fn schema(&self, conn_id: &ConnectionId) -> Option<&Schema> { + self.by_conn + .get(conn_id) + .and_then(|namespace| namespace.schema.as_ref()) + } + + pub(super) fn schema_mut(&mut self, conn_id: &ConnectionId) -> Option<&mut Schema> { + self.by_conn + .get_mut(conn_id) + .and_then(|namespace| namespace.schema.as_mut()) + } + + pub(super) fn schemas(&self) -> impl Iterator { + self.by_conn + .values() + .filter_map(|namespace| namespace.schema.as_ref()) + } + + pub(super) fn conn_for_uuid(&self, uuid: &Uuid) -> Option<&ConnectionId> { + self.conns_by_uuid.get(uuid) + } + + pub(super) fn uuid_for_conn(&self, conn_id: &ConnectionId) -> Option { + self.by_conn.get(conn_id).map(|namespace| namespace.uuid) + } + + pub(super) fn contains_conn(&self, conn_id: &ConnectionId) -> bool { + self.by_conn.contains_key(conn_id) + } + + pub(super) fn contains_uuid(&self, uuid: &Uuid) -> bool { + self.conns_by_uuid.contains_key(uuid) + } +} + /// Keeps track of what expressions are cached or not during startup. /// It's also used during catalog transactions to avoid re-optimizing CREATE VIEW / CREATE MAT VIEW /// statements when going back and forth between durable catalog operations and in-memory catalog @@ -304,7 +437,7 @@ impl CatalogState { notices_by_dep_id: Default::default(), ambient_schemas_by_name: Default::default(), ambient_schemas_by_id: Default::default(), - temporary_schemas: Default::default(), + temporary_namespaces: Default::default(), clusters_by_id: Default::default(), clusters_by_name: Default::default(), network_policies_by_name: Default::default(), @@ -826,20 +959,58 @@ impl CatalogState { } pub fn get_temp_items(&self, conn: &ConnectionId) -> impl Iterator + '_ { - // Temporary schemas are created lazily, so it's valid for one to not exist yet. - self.temporary_schemas - .get(conn) + // A temporary namespace is registered at the connection's first + // temporary-item creation, so it's valid for one to not exist yet. + self.temporary_namespaces + .schema(conn) .into_iter() .flat_map(|schema| schema.items.values().copied().map(ObjectId::from)) } - /// Returns true if a temporary schema exists for the given connection. + /// Returns true if a temporary namespace is registered for the given + /// connection, i.e. it has (or has had) temporary items. /// - /// Temporary schemas are created lazily when the first temporary object is created - /// for a connection, so this may return false for connections that haven't created + /// The namespace is registered at the connection's first temporary-item + /// creation, so this returns false for connections that never created /// any temporary objects. - pub fn has_temporary_schema(&self, conn: &ConnectionId) -> bool { - self.temporary_schemas.contains_key(conn) + pub fn has_temporary_namespace(&self, conn: &ConnectionId) -> bool { + self.temporary_namespaces.contains_conn(conn) + } + + /// Converts an in-memory catalog entry into its durable representation. + /// + /// The durable owner of a temporary entry is the session whose connection + /// currently holds it, resolved from the temporary namespace + /// registered at the session's first temporary-item creation. + pub(super) fn durable_item( + &self, + entry: CatalogEntry, + ) -> Result { + let ephemeral_owner_session = entry + .conn_id() + .map(|conn_id| { + self.temporary_namespaces + .uuid_for_conn(conn_id) + .ok_or_else(|| { + AdapterError::Internal(format!( + "no session record for connection {conn_id} owning temporary item" + )) + }) + }) + .transpose()?; + let (create_sql, global_id, extra_versions) = entry.item.into_serialized(); + Ok(mz_catalog::durable::Item { + id: entry.id, + oid: entry.oid, + global_id, + schema_id: entry.name.qualifiers.schema_spec.into(), + name: entry.name.item, + create_sql, + owner_id: entry.owner_id, + privileges: entry.privileges.into_all_values().collect(), + extra_versions, + ephemeral_owner_session, + }) } /// Gets a type named `name` from exactly one of the system schemas. @@ -1701,7 +1872,7 @@ impl CatalogState { ) -> Result<&Schema, SqlCatalogError> { let schema = match database_spec { ResolvedDatabaseSpecifier::Ambient if schema_name == MZ_TEMP_SCHEMA => { - self.temporary_schemas.get(conn_id) + self.temporary_namespaces.schema(conn_id) } ResolvedDatabaseSpecifier::Ambient => self .ambient_schemas_by_name @@ -1718,8 +1889,9 @@ impl CatalogState { /// Try to get a schema, returning `None` if it doesn't exist. /// - /// For temporary schemas, returns `None` if the schema hasn't been created yet - /// (temporary schemas are created lazily when the first temporary object is created). + /// For temporary schemas, returns `None` if the connection's temporary + /// namespace hasn't been registered yet (that happens at its first + /// temporary-item creation). pub fn try_get_schema( &self, database_spec: &ResolvedDatabaseSpecifier, @@ -1729,7 +1901,7 @@ impl CatalogState { // Keep in sync with `get_schema` and `get_schemas_mut` match (database_spec, schema_spec) { (ResolvedDatabaseSpecifier::Ambient, SchemaSpecifier::Temporary) => { - self.temporary_schemas.get(conn_id) + self.temporary_namespaces.schema(conn_id) } (ResolvedDatabaseSpecifier::Ambient, SchemaSpecifier::Id(id)) => { self.ambient_schemas_by_id.get(id) @@ -1764,13 +1936,6 @@ impl CatalogState { .into_first() } - pub(super) fn find_temp_schema(&self, schema_id: &SchemaId) -> &Schema { - self.temporary_schemas - .values() - .filter(|schema| schema.id() == &SchemaSpecifier::from(*schema_id)) - .into_first() - } - pub fn get_mz_catalog_schema_id(&self) -> SchemaId { self.ambient_schemas_by_name[MZ_CATALOG_SCHEMA] } @@ -1833,40 +1998,6 @@ impl CatalogState { } } - /// Creates a new schema in the `Catalog` for temporary items - /// indicated by the TEMPORARY or TEMP keywords. - pub fn create_temporary_schema( - &mut self, - conn_id: &ConnectionId, - owner_id: RoleId, - ) -> Result<(), Error> { - // Temporary schema OIDs are never used, and it's therefore wasteful to go to the durable - // catalog to allocate a new OID for every temporary schema. Instead, we give them all the - // same invalid OID. This matches the semantics of temporary schema `GlobalId`s which are - // all -1. - let oid = INVALID_OID; - self.temporary_schemas.insert( - conn_id.clone(), - Schema { - name: QualifiedSchemaName { - database: ResolvedDatabaseSpecifier::Ambient, - schema: MZ_TEMP_SCHEMA.into(), - }, - id: SchemaSpecifier::Temporary, - oid, - items: BTreeMap::new(), - functions: BTreeMap::new(), - types: BTreeMap::new(), - owner_id, - privileges: PrivilegeMap::from_mz_acl_items(vec![rbac::owner_privilege( - mz_sql::catalog::ObjectType::Schema, - owner_id, - )]), - }, - ); - Ok(()) - } - /// Return all OIDs that are allocated to temporary objects. pub(crate) fn get_temporary_oids(&self) -> impl Iterator + '_ { std::iter::empty() @@ -2084,6 +2215,11 @@ impl CatalogState { .get(session.database()) .map(|id| id.clone()); + // NOTE: This drops schemas that don't resolve, and consumers rely on + // every returned entry existing (e.g. `allocate_full_name` and the + // `current_schemas` evaluation look schemas up infallibly). In + // particular, `mz_temp` is dropped until the session's temporary + // namespace is registered at its first temporary-item creation. session .search_path() .iter() diff --git a/src/adapter/src/catalog/transact.rs b/src/adapter/src/catalog/transact.rs index 3a426fd793c82..78350a78657dc 100644 --- a/src/adapter/src/catalog/transact.rs +++ b/src/adapter/src/catalog/transact.rs @@ -40,13 +40,12 @@ use mz_catalog::memory::error::{AmbiguousRename, Error, ErrorKind}; use mz_catalog::memory::objects::{ CatalogEntry, CatalogItem, ClusterConfig, ClusterVariant, DataSourceDesc, DefaultPrivileges, ReconfigurationState, ReconfigurationStatus, ReconfigurationTarget, SourceReferences, - StateDiff, StateUpdate, StateUpdateKind, TemporaryItem, }; use mz_cluster_controller::ctx::RefreshWindowDecision; use mz_controller::clusters::{ManagedReplicaLocation, ReplicaConfig, ReplicaLocation}; use mz_controller_types::{ClusterId, ReplicaId}; use mz_ore::collections::HashSet; -use mz_ore::instrument; +use mz_ore::{instrument, soft_assert_or_log}; use mz_persist_types::ShardId; use mz_repr::adt::interval::Interval; use mz_repr::adt::mz_acl_item::{AclMode, MzAclItem, PrivilegeMap, merge_mz_acl_items}; @@ -996,7 +995,7 @@ impl Catalog { let mut updates = Vec::new(); for op in ops { - let temporary_item_updates = Self::transact_op( + Self::transact_op( oracle_write_ts, session, op, @@ -1010,22 +1009,7 @@ impl Catalog { ) .await?; - // Temporary items are not stored in the durable catalog, so they need to be handled - // separately for updating state and builtin tables. - // TODO(jkosh44) Some more thought needs to be given as to how temporary tables work - // in a multi-subscriber catalog world. - let upper = tx.upper(); - let temporary_item_updates = - temporary_item_updates - .into_iter() - .map(|(item, diff)| StateUpdate { - kind: StateUpdateKind::TemporaryItem(item), - ts: upper, - diff, - }); - let mut op_updates: Vec<_> = tx.get_and_commit_op_updates(); - op_updates.extend(temporary_item_updates); if !op_updates.is_empty() { // Clone the cache so each apply_updates call has access to cached expressions. // The cache uses `remove` semantics, so we need a fresh clone for each call. @@ -1095,10 +1079,6 @@ impl Catalog { /// Performs the transaction operation described by `op`. This function prepares the changes in /// `tx`, but does not update `state`. `state` will be updated when applying the durable /// changes. - /// - /// Optionally returns a builtin table update for any builtin table updates than cannot be - /// derived from the durable catalog state, and temporary item diffs. These are all very weird - /// scenarios and ideally in the future don't exist. #[instrument] async fn transact_op( oracle_write_ts: mz_repr::Timestamp, @@ -1111,9 +1091,7 @@ impl Catalog { storage_collections_to_create: &mut BTreeSet, storage_collections_to_drop: &mut BTreeSet, storage_collections_to_register: &mut BTreeMap, - ) -> Result, AdapterError> { - let mut temporary_item_updates = Vec::new(); - + ) -> Result<(), AdapterError> { match op { Op::CheckClusterState { cluster_id, @@ -1169,7 +1147,7 @@ impl Catalog { )?; } - tx.update_item(id, new_entry.into())?; + tx.update_item(id, state.durable_item(new_entry)?)?; Self::log_update(state, &id); } @@ -1219,7 +1197,7 @@ impl Catalog { )?; } - tx.update_item(id, new_entry.into())?; + tx.update_item(id, state.durable_item(new_entry)?)?; Self::log_update(state, &id); } @@ -1342,7 +1320,7 @@ impl Catalog { )?; } - tx.update_item(id, new_entry.into())?; + tx.update_item(id, state.durable_item(new_entry)?)?; storage_collections_to_register.insert(new_global_id, shard_id); } Op::AlterMaterializedViewApplyReplacement { id, replacement_id } => { @@ -1370,7 +1348,7 @@ impl Catalog { tx.remove_item(replacement_id)?; new_entry.id = replacement_id; - tx_replace_item(tx, state, id, new_entry, &mut temporary_item_updates)?; + tx_replace_item(tx, state, id, new_entry)?; let comment_id = CommentObjectId::MaterializedView(replacement_id); tx.drop_comments(&[comment_id].into())?; @@ -1783,25 +1761,47 @@ impl Catalog { ErrorKind::InvalidTemporarySchema, ))); } - let oid = tx.allocate_oid(&temporary_oids)?; + // The durable owner of a temporary item is the uuid of + // the session that created it. + let session = session.ok_or_else(|| { + AdapterError::Internal( + "temporary items must have an owner session".to_string(), + ) + })?; + let owner_session = session.uuid(); + soft_assert_or_log!( + Some(session.conn_id()) == item.conn_id(), + "temporary item connection must match the creating session" + ); + + // Defensive check: the connection -> session mapping is + // registered lazily in `catalog_transact_inner`. We + // ensure that the mapping exists as expected. + if state.temporary_namespaces.uuid_for_conn(session.conn_id()) + != Some(owner_session) + { + return Err(AdapterError::Internal(format!( + "connection {} has no temporary namespace while creating temporary item {}", + session.conn_id(), + name.item, + ))); + } let schema_id = name.qualifiers.schema_spec.clone().into(); let item_type = item.typ(); let (create_sql, global_id, versions) = item.to_serialized(); - - let item = TemporaryItem { + tx.insert_user_item( id, - oid, global_id, schema_id, - name: name.item.clone(), + &name.item, create_sql, - conn_id: item.conn_id().cloned(), owner_id, - privileges: privileges.clone(), - extra_versions: versions, - }; - temporary_item_updates.push((item, StateDiff::Addition)); + privileges.clone(), + &temporary_oids, + versions, + Some(owner_session), + )?; info!( "create temporary {} {} ({})", @@ -1846,6 +1846,7 @@ impl Catalog { privileges.clone(), &temporary_oids, versions, + None, )?; info!( "create {} {} ({})", @@ -2045,17 +2046,8 @@ impl Catalog { tx.drop_comments(&delta.comments)?; // Drop any items. - let (durable_items_to_drop, temporary_items_to_drop): (BTreeSet<_>, BTreeSet<_>) = - delta - .items - .iter() - .map(|id| id) - .partition(|id| !state.get_entry(*id).item().is_temporary()); - tx.remove_items(&durable_items_to_drop)?; - temporary_item_updates.extend(temporary_items_to_drop.into_iter().map(|id| { - let entry = state.get_entry(&id); - (entry.clone().into(), StateDiff::Retraction) - })); + let items_to_drop: BTreeSet<_> = delta.items.iter().copied().collect(); + tx.remove_items(&items_to_drop)?; for item_id in delta.items { let entry = state.get_entry(&item_id); @@ -2380,14 +2372,7 @@ impl Catalog { let entry = state.get_entry(id); let mut new_entry = entry.clone(); update_privilege_fn(&mut new_entry.privileges); - if !new_entry.item().is_temporary() { - tx.update_item(*id, new_entry.into())?; - } else { - temporary_item_updates - .push((entry.clone().into(), StateDiff::Retraction)); - temporary_item_updates - .push((new_entry.into(), StateDiff::Addition)); - } + tx.update_item(*id, state.durable_item(new_entry)?)?; } ObjectId::Role(_) | ObjectId::ClusterReplica(_) => {} }, @@ -2620,21 +2605,10 @@ impl Catalog { })) })?; - if !to_entry.item().is_temporary() { - tx.update_item(*id, to_entry.into())?; - } else { - temporary_item_updates - .push((dependent_item.clone().into(), StateDiff::Retraction)); - temporary_item_updates.push((to_entry.into(), StateDiff::Addition)); - } + tx.update_item(*id, state.durable_item(to_entry)?)?; updates.push(*id); } - if !new_entry.item().is_temporary() { - tx.update_item(id, new_entry.into())?; - } else { - temporary_item_updates.push((entry.clone().into(), StateDiff::Retraction)); - temporary_item_updates.push((new_entry.into(), StateDiff::Addition)); - } + tx.update_item(id, state.durable_item(new_entry)?)?; updates.push(id); for id in updates { @@ -2670,16 +2644,9 @@ impl Catalog { let mut updates: Vec = Vec::new(); let mut items_to_update = BTreeMap::new(); - // Dedup guard covering both persistent and temporary items. An - // item can be reached more than once: once as a member of the - // schema and again for each object in the schema it depends on. - // Persistent items are also tracked in `items_to_update`, but - // temporary items only land in `temporary_item_updates` (a Vec - // with no dedup), so a temp dependent referencing multiple - // objects in the renamed schema would otherwise be enqueued once - // per reference. That produces duplicate retraction/addition - // updates that consolidate to an invalid diff (e.g. -2) and - // panic catalog apply. + // An item can be reached more than once: once as a member of + // the schema and again for each object in the schema it + // depends on. Skip items that were already rewritten. let mut seen: BTreeSet = BTreeSet::new(); let mut update_item = |id: &CatalogItemId| { @@ -2705,12 +2672,7 @@ impl Catalog { })?; // Queue updates for Catalog storage and Builtin Tables. - if !new_entry.item().is_temporary() { - items_to_update.insert(*id, new_entry.into()); - } else { - temporary_item_updates.push((entry.clone().into(), StateDiff::Retraction)); - temporary_item_updates.push((new_entry.into(), StateDiff::Addition)); - } + items_to_update.insert(*id, state.durable_item(new_entry)?); updates.push(*id); Ok::<_, AdapterError>(()) @@ -2866,13 +2828,7 @@ impl Catalog { new_owner, ); new_entry.owner_id = new_owner; - if !new_entry.item().is_temporary() { - tx.update_item(*id, new_entry.into())?; - } else { - temporary_item_updates - .push((entry.clone().into(), StateDiff::Retraction)); - temporary_item_updates.push((new_entry.into(), StateDiff::Addition)); - } + tx.update_item(*id, state.durable_item(new_entry)?)?; } ObjectId::NetworkPolicy(id) => { let mut policy = state.get_network_policy(id).clone(); @@ -3024,11 +2980,9 @@ impl Catalog { } Op::UpdateItem { id, name, to_item } => { // A non-temporary item must not depend on a temporary one. - // Temporary objects are session-scoped and never persisted, so - // a durable item referencing one is a dangling reference that - // panics the coordinator when its create_sql is re-planned on - // catalog apply (apply emits durable items before temporary - // ones, relying on this invariant). `Op::CreateItem` enforces + // Temporary objects are session-scoped and disappear with + // their session, so a longer-lived item referencing one would + // be left with a dangling reference. `Op::CreateItem` enforces // it; mirror it here so ALTER paths (e.g. ALTER SINK ... SET // FROM) cannot repoint a persistent item at a temporary one. if !to_item.is_temporary() { @@ -3051,7 +3005,7 @@ impl Catalog { let mut entry = state.get_entry(&id).clone(); entry.name = name.clone(); entry.item = to_item.clone(); - tx.update_item(id, entry.into())?; + tx.update_item(id, state.durable_item(entry)?)?; if Self::should_audit_log_item(&to_item) { let mut full_name = Self::full_name_detail( @@ -3256,7 +3210,7 @@ impl Catalog { } } }; - Ok(temporary_item_updates) + Ok(()) } fn log_update(state: &CatalogState, id: &CatalogItemId) { @@ -3346,7 +3300,6 @@ fn tx_replace_item( state: &CatalogState, id: CatalogItemId, new_entry: CatalogEntry, - temporary_item_updates: &mut Vec<(TemporaryItem, StateDiff)>, ) -> Result<(), AdapterError> { let new_id = new_entry.id; @@ -3354,19 +3307,6 @@ fn tx_replace_item( for use_id in new_entry.referenced_by() { let dependent = state.get_entry(use_id); - // Temporary items live only in the in-memory catalog, never in the durable - // transaction. They must be rewritten via `temporary_item_updates`. Routing them - // through `tx.update_item` would be a no-op (they are not in `tx`), leaving the - // temporary object referencing the removed `id` and tripping the catalog - // consistency check. Mirrors how `Op::RenameItem` handles temporary dependents. - if dependent.item().is_temporary() { - let mut rewritten = dependent.clone(); - rewritten.item = rewritten.item.replace_item_refs(id, new_id); - temporary_item_updates.push((dependent.clone().into(), StateDiff::Retraction)); - temporary_item_updates.push((rewritten.into(), StateDiff::Addition)); - continue; - } - // The dependent might be dropped in the same tx, so check. if tx.get_item(use_id).is_none() { continue; @@ -3374,7 +3314,7 @@ fn tx_replace_item( let mut dependent = dependent.clone(); dependent.item = dependent.item.replace_item_refs(id, new_id); - tx.update_item(*use_id, dependent.into())?; + tx.update_item(*use_id, state.durable_item(dependent)?)?; } // Move comments to the new ID. @@ -3397,7 +3337,8 @@ fn tx_replace_item( owner_id, privileges, extra_versions, - } = new_entry.into(); + ephemeral_owner_session, + } = state.durable_item(new_entry)?; tx.remove_item(id)?; tx.insert_item( @@ -3410,6 +3351,7 @@ fn tx_replace_item( owner_id, privileges, extra_versions, + ephemeral_owner_session, )?; Ok(()) diff --git a/src/adapter/src/coord/catalog_implications.rs b/src/adapter/src/coord/catalog_implications.rs index 9f5cda2cdf1ec..8ba2929c23ec7 100644 --- a/src/adapter/src/coord/catalog_implications.rs +++ b/src/adapter/src/coord/catalog_implications.rs @@ -125,17 +125,6 @@ impl Coordinator { .or_insert_with(|| CatalogImplication::None); entry.absorb(update); } - ParsedStateUpdateKind::TemporaryItem { - durable_item, - parsed_item: _, - connection: _, - parsed_full_name: _, - } => { - let entry = catalog_implications - .entry(durable_item.id.clone()) - .or_insert_with(|| CatalogImplication::None); - entry.absorb(update); - } ParsedStateUpdateKind::Cluster { durable_cluster, parsed_cluster: _, @@ -1850,45 +1839,6 @@ impl CatalogImplication { CatalogItem::Type(_) => {} CatalogItem::Func(_) => {} }, - ParsedStateUpdateKind::TemporaryItem { - durable_item: _, - parsed_item, - connection, - parsed_full_name, - } => match parsed_item { - CatalogItem::Table(table) => { - self.absorb_table(table, Some(parsed_full_name), catalog_update.diff) - } - CatalogItem::Source(source) => { - self.absorb_source( - (source, connection), - Some(parsed_full_name), - catalog_update.diff, - ); - } - CatalogItem::Sink(sink) => { - self.absorb_sink(sink, Some(parsed_full_name), catalog_update.diff); - } - CatalogItem::Index(index) => { - self.absorb_index(index, Some(parsed_full_name), catalog_update.diff); - } - CatalogItem::MaterializedView(mv) => { - self.absorb_materialized_view(mv, Some(parsed_full_name), catalog_update.diff); - } - CatalogItem::View(view) => { - self.absorb_view(view, Some(parsed_full_name), catalog_update.diff); - } - - CatalogItem::Secret(secret) => { - self.absorb_secret(secret, None, catalog_update.diff); - } - CatalogItem::Connection(connection) => { - self.absorb_connection(connection, None, catalog_update.diff); - } - CatalogItem::Log(_) => {} - CatalogItem::Type(_) => {} - CatalogItem::Func(_) => {} - }, ParsedStateUpdateKind::Cluster { durable_cluster: _, parsed_cluster, diff --git a/src/adapter/src/coord/catalog_implications/parsed_state_updates.rs b/src/adapter/src/coord/catalog_implications/parsed_state_updates.rs index 46a36830ffc52..77d87180a04e4 100644 --- a/src/adapter/src/coord/catalog_implications/parsed_state_updates.rs +++ b/src/adapter/src/coord/catalog_implications/parsed_state_updates.rs @@ -45,12 +45,6 @@ pub enum ParsedStateUpdateKind { connection: Option, parsed_full_name: String, }, - TemporaryItem { - durable_item: memory::objects::TemporaryItem, - parsed_item: memory::objects::CatalogItem, - connection: Option, - parsed_full_name: String, - }, Cluster { durable_cluster: durable::objects::Cluster, parsed_cluster: memory::objects::Cluster, @@ -103,7 +97,6 @@ pub fn parse_state_update( ) -> Option { let kind = match state_update.kind { StateUpdateKind::Item(item) => Some(parse_item_update(catalog, item)), - StateUpdateKind::TemporaryItem(item) => Some(parse_temporary_item_update(catalog, item)), StateUpdateKind::Cluster(cluster) => Some(parse_cluster_update(catalog, cluster)), StateUpdateKind::ClusterReplica(replica) => { Some(parse_cluster_replica_update(catalog, replica)) @@ -148,22 +141,6 @@ fn parse_item_update( } } -fn parse_temporary_item_update( - catalog: &CatalogState, - durable_item: memory::objects::TemporaryItem, -) -> ParsedStateUpdateKind { - let (parsed_item, connection, parsed_full_name) = - parse_item_update_common(catalog, &durable_item.id); - - ParsedStateUpdateKind::TemporaryItem { - durable_item, - parsed_item, - connection, - parsed_full_name, - } -} - -// Shared between temporary items and durable items. fn parse_item_update_common( catalog: &CatalogState, item_id: &CatalogItemId, diff --git a/src/adapter/src/coord/command_handler.rs b/src/adapter/src/coord/command_handler.rs index 45f582cf42cee..cf39a9c523d9d 100644 --- a/src/adapter/src/coord/command_handler.rs +++ b/src/adapter/src/coord/command_handler.rs @@ -81,7 +81,7 @@ use crate::error::{AdapterError, AuthenticationError}; use crate::notice::AdapterNotice; use crate::session::{Session, TransactionOps, TransactionStatus}; use crate::statement_logging::{StatementEndedExecutionReason, WatchSetCreation}; -use crate::util::{ClientTransmitter, ResultExt}; +use crate::util::ClientTransmitter; use crate::webhook::{ AppendWebhookResponse, AppendWebhookValidator, WebhookAppender, WebhookAppenderInvalidator, }; @@ -2019,13 +2019,13 @@ impl Coordinator { drop(retire_notify); self.drop_temp_items(&conn_id).await; - // Only call catalog_mut() if a temporary schema actually exists for this connection. + // Only call catalog_mut() if a temporary namespace actually exists for this connection. // This avoids an expensive Arc::make_mut clone for the common case where the connection // never created any temporary objects. - if self.catalog().state().has_temporary_schema(&conn_id) { - self.catalog_mut() - .drop_temporary_schema(&conn_id) - .unwrap_or_terminate("unable to drop temporary schema"); + if self.catalog().state().has_temporary_namespace(&conn_id) { + if let Err(err) = self.catalog_mut().drop_temporary_namespace(&conn_id) { + warn!(%conn_id, "failed to drop temporary namespace: {err:?}"); + } } let conn = self.active_conns.remove(&conn_id).expect("conn must exist"); let session_type = metrics::session_type_label_value(conn.user()); diff --git a/src/adapter/src/coord/ddl.rs b/src/adapter/src/coord/ddl.rs index a9df4730f3cc4..4a8cfa5e90373 100644 --- a/src/adapter/src/coord/ddl.rs +++ b/src/adapter/src/coord/ddl.rs @@ -565,6 +565,17 @@ impl Coordinator { let catalog = Arc::make_mut(catalog); let conn = conn_id.map(|id| active_conns.get(id).expect("connection must exist")); + // Register the session as an ephemeral owner (its uuid <-> connection + // mapping) at its first temporary-item creation. + if let Some(conn) = conn { + let creates_temp_item = ops.iter().any( + |op| matches!(op, catalog::Op::CreateItem { item, .. } if item.is_temporary()), + ); + if creates_temp_item && !catalog.state().has_temporary_namespace(conn.conn_id()) { + catalog.register_temporary_namespace(conn.conn_id(), conn.uuid()); + } + } + // NOTE: This phase contains every durable `sync` and `commit` a catalog // transaction performs, which is what makes `transact` minus those two // histograms an estimate of the in-memory work. Two caveats. More than diff --git a/src/catalog-protos/Cargo.toml b/src/catalog-protos/Cargo.toml index 3d65bc89bbf64..bcaf75966d19d 100644 --- a/src/catalog-protos/Cargo.toml +++ b/src/catalog-protos/Cargo.toml @@ -21,6 +21,7 @@ proptest = { workspace = true, optional = true } proptest-derive = { workspace = true, optional = true } serde.workspace = true serde_repr.workspace = true +uuid = { workspace = true, features = ["serde"] } [dev-dependencies] mz-catalog-protos = { path = ".", features = ["proptest"] } diff --git a/src/catalog-protos/objects_hashes.json b/src/catalog-protos/objects_hashes.json index 9d55f7fd37f34..94c932cc101a3 100644 --- a/src/catalog-protos/objects_hashes.json +++ b/src/catalog-protos/objects_hashes.json @@ -1,7 +1,7 @@ [ { "name": "objects.rs", - "md5": "b661fcd073a04f5a5cfcead68f3f4ccf" + "md5": "3f63def282801a99c187bbf721674a28" }, { "name": "objects_v74.rs", @@ -70,5 +70,9 @@ { "name": "objects_v90.rs", "md5": "b661fcd073a04f5a5cfcead68f3f4ccf" + }, + { + "name": "objects_v91.rs", + "md5": "3f63def282801a99c187bbf721674a28" } ] diff --git a/src/catalog-protos/src/lib.rs b/src/catalog-protos/src/lib.rs index f81faa6e38f95..4e827b52dcfd4 100644 --- a/src/catalog-protos/src/lib.rs +++ b/src/catalog-protos/src/lib.rs @@ -28,6 +28,7 @@ pub mod objects_v87; pub mod objects_v88; pub mod objects_v89; pub mod objects_v90; +pub mod objects_v91; pub mod serialization; /// The current version of the `Catalog`. @@ -35,7 +36,7 @@ pub mod serialization; /// We will initialize new `Catalog`s with this version, and migrate existing `Catalog`s to this /// version. Whenever the `Catalog` changes, e.g. the types we serialize in the `Catalog` /// change, we need to bump this version. -pub const CATALOG_VERSION: u64 = 90; +pub const CATALOG_VERSION: u64 = 91; /// The minimum `Catalog` version number that we support migrating from. /// diff --git a/src/catalog-protos/src/objects.rs b/src/catalog-protos/src/objects.rs index df379bd2f27f0..1ed2a596ae3c7 100644 --- a/src/catalog-protos/src/objects.rs +++ b/src/catalog-protos/src/objects.rs @@ -11,6 +11,14 @@ use proptest_derive::Arbitrary; use serde::{Deserialize, Serialize}; use serde_repr::{Deserialize_repr, Serialize_repr}; +use uuid::Uuid; + +/// A proptest strategy for [`Uuid`]s, which don't implement `Arbitrary`. +#[cfg(any(test, feature = "proptest"))] +fn any_uuid() -> impl proptest::strategy::Strategy { + use proptest::strategy::Strategy; + proptest::arbitrary::any::().prop_map(Uuid::from_u128) +} #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] @@ -237,6 +245,13 @@ pub struct ItemValue { pub oid: u32, pub global_id: GlobalId, pub extra_versions: Vec, + /// `Some(uuid)` marks a temporary item owned by, and only visible to, the + /// session with that UUID. `None` is a normal durable item. + #[cfg_attr( + any(test, feature = "proptest"), + proptest(strategy = "proptest::option::of(any_uuid())") + )] + pub ephemeral_owner_session: Option, } #[derive( diff --git a/src/catalog-protos/src/objects_v91.rs b/src/catalog-protos/src/objects_v91.rs new file mode 100644 index 0000000000000..1ed2a596ae3c7 --- /dev/null +++ b/src/catalog-protos/src/objects_v91.rs @@ -0,0 +1,2286 @@ +// 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. + +#[cfg(any(test, feature = "proptest"))] +use proptest_derive::Arbitrary; +use serde::{Deserialize, Serialize}; +use serde_repr::{Deserialize_repr, Serialize_repr}; +use uuid::Uuid; + +/// A proptest strategy for [`Uuid`]s, which don't implement `Arbitrary`. +#[cfg(any(test, feature = "proptest"))] +fn any_uuid() -> impl proptest::strategy::Strategy { + use proptest::strategy::Strategy; + proptest::arbitrary::any::().prop_map(Uuid::from_u128) +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ConfigKey { + pub key: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ConfigValue { + pub value: u64, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SettingKey { + pub name: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SettingValue { + pub value: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct IdAllocKey { + pub name: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct IdAllocValue { + pub next_id: u64, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct GidMappingKey { + pub schema_name: String, + pub object_type: CatalogItemType, + pub object_name: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct GidMappingValue { + pub catalog_id: SystemCatalogItemId, + pub global_id: SystemGlobalId, + pub fingerprint: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterKey { + pub id: ClusterId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterValue { + pub name: String, + pub owner_id: RoleId, + pub privileges: Vec, + pub config: ClusterConfig, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterIntrospectionSourceIndexKey { + pub cluster_id: ClusterId, + pub name: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterIntrospectionSourceIndexValue { + pub catalog_id: IntrospectionSourceIndexCatalogItemId, + pub global_id: IntrospectionSourceIndexGlobalId, + pub oid: u32, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterReplicaKey { + pub id: ReplicaId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterReplicaValue { + pub cluster_id: ClusterId, + pub name: String, + pub config: ReplicaConfig, + pub owner_id: RoleId, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct DatabaseKey { + pub id: DatabaseId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct DatabaseValue { + pub name: String, + pub owner_id: RoleId, + pub privileges: Vec, + pub oid: u32, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SchemaKey { + pub id: SchemaId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SchemaValue { + pub database_id: Option, + pub name: String, + pub owner_id: RoleId, + pub privileges: Vec, + pub oid: u32, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ItemKey { + pub gid: CatalogItemId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ItemValue { + pub schema_id: SchemaId, + pub name: String, + pub definition: CatalogItem, + pub owner_id: RoleId, + pub privileges: Vec, + pub oid: u32, + pub global_id: GlobalId, + pub extra_versions: Vec, + /// `Some(uuid)` marks a temporary item owned by, and only visible to, the + /// session with that UUID. `None` is a normal durable item. + #[cfg_attr( + any(test, feature = "proptest"), + proptest(strategy = "proptest::option::of(any_uuid())") + )] + pub ephemeral_owner_session: Option, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ItemVersion { + pub global_id: GlobalId, + pub version: Version, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleKey { + pub id: RoleId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleValue { + pub name: String, + pub attributes: RoleAttributes, + pub membership: RoleMembership, + pub vars: RoleVars, + pub oid: u32, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleAuthKey { + pub id: RoleId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleAuthValue { + pub password_hash: Option, + pub updated_at: EpochMillis, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct NetworkPolicyKey { + pub id: NetworkPolicyId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct NetworkPolicyValue { + pub name: String, + pub rules: Vec, + pub owner_id: RoleId, + pub privileges: Vec, + pub oid: u32, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ServerConfigurationKey { + pub name: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ServerConfigurationValue { + pub value: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterSystemConfigurationKey { + pub cluster_id: ClusterId, + pub name: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterSystemConfigurationValue { + pub value: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ReplicaSystemConfigurationKey { + pub replica_id: ReplicaId, + pub name: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ReplicaSystemConfigurationValue { + pub value: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct AuditLogKey { + pub event: AuditLogEvent, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum AuditLogEvent { + V1(AuditLogEventV1), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct CommentKey { + pub object: CommentObject, + pub sub_component: Option, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum CommentObject { + Table(CatalogItemId), + View(CatalogItemId), + MaterializedView(CatalogItemId), + Source(CatalogItemId), + Sink(CatalogItemId), + Index(CatalogItemId), + Func(CatalogItemId), + Connection(CatalogItemId), + Type(CatalogItemId), + Secret(CatalogItemId), + Role(RoleId), + Database(DatabaseId), + Schema(ResolvedSchema), + Cluster(ClusterId), + ClusterReplica(ClusterReplicaId), + NetworkPolicy(NetworkPolicyId), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum CommentSubComponent { + ColumnPos(u64), +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct CommentValue { + pub comment: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SourceReferencesKey { + pub source: CatalogItemId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SourceReferencesValue { + pub references: Vec, + pub updated_at: EpochMillis, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SourceReference { + pub name: String, + pub namespace: Option, + pub columns: Vec, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct StorageCollectionMetadataKey { + pub id: GlobalId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct StorageCollectionMetadataValue { + pub shard: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct UnfinalizedShardKey { + pub shard: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct TxnWalShardValue { + pub shard: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Empty {} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct StringWrapper { + pub inner: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Duration { + pub secs: u64, + pub nanos: u32, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct EpochMillis { + pub millis: u64, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Version { + pub value: u64, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum CatalogItem { + V1(CatalogItemV1), +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct CatalogItemV1 { + pub create_sql: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum CatalogItemId { + System(u64), + User(u64), + Transient(u64), + IntrospectionSourceIndex(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SystemCatalogItemId(pub u64); + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct IntrospectionSourceIndexCatalogItemId(pub u64); + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum GlobalId { + System(u64), + User(u64), + Transient(u64), + Explain, + IntrospectionSourceIndex(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SystemGlobalId(pub u64); + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct IntrospectionSourceIndexGlobalId(pub u64); + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum ClusterId { + System(u64), + User(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum DatabaseId { + System(u64), + User(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum ResolvedDatabaseSpecifier { + Ambient, + Id(DatabaseId), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum SchemaId { + System(u64), + User(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum SchemaSpecifier { + Temporary, + Id(SchemaId), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ResolvedSchema { + pub database: ResolvedDatabaseSpecifier, + pub schema: SchemaSpecifier, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum ReplicaId { + System(u64), + User(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterReplicaId { + pub cluster_id: ClusterId, + pub replica_id: ReplicaId, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum NetworkPolicyId { + System(u64), + User(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ReplicaLogging { + pub log_logging: bool, + pub interval: Option, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct OptimizerFeatureOverride { + pub name: String, + pub value: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterScheduleRefreshOptions { + pub rehydration_time_estimate: Duration, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum ClusterSchedule { + Manual, + Refresh(ClusterScheduleRefreshOptions), +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterConfig { + pub workload_class: Option, + pub variant: ClusterVariant, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum ClusterVariant { + Unmanaged, + Managed(ManagedCluster), +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ManagedCluster { + pub size: String, + pub replication_factor: u32, + pub availability_zones: Vec, + pub logging: ReplicaLogging, + pub arrangement_compression: bool, + pub optimizer_feature_overrides: Vec, + pub schedule: ClusterSchedule, + /// User-configured autoscaling policy, distinct from the in-flight runtime + /// records below. + pub auto_scaling_strategy: Option, + /// Latest graceful reconfiguration record, if one has been written. + pub reconfiguration: Option, + /// In-flight hydration burst the controller is running. + pub burst: Option, +} + +/// The user-configured autoscaling policy of a managed cluster. +/// +/// Extensible: future strategies are added as additional optional sub-policies. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct AutoScalingStrategy { + pub on_hydration: Option, +} + +/// The `ON HYDRATION` autoscaling sub-policy. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct OnHydration { + pub hydration_size: String, + pub linger_duration: Option, +} + +/// Latest graceful reconfiguration record, including the target shape, deadline, +/// timeout action, and lifecycle status. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ReconfigurationState { + pub target: ReconfigurationTarget, + /// Deadline as an `mz_repr::Timestamp`. + pub deadline: u64, + /// What to do if the deadline passes before the target hydrates. + pub on_timeout: OnTimeoutAction, + pub status: ReconfigurationStatus, +} + +/// The lifecycle status of the latest graceful reconfiguration. +/// +/// NOTE: the serde serialization of these variant names is what the +/// `mz_internal.mz_cluster_reconfigurations` builtin view matches on. When +/// adding a variant, extend that view's `status` CASE mapping, or the new +/// variant surfaces verbatim (`SomeNewStatus`) instead of snake_case. +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum ReconfigurationStatus { + InProgress, + Finalized, + TimedOut, + Cancelled, + ResourceExhausted, +} + +/// The action a graceful reconfiguration applies if its deadline passes before +/// the target replicas hydrate. Mirrors `mz_sql::plan::OnTimeoutAction`. +/// +/// NOTE: like `ReconfigurationStatus`, the serde variant names feed the +/// `on_timeout` CASE mapping in `mz_internal.mz_cluster_reconfigurations`. +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum OnTimeoutAction { + /// Cut over to the (not-yet-hydrated) target anyway. + Commit, + /// Drop the target replica set, reverting to the pre-reconfiguration shape. + Rollback, +} + +/// The full config shape a reconfiguration is moving the cluster to, so a +/// combined size + replication-factor + availability-zone change is one record. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ReconfigurationTarget { + pub size: String, + pub replication_factor: u32, + pub availability_zones: Vec, + pub logging: ReplicaLogging, + pub arrangement_compression: bool, +} + +/// An active hydration burst. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct BurstState { + pub burst_size: String, + pub linger_duration: Duration, + /// When the steady-state replicas were first observed hydrated, as an + /// `mz_repr::Timestamp`. Absent until that observation. + pub steady_hydrated_at: Option, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ReplicaConfig { + pub logging: ReplicaLogging, + pub location: ReplicaLocation, + pub arrangement_compression: bool, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct UnmanagedLocation { + pub storagectl_addrs: Vec, + pub computectl_addrs: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ManagedLocation { + pub size: String, + /// The availability zones the replica was provisioned under. + /// + /// For a replica of a managed cluster this is the cluster's + /// `AVAILABILITY ZONES` pool at provision time; the cluster controller + /// compares it against a cluster's target `availability_zones` to tell + /// realized- from target-shape replicas (including an `AVAILABILITY ZONES` + /// divergence). For a replica of an unmanaged cluster it is the user-pinned + /// `AVAILABILITY ZONE`, as a zero- or one-element list. Empty when no zones + /// constrain placement. + pub availability_zones: Vec, + pub internal: bool, + pub billed_as: Option, + pub pending: bool, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum ReplicaLocation { + Unmanaged(UnmanagedLocation), + Managed(ManagedLocation), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum RoleId { + System(u64), + User(u64), + Public, + Predefined(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum AutoProvisionSource { + Oidc = 0, + Frontegg = 1, + None = 2, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleAttributes { + pub inherit: bool, + pub superuser: Option, + pub login: Option, + pub auto_provision_source: Option, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleMembership { + pub map: Vec, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleMembershipEntry { + pub key: RoleId, + pub value: RoleId, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleVars { + pub entries: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleVarsEntry { + pub key: String, + pub val: RoleVar, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum RoleVar { + Flat(String), + SqlSet(Vec), +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct NetworkPolicyRule { + pub name: String, + pub address: String, + pub action: NetworkPolicyRuleAction, + pub direction: NetworkPolicyRuleDirection, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum NetworkPolicyRuleAction { + Allow, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub enum NetworkPolicyRuleDirection { + Ingress, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct AclMode { + pub bitflags: u64, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct MzAclItem { + pub grantee: RoleId, + pub grantor: RoleId, + pub acl_mode: AclMode, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct DefaultPrivilegesKey { + pub role_id: RoleId, + pub database_id: Option, + pub schema_id: Option, + pub object_type: ObjectType, + pub grantee: RoleId, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct DefaultPrivilegesValue { + pub privileges: AclMode, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SystemPrivilegesKey { + pub grantee: RoleId, + pub grantor: RoleId, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SystemPrivilegesValue { + pub acl_mode: AclMode, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct AuditLogEventV1 { + pub id: u64, + pub event_type: audit_log_event_v1::EventType, + pub object_type: audit_log_event_v1::ObjectType, + pub user: Option, + pub occurred_at: EpochMillis, + pub details: audit_log_event_v1::Details, +} + +pub mod audit_log_event_v1 { + use super::*; + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct IdFullNameV1 { + pub id: String, + pub name: FullNameV1, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct FullNameV1 { + pub database: String, + pub schema: String, + pub item: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct IdNameV1 { + pub id: String, + pub name: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RenameClusterV1 { + pub id: String, + pub old_name: String, + pub new_name: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RenameClusterReplicaV1 { + pub cluster_id: String, + pub replica_id: String, + pub old_name: String, + pub new_name: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct AlterClusterReconfigurationV1 { + pub cluster_id: String, + pub cluster_name: String, + pub transition: ReconfigurationLifecycleV1, + /// On a `finalized` transition: whether the cut-over was forced by `ON + /// TIMEOUT COMMIT` at the deadline rather than reached by hydration. + #[serde(default)] + pub forced: Option, + pub target_size: String, + pub target_replication_factor: u32, + pub target_availability_zones: Vec, + pub target_logging: ClusterReplicaLoggingV1, + pub deadline: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct ClusterReplicaLoggingV1 { + pub log_logging: bool, + pub interval: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct ReconfigurationLifecycleV1 { + pub transition: reconfiguration_lifecycle_v1::Transition, + } + + pub mod reconfiguration_lifecycle_v1 { + use super::*; + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub enum Transition { + Started(Empty), + Finalized(Empty), + TimedOut(Empty), + Cancelled(Empty), + ResourceExhausted(Empty), + } + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct ClusterHydrationBurstV1 { + pub cluster_id: String, + pub cluster_name: String, + pub transition: HydrationBurstLifecycleV1, + /// On a `finished` transition: why the burst tore down. + #[serde(default)] + pub finish_cause: Option, + pub burst_size: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct HydrationBurstLifecycleV1 { + pub transition: hydration_burst_lifecycle_v1::Transition, + } + + pub mod hydration_burst_lifecycle_v1 { + use super::*; + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub enum Transition { + Started(Empty), + Finished(Empty), + } + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct BurstFinishCauseV1 { + pub cause: burst_finish_cause_v1::Cause, + } + + pub mod burst_finish_cause_v1 { + use super::*; + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub enum Cause { + LingerElapsed(Empty), + NoLongerWarranted(Empty), + } + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RenameItemV1 { + pub id: String, + pub old_name: FullNameV1, + pub new_name: FullNameV1, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateClusterReplicaV1 { + pub cluster_id: String, + pub cluster_name: String, + pub replica_id: Option, + pub replica_name: String, + pub logical_size: String, + pub disk: bool, + pub billed_as: Option, + pub internal: bool, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateClusterReplicaV2 { + pub cluster_id: String, + pub cluster_name: String, + pub replica_id: Option, + pub replica_name: String, + pub logical_size: String, + pub disk: bool, + pub billed_as: Option, + pub internal: bool, + pub reason: CreateOrDropClusterReplicaReasonV1, + pub scheduling_policies: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateClusterReplicaV3 { + pub cluster_id: String, + pub cluster_name: String, + pub replica_id: Option, + pub replica_name: String, + pub logical_size: String, + pub disk: bool, + pub billed_as: Option, + pub internal: bool, + pub reason: CreateOrDropClusterReplicaReasonV1, + pub scheduling_policies: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateClusterReplicaV4 { + pub cluster_id: String, + pub cluster_name: String, + pub replica_id: Option, + pub replica_name: String, + pub logical_size: String, + pub billed_as: Option, + pub internal: bool, + pub reason: CreateOrDropClusterReplicaReasonV1, + pub scheduling_policies: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct DropClusterReplicaV1 { + pub cluster_id: String, + pub cluster_name: String, + pub replica_id: Option, + pub replica_name: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct DropClusterReplicaV2 { + pub cluster_id: String, + pub cluster_name: String, + pub replica_id: Option, + pub replica_name: String, + pub reason: CreateOrDropClusterReplicaReasonV1, + pub scheduling_policies: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct DropClusterReplicaV3 { + pub cluster_id: String, + pub cluster_name: String, + pub replica_id: Option, + pub replica_name: String, + pub reason: CreateOrDropClusterReplicaReasonV1, + pub scheduling_policies: Option, + } + + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize + )] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateOrDropClusterReplicaReasonV1 { + pub reason: CreateOrDropClusterReplicaReasonV1Reason, + } + + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize + )] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub enum CreateOrDropClusterReplicaReasonV1Reason { + Manual(Empty), + Schedule(Empty), + System(Empty), + Reconfiguration(Empty), + HydrationBurst(Empty), + Retired(Empty), + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct SchedulingDecisionsWithReasonsV1 { + pub on_refresh: RefreshDecisionWithReasonV1, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct SchedulingDecisionsWithReasonsV2 { + pub on_refresh: RefreshDecisionWithReasonV2, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub enum RefreshDecision { + On(Empty), + Off(Empty), + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RefreshDecisionWithReasonV1 { + pub objects_needing_refresh: Vec, + pub rehydration_time_estimate: String, + pub decision: RefreshDecision, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RefreshDecisionWithReasonV2 { + pub objects_needing_refresh: Vec, + pub objects_needing_compaction: Vec, + pub rehydration_time_estimate: String, + pub decision: RefreshDecision, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateSourceSinkV1 { + pub id: String, + pub name: FullNameV1, + pub size: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateSourceSinkV2 { + pub id: String, + pub name: FullNameV1, + pub size: Option, + pub external_type: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateSourceSinkV3 { + pub id: String, + pub name: FullNameV1, + pub external_type: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateSourceSinkV4 { + pub id: String, + pub cluster_id: Option, + pub name: FullNameV1, + pub external_type: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateIndexV1 { + pub id: String, + pub cluster_id: String, + pub name: FullNameV1, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateMaterializedViewV1 { + pub id: String, + pub cluster_id: String, + pub name: FullNameV1, + pub replacement_target_id: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct AlterApplyReplacementV1 { + pub target: IdFullNameV1, + pub replacement: IdFullNameV1, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct AlterSourceSinkV1 { + pub id: String, + pub name: FullNameV1, + pub old_size: Option, + pub new_size: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct AlterSetClusterV1 { + pub id: String, + pub name: FullNameV1, + pub old_cluster_id: String, + pub new_cluster_id: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct GrantRoleV1 { + pub role_id: String, + pub member_id: String, + pub grantor_id: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct GrantRoleV2 { + pub role_id: String, + pub member_id: String, + pub grantor_id: String, + pub executed_by: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RevokeRoleV1 { + pub role_id: String, + pub member_id: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RevokeRoleV2 { + pub role_id: String, + pub member_id: String, + pub grantor_id: String, + pub executed_by: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct UpdatePrivilegeV1 { + pub object_id: String, + pub grantee_id: String, + pub grantor_id: String, + pub privileges: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct AlterDefaultPrivilegeV1 { + pub role_id: String, + pub database_id: Option, + pub schema_id: Option, + pub grantee_id: String, + pub privileges: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct UpdateOwnerV1 { + pub object_id: String, + pub old_owner_id: String, + pub new_owner_id: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct SchemaV1 { + pub id: String, + pub name: String, + pub database_name: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct SchemaV2 { + pub id: String, + pub name: String, + pub database_name: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RenameSchemaV1 { + pub id: String, + pub database_name: Option, + pub old_name: String, + pub new_name: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct UpdateItemV1 { + pub id: String, + pub name: FullNameV1, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct AlterRetainHistoryV1 { + pub id: String, + pub old_history: Option, + pub new_history: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct AlterAddColumnV1 { + pub id: String, + pub column: String, + pub column_type: String, + pub nullable: bool, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct AlterSourceTimestampIntervalV1 { + pub id: String, + pub old_interval: Option, + pub new_interval: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct ToNewIdV1 { + pub id: String, + pub new_id: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct FromPreviousIdV1 { + pub id: String, + pub previous_id: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct SetV1 { + pub name: String, + pub value: Option, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct RotateKeysV1 { + pub id: String, + pub name: String, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub struct CreateRoleV1 { + pub id: String, + pub name: String, + pub auto_provision_source: Option, + } + + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Serialize_repr, + Deserialize_repr + )] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + #[repr(u8)] + pub enum EventType { + Unknown = 0, + Create = 1, + Drop = 2, + Alter = 3, + Grant = 4, + Revoke = 5, + Comment = 6, + } + + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Serialize_repr, + Deserialize_repr + )] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + #[repr(u8)] + pub enum ObjectType { + Unknown = 0, + Cluster = 1, + ClusterReplica = 2, + Connection = 3, + Database = 4, + Func = 5, + Index = 6, + MaterializedView = 7, + Role = 8, + Secret = 9, + Schema = 10, + Sink = 11, + Source = 12, + Table = 13, + Type = 14, + View = 15, + System = 16, + ContinualTask = 17, + NetworkPolicy = 18, + } + + #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] + #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] + pub enum Details { + CreateClusterReplicaV1(CreateClusterReplicaV1), + CreateClusterReplicaV2(CreateClusterReplicaV2), + CreateClusterReplicaV3(CreateClusterReplicaV3), + CreateClusterReplicaV4(CreateClusterReplicaV4), + DropClusterReplicaV1(DropClusterReplicaV1), + DropClusterReplicaV2(DropClusterReplicaV2), + DropClusterReplicaV3(DropClusterReplicaV3), + CreateSourceSinkV1(CreateSourceSinkV1), + CreateSourceSinkV2(CreateSourceSinkV2), + AlterSourceSinkV1(AlterSourceSinkV1), + AlterSetClusterV1(AlterSetClusterV1), + GrantRoleV1(GrantRoleV1), + GrantRoleV2(GrantRoleV2), + RevokeRoleV1(RevokeRoleV1), + RevokeRoleV2(RevokeRoleV2), + UpdatePrivilegeV1(UpdatePrivilegeV1), + AlterDefaultPrivilegeV1(AlterDefaultPrivilegeV1), + UpdateOwnerV1(UpdateOwnerV1), + IdFullNameV1(IdFullNameV1), + RenameClusterV1(RenameClusterV1), + RenameClusterReplicaV1(RenameClusterReplicaV1), + RenameItemV1(RenameItemV1), + IdNameV1(IdNameV1), + SchemaV1(SchemaV1), + SchemaV2(SchemaV2), + RenameSchemaV1(RenameSchemaV1), + UpdateItemV1(UpdateItemV1), + CreateSourceSinkV3(CreateSourceSinkV3), + AlterRetainHistoryV1(AlterRetainHistoryV1), + ToNewIdV1(ToNewIdV1), + FromPreviousIdV1(FromPreviousIdV1), + SetV1(SetV1), + ResetAllV1(Empty), + RotateKeysV1(RotateKeysV1), + CreateSourceSinkV4(CreateSourceSinkV4), + CreateIndexV1(CreateIndexV1), + CreateMaterializedViewV1(CreateMaterializedViewV1), + AlterApplyReplacementV1(AlterApplyReplacementV1), + CreateRoleV1(CreateRoleV1), + AlterAddColumnV1(AlterAddColumnV1), + AlterSourceTimestampIntervalV1(AlterSourceTimestampIntervalV1), + AlterClusterReconfigurationV1(AlterClusterReconfigurationV1), + ClusterHydrationBurstV1(ClusterHydrationBurstV1), + } +} + +/// The contents of a single state update. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +// Serialize the top-level enum in the persist-backed catalog as internally tagged to set up +// persist pushdown statistics for success. +#[serde(tag = "kind")] +pub enum StateUpdateKind { + AuditLog(AuditLog), + Cluster(Cluster), + ClusterIntrospectionSourceIndex(ClusterIntrospectionSourceIndex), + ClusterReplica(ClusterReplica), + Comment(Comment), + Config(Config), + Database(Database), + DefaultPrivileges(DefaultPrivileges), + FenceToken(FenceToken), + GidMapping(GidMapping), + IdAlloc(IdAlloc), + Item(Item), + NetworkPolicy(NetworkPolicy), + Role(Role), + RoleAuth(RoleAuth), + Schema(Schema), + ServerConfiguration(ServerConfiguration), + ClusterSystemConfiguration(ClusterSystemConfiguration), + ReplicaSystemConfiguration(ReplicaSystemConfiguration), + Setting(Setting), + SourceReferences(SourceReferences), + StorageCollectionMetadata(StorageCollectionMetadata), + SystemPrivileges(SystemPrivileges), + TxnWalShard(TxnWalShard), + UnfinalizedShard(UnfinalizedShard), +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct AuditLog { + pub key: AuditLogKey, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Cluster { + pub key: ClusterKey, + pub value: ClusterValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterReplica { + pub key: ClusterReplicaKey, + pub value: ClusterReplicaValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Comment { + pub key: CommentKey, + pub value: CommentValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Config { + pub key: ConfigKey, + pub value: ConfigValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Database { + pub key: DatabaseKey, + pub value: DatabaseValue, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct DefaultPrivileges { + pub key: DefaultPrivilegesKey, + pub value: DefaultPrivilegesValue, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct FenceToken { + pub deploy_generation: u64, + pub epoch: i64, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct IdAlloc { + pub key: IdAllocKey, + pub value: IdAllocValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterIntrospectionSourceIndex { + pub key: ClusterIntrospectionSourceIndexKey, + pub value: ClusterIntrospectionSourceIndexValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Item { + pub key: ItemKey, + pub value: ItemValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Role { + pub key: RoleKey, + pub value: RoleValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct RoleAuth { + pub key: RoleAuthKey, + pub value: RoleAuthValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct NetworkPolicy { + pub key: NetworkPolicyKey, + pub value: NetworkPolicyValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Schema { + pub key: SchemaKey, + pub value: SchemaValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct Setting { + pub key: SettingKey, + pub value: SettingValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ServerConfiguration { + pub key: ServerConfigurationKey, + pub value: ServerConfigurationValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ClusterSystemConfiguration { + pub key: ClusterSystemConfigurationKey, + pub value: ClusterSystemConfigurationValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct ReplicaSystemConfiguration { + pub key: ReplicaSystemConfigurationKey, + pub value: ReplicaSystemConfigurationValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SourceReferences { + pub key: SourceReferencesKey, + pub value: SourceReferencesValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct GidMapping { + pub key: GidMappingKey, + pub value: GidMappingValue, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct SystemPrivileges { + pub key: SystemPrivilegesKey, + pub value: SystemPrivilegesValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct StorageCollectionMetadata { + pub key: StorageCollectionMetadataKey, + pub value: StorageCollectionMetadataValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct UnfinalizedShard { + pub key: UnfinalizedShardKey, +} + +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +pub struct TxnWalShard { + pub value: TxnWalShardValue, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Serialize_repr, + Deserialize_repr +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +#[repr(u8)] +pub enum CatalogItemType { + Unknown = 0, + Table = 1, + Source = 2, + Sink = 3, + View = 4, + MaterializedView = 5, + Index = 6, + Type = 7, + Func = 8, + Secret = 9, + Connection = 10, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Serialize_repr, + Deserialize_repr +)] +#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))] +#[repr(u8)] +pub enum ObjectType { + Unknown = 0, + Table = 1, + View = 2, + MaterializedView = 3, + Source = 4, + Sink = 5, + Index = 6, + Type = 7, + Role = 8, + Cluster = 9, + ClusterReplica = 10, + Secret = 11, + Connection = 12, + Database = 13, + Schema = 14, + Func = 15, + NetworkPolicy = 17, +} diff --git a/src/catalog/src/durable/objects.rs b/src/catalog/src/durable/objects.rs index f7f981a43fccb..45c2051eeb9f8 100644 --- a/src/catalog/src/durable/objects.rs +++ b/src/catalog/src/durable/objects.rs @@ -48,11 +48,19 @@ use mz_sql::names::{CommentObjectId, DatabaseId, SchemaId}; use mz_sql::plan::{AutoScalingStrategy, ClusterSchedule, NetworkPolicyRule, OnTimeoutAction}; #[cfg(test)] use proptest_derive::Arbitrary; +use uuid::Uuid; use crate::builtin::RUNTIME_ALTERABLE_FINGERPRINT_SENTINEL; use crate::durable::Epoch; use crate::durable::objects::serialization::proto; +/// A proptest strategy for [`Uuid`]s, which don't implement `Arbitrary`. +#[cfg(test)] +fn any_uuid() -> impl proptest::strategy::Strategy { + use proptest::strategy::Strategy; + proptest::arbitrary::any::().prop_map(Uuid::from_u128) +} + // Structs used to pass information to outside modules. /// A trait for representing `Self` as a key-value pair of type @@ -623,6 +631,9 @@ pub struct Item { pub owner_id: RoleId, pub privileges: Vec, pub extra_versions: BTreeMap, + /// `Some(uuid)` marks a temporary item owned by, and only visible to, the + /// session with that UUID. `None` is a normal durable item. + pub ephemeral_owner_session: Option, } impl Item { @@ -647,6 +658,7 @@ impl DurableType for Item { owner_id: self.owner_id, privileges: self.privileges, extra_versions: self.extra_versions, + ephemeral_owner_session: self.ephemeral_owner_session, }, ) } @@ -662,6 +674,7 @@ impl DurableType for Item { owner_id: value.owner_id, privileges: value.privileges, extra_versions: value.extra_versions, + ephemeral_owner_session: value.ephemeral_owner_session, } } @@ -1515,6 +1528,8 @@ pub struct ItemValue { pub(crate) oid: u32, pub(crate) global_id: GlobalId, pub(crate) extra_versions: BTreeMap, + #[cfg_attr(test, proptest(strategy = "proptest::option::of(any_uuid())"))] + pub(crate) ephemeral_owner_session: Option, } impl ItemValue { diff --git a/src/catalog/src/durable/objects/serialization.rs b/src/catalog/src/durable/objects/serialization.rs index 345d0b31ed742..d735d1999cba2 100644 --- a/src/catalog/src/durable/objects/serialization.rs +++ b/src/catalog/src/durable/objects/serialization.rs @@ -563,6 +563,7 @@ impl RustType for ItemValue { version: version.into_proto(), }) .collect(), + ephemeral_owner_session: self.ephemeral_owner_session, } } @@ -588,6 +589,7 @@ impl RustType for ItemValue { oid: proto.oid, global_id: proto.global_id.into_rust()?, extra_versions, + ephemeral_owner_session: proto.ephemeral_owner_session, }) } } diff --git a/src/catalog/src/durable/persist.rs b/src/catalog/src/durable/persist.rs index eae64da9ee3cd..ee59613e06989 100644 --- a/src/catalog/src/durable/persist.rs +++ b/src/catalog/src/durable/persist.rs @@ -1323,6 +1323,14 @@ impl UnopenedPersistCatalogState { txn.set_setting("migration_version".into(), old_version.map(Into::into))?; } + // Opening the catalog with write intent fences out every previous + // catalog owner, so all sessions served by previous owners are + // dead. Reclaim the temporary items they owned here, before + // anything else reads the catalog. + if mode != Mode::Readonly { + txn.remove_ephemeral_items(); + } + txn.set_catalog_content_version(catalog_content_version)?; txn } else { diff --git a/src/catalog/src/durable/transaction.rs b/src/catalog/src/durable/transaction.rs index 5c01ccbe3f80b..e15c174f18949 100644 --- a/src/catalog/src/durable/transaction.rs +++ b/src/catalog/src/durable/transaction.rs @@ -40,6 +40,7 @@ use mz_sql_parser::ast::QualifiedReplica; use mz_storage_client::controller::StorageTxn; use mz_storage_types::controller::StorageError; use tracing::warn; +use uuid::Uuid; use crate::builtin::BuiltinLog; use crate::durable::initialize::{ @@ -204,21 +205,29 @@ impl<'a> Transaction<'a> { schema_unique_fn, schema_unique_fn, )?, + // Temporary items from different sessions may share a name in the + // temporary schema (whose durable schema id is a sentinel shared + // by every session), so name uniqueness is additionally scoped by + // the owning session. items: TableTransaction::new_with_uniqueness_fn( items, |a: &ItemValue, b| { - a.schema_id == b.schema_id && a.name == b.name && { - // `item_type` is slow, only compute if needed. - let a_type = a.item_type(); - let b_type = b.item_type(); - (a_type != CatalogItemType::Type && b_type != CatalogItemType::Type) - || (a_type == CatalogItemType::Type && b_type.conflicts_with_type()) - || (b_type == CatalogItemType::Type && a_type.conflicts_with_type()) - } + a.schema_id == b.schema_id + && a.name == b.name + && a.ephemeral_owner_session == b.ephemeral_owner_session + && { + // `item_type` is slow, only compute if needed. + let a_type = a.item_type(); + let b_type = b.item_type(); + (a_type != CatalogItemType::Type && b_type != CatalogItemType::Type) + || (a_type == CatalogItemType::Type && b_type.conflicts_with_type()) + || (b_type == CatalogItemType::Type && a_type.conflicts_with_type()) + } }, |prev: &ItemValue, next| { prev.schema_id == next.schema_id && prev.name == next.name + && prev.ephemeral_owner_session == next.ephemeral_owner_session // `item_type` is slow, only compute it once name and schema match. && prev.item_type() == next.item_type() }, @@ -742,10 +751,20 @@ impl<'a> Transaction<'a> { privileges: Vec, temporary_oids: &HashSet, versions: BTreeMap, + ephemeral_owner_session: Option, ) -> Result { let oid = self.allocate_oid(temporary_oids)?; self.insert_item( - id, oid, global_id, schema_id, item_name, create_sql, owner_id, privileges, versions, + id, + oid, + global_id, + schema_id, + item_name, + create_sql, + owner_id, + privileges, + versions, + ephemeral_owner_session, )?; Ok(oid) } @@ -761,6 +780,7 @@ impl<'a> Transaction<'a> { owner_id: RoleId, privileges: Vec, extra_versions: BTreeMap, + ephemeral_owner_session: Option, ) -> Result<(), CatalogError> { match self.items.insert( ItemKey { id }, @@ -773,6 +793,7 @@ impl<'a> Transaction<'a> { oid, global_id, extra_versions, + ephemeral_owner_session, }, self.op_id, ) { @@ -781,6 +802,21 @@ impl<'a> Transaction<'a> { } } + /// Removes every item owned by an ephemeral session from the transaction. + /// + /// Used to reclaim temporary items when the catalog is opened with write + /// intent, at which point every session that could own one is dead. + pub fn remove_ephemeral_items(&mut self) { + let keys: Vec<_> = self + .items + .items() + .into_iter() + .filter(|(_, value)| value.ephemeral_owner_session.is_some()) + .map(|(key, _)| key.clone()) + .collect(); + self.items.delete_by_keys(keys, self.op_id); + } + pub fn get_and_increment_id(&mut self, key: String) -> Result { Ok(self.get_and_increment_id_by(key, 1)?.into_element()) } diff --git a/src/catalog/src/durable/upgrade.rs b/src/catalog/src/durable/upgrade.rs index 11c1266b2e817..d9c01a68b63a2 100644 --- a/src/catalog/src/durable/upgrade.rs +++ b/src/catalog/src/durable/upgrade.rs @@ -242,7 +242,9 @@ macro_rules! objects { objects!( [v74, v75, v76, v77, v78], - [v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90] + [ + v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91 + ] ); /// The current version of the `Catalog`. @@ -271,6 +273,7 @@ mod v86_to_v87; mod v87_to_v88; mod v88_to_v89; mod v89_to_v90; +mod v90_to_v91; /// Describes a single action to take during a migration from `V1` to `V2`. #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] @@ -484,6 +487,15 @@ async fn run_upgrade( ) .await } + 90 => { + run_versioned_upgrade( + unopened_catalog_state, + version, + commit_ts, + v90_to_v91::upgrade, + ) + .await + } // Up-to-date, no migration needed! CATALOG_VERSION => Ok((CATALOG_VERSION, commit_ts)), FUTURE_VERSION.. => Err(incompatible), diff --git a/src/catalog/src/durable/upgrade/snapshots/objects_v91.txt b/src/catalog/src/durable/upgrade/snapshots/objects_v91.txt new file mode 100644 index 0000000000000..0faed319dd0e2 --- /dev/null +++ b/src/catalog/src/durable/upgrade/snapshots/objects_v91.txt @@ -0,0 +1,100 @@ +CkIKQLoBPQofCgNrZXkSGLoBFQoTCgVzaGFyZBIKQggmwqUk4KmRPwoaCgRraW5kEhJCEFVuZmluYWxpemVkU2hhcmQ= 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 +Cq0BCqoBugGmAQp0CgNrZXkSbboBago1CgZvYmplY3QSK7oBKAomCgRSb2xlEh66ARsKGQoGU3lzdGVtEg/CAQwKCiVIVBBWWIhQI0wKMQoNc3ViX2NvbXBvbmVudBIgugEdChsKCUNvbHVtblBvcxIOwgELCgkRUGmYd0BQaUwKEQoEa2luZBIJQgdDb21tZW50ChsKBXZhbHVlEhK6AQ8KDQoHY29tbWVudBICQgA= +CpACCo0CugGJAgqqAQoDa2V5EqIBugGeAQqGAQoGb2JqZWN0Eny6AXkKdwoGU2NoZW1hEm26AWoKNQoIZGF0YWJhc2USKboBJgokCgJJZBIeugEbChkKBlN5c3RlbRIPwgEMCgooUFAzCRRkhTBsCjEKBnNjaGVtYRInugEkCiIKAklkEhy6ARkKFwoEVXNlchIPwgEMCgo4gSF2GYKQJmV8ChMKDXN1Yl9jb21wb25lbnQSAggEChEKBGtpbmQSCUIHQ29tbWVudApHCgV2YWx1ZRI+ugE7CjkKB2NvbW1lbnQSLkIs8JGMvy7wnqWf8JKSo9mEVPCen7niv7rwkKiVe3jhpINKNnvDjfCUjpJgXC4= +CokBCoYBugGCAQoaCgNrZXkSE7oBEAoOCgJpZBIIQgZQdWJsaWMKEgoEa2luZBIKQghSb2xlQXV0aApQCgV2YWx1ZRJHugFEChMKDXBhc3N3b3JkX2hhc2gSAggECi0KCnVwZGF0ZWRfYXQSH7oBHAoaCgZtaWxsaXMSEMIBDQoLAWWUMCR5BIeDRDw= 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 +ClwKWroBVwobCgNrZXkSFLoBEQoPCgNrZXkSCEIG8J+DkcKkChAKBGtpbmQSCEIGQ29uZmlnCiYKBXZhbHVlEh26ARoKGAoFdmFsdWUSD8IBDAoKIjRBhlkQlVdQnA== +CscBCsQBugHAAQpbCgNrZXkSVLoBUQo6CgZvYmplY3QSMLoBLQorCgpDb25uZWN0aW9uEh26ARoKGAoEVXNlchIQwgENCgsBESGIWCVlAHlYbAoTCg1zdWJfY29tcG9uZW50EgIIBAoRCgRraW5kEglCB0NvbW1lbnQKTgoFdmFsdWUSRboBQgpACgdjb21tZW50EjVCMy/wn5W0Z8OJefCepZPgprLIuvCWraHwn5W08JGwgPCehY468K65hvCRmaXwnrm5wqUxJw== +CqMBCqABugGcAQo0CgNrZXkSLboBKgooCgJpZBIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKA1VllUcYZEKDjAoSCgRraW5kEgpCCFJvbGVBdXRoClAKBXZhbHVlEke6AUQKEwoNcGFzc3dvcmRfaGFzaBICCAQKLQoKdXBkYXRlZF9hdBIfugEcChoKBm1pbGxpcxIQwgENCgsBKCd0M3KJU2SUfA== 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 +CrEBCq4BugGqAQpPCgNrZXkSSLoBRQoTCgdncmFudGVlEghCBlB1YmxpYwouCgdncmFudG9yEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBFDhQdHRoFFURHAoaCgRraW5kEhJCEFN5c3RlbVByaXZpbGVnZXMKOwoFdmFsdWUSMroBLwotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwETNXV4JhlWlVE8 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 +CmYKZLoBYQovChFkZXBsb3lfZ2VuZXJhdGlvbhIawgEXCgoBM5cRgEIxhZQsEP///////////wEKGAoFZXBvY2gSD8IBDAoKVIAkSVeAMTgyHAoUCgRraW5kEgxCCkZlbmNlVG9rZW4= +CmYKZLoBYQpDCgNrZXkSPLoBOQo3CgVzaGFyZBIuQixOJD/ho4vwn6K00ajDoDoiIibwkaSW762DIiZo8JKArfCdlJPwkLqx8JCkrgoaCgRraW5kEhJCEFVuZmluYWxpemVkU2hhcmQ= +CtkBCtYBugHSAQp9CgNrZXkSdroBcwoqCgpjbHVzdGVyX2lkEhy6ARkKFwoEVXNlchIPwgEMCgqSgpSIV0gJMyksCkUKBG5hbWUSPUI7LyLhi7Twnpe/XmBc44G3e1zwnouV8JGNkPCRpL974rS/JeCwpTQmbTzwkbCmw5TIuj9S4LOz8J65mT0KJAoEa2luZBIcQhpDbHVzdGVyU3lzdGVtQ29uZmlndXJhdGlvbgorCgV2YWx1ZRIiugEfCh0KBXZhbHVlEhRCEiTvv5Yn6qeZ8J2VjWlMNT8qcg== +Cq0BCqoBugGmAQpJCgNrZXkSQroBPwosCgpjbHVzdGVyX2lkEh66ARsKGQoGU3lzdGVtEg/CAQwKCiBliXJDJVOSAJwKDwoEbmFtZRIHQgXgtI7IugokCgRraW5kEhxCGkNsdXN0ZXJTeXN0ZW1Db25maWd1cmF0aW9uCjMKBXZhbHVlEiq6AScKJQoFdmFsdWUSHEIaPPCbhZHhpqLgqZ4r4YuFLvCQspIqe/CQp40= +CpIBCo8BugGLAQovCgNrZXkSKLoBJQojCgRuYW1lEhtCGfCRvrAl8JGDl1TDj3TCpeGwvNaOI/CWrLAKHQoEa2luZBIVQhNTZXJ2ZXJDb25maWd1cmF0aW9uCjkKBXZhbHVlEjC6AS0KKwoFdmFsdWUSIkIgPz0ubG5fXF3vv70n2JEzXCXhqqhgNnNje27wnLyGwqU= +Cn0Ke7oBeAo2CgNrZXkSL7oBLAoqCgRuYW1lEiJCIGBZI9Go4KujQ0RFVzPqoZU68Jarhi9ceSYvPOCqs3skCh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgofCgV2YWx1ZRIWugETChEKBXZhbHVlEghCBkZ48JOCiA== +CrABCq0BugGpAQpiCgNrZXkSW7oBWAoqCgRuYW1lEiJCIC4iIvCRpYNmOknRqOCmkCRt8JCMo8Or8JGkiUnwkaKlCioKCnJlcGxpY2FfaWQSHLoBGQoXCgRVc2VyEg/CAQwKCoUUQYCRJTIRJnwKJAoEa2luZBIcQhpSZXBsaWNhU3lzdGVtQ29uZmlndXJhdGlvbgodCgV2YWx1ZRIUugERCg8KBXZhbHVlEgZCBPCQnJQ= +CnAKbroBawoVCgRraW5kEg1CC1R4bldhbFNoYXJkClIKBXZhbHVlEkm6AUYKRAoFc2hhcmQSO0I5JPCflbQkOvCRiIrCpci64LqlJcKl8J+iuSHhmoU/VDRh8JGQk/CSkKXwkJ618J64u8OKUyInwqVg +CvIECu8EugHrBArUBAoDa2V5EswEugHIBArFBAoFZXZlbnQSuwS6AbcECrQECgJWMRKtBLoBqQQK9AIKB2RldGFpbHMS6AK6AeQCCuECChJDcmVhdGVTb3VyY2VTaW5rVjQSygK6AcYCChAKCmNsdXN0ZXJfaWQSAggECj0KDWV4dGVybmFsX3R5cGUSLEIqePCfqJjwnrqhQjLDm3sm4bOExbLwn5W06p+T86CFmizvrrdJe8OR4r6ICkQKAmlkEj5CPD88wrjwkKiNVvCfq4/tn4Jge1ZxIjrwm4qLJjV28JGkhuK2k1wlMTXgqY3gorpg8J67sXnwkKi44ambPAqsAQoEbmFtZRKjAboBnwEKKQoIZGF0YWJhc2USHUIbcX0vX/Ceubkne/CdjYngvafgrYN777+9ZCpZCjUKBGl0ZW0SLUIr4LaNUPCQj47hpaQq8J+qnmDwkICPXiXvvbQk8J+VtOChnlzvv73gv457Zgo7CgZzY2hlbWESMUIv8JCWqPCQoaYmTHJse3ZQWnvwn5W0LzJ70ajwkYyyPmhNIj1c4b+9PPCflbTCsUEKFAoKZXZlbnRfdHlwZRIGwgEDCgEcChYKAmlkEhDCAQ0KCwFziEdohgZmYROMChUKC29iamVjdF90eXBlEgbCAQMKAQwKLgoLb2NjdXJyZWRfYXQSH7oBHAoaCgZtaWxsaXMSEMIBDQoLARYDRhUHM5QndmwKOwoEdXNlchIzugEwCi4KBWlubmVyEiVCI2Ige+Czh1w977+94LeW4LCOJ+qvsvCdja8i8JCdpmDgrZcmChIKBGtpbmQSCkIIQXVkaXRMb2c= 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 +CpECCo4CugGKAgqsAQoDa2V5EqQBugGgAQorCgtkYXRhYmFzZV9pZBIcugEZChcKBFVzZXISD8IBDAoKkJRyAwhWBUFobAoTCgdncmFudGVlEghCBlB1YmxpYwoWCgtvYmplY3RfdHlwZRIHwgEECgIBXAozCgdyb2xlX2lkEii6ASUKIwoGU3lzdGVtEhnCARYKCVAJkmiTYXlTfBD+//////////8BCg8KCXNjaGVtYV9pZBICCAQKGwoEa2luZBITQhFEZWZhdWx0UHJpdmlsZWdlcwo8CgV2YWx1ZRIzugEwCi4KCnByaXZpbGVnZXMSILoBHQobCghiaXRmbGFncxIPwgEMCgoXE2aXJxhUUzQc +CpwBCpkBugGVAQpSCgNrZXkSS7oBSAosCgpjbHVzdGVyX2lkEh66ARsKGQoGU3lzdGVtEg/CAQwKCkFSlSmIlAkFZYwKGAoEbmFtZRIQQg7wkKCDw5Hhv6wk8J65rwokCgRraW5kEhxCGkNsdXN0ZXJTeXN0ZW1Db25maWd1cmF0aW9uChkKBXZhbHVlEhC6AQ0KCwoFdmFsdWUSAkIA +CvkBCvYBugHyAQqNAQoDa2V5EoUBugGBAQpqCgZvYmplY3QSYLoBXQpbCgZTY2hlbWESUboBTgo1CghkYXRhYmFzZRIpugEmCiQKAklkEh66ARsKGQoGU3lzdGVtEg/CAQwKCoRGRZZVVYgmOCwKFQoGc2NoZW1hEgtCCVRlbXBvcmFyeQoTCg1zdWJfY29tcG9uZW50EgIIBAoRCgRraW5kEglCB0NvbW1lbnQKTQoFdmFsdWUSRLoBQQo/Cgdjb21tZW50EjRCMvCeuLvIujPgp6BY8JGvtPCrnY4mLmXqrpHDgfCepJThnJXgsYYvVSdo4K2nNdGoLzpb +CpcBCpQBugGQAQpUCgNrZXkSTboBSgpICgNrZXkSQUI/6q+3cici8J+VtOGktOGLiGsk8JGPkOqslPCQspdqyLo74K2hdsi6J2bwnpOT4K2N8JC7gu+sk/CfmavCusKkChAKBGtpbmQSCEIGQ29uZmlnCiYKBXZhbHVlEh26ARoKGAoFdmFsdWUSD8IBDAoKKJlWEAk0hnd5LA== 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 +Cs4BCssBugHHAQpNCgNrZXkSRroBQwotCgpjbHVzdGVyX2lkEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFUB2FVk5dAcUhMChIKBG5hbWUSCkII8JG0hfCRpIkKJAoEa2luZBIcQhpDbHVzdGVyU3lzdGVtQ29uZmlndXJhdGlvbgpQCgV2YWx1ZRJHugFECkIKBXZhbHVlEjlCNy8u6paKJ8Kl3YHiuorwkYyDTzjgp5/wmIWK8JC6reKvhuqiqvCQso0q8JGyjsOT4oCD8J65iyo= +ClAKTroBSwotCgNrZXkSJroBIwohCgVzaGFyZBIYQhYmd/CQoLzIuiZe3p7wnoCXIj7vv71EChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +CnsKeboBdgovCgNrZXkSKLoBJQojCgNrZXkSHEIaeSbwkJav4KG48J6Cjzx54Kqy4YuA8JGwryYKEAoEa2luZBIIQgZDb25maWcKMQoFdmFsdWUSKLoBJQojCgV2YWx1ZRIawgEXCgoYF0QpE2UilAAsEP///////////wE= +CrsBCrgBugG0AQpeCgNrZXkSV7oBVAojCgRuYW1lEhtCGSJj4Z+kYNGoLu+qtHk9KvCRtpDhqpbhiZAKLQoKcmVwbGljYV9pZBIfugEcChoKBlN5c3RlbRIQwgENCgsBeFE5chJ1JkQ4nAokCgRraW5kEhxCGlJlcGxpY2FTeXN0ZW1Db25maWd1cmF0aW9uCiwKBXZhbHVlEiO6ASAKHgoFdmFsdWUSFUIT4bGF4ai5XPCRspnwkKSj0ahIJA== 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 +CqkGCqYGugGiBgowCgNrZXkSKboBJgokCgJpZBIeugEbChkKBlN5c3RlbRIPwgEMCgo1lVKUU1BzKWhsChEKBGtpbmQSCUIHQ2x1c3RlcgraBQoFdmFsdWUS0AW6AcwFCjsKBmNvbmZpZxIxugEuChYKB3ZhcmlhbnQSC0IJVW5tYW5hZ2VkChQKDndvcmtsb2FkX2NsYXNzEgIIBAohCgRuYW1lEhlCF/CSkqwuUiV7JHLDqPCflbRd8JG1o1M9CisKCG93bmVyX2lkEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwEWdmApd0QnKUMsCrwECgpwcml2aWxlZ2VzEq0EsgGpBAqdAboBmQEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBEIECUxE0JTVkjAo4CgdncmFudGVlEi26ASoKKAoKUHJlZGVmaW5lZBIawgEXCgoCMnU0dWEFgQJcEP///////////wEKLgoHZ3JhbnRvchIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLASVWdZdSmYdIQIwKcboBbgosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCndiUEaFmZMoYowKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKKQoHZ3JhbnRvchIeugEbChkKBlN5c3RlbRIPwgEMCgozYwIEmEAAIAk8CpwBugGYAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEkd5d2BBk1eUJcCjgKB2dyYW50ZWUSLboBKgooCgpQcmVkZWZpbmVkEhrCARcKChGIMkElgzOAACwQ////////////AQotCgdncmFudG9yEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgqRgUSSKCBDkpZsCnW6AXIKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgomMQYRYAlRE0IsCi0KB2dyYW50ZWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKChI4dzZzFkQochwKEwoHZ3JhbnRvchIIQgZQdWJsaWM= +ClsKWboBVgoVCgRraW5kEg1CC1R4bldhbFNoYXJkCj0KBXZhbHVlEjS6ATEKLwoFc2hhcmQSJkIk4Kma4KeHKfCQoILwnZWGL3EuLyXhja9g4ra+77+9MyUn4ZOV +CqwBCqkBugGlAQo0CgNrZXkSLboBKgooCgJpZBIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKmIdCchgJZ3FGHAoSCgRraW5kEgpCCFJvbGVBdXRoClkKBXZhbHVlElC6AU0KHQoNcGFzc3dvcmRfaGFzaBIMQgomcuCsmTTRqD1JCiwKCnVwZGF0ZWRfYXQSHroBGwoZCgZtaWxsaXMSD8IBDAoKVZRRJXMZhoSTLA== +ClsKWboBVgokChFkZXBsb3lfZ2VuZXJhdGlvbhIPwgEMCgoyAEGCkBCUlyksChgKBWVwb2NoEg/CAQwKCikpFgSCEggDdJ0KFAoEa2luZBIMQgpGZW5jZVRva2Vu +CrIBCq8BugGrAQpYCgNrZXkSUboBTgo3CgZvYmplY3QSLboBKgooCgZTZWNyZXQSHroBGwoZCgZTeXN0ZW0SD8IBDAoKJ1BnkVhRIXAjjAoTCg1zdWJfY29tcG9uZW50EgIIBAoRCgRraW5kEglCB0NvbW1lbnQKPAoFdmFsdWUSM7oBMAouCgdjb21tZW50EiNCIfCQgZbwkbWRWTwl8JG0vMi6XfCSkbJp8J2Xr+qltyRAJA== +ClwKWroBVwolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBNlI1QnGBdpCHjAoYCgVlcG9jaBIPwgEMCgpGYGUyVAFDN5EdChQKBGtpbmQSDEIKRmVuY2VUb2tlbg== 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 +CoYCCoMCugH/AQqhAQoDa2V5EpkBugGVAQoRCgtkYXRhYmFzZV9pZBICCAQKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAXaEZAlDCFMyhmwKFQoLb2JqZWN0X3R5cGUSBsIBAwoBTAooCgdyb2xlX2lkEh26ARoKGAoEVXNlchIQwgENCgsBM2B1h5cJdDgpbAoPCglzY2hlbWFfaWQSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKPAoFdmFsdWUSM7oBMAouCgpwcml2aWxlZ2VzEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKUxATlSV4VzBXHA== +CsMDCsADugG8AwqlAwoDa2V5Ep0DugGZAwqWAwoFZXZlbnQSjAO6AYgDCoUDCgJWMRL+AroB+gIK6wEKB2RldGFpbHMS3wG6AdsBCtgBChJDcmVhdGVTb3VyY2VTaW5rVjESwQG6Ab0BChAKAmlkEgpCCD08JvCfgqtcCpwBCgRuYW1lEpMBugGPAQpCCghkYXRhYmFzZRI2QjRRWiUvXC7vv71N8J6BkMi64K6qWSUqwqXwn5W0yLolLuGurC/gpqguJkciwqXdgPCRjK9lCiYKBGl0ZW0SHkIc0agq8J+fsMOE4YOHez86JPCeuKfCpVnwkKSLLgohCgZzY2hlbWESF0IVJuC3nPCfqavwkY+CN/CeuKd7NcO5CgoKBHNpemUSAggEChQKCmV2ZW50X3R5cGUSBsIBAwoBDAoWCgJpZBIQwgENCgsBNBgXYIIZInUZfAoWCgtvYmplY3RfdHlwZRIHwgEECgIBjAo4CgtvY2N1cnJlZF9hdBIpugEmCiQKBm1pbGxpcxIawgEXCgoBRIhyeFgVFzkcEP///////////wEKCgoEdXNlchICCAQKEgoEa2luZBIKQghBdWRpdExvZw== +Co8BCowBugGIAQpLCgNrZXkSRLoBQQo/CgNrZXkSOEI2PfCflbTwkI6RT9GobOCsr8OzL3bwlr6Pw4sq4LOs6qyVW1wm8J6FhyoqWfCWq7Eh8JGOi2Q9ChAKBGtpbmQSCEIGQ29uZmlnCicKBXZhbHVlEh66ARsKGQoFdmFsdWUSEMIBDQoLASORUTFjcil3Zzw= +CokCCoYCugGCAgqjAQoDa2V5EpsBugGXAQoRCgtkYXRhYmFzZV9pZBICCAQKKAoHZ3JhbnRlZRIdugEaChgKBFVzZXISEMIBDQoLAUhGB2KEmYgScJwKFQoLb2JqZWN0X3R5cGUSBsIBAwoBnAoTCgdyb2xlX2lkEghCBlB1YmxpYwosCglzY2hlbWFfaWQSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAYMHdDWGlkUESCwKGwoEa2luZBITQhFEZWZhdWx0UHJpdmlsZWdlcwo9CgV2YWx1ZRI0ugExCi8KCnByaXZpbGVnZXMSIboBHgocCghiaXRmbGFncxIQwgENCgsBWDBYGRkYSZVobA== +CqwBCqkBugGlAQpLCgNrZXkSRLoBQQoTCgdncmFudGVlEghCBlB1YmxpYwoqCgdncmFudG9yEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFDGXcBMTcoKFaMChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwo6CgV2YWx1ZRIxugEuCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKRSBSWUEWhWOHHA== +CqoBCqcBugGjAQowCgNrZXkSKboBJgokCgJpZBIeugEbChkKBlN5c3RlbRIPwgEMCgo3QpFwdxA5UnQsCiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQpKCgV2YWx1ZRJBugE+CjwKBXNoYXJkEjNCMfCQoLclXC8qRivwkKCB4bGI8J65rPCWq7TwkY6iP2/wkYiT76y+yLoq4KiPd/CfgJ8= +CrwvCrkvugG1LwowCgNrZXkSKboBJgokCgJpZBIeugEbChkKBlN5c3RlbRIPwgEMCgo0aAARAIZ3gohsChgKBGtpbmQSEEIOQ2x1c3RlclJlcGxpY2EK5i4KBXZhbHVlEtwuugHYLgorCgpjbHVzdGVyX2lkEh26ARoKGAoEVXNlchIQwgENCgsBEZeBZ1lQcUYQLAryLQoGY29uZmlnEuctugHjLQodChdhcnJhbmdlbWVudF9jb21wcmVzc2lvbhICCAIKji0KCGxvY2F0aW9uEoEtugH9LAr6LAoJVW5tYW5hZ2VkEuwsugHoLAqGEwoQY29tcHV0ZWN0bF9hZGRycxLxErIB7RIKQEI+77+i8JuylyRVPfCel79cJeG+t+Cuk3QmyLrwnrikP/CQv7PwnoSA8J+VtCXhnqA8U+GlgOCmqnIlc1d7wqUKD0IN4KyBOtGo8JCetWMqIAoZQhfgrp8x8J+VtOCvguGJjXvvv71U8JGKiwoEQgI6PQo4QjZgKi4kaCZq4rasYPCQuqkvJ/CflbTvv6Hitq0n8JCjtHjwlqqALydv4rSt4b2B8J+qsfCflbQKB0IF8J6ij1MKNUIzIOG9lExx8JCegO+3jy8v8JGxnENXwqXDmSLhsY88RCcuIOG/tE1aPfCRkorwnpetw5J7CitCKULgs6jDpMKlwqVA77mh8Ja/sOCpgi/wlqukJzY/4aq4eyIuIybwn5W0CilCJyckdPCQq6vhiZHwlr+wPdGo4KuQwqXgs50n4rqWJDhg6q+2MeGLqwoeQhwiUOC6gfCQqZA8bfCQoLwqSEku8J+VtGDDg8KlCipCKFUlJOGcjC/qmIjCofCflbQiZyfwnrux8JGCviQ576q98JGWsjEvOy4KKkIo4oaHbO+/vWBgwrN64LWH4LWN77+9PCnCqPCRm5ZgP8OCyLrYmlwnaAoyQjDwkYyPZC4iPT928JGnlPCQjLlW77+9PCZLP3Ditr7hv7nwkLSyX+GJjC5KPEHDkk0KDkIMPEvqp5dg77+9OtGoCgJCAAoxQi8zwqbvvJ3wkJelIDY/Lz0vJSIt8JGKmHsvcmht8JGDglLgqK48JFXCpVww4K6FPwo3QjXwn5W077+9wqXvv73wsISp8JCGgeGiiTTwkbSUOmA6yLokQijRqPCeuoN5e+ChmPCQlpTVtAoRQg/IuuCoh+GbuD3qoYl4KlwKFUITNvCRpInhna49Oi/DvSXwkIWMPApGQkRmL+G8mD9b8J+vryfhq4MkS+qpojs/4YONP0o94b+04Z2HQjnwn6+ARPCdlJBh4aGq8JCmo/CflbTgprLhvYwn8JGDtgoTQhFJaPCegYxcyLpTbMi6L+CthwoHQgUnOuGlgAo9QjvRqHfwkKS/8J2Yie+/vfCQtaXwkISCLiJg8JG+sCrgsYgvJPCen67CpdGo8JCBmGDwnZKqKi8iPDslLgpFQkM48JG0vFzvv73wn5W0JvCepZ7wkK6v8J64gsi6yLokJ8KlJEnwkY+H8JGOiPCRjYgn8J2Ss3s9Y28he8i64KqFJigiCiNCISVgXNGo8JCol1UneiLvrYFFIkRKYOCpkUwqfeC8iDwnKgpHQkXwnoCd8J+qnyLwnou/4raVKvCRv6XgsrYlPOGOj++/vfCflbQ88J+hguC0mlHvv73wkY+CIyLgqZvXky/wkbSF8J65m34KQUI/JuqsqOGmnDzwnp+o8JGkgNyr4K6DOsKlOlJ7e/Cdk4IhyLrhlbpg4L+JJE0k8JGvslzitIvCsSdgKvCQlLksCitCKSfwkKedWjrhvZvCsmAkOipjLyzgqbTwkYyuw4LIuuKAhdGo4KuJ4KGRChZCFG7VqNGo4Y2f8JChgOC2vVLDnSY8ClZCVPCeuI/wnLyGKEPgrajwnYSML2Pvt48m8J6ftuqgtyzwkY+X8J+hpvCfoqHwn5W08JCSsPCbhZLvv6Hgr43vv709YPCQsqck4K208LKDpDwi4K6kVQpCQkDwkaSV8JGkve+/vfCQvr5uefCRiqXwlq2c77iOIvCdi4nvv71N8Ja8jO++uW89PeGJje+/vT1w6p+TKsKlSDFRCh1CG/CeuZ3wn5W0OuG9my9t8JCmviVtMUDIuuqlvAoGQgTwkY+CChFCDyXwkKS/OsOf8J+tm+CpngoSQhDvv6YlJsi6VPCeuKfwn5W0CixCKnvwkIGDYPCQubrio7vgr4ckOmd6RPCRjIkl8JCBlm3wkY+HOXouNuC+iQoWQhThirNJL3vwn5WQaX7hvJwzPeqlvAorQinwnrqYzb7gso8v8JCcqi7wrL6CI+OFvci64LCx4KmcePCeuoB78JGYlwoQQg4iyLrhs6Hwn6qJ0ajDjwoPQg3vv71nL+qrny5uO8i6CgxCCvCflbQm8J2NkycKL0It0ahgL/CflbTCpfCdna4qLi9GzpRL8JG1ujrvrYHivpjvvoAh4b+GbvCflbQkCgRCAiovCjdCNfCRtInwkY+IU/CbhaXgpovwn5+PQTNtJeGdkCztnrkvNOCskHYn8JCEgHvgq6cs77+9zowqCiRCIk0m4YOHSntB4KeiPeGftPCdkp5qMmNB4LecJz/wkbWERy8KIUIfQC3vv71cJmDwkKm977+98JGMh++/vXtv4Lql4ZyyPgoKQggpc9GoYCzWjgpDQkHIuuGLgPCRmJQufSXhpbTCpci6JfCeoKds8JCWlDpBJvCQk7LhkKFR8JCKl1fwkYSXwqXDrO+/vfCbgpfwkLuDQQoKQgjwkIC98JGKkAoEQgI6LgoDQgE/CgxCCtGoP2Z78JuygC0KEEIO4aSn8JGxv+CqkVM1Ik4KOEI2cSJg8J+VtPCflbRcJPCQlIAwS8KldGvigKRLJeGLmD8mbmB74YuAw5bgqq3gpq0ifvCflbQ6ChhCFicl4LCyaHZqJmBcLz0k8JGmoPCRnKIKR0JFO/CRjZdc8J+VtDt6PPCRjLPgt5DqqZZEPNGo44Ge8J+VtO+/vfCdlLPRqGsq8JCwoW/wm7KCNGDvv5xx8JGatvCRipgkCi9CLUTwkbK0PWDwn5W08JG1hO+/vWvwn5+wdu+6jSQ9bfCRj5TwnqSdIvCdgbk5XAoxQi/wkayG8J+VtMiHw5tb0ajIulzSgWDwn5W0ZfCflbRV4LeBOz3gtrHDi3ZUPOGelgoPQg3wkKS/YOK6iSDwnZK/CilCJ8i6PPCRpInqrIZM8J60kTonJGAu8JGPijzRqGk9LiLIuvCeuaRLQgoGQgTgp414CipCKEQq8J+VtPCeupTgsaDgqIYiKvCRkrXigJhoQ9GoJSTVkj/hiZhKPDwKJ0IlOHHgu53wn5uhISY98J2Sqe+5l+qpiVhK8JCkvzrvrYEi4oGKVQoVQhPDj/CQk5Lhqoln8JGMh1nhvbR7CitCKcKlaeC4jsKlQyIhIvCQua1Ew6jIuiImL+CotcKiPPCQnqLitrJaYCJWCkBCPvCQpL9RPmnwn4OmTe+5hi5gOuCpruC7lix58JG2keC1syJSTSnDm+Cqj1ci8Jq/vuCzgO+/vUdcLFnwkJWbCtwZChBzdG9yYWdlY3RsX2FkZHJzEscZsgHDGQoqQijwkZiZ4Kyu8JG0hiJJ77+94K+LbdGoL31fUe+tgUc/JfCeip1VKsKlCgVCA9iiYgoDQgEzCjdCNSLgrpzwkKSw4Z2v8J6kmmfwnYuF8JG1kTrRqCYvPDM60ajhnbPgsZbIusKzeEvwkZywJMOJCitCKS7RqDolOifwkJGtJiI4e3LwkamhPdGoPOG8suCmj/CQhI17PD3wkKCICgJCAAoCQgAKHkIcIDFXJmMm8JGOkiI68J+VtCrhg4cpXOKClMOAaQpGQkTvv73vt4/gt6rwkbyq8JK+tfCQlo9H4Ky4w511SDwi8JCGoPCdkrtyRWQ6fCVc4La96pOzPfCRj6HhvZvwkaSWXOG8mQoiQiDgsZlU4YONKS43XDQvIvCeuY9lYvCQp59LJSbCpTxzIgpKQkhoWGA/XC9gMSjCsvCQra7wnrqiVF8q4KCU8J6fqPCQoIhH8JGrnFjwmr++deCzlVThqpXwkJaH8J66hT/wnY2T8J2GtPCQubgKIUIf8J+hpjLvv73qoLI944S1XifwkJOH4KmtMsOM8JCiqgpCQkDWjTzqqZZgJeCyjvCdnLbwkKO9JCQ84LqB8J+VtMKlw5nvv70n4oSGe/CehJ8/cCY64KuQeiLwkLuDP/CQgJdIChpCGGXOiPCeuqFgOSpj4KGe8J60pOqvlntUPwoOQgw68JCAgHtV0ahkQEwKLkIsNjdB8JGKl1vgq4jwkYWwL2LhoJN6IiJeMvCQoLw9JTXwkbG3WfCRj4rhjJUKCUIH6qGCOMKpYQokQiI1OiZOP++tg/CbhLLIuvCdkLhNOjrDtOqrqOCvlyTwn5W0CjJCMPCeuqcuRD86a2LhjrHwnqSaRPCfqbF8efCRtJfIuvCRjIvwnZKI4LOdXHvwn4e5PwoKQghEJfCQgJMlJAoCQgAKG0IZJu+uh9Go4bKlwqXwn6u1w5BgLnvhpo5feQozQjHRqPCeuYLgsKpl4aqZLuC4oCbwkY2QLiLCtfCQoLjgp4Tgt5w48J2UqvCbhZHwkJ2OCjRCMipg4rWCdPCumYhc8JCBhfCfiZF2JjnilZPwn5W0TWvgs5Umwr9jZ/CQrq7wnYSQyLovCitCKSbXsCXDksOb8J65jjzgtqVJ4LKtL/CQv6Y5KPCRipVoOcKl4Z6z4aSyCg5CDPCen6FgPW5U8J6TmgoIQgbOny4oVD0KOUI317B78JGkheCmuWHigJVK4rGnOnlv6qyV8JCdjPCQnZJlRlE8avCfiZEvPz/CpOCqg3jwkbaRXAobQhlWYPCSkbLwkIGEa/CRlr7qnZfwkIGQPcKgChlCF/CQhptS4Ku5ZjbwsZu9ciLRqMOOTk85CjdCNci6w7zwlq2UTzfwkY2Q77+98J+VtF8vYkl18J+qiSIiOFTwkbSgL3vgoofwlqmk151CaMKlCjRCMvCWo6B24K+LJzjwkLmo4LGd8JGcv3XRqF3vv71WJMO88J+VtFxqLuCtquCngsOo77+9CjpCOOCziFzwkoWhYHxF4La48JiIlvCRjZcvJWAk4aSiLvCQl5wt77+9XFzwlq2/POCtiFDwkaCnISd5CiFCH/CflbTwkbaQPnt04b+zX+GciuGKoyRD8J6fpH3gs4YKMEIu4LGBInxX34glJNGoKiUvJ+qvtSMlYfCRmarqpaXvv71g8JGXlmY/J+CwvcKlcAoXQhXwlqC8yLrdqsO3bHIn77+9JOG9nWEKNkI0KkPgqIrRqPCRsJNO8JaujCLvv70qV+CnjvCQlp164KmZJ/CRmoRv1bTwkKC8wqV2YyY8Igo3QjVswql26qihdCXhv7RtKPCflbQ/euC2u/CfnIzwkKGZYPCYoIhkJ1wmKsKnY/CQgZjCpTp7YAolQiPwn5W0PEPwnYC3VuC7gSZN4q6Aw45O8J65ufCRhZzwnoWPPwo4QjYuJjTvtrovI/CRpYQ/8J+VtDAm8JGnnV578J+isz14IvCQh5XwkZqiPS3gsafgp6B9JTXgp4cKQkJA77+9JOqfkz0u8JC6o+CviMKq8JGcly88PCzwnZWGaHfIusi6Xi866qelPfCTkZPWjs6JUPCepLxl8Jargu+/vQo0QjLIuj3wkbWlLj3wkK26XOCpkfCRhK9cJPCQsJIl4Ku7P+CytVDwkLWSJC7vv73IuuqvtApGQkQ26qyKJ/CfiZHwn6ir0ajwkYqj4K6QPD98ZPCWubRcwq49e/CtlLfwkYOkSHvhvJjwkJa78J+MueC7huOAuvCQhqA/RQoNQgvqp4fhvZllZOqflgoRQg8oL/CRkInjiIM+w6sqKjIKLUIryLrwmK6K8JGNg+C4p+G9m/CflbRb4LG5JSJV8JColWXwnqS+8J+JgDw6LwohQh/wnrmXWOqfmGA0dic9e+qsjPCQp57vtq1oT0N2e8i6Ci9CLfCRpInwkJazzoTwkYyy3Inwn6Cn8J+vrirgvqfwkKCIPCQ/8JC+t04/8JC5oAoYQhbgtInwlr+xLUnwkbKU44ObfvCflbRfCgdCBWrwn4OJCkNCQSRx8J6kjiXwnZSjMvCQoox74YuDZc29W2YnP+C7mPCQjqHCu2BFYH3hn4fwkL2O8J+hufCQv6dH8JCdky7gqLggCiJCICLwn5W04oOh8JCNiS/wkY+A4KGe8LGIqPCQoaA/JCpACjlCN1Dqk4HwnrmdJi/wn5W0IlzwnruwPeC6nPCYrZ5g4LC1YDJZ4bGG8J+JgvCeuZnwnrmU4KegyLoKFkIUe8KsLOCtiC514Yma8J+VtCdgXUYKE0IR8Juwv1Z7cD9a4rWBLuqbkz8KFUITe/Ceua7wkJa2XFrwnZSB4K6PJwoQQg7wnZSHU1kkzbwl44KLIgoHQgUlcuGLkQpIQkbRqCQl8J6AoO+/ofCfgIngtbjwkYqfwqzgso7grZ9cM/CRmp5ESldgJPCQlpQsJuCsj/CRj4LwkJSn8JCUgiciWvCbsLMxCjpCOHI8eG/gqZEmOfCeuZs7YyrwkaS/YMO48J+YosKlUT1u8J2SnvCRh4hSI+qpjNGocDQ8S8O1O8i6Ch1CG1hs8J2Upy9hJ/CRr7RcJeqqo/CdvJXhpKJ1bgoTQhFAJ2A60ajgsZ0qwqXwkbGDWgoEQgI6YAojQiHwmr++16BLIsOD44C14rSt8JGWoGQ/X/CQl7LwnqKian0KKUIn77mz7Z638J6XnfCQlJTDqGzwkKeF4LGjw6Tvv4zwkIC8T3jWrSdXCgJCAAo+Qjw38J+JhkHwkaSsXC4/8J2DplpyPPCSkbF9ZHHwka+UJfCutpvDnTrDrlXhoLs6RyxS8JCOheCoifCbhZUKFUITUPCfqbLwmK2q8J2SuyIp0agiPAo7Qjngq4ArcPCRvZnIuvCdi7HIuuCok/CflbTitrQ68J2NtvCRiopA4reIwqVGJ/Cfm6hB0ajhpoU/LzwKREJCUnvwkKO14b2bV/CRjYPwkbS04LeE4LOyXHYk4raiyLrwn4K9JPCRjaNh4KysTvCSvrwt8JGBqeCsrPCQsYYu4KyqCgtCCdGoP/CRpYBGXAowQi4n77+EXOC0kMKlyLouNuGLgsOd6qqK4KmsIiZAfeGdrvCRsIUvVSR88JGqnlw5Cj5CPO+slvCRjLg98JGPhSbwkIyxJGDjgq7wn66qRSp8N9Go8J+VtCZ58JCKlPCRjqx78JC0oyfgr5dEXitXLgoLQglSLsOU8J+VtDwKPEI6KT858JC9j/CRtaTwkLS14Z2yZuK1r/CRtLzwm4mI0ahw76y7MVI+4oWLTlxg0ag88J+VtO+sleG9gwo7Qjl74LWuJ+Gxo/CflbRremZ3XC864LeK8JCorOC6gcOX8J6fq/CbsbTDrn148J+VtMi6OEfwnrmJXC4KDUILKz0n8JCng0U/cnUKBkIE8J2LrQoTQhHwnZKicdGoWmzvrYEuw7MkcAotQivwn5W0LiXDiS8nOSLitqDqrZc8buCxjfCQuq1Ue/Cfg43DjXt5bF7gq5BdChtCGSXwkK2M8J+VtPCRgpZi8J2ciOC1lvCRrIcKEkIQcOCrkElW6qmV6qGI8JCPiwokQiJL76274aCSLuqStjw60ahr4aSI8JCTptGoaUc8PyckyLo1CjBCLiRofnrigpfDknvIuiQ2yLon4KiCPPCRtYNeanjIusi6JPCQlI1vMjrwkKCIKnEKL0ItJuqsreCzoT4i4K6O8J65umByZT0k8JuBkvCRu63wlr+k15NBMvCflbQlJ9GoCg9CDfCfn6RN8J+jgTpRe1gKNkI08Ja9usi6JsK/8JCiiH7wkLuDyLrhorZiLjHCpVHwkJaS8JapqCp4wqVhdiLwnqOOwqPRqAoxCgdsb2dnaW5nEia6ASMKDgoIaW50ZXJ2YWwSAggEChEKC2xvZ19sb2dnaW5nEgIIAwoeCgRuYW1lEhZCFFBKaeK3lfCQpppl8JGkvyQqZjMuChQKCG93bmVyX2lkEghCBlB1YmxpYw== +ClwKWroBVwolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBMXlnBkgHcSIpHAoYCgVlcG9jaBIPwgEMCgowGSZpMWZRAhAtChQKBGtpbmQSDEIKRmVuY2VUb2tlbg== +CmcKZboBYgojCgNrZXkSHLoBGQoXCgRuYW1lEg9CDSXwn5uoPO+/vV7grK4KEQoEa2luZBIJQgdJZEFsbG9jCigKBXZhbHVlEh+6ARwKGgoHbmV4dF9pZBIPwgEMCgoXMFg3VnhYKBFM +CpUBCpIBugGOAQo0CgNrZXkSLboBKgoTCgdncmFudGVlEghCBlB1YmxpYwoTCgdncmFudG9yEghCBlB1YmxpYwoaCgRraW5kEhJCEFN5c3RlbVByaXZpbGVnZXMKOgoFdmFsdWUSMboBLgosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCoU2I4UmOYRjgmw= +CpsRCpgRugGUEQovCgNrZXkSKLoBJQojCgJpZBIdugEaChgKBFVzZXISEMIBDQoLAXd1FwaJAUeUZFwKEAoEa2luZBIIQgZTY2hlbWEKzhAKBXZhbHVlEsQQugHAEAoRCgtkYXRhYmFzZV9pZBICCAQKMAoEbmFtZRIoQibhp4N5YGDqqYEiOu+suXsw4oKL4aqRbPCuuLVkSsKo4LK9RljCpQoSCgNvaWQSC8IBCAoGAZKGJDdsCigKCG93bmVyX2lkEhy6ARkKFwoEVXNlchIPwgEMCgqASEI1MUZSFHJMCroPCgpwcml2aWxlZ2VzEqsPsgGnDwqSAboBjgEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgp5eQSEBXFBBVc8CigKB2dyYW50ZWUSHboBGgoYCgRVc2VyEhDCAQ0KCwGBBTGINJFgJQJsCjQKB2dyYW50b3ISKboBJgokCgZTeXN0ZW0SGsIBFwoKATF4ZpGFOAhVfBD+//////////8BCoYBugGCAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCpEwZjeCQSmEKDwKKQoHZ3JhbnRlZRIeugEbChkKBlN5c3RlbRIPwgEMCgo4kRZAGBKHc4GcCicKB2dyYW50b3ISHLoBGQoXCgRVc2VyEg/CAQwKCpkwlQVBdWRDU2wKjQG6AYkBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKMUlAFjhYFnQhnAouCgdncmFudGVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBJCFkWTZTeAAHHAopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKCkhUQyl4hVcAKHwKjAG6AYgBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKSAAFYwMHY5WWjAooCgdncmFudGVlEh26ARoKGAoEVXNlchIQwgENCgsBASd1ggABAxYzXAouCgdncmFudG9yEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBQ2lJhJGBQHZHTAqWAboBkgEKNwoIYWNsX21vZGUSK7oBKAomCghiaXRmbGFncxIawgEXCgoIgnlTgIRXNwRMEP///////////wEKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLASInYwdVRjY1lDwKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKZTc1KGZzBYNRbAqHAboBgwEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBEld5J5FSRBODHAonCgdncmFudGVlEhy6ARkKFwoEVXNlchIPwgEMCgo5Q4EkNRSCV0aMCikKB2dyYW50b3ISHroBGwoZCgZTeXN0ZW0SD8IBDAoKNJBiGBIIBGMYLApxugFuCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLATEhVEGTCWaAhiwKKAoHZ3JhbnRlZRIdugEaChgKBFVzZXISEMIBDQoLAUJGiWE5lFggBTwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKjAG6AYgBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLARhTI0hzOGJph4wKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLASUwAnmDEQSXR1wKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKlxQyVocYJSMUHAqLAboBhwEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpXgUhEA3k4OBZ8CicKB2dyYW50ZWUSHLoBGQoXCgRVc2VyEg/CAQwKCmRWSIOXNBYmdSwKLgoHZ3JhbnRvchIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLARQEBghAZUBHFiwKlQG6AZEBCjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKAWGVeHcZJzZwfBD///////////8BCioKB2dyYW50ZWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAWeRMQZZNSBmASwKKgoHZ3JhbnRvchIfugEcChoKBlN5c3RlbRIQwgENCgsBJCSElmkjiYCSHAqIAboBhAEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBJgCHURAWh0MVjAonCgdncmFudGVlEhy6ARkKFwoEVXNlchIPwgEMCgophnA0WCiZeSh8CioKB2dyYW50b3ISH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAWQFhjVHAQcUQWwKdroBcwosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCiJ2ZpREVxYkKZwKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAUcXCXNTBpEFYkwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKhwG6AYMBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLARE0SFBCdEJ1F2wKJwoHZ3JhbnRlZRIcugEZChcKBFVzZXISD8IBDAoKaIIZIRN2JYOTPAopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKCmd1SJZml0MRAVwKjwG6AYsBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAXFBJRBYR3UEMywKKgoHZ3JhbnRlZRIfugEcChoKBlN5c3RlbRIQwgENCgsBNGOQBwNmZQWIfAouCgdncmFudG9yEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBcQcRU0MydWEBTA== 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 +CqABCp0BugGZAQpQCgNrZXkSSboBRgoXCgRuYW1lEg9CDe+/vTon17BgNOGspj8KKwoKcmVwbGljYV9pZBIdugEaChgKBFVzZXISEMIBDQoLAWGQJ5RnAwgBYBwKJAoEa2luZBIcQhpSZXBsaWNhU3lzdGVtQ29uZmlndXJhdGlvbgofCgV2YWx1ZRIWugETChEKBXZhbHVlEghCBndH4LCrOg== +CqUBCqIBugGeAQo3CgNrZXkSMLoBLQorCgRuYW1lEiNCIfCRjLV9yLpK8J6lkcK3IvCflbQ/8JCtjuCqkWNcOuC/iQodCgRraW5kEhVCE1NlcnZlckNvbmZpZ3VyYXRpb24KRAoFdmFsdWUSO7oBOAo2CgV2YWx1ZRItQivRqGwlayUg8J6fqtGow6lDJCo98JGjv+K2kFfgsYE98JGZlj7gsLXwn5W0 +ClsKWboBVgokChFkZXBsb3lfZ2VuZXJhdGlvbhIPwgEMCgoQkleVE5J0QlmMChgKBWVwb2NoEg/CAQwKCjhIA5doJjOYGE0KFAoEa2luZBIMQgpGZW5jZVRva2Vu +Cl8KXboBWgoVCgRraW5kEg1CC1R4bldhbFNoYXJkCkEKBXZhbHVlEji6ATUKMwoFc2hhcmQSKkIo8JGkiUTwn5W04LuGJzFuSfCeuZHwn56UJiI/8J+VtDxcJz0pe+Gjng== +CqoBCqcBugGjAQovCgNrZXkSKLoBJQojCgJpZBIdugEaChgKBFVzZXISEMIBDQoLAXEjmWZmISMoFIwKIwoEa2luZBIbQhlTdG9yYWdlQ29sbGVjdGlvbk1ldGFkYXRhCksKBXZhbHVlEkK6AT8KPQoFc2hhcmQSNEIyJyIuYDZ38JCetydOzonwkYWDKVwp8J+fsFAv4b+f8J+fpy/wkY2IZVI88JCdhPCRq44= +CqQBCqEBugGdAQo1CgNrZXkSLroBKwopCgJpZBIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLATFSQXAQcgRXckwKEgoEa2luZBIKQghSb2xlQXV0aApQCgV2YWx1ZRJHugFEChMKDXBhc3N3b3JkX2hhc2gSAggECi0KCnVwZGF0ZWRfYXQSH7oBHAoaCgZtaWxsaXMSEMIBDQoLATdVEiYTJicjFxw= +CrsCCrgCugG0AgqCAQoDa2V5Enu6AXgKJgoLb2JqZWN0X25hbWUSF0IV4L6yXPCfoIck8KqDvMOUL35+OnJtChUKC29iamVjdF90eXBlEgbCAQMKAQwKNwoLc2NoZW1hX25hbWUSKEIm6qeT6p+a8J6TnPCQlrPvv73vv73wkaq+VeCxlu+svvCel7MuXiQKFAoEa2luZBIMQgpHaWRNYXBwaW5nCpYBCgV2YWx1ZRKMAboBiAEKHgoKY2F0YWxvZ19pZBIQwgENCgsBcnM4l3kiMDcpPApICgtmaW5nZXJwcmludBI5Qjfhm6068JC2jvCflbQ6JeCviHsq4ayH8JGMv/CQvL0/8K+htPCeuqg6WO+ttUbqorXgupHwkbS8ChwKCWdsb2JhbF9pZBIPwgEMCgpXZpMlEChjIFWM +Cs0BCsoBugHGAQp3CgNrZXkScLoBbQo2CgZvYmplY3QSLLoBKQonCgZTZWNyZXQSHboBGgoYCgRVc2VyEhDCAQ0KCwFlCAM0cIkGVTZsCjMKDXN1Yl9jb21wb25lbnQSIroBHwodCglDb2x1bW5Qb3MSEMIBDQoLATZgZpFpZQWRAIwKEQoEa2luZBIJQgdDb21tZW50CjgKBXZhbHVlEi+6ASwKKgoHY29tbWVudBIfQh1I4K6fLXFgLyVL4KiB0agx6qC2JvCQqYbwn5W0Lg== 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 +Cm0Ka7oBaAorCgNrZXkSJLoBIQofCgNrZXkSGEIWIeCxmvCeuKTwkJKj4ZuX4ZG88J2SrAoQCgRraW5kEghCBkNvbmZpZwonCgV2YWx1ZRIeugEbChkKBXZhbHVlEhDCAQ0KCwGAd3VjZxKUZAQ8 +CqQBCqEBugGdAQo1CgNrZXkSLroBKwopCgJpZBIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAQN1gndHkoYndSwKEgoEa2luZBIKQghSb2xlQXV0aApQCgV2YWx1ZRJHugFEChMKDXBhc3N3b3JkX2hhc2gSAggECi0KCnVwZGF0ZWRfYXQSH7oBHAoaCgZtaWxsaXMSEMIBDQoLARlxZ5ZZdYSZJ1w= +CuABCt0BugHZAQp4CgNrZXkScboBbgo/CgRuYW1lEjdCNe+/vfCQloYuSU49beCnnMOQwrvwkKO80ahc8JGkicOf4LCZ4Ki24reSYF3bl/CQs5ci4LqJCisKCnJlcGxpY2FfaWQSHboBGgoYCgRVc2VyEhDCAQ0KCwGAEAkpE3cFh0FcCiQKBGtpbmQSHEIaUmVwbGljYVN5c3RlbUNvbmZpZ3VyYXRpb24KNwoFdmFsdWUSLroBKwopCgV2YWx1ZRIgQh7DkvCQlrzwn5W04K2c8JGwhOGZoU3hg43wn4mDYCs= +Cv0BCvoBugH2AQqAAQoDa2V5Enm6AXYKPQoEbmFtZRI1QjNcOj/wn5W08JCdkSDhsaDtnrVZPci6dk1pSVw/8JCNmfCegKN8wqXDqywqTvCRtpfjg5gKNQoKcmVwbGljYV9pZBInugEkCiIKBFVzZXISGsIBFwoKBWMYYEk5R3eSLBD///////////8BCiQKBGtpbmQSHEIaUmVwbGljYVN5c3RlbUNvbmZpZ3VyYXRpb24KSwoFdmFsdWUSQroBPwo9CgV2YWx1ZRI0QjLqrKvCpFHwn5W0L/CRvIM6QMKl8J6To++/hz/IuvCdhI7Dmj7wn4K44KKBL8K7QjouPQ== +CvQDCvEDugHtAwrWAwoDa2V5Es4DugHKAwrHAwoFZXZlbnQSvQO6AbkDCrYDCgJWMRKvA7oBqwMKgwIKB2RldGFpbHMS9wG6AfMBCvABChJDcmVhdGVTb3VyY2VTaW5rVjMS2QG6AdUBCj4KDWV4dGVybmFsX3R5cGUSLUIrVG7qp7rvt4/wn4mGKkDgrpwvOjoq6qyJcvCSkbHwkaSa6qe9Js6M8JGcmgoLCgJpZBIFQgPgrbQKhQEKBG5hbWUSfboBegobCghkYXRhYmFzZRIPQg3wkZmicOGpovCWuYE/Ch0KBGl0ZW0SFUIT8JG2kO+/lDpr8J60ovCRjKLCpQo8CgZzY2hlbWESMkIw4Zyl5oWne/CetJjDhvCRjotUP+GlkfCfm5fwkKCIfTU84Kay4Ked8J6itDLwm4CIChQKCmV2ZW50X3R5cGUSBsIBAwoBDAoWCgJpZBIQwgENCgsBJlCVZQJJFiEVfAoWCgtvYmplY3RfdHlwZRIHwgEECgIBHAouCgtvY2N1cnJlZF9hdBIfugEcChoKBm1pbGxpcxIQwgENCgsBIQKCklIIAocUHAotCgR1c2VyEiW6ASIKIAoFaW5uZXISF0IV77+9PmAl8J+AqFsk8JCguPCeuY8nChIKBGtpbmQSCkIIQXVkaXRMb2c= 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 +CnMKcboBbgobCgNrZXkSFLoBEQoPCgJpZBIJQgdFeHBsYWluCiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQoqCgV2YWx1ZRIhugEeChwKBXNoYXJkEhNCEUI88J2UkjsvfeC2gzpUPNS+ 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 +CkMKQboBPgoVCgRraW5kEg1CC1R4bldhbFNoYXJkCiUKBXZhbHVlEhy6ARkKFwoFc2hhcmQSDkIMQkfwn5W04LKPJD13 +CugBCuUBugHhAQpzCgNrZXkSbLoBaQoqCgpjbHVzdGVyX2lkEhy6ARkKFwoEVXNlchIPwgEMCgqHI2QQaXE2iAV8CjsKBG5hbWUSM0Ixakvit4nwkJaV4LOV8JartFxGSHfitqPRqOqjllU60agl8J+VtHzwq5e+cu+/veqitwokCgRraW5kEhxCGkNsdXN0ZXJTeXN0ZW1Db25maWd1cmF0aW9uCkQKBXZhbHVlEju6ATgKNgoFdmFsdWUSLUIrLPCQjbXViOGPg/Cen614MvCQlJwkVi5SfeGngybwkYyew7Lgt7LwkbyEOw== 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 +CogCCoUCugGBAgqlAQoDa2V5Ep0BugGZAQqBAQoGb2JqZWN0Ene6AXQKcgoOQ2x1c3RlclJlcGxpY2ESYLoBXQosCgpjbHVzdGVyX2lkEh66ARsKGQoGU3lzdGVtEg/CAQwKCkRAV2JWcQQ3NjwKLQoKcmVwbGljYV9pZBIfugEcChoKBlN5c3RlbRIQwgENCgsBJBQXiEJnVpggjAoTCg1zdWJfY29tcG9uZW50EgIIBAoRCgRraW5kEglCB0NvbW1lbnQKRAoFdmFsdWUSO7oBOAo2Cgdjb21tZW50EitCKUnwkYu4JPCQlo9uw5nhs7Pgrpk/8JGWjWQm8JGHruCuiS4q8JGchSQi +Cp0BCpoBugGWAQovCgNrZXkSKLoBJQojCgRuYW1lEhtCGSlXYPCRkJ0vyLrwn5W08J+fsGbwkLKnJjoKEQoEa2luZBIJQgdTZXR0aW5nClAKBXZhbHVlEke6AUQKQgoFdmFsdWUSOUI3Lz3RqDrgp69xdvCQhppaTOqsrOCrkPCQkqQ/8J+hhvCdjLfRqHJIP3Nc4LGjZSrwkY2X77+9PQ== +CqkBCqYBugGiAQpICgNrZXkSQboBPgoTCgdncmFudGVlEghCBlB1YmxpYwonCgdncmFudG9yEhy6ARkKFwoEVXNlchIPwgEMCgo5kEYRV3h4B5KMChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwo6CgV2YWx1ZRIxugEuCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKdESUWEBmZYMWTA== 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 +CnEKb7oBbApOCgNrZXkSR7oBRApCCgVzaGFyZBI5Qjc/VtGo8J2UveGqhEk/ez898JC+gm1G8J2qqz5d8J+cuVbwkaSs77+aP3Lvv71oPzRg8JGwgWY+ChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +CooBCocBugGDAQpDCgNrZXkSPLoBOQo3CgRuYW1lEi9CLcOAY+GltD3gs4h6yLon4K208J+VtCbgsYhHV8i6WmRM4Ka94b2Dw57vv6U/YgoRCgRraW5kEglCB0lkQWxsb2MKKQoFdmFsdWUSILoBHQobCgduZXh0X2lkEhDCAQ0KCwEzM3FnV0kQIBEc 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 +CqABCp0BugGZAQoxCgNrZXkSKroBJwolCgRuYW1lEh1CG2o8wqXwkY2MTtGo8J6XpFpPOiZGcDt4S+K2swoRCgRraW5kEglCB1NldHRpbmcKUQoFdmFsdWUSSLoBRQpDCgV2YWx1ZRI6QjjwkK2jw5wiYPCrqrLwlr2KOuqflvCeuK/wnoCMIuK2q/CQqYjwkKir8JC2j/CRjZBu4KmA8JCMtQ== +Cm4KbLoBaQosCgNrZXkSJboBIgogCgNrZXkSGUIX6qKG6pKQXHvgqLY877+94aSj8JC6sSMKEAoEa2luZBIIQgZDb25maWcKJwoFdmFsdWUSHroBGwoZCgV2YWx1ZRIQwgENCgsBSJJhNFmHUTF0bA== +CoUBCoIBugF/CjAKA2tleRIpugEmCiQKAmlkEh66ARsKGQoGU3lzdGVtEg/CAQwKChBgeXQzmBJlCVwKIwoEa2luZBIbQhlTdG9yYWdlQ29sbGVjdGlvbk1ldGFkYXRhCiYKBXZhbHVlEh26ARoKGAoFc2hhcmQSD0INw4o/VVzvv5fwkIaQZw== +CmQKYroBXwojCgNrZXkSHLoBGQoXCgNrZXkSEEIO8J64gdiUJGRUMOCpiyIKEAoEa2luZBIIQgZDb25maWcKJgoFdmFsdWUSHboBGgoYCgV2YWx1ZRIPwgEMCgpIcAOCBVAjCXY8 +CskBCsYBugHCAQpBCgNrZXkSOroBNwo1CgJpZBIvugEsCioKGEludHJvc3BlY3Rpb25Tb3VyY2VJbmRleBIOwgELCgmGhoUlgBEUYZwKIwoEa2luZBIbQhlTdG9yYWdlQ29sbGVjdGlvbk1ldGFkYXRhClgKBXZhbHVlEk+6AUwKSgoFc2hhcmQSQUI/4aCh8J2SgyVg8JCXjTzwkI+VeyV1S/CdhalccsKhQi/wkLy+8JCEjCbRqGslPSc/8JC/sPCQhIDCpfCeo4kl +CscBCsQBugHAAQpMCgNrZXkSRboBQgotCgpjbHVzdGVyX2lkEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFDVghRhyaGA2VsChEKBG5hbWUSCUIHaS/wnZSWTAokCgRraW5kEhxCGkNsdXN0ZXJTeXN0ZW1Db25maWd1cmF0aW9uCkoKBXZhbHVlEkG6AT4KPAoFdmFsdWUSM0IxPPCQlodgN2N+LlzwnritS/CQnoFtKeqvuPCRk4Nyw5bqopLgs6M48J28pUDwn5W0Jw== +Cs4BCssBugHHAQpzCgNrZXkSbLoBaQorCgpjbHVzdGVyX2lkEh26ARoKGAoEVXNlchIQwgENCgsBgJGEiAWDU2hnfAo6CgRuYW1lEjJCMFzwnYaNPTjwkaS7aOGelWwpLi7wnrmbQkjgu5wlVOChs1zRqD41yLpcKvCeo4s8JgokCgRraW5kEhxCGkNsdXN0ZXJTeXN0ZW1Db25maWd1cmF0aW9uCioKBXZhbHVlEiG6AR4KHAoFdmFsdWUSE0IRSPCQrLVxV3DRqG1gVz3grpw= +Cq4CCqsCugGnAgqOAQoDa2V5EoYBugGCAQosCgpjbHVzdGVyX2lkEh66ARsKGQoGU3lzdGVtEg/CAQwKCmNwlokVEVNWVRwKUgoEbmFtZRJKQkg9w7PIunnitr3gt63grrAi8J6XneqgtfCfgonRqMOH8JCkh/CdkqpNLmbgsLh0JTDFtvCWq4ci4oKT8JC5osKpT++/ve+/vUAKKQoEa2luZBIhQh9DbHVzdGVySW50cm9zcGVjdGlvblNvdXJjZUluZGV4CmkKBXZhbHVlEmC6AV0KHgoKY2F0YWxvZ19pZBIQwgENCgsBOVYleChAmIWXXAonCglnbG9iYWxfaWQSGsIBFwoKCUJniYAjBzhjLBD///////////8BChIKA29pZBILwgEICgYCcCF5Axw= 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 +CjkKN7oBNAoVCgRraW5kEg1CC1R4bldhbFNoYXJkChsKBXZhbHVlEhK6AQ8KDQoFc2hhcmQSBEICeDI= +ClQKUroBTwoxCgNrZXkSKroBJwolCgVzaGFyZBIcQhonND3wkY2Bw6I9XErRqNGo8JCgvOK0p+2frAoaCgRraW5kEhJCEFVuZmluYWxpemVkU2hhcmQ= +CsMBCsABugG8AQoxCgNrZXkSKroBJwolCgJpZBIfugEcChoKBlN5c3RlbRIQwgENCgsBdGAWhRWRl5BmnAojCgRraW5kEhtCGVN0b3JhZ2VDb2xsZWN0aW9uTWV0YWRhdGEKYgoFdmFsdWUSWboBVgpUCgVzaGFyZBJLQknwkZmRJyDwnoSO4LCW8KKPryfwlr2X8J+VtC1S8JKQlD3DrPCQuqvwnZWQKPCRm6A9JeCyt2Pfj+C7n+Gzg/CRpL7wkLyQLmlQ +CncKdboBcgoVCgRraW5kEg1CC1R4bldhbFNoYXJkClkKBXZhbHVlElC6AU0KSwoFc2hhcmQSQkJA8JGdgXrwm4W0RuqroC/wnbyMYjrIumbwkKCI44G+PPCQrqoh0ahb4K+G4K6Dw6DwkYKmPELIuvCRhIMl8J+psg== +CucBCuQBugHgAQqAAQoDa2V5Enm6AXYKKwoKY2x1c3Rlcl9pZBIdugEaChgKBFVzZXISEMIBDQoLAXg4eRIHMGJjGBwKRwoEbmFtZRI/Qj1X4YmL4Kq4MjQmTuCtiyLwnLeVLsi64Yq5QXvhv7zCpSYq4Zyi8JGPguGxqfCRmrbwkZmo4K+GXfCeurg8CiQKBGtpbmQSHEIaQ2x1c3RlclN5c3RlbUNvbmZpZ3VyYXRpb24KNQoFdmFsdWUSLLoBKQonCgV2YWx1ZRIeQhzgsozhv6Fq4KGnOOKAt/CRqJ3wkJ6D8JGOnGBy +CogCCoUCugGBAgp1CgNrZXkSbroBawosCgpjbHVzdGVyX2lkEh66ARsKGQoGU3lzdGVtEg/CAQwKCoFUQISZCQiJBFwKOwoEbmFtZRIzQjHwnrmH8J2ShWDCpVXhhZPDn/CQsos5XvCQuqV0Pz0lIkd+ezkiKT/fjDrhjLLwn4K4CikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleApdCgV2YWx1ZRJUugFRCh0KCmNhdGFsb2dfaWQSD8IBDAoKKVMXAEdEYDUVXAodCglnbG9iYWxfaWQSEMIBDQoLAXKBVJFiZmkQV5wKEQoDb2lkEgrCAQcKBUaJF3BM +CqRECqFEugGdRAowCgNrZXkSKboBJgokCgJpZBIeugEbChkKBlN5c3RlbRIPwgEMCgonEINCExeIYYMsChIKBGtpbmQSCkIIRGF0YWJhc2UK1EMKBXZhbHVlEspDugHGQwo8CgRuYW1lEjRCMid0Jy06OiXhs4Ykwr46J0Dwm7G2QyR54LGhNeCrgXA6L1pK76ys8JG9iSHgrqTgqI8tChIKA29pZBILwgEICgYDcUcEJSwKMwoIb3duZXJfaWQSJ7oBJAoiCgRVc2VyEhrCARcKChVmAQeCRIIzJmwQ////////////AQq8QgoKcHJpdmlsZWdlcxKtQrIBqUIKhwG6AYMBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKE0JiWYcoARZGHAooCgdncmFudGVlEh26ARoKGAoEVXNlchIQwgENCgsBREBxhZJRB5iTbAopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKCmJmWRlYR1lGIJwKd7oBdAotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwETiDAZhQYUQQOcCi4KB2dyYW50ZWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEpaYUFOJAHYSR8ChMKB2dyYW50b3ISCEIGUHVibGljCly6AVkKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBNAlTUgBVlpaJHAoTCgdncmFudGVlEghCBlB1YmxpYwoTCgdncmFudG9yEghCBlB1YmxpYwqAAboBfQo3CghhY2xfbW9kZRIrugEoCiYKCGJpdGZsYWdzEhrCARcKChIokjVBiWQQl4wQ////////////AQotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgpJRgVDVDBjVQdsChMKB2dyYW50b3ISCEIGUHVibGljCly6AVkKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBAEcwOSIEZyJXnAoTCgdncmFudGVlEghCBlB1YmxpYwoTCgdncmFudG9yEghCBlB1YmxpYwp3ugF0Ci0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAWBmNllgOZWVE4wKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAWkllBmVcGQ4dRwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKhQG6AYEBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKcZQhmGeQNXEmjAooCgdncmFudGVlEh26ARoKGAoEVXNlchIQwgENCgsBASQHAXeAOVhGTAonCgdncmFudG9yEhy6ARkKFwoEVXNlchIPwgEMCgoGNBkJM1RkmWc8CpcBugGTAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwECFgiHViR0MFOcCikKB2dyYW50ZWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKVDdZmJAHcZkjLAo3CgdncmFudG9yEiy6ASkKJwoKUHJlZGVmaW5lZBIZwgEWCgk2U2N4I5BJOTwQ////////////AQqGAboBggEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBOXWIUDSUk4QzTAonCgdncmFudGVlEhy6ARkKFwoEVXNlchIPwgEMCgoXcnV0R2cUFDFsCigKB2dyYW50b3ISHboBGgoYCgRVc2VyEhDCAQ0KCwFGFkIkQpYyhCAcCpEBugGNAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEmV2VCEpllR4icCi0KB2dyYW50ZWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCmIoiTcWaBNYlkwKLQoHZ3JhbnRvchIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKMYABM3kpQRRTfAqbAboBlwEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqCImAHYFAQFBMsCi0KB2dyYW50ZWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCgl0eWaXMYKDVkwKOAoHZ3JhbnRvchItugEqCigKClByZWRlZmluZWQSGsIBFwoKAVY4NgRkYkIDfBD+//////////8BCnG6AW4KLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgozVHKCUSZSliFcChMKB2dyYW50ZWUSCEIGUHVibGljCikKB2dyYW50b3ISHroBGwoZCgZTeXN0ZW0SD8IBDAoKkzmVFAFFgkKBnAqUAboBkAEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpgEURpgFCCkpl8CioKB2dyYW50ZWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAVSQh0ZphgZQlIwKNAoHZ3JhbnRvchIpugEmCiQKBlN5c3RlbRIawgEXCgoWkjMzABRGcZJMEP///////////wEKcLoBbQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCkVzCBZmgxEXISwKKAoHZ3JhbnRlZRIdugEaChgKBFVzZXISEMIBDQoLASlJcHgYRoFFgVwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKiwG6AYcBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKYUOJZYBCaSQ4TAooCgdncmFudGVlEh26ARoKGAoEVXNlchIQwgENCgsBECRyMiNRIkcBbAotCgdncmFudG9yEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgoDaGmXKJABcIVMCosBugGHAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFAQkgwloGBN3AcCicKB2dyYW50ZWUSHLoBGQoXCgRVc2VyEg/CAQwKCoF4kJFHhwJkQ0wKLQoHZ3JhbnRvchIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKGGiDkFMZMnWALApbugFYCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKQygDOUUwBkhGbAoTCgdncmFudGVlEghCBlB1YmxpYwoTCgdncmFudG9yEghCBlB1YmxpYwp6ugF3CjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKAgJYgIA3iHmFTBD///////////8BChMKB2dyYW50ZWUSCEIGUHVibGljCicKB2dyYW50b3ISHLoBGQoXCgRVc2VyEg/CAQwKCkggYiZiAQUpKYwKW7oBWAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCkRVcUGEVxWViSwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKEwoHZ3JhbnRvchIIQgZQdWJsaWMKfLoBeQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKClIEOQBQWUgUkRwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKNAoHZ3JhbnRvchIpugEmCiQKBlN5c3RlbRIawgEXCgoQiXRXAAIhc2iMEP///////////wEKiAG6AYQBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAXZUklMHEndZQUwKJwoHZ3JhbnRlZRIcugEZChcKBFVzZXISD8IBDAoKVhcxE3RTZRJgLAoqCgdncmFudG9yEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFVEoVWdEYkYUVMCooBugGGAQo2CghhY2xfbW9kZRIqugEnCiUKCGJpdGZsYWdzEhnCARYKCQdxAZhXdzUojBD///////////8BChMKB2dyYW50ZWUSCEIGUHVibGljCjcKB2dyYW50b3ISLLoBKQonCgpQcmVkZWZpbmVkEhnCARYKCYBTJRAgMRNUjBD+//////////8BCoEBugF+Ci0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAXSSSDCDglZgdFwKOAoHZ3JhbnRlZRItugEqCigKClByZWRlZmluZWQSGsIBFwoKCZSUQ5kDJVlHnBD///////////8BChMKB2dyYW50b3ISCEIGUHVibGljCnG6AW4KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBV0NmcnURAHNZnAoTCgdncmFudGVlEghCBlB1YmxpYwooCgdncmFudG9yEh26ARoKGAoEVXNlchIQwgENCgsBRzVmFXE2aABVPAqfAboBmwEKNwoIYWNsX21vZGUSK7oBKAomCghiaXRmbGFncxIawgEXCgoQInQxCBVwaTY8EP///////////wEKKgoHZ3JhbnRlZRIfugEcChoKBlN5c3RlbRIQwgENCgsBNXYEKAhyhGSIjAo0CgdncmFudG9yEim6ASYKJAoGU3lzdGVtEhrCARcKChcJJFdnQgBxdnwQ////////////AQpmugFjCjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKBhd1hDklSYACHBD///////////8BChMKB2dyYW50ZWUSCEIGUHVibGljChMKB2dyYW50b3ISCEIGUHVibGljCpEBugGNAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCjIIWIggiFkxeBwKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLARg0gYcIIlMhOZwKLQoHZ3JhbnRvchIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKGFEnlAM2ZFggbAqNAboBiQEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBYwZXR3iFcHdUHAopCgdncmFudGVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCnVkSYVQaCYkdxwKLQoHZ3JhbnRvchIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKZJkhFYUYhBlzHAqKAboBhgEKKwoIYWNsX21vZGUSH7oBHAoaCghiaXRmbGFncxIOwgELCgl2FXmJYlYIUzwKKAoHZ3JhbnRlZRIdugEaChgKBFVzZXISEMIBDQoLAShwZEhhl4M5KUwKLQoHZ3JhbnRvchIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKlJFBMXACWIJgHAqMAboBiAEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBZmAjEmZGl3GRLAouCgdncmFudGVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBZneEEEKFE2RmfAonCgdncmFudG9yEhy6ARkKFwoEVXNlchIPwgEMCgp5AyBUYkkzF4dsCna6AXMKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBciglhIMAd1dkLAotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgoTWVdXJCQ2MYmcChMKB2dyYW50b3ISCEIGUHVibGljClu6AVgKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqJKDFIZJc4kZl8ChMKB2dyYW50ZWUSCEIGUHVibGljChMKB2dyYW50b3ISCEIGUHVibGljCpkBugGVAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFiKHFwgzY2YhCcCjgKB2dyYW50ZWUSLboBKgooCgpQcmVkZWZpbmVkEhrCARcKCgWAdkSWNogTIGwQ////////////AQoqCgdncmFudG9yEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwEWUBY3EFKAeBGcCly6AVkKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBNnWQCYh1CJdIXAoTCgdncmFudGVlEghCBlB1YmxpYwoTCgdncmFudG9yEghCBlB1YmxpYwqMAboBiAEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgozWAJVJQMwaQR8Ci0KB2dyYW50ZWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCkISVCiQCFSYEJwKKQoHZ3JhbnRvchIeugEbChkKBlN5c3RlbRIPwgEMCgpjcnGXhUIzhUg8CnK6AW8KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBBSQEVIAnYogmjAopCgdncmFudGVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCjdiVyJUMDMIUkwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKiAG6AYQBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKmEaWYQRyeGiGHAopCgdncmFudGVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCiEgkUA4AyhCQZwKKQoHZ3JhbnRvchIeugEbChkKBlN5c3RlbRIPwgEMCgpQCBRpFocHBXCcCna6AXMKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgo0QyIBEzADdgacCi4KB2dyYW50ZWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEEhyeGYxBnAyk8ChMKB2dyYW50b3ISCEIGUHVibGljCocBugGDAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCpE3VFMXMmBhQhwKKQoHZ3JhbnRlZRIeugEbChkKBlN5c3RlbRIPwgEMCgoGNZkYkpk0BoRMCigKB2dyYW50b3ISHboBGgoYCgRVc2VyEhDCAQ0KCwFwiAk0BUBoIZUcCo0BugGJAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCigoKUJ1F0BHAVwKKgoHZ3JhbnRlZRIfugEcChoKBlN5c3RlbRIQwgENCgsBFiIjVhRylSB1fAotCgdncmFudG9yEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgpkQDQAUWCYdYacCokBugGFAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFEhXV4cHhxg0lMCioKB2dyYW50ZWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAVNFNTGVEFCSljwKKAoHZ3JhbnRvchIdugEaChgKBFVzZXISEMIBDQoLATOQSUZROJWSFJwKigG6AYYBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLARKSdJSDdEBDMmwKKgoHZ3JhbnRlZRIfugEcChoKBlN5c3RlbRIQwgENCgsBAVdyFENClTNXnAopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKCmcJdHcnQoIWNzwKlQG6AZEBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKg1RHBAiVcFBgHAooCgdncmFudGVlEh26ARoKGAoEVXNlchIQwgENCgsBdngSFZNCQDcQHAo3CgdncmFudG9yEiy6ASkKJwoKUHJlZGVmaW5lZBIZwgEWCgmTOZN1hzI1iHwQ/v//////////AQqCAboBfworCghhY2xfbW9kZRIfugEcChoKCGJpdGZsYWdzEg7CAQsKCXlkRGNkYYcwnAonCgdncmFudGVlEhy6ARkKFwoEVXNlchIPwgEMCgqZaTMTFgKDY4JMCicKB2dyYW50b3ISHLoBGQoXCgRVc2VyEg/CAQwKCjBnU0ZERZCHhjwKhwG6AYMBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLATAzmJiFMCVhRWwKKAoHZ3JhbnRlZRIdugEaChgKBlN5c3RlbRIOwgELCgkmeHVkcoBHJHwKKAoHZ3JhbnRvchIdugEaChgKBFVzZXISEMIBDQoLATBJiTNEJ1NEJEwKjQG6AYkBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKBEZQYEI3dzBlPAopCgdncmFudGVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCid3YpOTdghIJ3wKLgoHZ3JhbnRvchIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAWRpWBYmhDlhYYwKjAG6AYgBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLASFmRyYxczU2NFwKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLATSSGABHczcHYlwKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKJBQiAAgIBCkCPApcugFZCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAUEFIgMFAIdic2wKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKEwoHZ3JhbnRvchIIQgZQdWJsaWMKhQG6AYEBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKJYmYZjYlCThjnAooCgdncmFudGVlEh26ARoKGAoEVXNlchIQwgENCgsBgyIGeCFJSTF5jAonCgdncmFudG9yEhy6ARkKFwoEVXNlchIPwgEMCgpjmTmQiUiZhQGMCna6AXMKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqEkJNwR5MpZQYcCi4KB2dyYW50ZWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwFAiUUQgRN1J1OcChMKB2dyYW50b3ISCEIGUHVibGljCpcBugGTAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKChJiAxVBmJMlhpwKLQoHZ3JhbnRlZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKZiCBJhdHNSlIbAo0CgdncmFudG9yEim6ASYKJAoGU3lzdGVtEhrCARcKCgcSBDGIWICDZGwQ////////////AQqYAboBlAEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpDBEkJlIN2E5ZMCjQKB2dyYW50ZWUSKboBJgokCgZTeXN0ZW0SGsIBFwoKAgOVITgRUJBFjBD///////////8BCi4KB2dyYW50b3ISI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwFINkB0YAkQaHA8CoABugF9CiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKlwAiaDJ3djZYTAoTCgdncmFudGVlEghCBlB1YmxpYwo4CgdncmFudG9yEi26ASoKKAoKUHJlZGVmaW5lZBIawgEXCgoElWiJVBVUOHd8EP///////////wEKeroBdwosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCklTGSJSaUUVgmwKMgoHZ3JhbnRlZRInugEkCiIKBFVzZXISGsIBFwoKEwWEWQFBaElxjBD///////////8BChMKB2dyYW50b3ISCEIGUHVibGljCowBugGIAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKChFmNFJpCQUAKJwKLQoHZ3JhbnRlZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKFZJJBhIXQCYmHAopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKCgSFkHFZUngVmZwKqwG6AacBCjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKFShYh5UocYiTjBD///////////8BCjIKB2dyYW50ZWUSJ7oBJAoiCgRVc2VyEhrCARcKChEhR4MnJEUkU5wQ////////////AQo4CgdncmFudG9yEi26ASoKKAoKUHJlZGVmaW5lZBIawgEXCgoWJ5VnYBeHYjZsEP///////////wEKjQG6AYkBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLASCEhkaRZ1Yoh0wKKQoHZ3JhbnRlZRIeugEbChkKBlN5c3RlbRIPwgEMCgowlGGTIGlmNRmMCi0KB2dyYW50b3ISIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCiKDcBEBiTeAAFwKigG6AYYBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKd4aRNFRRWWIhTAonCgdncmFudGVlEhy6ARkKFwoEVXNlchIPwgEMCgqSBThlcAEDQ3WMCi0KB2dyYW50b3ISIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCnSIgiKGdXUCl1wKmAG6AZQBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKEANjGZg2AmZBPAouCgdncmFudGVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBFVR5EDMiIZFVLAo0CgdncmFudG9yEim6ASYKJAoGU3lzdGVtEhrCARcKCghSVFJYgiAxhUwQ////////////AQqQAboBjAEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpoEUKCc5Y0Yyh8CjIKB2dyYW50ZWUSJ7oBJAoiCgRVc2VyEhrCARcKChNxMYiZJVgzNFwQ////////////AQooCgdncmFudG9yEh26ARoKGAoEVXNlchIQwgENCgsBdgIjiShEZQQUXApbugFYCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKB1FUFDlHaXYBjAoTCgdncmFudGVlEghCBlB1YmxpYwoTCgdncmFudG9yEghCBlB1YmxpYwpzugFwCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLASmUMzcSKXEmVJwKKgoHZ3JhbnRlZRIfugEcChoKBlN5c3RlbRIQwgENCgsBCZEHkodFYmWYTAoTCgdncmFudG9yEghCBlB1YmxpYwqXAboBkwEKNgoIYWNsX21vZGUSKroBJwolCghiaXRmbGFncxIZwgEWCglnCTeUN4CQIVwQ/v//////////AQotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgp3BYlFkklQkmMcCioKB2dyYW50b3ISH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAXmQUUZSBnU0hCwKlQG6AZEBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKKSJRN2AFUyY3LAotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgoYiCZpF0AliCRcCjIKB2dyYW50b3ISJ7oBJAoiCgRVc2VyEhrCARcKCgVESTVFRiMQBHwQ////////////AQ== +Cq0BCqoBugGmAQpfCgNrZXkSWLoBVQomCgRuYW1lEh5CHPCflbTIunFT8JCWoe+/vT3wkaal4Y+TJvCQnokKKwoKcmVwbGljYV9pZBIdugEaChgKBFVzZXISEMIBDQoLAWJWaEAUR3EYBhwKJAoEa2luZBIcQhpSZXBsaWNhU3lzdGVtQ29uZmlndXJhdGlvbgodCgV2YWx1ZRIUugERCg8KBXZhbHVlEgZCBPCRsJ4= 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 +CqwBCqkBugGlAQpLCgNrZXkSRLoBQQoTCgdncmFudGVlEghCBlB1YmxpYwoqCgdncmFudG9yEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwEYmRdwE4QFV1FMChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwo6CgV2YWx1ZRIxugEuCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKcZSCFVIJERAFfA== diff --git a/src/catalog/src/durable/upgrade/v90_to_v91.rs b/src/catalog/src/durable/upgrade/v90_to_v91.rs new file mode 100644 index 0000000000000..e2cb88de6b053 --- /dev/null +++ b/src/catalog/src/durable/upgrade/v90_to_v91.rs @@ -0,0 +1,130 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +use crate::durable::upgrade::MigrationAction; +use crate::durable::upgrade::json_compatible::JsonCompatible; +use crate::durable::upgrade::objects_v90 as v90; +use crate::durable::upgrade::objects_v91 as v91; + +crate::json_compatible!(v90::ItemKey with v91::ItemKey); +crate::json_compatible!(v90::SchemaId with v91::SchemaId); +crate::json_compatible!(v90::RoleId with v91::RoleId); +crate::json_compatible!(v90::MzAclItem with v91::MzAclItem); +crate::json_compatible!(v90::CatalogItem with v91::CatalogItem); +crate::json_compatible!(v90::GlobalId with v91::GlobalId); +crate::json_compatible!(v90::ItemVersion with v91::ItemVersion); + +/// Adds the `ephemeral_owner_session` field to items, backfilling it as +/// `None`. Existing records all describe durable items, temporary items were +/// never written to the catalog before this field existed. +/// +/// `Item` records gained a new field, so their stored JSON is no longer +/// readable as the v91 type and every such record is rewritten. All other +/// records are unchanged and pass through untouched. +pub fn upgrade( + snapshot: Vec, +) -> Vec> { + let mut migrations = Vec::new(); + for update in snapshot { + match update { + v90::StateUpdateKind::Item(old_item) => { + let new_item = migrate_item(old_item.clone()); + migrations.push(MigrationAction::Update( + v90::StateUpdateKind::Item(old_item), + v91::StateUpdateKind::Item(new_item), + )); + } + _ => {} + } + } + migrations +} + +fn migrate_item(old: v90::Item) -> v91::Item { + let v90::Item { key, value } = old; + v91::Item { + key: JsonCompatible::convert(&key), + value: v91::ItemValue { + schema_id: JsonCompatible::convert(&value.schema_id), + name: value.name, + definition: JsonCompatible::convert(&value.definition), + owner_id: JsonCompatible::convert(&value.owner_id), + privileges: value + .privileges + .iter() + .map(JsonCompatible::convert) + .collect(), + oid: value.oid, + global_id: JsonCompatible::convert(&value.global_id), + extra_versions: value + .extra_versions + .iter() + .map(JsonCompatible::convert) + .collect(), + ephemeral_owner_session: None, + }, + } +} + +#[cfg(test)] +mod tests { + use crate::durable::upgrade::MigrationAction; + use crate::durable::upgrade::v90_to_v91::upgrade; + use crate::durable::upgrade::{objects_v90 as v90, objects_v91 as v91}; + + fn schema(id: u64) -> v90::Schema { + v90::Schema { + key: v90::SchemaKey { + id: v90::SchemaId::User(id), + }, + value: v90::SchemaValue { + database_id: Some(v90::DatabaseId::User(1)), + name: format!("schema{id}"), + owner_id: v90::RoleId::User(1), + privileges: Vec::new(), + oid: 20_000, + }, + } + } + + fn item(id: u64) -> v90::Item { + v90::Item { + key: v90::ItemKey { + gid: v90::CatalogItemId::User(id), + }, + value: v90::ItemValue { + schema_id: v90::SchemaId::User(1), + name: format!("item{id}"), + definition: v90::CatalogItem::V1(v90::CatalogItemV1 { + create_sql: "CREATE VIEW v AS SELECT 1".to_string(), + }), + owner_id: v90::RoleId::User(1), + privileges: Vec::new(), + oid: 20_001, + global_id: v90::GlobalId::User(id), + extra_versions: Vec::new(), + }, + } + } + + #[mz_ore::test] + fn backfills_items_as_none() { + let migrations = upgrade(vec![ + v90::StateUpdateKind::Schema(schema(1)), + v90::StateUpdateKind::Item(item(1)), + ]); + // The item migrates; the schema passes through. + assert_eq!(migrations.len(), 1); + + let MigrationAction::Update(_, v91::StateUpdateKind::Item(item)) = &migrations[0] else { + panic!("expected an item update"); + }; + assert_eq!(item.value.ephemeral_owner_session, None); + } +} diff --git a/src/catalog/src/memory/objects.rs b/src/catalog/src/memory/objects.rs index c422cd79e0148..e914741c6d0f9 100644 --- a/src/catalog/src/memory/objects.rs +++ b/src/catalog/src/memory/objects.rs @@ -76,7 +76,6 @@ use tracing::debug; use crate::builtin::{MZ_CATALOG_SERVER_CLUSTER, MZ_SYSTEM_CLUSTER}; use crate::durable; -use crate::durable::objects::item_type; /// Used to update `self` from the input value while consuming the input value. pub trait UpdateFrom: From { @@ -868,23 +867,6 @@ pub enum CatalogItem { Connection(Connection), } -impl From for durable::Item { - fn from(entry: CatalogEntry) -> durable::Item { - let (create_sql, global_id, extra_versions) = entry.item.into_serialized(); - durable::Item { - id: entry.id, - oid: entry.oid, - global_id, - schema_id: entry.name.qualifiers.schema_spec.into(), - name: entry.name.item, - create_sql, - owner_id: entry.owner_id, - privileges: entry.privileges.into_all_values().collect(), - extra_versions, - } - } -} - #[derive(Debug, Clone, Serialize)] pub struct Table { /// Parse-able SQL that defines this table. @@ -4175,10 +4157,6 @@ pub enum StateUpdateKind { ReplicaSystemConfiguration(durable::objects::ReplicaSystemConfiguration), SourceReferences(durable::objects::SourceReferences), SystemObjectMapping(durable::objects::SystemObjectMapping), - // Temporary items are not actually updated via the durable catalog, but - // this allows us to model them the same way as all other items in parts of - // the pipeline. - TemporaryItem(TemporaryItem), Item(durable::objects::Item), Comment(durable::objects::Comment), AuditLog(durable::objects::AuditLog), @@ -4213,171 +4191,3 @@ impl TryFrom for StateDiff { } } } - -/// Information needed to process an update to a temporary item. -#[derive(Debug, Clone, Ord, PartialOrd, PartialEq, Eq)] -pub struct TemporaryItem { - pub id: CatalogItemId, - pub oid: u32, - pub global_id: GlobalId, - pub schema_id: SchemaId, - pub name: String, - pub conn_id: Option, - pub create_sql: String, - pub owner_id: RoleId, - pub privileges: Vec, - pub extra_versions: BTreeMap, -} - -impl From for TemporaryItem { - fn from(entry: CatalogEntry) -> Self { - let conn_id = entry.conn_id().cloned(); - let (create_sql, global_id, extra_versions) = entry.item.to_serialized(); - - TemporaryItem { - id: entry.id, - oid: entry.oid, - global_id, - schema_id: entry.name.qualifiers.schema_spec.into(), - name: entry.name.item, - conn_id, - create_sql, - owner_id: entry.owner_id, - privileges: entry.privileges.into_all_values().collect(), - extra_versions, - } - } -} - -impl TemporaryItem { - pub fn item_type(&self) -> CatalogItemType { - item_type(&self.create_sql) - } -} - -/// The same as [`StateUpdateKind`], but without `TemporaryItem` so we can derive [`Ord`]. -#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)] -pub enum BootstrapStateUpdateKind { - Role(durable::objects::Role), - RoleAuth(durable::objects::RoleAuth), - Database(durable::objects::Database), - Schema(durable::objects::Schema), - DefaultPrivilege(durable::objects::DefaultPrivilege), - SystemPrivilege(MzAclItem), - SystemConfiguration(durable::objects::SystemConfiguration), - Cluster(durable::objects::Cluster), - ClusterSystemConfiguration(durable::objects::ClusterSystemConfiguration), - NetworkPolicy(durable::objects::NetworkPolicy), - IntrospectionSourceIndex(durable::objects::IntrospectionSourceIndex), - ClusterReplica(durable::objects::ClusterReplica), - ReplicaSystemConfiguration(durable::objects::ReplicaSystemConfiguration), - SourceReferences(durable::objects::SourceReferences), - SystemObjectMapping(durable::objects::SystemObjectMapping), - Item(durable::objects::Item), - Comment(durable::objects::Comment), - AuditLog(durable::objects::AuditLog), - // Storage updates. - StorageCollectionMetadata(durable::objects::StorageCollectionMetadata), - UnfinalizedShard(durable::objects::UnfinalizedShard), -} - -impl From for StateUpdateKind { - fn from(value: BootstrapStateUpdateKind) -> Self { - match value { - BootstrapStateUpdateKind::Role(kind) => StateUpdateKind::Role(kind), - BootstrapStateUpdateKind::RoleAuth(kind) => StateUpdateKind::RoleAuth(kind), - BootstrapStateUpdateKind::Database(kind) => StateUpdateKind::Database(kind), - BootstrapStateUpdateKind::Schema(kind) => StateUpdateKind::Schema(kind), - BootstrapStateUpdateKind::DefaultPrivilege(kind) => { - StateUpdateKind::DefaultPrivilege(kind) - } - BootstrapStateUpdateKind::SystemPrivilege(kind) => { - StateUpdateKind::SystemPrivilege(kind) - } - BootstrapStateUpdateKind::SystemConfiguration(kind) => { - StateUpdateKind::SystemConfiguration(kind) - } - BootstrapStateUpdateKind::ClusterSystemConfiguration(kind) => { - StateUpdateKind::ClusterSystemConfiguration(kind) - } - BootstrapStateUpdateKind::ReplicaSystemConfiguration(kind) => { - StateUpdateKind::ReplicaSystemConfiguration(kind) - } - BootstrapStateUpdateKind::SourceReferences(kind) => { - StateUpdateKind::SourceReferences(kind) - } - BootstrapStateUpdateKind::Cluster(kind) => StateUpdateKind::Cluster(kind), - BootstrapStateUpdateKind::NetworkPolicy(kind) => StateUpdateKind::NetworkPolicy(kind), - BootstrapStateUpdateKind::IntrospectionSourceIndex(kind) => { - StateUpdateKind::IntrospectionSourceIndex(kind) - } - BootstrapStateUpdateKind::ClusterReplica(kind) => StateUpdateKind::ClusterReplica(kind), - BootstrapStateUpdateKind::SystemObjectMapping(kind) => { - StateUpdateKind::SystemObjectMapping(kind) - } - BootstrapStateUpdateKind::Item(kind) => StateUpdateKind::Item(kind), - BootstrapStateUpdateKind::Comment(kind) => StateUpdateKind::Comment(kind), - BootstrapStateUpdateKind::AuditLog(kind) => StateUpdateKind::AuditLog(kind), - BootstrapStateUpdateKind::StorageCollectionMetadata(kind) => { - StateUpdateKind::StorageCollectionMetadata(kind) - } - BootstrapStateUpdateKind::UnfinalizedShard(kind) => { - StateUpdateKind::UnfinalizedShard(kind) - } - } - } -} - -impl TryFrom for BootstrapStateUpdateKind { - type Error = TemporaryItem; - - fn try_from(value: StateUpdateKind) -> Result { - match value { - StateUpdateKind::Role(kind) => Ok(BootstrapStateUpdateKind::Role(kind)), - StateUpdateKind::RoleAuth(kind) => Ok(BootstrapStateUpdateKind::RoleAuth(kind)), - StateUpdateKind::Database(kind) => Ok(BootstrapStateUpdateKind::Database(kind)), - StateUpdateKind::Schema(kind) => Ok(BootstrapStateUpdateKind::Schema(kind)), - StateUpdateKind::DefaultPrivilege(kind) => { - Ok(BootstrapStateUpdateKind::DefaultPrivilege(kind)) - } - StateUpdateKind::SystemPrivilege(kind) => { - Ok(BootstrapStateUpdateKind::SystemPrivilege(kind)) - } - StateUpdateKind::SystemConfiguration(kind) => { - Ok(BootstrapStateUpdateKind::SystemConfiguration(kind)) - } - StateUpdateKind::ClusterSystemConfiguration(kind) => { - Ok(BootstrapStateUpdateKind::ClusterSystemConfiguration(kind)) - } - StateUpdateKind::ReplicaSystemConfiguration(kind) => { - Ok(BootstrapStateUpdateKind::ReplicaSystemConfiguration(kind)) - } - StateUpdateKind::Cluster(kind) => Ok(BootstrapStateUpdateKind::Cluster(kind)), - StateUpdateKind::NetworkPolicy(kind) => { - Ok(BootstrapStateUpdateKind::NetworkPolicy(kind)) - } - StateUpdateKind::IntrospectionSourceIndex(kind) => { - Ok(BootstrapStateUpdateKind::IntrospectionSourceIndex(kind)) - } - StateUpdateKind::ClusterReplica(kind) => { - Ok(BootstrapStateUpdateKind::ClusterReplica(kind)) - } - StateUpdateKind::SourceReferences(kind) => { - Ok(BootstrapStateUpdateKind::SourceReferences(kind)) - } - StateUpdateKind::SystemObjectMapping(kind) => { - Ok(BootstrapStateUpdateKind::SystemObjectMapping(kind)) - } - StateUpdateKind::TemporaryItem(kind) => Err(kind), - StateUpdateKind::Item(kind) => Ok(BootstrapStateUpdateKind::Item(kind)), - StateUpdateKind::Comment(kind) => Ok(BootstrapStateUpdateKind::Comment(kind)), - StateUpdateKind::AuditLog(kind) => Ok(BootstrapStateUpdateKind::AuditLog(kind)), - StateUpdateKind::StorageCollectionMetadata(kind) => { - Ok(BootstrapStateUpdateKind::StorageCollectionMetadata(kind)) - } - StateUpdateKind::UnfinalizedShard(kind) => { - Ok(BootstrapStateUpdateKind::UnfinalizedShard(kind)) - } - } - } -} diff --git a/src/catalog/tests/read-write.rs b/src/catalog/tests/read-write.rs index 387675e8937dc..c312590a60258 100644 --- a/src/catalog/tests/read-write.rs +++ b/src/catalog/tests/read-write.rs @@ -453,6 +453,7 @@ async fn test_items(state_builder: TestCatalogStateBuilder) { owner_id: RoleId::User(1), privileges: vec![], extra_versions: BTreeMap::new(), + ephemeral_owner_session: None, }, Item { id: CatalogItemId::User(200), @@ -464,6 +465,7 @@ async fn test_items(state_builder: TestCatalogStateBuilder) { owner_id: RoleId::User(2), privileges: vec![], extra_versions: BTreeMap::new(), + ephemeral_owner_session: None, }, ]; @@ -490,6 +492,7 @@ async fn test_items(state_builder: TestCatalogStateBuilder) { item.owner_id, item.privileges.clone(), item.extra_versions.clone(), + item.ephemeral_owner_session, ) .unwrap(); } @@ -744,6 +747,7 @@ async fn test_persist_ddl_detection_with_batch_allocated_ids() { RoleId::User(1), vec![], BTreeMap::new(), + None, ) .unwrap(); }