diff --git a/doc/developer/design/20260412_cluster_replica_sizes.md b/doc/developer/design/20260412_cluster_replica_sizes.md new file mode 100644 index 0000000000000..c0bc3dcfeface --- /dev/null +++ b/doc/developer/design/20260412_cluster_replica_sizes.md @@ -0,0 +1,224 @@ +# User-Defined Cluster Replica Sizes + +- Associated: [PR #35971](https://github.com/MaterializeInc/materialize/pull/35971) + +## The Problem + +Cluster replica sizes in Materialize are configured exclusively through +the `CLUSTER_REPLICA_SIZES` environment variable, passed as a JSON blob +at startup. This creates several problems: + +* **Adding or changing sizes requires an environmentd restart.** Any + modification to the set of available sizes -- adding a new size, + adjusting resource limits, disabling an existing one -- requires + updating a cli flag and restarting environmentd. In cloud + environments this means a deployment rollout; in self-managed + environments it means coordinating downtime. +* **No ad-hoc experimentation.** Operators cannot quickly test a new + size to explore whether a different CPU/memory/worker configuration + better fits a workload. Every experiment requires the full + restart-and-redeploy cycle, making iterative sizing impractical. +* **No durability or safety guarantees.** Sizes are held only in + memory. If the env var changes between restarts, sizes can silently + appear or disappear with no audit trail and no protection against + removing a size that existing replicas depend on. + +## Success Criteria + +* Operators can create and remove cluster replica sizes without + restarting environmentd or coordinating a deployment rollout. +* Operators can inspect the full definition of a cluster replica + size — including node selectors, swap configuration, and resource + limits — through SQL. +* Removing a size that is actively in use by a replica is prevented, + avoiding silent breakage of running workloads. +* Existing CLI flag based sizes continue to work unchanged. Operators + who don't use the new DDL see no behavior difference. + +## Out of Scope + +* **ALTER CLUSTER REPLICA SIZE.** Sizes are immutable once created. + To change a size definition, drop and recreate it (after migrating + replicas off it). This avoids the complexity of drift between + running replicas and their declared size, and avoids needing to + track size history per replica. + +## Solution Proposal + +### Durable storage + +`ClusterReplicaSize` is added as a new durable catalog object, +following the established pattern used by `NetworkPolicy`, `Cluster`, +and other catalog objects. + +#### Identity + +A new `ClusterReplicaSizeId` type in `mz-repr` with `User(u64)` and +`System(u64)` variants, matching `NetworkPolicyId`, `ClusterId`, +`RoleId`, etc. Two allocator keys track the next ID in each namespace. +Builtin sizes synced from the env var get `System` IDs; user-defined +sizes created via SQL get `User` IDs. + +Replicas still reference sizes by name (`ManagedLocation.size` remains +a `String`). The ID is catalog-internal identity only; the name is the +user-facing reference. This avoids migrating the replica storage format. + +#### Proto definitions + +```rust +// Key — the durable identity +pub struct ClusterReplicaSizeKey { + pub id: ClusterReplicaSizeId, +} + +pub enum ClusterReplicaSizeId { + System(u64), + User(u64), +} + +// Value — the allocation details and metadata +pub struct ClusterReplicaSizeValue { + pub name: String, + pub memory_limit: Option, // bytes + pub memory_request: Option, + pub cpu_limit: Option, // nanocpus + pub cpu_request: Option, + pub disk_limit: Option, // bytes + pub scale: u16, + pub workers: u64, + pub credits_per_hour: String, // Numeric as string + pub cpu_exclusive: bool, + pub is_cc: bool, + pub swap_enabled: bool, + pub disabled: bool, + pub selectors: BTreeMap, + pub builtin: bool, +} +``` + +#### Combined durable type + +```rust +pub struct ClusterReplicaSize { + pub id: ClusterReplicaSizeId, + pub name: String, + pub allocation: ReplicaAllocation, + pub builtin: bool, +} +``` + +Name uniqueness across the table is enforced by the `UniqueName` +trait on `ClusterReplicaSizeValue`. + +### Builtin sync + +On every catalog open, `sync_builtin_cluster_replica_sizes()` reconciles +the env-var `ClusterReplicaSizeMap` with durable state: + +* **New sizes** in the env var are inserted with `builtin: true`. +* **Changed allocations** are retracted and reinserted. +* **Removed sizes** are handled based on usage: + * If no replica references the size, it is deleted. + * If a replica still uses it, it is marked `disabled: true` with a + warning log, preventing new replicas from using it while avoiding + panics in `concretize_replica_location`. + +`CatalogState.cluster_replica_sizes` is initialized empty and populated +from durable state updates (via `apply_cluster_replica_size_update`) +rather than directly from config. + +### SQL DDL + +```sql +CREATE CLUSTER REPLICA SIZE ( + CREDITS PER HOUR = '', -- required + WORKERS = , -- default 1 + SCALE = , -- default 1 + MEMORY LIMIT = '', -- e.g. '4GiB', '512MiB' + CPU LIMIT = '', -- e.g. '0.5', '500m' + DISK LIMIT = '', + CPU EXCLUSIVE = , + DISABLED = , + IS CC = , -- default true + SWAP ENABLED = , + NODE SELECTORS = '' -- e.g. '{"k8s.io/arch": "arm64"}' +); + +DROP CLUSTER REPLICA SIZE ; +``` + +**Human-readable units:** +* Memory/disk: `GiB`, `MiB`, `GB`, `MB`, `kB`, or raw bytes. +* CPU: cores (`0.5`, `2`), millicpus (`500m`), or raw nanocpus. + +**Access control:** +* Gated behind `enable_custom_cluster_replica_sizes` feature flag + (default off). +* `mz_system` bypasses the feature flag. +* RBAC requires superuser for both CREATE and DROP. +* Cannot drop builtin sizes or sizes in use by existing replicas. +* Cannot create a size with a name that already exists. + +**Credit enforcement:** In self-managed deployments, `credits_per_hour` +is automatically calculated as `(memory_limit * scale) / 1 GiB`, +matching the existing behavior of env-var sizes. The user-provided +`CREDITS PER HOUR` value is ignored. This ensures the DDL cannot be +used to bypass license-based billing limits. Cloud deployments (where +the license allows credit consumption overrides) honor the user-provided +value. + +**Immutability:** Sizes cannot be altered after creation. To change a +size definition, drop it (after migrating replicas off it) and recreate +with the new parameters. + +### System tables + +**`mz_catalog.mz_cluster_replica_sizes`** (existing, public): Updated +via durable state updates instead of manual startup packing. Shows +`size`, `processes`, `workers`, `cpu_nano_cores`, `memory_bytes`, +`disk_bytes`, `credits_per_hour`. + +**`mz_internal.mz_cluster_replica_size_details`** (new, public): +Exposes the full allocation including `cpu_exclusive`, `is_cc`, +`swap_enabled`, `disabled`, `builtin`, and `node_selectors` (as JSONB). + +### Audit logging + +`ObjectType::ClusterReplicaSize` added to the audit log enum. CREATE +and DROP operations emit audit events with `EventDetails::IdNameV1`. + +## Alternatives + +### String key (name) as the catalog key + +An earlier iteration used the size name as the durable key directly, +avoiding the need for a separate ID type. This worked but was +inconsistent with every other catalog object and would have made +size rename impossible without replica migration (since the name +would be the primary identity). The ID approach adds minor +complexity in exchange for pattern consistency and future rename +support, without requiring any changes to how replicas reference +sizes today. + +### Mutable sizes with drift tracking + +An alternative design would allow `ALTER CLUSTER REPLICA SIZE` and +track which allocation each replica was created with. This enables +live reconfiguration but introduces significant complexity: snapshot +allocation at creation time, drift detection columns, history tables. +The immutable approach is simpler and sufficient for the initial use +case. ALTER can be added later if needed. + +### Storing `ReplicaAllocation` directly in the durable value + +The durable `ClusterReplicaSizeValue` could embed `ReplicaAllocation` +directly. However, `ReplicaAllocation` contains `Numeric` (for +`credits_per_hour`) which doesn't implement `Eq`/`Ord`, both required +by `TableTransaction`. Storing raw `u64`/`String` fields and +converting in `DurableType::from_key_value` avoids this constraint. + +## Open Questions + +* Should we actually provide this to self-managed customers? +* Adding new replica sizes in cloud is tricky and requires input from finance. + How do we prevent support from going wild and creating new replica sizes. diff --git a/doc/user/content/reference/system-catalog/mz_internal.md b/doc/user/content/reference/system-catalog/mz_internal.md index f2c38b08f80d6..4da0350a39923 100644 --- a/doc/user/content/reference/system-catalog/mz_internal.md +++ b/doc/user/content/reference/system-catalog/mz_internal.md @@ -183,6 +183,8 @@ At this time, we do not make any guarantees about the exactness or freshness of | `heap_bytes` | [`uint8`] | Approximate heap (RAM + swap) usage, in bytes. | `heap_limit` | [`uint8`] | Available heap (RAM + swap) space, in bytes. + + ## `mz_cluster_replica_metrics_history` {{< warn-if-unreleased v0.116 >}} diff --git a/src/adapter/src/catalog/apply.rs b/src/adapter/src/catalog/apply.rs index 6dc48c3335997..98a97f654ec8c 100644 --- a/src/adapter/src/catalog/apply.rs +++ b/src/adapter/src/catalog/apply.rs @@ -300,6 +300,9 @@ impl CatalogState { StateUpdateKind::NetworkPolicy(network_policy) => { self.apply_network_policy_update(network_policy, diff, retractions); } + StateUpdateKind::ClusterReplicaSize(size) => { + self.apply_cluster_replica_size_update(size, diff, retractions); + } StateUpdateKind::IntrospectionSourceIndex(introspection_source_index) => { self.apply_introspection_source_index_update( introspection_source_index, @@ -542,6 +545,25 @@ impl CatalogState { ); } + #[instrument(level = "debug")] + fn apply_cluster_replica_size_update( + &mut self, + size: mz_catalog::durable::ClusterReplicaSize, + diff: StateDiff, + _retractions: &mut InProgressRetractions, + ) { + match diff { + StateDiff::Addition => { + self.cluster_replica_sizes + .0 + .insert(size.name, size.allocation); + } + StateDiff::Retraction => { + self.cluster_replica_sizes.0.remove(&size.name); + } + } + } + #[instrument(level = "debug")] fn apply_introspection_source_index_update( &mut self, @@ -1454,6 +1476,18 @@ impl CatalogState { .expect("could not pack audit log update"), ] } + StateUpdateKind::ClusterReplicaSize(ref size) => { + if size.allocation.disabled { + Vec::new() + } else { + CatalogState::pack_replica_size_update( + &size.name, + &size.allocation, + size.builtin, + diff, + ) + } + } StateUpdateKind::Database(_) | StateUpdateKind::Schema(_) | StateUpdateKind::NetworkPolicy(_) @@ -2031,7 +2065,8 @@ fn sort_updates(updates: Vec) -> Vec { | StateUpdateKind::DefaultPrivilege(_) | StateUpdateKind::SystemPrivilege(_) | StateUpdateKind::SystemConfiguration(_) - | StateUpdateKind::NetworkPolicy(_) => push_update( + | StateUpdateKind::NetworkPolicy(_) + | StateUpdateKind::ClusterReplicaSize(_) => push_update( update, diff, &mut pre_cluster_retractions, @@ -2397,6 +2432,7 @@ impl ApplyState { | SystemConfiguration(_) | Cluster(_) | NetworkPolicy(_) + | ClusterReplicaSize(_) | ClusterReplica(_) | SourceReferences(_) | Comment(_) diff --git a/src/adapter/src/catalog/builtin_table_updates.rs b/src/adapter/src/catalog/builtin_table_updates.rs index a6ac617bc6628..167d173c90e69 100644 --- a/src/adapter/src/catalog/builtin_table_updates.rs +++ b/src/adapter/src/catalog/builtin_table_updates.rs @@ -16,17 +16,18 @@ use mz_audit_log::{EventDetails, EventType, ObjectType, VersionedEvent, Versione use mz_catalog::SYSTEM_CONN_ID; use mz_catalog::builtin::{ BuiltinTable, MZ_AGGREGATES, MZ_ARRAY_TYPES, MZ_AUDIT_EVENTS, MZ_AWS_CONNECTIONS, - MZ_AWS_PRIVATELINK_CONNECTIONS, MZ_BASE_TYPES, MZ_CLUSTER_REPLICA_SIZES, MZ_CLUSTER_REPLICAS, - MZ_CLUSTER_SCHEDULES, MZ_CLUSTERS, MZ_COLUMNS, MZ_COMMENTS, MZ_CONNECTIONS, MZ_CONTINUAL_TASKS, - MZ_DEFAULT_PRIVILEGES, MZ_EGRESS_IPS, MZ_FUNCTIONS, MZ_HISTORY_RETENTION_STRATEGIES, - MZ_ICEBERG_SINKS, MZ_INDEX_COLUMNS, MZ_INDEXES, MZ_KAFKA_CONNECTIONS, MZ_KAFKA_SINKS, - MZ_KAFKA_SOURCE_TABLES, MZ_KAFKA_SOURCES, MZ_LICENSE_KEYS, MZ_LIST_TYPES, MZ_MAP_TYPES, - MZ_MATERIALIZED_VIEW_REFRESH_STRATEGIES, MZ_MYSQL_SOURCE_TABLES, MZ_OBJECT_DEPENDENCIES, - MZ_OBJECT_GLOBAL_IDS, MZ_OPERATORS, MZ_POSTGRES_SOURCE_TABLES, MZ_POSTGRES_SOURCES, - MZ_PSEUDO_TYPES, MZ_REPLACEMENTS, MZ_ROLE_AUTH, MZ_ROLE_PARAMETERS, MZ_ROLES, MZ_SECRETS, - MZ_SESSIONS, MZ_SINKS, MZ_SOURCE_REFERENCES, MZ_SOURCES, MZ_SQL_SERVER_SOURCE_TABLES, - MZ_SSH_TUNNEL_CONNECTIONS, MZ_STORAGE_USAGE_BY_SHARD, MZ_SUBSCRIPTIONS, MZ_SYSTEM_PRIVILEGES, - MZ_TABLES, MZ_TYPE_PG_METADATA, MZ_TYPES, MZ_VIEWS, MZ_WEBHOOKS_SOURCES, + MZ_AWS_PRIVATELINK_CONNECTIONS, MZ_BASE_TYPES, MZ_CLUSTER_REPLICA_SIZE_DETAILS, + MZ_CLUSTER_REPLICA_SIZES, MZ_CLUSTER_REPLICAS, MZ_CLUSTER_SCHEDULES, MZ_CLUSTERS, MZ_COLUMNS, + MZ_COMMENTS, MZ_CONNECTIONS, MZ_CONTINUAL_TASKS, MZ_DEFAULT_PRIVILEGES, MZ_EGRESS_IPS, + MZ_FUNCTIONS, MZ_HISTORY_RETENTION_STRATEGIES, MZ_ICEBERG_SINKS, MZ_INDEX_COLUMNS, MZ_INDEXES, + MZ_KAFKA_CONNECTIONS, MZ_KAFKA_SINKS, MZ_KAFKA_SOURCE_TABLES, MZ_KAFKA_SOURCES, + MZ_LICENSE_KEYS, MZ_LIST_TYPES, MZ_MAP_TYPES, MZ_MATERIALIZED_VIEW_REFRESH_STRATEGIES, + MZ_MYSQL_SOURCE_TABLES, MZ_OBJECT_DEPENDENCIES, MZ_OBJECT_GLOBAL_IDS, MZ_OPERATORS, + MZ_POSTGRES_SOURCE_TABLES, MZ_POSTGRES_SOURCES, MZ_PSEUDO_TYPES, MZ_REPLACEMENTS, MZ_ROLE_AUTH, + MZ_ROLE_PARAMETERS, MZ_ROLES, MZ_SECRETS, MZ_SESSIONS, MZ_SINKS, MZ_SOURCE_REFERENCES, + MZ_SOURCES, MZ_SQL_SERVER_SOURCE_TABLES, MZ_SSH_TUNNEL_CONNECTIONS, MZ_STORAGE_USAGE_BY_SHARD, + MZ_SUBSCRIPTIONS, MZ_SYSTEM_PRIVILEGES, MZ_TABLES, MZ_TYPE_PG_METADATA, MZ_TYPES, MZ_VIEWS, + MZ_WEBHOOKS_SOURCES, }; use mz_catalog::config::AwsPrincipalContext; use mz_catalog::durable::SourceReferences; @@ -35,6 +36,7 @@ use mz_catalog::memory::objects::{ CatalogEntry, CatalogItem, ClusterVariant, Connection, ContinualTask, DataSourceDesc, Func, Index, MaterializedView, Sink, Table, TableDataSource, Type, View, }; +use mz_controller::clusters::ReplicaAllocation; use mz_controller::clusters::{ ManagedReplicaAvailabilityZones, ManagedReplicaLocation, ReplicaLocation, }; @@ -1933,27 +1935,13 @@ impl CatalogState { continue; } - // Just invent something when the limits are `None`, which only happens in non-prod - // environments (tests, process orchestrator, etc.) - let cpu_limit = alloc.cpu_limit.unwrap_or(CpuLimit::MAX); - let MemoryLimit(ByteSize(memory_bytes)) = - (alloc.memory_limit).unwrap_or(MemoryLimit::MAX); - let DiskLimit(ByteSize(disk_bytes)) = - (alloc.disk_limit).unwrap_or(DiskLimit::ARBITRARY); - - let row = Row::pack_slice(&[ - size.as_str().into(), - u64::cast_from(alloc.scale).into(), - u64::cast_from(alloc.workers).into(), - cpu_limit.as_nanocpus().into(), - memory_bytes.into(), - disk_bytes.into(), - (alloc.credits_per_hour).into(), - ]); - - updates.push(BuiltinTableUpdate::row( - &*MZ_CLUSTER_REPLICA_SIZES, - row, + // The builtin flag isn't available from ClusterReplicaSizeMap; the details + // table is populated correctly via state updates in apply.rs which has + // access to the full ClusterReplicaSize with the builtin flag. + updates.extend(Self::pack_replica_size_update( + size, + alloc, + false, Diff::ONE, )); } @@ -1961,6 +1949,53 @@ impl CatalogState { updates } + pub fn pack_replica_size_update( + size: &str, + alloc: &ReplicaAllocation, + builtin: bool, + diff: Diff, + ) -> Vec> { + // Just invent something when the limits are `None`, which only happens in non-prod + // environments (tests, process orchestrator, etc.) + let cpu_limit = alloc.cpu_limit.unwrap_or(CpuLimit::MAX); + let MemoryLimit(ByteSize(memory_bytes)) = (alloc.memory_limit).unwrap_or(MemoryLimit::MAX); + let DiskLimit(ByteSize(disk_bytes)) = (alloc.disk_limit).unwrap_or(DiskLimit::ARBITRARY); + + let public_row = Row::pack_slice(&[ + size.into(), + u64::cast_from(alloc.scale).into(), + u64::cast_from(alloc.workers).into(), + cpu_limit.as_nanocpus().into(), + memory_bytes.into(), + disk_bytes.into(), + (alloc.credits_per_hour).into(), + ]); + + let selectors_value = + serde_json::to_value(&alloc.selectors).expect("selectors serializable"); + let selectors_jsonb = Jsonb::from_serde_json(selectors_value).expect("valid jsonb"); + let details_row = Row::pack_slice(&[ + size.into(), + u64::cast_from(alloc.scale).into(), + u64::cast_from(alloc.workers).into(), + cpu_limit.as_nanocpus().into(), + memory_bytes.into(), + disk_bytes.into(), + (alloc.credits_per_hour).into(), + alloc.cpu_exclusive.into(), + alloc.is_cc.into(), + alloc.swap_enabled.into(), + alloc.disabled.into(), + builtin.into(), + selectors_jsonb.into_row().into_element(), + ]); + + vec![ + BuiltinTableUpdate::row(&*MZ_CLUSTER_REPLICA_SIZES, public_row, diff), + BuiltinTableUpdate::row(&*MZ_CLUSTER_REPLICA_SIZE_DETAILS, details_row, diff), + ] + } + pub fn pack_subscribe_update( &self, id: GlobalId, diff --git a/src/adapter/src/catalog/open.rs b/src/adapter/src/catalog/open.rs index 25dec5e896b5d..f306ae64cc690 100644 --- a/src/adapter/src/catalog/open.rs +++ b/src/adapter/src/catalog/open.rs @@ -29,7 +29,7 @@ use mz_catalog::builtin::{ BUILTIN_CLUSTER_REPLICAS, BUILTIN_CLUSTERS, BUILTIN_PREFIXES, BUILTIN_ROLES, BUILTINS, Builtin, Fingerprint, MZ_CATALOG_RAW, RUNTIME_ALTERABLE_FINGERPRINT_SENTINEL, }; -use mz_catalog::config::StateConfig; +use mz_catalog::config::{ClusterReplicaSizeMap, StateConfig}; use mz_catalog::durable::objects::{ SystemObjectDescription, SystemObjectMapping, SystemObjectUniqueIdentifier, }; @@ -176,7 +176,8 @@ impl Catalog { }, helm_chart_version: config.helm_chart_version, }, - cluster_replica_sizes: config.cluster_replica_sizes, + // Start empty; populated from durable state updates after builtin sync. + cluster_replica_sizes: ClusterReplicaSizeMap(std::collections::BTreeMap::new()), availability_zones: config.availability_zones, egress_addresses: config.egress_addresses, aws_principal_context: config.aws_principal_context, @@ -228,6 +229,7 @@ impl Catalog { config.boot_ts, )?; add_new_remove_old_builtin_roles_migration(&mut txn)?; + sync_builtin_cluster_replica_sizes(&mut txn, &config.cluster_replica_sizes)?; remove_invalid_config_param_role_defaults_migration(&mut txn)?; remove_pending_cluster_replicas_migration(&mut txn, config.boot_ts)?; @@ -282,6 +284,7 @@ impl Catalog { | BootstrapStateUpdateKind::SystemConfiguration(_) | BootstrapStateUpdateKind::Cluster(_) | BootstrapStateUpdateKind::NetworkPolicy(_) + | BootstrapStateUpdateKind::ClusterReplicaSize(_) | BootstrapStateUpdateKind::ClusterReplica(_) => { pre_item_updates.push(StateUpdate { kind: kind.into(), @@ -1117,6 +1120,89 @@ fn add_new_remove_old_builtin_roles_migration( Ok(()) } +/// Syncs the builtin cluster replica sizes from the env-var configuration into +/// the durable catalog. Inserts new sizes, updates changed sizes, and removes +/// sizes that are no longer in the configuration. +fn sync_builtin_cluster_replica_sizes( + txn: &mut Transaction<'_>, + config_sizes: &ClusterReplicaSizeMap, +) -> Result<(), AdapterError> { + use std::collections::BTreeMap; + + use mz_catalog::durable::objects::DurableType; + + // Collect current durable builtin sizes. + let durable_sizes: BTreeMap = txn + .get_cluster_replica_sizes() + .filter(|s| s.builtin) + .map(|s| (s.name.clone(), s)) + .collect(); + + // Insert or update builtins from config. + for (name, allocation) in &config_sizes.0 { + if let Some(existing) = durable_sizes.get(name) { + // Check if the allocation changed by comparing the durable value + // representation (which is Eq-comparable). Reuse the existing ID + // so the key stays stable across restarts. + let new_size = mz_catalog::durable::ClusterReplicaSize { + id: existing.id, + name: name.clone(), + allocation: allocation.clone(), + builtin: true, + }; + let (_, new_value) = DurableType::into_key_value(new_size); + let (_, existing_value) = DurableType::into_key_value(existing.clone()); + if new_value != existing_value { + // Retract and reinsert with updated allocation. The reinsertion + // will allocate a fresh ID, which is fine — the old one was + // only meaningful while the size existed. + txn.remove_cluster_replica_size(name)?; + txn.insert_cluster_replica_size(name.clone(), allocation.clone(), true)?; + } + } else { + // New builtin size, insert it. + txn.insert_cluster_replica_size(name.clone(), allocation.clone(), true)?; + } + } + + // Remove or disable builtins that are no longer in config. + // If a replica still references the size, mark it disabled instead of + // deleting to avoid panics in concretize_replica_location. + // If no replica references it, delete it outright. + let in_use_sizes: std::collections::BTreeSet = txn + .get_cluster_replicas() + .filter_map(|r| match r.config.location { + mz_catalog::durable::ReplicaLocation::Managed { ref size, .. } => Some(size.clone()), + mz_catalog::durable::ReplicaLocation::Unmanaged { .. } => None, + }) + .collect(); + + for (name, existing) in &durable_sizes { + if !config_sizes.0.contains_key(name) { + if in_use_sizes.contains(name) { + // Still referenced by a replica — keep but disable. + warn!( + "builtin cluster replica size '{}' removed from config but still \ + in use by a replica; marking as disabled", + name + ); + let mut disabled_allocation = existing.allocation.clone(); + disabled_allocation.disabled = true; + txn.remove_cluster_replica_size(name)?; + txn.insert_cluster_replica_size(name.clone(), disabled_allocation, true)?; + } else { + info!( + "removing builtin cluster replica size '{}' (no longer in config)", + name + ); + txn.remove_cluster_replica_size(name)?; + } + } + } + + Ok(()) +} + fn add_new_remove_old_builtin_cluster_replicas_migration( txn: &mut Transaction<'_>, builtin_cluster_config_map: &BuiltinBootstrapClusterConfigMap, diff --git a/src/adapter/src/catalog/state.rs b/src/adapter/src/catalog/state.rs index a3e1dbbbec4e8..f6210857a41e5 100644 --- a/src/adapter/src/catalog/state.rs +++ b/src/adapter/src/catalog/state.rs @@ -2446,6 +2446,20 @@ impl CatalogState { } } + /// Returns true if the given cluster replica size name is in use by any + /// existing cluster replica. + pub fn is_cluster_replica_size_in_use(&self, size_name: &str) -> bool { + use mz_controller::clusters::ReplicaLocation; + self.clusters_by_id.values().any(|cluster| { + cluster.replicas().any(|replica| { + matches!( + &replica.config.location, + ReplicaLocation::Managed(loc) if loc.size == size_name + ) + }) + }) + } + pub fn ensure_not_reserved_role(&self, role_id: &RoleId) -> Result<(), Error> { if role_id.is_builtin() { let role = self.get_role(role_id); diff --git a/src/adapter/src/catalog/transact.rs b/src/adapter/src/catalog/transact.rs index 68a1fc03a44ae..4d1156fe9f721 100644 --- a/src/adapter/src/catalog/transact.rs +++ b/src/adapter/src/catalog/transact.rs @@ -165,6 +165,23 @@ pub enum Op { name: String, owner_id: RoleId, }, + CreateClusterReplicaSize { + name: String, + workers: usize, + scale: u16, + credits_per_hour: mz_repr::adt::numeric::Numeric, + memory_limit: Option, + cpu_limit: Option, + disk_limit: Option, + cpu_exclusive: bool, + disabled: bool, + selectors: BTreeMap, + is_cc: bool, + swap_enabled: bool, + }, + DropClusterReplicaSize { + name: String, + }, Comment { object_id: CommentObjectId, sub_component: Option, @@ -1664,6 +1681,91 @@ impl Catalog { info!("created network policy {name} ({id})"); } + Op::CreateClusterReplicaSize { + name, + workers, + scale, + credits_per_hour, + memory_limit, + cpu_limit, + disk_limit, + cpu_exclusive, + disabled, + selectors, + is_cc, + swap_enabled, + } => { + // Build ReplicaAllocation from the fields + use mz_orchestrator::{CpuLimit, DiskLimit, MemoryLimit}; + use std::num::NonZero; + + let allocation = mz_controller::clusters::ReplicaAllocation { + memory_limit: memory_limit.map(|b| MemoryLimit(bytesize::ByteSize(b))), + memory_request: None, + cpu_limit: cpu_limit.map(|n| { + CpuLimit::from_millicpus(usize::try_from(n / 1_000_000).expect("cpu fits")) + }), + cpu_request: None, + disk_limit: disk_limit.map(|b| DiskLimit(bytesize::ByteSize(b))), + scale: NonZero::new(scale).expect("scale must be non-zero"), + workers: NonZero::new(workers).expect("workers must be non-zero"), + credits_per_hour, + cpu_exclusive, + is_cc, + swap_enabled, + disabled, + selectors, + }; + tx.insert_cluster_replica_size(name.clone(), allocation, false)?; + + CatalogState::add_to_audit_log( + &state.system_configuration, + oracle_write_ts, + session, + tx, + audit_events, + EventType::Create, + mz_audit_log::ObjectType::ClusterReplicaSize, + EventDetails::IdNameV1(mz_audit_log::IdNameV1 { + id: name.clone(), + name: name.clone(), + }), + )?; + } + Op::DropClusterReplicaSize { name } => { + // Check that it exists and is not builtin + let sizes: Vec<_> = tx.get_cluster_replica_sizes().collect(); + let size = sizes.iter().find(|s| s.name == name); + match size { + Some(s) if s.builtin => { + return Err(AdapterError::Catalog(Error::new( + ErrorKind::ReadOnlyClusterReplicaSize(name), + ))); + } + Some(_) => { + tx.remove_cluster_replica_size(&name)?; + } + None => { + return Err(AdapterError::PlanError(PlanError::Catalog( + SqlCatalogError::UnknownClusterReplicaSize(name), + ))); + } + } + + CatalogState::add_to_audit_log( + &state.system_configuration, + oracle_write_ts, + session, + tx, + audit_events, + EventType::Drop, + mz_audit_log::ObjectType::ClusterReplicaSize, + EventDetails::IdNameV1(mz_audit_log::IdNameV1 { + id: name.clone(), + name: name.clone(), + }), + )?; + } Op::Comment { object_id, sub_component, diff --git a/src/adapter/src/command.rs b/src/adapter/src/command.rs index 55d4ddd526891..ea55788f4a393 100644 --- a/src/adapter/src/command.rs +++ b/src/adapter/src/command.rs @@ -589,6 +589,10 @@ pub enum ExecuteResponse { CreatedType, /// The requested network policy was created. CreatedNetworkPolicy, + /// The requested cluster replica size was created. + CreatedClusterReplicaSize, + /// The requested cluster replica size was dropped. + DroppedClusterReplicaSize, /// The requested prepared statement was removed. Deallocate { all: bool }, /// The requested cursor was declared. @@ -755,6 +759,12 @@ impl TryInto for ExecuteResponseKind { Ok(ExecuteResponse::CreatedMaterializedView) } ExecuteResponseKind::CreatedNetworkPolicy => Ok(ExecuteResponse::CreatedNetworkPolicy), + ExecuteResponseKind::CreatedClusterReplicaSize => { + Ok(ExecuteResponse::CreatedClusterReplicaSize) + } + ExecuteResponseKind::DroppedClusterReplicaSize => { + Ok(ExecuteResponse::DroppedClusterReplicaSize) + } ExecuteResponseKind::CreatedContinualTask => Ok(ExecuteResponse::CreatedContinualTask), ExecuteResponseKind::CreatedType => Ok(ExecuteResponse::CreatedType), ExecuteResponseKind::Deallocate => Err(()), @@ -820,6 +830,8 @@ impl ExecuteResponse { CreatedContinualTask { .. } => Some("CREATE CONTINUAL TASK".into()), CreatedType => Some("CREATE TYPE".into()), CreatedNetworkPolicy => Some("CREATE NETWORKPOLICY".into()), + CreatedClusterReplicaSize => Some("CREATE CLUSTER REPLICA SIZE".into()), + DroppedClusterReplicaSize => Some("DROP CLUSTER REPLICA SIZE".into()), Deallocate { all } => Some(format!("DEALLOCATE{}", if *all { " ALL" } else { "" })), DeclaredCursor => Some("DECLARE CURSOR".into()), Deleted(n) => Some(format!("DELETE {}", n)), @@ -914,6 +926,8 @@ impl ExecuteResponse { CreateType => &[CreatedType], PlanKind::Deallocate => &[ExecuteResponseKind::Deallocate], CreateNetworkPolicy => &[CreatedNetworkPolicy], + CreateClusterReplicaSize => &[CreatedClusterReplicaSize], + DropClusterReplicaSize => &[DroppedClusterReplicaSize], Declare => &[DeclaredCursor], DiscardTemp => &[DiscardedTemp], DiscardAll => &[DiscardedAll], diff --git a/src/adapter/src/coord.rs b/src/adapter/src/coord.rs index a4370bfffa5d8..63d6f516c688a 100644 --- a/src/adapter/src/coord.rs +++ b/src/adapter/src/coord.rs @@ -2391,12 +2391,8 @@ impl Coordinator { self.initialize_read_policies(&policies, cw).await; } - // Expose mapping from T-shirt sizes to actual sizes - builtin_table_updates.extend( - self.catalog().state().resolve_builtin_table_updates( - self.catalog().state().pack_all_replica_size_updates(), - ), - ); + // Cluster replica sizes are now durable objects; their builtin table updates + // are generated via state updates in apply.rs, so no manual packing needed here. debug!("startup: coordinator init: bootstrap: initializing migrated builtin tables"); // When 0dt is enabled, we create new shards for any migrated builtin storage collections. diff --git a/src/adapter/src/coord/appends.rs b/src/adapter/src/coord/appends.rs index 265ffa5841d6a..20d986954a310 100644 --- a/src/adapter/src/coord/appends.rs +++ b/src/adapter/src/coord/appends.rs @@ -957,6 +957,8 @@ pub(crate) fn waiting_on_startup_appends( | Plan::CreateSchema(_) | Plan::CreateRole(_) | Plan::CreateNetworkPolicy(_) + | Plan::CreateClusterReplicaSize(_) + | Plan::DropClusterReplicaSize(_) | Plan::CreateCluster(_) | Plan::CreateClusterReplica(_) | Plan::CreateContinualTask(_) diff --git a/src/adapter/src/coord/catalog_serving.rs b/src/adapter/src/coord/catalog_serving.rs index aa3a92b5c4b2a..3619b5c76b175 100644 --- a/src/adapter/src/coord/catalog_serving.rs +++ b/src/adapter/src/coord/catalog_serving.rs @@ -82,6 +82,8 @@ pub fn auto_run_on_catalog_server<'a, 's, 'p>( | Plan::CreateSchema(_) | Plan::CreateRole(_) | Plan::CreateNetworkPolicy(_) + | Plan::CreateClusterReplicaSize(_) + | Plan::DropClusterReplicaSize(_) | Plan::CreateCluster(_) | Plan::CreateClusterReplica(_) | Plan::CreateContinualTask(_) diff --git a/src/adapter/src/coord/command_handler.rs b/src/adapter/src/coord/command_handler.rs index d58c6b4c095aa..3301ea6834eff 100644 --- a/src/adapter/src/coord/command_handler.rs +++ b/src/adapter/src/coord/command_handler.rs @@ -1296,6 +1296,8 @@ impl Coordinator { | Statement::CreateView(_) | Statement::CreateWebhookSource(_) | Statement::CreateNetworkPolicy(_) + | Statement::CreateClusterReplicaSize(_) + | Statement::DropClusterReplicaSize(_) | Statement::Delete(_) | Statement::DropObjects(_) | Statement::DropOwned(_) diff --git a/src/adapter/src/coord/ddl.rs b/src/adapter/src/coord/ddl.rs index c6ea49132cd7a..9a13cee0d63ef 100644 --- a/src/adapter/src/coord/ddl.rs +++ b/src/adapter/src/coord/ddl.rs @@ -1291,7 +1291,9 @@ impl Coordinator { | Op::ResetAllSystemConfiguration { .. } | Op::Comment { .. } | Op::WeirdStorageUsageUpdates { .. } - | Op::InjectAuditEvents { .. } => {} + | Op::InjectAuditEvents { .. } + | Op::CreateClusterReplicaSize { .. } + | Op::DropClusterReplicaSize { .. } => {} } } diff --git a/src/adapter/src/coord/sequencer.rs b/src/adapter/src/coord/sequencer.rs index c77b1bc89be07..5a98bc2f0d351 100644 --- a/src/adapter/src/coord/sequencer.rs +++ b/src/adapter/src/coord/sequencer.rs @@ -302,6 +302,18 @@ impl Coordinator { .await; ctx.retire(res); } + Plan::CreateClusterReplicaSize(plan) => { + let res = self + .sequence_create_cluster_replica_size(ctx.session(), plan) + .await; + ctx.retire(res); + } + Plan::DropClusterReplicaSize(plan) => { + let res = self + .sequence_drop_cluster_replica_size(ctx.session(), plan) + .await; + ctx.retire(res); + } Plan::Comment(plan) => { let result = self.sequence_comment_on(ctx.session(), plan).await; ctx.retire(result); diff --git a/src/adapter/src/coord/sequencer/inner.rs b/src/adapter/src/coord/sequencer/inner.rs index d9923192fe3d7..e40b3b8278ea8 100644 --- a/src/adapter/src/coord/sequencer/inner.rs +++ b/src/adapter/src/coord/sequencer/inner.rs @@ -905,6 +905,57 @@ impl Coordinator { .map(|_| ExecuteResponse::CreatedNetworkPolicy) } + #[instrument] + pub(super) async fn sequence_create_cluster_replica_size( + &mut self, + _session: &Session, + plan: plan::CreateClusterReplicaSizePlan, + ) -> Result { + let op = catalog::Op::CreateClusterReplicaSize { + name: plan.name, + workers: plan.workers, + scale: plan.scale, + credits_per_hour: plan.credits_per_hour, + memory_limit: plan.memory_limit, + cpu_limit: plan.cpu_limit, + disk_limit: plan.disk_limit, + cpu_exclusive: plan.cpu_exclusive, + disabled: plan.disabled, + selectors: plan.selectors, + is_cc: plan.is_cc, + swap_enabled: plan.swap_enabled, + }; + self.catalog_transact(None, vec![op]) + .await + .map(|_| ExecuteResponse::CreatedClusterReplicaSize) + } + + #[instrument] + pub(super) async fn sequence_drop_cluster_replica_size( + &mut self, + _session: &Session, + plan: plan::DropClusterReplicaSizePlan, + ) -> Result { + // Check in-use + if self + .catalog() + .state() + .is_cluster_replica_size_in_use(&plan.name) + { + return Err(AdapterError::Catalog( + mz_catalog::memory::error::Error::new( + mz_catalog::memory::error::ErrorKind::ClusterReplicaSizeInUse( + plan.name.clone(), + ), + ), + )); + } + let op = catalog::Op::DropClusterReplicaSize { name: plan.name }; + self.catalog_transact(None, vec![op]) + .await + .map(|_| ExecuteResponse::DroppedClusterReplicaSize) + } + #[instrument] pub(super) async fn sequence_alter_network_policy( &mut self, diff --git a/src/adapter/src/statement_logging.rs b/src/adapter/src/statement_logging.rs index 7fb908574ed3b..004ffe1a29e8d 100644 --- a/src/adapter/src/statement_logging.rs +++ b/src/adapter/src/statement_logging.rs @@ -236,6 +236,8 @@ impl From<&ExecuteResponse> for StatementEndedExecutionReason { | ExecuteResponse::CreatedContinualTask | ExecuteResponse::CreatedType | ExecuteResponse::CreatedNetworkPolicy + | ExecuteResponse::CreatedClusterReplicaSize + | ExecuteResponse::DroppedClusterReplicaSize | ExecuteResponse::Deallocate { .. } | ExecuteResponse::DeclaredCursor | ExecuteResponse::Deleted(_) diff --git a/src/audit-log/src/lib.rs b/src/audit-log/src/lib.rs index 5880f139b80e7..bda2fafcebbcc 100644 --- a/src/audit-log/src/lib.rs +++ b/src/audit-log/src/lib.rs @@ -145,6 +145,7 @@ pub enum ObjectType { Func, Index, MaterializedView, + ClusterReplicaSize, NetworkPolicy, Role, Secret, @@ -162,6 +163,7 @@ impl ObjectType { match self { ObjectType::Cluster => "Cluster", ObjectType::ClusterReplica => "Cluster Replica", + ObjectType::ClusterReplicaSize => "Cluster Replica Size", ObjectType::Connection => "Connection", ObjectType::ContinualTask => "Continual Task", ObjectType::Database => "Database", diff --git a/src/catalog-debug/src/main.rs b/src/catalog-debug/src/main.rs index df4bc97f91784..8da252b4cdcdd 100644 --- a/src/catalog-debug/src/main.rs +++ b/src/catalog-debug/src/main.rs @@ -32,11 +32,11 @@ use mz_build_info::{BuildInfo, build_info}; use mz_catalog::config::{BuiltinItemMigrationConfig, ClusterReplicaSizeMap, StateConfig}; use mz_catalog::durable::debug::{ AuditLogCollection, ClusterCollection, ClusterIntrospectionSourceIndexCollection, - ClusterReplicaCollection, Collection, CollectionTrace, CollectionType, CommentCollection, - ConfigCollection, DatabaseCollection, DebugCatalogState, DefaultPrivilegeCollection, - IdAllocatorCollection, ItemCollection, NetworkPolicyCollection, RoleAuthCollection, - RoleCollection, SchemaCollection, SettingCollection, SourceReferencesCollection, - StorageCollectionMetadataCollection, SystemConfigurationCollection, + ClusterReplicaCollection, ClusterReplicaSizeCollection, Collection, CollectionTrace, + CollectionType, CommentCollection, ConfigCollection, DatabaseCollection, DebugCatalogState, + DefaultPrivilegeCollection, IdAllocatorCollection, ItemCollection, NetworkPolicyCollection, + RoleAuthCollection, RoleCollection, SchemaCollection, SettingCollection, + SourceReferencesCollection, StorageCollectionMetadataCollection, SystemConfigurationCollection, SystemItemMappingCollection, SystemPrivilegeCollection, Trace, TxnWalShardCollection, UnfinalizedShardsCollection, }; @@ -300,6 +300,9 @@ macro_rules! for_collection { } CollectionType::IdAlloc => $fn::($($arg),*).await?, CollectionType::Item => $fn::($($arg),*).await?, + CollectionType::ClusterReplicaSize => { + $fn::($($arg),*).await? + } CollectionType::NetworkPolicy => $fn::($($arg),*).await?, CollectionType::Role => $fn::($($arg),*).await?, CollectionType::RoleAuth => $fn::($($arg),*).await?, @@ -450,6 +453,7 @@ async fn dump( clusters, introspection_sources, cluster_replicas, + cluster_replica_sizes, comments, configs, databases, @@ -492,6 +496,13 @@ async fn dump( stats_only, consolidate, ); + dump_col( + &mut data, + cluster_replica_sizes, + &ignore, + stats_only, + consolidate, + ); dump_col(&mut data, comments, &ignore, stats_only, consolidate); dump_col(&mut data, configs, &ignore, stats_only, consolidate); dump_col(&mut data, databases, &ignore, stats_only, consolidate); diff --git a/src/catalog-protos/objects_hashes.json b/src/catalog-protos/objects_hashes.json index ebdcb5ef1ea79..861514324dd6a 100644 --- a/src/catalog-protos/objects_hashes.json +++ b/src/catalog-protos/objects_hashes.json @@ -1,7 +1,7 @@ [ { "name": "objects.rs", - "md5": "42585baa1b4b5e1b6da4e361a35ec546" + "md5": "4523ca826f29a9ac6b1eb4782170b110" }, { "name": "objects_v74.rs", @@ -34,5 +34,9 @@ { "name": "objects_v81.rs", "md5": "42585baa1b4b5e1b6da4e361a35ec546" + }, + { + "name": "objects_v82.rs", + "md5": "4523ca826f29a9ac6b1eb4782170b110" } ] diff --git a/src/catalog-protos/src/audit_log.rs b/src/catalog-protos/src/audit_log.rs index 8dbdf6253ac3e..0626ae961e193 100644 --- a/src/catalog-protos/src/audit_log.rs +++ b/src/catalog-protos/src/audit_log.rs @@ -82,6 +82,9 @@ impl RustType for mz_audit_log:: mz_audit_log::ObjectType::ClusterReplica => { crate::objects::audit_log_event_v1::ObjectType::ClusterReplica } + mz_audit_log::ObjectType::ClusterReplicaSize => { + crate::objects::audit_log_event_v1::ObjectType::ClusterReplicaSize + } mz_audit_log::ObjectType::Connection => { crate::objects::audit_log_event_v1::ObjectType::Connection } @@ -133,6 +136,9 @@ impl RustType for mz_audit_log:: crate::objects::audit_log_event_v1::ObjectType::ClusterReplica => { Ok(mz_audit_log::ObjectType::ClusterReplica) } + crate::objects::audit_log_event_v1::ObjectType::ClusterReplicaSize => { + Ok(mz_audit_log::ObjectType::ClusterReplicaSize) + } crate::objects::audit_log_event_v1::ObjectType::Connection => { Ok(mz_audit_log::ObjectType::Connection) } diff --git a/src/catalog-protos/src/lib.rs b/src/catalog-protos/src/lib.rs index 34aade71816a1..e553232530d14 100644 --- a/src/catalog-protos/src/lib.rs +++ b/src/catalog-protos/src/lib.rs @@ -19,6 +19,7 @@ pub mod objects_v78; pub mod objects_v79; pub mod objects_v80; pub mod objects_v81; +pub mod objects_v82; pub mod serialization; /// The current version of the `Catalog`. @@ -26,7 +27,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 = 81; +pub const CATALOG_VERSION: u64 = 82; /// 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 d8ced6a331103..e411fda3cac2e 100644 --- a/src/catalog-protos/src/objects.rs +++ b/src/catalog-protos/src/objects.rs @@ -465,6 +465,82 @@ pub struct NetworkPolicyValue { pub oid: u32, } +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ClusterReplicaSizeKey { + pub id: ClusterReplicaSizeId, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum ClusterReplicaSizeId { + System(u64), + User(u64), +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ClusterReplicaSizeValue { + /// The human-readable name of the size. + pub name: String, + /// The memory limit for each process, in bytes. + pub memory_limit: Option, + /// The memory request for each process, in bytes. + pub memory_request: Option, + /// The CPU limit for each process, in nanocpus. + pub cpu_limit: Option, + /// The CPU request for each process, in nanocpus. + pub cpu_request: Option, + /// The disk limit for each process, in bytes. + pub disk_limit: Option, + /// The number of processes in the replica. + pub scale: u16, + /// The number of worker threads per process. + pub workers: u64, + /// The number of credits per hour that the replica consumes. + pub credits_per_hour: String, + /// Whether each process has exclusive access to its CPU cores. + pub cpu_exclusive: bool, + /// Whether this size represents a modern "cc" size rather than a legacy T-shirt size. + pub is_cc: bool, + /// Whether instances of this type use swap as the spill-to-disk mechanism. + pub swap_enabled: bool, + /// Whether instances of this type can be created. + pub disabled: bool, + /// Additional node selectors. + pub selectors: std::collections::BTreeMap, + /// Whether this is a builtin size (from env var) or user-defined. + pub builtin: bool, +} + #[derive( Clone, Debug, @@ -2438,6 +2514,7 @@ pub mod audit_log_event_v1 { System = 16, ContinualTask = 17, NetworkPolicy = 18, + ClusterReplicaSize = 19, } #[derive( @@ -2514,6 +2591,7 @@ pub enum StateUpdateKind { Cluster(Cluster), ClusterIntrospectionSourceIndex(ClusterIntrospectionSourceIndex), ClusterReplica(ClusterReplica), + ClusterReplicaSize(ClusterReplicaSize), Comment(Comment), Config(Config), Database(Database), @@ -2760,6 +2838,22 @@ pub struct NetworkPolicy { pub value: NetworkPolicyValue, } +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ClusterReplicaSize { + pub key: ClusterReplicaSizeKey, + pub value: ClusterReplicaSizeValue, +} + #[derive( Clone, Debug, diff --git a/src/catalog-protos/src/objects_v82.rs b/src/catalog-protos/src/objects_v82.rs new file mode 100644 index 0000000000000..e411fda3cac2e --- /dev/null +++ b/src/catalog-protos/src/objects_v82.rs @@ -0,0 +1,3062 @@ +// 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 proptest_derive::Arbitrary; +use serde::{Deserialize, Serialize}; +use serde_repr::{Deserialize_repr, Serialize_repr}; + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ConfigKey { + pub key: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ConfigValue { + pub value: u64, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct SettingKey { + pub name: String, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct SettingValue { + pub value: String, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct IdAllocKey { + pub name: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct IdAllocValue { + pub next_id: u64, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + 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, + Arbitrary +)] +pub struct ClusterKey { + pub id: ClusterId, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + Arbitrary +)] +pub struct ClusterIntrospectionSourceIndexKey { + pub cluster_id: ClusterId, + pub name: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + Arbitrary +)] +pub struct ClusterReplicaKey { + pub id: ReplicaId, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + Arbitrary +)] +pub struct DatabaseKey { + pub id: DatabaseId, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + Arbitrary +)] +pub struct SchemaKey { + pub id: SchemaId, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + Arbitrary +)] +pub struct ItemKey { + pub gid: CatalogItemId, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ItemVersion { + pub global_id: GlobalId, + pub version: Version, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct RoleKey { + pub id: RoleId, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + Arbitrary +)] +pub struct RoleAuthKey { + pub id: RoleId, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct RoleAuthValue { + pub password_hash: Option, + pub updated_at: EpochMillis, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct NetworkPolicyKey { + pub id: NetworkPolicyId, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + Arbitrary +)] +pub struct ClusterReplicaSizeKey { + pub id: ClusterReplicaSizeId, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum ClusterReplicaSizeId { + System(u64), + User(u64), +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ClusterReplicaSizeValue { + /// The human-readable name of the size. + pub name: String, + /// The memory limit for each process, in bytes. + pub memory_limit: Option, + /// The memory request for each process, in bytes. + pub memory_request: Option, + /// The CPU limit for each process, in nanocpus. + pub cpu_limit: Option, + /// The CPU request for each process, in nanocpus. + pub cpu_request: Option, + /// The disk limit for each process, in bytes. + pub disk_limit: Option, + /// The number of processes in the replica. + pub scale: u16, + /// The number of worker threads per process. + pub workers: u64, + /// The number of credits per hour that the replica consumes. + pub credits_per_hour: String, + /// Whether each process has exclusive access to its CPU cores. + pub cpu_exclusive: bool, + /// Whether this size represents a modern "cc" size rather than a legacy T-shirt size. + pub is_cc: bool, + /// Whether instances of this type use swap as the spill-to-disk mechanism. + pub swap_enabled: bool, + /// Whether instances of this type can be created. + pub disabled: bool, + /// Additional node selectors. + pub selectors: std::collections::BTreeMap, + /// Whether this is a builtin size (from env var) or user-defined. + pub builtin: bool, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ServerConfigurationKey { + pub name: String, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ServerConfigurationValue { + pub value: String, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct AuditLogKey { + pub event: AuditLogEvent, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum AuditLogEvent { + V1(AuditLogEventV1), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct CommentKey { + pub object: CommentObject, + pub sub_component: Option, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum CommentObject { + Table(CatalogItemId), + View(CatalogItemId), + MaterializedView(CatalogItemId), + Source(CatalogItemId), + Sink(CatalogItemId), + Index(CatalogItemId), + Func(CatalogItemId), + Connection(CatalogItemId), + Type(CatalogItemId), + Secret(CatalogItemId), + ContinualTask(CatalogItemId), + Role(RoleId), + Database(DatabaseId), + Schema(ResolvedSchema), + Cluster(ClusterId), + ClusterReplica(ClusterReplicaId), + NetworkPolicy(NetworkPolicyId), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum CommentSubComponent { + ColumnPos(u64), +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct CommentValue { + pub comment: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct SourceReferencesKey { + pub source: CatalogItemId, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct SourceReferencesValue { + pub references: Vec, + pub updated_at: EpochMillis, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct SourceReference { + pub name: String, + pub namespace: Option, + pub columns: Vec, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct StorageCollectionMetadataKey { + pub id: GlobalId, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct StorageCollectionMetadataValue { + pub shard: String, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct UnfinalizedShardKey { + pub shard: String, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct TxnWalShardValue { + pub shard: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct Empty {} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct StringWrapper { + pub inner: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct Duration { + pub secs: u64, + pub nanos: u32, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct EpochMillis { + pub millis: u64, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct Version { + pub value: u64, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum CatalogItem { + V1(CatalogItemV1), +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct CatalogItemV1 { + pub create_sql: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum CatalogItemId { + System(u64), + User(u64), + Transient(u64), + IntrospectionSourceIndex(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct SystemCatalogItemId(pub u64); + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct IntrospectionSourceIndexCatalogItemId(pub u64); + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum GlobalId { + System(u64), + User(u64), + Transient(u64), + Explain, + IntrospectionSourceIndex(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct SystemGlobalId(pub u64); + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct IntrospectionSourceIndexGlobalId(pub u64); + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum ClusterId { + System(u64), + User(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum DatabaseId { + System(u64), + User(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum ResolvedDatabaseSpecifier { + Ambient, + Id(DatabaseId), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum SchemaId { + System(u64), + User(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum SchemaSpecifier { + Temporary, + Id(SchemaId), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ResolvedSchema { + pub database: ResolvedDatabaseSpecifier, + pub schema: SchemaSpecifier, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum ReplicaId { + System(u64), + User(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ClusterReplicaId { + pub cluster_id: ClusterId, + pub replica_id: ReplicaId, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum NetworkPolicyId { + System(u64), + User(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ReplicaLogging { + pub log_logging: bool, + pub interval: Option, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct OptimizerFeatureOverride { + pub name: String, + pub value: String, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ClusterScheduleRefreshOptions { + pub rehydration_time_estimate: Duration, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum ClusterSchedule { + Manual, + Refresh(ClusterScheduleRefreshOptions), +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ClusterConfig { + pub workload_class: Option, + pub variant: ClusterVariant, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum ClusterVariant { + Unmanaged, + Managed(ManagedCluster), +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ManagedCluster { + pub size: String, + pub replication_factor: u32, + pub availability_zones: Vec, + pub logging: ReplicaLogging, + pub optimizer_feature_overrides: Vec, + pub schedule: ClusterSchedule, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ReplicaConfig { + pub logging: ReplicaLogging, + pub location: ReplicaLocation, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct UnmanagedLocation { + pub storagectl_addrs: Vec, + pub computectl_addrs: Vec, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ManagedLocation { + pub size: String, + pub availability_zone: Option, + pub internal: bool, + pub billed_as: Option, + pub pending: bool, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum ReplicaLocation { + Unmanaged(UnmanagedLocation), + Managed(ManagedLocation), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum RoleId { + System(u64), + User(u64), + Public, + Predefined(u64), +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum AutoProvisionSource { + Oidc = 0, + Frontegg = 1, + None = 2, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + Arbitrary +)] +pub struct RoleMembership { + pub map: Vec, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct RoleMembershipEntry { + pub key: RoleId, + pub value: RoleId, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct RoleVars { + pub entries: Vec, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct RoleVarsEntry { + pub key: String, + pub val: RoleVar, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum RoleVar { + Flat(String), + SqlSet(Vec), +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + Arbitrary +)] +pub enum NetworkPolicyRuleAction { + Allow, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub enum NetworkPolicyRuleDirection { + Ingress, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct AclMode { + pub bitflags: u64, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct MzAclItem { + pub grantee: RoleId, + pub grantor: RoleId, + pub acl_mode: AclMode, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + Arbitrary +)] +pub struct DefaultPrivilegesValue { + pub privileges: AclMode, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct SystemPrivilegesKey { + pub grantee: RoleId, + pub grantor: RoleId, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct SystemPrivilegesValue { + pub acl_mode: AclMode, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + Arbitrary + )] + pub struct IdFullNameV1 { + pub id: String, + pub name: FullNameV1, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary + )] + pub struct FullNameV1 { + pub database: String, + pub schema: String, + pub item: String, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary + )] + pub struct IdNameV1 { + pub id: String, + pub name: String, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary + )] + pub struct RenameClusterV1 { + pub id: String, + pub old_name: String, + pub new_name: String, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + Arbitrary + )] + pub struct RenameItemV1 { + pub id: String, + pub old_name: FullNameV1, + pub new_name: FullNameV1, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + Arbitrary + )] + pub struct CreateOrDropClusterReplicaReasonV1 { + pub reason: CreateOrDropClusterReplicaReasonV1Reason, + } + + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary + )] + pub enum CreateOrDropClusterReplicaReasonV1Reason { + Manual(Empty), + Schedule(Empty), + System(Empty), + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary + )] + pub struct SchedulingDecisionsWithReasonsV1 { + pub on_refresh: RefreshDecisionWithReasonV1, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary + )] + pub struct SchedulingDecisionsWithReasonsV2 { + pub on_refresh: RefreshDecisionWithReasonV2, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary + )] + pub enum RefreshDecision { + On(Empty), + Off(Empty), + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + 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, + Arbitrary + )] + pub struct CreateSourceSinkV1 { + pub id: String, + pub name: FullNameV1, + pub size: Option, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + Arbitrary + )] + pub struct CreateSourceSinkV3 { + pub id: String, + pub name: FullNameV1, + pub external_type: String, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + Arbitrary + )] + pub struct CreateIndexV1 { + pub id: String, + pub cluster_id: String, + pub name: FullNameV1, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + Arbitrary + )] + pub struct AlterApplyReplacementV1 { + pub target: IdFullNameV1, + pub replacement: IdFullNameV1, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + 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, + 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, + 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, + Arbitrary + )] + pub struct RevokeRoleV1 { + pub role_id: String, + pub member_id: String, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + 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, + 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, + 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, + Arbitrary + )] + pub struct SchemaV1 { + pub id: String, + pub name: String, + pub database_name: String, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary + )] + pub struct SchemaV2 { + pub id: String, + pub name: String, + pub database_name: Option, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + Arbitrary + )] + pub struct UpdateItemV1 { + pub id: String, + pub name: FullNameV1, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary + )] + pub struct AlterRetainHistoryV1 { + pub id: String, + pub old_history: Option, + pub new_history: Option, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary + )] + pub struct ToNewIdV1 { + pub id: String, + pub new_id: String, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary + )] + pub struct FromPreviousIdV1 { + pub id: String, + pub previous_id: String, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary + )] + pub struct SetV1 { + pub name: String, + pub value: Option, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary + )] + pub struct RotateKeysV1 { + pub id: String, + pub name: String, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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, + 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, + 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, + ClusterReplicaSize = 19, + } + + #[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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), + } +} + +/// The contents of a single state update. +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + 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), + ClusterReplicaSize(ClusterReplicaSize), + 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), + Setting(Setting), + SourceReferences(SourceReferences), + StorageCollectionMetadata(StorageCollectionMetadata), + SystemPrivileges(SystemPrivileges), + TxnWalShard(TxnWalShard), + UnfinalizedShard(UnfinalizedShard), +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct AuditLog { + pub key: AuditLogKey, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct Cluster { + pub key: ClusterKey, + pub value: ClusterValue, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ClusterReplica { + pub key: ClusterReplicaKey, + pub value: ClusterReplicaValue, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct Comment { + pub key: CommentKey, + pub value: CommentValue, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct Config { + pub key: ConfigKey, + pub value: ConfigValue, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct Database { + pub key: DatabaseKey, + pub value: DatabaseValue, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct DefaultPrivileges { + pub key: DefaultPrivilegesKey, + pub value: DefaultPrivilegesValue, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct FenceToken { + pub deploy_generation: u64, + pub epoch: i64, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct IdAlloc { + pub key: IdAllocKey, + pub value: IdAllocValue, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ClusterIntrospectionSourceIndex { + pub key: ClusterIntrospectionSourceIndexKey, + pub value: ClusterIntrospectionSourceIndexValue, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct Item { + pub key: ItemKey, + pub value: ItemValue, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct Role { + pub key: RoleKey, + pub value: RoleValue, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct RoleAuth { + pub key: RoleAuthKey, + pub value: RoleAuthValue, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct NetworkPolicy { + pub key: NetworkPolicyKey, + pub value: NetworkPolicyValue, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ClusterReplicaSize { + pub key: ClusterReplicaSizeKey, + pub value: ClusterReplicaSizeValue, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct Schema { + pub key: SchemaKey, + pub value: SchemaValue, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct Setting { + pub key: SettingKey, + pub value: SettingValue, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct ServerConfiguration { + pub key: ServerConfigurationKey, + pub value: ServerConfigurationValue, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct SourceReferences { + pub key: SourceReferencesKey, + pub value: SourceReferencesValue, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct GidMapping { + pub key: GidMappingKey, + pub value: GidMappingValue, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct SystemPrivileges { + pub key: SystemPrivilegesKey, + pub value: SystemPrivilegesValue, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct StorageCollectionMetadata { + pub key: StorageCollectionMetadataKey, + pub value: StorageCollectionMetadataValue, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct UnfinalizedShard { + pub key: UnfinalizedShardKey, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Arbitrary +)] +pub struct TxnWalShard { + pub value: TxnWalShardValue, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Serialize_repr, + Deserialize_repr, + 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, + ContinualTask = 11, +} + +#[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Serialize_repr, + Deserialize_repr, + 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, + ContinualTask = 16, + NetworkPolicy = 17, +} diff --git a/src/catalog-protos/src/serialization.rs b/src/catalog-protos/src/serialization.rs index fd2bd00ed377b..cc38214f039c5 100644 --- a/src/catalog-protos/src/serialization.rs +++ b/src/catalog-protos/src/serialization.rs @@ -19,6 +19,7 @@ use mz_compute_types::config::ComputeReplicaLogging; use mz_controller_types::ReplicaId; use mz_proto::{ProtoMapEntry, ProtoType, RustType, TryFromProtoError}; use mz_repr::adt::mz_acl_item::{AclMode, MzAclItem}; +use mz_repr::cluster_replica_size_id::ClusterReplicaSizeId; use mz_repr::network_policy_id::NetworkPolicyId; use mz_repr::role_id::RoleId; use mz_repr::{CatalogItemId, GlobalId, RelationVersion}; @@ -210,6 +211,23 @@ impl RustType for NetworkPolicyId { } } +impl RustType for ClusterReplicaSizeId { + fn into_proto(&self) -> crate::objects::ClusterReplicaSizeId { + match self { + ClusterReplicaSizeId::User(id) => crate::objects::ClusterReplicaSizeId::User(*id), + ClusterReplicaSizeId::System(id) => crate::objects::ClusterReplicaSizeId::System(*id), + } + } + + fn from_proto(proto: crate::objects::ClusterReplicaSizeId) -> Result { + let id = match proto { + crate::objects::ClusterReplicaSizeId::User(id) => ClusterReplicaSizeId::User(id), + crate::objects::ClusterReplicaSizeId::System(id) => ClusterReplicaSizeId::System(id), + }; + Ok(id) + } +} + impl RustType for CatalogItemType { fn into_proto(&self) -> crate::objects::CatalogItemType { match self { diff --git a/src/catalog/src/builtin.rs b/src/catalog/src/builtin.rs index 334d31c285856..2e8d4b86b0d46 100644 --- a/src/catalog/src/builtin.rs +++ b/src/catalog/src/builtin.rs @@ -3957,6 +3957,75 @@ pub static MZ_CLUSTER_REPLICA_SIZES: LazyLock = LazyLock::new(|| B access: vec![PUBLIC_SELECT], }); +pub static MZ_CLUSTER_REPLICA_SIZE_DETAILS: LazyLock = + LazyLock::new(|| BuiltinTable { + name: "mz_cluster_replica_size_details", + schema: MZ_INTERNAL_SCHEMA, + oid: oid::TABLE_MZ_CLUSTER_REPLICA_SIZE_DETAILS_OID, + desc: RelationDesc::builder() + .with_column("size", SqlScalarType::String.nullable(false)) + .with_column("processes", SqlScalarType::UInt64.nullable(false)) + .with_column("workers", SqlScalarType::UInt64.nullable(false)) + .with_column("cpu_nano_cores", SqlScalarType::UInt64.nullable(false)) + .with_column("memory_bytes", SqlScalarType::UInt64.nullable(false)) + .with_column("disk_bytes", SqlScalarType::UInt64.nullable(true)) + .with_column( + "credits_per_hour", + SqlScalarType::Numeric { max_scale: None }.nullable(false), + ) + .with_column("cpu_exclusive", SqlScalarType::Bool.nullable(false)) + .with_column("is_cc", SqlScalarType::Bool.nullable(false)) + .with_column("swap_enabled", SqlScalarType::Bool.nullable(false)) + .with_column("disabled", SqlScalarType::Bool.nullable(false)) + .with_column("builtin", SqlScalarType::Bool.nullable(false)) + .with_column("node_selectors", SqlScalarType::Jsonb.nullable(false)) + .finish(), + column_comments: BTreeMap::from_iter([ + ("size", "The human-readable replica size name."), + ( + "processes", + "The number of processes (scale) in the replica.", + ), + ( + "workers", + "The number of Timely Dataflow workers per process.", + ), + ( + "cpu_nano_cores", + "The CPU allocation per process, in billionths of a vCPU core.", + ), + ("memory_bytes", "The RAM allocation per process, in bytes."), + ("disk_bytes", "The disk allocation per process, in bytes."), + ( + "credits_per_hour", + "The number of compute credits consumed per hour.", + ), + ( + "cpu_exclusive", + "Whether each process has exclusive access to its CPU cores.", + ), + ("is_cc", "Whether this is a modern cc-style size."), + ( + "swap_enabled", + "Whether swap is used as the spill-to-disk mechanism.", + ), + ( + "disabled", + "Whether this size is disabled and cannot be used for new replicas.", + ), + ( + "builtin", + "Whether this size is a builtin (from env var) or user-defined.", + ), + ( + "node_selectors", + "Kubernetes node selectors for scheduling, as a JSON object.", + ), + ]), + is_retained_metrics_object: false, + access: vec![PUBLIC_SELECT], + }); + pub static MZ_AUDIT_EVENTS: LazyLock = LazyLock::new(|| BuiltinTable { name: "mz_audit_events", schema: MZ_CATALOG_SCHEMA, @@ -14333,6 +14402,7 @@ pub static BUILTINS_STATIC: LazyLock>> = LazyLock::ne Builtin::Source(&MZ_CLUSTER_REPLICA_METRICS_HISTORY), Builtin::View(&MZ_CLUSTER_REPLICA_METRICS), Builtin::Table(&MZ_CLUSTER_REPLICA_SIZES), + Builtin::Table(&MZ_CLUSTER_REPLICA_SIZE_DETAILS), Builtin::Source(&MZ_CLUSTER_REPLICA_STATUS_HISTORY), Builtin::View(&MZ_CLUSTER_REPLICA_STATUSES), Builtin::MaterializedView(&MZ_INTERNAL_CLUSTER_REPLICAS), diff --git a/src/catalog/src/durable.rs b/src/catalog/src/durable.rs index fac877b89a297..0d5cbc7ecbef2 100644 --- a/src/catalog/src/durable.rs +++ b/src/catalog/src/durable.rs @@ -35,11 +35,11 @@ pub use crate::durable::objects::Snapshot; pub use crate::durable::objects::state_update::StateUpdate; use crate::durable::objects::state_update::{StateUpdateKindJson, TryIntoStateUpdateKind}; pub use crate::durable::objects::{ - Cluster, ClusterConfig, ClusterReplica, ClusterVariant, ClusterVariantManaged, Comment, - Database, DefaultPrivilege, IntrospectionSourceIndex, Item, NetworkPolicy, ReplicaConfig, - ReplicaLocation, Role, RoleAuth, Schema, SourceReference, SourceReferences, - StorageCollectionMetadata, SystemConfiguration, SystemObjectDescription, SystemObjectMapping, - UnfinalizedShard, + Cluster, ClusterConfig, ClusterReplica, ClusterReplicaSize, ClusterVariant, + ClusterVariantManaged, Comment, Database, DefaultPrivilege, IntrospectionSourceIndex, Item, + NetworkPolicy, ReplicaConfig, ReplicaLocation, Role, RoleAuth, Schema, SourceReference, + SourceReferences, StorageCollectionMetadata, SystemConfiguration, SystemObjectDescription, + SystemObjectMapping, UnfinalizedShard, }; pub use crate::durable::persist::shard_id; use crate::durable::persist::{Timestamp, UnopenedPersistCatalogState}; @@ -70,6 +70,8 @@ pub const SYSTEM_REPLICA_ID_ALLOC_KEY: &str = "system_replica"; pub const AUDIT_LOG_ID_ALLOC_KEY: &str = "auditlog"; pub const STORAGE_USAGE_ID_ALLOC_KEY: &str = "storage_usage"; pub const USER_NETWORK_POLICY_ID_ALLOC_KEY: &str = "user_network_policy"; +pub const USER_CLUSTER_REPLICA_SIZE_ID_ALLOC_KEY: &str = "user_cluster_replica_size"; +pub const SYSTEM_CLUSTER_REPLICA_SIZE_ID_ALLOC_KEY: &str = "system_cluster_replica_size"; pub const OID_ALLOC_KEY: &str = "oid"; pub(crate) const CATALOG_CONTENT_VERSION_KEY: &str = "catalog_content_version"; pub const BUILTIN_MIGRATION_SHARD_KEY: &str = "builtin_migration_shard"; diff --git a/src/catalog/src/durable/debug.rs b/src/catalog/src/durable/debug.rs index 5586053e8bc69..690e3129b24d5 100644 --- a/src/catalog/src/durable/debug.rs +++ b/src/catalog/src/durable/debug.rs @@ -57,6 +57,7 @@ pub enum CollectionType { ComputeInstance, ComputeIntrospectionSourceIndex, ComputeReplicas, + ClusterReplicaSize, Comments, Config, Database, @@ -152,6 +153,14 @@ collection_impl!({ trace_field: cluster_replicas, update: StateUpdateKind::ClusterReplica, }); +collection_impl!({ + name: ClusterReplicaSizeCollection, + key: proto::ClusterReplicaSizeKey, + value: proto::ClusterReplicaSizeValue, + collection_type: CollectionType::ClusterReplicaSize, + trace_field: cluster_replica_sizes, + update: StateUpdateKind::ClusterReplicaSize, +}); collection_impl!({ name: CommentCollection, key: proto::CommentKey, @@ -332,6 +341,7 @@ pub struct Trace { pub clusters: CollectionTrace, pub introspection_sources: CollectionTrace, pub cluster_replicas: CollectionTrace, + pub cluster_replica_sizes: CollectionTrace, pub comments: CollectionTrace, pub configs: CollectionTrace, pub databases: CollectionTrace, @@ -359,6 +369,7 @@ impl Trace { clusters: CollectionTrace::new(), introspection_sources: CollectionTrace::new(), cluster_replicas: CollectionTrace::new(), + cluster_replica_sizes: CollectionTrace::new(), comments: CollectionTrace::new(), configs: CollectionTrace::new(), databases: CollectionTrace::new(), @@ -386,6 +397,7 @@ impl Trace { clusters, introspection_sources, cluster_replicas, + cluster_replica_sizes, comments, configs, databases, @@ -409,6 +421,7 @@ impl Trace { clusters.sort(); introspection_sources.sort(); cluster_replicas.sort(); + cluster_replica_sizes.sort(); comments.sort(); configs.sort(); databases.sort(); diff --git a/src/catalog/src/durable/initialize.rs b/src/catalog/src/durable/initialize.rs index 4256bc99a9cf5..a6f4d9e2b020a 100644 --- a/src/catalog/src/durable/initialize.rs +++ b/src/catalog/src/durable/initialize.rs @@ -50,7 +50,8 @@ use crate::durable::{ ClusterVariantManaged, DATABASE_ID_ALLOC_KEY, DefaultPrivilege, EXPRESSION_CACHE_SHARD_KEY, MOCK_AUTHENTICATION_NONCE_KEY, OID_ALLOC_KEY, ReplicaConfig, ReplicaLocation, Role, SCHEMA_ID_ALLOC_KEY, STORAGE_USAGE_ID_ALLOC_KEY, SYSTEM_CLUSTER_ID_ALLOC_KEY, - SYSTEM_REPLICA_ID_ALLOC_KEY, Schema, Transaction, USER_CLUSTER_ID_ALLOC_KEY, + SYSTEM_CLUSTER_REPLICA_SIZE_ID_ALLOC_KEY, SYSTEM_REPLICA_ID_ALLOC_KEY, Schema, Transaction, + USER_CLUSTER_ID_ALLOC_KEY, USER_CLUSTER_REPLICA_SIZE_ID_ALLOC_KEY, USER_NETWORK_POLICY_ID_ALLOC_KEY, USER_REPLICA_ID_ALLOC_KEY, USER_ROLE_ID_ALLOC_KEY, }; @@ -265,6 +266,14 @@ pub(crate) async fn initialize( USER_NETWORK_POLICY_ID_ALLOC_KEY.to_string(), DEFAULT_ALLOCATOR_ID, ), + ( + USER_CLUSTER_REPLICA_SIZE_ID_ALLOC_KEY.to_string(), + DEFAULT_ALLOCATOR_ID, + ), + ( + SYSTEM_CLUSTER_REPLICA_SIZE_ID_ALLOC_KEY.to_string(), + DEFAULT_ALLOCATOR_ID, + ), (AUDIT_LOG_ID_ALLOC_KEY.to_string(), DEFAULT_ALLOCATOR_ID), (STORAGE_USAGE_ID_ALLOC_KEY.to_string(), DEFAULT_ALLOCATOR_ID), (OID_ALLOC_KEY.to_string(), FIRST_USER_OID.into()), diff --git a/src/catalog/src/durable/objects.rs b/src/catalog/src/durable/objects.rs index 656ffbfb3eefe..e604f4beded69 100644 --- a/src/catalog/src/durable/objects.rs +++ b/src/catalog/src/durable/objects.rs @@ -32,10 +32,11 @@ use std::cmp::Ordering; use std::collections::BTreeMap; use mz_audit_log::VersionedEvent; -use mz_controller::clusters::ReplicaLogging; +use mz_controller::clusters::{ReplicaAllocation, ReplicaLogging}; use mz_controller_types::{ClusterId, ReplicaId}; use mz_persist_types::ShardId; use mz_repr::adt::mz_acl_item::{AclMode, MzAclItem}; +use mz_repr::cluster_replica_size_id::ClusterReplicaSizeId; use mz_repr::network_policy_id::NetworkPolicyId; use mz_repr::role_id::RoleId; use mz_repr::{CatalogItemId, GlobalId, RelationVersion}; @@ -290,6 +291,112 @@ impl DurableType for NetworkPolicy { } } +#[derive(Debug, Clone)] +pub struct ClusterReplicaSize { + pub id: ClusterReplicaSizeId, + pub name: String, + pub allocation: ReplicaAllocation, + pub builtin: bool, +} + +// Manual impls because ReplicaAllocation contains Numeric which doesn't impl Eq/Ord. +// Identity is determined by the `id`, so we ignore `allocation` in comparisons. +// Callers needing to detect allocation changes should compare the +// ClusterReplicaSizeValue (via DurableType::into_key_value) instead. +impl PartialEq for ClusterReplicaSize { + fn eq(&self, other: &Self) -> bool { + self.id == other.id && self.name == other.name && self.builtin == other.builtin + } +} + +impl Eq for ClusterReplicaSize {} + +impl PartialOrd for ClusterReplicaSize { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} + +impl Ord for ClusterReplicaSize { + fn cmp(&self, other: &Self) -> Ordering { + (&self.id, &self.name, &self.builtin).cmp(&(&other.id, &other.name, &other.builtin)) + } +} + +impl DurableType for ClusterReplicaSize { + type Key = ClusterReplicaSizeKey; + type Value = ClusterReplicaSizeValue; + + fn into_key_value(self) -> (Self::Key, Self::Value) { + use mz_ore::cast::CastFrom; + ( + ClusterReplicaSizeKey { id: self.id }, + ClusterReplicaSizeValue { + name: self.name, + memory_limit: self.allocation.memory_limit.map(|m| (m.0).0), + memory_request: self.allocation.memory_request.map(|m| (m.0).0), + cpu_limit: self.allocation.cpu_limit.map(|c| c.as_nanocpus()), + cpu_request: self.allocation.cpu_request.map(|c| c.as_nanocpus()), + disk_limit: self.allocation.disk_limit.map(|d| (d.0).0), + scale: self.allocation.scale.get(), + workers: u64::cast_from(self.allocation.workers.get()), + credits_per_hour: self.allocation.credits_per_hour.to_string(), + cpu_exclusive: self.allocation.cpu_exclusive, + is_cc: self.allocation.is_cc, + swap_enabled: self.allocation.swap_enabled, + disabled: self.allocation.disabled, + selectors: self.allocation.selectors.clone(), + builtin: self.builtin, + }, + ) + } + + fn from_key_value(key: Self::Key, value: Self::Value) -> Self { + use std::num::NonZero; + + use mz_orchestrator::{CpuLimit, DiskLimit, MemoryLimit}; + use mz_ore::cast::CastFrom; + use mz_repr::adt::numeric::Numeric; + + Self { + id: key.id, + name: value.name, + allocation: ReplicaAllocation { + memory_limit: value + .memory_limit + .map(|b| MemoryLimit(bytesize::ByteSize(b))), + memory_request: value + .memory_request + .map(|b| MemoryLimit(bytesize::ByteSize(b))), + cpu_limit: value + .cpu_limit + .map(|n| CpuLimit::from_millicpus(usize::cast_from(n / 1_000_000))), + cpu_request: value + .cpu_request + .map(|n| CpuLimit::from_millicpus(usize::cast_from(n / 1_000_000))), + disk_limit: value.disk_limit.map(|b| DiskLimit(bytesize::ByteSize(b))), + scale: NonZero::new(value.scale).expect("scale must be non-zero"), + workers: NonZero::new(usize::cast_from(value.workers)) + .expect("workers must be non-zero"), + credits_per_hour: value + .credits_per_hour + .parse::() + .expect("invalid credits_per_hour"), + cpu_exclusive: value.cpu_exclusive, + is_cc: value.is_cc, + swap_enabled: value.swap_enabled, + disabled: value.disabled, + selectors: value.selectors, + }, + builtin: value.builtin, + } + } + + fn key(&self) -> Self::Key { + ClusterReplicaSizeKey { id: self.id } + } +} + #[derive(Debug, Clone, Ord, PartialOrd, PartialEq, Eq)] pub struct Cluster { pub id: ClusterId, @@ -1142,6 +1249,8 @@ pub struct Snapshot { pub comments: BTreeMap, pub clusters: BTreeMap, pub network_policies: BTreeMap, + pub cluster_replica_sizes: + BTreeMap, pub cluster_replicas: BTreeMap, pub introspection_sources: BTreeMap< proto::ClusterIntrospectionSourceIndexKey, @@ -1400,6 +1509,33 @@ pub struct NetworkPolicyValue { pub(crate) oid: u32, } +#[derive(Clone, Copy, PartialOrd, PartialEq, Eq, Ord, Hash, Debug)] +pub struct ClusterReplicaSizeKey { + pub(crate) id: ClusterReplicaSizeId, +} + +/// Internal durable representation of a cluster replica size value. +/// Uses proto-compatible types (no `Numeric`) so it can implement `Eq`/`Ord`. +/// Conversion to `ReplicaAllocation` happens via `DurableType::from_key_value`. +#[derive(Clone, PartialOrd, PartialEq, Eq, Ord, Debug)] +pub struct ClusterReplicaSizeValue { + pub(crate) name: String, + pub(crate) memory_limit: Option, + pub(crate) memory_request: Option, + pub(crate) cpu_limit: Option, + pub(crate) cpu_request: Option, + pub(crate) disk_limit: Option, + pub(crate) scale: u16, + pub(crate) workers: u64, + pub(crate) credits_per_hour: String, + pub(crate) cpu_exclusive: bool, + pub(crate) is_cc: bool, + pub(crate) swap_enabled: bool, + pub(crate) disabled: bool, + pub(crate) selectors: BTreeMap, + pub(crate) builtin: bool, +} + #[derive(Debug, Clone, PartialOrd, PartialEq, Eq, Ord)] pub struct ConfigKey { pub(crate) key: String, diff --git a/src/catalog/src/durable/objects/serialization.rs b/src/catalog/src/durable/objects/serialization.rs index 28a164509d6d3..c7983748ae357 100644 --- a/src/catalog/src/durable/objects/serialization.rs +++ b/src/catalog/src/durable/objects/serialization.rs @@ -15,15 +15,16 @@ use mz_proto::{ProtoType, RustType, TryFromProtoError}; use crate::durable::objects::state_update::StateUpdateKindJson; use crate::durable::objects::{ AuditLogKey, ClusterIntrospectionSourceIndexKey, ClusterIntrospectionSourceIndexValue, - ClusterKey, ClusterReplicaKey, ClusterReplicaValue, ClusterValue, CommentKey, CommentValue, - ConfigKey, ConfigValue, DatabaseKey, DatabaseValue, DefaultPrivilegesKey, - DefaultPrivilegesValue, GidMappingKey, GidMappingValue, IdAllocKey, IdAllocValue, - IntrospectionSourceIndexCatalogItemId, IntrospectionSourceIndexGlobalId, ItemKey, ItemValue, - NetworkPolicyKey, NetworkPolicyValue, RoleKey, RoleValue, SchemaKey, SchemaValue, - ServerConfigurationKey, ServerConfigurationValue, SettingKey, SettingValue, SourceReference, - SourceReferencesKey, SourceReferencesValue, StorageCollectionMetadataKey, - StorageCollectionMetadataValue, SystemCatalogItemId, SystemGlobalId, SystemPrivilegesKey, - SystemPrivilegesValue, TxnWalShardValue, UnfinalizedShardKey, + ClusterKey, ClusterReplicaKey, ClusterReplicaSizeKey, ClusterReplicaSizeValue, + ClusterReplicaValue, ClusterValue, CommentKey, CommentValue, ConfigKey, ConfigValue, + DatabaseKey, DatabaseValue, DefaultPrivilegesKey, DefaultPrivilegesValue, GidMappingKey, + GidMappingValue, IdAllocKey, IdAllocValue, IntrospectionSourceIndexCatalogItemId, + IntrospectionSourceIndexGlobalId, ItemKey, ItemValue, NetworkPolicyKey, NetworkPolicyValue, + RoleKey, RoleValue, SchemaKey, SchemaValue, ServerConfigurationKey, ServerConfigurationValue, + SettingKey, SettingValue, SourceReference, SourceReferencesKey, SourceReferencesValue, + StorageCollectionMetadataKey, StorageCollectionMetadataValue, SystemCatalogItemId, + SystemGlobalId, SystemPrivilegesKey, SystemPrivilegesValue, TxnWalShardValue, + UnfinalizedShardKey, }; use crate::durable::{ ClusterConfig, ClusterVariant, ClusterVariantManaged, ReplicaConfig, ReplicaLocation, @@ -633,6 +634,62 @@ impl RustType for NetworkPolicyValue { } } +impl RustType for ClusterReplicaSizeKey { + fn into_proto(&self) -> proto::ClusterReplicaSizeKey { + proto::ClusterReplicaSizeKey { + id: self.id.into_proto(), + } + } + + fn from_proto(proto: proto::ClusterReplicaSizeKey) -> Result { + Ok(ClusterReplicaSizeKey { + id: proto.id.into_rust()?, + }) + } +} + +impl RustType for ClusterReplicaSizeValue { + fn into_proto(&self) -> proto::ClusterReplicaSizeValue { + proto::ClusterReplicaSizeValue { + name: self.name.clone(), + memory_limit: self.memory_limit, + memory_request: self.memory_request, + cpu_limit: self.cpu_limit, + cpu_request: self.cpu_request, + disk_limit: self.disk_limit, + scale: self.scale, + workers: self.workers, + credits_per_hour: self.credits_per_hour.clone(), + cpu_exclusive: self.cpu_exclusive, + is_cc: self.is_cc, + swap_enabled: self.swap_enabled, + disabled: self.disabled, + selectors: self.selectors.clone(), + builtin: self.builtin, + } + } + + fn from_proto(proto: proto::ClusterReplicaSizeValue) -> Result { + Ok(ClusterReplicaSizeValue { + name: proto.name, + memory_limit: proto.memory_limit, + memory_request: proto.memory_request, + cpu_limit: proto.cpu_limit, + cpu_request: proto.cpu_request, + disk_limit: proto.disk_limit, + scale: proto.scale, + workers: proto.workers, + credits_per_hour: proto.credits_per_hour, + cpu_exclusive: proto.cpu_exclusive, + is_cc: proto.is_cc, + swap_enabled: proto.swap_enabled, + disabled: proto.disabled, + selectors: proto.selectors, + builtin: proto.builtin, + }) + } +} + impl RustType for ConfigKey { fn into_proto(&self) -> proto::ConfigKey { proto::ConfigKey { diff --git a/src/catalog/src/durable/objects/state_update.rs b/src/catalog/src/durable/objects/state_update.rs index 4039c61d3d52e..797a0f9d864dd 100644 --- a/src/catalog/src/durable/objects/state_update.rs +++ b/src/catalog/src/durable/objects/state_update.rs @@ -141,6 +141,7 @@ impl StateUpdate { clusters, cluster_replicas, network_policies, + cluster_replica_sizes, introspection_sources, id_allocator, configs, @@ -165,6 +166,8 @@ impl StateUpdate { let clusters = from_batch(clusters, StateUpdateKind::Cluster); let cluster_replicas = from_batch(cluster_replicas, StateUpdateKind::ClusterReplica); let network_policies = from_batch(network_policies, StateUpdateKind::NetworkPolicy); + let cluster_replica_sizes = + from_batch(cluster_replica_sizes, StateUpdateKind::ClusterReplicaSize); let introspection_sources = from_batch( introspection_sources, StateUpdateKind::IntrospectionSourceIndex, @@ -196,6 +199,7 @@ impl StateUpdate { .chain(clusters) .chain(cluster_replicas) .chain(network_policies) + .chain(cluster_replica_sizes) .chain(introspection_sources) .chain(id_allocators) .chain(configs) @@ -221,6 +225,7 @@ pub enum StateUpdateKind { AuditLog(proto::AuditLogKey, ()), Cluster(proto::ClusterKey, proto::ClusterValue), ClusterReplica(proto::ClusterReplicaKey, proto::ClusterReplicaValue), + ClusterReplicaSize(proto::ClusterReplicaSizeKey, proto::ClusterReplicaSizeValue), Comment(proto::CommentKey, proto::CommentValue), Config(proto::ConfigKey, proto::ConfigValue), Database(proto::DatabaseKey, proto::DatabaseValue), @@ -258,6 +263,7 @@ impl StateUpdateKind { StateUpdateKind::AuditLog(_, _) => Some(CollectionType::AuditLog), StateUpdateKind::Cluster(_, _) => Some(CollectionType::ComputeInstance), StateUpdateKind::ClusterReplica(_, _) => Some(CollectionType::ComputeReplicas), + StateUpdateKind::ClusterReplicaSize(_, _) => Some(CollectionType::ClusterReplicaSize), StateUpdateKind::Comment(_, _) => Some(CollectionType::Comments), StateUpdateKind::Config(_, _) => Some(CollectionType::Config), StateUpdateKind::Database(_, _) => Some(CollectionType::Database), @@ -496,6 +502,10 @@ impl TryFrom<&StateUpdateKind> for Option { let policy = into_durable(key, value)?; Some(memory::objects::StateUpdateKind::NetworkPolicy(policy)) } + StateUpdateKind::ClusterReplicaSize(key, value) => { + let size = into_durable(key, value)?; + Some(memory::objects::StateUpdateKind::ClusterReplicaSize(size)) + } StateUpdateKind::Role(key, value) => { let role = into_durable(key, value)?; Some(memory::objects::StateUpdateKind::Role(role)) @@ -643,6 +653,9 @@ impl RustType for StateUpdateKind { StateUpdateKind::NetworkPolicy(key, value) => { proto::StateUpdateKind::NetworkPolicy(proto::NetworkPolicy { key, value }) } + StateUpdateKind::ClusterReplicaSize(key, value) => { + proto::StateUpdateKind::ClusterReplicaSize(proto::ClusterReplicaSize { key, value }) + } StateUpdateKind::Role(key, value) => { proto::StateUpdateKind::Role(proto::Role { key, value }) } @@ -762,6 +775,10 @@ impl RustType for StateUpdateKind { proto::StateUpdateKind::NetworkPolicy(proto::NetworkPolicy { key, value }) => { StateUpdateKind::NetworkPolicy(key, value) } + proto::StateUpdateKind::ClusterReplicaSize(proto::ClusterReplicaSize { + key, + value, + }) => StateUpdateKind::ClusterReplicaSize(key, value), }) } } diff --git a/src/catalog/src/durable/persist.rs b/src/catalog/src/durable/persist.rs index caceeaa3be47f..ec896f55a9a7f 100644 --- a/src/catalog/src/durable/persist.rs +++ b/src/catalog/src/durable/persist.rs @@ -754,6 +754,9 @@ impl> PersistHandle { StateUpdateKind::ClusterReplica(key, value) => { apply(&mut snapshot.cluster_replicas, key, value, diff); } + StateUpdateKind::ClusterReplicaSize(key, value) => { + apply(&mut snapshot.cluster_replica_sizes, key, value, diff); + } StateUpdateKind::Comment(key, value) => { apply(&mut snapshot.comments, key, value, diff); } @@ -1959,6 +1962,9 @@ impl Trace { StateUpdateKind::ClusterReplica(k, v) => { trace.cluster_replicas.values.push(((k, v), ts, diff)) } + StateUpdateKind::ClusterReplicaSize(k, v) => { + trace.cluster_replica_sizes.values.push(((k, v), ts, diff)) + } StateUpdateKind::Comment(k, v) => trace.comments.values.push(((k, v), ts, diff)), StateUpdateKind::Config(k, v) => trace.configs.values.push(((k, v), ts, diff)), StateUpdateKind::Database(k, v) => trace.databases.values.push(((k, v), ts, diff)), diff --git a/src/catalog/src/durable/transaction.rs b/src/catalog/src/durable/transaction.rs index 537837b5e7788..306a269ff0419 100644 --- a/src/catalog/src/durable/transaction.rs +++ b/src/catalog/src/durable/transaction.rs @@ -50,11 +50,11 @@ use crate::durable::objects::serialization::proto; use crate::durable::objects::{ AuditLogKey, Cluster, ClusterConfig, ClusterIntrospectionSourceIndexKey, ClusterIntrospectionSourceIndexValue, ClusterKey, ClusterReplica, ClusterReplicaKey, - ClusterReplicaValue, ClusterValue, CommentKey, CommentValue, Config, ConfigKey, ConfigValue, - Database, DatabaseKey, DatabaseValue, DefaultPrivilegesKey, DefaultPrivilegesValue, - DurableType, GidMappingKey, GidMappingValue, IdAllocKey, IdAllocValue, - IntrospectionSourceIndex, Item, ItemKey, ItemValue, NetworkPolicyKey, NetworkPolicyValue, - ReplicaConfig, Role, RoleKey, RoleValue, Schema, SchemaKey, SchemaValue, + ClusterReplicaSizeKey, ClusterReplicaSizeValue, ClusterReplicaValue, ClusterValue, CommentKey, + CommentValue, Config, ConfigKey, ConfigValue, Database, DatabaseKey, DatabaseValue, + DefaultPrivilegesKey, DefaultPrivilegesValue, DurableType, GidMappingKey, GidMappingValue, + IdAllocKey, IdAllocValue, IntrospectionSourceIndex, Item, ItemKey, ItemValue, NetworkPolicyKey, + NetworkPolicyValue, ReplicaConfig, Role, RoleKey, RoleValue, Schema, SchemaKey, SchemaValue, ServerConfigurationKey, ServerConfigurationValue, SettingKey, SettingValue, SourceReference, SourceReferencesKey, SourceReferencesValue, StorageCollectionMetadataKey, StorageCollectionMetadataValue, SystemObjectDescription, SystemObjectMapping, @@ -65,9 +65,9 @@ use crate::durable::{ DATABASE_ID_ALLOC_KEY, DefaultPrivilege, DurableCatalogError, DurableCatalogState, EXPRESSION_CACHE_SHARD_KEY, MOCK_AUTHENTICATION_NONCE_KEY, NetworkPolicy, OID_ALLOC_KEY, SCHEMA_ID_ALLOC_KEY, STORAGE_USAGE_ID_ALLOC_KEY, SYSTEM_CLUSTER_ID_ALLOC_KEY, - SYSTEM_ITEM_ALLOC_KEY, SYSTEM_REPLICA_ID_ALLOC_KEY, Snapshot, SystemConfiguration, - USER_ITEM_ALLOC_KEY, USER_NETWORK_POLICY_ID_ALLOC_KEY, USER_REPLICA_ID_ALLOC_KEY, - USER_ROLE_ID_ALLOC_KEY, + SYSTEM_CLUSTER_REPLICA_SIZE_ID_ALLOC_KEY, SYSTEM_ITEM_ALLOC_KEY, SYSTEM_REPLICA_ID_ALLOC_KEY, + Snapshot, SystemConfiguration, USER_CLUSTER_REPLICA_SIZE_ID_ALLOC_KEY, USER_ITEM_ALLOC_KEY, + USER_NETWORK_POLICY_ID_ALLOC_KEY, USER_REPLICA_ID_ALLOC_KEY, USER_ROLE_ID_ALLOC_KEY, }; use crate::memory::objects::{StateDiff, StateUpdate, StateUpdateKind}; @@ -100,6 +100,7 @@ pub struct Transaction<'a> { source_references: TableTransaction, system_privileges: TableTransaction, network_policies: TableTransaction, + cluster_replica_sizes: TableTransaction, storage_collection_metadata: TableTransaction, unfinalized_shards: TableTransaction, @@ -125,6 +126,7 @@ impl<'a> Transaction<'a> { comments, clusters, network_policies, + cluster_replica_sizes, cluster_replicas, introspection_sources, id_allocator, @@ -172,6 +174,10 @@ impl<'a> Transaction<'a> { network_policies, |a: &NetworkPolicyValue, b| a.name == b.name, )?, + cluster_replica_sizes: TableTransaction::new_with_uniqueness_fn( + cluster_replica_sizes, + |a: &ClusterReplicaSizeValue, b| a.name == b.name, + )?, cluster_replicas: TableTransaction::new_with_uniqueness_fn( cluster_replicas, |a: &ClusterReplicaValue, b| a.cluster_id == b.cluster_id && a.name == b.name, @@ -1041,6 +1047,7 @@ impl<'a> Transaction<'a> { comments: self.comments.current_items_proto(), clusters: self.clusters.current_items_proto(), network_policies: self.network_policies.current_items_proto(), + cluster_replica_sizes: self.cluster_replica_sizes.current_items_proto(), cluster_replicas: self.cluster_replicas.current_items_proto(), introspection_sources: self.introspection_sources.current_items_proto(), id_allocator: self.id_allocator.current_items_proto(), @@ -2205,6 +2212,68 @@ impl<'a> Transaction<'a> { .map(|(k, v)| DurableType::from_key_value(k.clone(), v.clone())) } + pub fn get_cluster_replica_sizes( + &self, + ) -> impl Iterator + use<'_> { + self.cluster_replica_sizes + .items() + .into_iter() + .map(|(k, v)| DurableType::from_key_value(k.clone(), v.clone())) + } + + /// Insert a new cluster replica size, allocating a fresh ID from either the + /// user or system allocator depending on the `builtin` flag. + pub fn insert_cluster_replica_size( + &mut self, + name: String, + allocation: mz_controller::clusters::ReplicaAllocation, + builtin: bool, + ) -> Result { + use mz_repr::cluster_replica_size_id::ClusterReplicaSizeId; + let raw_id = if builtin { + self.get_and_increment_id(SYSTEM_CLUSTER_REPLICA_SIZE_ID_ALLOC_KEY.to_string())? + } else { + self.get_and_increment_id(USER_CLUSTER_REPLICA_SIZE_ID_ALLOC_KEY.to_string())? + }; + let id = if builtin { + ClusterReplicaSizeId::System(raw_id) + } else { + ClusterReplicaSizeId::User(raw_id) + }; + let size = super::ClusterReplicaSize { + id, + name: name.clone(), + allocation, + builtin, + }; + let (key, value) = DurableType::into_key_value(size); + match self.cluster_replica_sizes.insert(key, value, self.op_id) { + Ok(_) => Ok(id), + Err(_) => Err(SqlCatalogError::ClusterReplicaSizeAlreadyExists(name).into()), + } + } + + /// Remove a cluster replica size by name. + pub fn remove_cluster_replica_size(&mut self, name: &str) -> Result<(), CatalogError> { + // Since the key is the ID, we must look up the ID from the name first. + let id = self + .cluster_replica_sizes + .items() + .into_iter() + .find(|(_, v)| v.name == name) + .map(|(k, _)| k.id); + let Some(id) = id else { + return Err(SqlCatalogError::UnknownClusterReplicaSize(name.to_string()).into()); + }; + let key = ClusterReplicaSizeKey { id }; + let prev = self.cluster_replica_sizes.delete_by_key(key, self.op_id); + if prev.is_none() { + Err(SqlCatalogError::UnknownClusterReplicaSize(name.to_string()).into()) + } else { + Ok(()) + } + } + pub fn get_system_object_mappings( &self, ) -> impl Iterator + use<'_> { @@ -2336,6 +2405,7 @@ impl<'a> Transaction<'a> { role_auth, clusters, network_policies, + cluster_replica_sizes, cluster_replicas, introspection_sources, system_gid_mapping, @@ -2401,6 +2471,11 @@ impl<'a> Transaction<'a> { StateUpdateKind::NetworkPolicy, self.op_id, )) + .chain(get_collection_op_updates( + cluster_replica_sizes, + StateUpdateKind::ClusterReplicaSize, + self.op_id, + )) .chain(get_collection_op_updates( introspection_sources, StateUpdateKind::IntrospectionSourceIndex, @@ -2489,6 +2564,7 @@ impl<'a> Transaction<'a> { clusters: self.clusters.pending(), cluster_replicas: self.cluster_replicas.pending(), network_policies: self.network_policies.pending(), + cluster_replica_sizes: self.cluster_replica_sizes.pending(), introspection_sources: self.introspection_sources.pending(), id_allocator: self.id_allocator.pending(), configs: self.configs.pending(), @@ -2534,6 +2610,7 @@ impl<'a> Transaction<'a> { clusters, cluster_replicas, network_policies, + cluster_replica_sizes, introspection_sources, id_allocator, configs, @@ -2560,6 +2637,7 @@ impl<'a> Transaction<'a> { differential_dataflow::consolidation::consolidate_updates(clusters); differential_dataflow::consolidation::consolidate_updates(cluster_replicas); differential_dataflow::consolidation::consolidate_updates(network_policies); + differential_dataflow::consolidation::consolidate_updates(cluster_replica_sizes); differential_dataflow::consolidation::consolidate_updates(introspection_sources); differential_dataflow::consolidation::consolidate_updates(id_allocator); differential_dataflow::consolidation::consolidate_updates(configs); @@ -2747,6 +2825,11 @@ pub struct TransactionBatch { pub(crate) clusters: Vec<(proto::ClusterKey, proto::ClusterValue, Diff)>, pub(crate) cluster_replicas: Vec<(proto::ClusterReplicaKey, proto::ClusterReplicaValue, Diff)>, pub(crate) network_policies: Vec<(proto::NetworkPolicyKey, proto::NetworkPolicyValue, Diff)>, + pub(crate) cluster_replica_sizes: Vec<( + proto::ClusterReplicaSizeKey, + proto::ClusterReplicaSizeValue, + Diff, + )>, pub(crate) introspection_sources: Vec<( proto::ClusterIntrospectionSourceIndexKey, proto::ClusterIntrospectionSourceIndexValue, @@ -2800,6 +2883,7 @@ impl TransactionBatch { clusters, cluster_replicas, network_policies, + cluster_replica_sizes, introspection_sources, id_allocator, configs, @@ -2824,6 +2908,7 @@ impl TransactionBatch { && clusters.is_empty() && cluster_replicas.is_empty() && network_policies.is_empty() + && cluster_replica_sizes.is_empty() && introspection_sources.is_empty() && id_allocator.is_empty() && configs.is_empty() @@ -2886,6 +2971,7 @@ mod unique_name { } impl_unique_name! { + ClusterReplicaSizeValue, ClusterReplicaValue, ClusterValue, DatabaseValue, diff --git a/src/catalog/src/durable/upgrade.rs b/src/catalog/src/durable/upgrade.rs index 18471d0710338..016d4a7108644 100644 --- a/src/catalog/src/durable/upgrade.rs +++ b/src/catalog/src/durable/upgrade.rs @@ -240,7 +240,7 @@ macro_rules! objects { } } -objects!([v74, v75, v76, v77, v78], [v79, v80, v81]); +objects!([v74, v75, v76, v77, v78], [v79, v80, v81, v82]); /// The current version of the `Catalog`. pub use mz_catalog_protos::CATALOG_VERSION; @@ -259,6 +259,7 @@ mod v77_to_v78; mod v78_to_v79; mod v79_to_v80; mod v80_to_v81; +mod v81_to_v82; /// Describes a single action to take during a migration from `V1` to `V2`. #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] @@ -404,6 +405,15 @@ async fn run_upgrade( ) .await } + 81 => { + run_versioned_upgrade( + unopened_catalog_state, + version, + commit_ts, + v81_to_v82::upgrade, + ) + .await + } // Up-to-date, no migration needed! CATALOG_VERSION => Ok((CATALOG_VERSION, commit_ts)), diff --git a/src/catalog/src/durable/upgrade/snapshots/objects_v82.txt b/src/catalog/src/durable/upgrade/snapshots/objects_v82.txt new file mode 100644 index 0000000000000..87a3b703072a5 --- /dev/null +++ b/src/catalog/src/durable/upgrade/snapshots/objects_v82.txt @@ -0,0 +1,100 @@ +CmoKaLoBZQpHCgNrZXkSQLoBPQo7CgVzaGFyZBIyQjDvv70iICrgu4Ik8JCSoSfgu4l7yLps2bLhqpTwkKO0VNGo4aqYIvCRsoMia0fgt48KGgoEa2luZBISQhBVbmZpbmFsaXplZFNoYXJk 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 +CmgKZroBYwoVCgRraW5kEg1CC1R4bldhbFNoYXJkCkoKBXZhbHVlEkG6AT4KPAoFc2hhcmQSM0IxIuCsqvCRvrBNXzonODtDJjw8RvCdqqbvv73wnZKf8JCEgPCRiopc8J+dn1Un8JGZog== +CphWCpVWugGRVgowCgNrZXkSKboBJgokCgJpZBIeugEbChkKBlN5c3RlbRIPwgEMCgqIFUFAdUOJJXNcChAKBGtpbmQSCEIGU2NoZW1hCspVCgV2YWx1ZRLAVboBvFUKLAoLZGF0YWJhc2VfaWQSHboBGgoYCgRVc2VyEhDCAQ0KCwESgyBIdHgUhVA8ChUKBG5hbWUSDUILLjwl8J+VtPCQjLgKEgoDb2lkEgvCAQgKBgMWcRkCXAoqCghvd25lcl9pZBIeugEbChkKBlN5c3RlbRIPwgEMCgpHMjkHVhFSI1VsCrRUCgpwcml2aWxlZ2VzEqVUsgGhVAqSAboBjgEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBNmZElhMyhHY2XAotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgqJYWIoEzglhUh8Ci4KB2dyYW50b3ISI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwFlGZEmAVQmeZiMCnG6AW4KLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgp5hxAIVJBRmAhsChMKB2dyYW50ZWUSCEIGUHVibGljCikKB2dyYW50b3ISHroBGwoZCgZTeXN0ZW0SD8IBDAoKMXRHU1KUdwURPApxugFuCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAQeBiIMJAJSYUSwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKKAoHZ3JhbnRvchIdugEaChgKBFVzZXISEMIBDQoLARkkEIcYEZR5d4wKkQG6AY0BCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKSDKGhnSAUIIUHAouCgdncmFudGVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBIxQzFWZEQpkCPAotCgdncmFudG9yEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgoSNgJBGANZYJQsCne6AXQKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBWQglcWcZRmRpfAoTCgdncmFudGVlEghCBlB1YmxpYwouCgdncmFudG9yEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBJDMYERmXgIiVfAqMAboBiAEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBdhJCdYSZiABHjAotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgoyYgSDiWkkIVZsCigKB2dyYW50b3ISHboBGgoYCgRVc2VyEhDCAQ0KCwEIMEQ5CVZWSAZcCna6AXMKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqXhVQkkSg5QJeMChMKB2dyYW50ZWUSCEIGUHVibGljCi4KB2dyYW50b3ISI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwFlhJZGAHIpSBGMCoYBugGCAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCkhTmFdyeJkVVBwKJwoHZ3JhbnRlZRIcugEZChcKBFVzZXISD8IBDAoKgzdzJWBGZCdTjAopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKCjAhhXcIhhYXaZwKdroBcwosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCll4JEVABFInICwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKLgoHZ3JhbnRvchIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLATlEhIFmGAAFiFwKdboBcgosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCplAM4UlRxOIRWwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKLQoHZ3JhbnRvchIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKQpRiZiZVMIA1TAqEAboBgAEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqUQVF2eJmTMGA8CicKB2dyYW50ZWUSHLoBGQoXCgRVc2VyEg/CAQwKCnNIETKJh5BRmZwKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKCQODY2hUd5NHfAp3ugF0Ci0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLARk2R3NJFzU0FmwKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAWFIBHNCFRIWdRwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKW7oBWAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCnQZUmFgdYRXI0wKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKEwoHZ3JhbnRvchIIQgZQdWJsaWMKhwG6AYMBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAVdSeIBXZSlUOEwKKQoHZ3JhbnRlZRIeugEbChkKBlN5c3RlbRIPwgEMCgpYgWVAZGWBSTacCicKB2dyYW50b3ISHLoBGQoXCgRVc2VyEg/CAQwKCkJyUlEGYiInE1wKnQG6AZkBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLASgJEQUBZXFwIhwKOAoHZ3JhbnRlZRItugEqCigKClByZWRlZmluZWQSGsIBFwoKAWRiVZMQQQdhjBD///////////8BCi4KB2dyYW50b3ISI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEEcXciSJFUgzhMCne6AXQKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBN4kHmJNFKGNQXAoTCgdncmFudGVlEghCBlB1YmxpYwouCgdncmFudG9yEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBFHJgKZeGIAE1nApwugFtCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAWJwEjWFCBBTFYwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKYoMFc4VjdpljfAp2ugFzCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKR2RDEgCHcGZZnAoTCgdncmFudGVlEghCBlB1YmxpYwouCgdncmFudG9yEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBAmJXeIR1RolAPAqIAboBhAEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBCTEkISJBZGh4LAooCgdncmFudGVlEh26ARoKGAoEVXNlchIQwgENCgsBKTQZCAZhGZAmfAopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKClVlAzBCVYYCiDwKcboBbgosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCgOTWBeVJ5GBI4wKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKKQoHZ3JhbnRvchIeugEbChkKBlN5c3RlbRIPwgEMCgqZaFhYIJcJeHScCpsBugGXAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCjJVBSdhcUVog1wKOAoHZ3JhbnRlZRItugEqCigKClByZWRlZmluZWQSGsIBFwoKCAEgIhQzFlkjHBD///////////8BCi0KB2dyYW50b3ISIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCjQ3FTUECBMgWEwKXLoBWQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFEU4dTKWRjVwdsChMKB2dyYW50ZWUSCEIGUHVibGljChMKB2dyYW50b3ISCEIGUHVibGljCpgBugGUAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCjCUGVkUZVRWRVwKNAoHZ3JhbnRlZRIpugEmCiQKBlN5c3RlbRIawgEXCgoRNXZyU2mIcUEsEP///////////wEKLgoHZ3JhbnRvchIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAUVRdkggRgEXcEwKdboBcgosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCgFDUWWSd0F0NJwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKLQoHZ3JhbnRvchIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKgoQTUEU2cJQiLAqFAboBgQEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqWNxdBGYSUlQOMCigKB2dyYW50ZWUSHboBGgoYCgRVc2VyEhDCAQ0KCwFZQCUmIWcyk4V8CicKB2dyYW50b3ISHLoBGQoXCgRVc2VyEg/CAQwKCpJjAQIgBEB1R4wKb7oBbAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKChdVCCkEFEA0ZlwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKlzlXd4GBc1QBHApbugFYCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKKSMYE3CGNyRnnAoTCgdncmFudGVlEghCBlB1YmxpYwoTCgdncmFudG9yEghCBlB1YmxpYwpyugFvCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAXFGFUMRWDEAEywKKQoHZ3JhbnRlZRIeugEbChkKBlN5c3RlbRIPwgEMCgqUY3J1MkgEgUM8ChMKB2dyYW50b3ISCEIGUHVibGljCm+6AWwKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqDIyR0hTk4aSVMCicKB2dyYW50ZWUSHLoBGQoXCgRVc2VyEg/CAQwKCkVDkgSXd5GANTwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKeroBdwosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCleCAjAIM4MokBwKMgoHZ3JhbnRlZRInugEkCiIKBFVzZXISGsIBFwoKEoeEUHc2BkOHXBD///////////8BChMKB2dyYW50b3ISCEIGUHVibGljCly6AVkKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBBjWEcnU2AQIALAoTCgdncmFudGVlEghCBlB1YmxpYwoTCgdncmFudG9yEghCBlB1YmxpYwqNAboBiQEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpJdENRkSYJEnecCioKB2dyYW50ZWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAQiGN3gwYDBjRGwKLQoHZ3JhbnRvchIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKJoN1SWNQdkZXTAqbAboBlwEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBWVBicnmXZ1BhnAo3CgdncmFudGVlEiy6ASkKJwoKUHJlZGVmaW5lZBIZwgEWCgliQ3gZNECTWTwQ////////////AQotCgdncmFudG9yEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgoRUolpcTkgBCI8CpcBugGTAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCnJ5ZRA1JjgwEZwKNAoHZ3JhbnRlZRIpugEmCiQKBlN5c3RlbRIawgEXCgoBZ5SWQigpYhM8EP7//////////wEKLQoHZ3JhbnRvchIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKGCVTSBgmIIJ4HAqWAboBkgEKNwoIYWNsX21vZGUSK7oBKAomCghiaXRmbGFncxIawgEXCgoQKVKDUwUZgCccEP///////////wEKJwoHZ3JhbnRlZRIcugEZChcKBFVzZXISD8IBDAoKF5MIIXg0eSQTTAouCgdncmFudG9yEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBg3QzYwFXVnWRnAqLAboBhwEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBJ2aVIGViaEeHXAonCgdncmFudGVlEhy6ARkKFwoEVXNlchIPwgEMCgqCMmRyGXNJQkJ8Ci0KB2dyYW50b3ISIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKChAglilxIDgHEjwKjQG6AYkBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLARAHdZSJhoJYgowKKQoHZ3JhbnRlZRIeugEbChkKBlN5c3RlbRIPwgEMCgplWEBhMhc2GGOMCi0KB2dyYW50b3ISIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCoFzMYB2V0YSGSwKjgG6AYoBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLARMXlUKUcCCHYowKKgoHZ3JhbnRlZRIfugEcChoKBlN5c3RlbRIQwgENCgsBAJQJlZYnZZVofAotCgdncmFudG9yEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgppdxMTURl5lhl8CpgBugGUAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFWNolEZQlZZGk8Ci0KB2dyYW50ZWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCoBXkzCSVzOAVUwKNAoHZ3JhbnRvchIpugEmCiQKBlN5c3RlbRIawgEXCgoHZFZoEZlWSQkcEP///////////wEKdroBcwosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCiI5CAMDgoFVNFwKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLARSYODaXlmQRJhwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKdboBcgosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCpF4WDUwhYE2A4wKLQoHZ3JhbnRlZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKCDdkh3ZWIVVnjAoTCgdncmFudG9yEghCBlB1YmxpYwqSAboBjgEKNwoIYWNsX21vZGUSK7oBKAomCghiaXRmbGFncxIawgEXCgoWhiBGdwlkElZ8EP///////////wEKKAoHZ3JhbnRlZRIdugEaChgKBFVzZXISEMIBDQoLAUcRMHIWgQMYN2wKKQoHZ3JhbnRvchIeugEbChkKBlN5c3RlbRIPwgEMCgoBABB5dhGVYHEsCpwBugGYAQo3CghhY2xfbW9kZRIrugEoCiYKCGJpdGZsYWdzEhrCARcKCgNVZgRpkgE0dZwQ////////////AQotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgpDhzlkIghmaCIcCi4KB2dyYW50b3ISI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwGBJ5WTYGYoEyWcCogBugGEAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEjhQYpdQF2OBQ8CioKB2dyYW50ZWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAXgxImFgg1FnRnwKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKEoApFVERRkBiPApbugFYCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKgwQSICeBVzUBPAoTCgdncmFudGVlEghCBlB1YmxpYwoTCgdncmFudG9yEghCBlB1YmxpYwqRAboBjQEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBBJYokJMSkJhFHAotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgqZRxdnMmUkBwYcCi0KB2dyYW50b3ISIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCiFgFwEWOCB0WRwKjAG6AYgBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKAShCUSSYcHMhnAooCgdncmFudGVlEh26ARoKGAoEVXNlchIQwgENCgsBEnJlOZNjcZVYbAouCgdncmFudG9yEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBYGVUgTEWUFIgnAqKAboBhgEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoXl4lJFTBnESQ8CioKB2dyYW50ZWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAUA5ZElgFWY1FIwKKgoHZ3JhbnRvchIfugEcChoKBlN5c3RlbRIQwgENCgsBRjcyM0l4ZZIZLApxugFuCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAQFXlAEGcmlQN2wKKAoHZ3JhbnRlZRIdugEaChgKBFVzZXISEMIBDQoLATKJVHcAl5GJiHwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKc7oBcAotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEIVZBIWXgmlElsChMKB2dyYW50ZWUSCEIGUHVibGljCioKB2dyYW50b3ISH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAXKCE3gWVol2g5wKiQG6AYUBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAQgXV4AjA2AXV2wKKAoHZ3JhbnRlZRIdugEaChgKBFVzZXISEMIBDQoLAXRCBmUgV2NxQ5wKKgoHZ3JhbnRvchIfugEcChoKBlN5c3RlbRIQwgENCgsBM3cTljQ0JzWRTAqRAboBjQEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqTZlIzkCQVAiWMCjIKB2dyYW50ZWUSJ7oBJAoiCgRVc2VyEhrCARcKCgaYJHd4AXghUVwQ////////////AQopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKCkGYSDaJaYY4WSwKgQG6AX4KNwoIYWNsX21vZGUSK7oBKAomCghiaXRmbGFncxIawgEXCgoQQEAhWDJAkxVcEP///////////wEKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKLgoHZ3JhbnRvchIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAYMCVYgFgAJ0hEwKhwG6AYMBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKNUAJAnhiNTIQfAonCgdncmFudGVlEhy6ARkKFwoEVXNlchIPwgEMCgpYiUFAkxQiBBRsCioKB2dyYW50b3ISH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAVSAcnUzJRgXCZwKmwG6AZcBCjYKCGFjbF9tb2RlEiq6AScKJQoIYml0ZmxhZ3MSGcIBFgoJkDZZOCg4GXBMEP///////////wEKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLASOQJ4eVAzhlR3wKLQoHZ3JhbnRvchIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKdzMhUzmWeJAJLApbugFYCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKU1JCaIUBFRAFbAoTCgdncmFudGVlEghCBlB1YmxpYwoTCgdncmFudG9yEghCBlB1YmxpYwqFAboBgQEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoIcpVElDOJRiE8CicKB2dyYW50ZWUSHLoBGQoXCgRVc2VyEg/CAQwKCpBDhTFIgHaFJywKKAoHZ3JhbnRvchIdugEaChgKBFVzZXISEMIBDQoLAYN2QxNzM4EgFzwKjwG6AYsBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAVGRZHljIyJjCDwKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLASgIGXSJNHJIeXwKKgoHZ3JhbnRvchIfugEcChoKBlN5c3RlbRIQwgENCgsBQZkgMTMIdiUhPAqLAboBhwEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBYkQnaVhCQzF3fAotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgqRRyWHGAKRIDc8CicKB2dyYW50b3ISHLoBGQoXCgRVc2VyEg/CAQwKCgNCMHYDUlR3F1wKb7oBbAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCgQkeDdCSQYWiDwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKRYKElEkCV5l1jAqJAboBhQEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgokh2iQGSdDUSlcCikKB2dyYW50ZWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKVCk3GVJ2WZdkLAoqCgdncmFudG9yEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFDB2kxQnBCMmI8CosBugGHAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCoFQM0NkKDRAMnwKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAVAJJ4Z0cwMhJCwKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKQZiDBkNDeEMjfAp1ugFyCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKUZNlGBlCR2J4TAoTCgdncmFudGVlEghCBlB1YmxpYwotCgdncmFudG9yEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgqTQ3ElNgUThGF8Cny6AXkKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgo2A1N1iRdoCZlcCjQKB2dyYW50ZWUSKboBJgokCgZTeXN0ZW0SGsIBFwoKCQIUQiUjFVUVbBD///////////8BChMKB2dyYW50b3ISCEIGUHVibGljCly6AVkKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBUISBUwgTgZEYfAoTCgdncmFudGVlEghCBlB1YmxpYwoTCgdncmFudG9yEghCBlB1YmxpYwpcugFZCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAWkBhkYyaWSQiIwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKEwoHZ3JhbnRvchIIQgZQdWJsaWMKhwG6AYMBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKUEQiQ2FTcSFoPAopCgdncmFudGVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCikmNCQGUVkhBVwKKAoHZ3JhbnRvchIdugEaChgKBFVzZXISEMIBDQoLAVJyQTUmBhJIeTwKZroBYwo3CghhY2xfbW9kZRIrugEoCiYKCGJpdGZsYWdzEhrCARcKChZDlggWOUNlMUwQ////////////AQoTCgdncmFudGVlEghCBlB1YmxpYwoTCgdncmFudG9yEghCBlB1YmxpYwqSAboBjgEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgp4NpRRKCV1gmRsCi4KB2dyYW50ZWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwFFRXE4CHJ4VXB8Ci4KB2dyYW50b3ISI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEGOBY1AUB1R0NcCoYBugGCAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwESZmJ3KSgnQ5OcCigKB2dyYW50ZWUSHboBGgoYCgRVc2VyEhDCAQ0KCwFDZWFUeTcnR3VsCicKB2dyYW50b3ISHLoBGQoXCgRVc2VyEg/CAQwKCmYFU3kjZpNIVywKlQG6AZEBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAThlZWhiBhcAUBwKKgoHZ3JhbnRlZRIfugEcChoKBlN5c3RlbRIQwgENCgsBgJASBxRReSmWHAo0CgdncmFudG9yEim6ASYKJAoGU3lzdGVtEhrCARcKCgYxMwEVdZYUmYwQ////////////AQqSAboBjgEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoWJ2J0V4Z4FUhsCi4KB2dyYW50ZWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEJgUd0QWARETRMCi4KB2dyYW50b3ISI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEYhXU3UAY4I5CMCna6AXMKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBdnYFOGMSRmY1PAotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgpiSROEFwdyZUdcChMKB2dyYW50b3ISCEIGUHVibGljCnC6AW0KLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqRAWZJNxaXARKcChMKB2dyYW50ZWUSCEIGUHVibGljCigKB2dyYW50b3ISHboBGgoYCgRVc2VyEhDCAQ0KCwESNkQHZRaGQ5JsCnW6AXIKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgo2h1J5V3CIEHFMChMKB2dyYW50ZWUSCEIGUHVibGljCi0KB2dyYW50b3ISIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCmkUBIgmIQkZiWwKjAG6AYgBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKFCUENhlWkHYSLAotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgpYlyiWdDUliXlMCikKB2dyYW50b3ISHroBGwoZCgZTeXN0ZW0SD8IBDAoKcUQ4YVE1c1RIjApcugFZCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLASFoYhhzZWgBVnwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKEwoHZ3JhbnRvchIIQgZQdWJsaWMKfLoBeQo3CghhY2xfbW9kZRIrugEoCiYKCGJpdGZsYWdzEhrCARcKCgUWCJNniGITMmwQ////////////AQoTCgdncmFudGVlEghCBlB1YmxpYwopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKCjglhzYFZhOIeSwKiQG6AYUBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKKShZhHBQeVKAHAoqCgdncmFudGVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwF2Blg0BgJJKEl8CikKB2dyYW50b3ISHroBGwoZCgZTeXN0ZW0SD8IBDAoKGXIERilXVpMGfApwugFtCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKSZaVknVmc2OGjAooCgdncmFudGVlEh26ARoKGAoEVXNlchIQwgENCgsBI0mGBjSGdoiTHAoTCgdncmFudG9yEghCBlB1YmxpYwqMAboBiAEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBQ4EIZSd2ZCeVfAotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgqWc4dHk0MQQoWcCigKB2dyYW50b3ISHboBGgoYCgRVc2VyEhDCAQ0KCwEUYYhXmXCFFlY8CoEBugF+CjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKB4R3GEQJliAkjBD///////////8BChMKB2dyYW50ZWUSCEIGUHVibGljCi4KB2dyYW50b3ISI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEYAyRBeQAWKUOMCpcBugGTAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCiEERGE2kUGYgowKKQoHZ3JhbnRlZRIeugEbChkKBlN5c3RlbRIPwgEMCgqSMBaRB3BghYdcCjgKB2dyYW50b3ISLboBKgooCgpQcmVkZWZpbmVkEhrCARcKCgNQVTKGFhgHY2wQ////////////AQ== +CmcKZboBYgolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBFVFlAUVpgXKFXAojCgVlcG9jaBIawgEXCgoJEYlziHGSWWKdEP///////////wEKFAoEa2luZBIMQgpGZW5jZVRva2Vu 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 +CmEKX7oBXAoVCgRraW5kEg1CC1R4bldhbFNoYXJkCkMKBXZhbHVlEjq6ATcKNQoFc2hhcmQSLEIqeiXit4JP4Kae8JGNjW0m4Ke86qazLPCegKgqPPCdlYLvvbEweyXwn5W0 +CtcBCtQBugHQAQp/CgNrZXkSeLoBdQo/CgZvYmplY3QSNboBMgowCg1OZXR3b3JrUG9saWN5Eh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFzYXhDiWBYlwccCjIKDXN1Yl9jb21wb25lbnQSIboBHgocCglDb2x1bW5Qb3MSD8IBDAoKIWMWNxAABAWDjAoRCgRraW5kEglCB0NvbW1lbnQKOgoFdmFsdWUSMboBLgosCgdjb21tZW50EiFCH2U6KiEmIuG8ncKs8JOHjTzwn6CsRSrgurbhvojhiKg= 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 +Cr4BCrsBugG3AQovCgNrZXkSKLoBJQojCgJpZBIdugEaChgKBFVzZXISEMIBDQoLAXIgYEFTVpAIhnwKIwoEa2luZBIbQhlTdG9yYWdlQ29sbGVjdGlvbk1ldGFkYXRhCl8KBXZhbHVlEla6AVMKUQoFc2hhcmQSSEJG8Jy2uvCflbRcwqph8J66qPCeubfgtYZzaCrCsjwr8Juwr3ZcLu+/rHtD77+98J+VtPCRjrhcWOC7huCth0nwnrKn8J28ig== +CnwKeroBdwolCgNrZXkSHroBGwoZCgRuYW1lEhFCDyXhs4LwkYu2dSfhoa48PgoRCgRraW5kEglCB1NldHRpbmcKOwoFdmFsdWUSMroBLwotCgV2YWx1ZRIkQiLwnL2CLfCdhrwhaz8i8J64sC8vImjwn5W08JuymcKwL1tH +Ck0KS7oBSAoqCgNrZXkSI7oBIAoeCgVzaGFyZBIVQhNb86CEjiRje+Gngi8k8JyzrMOuChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +Cp4BCpsBugGXAQpXCgNrZXkSULoBTQpLCgRuYW1lEkNCQVvCpeqsrD09J2DwkIC38J+gi/CQqaLwn4Cwe8i677mmPCXvv73gt5Bs77+98JCeuGDwnaqe4K6fPfCTuqY8VtGoChEKBGtpbmQSCUIHSWRBbGxvYwopCgV2YWx1ZRIgugEdChsKB25leHRfaWQSEMIBDQoLAVBpSUZCg0lHdCw= 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 +CqAECp0EugGZBAouCgNrZXkSJ7oBJAoiCgJpZBIcugEZChcKBFVzZXISD8IBDAoKBoJZKXMFMQZSfAoYCgRraW5kEhBCDkNsdXN0ZXJSZXBsaWNhCswDCgV2YWx1ZRLCA7oBvgMKLAoKY2x1c3Rlcl9pZBIeugEbChkKBlN5c3RlbRIPwgEMCgopOSYBloQmZGYsCrgCCgZjb25maWcSrQK6AakCCsMBCghsb2NhdGlvbhK2AboBsgEKrwEKB01hbmFnZWQSowG6AZ8BClMKEWF2YWlsYWJpbGl0eV96b25lEj5CPMi6JC9cXCQq4aeU8JGPlOGKtX0/yLpXK+CqkEd0RD8u8JC7g9+IOu+/vfCfm6XwlqGeJuChtNGo8JGNsQoZCgliaWxsZWRfYXMSDEIKJeCyjkLDui8qdgoOCghpbnRlcm5hbBICCAMKDQoHcGVuZGluZxICCAMKDgoEc2l6ZRIGQgTgsY0hCmEKB2xvZ2dpbmcSVroBUwo+CghpbnRlcnZhbBIyugEvChQKBW5hbm9zEgvCAQgKBgQCFygyPAoXCgRzZWNzEg/CAQwKClWJUQJWdogSIJwKEQoLbG9nX2xvZ2dpbmcSAggDChwKBG5hbWUSFEISKm3wnYi0KmYqJvCRoKDWui8mCjUKCG93bmVyX2lkEim6ASYKJAoGU3lzdGVtEhrCARcKCgFUghSZVhCCJVwQ////////////AQ== +Cs5GCstGugHHRgouCgNrZXkSJ7oBJAoiCgJpZBIcugEZChcKBFVzZXISD8IBDAoKB0dBdgZXNCYpXAoQCgRraW5kEghCBlNjaGVtYQqCRgoFdmFsdWUS+EW6AfRFChEKC2RhdGFiYXNlX2lkEgIIBApBCgRuYW1lEjlCN+Gfpz9S4LGDwqo7e2hT8JG2l19PY/CeuZ96LvCav7Hgq5BqZ++/vVx1JTTqrInwkaSWU/CflbQKEgoDb2lkEgvCAQgKBgFAdDMZnAopCghvd25lcl9pZBIdugEaChgKBFVzZXISEMIBDQoLAQlkFUB1BjCVJnwK3EQKCnByaXZpbGVnZXMSzUSyAclECosBugGHAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCpgmCZcFYIZkY1wKLQoHZ3JhbnRlZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKeQggMZMjh1WELAooCgdncmFudG9yEh26ARoKGAoEVXNlchIQwgENCgsBYAFISDV4iBFpfAqMAboBiAEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBJ0KYY1AQZYZyXAouCgdncmFudGVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBY0NUlTJklIiAjAonCgdncmFudG9yEhy6ARkKFwoEVXNlchIPwgEMCgpwk4djZiURRCAcCqMBugGfAQo3CghhY2xfbW9kZRIrugEoCiYKCGJpdGZsYWdzEhrCARcKCgIkMVh3JnmIIhwQ////////////AQoqCgdncmFudGVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFghxIDGBOFA0GcCjgKB2dyYW50b3ISLboBKgooCgpQcmVkZWZpbmVkEhrCARcKCgh5UVJ1aQEHJHwQ////////////AQqMAboBiAEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoQYWM3kTZiaAksCigKB2dyYW50ZWUSHboBGgoYCgRVc2VyEhDCAQ0KCwFRRmkZhwmBZxI8Ci4KB2dyYW50b3ISI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwFnIQEpODg5OVIcCm+6AWwKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoIOEZEcmQQJJhMCicKB2dyYW50ZWUSHLoBGQoXCgRVc2VyEg/CAQwKCkdYY1JkkDVwYiwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKigG6AYYBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAYKEc5IQASVIlmwKKgoHZ3JhbnRlZRIfugEcChoKBlN5c3RlbRIQwgENCgsBR4MXQHiIYFknTAopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKCkKFdBMhZSMxYBwKdroBcwotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwE0KUUAJJBgh0RMCi0KB2dyYW50ZWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKClkVAUgQEkIEZ2wKEwoHZ3JhbnRvchIIQgZQdWJsaWMKkgG6AY4BCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAXJ0OABYIENQVXwKJwoHZ3JhbnRlZRIcugEZChcKBFVzZXISD8IBDAoKBhlXEYcjdDNjjAo0CgdncmFudG9yEim6ASYKJAoGU3lzdGVtEhrCARcKCgMkkBg0IXKTFYwQ////////////AQpwugFtCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLATlUJhBihwJTRZwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKYhNHd1OARkdxPAqXAboBkwEKNwoIYWNsX21vZGUSK7oBKAomCghiaXRmbGFncxIawgEXCgoVGSljVVmGIDAsEP///////////wEKLQoHZ3JhbnRlZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKaTgnCCZpAQM2XAopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKCjh2AlU0EYKQhzwKlAG6AZABCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLARcyl0lnQAOJkCwKNAoHZ3JhbnRlZRIpugEmCiQKBlN5c3RlbRIawgEXCgoIBHQVMACAAXhsEP///////////wEKKQoHZ3JhbnRvchIeugEbChkKBlN5c3RlbRIPwgEMCgokZ1JDWBIAQSM8CooBugGGAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFzEYgXAyJHRyBcCikKB2dyYW50ZWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKOXJTGJlBKUZ0HAoqCgdncmFudG9yEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwETJgE0J3BZFpl8CnC6AW0KLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoSNZAoFWaSNyCMCigKB2dyYW50ZWUSHboBGgoYCgRVc2VyEhDCAQ0KCwFmZyiUKTkAdEFcChMKB2dyYW50b3ISCEIGUHVibGljCoYBugGCAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKChRYI4iYZDUIeJwKKAoHZ3JhbnRlZRIdugEaChgKBFVzZXISEMIBDQoLAWNnUAaXFAh4FIwKKAoHZ3JhbnRvchIdugEaChgKBFVzZXISEMIBDQoLAQFnVwJkEzRjZFwKdroBcwosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCjBUJShZaSUjWHwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKLgoHZ3JhbnRvchIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAWeVhHVDiXVGZiwKiQG6AYUBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKWGkCMBZpljB1PAopCgdncmFudGVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCmCFVROBVyhxEIwKKgoHZ3JhbnRvchIfugEcChoKBlN5c3RlbRIQwgENCgsBFWNHI3R2cpmBLAqYAboBlAEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBZgFUODBQJnABHAo0CgdncmFudGVlEim6ASYKJAoGU3lzdGVtEhrCARcKChFTVCU5WVhTdRwQ////////////AQotCgdncmFudG9yEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgoYNAl3E3QDAHJsCnK6AW8KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBUDFGKCiGcSlDPAopCgdncmFudGVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCmVZFRUQJQiSAiwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKkQG6AY0BCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKh1WRcWFwaTM4bAo0CgdncmFudGVlEim6ASYKJAoGU3lzdGVtEhrCARcKChZpZpkJdjYGSIwQ////////////AQonCgdncmFudG9yEhy6ARkKFwoEVXNlchIPwgEMCgqXmXaYNgCUYIeMCpwBugGYAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwE4MYMwBSgZABhsCjgKB2dyYW50ZWUSLboBKgooCgpQcmVkZWZpbmVkEhrCARcKCgYwR4gpEzERMEwQ////////////AQotCgdncmFudG9yEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgpVhlFGYSiAQZY8CpsBugGXAQo3CghhY2xfbW9kZRIrugEoCiYKCGJpdGZsYWdzEhrCARcKChVWGYEZUlIHA5wQ////////////AQotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgoFNJZiiZlXKFEsCi0KB2dyYW50b3ISIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKChkoFpJ2ImARIIwKcLoBbQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwE5iJN0F1mBmRJsChMKB2dyYW50ZWUSCEIGUHVibGljCicKB2dyYW50b3ISHLoBGQoXCgRVc2VyEg/CAQwKChYjRJWIZRBIIkwKkQG6AY0BCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAXUBEzkJKXAmNDwKLQoHZ3JhbnRlZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKRjNjVUYHNVUzXAotCgdncmFudG9yEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgpoKBFZMmNZkgV8CpABugGMAQo3CghhY2xfbW9kZRIrugEoCiYKCGJpdGZsYWdzEhrCARcKChcAFlIkCUJzZTwQ////////////AQooCgdncmFudGVlEh26ARoKGAoEVXNlchIQwgENCgsBIzBAEXFxlQRiLAonCgdncmFudG9yEhy6ARkKFwoEVXNlchIPwgEMCgokcTdzSFCFApgsCne6AXQKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBIoMjCAlEdDBmbAouCgdncmFudGVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBFyYEBDmXFDNULAoTCgdncmFudG9yEghCBlB1YmxpYwqBAboBfgo3CghhY2xfbW9kZRIrugEoCiYKCGJpdGZsYWdzEhrCARcKCgEhc1gHIJSHKHwQ/v//////////AQouCgdncmFudGVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBUhYiWIR4lCSETAoTCgdncmFudG9yEghCBlB1YmxpYwqLAboBhwEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpoRHZHkGFAeUBMCicKB2dyYW50ZWUSHLoBGQoXCgRVc2VyEg/CAQwKChcHJiM2RRcClYwKLgoHZ3JhbnRvchIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLATgRMJhweAKFaFwKkwG6AY8BCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKd0iVU3KViBMZHAo0CgdncmFudGVlEim6ASYKJAoGU3lzdGVtEhrCARcKCghnlVaBaHFVmIwQ////////////AQopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKCgOIMHKQczF5Q5wKiwG6AYcBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLARk0cwF0lFiUJXwKLQoHZ3JhbnRlZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKcDeZOBYmdECQXAonCgdncmFudG9yEhy6ARkKFwoEVXNlchIPwgEMCgomQgGUgJWYE3Q8CokBugGFAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEikYCCIYloA5lMCioKB2dyYW50ZWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAUFnZGgnEUgSOYwKKAoHZ3JhbnRvchIdugEaChgKBFVzZXISEMIBDQoLAQeGl0WSaGcVVXwKkgG6AY4BCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKBHgSkUOCdTFIHAooCgdncmFudGVlEh26ARoKGAoEVXNlchIQwgENCgsBEDAUYCWBVUI0HAo0CgdncmFudG9yEim6ASYKJAoGU3lzdGVtEhrCARcKCgKIFXRkl1E1dhwQ////////////AQqWAboBkgEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBIiNQMjc3Q0F4XAoyCgdncmFudGVlEie6ASQKIgoEVXNlchIawgEXCgoJV5eJBGZQdQKMEP///////////wEKLQoHZ3JhbnRvchIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKEWdIFHKSh2KCTAqAAboBfQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCnZkIGQgk4U5cpwKOAoHZ3JhbnRlZRItugEqCigKClByZWRlZmluZWQSGsIBFwoKAgSTc2k3ITElTBD///////////8BChMKB2dyYW50b3ISCEIGUHVibGljCoABugF9CiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKg2GENBY4BmYgLAoTCgdncmFudGVlEghCBlB1YmxpYwo4CgdncmFudG9yEi26ASoKKAoKUHJlZGVmaW5lZBIawgEXCgoHI3U1AxRgY3IcEP///////////wEKcboBbgosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCiGFZFgjhGlBaGwKKQoHZ3JhbnRlZRIeugEbChkKBlN5c3RlbRIPwgEMCgpYgTI3h5ITCUd8ChMKB2dyYW50b3ISCEIGUHVibGljCogBugGEAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKClJHBJkWFEYGEywKKQoHZ3JhbnRlZRIeugEbChkKBlN5c3RlbRIPwgEMCgoHJ0WFQlJ3loicCikKB2dyYW50b3ISHroBGwoZCgZTeXN0ZW0SD8IBDAoKBIczkgJ1RxZEHApvugFsCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKhBU5UlUhKJdjbAoTCgdncmFudGVlEghCBlB1YmxpYwonCgdncmFudG9yEhy6ARkKFwoEVXNlchIPwgEMCgoRKYMolSEhdGdsCnG6AW4KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBQUU4RIEiJEVxbAoTCgdncmFudGVlEghCBlB1YmxpYwooCgdncmFudG9yEh26ARoKGAoEVXNlchIQwgENCgsBUIQngnlyAhAFfAqFAboBgQEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpHdzU0djVFJ5V8CigKB2dyYW50ZWUSHboBGgoYCgRVc2VyEhDCAQ0KCwFSc2CVGAdiFiUsCicKB2dyYW50b3ISHLoBGQoXCgRVc2VyEg/CAQwKClGXk2QCYpdWgGwKiAG6AYQBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLATNWCXIGE4QYl5wKKAoHZ3JhbnRlZRIdugEaChgKBFVzZXISEMIBDQoLAQmJB5VpRTdnYZwKKQoHZ3JhbnRvchIeugEbChkKBlN5c3RlbRIPwgEMCgojBVAJBoCJZhicCnG6AW4KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBMJAUIIlTgHkRnAooCgdncmFudGVlEh26ARoKGAoEVXNlchIQwgENCgsBI2FheJUFYxhBHAoTCgdncmFudG9yEghCBlB1YmxpYwqMAboBiAEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgokSQRiETM3VmcsCigKB2dyYW50ZWUSHboBGgoYCgRVc2VyEhDCAQ0KCwElc2Emc4IER2McCi4KB2dyYW50b3ISI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwFXAAYiYENDIhY8Cna6AXMKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBEYZBaJkAeYSSbAoTCgdncmFudGVlEghCBlB1YmxpYwotCgdncmFudG9yEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgpVFJKJcRFnQGIcCo4BugGKAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCiGUQDRyBjOGBBwKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAQYkCBhGFIUxl2wKKgoHZ3JhbnRvchIfugEcChoKBlN5c3RlbRIQwgENCgsBgWhhgAAmOBczXAqVAboBkQEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgogI4YHVwAnOXKcCjEKB2dyYW50ZWUSJroBIwohCgRVc2VyEhnCARYKCQaXRAeJCDJjnBD+//////////8BCi4KB2dyYW50b3ISI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEWdFgDkmEUY1kcCpEBugGNAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCnNYRieAhndolCwKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAXElhIB0JlFlh3wKLQoHZ3JhbnRvchIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKl0aGEGRiV5J0HAqIAboBhAEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgohMIKVNxiRFUFsCigKB2dyYW50ZWUSHboBGgoYCgRVc2VyEhDCAQ0KCwEDRJkikJAXdDFsCioKB2dyYW50b3ISH7oBHAoaCgZTeXN0ZW0SEMIBDQoLATeSVJUHUEkEdBwKjgG6AYoBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKA1MVVVIhhTZCTAouCgdncmFudGVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBg5hWU5M3kGV5LAoqCgdncmFudG9yEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwE5SVERN4RVGJcsCpYBugGSAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwF2YzWSMFJSQklcCjIKB2dyYW50ZWUSJ7oBJAoiCgRVc2VyEhrCARcKCgmRkmcEATdUF1wQ////////////AQotCgdncmFudG9yEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgoSmTQlAIZlAzVsCowBugGIAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCpRDMUlZWEMBc0wKKQoHZ3JhbnRlZRIeugEbChkKBlN5c3RlbRIPwgEMCgqDQoUkAjETKDJMCi0KB2dyYW50b3ISIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKClJxJlmWaVBidTwKc7oBcAotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFVhEh1YECJIBIsCioKB2dyYW50ZWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAXGIgCchRAcJFVwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKkQG6AY0BCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKEYAAeRCWUXQVXAouCgdncmFudGVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBSIMzCZOIiSh4XAotCgdncmFudG9yEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgoRgzRVN2gjAkmMCnW6AXIKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoGhhcCCQOWkkB8ChMKB2dyYW50ZWUSCEIGUHVibGljCi0KB2dyYW50b3ISIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCmNDJ4lJkygAh1wKjAG6AYgBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKeRkwckdjYAJxPAotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgqJVodhmChYKQc8CikKB2dyYW50b3ISHroBGwoZCgZTeXN0ZW0SD8IBDAoKmSeBAnE1IzEwTAqAAboBfQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCgkgUidQIYhDJhwKOAoHZ3JhbnRlZRItugEqCigKClByZWRlZmluZWQSGsIBFwoKA2gHBwEDNZYATBD///////////8BChMKB2dyYW50b3ISCEIGUHVibGljCowBugGIAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKClCEl1NYVBFkkywKKQoHZ3JhbnRlZRIeugEbChkKBlN5c3RlbRIPwgEMCgoXCGRRkWcQKQh8Ci0KB2dyYW50b3ISIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCjdAQUAGBQiHgzwKhwG6AYMBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKJWgjEZECclCBTAoqCgdncmFudGVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwE0MylAdDSUdJgcCicKB2dyYW50b3ISHLoBGQoXCgRVc2VyEg/CAQwKClUgYXhzVBWSkWwKcroBbwotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFDaWEjcnFBY2mMCikKB2dyYW50ZWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKGBlAEIF0ERlnXAoTCgdncmFudG9yEghCBlB1YmxpYwpxugFuCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKZWeQCAFwQFAlfAopCgdncmFudGVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCjMzckVZMAZAJJwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKcLoBbQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCjiUlychYydkFjwKKAoHZ3JhbnRlZRIdugEaChgKBFVzZXISEMIBDQoLAViBlgIAISllaTwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKfboBegotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFZFJJiAGFHkZKMCjQKB2dyYW50ZWUSKboBJgokCgZTeXN0ZW0SGsIBFwoKAyZkBYMHcDNWbBD///////////8BChMKB2dyYW50b3ISCEIGUHVibGljCna6AXMKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBJ3IyGSJTBCM3TAotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgpAZpIAWWYFJJM8ChMKB2dyYW50b3ISCEIGUHVibGljCn26AXoKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBVzknRWQIh5YAHAo0CgdncmFudGVlEim6ASYKJAoGU3lzdGVtEhrCARcKChg0h0aYglJZB1wQ////////////AQoTCgdncmFudG9yEghCBlB1YmxpYwqLAboBhwEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBMAUWJHZRQlNkbAoqCgdncmFudGVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwEImGmRBGlkg0E8CioKB2dyYW50b3ISH7oBHAoaCgZTeXN0ZW0SEMIBDQoLASQ2ZTGUk1Y1VjwKW7oBWAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCnWQQRJDJ3QTNTwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKEwoHZ3JhbnRvchIIQgZQdWJsaWM= +Cr4CCrsCugG3AgrZAQoDa2V5EtEBugHNAQosCgtkYXRhYmFzZV9pZBIdugEaChgKBFVzZXISEMIBDQoLATV5A1eAlSkEYmwKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAVlnSUZ3ZgYTJxwKFgoLb2JqZWN0X3R5cGUSB8IBBAoCAVwKKQoHcm9sZV9pZBIeugEbChkKBlN5c3RlbRIPwgEMCgoSNoJAlDBWMZhsCioKCXNjaGVtYV9pZBIdugEaChgKBFVzZXISEMIBDQoLAQcHYDVyMBV5dFwKGwoEa2luZBITQhFEZWZhdWx0UHJpdmlsZWdlcwo8CgV2YWx1ZRIzugEwCi4KCnByaXZpbGVnZXMSILoBHQobCghiaXRmbGFncxIPwgEMCgoDVkRnFoU0l3V8 +CnIKcLoBbQotCgNrZXkSJroBIwohCgRuYW1lEhlCFzckUPCQrbx34KuLfu+/vcKlJVgs44S0ChEKBGtpbmQSCUIHSWRBbGxvYwopCgV2YWx1ZRIgugEdChsKB25leHRfaWQSEMIBDQoLAQRRUGkVKWkCVTw= +Cp8BCpwBugGYAQpWCgNrZXkST7oBTAo1CgZvYmplY3QSK7oBKAomCgRUeXBlEh66ARsKGQoGU3lzdGVtEg/CAQwKCmYihZVGNoB4mWwKEwoNc3ViX2NvbXBvbmVudBICCAQKEQoEa2luZBIJQgdDb21tZW50CisKBXZhbHVlEiK6AR8KHQoHY29tbWVudBISQhA9fHRc77+94a+DwrQm4bOD +CmYKZLoBYQovChFkZXBsb3lfZ2VuZXJhdGlvbhIawgEXCgoSQgFYUBBSmUJsEP///////////wEKGAoFZXBvY2gSD8IBDAoKYHdDMmZXModVPAoUCgRraW5kEgxCCkZlbmNlVG9rZW4= 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 +Cr4CCrsCugG3AgqCAQoDa2V5Enu6AXgKMwoLb2JqZWN0X25hbWUSJEIiPvCQlrvwkKCA4KuHdi8n77+9yLoj4LCaLjwkM8OJ0ajCpQoVCgtvYmplY3RfdHlwZRIGwgEDCgFsCioKC3NjaGVtYV9uYW1lEhtCGSRlMPCcsKPwkbSC4aCPVz/wn5W0PPCRiLAKFAoEa2luZBIMQgpHaWRNYXBwaW5nCpkBCgV2YWx1ZRKPAboBiwEKKAoKY2F0YWxvZ19pZBIawgEXCgoUdTeYSFIAMQQ8EP///////////wEKQAoLZmluZ2VycHJpbnQSMUIve+CuqOKPvXVgLOCrq+K0rSpXJSUl77+94LWGSz/gsI4qL1lcJWQiRfCXrarvv5oKHQoJZ2xvYmFsX2lkEhDCAQ0KCwEAIDh1F1BINkds +CpEBCo4BugGKAQpKCgNrZXkSQ7oBQAo+CgRuYW1lEjZCNGzwkJauYCcvJ++/vWfIuu+/veKzmyolTsi6PPCWroLhg41seD5mwrgqNsi6JuKAhvCRsaMKEQoEa2luZBIJQgdJZEFsbG9jCikKBXZhbHVlEiC6AR0KGwoHbmV4dF9pZBIQwgENCgsBRUMmgEBxlilQbA== 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 +CsMBCsABugG8AQoxCgNrZXkSKroBJwolCgJpZBIfugEcChoKBlN5c3RlbRIQwgENCgsBZ5gzgmZmFglXTAoSCgRraW5kEgpCCFJvbGVBdXRoCnMKBXZhbHVlEmq6AWcKNwoNcGFzc3dvcmRfaGFzaBImQiRtOsKl4regYDo6JF9R77+9L+C7huG/oy0qP9Go4Ki28JCWj0wKLAoKdXBkYXRlZF9hdBIeugEbChkKBm1pbGxpcxIPwgEMCgoiBpI5lngWc0Qs +Cq0BCqoBugGmAQobCgNrZXkSFLoBEQoPCgJpZBIJQgdFeHBsYWluCiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQpiCgV2YWx1ZRJZugFWClQKBXNoYXJkEktCSfCeuLslwqLwkbaiUe+/vT9uJdGo4bGGJC3wkJSaS/Ccvr7wm7Cx8J+ciUjgtYfwrIm9Kj3woL+d6qS7WT88QeCon/Cav7Lgp4g= +Cr4BCrsBugG3AQouCgNrZXkSJ7oBJAoiCgJpZBIcugEZChcKBFVzZXISD8IBDAoKaBBnJEU4EUVYbAoSCgRraW5kEgpCCFJvbGVBdXRoCnEKBXZhbHVlEmi6AWUKNAoNcGFzc3dvcmRfaGFzaBIjQiHwkY2X8Jq/vkx8P1FU4oGfavCegJxg8JyzsvCRsLzvrYEKLQoKdXBkYXRlZF9hdBIfugEcChoKBm1pbGxpcxIQwgENCgsBBVEYllZ4NIVUHA== +CrcECrQEugGwBAouCgNrZXkSJ7oBJAoiCgJpZBIcugEZChcKBFVzZXISD8IBDAoKFDIyFhIYgyl5nAoYCgRraW5kEhBCDkNsdXN0ZXJSZXBsaWNhCuMDCgV2YWx1ZRLZA7oB1QMKLAoKY2x1c3Rlcl9pZBIeugEbChkKBlN5c3RlbRIPwgEMCgoJCAJBgjKHBRBcCqECCgZjb25maWcSlgK6AZICCqwBCghsb2NhdGlvbhKfAboBmwEKmAEKB01hbmFnZWQSjAG6AYgBChcKEWF2YWlsYWJpbGl0eV96b25lEgIIBAoPCgliaWxsZWRfYXMSAggECg4KCGludGVybmFsEgIIAwoNCgdwZW5kaW5nEgIIAwo9CgRzaXplEjVCM/CQq6/wkL+H77+94K2c8JK+rjrCpeK0lO+uplzhoadLXfCdkK9cLuqnsH0kKvCego9bRQphCgdsb2dnaW5nEla6AVMKPgoIaW50ZXJ2YWwSMroBLwoUCgVuYW5vcxILwgEICgYBEASRiBwKFwoEc2VjcxIPwgEMCgoGhWCDaSSJB4iMChEKC2xvZ19sb2dnaW5nEgIIAwpMCgRuYW1lEkRCQmZUwqVs4K+0OeGJiyYm8JCKli/gs6Am762A8J65myRrVOqsjOCqtXnvv71v8Ja8hcK/77+9XfCfgIIkRvCfg4XCpQozCghvd25lcl9pZBInugEkCiIKBFVzZXISGsIBFwoKFyNTBySXOFF3bBD///////////8B +CoECCv4BugH6AQpYCgNrZXkSUboBTgoqCgpjbHVzdGVyX2lkEhy6ARkKFwoEVXNlchIPwgEMCgpXYneGcVFZkEQ8CiAKBG5hbWUSGEIW0aguP+K3nMOS8J6ErCUqTmtk8JajnQopCgRraW5kEiFCH0NsdXN0ZXJJbnRyb3NwZWN0aW9uU291cmNlSW5kZXgKcwoFdmFsdWUSaroBZwooCgpjYXRhbG9nX2lkEhrCARcKChFwcpCFCERpFFwQ////////////AQodCglnbG9iYWxfaWQSEMIBDQoLAVNFNEASQANwdnwKHAoDb2lkEhXCARIKBQOElyIsEP///////////wE= +CoQBCoEBugF+CkEKA2tleRI6ugE3CjUKA2tleRIuQizwnoWOccO4L/CQoqx1JfCdvKp5JO+/vX1eXHYl8JGOi2DwlJi34amuKu+/vQoQCgRraW5kEghCBkNvbmZpZwonCgV2YWx1ZRIeugEbChkKBXZhbHVlEhDCAQ0KCwEzgJl2aQNihZJs +CpOaAQqPmgG6AYqaAQovCgNrZXkSKLoBJQojCgJpZBIdugEaChgKBFVzZXISEMIBDQoLARFleXCUMIYkI2wKFwoEa2luZBIPQg1OZXR3b3JrUG9saWN5CryZAQoFdmFsdWUSsZkBugGsmQEKGgoEbmFtZRISQhDgrqMuK3tT4aSBJS7wn5W0ChEKA29pZBIKwgEHCgUCYUWWHAooCghvd25lcl9pZBIcugEZChcKBFVzZXISD8IBDAoKdBRyEicGVyCVjArVYgoKcHJpdmlsZWdlcxLGYrIBwmIKc7oBcAotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEiIHFGljJRMjI8CioKB2dyYW50ZWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAVgkAAQgVBl1dVwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKcLoBbQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFAQRJiCSMyZSCMCicKB2dyYW50ZWUSHLoBGQoXCgRVc2VyEg/CAQwKCmlUB2EFJyFGBXwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKiQG6AYUBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKQWckATJkNJGEXAopCgdncmFudGVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCpUkI0E5JhKVlDwKKgoHZ3JhbnRvchIfugEcChoKBlN5c3RlbRIQwgENCgsBZjVih4mVRiCDjAqOAboBigEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBQIiYgxZxITd3PAoqCgdncmFudGVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwETYSQyUlgSN3NcCi0KB2dyYW50b3ISIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCoOINHFZMleHIEwKfLoBeQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCpJ5QGYYU1FZhxwKNAoHZ3JhbnRlZRIpugEmCiQKBlN5c3RlbRIawgEXCgoTGZMThFNpZJiMEP///////////wEKEwoHZ3JhbnRvchIIQgZQdWJsaWMKhgG6AYIBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAUUDaGQyaVZhkGwKKAoHZ3JhbnRlZRIdugEaChgKBFVzZXISEMIBDQoLASIRYVY3mReWVWwKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKaFklMWF4BHQkLAqHAboBgwEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpJYpBRFFYBlWYsCigKB2dyYW50ZWUSHboBGgoYCgRVc2VyEhDCAQ0KCwEDB4VkmDR0lAFsCikKB2dyYW50b3ISHroBGwoZCgZTeXN0ZW0SD8IBDAoKOSJDFxlmOVZWTAqSAboBjgEKNwoIYWNsX21vZGUSK7oBKAomCghiaXRmbGFncxIawgEXCgoUIJYxRkMwKIY8EP///////////wEKKgoHZ3JhbnRlZRIfugEcChoKBlN5c3RlbRIQwgENCgsBdJUhFzEReSIZnAonCgdncmFudG9yEhy6ARkKFwoEVXNlchIPwgEMCgplBQGQGVJFI4Y8CocBugGDAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFEUwA3RoOEgERsCicKB2dyYW50ZWUSHLoBGQoXCgRVc2VyEg/CAQwKCpMzaEFiZZBlBRwKKQoHZ3JhbnRvchIeugEbChkKBlN5c3RlbRIPwgEMCgqIdWVTCFCVMJIsCo4BugGKAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEThFkDWHFjZQWMCi0KB2dyYW50ZWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCpY4SCZ4RjRphUwKKgoHZ3JhbnRvchIfugEcChoKBlN5c3RlbRIQwgENCgsBdYERk4mJk2mAbApbugFYCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKUyOHAYQjZhKEfAoTCgdncmFudGVlEghCBlB1YmxpYwoTCgdncmFudG9yEghCBlB1YmxpYwqKAboBhgEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBNZIzMTNUkjhHTAoqCgdncmFudGVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwElMhCUFERFdGB8CikKB2dyYW50b3ISHroBGwoZCgZTeXN0ZW0SD8IBDAoKQUGYRjIXl3JkjAqEAboBgAEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpJkAlFljMniWAcCicKB2dyYW50ZWUSHLoBGQoXCgRVc2VyEg/CAQwKCkSIUzcSAyUSM5wKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKFBUjUxIBNwEBTAp9ugF6Ci0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLARcjmWIIAnCTYDwKNAoHZ3JhbnRlZRIpugEmCiQKBlN5c3RlbRIawgEXCgoIg0ZTUCaYQghsEP///////////wEKEwoHZ3JhbnRvchIIQgZQdWJsaWMKW7oBWAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCmIHMCGCGDdpmWwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKEwoHZ3JhbnRvchIIQgZQdWJsaWMKW7oBWAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCoRpCZljlSJUhpwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKEwoHZ3JhbnRvchIIQgZQdWJsaWMKdroBcwosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKChIAAEc4WGEyMlwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKLgoHZ3JhbnRvchIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAXYYBhgVQWEjRpwKmAG6AZQBCjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKEAQTdXI5gikYTBD///////////8BCioKB2dyYW50ZWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAWhhGEBHAyhTd5wKLQoHZ3JhbnRvchIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKCDBpZjYEUgWAfAp3ugF0Ci0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLARdQMoURJpaVcmwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKLgoHZ3JhbnRvchIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAUlwmBQ1kURIgxwKcboBbgosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCllTYRNhSFQTEywKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKKQoHZ3JhbnRvchIeugEbChkKBlN5c3RlbRIPwgEMCgp1BBYUaUYYdTV8CpsBugGXAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCkc2NjSRgogWQnwKLQoHZ3JhbnRlZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKOZczhod3NDZYHAo4CgdncmFudG9yEi26ASoKKAoKUHJlZGVmaW5lZBIawgEXCgoXhIWBIHVhdxlMEP///////////wEKcroBbwotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEjWScDJyFQIAhcChMKB2dyYW50ZWUSCEIGUHVibGljCikKB2dyYW50b3ISHroBGwoZCgZTeXN0ZW0SD8IBDAoKKWM5k4CFcndFfAqYAboBlAEKNwoIYWNsX21vZGUSK7oBKAomCghiaXRmbGFncxIawgEXCgoHYEYjQCV4I2hsEP///////////wEKLQoHZ3JhbnRlZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKQ1CIESgWmEB3nAoqCgdncmFudG9yEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFVFVgkSZGJhgksCocBugGDAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCpWVk3VBlkCDOSwKKAoHZ3JhbnRlZRIdugEaChgKBFVzZXISEMIBDQoLAQcYRwUQOIYVmHwKKQoHZ3JhbnRvchIeugEbChkKBlN5c3RlbRIPwgEMCgqXJ2E0Yjd5AHIcCo0BugGJAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwF1Q1SFdZZkhnVMCi4KB2dyYW50ZWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEUk4YnMjEhSCc8CigKB2dyYW50b3ISHboBGgoYCgRVc2VyEhDCAQ0KCwEYACgpJAMpMkSMCnG6AW4KLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoIRCEFQjM0g2GMChMKB2dyYW50ZWUSCEIGUHVibGljCikKB2dyYW50b3ISHroBGwoZCgZTeXN0ZW0SD8IBDAoKhkGEFlNSNGmVbAp2ugFzCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKdZCEiVYQQGdSPAouCgdncmFudGVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBNWiQWQNGIIVHPAoTCgdncmFudG9yEghCBlB1YmxpYwqJAboBhQEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBRXUAcgaXaVCJbAopCgdncmFudGVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCgMyUJRImGNJCFwKKQoHZ3JhbnRvchIeugEbChkKBlN5c3RlbRIPwgEMCgqDaCVpWEgYV3mMCoEBugF+Ci0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLASYHcnEJIkNJKCwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKOAoHZ3JhbnRvchItugEqCigKClByZWRlZmluZWQSGsIBFwoKAZCXNFBJZWMUnBD///////////8BCo8BugGLAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFDk1QwOGCZQJQ8Ci4KB2dyYW50ZWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwFzQxCTMAAIaCV8CioKB2dyYW50b3ISH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAUcCQDOARFKTCYwKnQG6AZkBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAXSQVBcQMQMSVjwKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAQA2FBcBUHgUVYwKOAoHZ3JhbnRvchItugEqCigKClByZWRlZmluZWQSGsIBFwoKFSc2hzIjNCcYjBD///////////8BCne6AXQKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBGXEFkHGFQTWYjAouCgdncmFudGVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBCCIDCWhYaUORLAoTCgdncmFudG9yEghCBlB1YmxpYwqVAboBkQEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpFOYUJdDJYZVFcCjIKB2dyYW50ZWUSJ7oBJAoiCgRVc2VyEhrCARcKCgdVMWciQFGSciwQ////////////AQotCgdncmFudG9yEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgoJgXKYWQaJVSicCnW6AXIKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpllVljgHcwlhaMChMKB2dyYW50ZWUSCEIGUHVibGljCi0KB2dyYW50b3ISIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCpMxdgZ3EzYIRxwKiQG6AYUBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKMHViUwGJcAg1PAopCgdncmFudGVlEh66ARsKGQoGU3lzdGVtEg/CAQwKClU4SBA2YjEBZZwKKgoHZ3JhbnRvchIfugEcChoKBlN5c3RlbRIQwgENCgsBdxh3IBCHJomVTAqJAboBhQEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoQdYJSB1cTgBB8CioKB2dyYW50ZWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAQYWAwdhJhk2BYwKKQoHZ3JhbnRvchIeugEbChkKBlN5c3RlbRIPwgEMCgplhHgZkTgmCVdMCnK6AW8KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBYjGDA3JxImV1bAoTCgdncmFudGVlEghCBlB1YmxpYwopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKCpdVGDUBmHeUJZwKiwG6AYcBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAUEBAoRZgXYpdSwKLQoHZ3JhbnRlZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKglJ3UUkzZBZQbAonCgdncmFudG9yEhy6ARkKFwoEVXNlchIPwgEMCgpSAAUGBzhDZpVcCnG6AW4KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBaUB3BYQpYgJyjAooCgdncmFudGVlEh26ARoKGAoEVXNlchIQwgENCgsBNmRII1AkdiFmjAoTCgdncmFudG9yEghCBlB1YmxpYwpxugFuCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLARU2AHkSJHMwdYwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKKAoHZ3JhbnRvchIdugEaChgKBFVzZXISEMIBDQoLARiDFXRxmECFlkwKdboBcgotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEHkIBIUjMyVEaMCiwKB2dyYW50ZWUSIboBHgocCgpQcmVkZWZpbmVkEg7CAQsKCQIklhY5eZWUbAoTCgdncmFudG9yEghCBlB1YmxpYwpcugFZCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAQNRYwMoAIORKRwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKEwoHZ3JhbnRvchIIQgZQdWJsaWMKcLoBbQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEoAWORc4h0iXUsCicKB2dyYW50ZWUSHLoBGQoXCgRVc2VyEg/CAQwKChmYKZYolkBGIEwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKjgG6AYoBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAQJyaRkmMTEUIBwKKQoHZ3JhbnRlZRIeugEbChkKBlN5c3RlbRIPwgEMCgpRMwKBlDBJJTN8Ci4KB2dyYW50b3ISI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwFyQDOUFHg5FxJMCnK6AW8KLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoYgGZQBzWZQ1gcCioKB2dyYW50ZWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAQOQKEUWEQNYlywKEwoHZ3JhbnRvchIIQgZQdWJsaWMKeroBdwosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKChSFE4iFJxiUVnwKMgoHZ3JhbnRlZRInugEkCiIKBFVzZXISGsIBFwoKCJc5VWIDYihWnBD///////////8BChMKB2dyYW50b3ISCEIGUHVibGljCnC6AW0KLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqSl2AZMQcGNWFsCigKB2dyYW50ZWUSHboBGgoYCgRVc2VyEhDCAQ0KCwFXkWd5kQQ3FkAsChMKB2dyYW50b3ISCEIGUHVibGljClu6AVgKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpShhklITFiSGZ8ChMKB2dyYW50ZWUSCEIGUHVibGljChMKB2dyYW50b3ISCEIGUHVibGljCnG6AW4KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBQkGHgFKCaAJXfAooCgdncmFudGVlEh26ARoKGAoEVXNlchIQwgENCgsBUhJXAwYxF3FJjAoTCgdncmFudG9yEghCBlB1YmxpYwqHAboBgwEKNgoIYWNsX21vZGUSKroBJwolCghiaXRmbGFncxIZwgEWCglmAkdXI1iQKGwQ////////////AQoTCgdncmFudGVlEghCBlB1YmxpYwo0CgdncmFudG9yEim6ASYKJAoGU3lzdGVtEhrCARcKCgJFMDIzg3goOHwQ////////////AQqGAboBggEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpnMHNCgZABJSmcCikKB2dyYW50ZWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKcpMQkgCVNUklbAonCgdncmFudG9yEhy6ARkKFwoEVXNlchIPwgEMCgonFldGdGhTYQksCnG6AW4KLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpZcQmWBASFdgOMChMKB2dyYW50ZWUSCEIGUHVibGljCikKB2dyYW50b3ISHroBGwoZCgZTeXN0ZW0SD8IBDAoKOYdkFhNZcVJTXApwugFtCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKMCiYJkOZE2BEnAooCgdncmFudGVlEh26ARoKGAoEVXNlchIQwgENCgsBECURhXQYFjlHnAoTCgdncmFudG9yEghCBlB1YmxpYwp9ugF6CjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKB1RXFyhjUJkxfBD///////////8BCioKB2dyYW50ZWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAXlHIHiGdXiZKZwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKcLoBbQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCjBRE2RTdlZAkWwKKAoHZ3JhbnRlZRIdugEaChgKBFVzZXISEMIBDQoLATU3EBSXFVlBMTwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKd7oBdAotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEhkIEEdAE1NEdcCi4KB2dyYW50ZWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEHRTEhQYAXOUScChMKB2dyYW50b3ISCEIGUHVibGljCosBugGHAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCgGAEICYYomBcBwKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLASVUiAc2VEckIBwKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKkWJ1JCBXJzaQjAqAAboBfQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCoN2SFZDhlCIVUwKOAoHZ3JhbnRlZRItugEqCigKClByZWRlZmluZWQSGsIBFwoKFRNUWVkgKXMwjBD///////////8BChMKB2dyYW50b3ISCEIGUHVibGljCpoBugGWAQo3CghhY2xfbW9kZRIrugEoCiYKCGJpdGZsYWdzEhrCARcKCgkEOYkpVSOXBUwQ////////////AQoyCgdncmFudGVlEie6ASQKIgoEVXNlchIawgEXCgoDBpR4J2dJSHccEP///////////wEKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKBFMEZFB2gIQGLAqKAboBhgEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpEUINpl4UXMEmMCi0KB2dyYW50ZWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCgcQlAAiZkWZdJwKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKFZY1V0mBZCJoPAqJAboBhQEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBBZQWSVUzkFMJnAoqCgdncmFudGVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwEIR3QgKVVVCXg8CigKB2dyYW50b3ISHboBGgoYCgRVc2VyEhDCAQ0KCwE1NnWCmGMYkJFMCnK6AW8KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBNZNUJUd2AmMBTAopCgdncmFudGVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCocmJpiBMUd4EHwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKb7oBbAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCocwSAVFNpeHh0wKJwoHZ3JhbnRlZRIcugEZChcKBFVzZXISD8IBDAoKQFaUVjcAOWdVjAoTCgdncmFudG9yEghCBlB1YmxpYwqKAboBhgEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgp5EhKUeDh3REdcCi0KB2dyYW50ZWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCjRlFkdEdwEjeCwKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKRngHOUhVZQVCPAqIAboBhAEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpEgAE3gEMSF1ZMCikKB2dyYW50ZWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKYWQZd4IZJ0c1LAopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKCnIAZEIUBUcFYTwKjAG6AYgBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAQEnUGhpWCiBJnwKKAoHZ3JhbnRlZRIdugEaChgKBFVzZXISEMIBDQoLATUlMTYElDYmeUwKLQoHZ3JhbnRvchIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKEwR2VzZXICWJPAqNAboBiQEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpZBGcwlyBiBRl8Ci4KB2dyYW50ZWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEpGCIpZVlSFkGcCikKB2dyYW50b3ISHroBGwoZCgZTeXN0ZW0SD8IBDAoKISd4YlNZZpVhPAqSAboBjgEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBJ0gjlWOBZnZUbAotCgdncmFudGVlEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgpwM2QgdhcFSTQsCi4KB2dyYW50b3ISI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwFhJjEZM3UGQwCMCo0BugGJAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCmBzlgkVZyESQVwKLQoHZ3JhbnRlZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKJEhXcjEycXcCbAoqCgdncmFudG9yEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwEmaRRAdXZAQpc8Cnu6AXgKNwoIYWNsX21vZGUSK7oBKAomCghiaXRmbGFncxIawgEXCgoYNjaXFxcYkUlMEP///////////wEKKAoHZ3JhbnRlZRIdugEaChgKBlN5c3RlbRIOwgELCglyJohigYkUd2wKEwoHZ3JhbnRvchIIQgZQdWJsaWMKhwG6AYMBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKZGmRIHdAglA5HAooCgdncmFudGVlEh26ARoKGAoEVXNlchIQwgENCgsBZYIBYUdUFHAyfAopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKCpKBl3Z3QEJFN3wKcroBbwosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKClZ1BBInB3aHcowKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKKgoHZ3JhbnRvchIfugEcChoKBlN5c3RlbRIQwgENCgsBNRVRJAE4BQFALAqKAboBhgEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqBhwN5hoSBISYcCicKB2dyYW50ZWUSHLoBGQoXCgRVc2VyEg/CAQwKCkSWAnGAYEBJUIwKLQoHZ3JhbnRvchIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKOWcCIlNSEYcZXAqKAboBhgEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpgAnFBZokpRIhMCicKB2dyYW50ZWUSHLoBGQoXCgRVc2VyEg/CAQwKCiA0UWlHZGIWQzwKLQoHZ3JhbnRvchIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKYHmVaUiQQFJ4TAp2ugFzCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKKGAAOZBjZAQxTAouCgdncmFudGVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBAABwR1B3gWRpbAoTCgdncmFudG9yEghCBlB1YmxpYwpwugFtCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAWkGB3YJVRU0A0wKJwoHZ3JhbnRlZRIcugEZChcKBFVzZXISD8IBDAoKczIIeXkzZyEmLAoTCgdncmFudG9yEghCBlB1YmxpYwqHAboBgwEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBEUJAWYNSBmA4jAopCgdncmFudGVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCiYiElN5Q0GTd5wKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKMiYhgFN0BJFRTAqXAboBkwEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpYERQGgRhRIFVsCikKB2dyYW50ZWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKgVMlE5MyOBRXfAo4CgdncmFudG9yEi26ASoKKAoKUHJlZGVmaW5lZBIawgEXCgoXiTJHg3eBY1VcEP///////////wEKcboBbgotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwElOUWEdDBpGXaMCigKB2dyYW50ZWUSHboBGgoYCgRVc2VyEhDCAQ0KCwGBSFVCeXQDdwJ8ChMKB2dyYW50b3ISCEIGUHVibGljCowBugGIAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEAdGRpSSIDEVVcCigKB2dyYW50ZWUSHboBGgoYCgRVc2VyEhDCAQ0KCwFjQAl4kklHKTJ8Ci0KB2dyYW50b3ISIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCpSGEoMZFkYgRHwKW7oBWAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCkMWaBQSVXE2lxwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKEwoHZ3JhbnRvchIIQgZQdWJsaWMKhwG6AYMBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKIFVpOGhwlGR3jAoqCgdncmFudGVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFpYnkVVVGIcRAsCicKB2dyYW50b3ISHLoBGQoXCgRVc2VyEg/CAQwKCmlSkDeVOEQ2hUwKcboBbgosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKClMJkiRZWRkFiHwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKKQoHZ3JhbnRvchIeugEbChkKBlN5c3RlbRIPwgEMCgpYE0FQQ0UzaFOcCpABugGMAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCiApN5lZcANFBBwKLQoHZ3JhbnRlZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKlQB0Ykc2FJQCPAotCgdncmFudG9yEiK6AR8KHQoKUHJlZGVmaW5lZBIPwgEMCgo2OIZHFVkkcwAsCpYBugGSAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCpgJVYY2kYAUaZwKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAREXeIk3ETGDR2wKMgoHZ3JhbnRvchInugEkCiIKBFVzZXISGsIBFwoKBxN2WSiGmYIGLBD///////////8BCo0BugGJAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCmgAACgSgyMXCXwKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAYJZlkIXBZI3ZIwKKQoHZ3JhbnRvchIeugEbChkKBlN5c3RlbRIPwgEMCgoHeGZjRXQWByd8Cm+6AWwKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgojkhaCY1gwlCNcCicKB2dyYW50ZWUSHLoBGQoXCgRVc2VyEg/CAQwKChVXlFQIgiQDZowKEwoHZ3JhbnRvchIIQgZQdWJsaWMKfboBego3CghhY2xfbW9kZRIrugEoCiYKCGJpdGZsYWdzEhrCARcKChZVAyczgSmIMkwQ////////////AQoqCgdncmFudGVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwERJTJggDYZBUFcChMKB2dyYW50b3ISCEIGUHVibGljCosBugGHAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFXUJNDZilYCCWcCi0KB2dyYW50ZWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKChlAhGB2khEYFlwKJwoHZ3JhbnRvchIcugEZChcKBFVzZXISD8IBDAoKNFF3UZiRaWRAfAqJAboBhQEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBKQAZcSZYaJAzPAooCgdncmFudGVlEh26ARoKGAoEVXNlchIQwgENCgsBZHAREXSAEZRjPAoqCgdncmFudG9yEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwEYZoABdGEFJYdMCpYBugGSAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCmCWNlh1hglgl3wKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAVmHeVQmcYlkMkwKMgoHZ3JhbnRvchInugEkCiIKBFVzZXISGsIBFwoKAlMyeWGWiDdBLBD///////////8BCokBugGFAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCieRMGEogJUnGJwKKQoHZ3JhbnRlZRIeugEbChkKBlN5c3RlbRIPwgEMCgonMUAUQWVyUxlMCioKB2dyYW50b3ISH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAYECg3ghQ3NlhXwKc7oBcAotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFyElKIJ5WUJ4B8CioKB2dyYW50ZWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAQc4RHSYF3NiFBwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKc7oBcAotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFYNCMydkhQCEQcChMKB2dyYW50ZWUSCEIGUHVibGljCioKB2dyYW50b3ISH7oBHAoaCgZTeXN0ZW0SEMIBDQoLATOHOASZlFmXFHwKlgG6AZIBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLARaZEmYWczeDk1wKMgoHZ3JhbnRlZRInugEkCiIKBFVzZXISGsIBFwoKFiQhdFNmhwaQTBD///////////8BCi0KB2dyYW50b3ISIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCpRgVUkGmCE2BUwKcroBbwosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKClc1MRIRGBEQcHwKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKKgoHZ3JhbnRvchIfugEcChoKBlN5c3RlbRIQwgENCgsBJUMJBZN1dUF3fAqAAboBfQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCgcyIZN5Y1F3M4wKEwoHZ3JhbnRlZRIIQgZQdWJsaWMKOAoHZ3JhbnRvchItugEqCigKClByZWRlZmluZWQSGsIBFwoKBxB5EkBUlRliPBD///////////8BCvg1CgVydWxlcxLuNbIB6jUKaLoBZQoRCgZhY3Rpb24SB0IFQWxsb3cKJQoHYWRkcmVzcxIaQhh7YPCRg7NuPOC+vOGxnsKlJCfqrJZhfSYKFgoJZGlyZWN0aW9uEglCB0luZ3Jlc3MKEQoEbmFtZRIJQgdz4LC/4KyCCnq6AXcKEQoGYWN0aW9uEgdCBUFsbG93CigKB2FkZHJlc3MSHUIbJybwn5W0WeCzrl098JGwhsOl8JCWkfCcsKcuChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzCiAKBG5hbWUSGEIW0aguZSUk8JGcmGknJMKp8JGwrSbDsgqcAboBmAEKEQoGYWN0aW9uEgdCBUFsbG93CisKB2FkZHJlc3MSIEIe8J+vk0Dwkb+v8JCip/Ceupg/8Ja/se+/glPCtzcmChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzCj4KBG5hbWUSNkI077+9L/CQvog877+9JeqsjWrvrL40wqVCP/CRkaFneyXwkbSILuCyl/CQsp1n4oK+8J+VtAp+ugF7ChEKBmFjdGlvbhIHQgVBbGxvdwohCgdhZGRyZXNzEhZCFFfwkY2rOsKlPfCRnYbwnrmN4LedChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzCisKBG5hbWUSI0IhJnRDIvCdkLTwkbKy4KmRzozvv73IuiU/8JGmpvCeuZcuCogBugGEAQoRCgZhY3Rpb24SB0IFQWxsb3cKDgoHYWRkcmVzcxIDQgElChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzCkcKBG5hbWUSP0I9Nj3wkIqs8JCohuqhkvCflbTwnaqbIijvv73gtYtP8JGAiS97ICLFlyTgqLZ78JuFldGo8J+VtC/wqrOQYAqaAboBlgEKEQoGYWN0aW9uEgdCBUFsbG93CjwKB2FkZHJlc3MSMUIvLOC3lsKl0ajNuuC7kdGoOnAnIvCQlJt2wqXDlTBd76y8zozgu4Y88JarhuCqgiYKFgoJZGlyZWN0aW9uEglCB0luZ3Jlc3MKKwoEbmFtZRIjQiHwnrqJ6puR4LaR8JarnC5AP+Gyqjwqe/CegJTgv4/vuakKowG6AZ8BChEKBmFjdGlvbhIHQgVBbGxvdwoiCgdhZGRyZXNzEhdCFeChpSLgtrTqn5AuwqU+dmslXeK3nQoWCglkaXJlY3Rpb24SCUIHSW5ncmVzcwpOCgRuYW1lEkZCROK6hzpWbCRt8JGpuuC1h/Cei7898JGHp/CegKh9LVfwkI+LRfCdlJfhn6I98J+VtNGo0ajRqFfwn6GWfSQ1yLpZ4LeKCo4BugGKAQoRCgZhY3Rpb24SB0IFQWxsb3cKFAoHYWRkcmVzcxIJQgfhv7Twn5W0ChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzCkcKBG5hbWUSP0I96qeg8J+Co/Cfo4Ev4K6/4KuA8JGrlPCmgaY6w6J58JChguGCvUJg4LOgXPCegKkibloqaWgkLyQt4YuNOgqNAboBiQEKEQoGYWN0aW9uEgdCBUFsbG93ChoKB2FkZHJlc3MSD0IN8J65nzrqn5NcwqUqPAoWCglkaXJlY3Rpb24SCUIHSW5ncmVzcwpACgRuYW1lEjhCNvCflbTwn5W08JGMs8i68J+VtF/jhpI/MeC7ju+/ve+/rWzwkKiw4b+bwrcuw7xfyLol8JuFkAqaAboBlgEKEQoGYWN0aW9uEgdCBUFsbG93CksKB2FkZHJlc3MSQEI+4KyK4ram4KisIvCWuarwnY2sbiJc8J+fqWDitK3tnrLvv73Iuj3igbDit5wv4L+JWPCQuqzhvZnDrS8kJSYKFgoJZGlyZWN0aW9uEglCB0luZ3Jlc3MKHAoEbmFtZRIUQhLitKA9e1XgrpR7P/Cfnp060agKlAG6AZABChEKBmFjdGlvbhIHQgVBbGxvdworCgdhZGRyZXNzEiBCHiRd76yvd1gu4YqvXMKl77+lJkk+77+94b+577+9PwoWCglkaXJlY3Rpb24SCUIHSW5ncmVzcwo2CgRuYW1lEi5CLC/wlrmZ8JGPgPCUlKNVOi8meyd74LWILSV74Ki8KXLDqPCflbRd8JG1o1M9Cq4BugGqAQoRCgZhY3Rpb24SB0IFQWxsb3cKUwoHYWRkcmVzcxJIQkbgqockwqVJ4b+28JC/pe+tg8KkOiTslJLwkKSwLvCQhprvv4rwnrql4KyyO30/8JK/idGo8J+JgCg8Yk/wnrqhyLrqq6F1ChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzCigKBG5hbWUSIEIe8JGLt2DhqZY5M8Ou77+9IvCRiJFg8J+VtD/grqRDCpwBugGYAQoRCgZhY3Rpb24SB0IFQWxsb3cKUQoHYWRkcmVzcxJGQkTwkKGMJ/CflbTwn5W04b+pJ+qnq+G8nfCQhonwnoSx8J+VtCLwkK6N77+9RzLwkZazfuqfvGVq8J6Ko2g9PeC3mOCvigoWCglkaXJlY3Rpb24SCUIHSW5ncmVzcwoYCgRuYW1lEhBCDsi6bid4VeKuhPCWuZUhCmS6AWEKEQoGYWN0aW9uEgdCBUFsbG93Cg8KB2FkZHJlc3MSBEICIlwKFgoJZGlyZWN0aW9uEglCB0luZ3Jlc3MKIwoEbmFtZRIbQhlTJsO74Yq54LqlJcOtPyZhO/CeuptFUMOxCnm6AXYKEQoGYWN0aW9uEgdCBUFsbG93ChQKB2FkZHJlc3MSCUIH4aSgTsi6ewoWCglkaXJlY3Rpb24SCUIHSW5ncmVzcwozCgRuYW1lEitCKfCehIIuL3Yvw4hSXmsm8J+VtPCflbRiYPCvp7fgsptc8JGNsvCRoLlgCokBugGFAQoRCgZhY3Rpb24SB0IFQWxsb3cKLgoHYWRkcmVzcxIjQiEi4LGdJ8i6PfCQsJ1c8JCqmvCQprXgqZFuL+CviuCiplcKFgoJZGlyZWN0aW9uEglCB0luZ3Jlc3MKKAoEbmFtZRIgQh4/8J+FlDV4KuK4uE3wkJW9WXtwLuCzlvCRu658L3sKcboBbgoRCgZhY3Rpb24SB0IFQWxsb3cKMgoHYWRkcmVzcxInQiXwn5W0JDEm8J+pvC9a4LCz4q6K0agt0agmSDo94b2bOj/wkKmRChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzCg0KBG5hbWUSBUIDw40/Cma6AWMKEQoGYWN0aW9uEgdCBUFsbG93CicKB2FkZHJlc3MSHEIaaOCmkPCdkrXvv6PwkKC88JGYuGrhqKRtJE0KFgoJZGlyZWN0aW9uEglCB0luZ3Jlc3MKDQoEbmFtZRIFQgMnP2QKe7oBeAoRCgZhY3Rpb24SB0IFQWxsb3cKEwoHYWRkcmVzcxIIQgYn8Jy9g2sKFgoJZGlyZWN0aW9uEglCB0luZ3Jlc3MKNgoEbmFtZRIuQixOL1w9e++tuUp7Ik7wkYKde2DwnqSOVOCsvNGo8J6AgFvwn4OM8Juwqz3RqAqQAboBjAEKEQoGYWN0aW9uEgdCBUFsbG93Ch8KB2FkZHJlc3MSFEIS8J+VtOGOijrwkYS+J/CRjKB7ChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzCj4KBG5hbWUSNkI0UT/hm7Al8JGckiQuZlDispUlLyrIui7wm7CbXEA/L1lObibwnYS777i78JCjtPCQgZx6VQqvAboBqwEKEQoGYWN0aW9uEgdCBUFsbG93Ci8KB2FkZHJlc3MSJEIi4reb4Zy14LqJYGAmLnYnJlE/QfCeuLLgv5DRqC7wkYqgWQoWCglkaXJlY3Rpb24SCUIHSW5ncmVzcwpNCgRuYW1lEkVCQ0zwnrmfMDw/150lJSXwn5W04LqH4LasYOCmt/CQj4gzwqVz8J+VtOC7iMOvPfCQo69g4Kyz7KauXvCfiJMqY/CflbQKbboBagoRCgZhY3Rpb24SB0IFQWxsb3cKFQoHYWRkcmVzcxIKQgjvrL7wkpCdJAoWCglkaXJlY3Rpb24SCUIHSW5ncmVzcwomCgRuYW1lEh5CHMKlbjPwkZaw8JG0uvCQlrhI77+TPyVM8J6XqToKYroBXwoRCgZhY3Rpb24SB0IFQWxsb3cKIQoHYWRkcmVzcxIWQhTvqIPgv5gi8JCKivCdiIdg8J+VtAoWCglkaXJlY3Rpb24SCUIHSW5ncmVzcwoPCgRuYW1lEgdCBdGo77ePCqMBugGfAQoRCgZhY3Rpb24SB0IFQWxsb3cKLAoHYWRkcmVzcxIhQh/wkJaVRj0ke+Cyg9Gow5xU8Ja8gOCvlzpKbiQiPV14ChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzCkQKBG5hbWUSPEI6XPCSkbDIuuC+jmoq76yD8JarseK1h+GOuzZ04rWwPz7gtI5S8Jy8myY98JGNp/CRkZ7gpqrhpKUkPQpzugFwChEKBmFjdGlvbhIHQgVBbGxvdwohCgdhZGRyZXNzEhZCFDzqn5nwn4mi4Y2vYOK2vu+/vTMlChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzCiAKBG5hbWUSGEIWYCfwkKiF4Kma4KeHKfCQoILwnZWGLwqBAboBfgoRCgZhY3Rpb24SB0IFQWxsb3cKDQoHYWRkcmVzcxICQgAKFgoJZGlyZWN0aW9uEglCB0luZ3Jlc3MKQgoEbmFtZRI6QjjhnbLwkL+mdeK7ivCflbTIuip7V/CQppXhmqVd8JCtm92NIuGqhnPvv70qPyXCpW7wka+H8JGOjgqIAboBhAEKEQoGYWN0aW9uEgdCBUFsbG93CjYKB2FkZHJlc3MSK0Ip8J+hqPCQhIHwpZyJ4KCpJXQu77+jJuCpkfCdpZtSVzpgwqVKL/Cav7oKFgoJZGlyZWN0aW9uEglCB0luZ3Jlc3MKHwoEbmFtZRIXQhXitLfwnp+t8J+jgPCQrbpkZvCdnZIKeboBdgoRCgZhY3Rpb24SB0IFQWxsb3cKMwoHYWRkcmVzcxIoQibwkZq2e/CWvaDgpqxfLuqnlMOlP1xn8Jatt+OImMKyZS/OjOCviwoWCglkaXJlY3Rpb24SCUIHSW5ncmVzcwoUCgRuYW1lEgxCCiQ2yLp78J65mTkKa7oBaAoRCgZhY3Rpb24SB0IFQWxsb3cKEwoHYWRkcmVzcxIIQgZh0aguY3cKFgoJZGlyZWN0aW9uEglCB0luZ3Jlc3MKJgoEbmFtZRIeQhwk8Ja/pO+/vXcq8JCetuCsq3siK8O2QPCWubw0Co0BugGJAQoRCgZhY3Rpb24SB0IFQWxsb3cKQQoHYWRkcmVzcxI2QjTCpSQnROC3r+K1v/CfqpduJCfgtq9J6qyhV/CRpL7wkZuIfFBkS23vu4HRqPCQhpXgqJwsChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzChkKBG5hbWUSEUIP0ajwnYiGyLpDyLrwkICFCo4BugGKAQoRCgZhY3Rpb24SB0IFQWxsb3cKIwoHYWRkcmVzcxIYQhbhj7nwkKiVPdGoecOq4L6CwqXgvoVVChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzCjgKBG5hbWUSMEIuw77Iuio5UT82Sm8qJ/CTg4vDlycq8JG9iOqvsPCdgpNvJe+/qEE876yDfeK0pwqEAboBgAEKEQoGYWN0aW9uEgdCBUFsbG93CisKB2FkZHJlc3MSIEIe8J+VtDzDimrgqLbwnqWeJ/CQtat7w7HRqOCthFczChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzCiYKBG5hbWUSHkIcwqXwn4mkPTpg4aWA0ajwnribPUnwkZGeYCTRrwp8ugF5ChEKBmFjdGlvbhIHQgVBbGxvdwofCgdhZGRyZXNzEhRCEsi6yLrRqMK/Xy7wkYaeYCouTwoWCglkaXJlY3Rpb24SCUIHSW5ncmVzcworCgRuYW1lEiNCIT/wnrmR4K6HJCoy4Kmr8J+VtF3it4UqL+qgsvCRsIh2JQp/ugF8ChEKBmFjdGlvbhIHQgVBbGxvdwoYCgdhZGRyZXNzEg1CC9GoPu+8v/CcvaM/ChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzCjUKBG5hbWUSLUIrw6EqJMKlLsi6Li/RqPCQgr7wnoCmNvCdlJg6TGDhiZgq8JCeuWPwkbuyNAqdAboBmQEKEQoGYWN0aW9uEgdCBUFsbG93CiwKB2FkZHJlc3MSIUIf0ajwkK2E8JCOhUnDn1PwkJ2mYTzhiZs84KKK8JGEvAoWCglkaXJlY3Rpb24SCUIHSW5ncmVzcwo+CgRuYW1lEjZCNOOGpT3CsPCQqJNQ77+9Kifhq4MkYEkvOvCRq7DwkY+VSm/RqGdNw4jwkZqf8JCoj0deJGAKlgG6AZIBChEKBmFjdGlvbhIHQgVBbGxvdwovCgdhZGRyZXNzEiRCIm4lyLpgROCpgTxae8K/0ahjPyTwkY+J8JC/oSLwkY2sOmAKFgoJZGlyZWN0aW9uEglCB0luZ3Jlc3MKNAoEbmFtZRIsQirwkYOh4pGIYi8nItGoTVx376qnUmAmIvCQnZI94LOe8JGLiX5W0ahVJCkKigG6AYYBChEKBmFjdGlvbhIHQgVBbGxvdwpECgdhZGRyZXNzEjlCN+K9qlo96qyWQiIgIvCeuK0kJDw8PeGMlHvwkYWjZj1gOylBKvCQgLwk3qTwmr+7XPCQu4PCpTkKFgoJZGlyZWN0aW9uEglCB0luZ3Jlc3MKEwoEbmFtZRILQgkl8JGMjy/hvrgKjQG6AYkBChEKBmFjdGlvbhIHQgVBbGxvdwotCgdhZGRyZXNzEiJCIPCRjYty8JuFlfCfkLIvw5Fk8JGMgnVZQS57Uy7wka+5ChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzCi0KBG5hbWUSJUIjRcK6IibwnrmS8JCEgCBRJfCRtLzIul3wkpGyafCdl6/qpbcKeboBdgoRCgZhY3Rpb24SB0IFQWxsb3cKFQoHYWRkcmVzcxIKQghgJ/CRtIDDtAoWCglkaXJlY3Rpb24SCUIHSW5ncmVzcwoyCgRuYW1lEipCKEHwkLqL6qmCRCbwn5W0az9xMu+/vWBAPydkWCYqLibgq79T0ag6P3sKiAG6AYQBChEKBmFjdGlvbhIHQgVBbGxvdwoaCgdhZGRyZXNzEg9CDci6YC9Me8KpOmYhIlwKFgoJZGlyZWN0aW9uEglCB0luZ3Jlc3MKOwoEbmFtZRIzQjHhvJvvrbZ78JC8jUXXtD8qJMi6VuK1r2Rc8JGNjOC7gVzgqo/IuiTgs7Pwnp+re0IiCoIBugF/ChEKBmFjdGlvbhIHQgVBbGxvdwo/CgdhZGRyZXNzEjRCMvCbspFSXSTwn5W08JGNizzgroLIuvCav77hv4Ai4rS18J+VtEBlJ/Cxm4zwkJSh4rSnChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzChEKBG5hbWUSCUIH8JCNre+vtwqOAboBigEKEQoGYWN0aW9uEgdCBUFsbG93CkoKB2FkZHJlc3MSP0I9LSIs762B8Jq/sPCQrb1v8J2jkFxr8K+ktfCdlY4n4Ku7YTwqImjDpvCRl5ArXSp74aKFXPCRipswIsi6cAoWCglkaXJlY3Rpb24SCUIHSW5ncmVzcwoRCgRuYW1lEglCB9Goe2Dgs4gKeboBdgoRCgZhY3Rpb24SB0IFQWxsb3cKLwoHYWRkcmVzcxIkQiI8N/CWtYIySSIqwrHDv3t8evCehYVaajpx0ahceztKzoh0ChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzChgKBG5hbWUSEEIO77+88JK+uTMm8JGNl1gKnAG6AZgBChEKBmFjdGlvbhIHQgVBbGxvdwo3CgdhZGRyZXNzEixCKtGoOu+/vSLIuiLwnoWOJsO/KvCsnr43L2c6SeGdryPwkKuJyLoq4K2NPwoWCglkaXJlY3Rpb24SCUIHSW5ncmVzcwoyCgRuYW1lEipCKMi644KQdCI/77auL+GNpUbgq6kk6qWGYOG/uyLwnqKVeyJ4XCxwwq8KlgG6AZIBChEKBmFjdGlvbhIHQgVBbGxvdwooCgdhZGRyZXNzEh1CG/CQqLrhvZnvv70lLfCWv6M/8J+VtC4rPeG9mQoWCglkaXJlY3Rpb24SCUIHSW5ncmVzcwo7CgRuYW1lEjNCMT8vPdGo4Ki58J+VtCLDgSdsZGde8J+VtC57VfCSiok1UuC6sci68JGbo+CshyZuQj0KiQG6AYUBChEKBmFjdGlvbhIHQgVBbGxvdwohCgdhZGRyZXNzEhZCFMKl8JC1nvCeuZTgr5fwkIGJ4Y6CChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzCjUKBG5hbWUSLUIrLvCdhKIuazpmZCLDvWDgq6B7NDw98JCWtCQ84Z+l8JGqleCtiCzhvZZgYAqPAboBiwEKEQoGYWN0aW9uEgdCBUFsbG93CkQKB2FkZHJlc3MSOUI3eyLqoLFGRcO2S/CQgL0lJvCRjI/wkJW2w4vCpWom8JC2j/CRj5jjhbTwnrirbz9b0ah88JCWlQoWCglkaXJlY3Rpb24SCUIHSW5ncmVzcwoYCgRuYW1lEhBCDvCRjbJ7a/CRpLch4LudCpEBugGNAQoRCgZhY3Rpb24SB0IFQWxsb3cKHQoHYWRkcmVzcxISQhBg8J2qmz8uJeKDl1hOJDJYChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzCkEKBG5hbWUSOUI34LuG8JCnj++/vVU88J+VtOCuteCnqeC0jnvNuiXwloSi8JCSoOGdkXzwn4mD8JCnsfCeuZlcKgp8ugF5ChEKBmFjdGlvbhIHQgVBbGxvdwouCgdhZGRyZXNzEiNCIeCsglPwkJ2NOVpJPHjgu5w9w4nvt4Tvv73im6pbeuGOgwoWCglkaXJlY3Rpb24SCUIHSW5ncmVzcwocCgRuYW1lEhRCEk7Nv+G9jOGds3vwn5W04ai4QQqEAboBgAEKEQoGYWN0aW9uEgdCBUFsbG93CkMKB2FkZHJlc3MSOEI28JCnnUbhv7QneeCqquCxo/CRp6Ny4YuA77+94K6cPSYmJWwvR2JV8J+fsNGo4reF8J65jz4iChYKCWRpcmVjdGlvbhIJQgdJbmdyZXNzCg4KBG5hbWUSBkIE8JConA== +CmYKZLoBYQovChFkZXBsb3lfZ2VuZXJhdGlvbhIawgEXCgoWWUBgiFdklpCcEP///////////wEKGAoFZXBvY2gSD8IBDAoKFYUkF2Q1hlMJPAoUCgRraW5kEgxCCkZlbmNlVG9rZW4= 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 +CqkGCqYGugGiBgowCgNrZXkSKboBJgokCgJpZBIeugEbChkKBlN5c3RlbRIPwgEMCgpGcyiWISiEmAGcChIKBGtpbmQSCkIIRGF0YWJhc2UK2QUKBXZhbHVlEs8FugHLBQoKCgRuYW1lEgJCAAoSCgNvaWQSC8IBCAoGAUgxJoZMChQKCG93bmVyX2lkEghCBlB1YmxpYwqSBQoKcHJpdmlsZWdlcxKDBbIB/wQKdroBcwotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFFZDcgeVdgMoU8ChMKB2dyYW50ZWUSCEIGUHVibGljCi0KB2dyYW50b3ISIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCpd2NGhmeXF0MIwKc7oBcAotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFJJpghhIExlYBsChMKB2dyYW50ZWUSCEIGUHVibGljCioKB2dyYW50b3ISH7oBHAoaCgZTeXN0ZW0SEMIBDQoLATgBEiGHOHVXJGwKfboBegotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEIASNpVnV1QyV8ChMKB2dyYW50ZWUSCEIGUHVibGljCjQKB2dyYW50b3ISKboBJgokCgZTeXN0ZW0SGsIBFwoKFDKSSTJ4RYQ2TBD///////////8BCokBugGFAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwF2clZkJRA1ZCmcCikKB2dyYW50ZWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKNYJWRQMJNBgmHAopCgdncmFudG9yEh66ARsKGQoGU3lzdGVtEg/CAQwKCpETcgM3hAkneEwKhAG6AYABCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKMicFV3UlRTYmXAonCgdncmFudGVlEhy6ARkKFwoEVXNlchIPwgEMCgqFZiESQlKHgBlMCicKB2dyYW50b3ISHLoBGQoXCgRVc2VyEg/CAQwKCmETUnJEiEKUhyw= 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 +ClwKWroBVwolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBCEKXODdQSJc4LAoYCgVlcG9jaBIPwgEMCgoZNCEmNRcUUpQdChQKBGtpbmQSDEIKRmVuY2VUb2tlbg== +CvcCCvQCugHwAgrZAgoDa2V5EtECugHNAgrKAgoFZXZlbnQSwAK6AbwCCrkCCgJWMRKyAroBrgIKqwEKB2RldGFpbHMSnwG6AZsBCpgBCghTY2hlbWFWMRKLAboBhwEKHgoNZGF0YWJhc2VfbmFtZRINQgvhrq5cJe+/vWPOkwozCgJpZBItQitj4KyGNeCunvCeuZ3DsOCpjFxEJTk64ra7P/CflbQj4YON8J+VtHs94YC+CjAKBG5hbWUSKEImLsi6w6VpKuCth+C1ozwnyLrwkJOObnIvyKsk8JGSpcOS4oWOZyYKFAoKZXZlbnRfdHlwZRIGwgEDCgFsChUKAmlkEg/CAQwKClRUeQaQZngycxwKFQoLb2JqZWN0X3R5cGUSBsIBAwoBPAouCgtvY2N1cnJlZF9hdBIfugEcChoKBm1pbGxpcxIQwgENCgsBEDdWRnUCYkFmjAoKCgR1c2VyEgIIBAoSCgRraW5kEgpCCEF1ZGl0TG9n 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 +CrMBCrABugGsAQoaCgNrZXkSE7oBEAoOCgJpZBIIQgZQdWJsaWMKEgoEa2luZBIKQghSb2xlQXV0aAp6CgV2YWx1ZRJxugFuCj4KDXBhc3N3b3JkX2hhc2gSLUIr77+MYDXwn5W+TU7vuZ/DtiThtLhuJCTwkYyPOuGyvfCdkZ/wnric4LGWOgosCgp1cGRhdGVkX2F0Eh66ARsKGQoGbWlsbGlzEg/CAQwKCihpZSVZCIYRARw= +CqgBCqUBugGhAQovCgNrZXkSKLoBJQojCgJpZBIdugEaChgKBFVzZXISEMIBDQoLARgzJzSScicABjwKEgoEa2luZBIKQghSb2xlQXV0aApaCgV2YWx1ZRJRugFOChMKDXBhc3N3b3JkX2hhc2gSAggECjcKCnVwZGF0ZWRfYXQSKboBJgokCgZtaWxsaXMSGsIBFwoKBHAkUBFBhpE4LBD///////////8B +CokBCoYBugGCAQoaCgNrZXkSE7oBEAoOCgJpZBIIQgZQdWJsaWMKEgoEa2luZBIKQghSb2xlQXV0aApQCgV2YWx1ZRJHugFEChMKDXBhc3N3b3JkX2hhc2gSAggECi0KCnVwZGF0ZWRfYXQSH7oBHAoaCgZtaWxsaXMSEMIBDQoLAUVARjJGJyKIZmw= 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 +CpoBCpcBugGTAQokCgNrZXkSHboBGgoYCgRuYW1lEhBCDnUvXFJC4LqlfeKugDw6Ch0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgpMCgV2YWx1ZRJDugFACj4KBXZhbHVlEjVCM3vgr5c28JGTmCdgLlw/Rj3hvZdiPT1f4K2v4YuAWj3RqMOl4bCo8J2Uu+CnhHMk8J+VtA== +CmcKZboBYgoVCgRraW5kEg1CC1R4bldhbFNoYXJkCkkKBXZhbHVlEkC6AT0KOwoFc2hhcmQSMkIwJlHhvqXwn6uc8JColS0qJFXIuvCQlphQVeG+tljCpjrwkaSV8J+VtPCRjILgp4I8 +CtIBCs8BugHLAQp8CgNrZXkSdboBcgo7CgZvYmplY3QSMboBLgosCgZTb3VyY2USIroBHwodCglUcmFuc2llbnQSEMIBDQoLAQB2UCUylTBldVwKMwoNc3ViX2NvbXBvbmVudBIiugEfCh0KCUNvbHVtblBvcxIQwgENCgsBdTU3AwEHVlkQTAoRCgRraW5kEglCB0NvbW1lbnQKOAoFdmFsdWUSL7oBLAoqCgdjb21tZW50Eh9CHVLwmKqYReCxrzzwkbSiJU7gqZ4/YGRa8J65kcKl +Co4BCosBugGHAQpLCgNrZXkSRLoBQQo/CgNrZXkSOEI2VvCctpPwm7KHUvCRkojqp5dg8J+VtGjwkYCzKjLwnbyb8JGyseCmvSZY8JG2kW7wkb+h4LuDChAKBGtpbmQSCEIGQ29uZmlnCiYKBXZhbHVlEh26ARoKGAoFdmFsdWUSD8IBDAoKKZKCKBOVGQYUjA== +Co0BCooBugGGAQpKCgNrZXkSQ7oBQAo+CgNrZXkSN0I18J+VtFzgtrReXD1gViLwn4mQ8JCjtGTwkY2XPPCegIPvv71Qa+GHlPCfq5wnYGAvKvCToL4KEAoEa2luZBIIQgZDb25maWcKJgoFdmFsdWUSHboBGgoYCgV2YWx1ZRIPwgEMCgqUSTeFCWkRdZec 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 +CocBCoQBugGAAQpiCgNrZXkSW7oBWApWCgVzaGFyZBJNQkvwkZubJX7wkLaO8J+VtDol4K+IeyrhrIfwkYy/8JC8vT/wr6G08J66qDpY7621RuqiteC6kfCRtLx78J65lCdh8J2Vi/CRhYHgt5YKGgoEa2luZBISQhBVbmZpbmFsaXplZFNoYXJk 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 +Cq8BCqwBugGoAQo0CgNrZXkSLboBKgooCgJpZBIiugEfCh0KCVRyYW5zaWVudBIQwgENCgsBVTdGSDl0lXAzLAojCgRraW5kEhtCGVN0b3JhZ2VDb2xsZWN0aW9uTWV0YWRhdGEKSwoFdmFsdWUSQroBPwo9CgVzaGFyZBI0QjIl8JCOiPCfg4/wkIagw48t4rawJFzhqoXwnrm7wqXIulxu8Jq/s8Kl8J64g8KlwqVAPA== +CooBCocBugGDAQozCgNrZXkSLLoBKQonCgJpZBIhugEeChwKCVRyYW5zaWVudBIPwgEMCgpDRSQUB2lnYpccCiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQonCgV2YWx1ZRIeugEbChkKBXNoYXJkEhBCDuC3j/CfiJE3J+OEmT1u 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 +CqsBCqgBugGkAQpKCgNrZXkSQ7oBQAopCgdncmFudGVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCkiIY2BVKDFYmRwKEwoHZ3JhbnRvchIIQgZQdWJsaWMKGgoEa2luZBISQhBTeXN0ZW1Qcml2aWxlZ2VzCjoKBXZhbHVlEjG6AS4KLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgo4YIGYk4kxU5Yc +CqsBCqgBugGkAQovCgNrZXkSKLoBJQojCgJpZBIdugEaChgKBFVzZXISEMIBDQoLARNCF1hBIFQ4JmwKIwoEa2luZBIbQhlTdG9yYWdlQ29sbGVjdGlvbk1ldGFkYXRhCkwKBXZhbHVlEkO6AUAKPgoFc2hhcmQSNUIzOjzwnZOZ8J+VtHs/77+9Ki89wqXwn5W0PGXbpvCRr5hc4reSJsi6Q0NIP+K2vuKDnDxg +CrYBCrMBugGvAQo0CgNrZXkSLboBKgooCgJpZBIiugEfCh0KCVRyYW5zaWVudBIQwgENCgsBBQCIYZQ5GDhhjAojCgRraW5kEhtCGVN0b3JhZ2VDb2xsZWN0aW9uTWV0YWRhdGEKUgoFdmFsdWUSSboBRgpECgVzaGFyZBI7QjnIui/wkYeie/CQvL908JCWu/CQgJTwkaSj4aWA8J6fqFxFciLDoS7wkYyz6qyL4LeUIsKlPO+slSU= +CogBCoUBugGBAQpPCgNrZXkSSLoBRQpDCgRuYW1lEjtCOeC/guGjg0zIuiLgsZXgqZ7gprBvXFZC3pYvYC0hIzXgq5DwkK6b8JCoufCQkrzwkYuyWEwmMuqfkwoRCgRraW5kEglCB1NldHRpbmcKGwoFdmFsdWUSEroBDwoNCgV2YWx1ZRIEQgJgXA== +CmsKaboBZgosCgNrZXkSJboBIgogCgRuYW1lEhhCFkx58JGyryDwkJ6X4reNcjw9UeGPji4KEQoEa2luZBIJQgdTZXR0aW5nCiMKBXZhbHVlEhq6ARcKFQoFdmFsdWUSDEIK8JC7guqphzc9Ig== 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 +CnEKb7oBbApOCgNrZXkSR7oBRApCCgVzaGFyZBI5QjdBTuCyj/CehYXvv71YIOGDjVhrXO2fmSrwnZWG4LiFNiLwqaOVXC5s8Ja+h0s68Jq/uzrRqCpNChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== 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 +CqwECqkEugGlBAqOBAoDa2V5EoYEugGCBAr/AwoFZXZlbnQS9QO6AfEDCu4DCgJWMRLnA7oB4wMK4AIKB2RldGFpbHMS1AK6AdACCs0CChhDcmVhdGVNYXRlcmlhbGl6ZWRWaWV3VjESsAK6AawCCkkKCmNsdXN0ZXJfaWQSO0I5LzzIujBjP/CeuLlj77+98JGnl/CRm5nvv4Xvv71q4b67KWsn8J+VtCYlKvCRmIXRqHY6ImUj4LCLCjUKAmlkEi9CLcKlwqV7YOKugEZRJ/CeuanOiDzwkb+G77+94aCU4LC48J+VtPCQppRc4LGdIgp0CgRuYW1lEmy6AWkKMQoIZGF0YWJhc2USJUIj4Ka4PfCeuaQm8JatsT88e8KoOeCnnD3vv70zYCrhvp9cJGEKFwoEaXRlbRIPQg0mKlpLekHwkaC2T1o2ChsKBnNjaGVtYRIRQg/wn5W0wqVWY+CngvCflbQKMgoVcmVwbGFjZW1lbnRfdGFyZ2V0X2lkEhlCF8Kl8JGOi2U88J+VtPCflbR7bfCRjo5XChQKCmV2ZW50X3R5cGUSBsIBAwoBDAoVCgJpZBIPwgEMCgqZF1IEEzURMlI8ChUKC29iamVjdF90eXBlEgbCAQMKARwKLgoLb2NjdXJyZWRfYXQSH7oBHAoaCgZtaWxsaXMSEMIBDQoLATmAB3g1IhE2lkwKCgoEdXNlchICCAQKEgoEa2luZBIKQghBdWRpdExvZw== +CqYBCqMBugGfAQowCgNrZXkSKboBJgokCgJpZBIeugEbChkKBlN5c3RlbRIPwgEMCgpSEIFgZHBpVlc8CiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQpGCgV2YWx1ZRI9ugE6CjgKBXNoYXJkEi9CLVNW8JCgvOC9jC5D4Kiz8JG0iPCdqptuwqV7WfCeuaQl8JuxuzfIuiLgq4wiIg== +CrIBCq8BugGrAQo1CgNrZXkSLroBKwopCgRuYW1lEiFCH2IlXGfRqPCfm54/SiY/JiJBPfCdlK4kwrPirooqIiIKHQoEa2luZBIVQhNTZXJ2ZXJDb25maWd1cmF0aW9uClMKBXZhbHVlEkq6AUcKRQoFdmFsdWUSPEI64L+MJmDCtjrwkIKkIzpp4KiD4raDIiUvcT8mK9Go8JGPgsO877+94K6fbETCpfCen63wkbWn8J65pA== +Cv8BCvwBugH4AQqZAQoDa2V5EpEBugGNAQoRCgtkYXRhYmFzZV9pZBICCAQKJwoHZ3JhbnRlZRIcugEZChcKBFVzZXISD8IBDAoKklKUiINYJzJHTAoVCgtvYmplY3RfdHlwZRIGwgEDCgE8CicKB3JvbGVfaWQSHLoBGQoXCgRVc2VyEg/CAQwKCnQHUpk0GYAikSwKDwoJc2NoZW1hX2lkEgIIBAobCgRraW5kEhNCEURlZmF1bHRQcml2aWxlZ2VzCj0KBXZhbHVlEjS6ATEKLwoKcHJpdmlsZWdlcxIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEVYpF1ZVWYEVWc +ClwKWroBVwolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBJzYDVJZIERlFXAoYCgVlcG9jaBIPwgEMCgp3AWZGGBFWAIMtChQKBGtpbmQSDEIKRmVuY2VUb2tlbg== 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 +CooBCocBugGDAQpHCgNrZXkSQLoBPQo7CgNrZXkSNEIyKiRqcuCunFMxKuGKnCJjP/CQtZIucydyPfCegKTwn5+p4Ku8IyRc6qiAPfCeuKLhn7IKEAoEa2luZBIIQgZDb25maWcKJgoFdmFsdWUSHboBGgoYCgV2YWx1ZRIPwgEMCgowcxBhFlk1ciQs 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 +ClsKWboBVgokChFkZXBsb3lfZ2VuZXJhdGlvbhIPwgEMCgpXJ1VVSHOARFlcChgKBWVwb2NoEg/CAQwKCnFIMSZJaZaEUJ0KFAoEa2luZBIMQgpGZW5jZVRva2Vu +ClsKWboBVgokCgNrZXkSHboBGgoYCgRuYW1lEhBCDiVg8JG2ons9fsKlL8i6ChEKBGtpbmQSCUIHU2V0dGluZwobCgV2YWx1ZRISugEPCg0KBXZhbHVlEgRCAsi6 +CogCCoUCugGBAgqiAQoDa2V5EpoBugGWAQoRCgtkYXRhYmFzZV9pZBICCAQKLgoHZ3JhbnRlZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAVETZSCWBIlXVSwKFQoLb2JqZWN0X3R5cGUSBsIBAwoBHAopCgdyb2xlX2lkEh66ARsKGQoGU3lzdGVtEg/CAQwKCkA0ggBSl2SVgYwKDwoJc2NoZW1hX2lkEgIIBAobCgRraW5kEhNCEURlZmF1bHRQcml2aWxlZ2VzCj0KBXZhbHVlEjS6ATEKLwoKcHJpdmlsZWdlcxIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFkUBA3VwV4E1l8 +Ct8CCtwCugHYAgqoAQoDa2V5EqABugGcAQpBCgtvYmplY3RfbmFtZRIyQjAuOj3wnrmi8Jq/sEA64LuDPScn4b+teyTwkZC0LS4nYDLitLIpWPCegIYvXe+/vSMKFQoLb2JqZWN0X3R5cGUSBsIBAwoBXApACgtzY2hlbWFfbmFtZRIxQi/wkIaZTFPhjJQvaUwvLPCQqIZgLiY9KiYn8JCrsCUnJvCbiZlr4YmsLnnqoIE9cAoUCgRraW5kEgxCCkdpZE1hcHBpbmcKlAEKBXZhbHVlEooBugGGAQoeCgpjYXRhbG9nX2lkEhDCAQ0KCwFCETQgBkB5KGeMCkUKC2ZpbmdlcnByaW50EjZCNPCRjo4uP+CpkeCvulBAPT17YOGDje2fq/CflbQ+KPCek5/wkY2EOvCflbQn1YDhvok6YHUKHQoJZ2xvYmFsX2lkEhDCAQ0KCwEzYYmAVARnBIBc +CqsBCqgBugGkAQpGCgNrZXkSP7oBPAo6CgRuYW1lEjJCMPCQgLzwkY6VTipo6qinROCxnTw38Ja9tyUq8JGShFwl4Yu+cVx4Rci6UXs04amtPwoRCgRraW5kEglCB1NldHRpbmcKRwoFdmFsdWUSProBOwo5CgV2YWx1ZRIwQi5uYydHflhnP+GKtfCTgorwkLyXYCZqJSXgq4klIjLhi4PwloSI6qusOiTwkLqw +ClwKWroBVwolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBZwB2VnWEWEcEnAoYCgVlcG9jaBIPwgEMCgpSAnKIJQdgRnVtChQKBGtpbmQSDEIKRmVuY2VUb2tlbg== +Cn4KfLoBeQo6CgNrZXkSM7oBMAouCgRuYW1lEiZCJGgy7Z+EJTY8YCLwn4iC8KWwqC888J+VtOCmvvCRq4s/JS8lMAoRCgRraW5kEglCB0lkQWxsb2MKKAoFdmFsdWUSH7oBHAoaCgduZXh0X2lkEg/CAQwKCpSZMVEiMkY0Ahw= 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 +Cu8BCuwBugHoAQqJAQoDa2V5EoEBugF+ChEKC2RhdGFiYXNlX2lkEgIIBAosCgdncmFudGVlEiG6AR4KHAoKUHJlZGVmaW5lZBIOwgELCglneCiJmJdikEwKFQoLb2JqZWN0X3R5cGUSBsIBAwoBPAoTCgdyb2xlX2lkEghCBlB1YmxpYwoPCglzY2hlbWFfaWQSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKPQoFdmFsdWUSNLoBMQovCgpwcml2aWxlZ2VzEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAVWVYTUXRnZygow= +Cr0BCroBugG2AQpcCgNrZXkSVboBUgonCgdncmFudGVlEhy6ARkKFwoEVXNlchIPwgEMCgpoloAnF1AVWFh8CicKB2dyYW50b3ISHLoBGQoXCgRVc2VyEg/CAQwKCohGM1RTeXFAhVwKGgoEa2luZBISQhBTeXN0ZW1Qcml2aWxlZ2VzCjoKBXZhbHVlEjG6AS4KLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoDcokAgBEkCDJM +CtIDCs8DugHLAwovCgNrZXkSKLoBJQojCgJpZBIdugEaChgKBFVzZXISEMIBDQoLAWl0MGEjFhQ3EWwKGAoEa2luZBIQQg5DbHVzdGVyUmVwbGljYQr9AgoFdmFsdWUS8wK6Ae8CCi0KCmNsdXN0ZXJfaWQSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAYJJVCmJCFAAYkwK+QEKBmNvbmZpZxLuAboB6gEKhAEKCGxvY2F0aW9uEni6AXUKcwoHTWFuYWdlZBJougFlChcKEWF2YWlsYWJpbGl0eV96b25lEgIIBAoPCgliaWxsZWRfYXMSAggECg4KCGludGVybmFsEgIIAgoNCgdwZW5kaW5nEgIIAwoaCgRzaXplEhJCEPCQloJx4KizL/Cfg4bvv70KYQoHbG9nZ2luZxJWugFTCj4KCGludGVydmFsEjK6AS8KFAoFbmFub3MSC8IBCAoGAwNgSSJ8ChcKBHNlY3MSD8IBDAoKVwGGl3dkECSHTAoRCgtsb2dfbG9nZ2luZxICCAIKGAoEbmFtZRIQQg4nwrHCpXZ+4Lax4r2sKgooCghvd25lcl9pZBIcugEZChcKBFVzZXISD8IBDAoKkplHhVQZBXRRTA== +CsALCr0LugG5CwouCgNrZXkSJ7oBJAoiCgJpZBIcugEZChcKBFVzZXISD8IBDAoKl1iQNUZwhiczTAocCgRraW5kEhRCEkNsdXN0ZXJSZXBsaWNhU2l6ZQroCgoFdmFsdWUS3gq6AdoKCg0KB2J1aWx0aW4SAggDChMKDWNwdV9leGNsdXNpdmUSAggCChwKCWNwdV9saW1pdBIPwgEMCgoygClgQDcTI4g8ChEKC2NwdV9yZXF1ZXN0EgIIBAosChBjcmVkaXRzX3Blcl9ob3VyEhhCFvCeuYfIunvwn5W0IvCQlYcp8JCUiiQKDgoIZGlzYWJsZWQSAggCCh4KCmRpc2tfbGltaXQSEMIBDQoLATCJCFCUNzQgcBwKCwoFaXNfY2MSAggDCh8KDG1lbW9yeV9saW1pdBIPwgEMCgqYBgdgFliDVicsCiEKDm1lbW9yeV9yZXF1ZXN0Eg/CAQwKCldpMEeGNEWTc4wKLAoEbmFtZRIkQiIl8J6Klm3IuiTgrZzwnYul8K+jlEc88JuyhXvgs53hpqskChwKBXNjYWxlEhPCARAKAwSFTBD///////////8BCswHCglzZWxlY3RvcnMSvge6AboHChUKAyI/YBIOQgzwn6GRXEjwn5+wUCUKSgoIJfCflbQlWWASPkI877+9L2Pwk4SAQSdW8JCWmuGztT/wkL2x77+9PPCehLfwn5W0QO+/vSbwkKey8JGMqGAs4L+S0ahFWHc6CkQKLiY9J/CRmobvv73wkY2XLyJQJ/CdmoU8766J4KWl8JGkieqdgivRqEvCpXjgu5ESEkIQ4LGWeFg8UVrwnrqO77ePZwpSChwnYD0677+p8J2UmvCdlIjgrqpaLjoiw4cnM2knEjJCMHFA4K2HJlp8JSfitoUqYCfgqZ7wnrii4Y+48JGPl/CRjZdFJvCQoIguQfCflbQndgpGCisu4reC8Ja+hvCfgqEiPXlBacKnw4Z1JyHCpfCflbTgrIMo8JCHlzDhrYIuEhdCFSXwnZyAPCZgYC/guoTRqHtnKuGdoAojCgwu8J+irFxf8J65tzwSE0IRJuODgfCQnZHwlqm077+9Oj0KaQobPMOo4LOM4aS5TfCflbTwn4miOkbguZnCpTpFEkpCSPCeub5c4K+X77+94b2K8JGkuMOw4b2ZLuGJmiLwnZOBwqXgq6nwm7Gz8JCLo/Cfgqvvv706w53wm4WV4YuA8Ji0gDrwkIGAMApHCio/8JGPkmAqIF1c77iIwq9t8J6frSXvv4fMgOCupCfgrIIi8J2VhvCegIYSGUIX8J+otFbigIZb6qyD4LOi8JGRoEJlIiQKIwoIT2zRqPCdi6oSF0IV8JGmpSUqMdGo4K+sfCxU8J67sDN7Ck0KE1/gqrM8VEbvt49pL3vguJd30agSNkI08J+AnPCQto7RqOK0uyI98JCQp+GKilDwnoWD8JCphted8JGCvnsmItGodfCWrbU24am2PwpWCkXwkKGV4YSg77+9XMi6JnvwkJa0Kjrhq47vrIPCpe+/vTfCr/CQlq3wn6uYQci6b1DDpDHwkJeb8JCiqSrIuuCmj/CQjoASDUILPzrwkbaU8JGLtEIKbQo48J2SpVLgrYskIuG+n/CQi7Lwm4Sy8J+VtCTwmLSI8JCGjmBrOeCvh/CQgpngsoo/Oig8yLprw7ASMUIvLkYn8J2RkPCWv6Lcl86M8JCksyrgsrwv8Jq/vWwuPSYrL/CQnaLwkaio77+9NCcKXwoy8J+hkeCosjpcJD8g4KyQOifvv73CpfCfq6JcJFwuOjLwkbaX8J2SpXssPO+/vfCQgLESKUInQUIlLvCflbTwn5W04LaJIu+tg1VcKfCQrq3wkLm78J+rlSTwkYyBChIKDHN3YXBfZW5hYmxlZBICCAMKJQoHd29ya2VycxIawgEXCgoJUGICWUiHiBl8EP///////////wE= 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 +CuIBCt8BugHbAQp2CgNrZXkSb7oBbAo0CgdncmFudGVlEim6ASYKJAoGU3lzdGVtEhrCARcKChNgIEBxREQ5iGwQ////////////AQo0CgdncmFudG9yEim6ASYKJAoGU3lzdGVtEhrCARcKCglXl4KRU1VkcnwQ////////////AQoaCgRraW5kEhJCEFN5c3RlbVByaXZpbGVnZXMKRQoFdmFsdWUSPLoBOQo3CghhY2xfbW9kZRIrugEoCiYKCGJpdGZsYWdzEhrCARcKChB3aTAwGCIRZHwQ////////////AQ== +CsYCCsMCugG/Agq4AQoDa2V5ErABugGsAQpOCgtvYmplY3RfbmFtZRI/Qj3wkKiF77+9KvCQoIQmP8Kl8J+VtD09JeGKp0Y84L+S8J6ApOqgkvCflbTwn5yPOPCRsIMlL/CQlrck4KijChUKC29iamVjdF90eXBlEgbCAQMKAVwKQwoLc2NoZW1hX25hbWUSNEIyUcOGP1p3Lmcv8JCkky068JGrlfCWq5fwloScJHTDkCbwn5W04Y6/KnFcbvCcsqbgprgKFAoEa2luZBIMQgpHaWRNYXBwaW5nCmwKBXZhbHVlEmO6AWAKHQoKY2F0YWxvZ19pZBIPwgEMCgqECUSWcoeCUlVMCiEKC2ZpbmdlcnByaW50EhJCECrRqD9n8JGQtD0uXFTgv4AKHAoJZ2xvYmFsX2lkEg/CAQwKClVHhJJYJIhgJTw= +ClsKWboBVgokChFkZXBsb3lfZ2VuZXJhdGlvbhIPwgEMCgoBUDGTKRYQQTVsChgKBWVwb2NoEg/CAQwKCiMRCYMFOWVBZC0KFAoEa2luZBIMQgpGZW5jZVRva2Vu +CrQBCrEBugGtAQpICgNrZXkSQboBPgoTCgdncmFudGVlEghCBlB1YmxpYwonCgdncmFudG9yEhy6ARkKFwoEVXNlchIPwgEMCgqXNBhnmXRTAEl8ChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwpFCgV2YWx1ZRI8ugE5CjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKEnQAAYiFFUKQjBD///////////8B +CpwCCpkCugGVAgq3AQoDa2V5Eq8BugGrAQorCgtkYXRhYmFzZV9pZBIcugEZChcKBFVzZXISD8IBDAoKVkgFaVIZdGdDnAopCgdncmFudGVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCkmXQpd1KDSYAXwKFgoLb2JqZWN0X3R5cGUSB8IBBAoCAVwKKAoHcm9sZV9pZBIdugEaChgKBFVzZXISEMIBDQoLAUmZeSYwdSQkkSwKDwoJc2NoZW1hX2lkEgIIBAobCgRraW5kEhNCEURlZmF1bHRQcml2aWxlZ2VzCjwKBXZhbHVlEjO6ATAKLgoKcHJpdmlsZWdlcxIgugEdChsKCGJpdGZsYWdzEg/CAQwKCjhocwgAEBJ4J4w= +CqUCCqICugGeAgrAAQoDa2V5ErgBugG0AQoRCgtkYXRhYmFzZV9pZBICCAQKNAoHZ3JhbnRlZRIpugEmCiQKBlN5c3RlbRIawgEXCgoXOZUCgHORgRZcEP///////////wEKFQoLb2JqZWN0X3R5cGUSBsIBAwoBbAonCgdyb2xlX2lkEhy6ARkKFwoEVXNlchIPwgEMCgoxQDgQiCKWISeMCikKCXNjaGVtYV9pZBIcugEZChcKBFVzZXISD8IBDAoKYWWRlkNJgygYfAobCgRraW5kEhNCEURlZmF1bHRQcml2aWxlZ2VzCjwKBXZhbHVlEjO6ATAKLgoKcHJpdmlsZWdlcxIgugEdChsKCGJpdGZsYWdzEg/CAQwKCoAmN2kSaJiCOHw= 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 +CsUCCsICugG+AgqQAQoDa2V5EogBugGEAQolCgtvYmplY3RfbmFtZRIWQhQqQzLDkiXWjiB7fPCeuZ3wnam/PAoVCgtvYmplY3RfdHlwZRIGwgEDCgFcCkQKC3NjaGVtYV9uYW1lEjVCMzghODrhp5rhnr/wn5W06qKryLrRqCMma0NLRjzwkKKq8J6Fj0/gt5PDuTwqe1nwkLObfQoUCgRraW5kEgxCCkdpZE1hcHBpbmcKkgEKBXZhbHVlEogBugGEAQodCgpjYXRhbG9nX2lkEg/CAQwKCgIHhQE3dZCVFSwKRQoLZmluZ2VycHJpbnQSNkI0S8Kleycl77+9yLrvt4/gqpYiKSQq8J+VtOCvkHHwnZGn77+9JS8sXHjgrZxO4aqWKuG/vAocCglnbG9iYWxfaWQSD8IBDAoKgXEGlmQSgSNYbA== diff --git a/src/catalog/src/durable/upgrade/v81_to_v82.rs b/src/catalog/src/durable/upgrade/v81_to_v82.rs new file mode 100644 index 0000000000000..1cf05b9b9a469 --- /dev/null +++ b/src/catalog/src/durable/upgrade/v81_to_v82.rs @@ -0,0 +1,58 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +use crate::durable::upgrade::MigrationAction; +use crate::durable::upgrade::objects_v81 as v81; +use crate::durable::upgrade::objects_v82 as v82; + +/// Migration that introduces the `ClusterReplicaSize` durable object type +/// and its two ID allocators (`user_cluster_replica_size` and +/// `system_cluster_replica_size`). The allocators are required for +/// `Transaction::insert_cluster_replica_size` to allocate fresh IDs; +/// catalogs upgraded from v81 must have these allocator entries inserted. +pub fn upgrade( + snapshot: Vec, +) -> Vec> { + // Check whether the allocator entries are already present (defensive: should + // never happen for a fresh v81 catalog, but guards against double-migration). + let user_alloc_present = snapshot.iter().any(|update| match update { + v81::StateUpdateKind::IdAlloc(alloc) => alloc.key.name == "user_cluster_replica_size", + _ => false, + }); + let system_alloc_present = snapshot.iter().any(|update| match update { + v81::StateUpdateKind::IdAlloc(alloc) => alloc.key.name == "system_cluster_replica_size", + _ => false, + }); + + let mut actions = Vec::new(); + + if !user_alloc_present { + actions.push(MigrationAction::Insert(v82::StateUpdateKind::IdAlloc( + v82::IdAlloc { + key: v82::IdAllocKey { + name: "user_cluster_replica_size".to_string(), + }, + value: v82::IdAllocValue { next_id: 1 }, + }, + ))); + } + + if !system_alloc_present { + actions.push(MigrationAction::Insert(v82::StateUpdateKind::IdAlloc( + v82::IdAlloc { + key: v82::IdAllocKey { + name: "system_cluster_replica_size".to_string(), + }, + value: v82::IdAllocValue { next_id: 1 }, + }, + ))); + } + + actions +} diff --git a/src/catalog/src/memory/error.rs b/src/catalog/src/memory/error.rs index 34203c0b5064c..b4512eeb8cdd6 100644 --- a/src/catalog/src/memory/error.rs +++ b/src/catalog/src/memory/error.rs @@ -43,6 +43,10 @@ pub enum ErrorKind { ReservedNetworkPolicyName(String), #[error("system network policy '{0}' cannot be modified")] ReadOnlyNetworkPolicy(String), + #[error("cannot drop cluster replica size '{}' because it is in use by an existing replica", .0)] + ClusterReplicaSizeInUse(String), + #[error("cannot drop builtin cluster replica size '{}'", .0)] + ReadOnlyClusterReplicaSize(String), #[error("replica name {} is reserved", .0.quoted())] ReservedReplicaName(String), #[error("system cluster '{0}' cannot be modified")] diff --git a/src/catalog/src/memory/objects.rs b/src/catalog/src/memory/objects.rs index 195e2532f2184..5d32b7a369365 100644 --- a/src/catalog/src/memory/objects.rs +++ b/src/catalog/src/memory/objects.rs @@ -3705,6 +3705,7 @@ pub enum StateUpdateKind { SystemConfiguration(durable::objects::SystemConfiguration), Cluster(durable::objects::Cluster), NetworkPolicy(durable::objects::NetworkPolicy), + ClusterReplicaSize(durable::objects::ClusterReplicaSize), IntrospectionSourceIndex(durable::objects::IntrospectionSourceIndex), ClusterReplica(durable::objects::ClusterReplica), SourceReferences(durable::objects::SourceReferences), @@ -3801,6 +3802,7 @@ pub enum BootstrapStateUpdateKind { SystemConfiguration(durable::objects::SystemConfiguration), Cluster(durable::objects::Cluster), NetworkPolicy(durable::objects::NetworkPolicy), + ClusterReplicaSize(durable::objects::ClusterReplicaSize), IntrospectionSourceIndex(durable::objects::IntrospectionSourceIndex), ClusterReplica(durable::objects::ClusterReplica), SourceReferences(durable::objects::SourceReferences), @@ -3834,6 +3836,9 @@ impl From for StateUpdateKind { } BootstrapStateUpdateKind::Cluster(kind) => StateUpdateKind::Cluster(kind), BootstrapStateUpdateKind::NetworkPolicy(kind) => StateUpdateKind::NetworkPolicy(kind), + BootstrapStateUpdateKind::ClusterReplicaSize(kind) => { + StateUpdateKind::ClusterReplicaSize(kind) + } BootstrapStateUpdateKind::IntrospectionSourceIndex(kind) => { StateUpdateKind::IntrospectionSourceIndex(kind) } @@ -3876,6 +3881,9 @@ impl TryFrom for BootstrapStateUpdateKind { StateUpdateKind::NetworkPolicy(kind) => { Ok(BootstrapStateUpdateKind::NetworkPolicy(kind)) } + StateUpdateKind::ClusterReplicaSize(kind) => { + Ok(BootstrapStateUpdateKind::ClusterReplicaSize(kind)) + } StateUpdateKind::IntrospectionSourceIndex(kind) => { Ok(BootstrapStateUpdateKind::IntrospectionSourceIndex(kind)) } diff --git a/src/catalog/tests/debug.rs b/src/catalog/tests/debug.rs index d773b9125cdcc..214fc05aa8fc8 100644 --- a/src/catalog/tests/debug.rs +++ b/src/catalog/tests/debug.rs @@ -92,6 +92,7 @@ impl Debug for StableTrace<'_> { clusters, introspection_sources, cluster_replicas, + cluster_replica_sizes, comments, configs, databases, @@ -136,6 +137,7 @@ impl Debug for StableTrace<'_> { .field("clusters", clusters) .field("introspection_sources", introspection_sources) .field("cluster_replicas", cluster_replicas) + .field("cluster_replica_sizes", cluster_replica_sizes) .field("comments", comments) .field("configs", &configs) .field("databases", databases) diff --git a/src/catalog/tests/open.rs b/src/catalog/tests/open.rs index f8c739e2505e5..1b2ffc5d76061 100644 --- a/src/catalog/tests/open.rs +++ b/src/catalog/tests/open.rs @@ -87,6 +87,7 @@ impl Debug for StableSnapshot<'_> { comments, clusters, network_policies, + cluster_replica_sizes, cluster_replicas, introspection_sources, id_allocator, @@ -117,6 +118,7 @@ impl Debug for StableSnapshot<'_> { .field("clusters", clusters) .field("network_policies", network_policies) .field("cluster_replicas", cluster_replicas) + .field("cluster_replica_sizes", cluster_replica_sizes) .field("introspection_sources", introspection_sources) .field("id_allocator", id_allocator) .field("configs", &configs) diff --git a/src/catalog/tests/snapshots/debug__opened_trace.snap b/src/catalog/tests/snapshots/debug__opened_trace.snap index 0d9d3df9296bb..34392549cf83c 100644 --- a/src/catalog/tests/snapshots/debug__opened_trace.snap +++ b/src/catalog/tests/snapshots/debug__opened_trace.snap @@ -507,6 +507,9 @@ Trace { ), ], }, + cluster_replica_sizes: CollectionTrace { + values: [], + }, comments: CollectionTrace { values: [], }, @@ -775,6 +778,20 @@ Trace { 1, ), ), + ( + ( + IdAllocKey { + name: "system_cluster_replica_size", + }, + IdAllocValue { + next_id: 1, + }, + ), + 2, + Overflowing( + 1, + ), + ), ( ( IdAllocKey { @@ -817,6 +834,20 @@ Trace { 1, ), ), + ( + ( + IdAllocKey { + name: "user_cluster_replica_size", + }, + IdAllocValue { + next_id: 1, + }, + ), + 2, + Overflowing( + 1, + ), + ), ( ( IdAllocKey { diff --git a/src/catalog/tests/snapshots/open__initial_snapshot.snap b/src/catalog/tests/snapshots/open__initial_snapshot.snap index f7ba089b9a52c..5269933938e73 100644 --- a/src/catalog/tests/snapshots/open__initial_snapshot.snap +++ b/src/catalog/tests/snapshots/open__initial_snapshot.snap @@ -677,6 +677,7 @@ Snapshot { ), }, }, + cluster_replica_sizes: {}, introspection_sources: {}, id_allocator: { IdAllocKey { @@ -714,6 +715,11 @@ Snapshot { }: IdAllocValue { next_id: 1, }, + IdAllocKey { + name: "system_cluster_replica_size", + }: IdAllocValue { + next_id: 1, + }, IdAllocKey { name: "system_compute", }: IdAllocValue { @@ -729,6 +735,11 @@ Snapshot { }: IdAllocValue { next_id: 1, }, + IdAllocKey { + name: "user_cluster_replica_size", + }: IdAllocValue { + next_id: 1, + }, IdAllocKey { name: "user_compute", }: IdAllocValue { diff --git a/src/environmentd/src/http/sql.rs b/src/environmentd/src/http/sql.rs index b46b58a1a4485..4dd658a1706dd 100644 --- a/src/environmentd/src/http/sql.rs +++ b/src/environmentd/src/http/sql.rs @@ -1493,6 +1493,8 @@ async fn execute_stmt( | ExecuteResponse::CreatedContinualTask { .. } | ExecuteResponse::CreatedType | ExecuteResponse::CreatedNetworkPolicy + | ExecuteResponse::CreatedClusterReplicaSize + | ExecuteResponse::DroppedClusterReplicaSize | ExecuteResponse::Comment | ExecuteResponse::Deleted(_) | ExecuteResponse::DiscardedTemp diff --git a/src/pgrepr-consts/src/oid.rs b/src/pgrepr-consts/src/oid.rs index f80b943f98b69..ada612a95a5b3 100644 --- a/src/pgrepr-consts/src/oid.rs +++ b/src/pgrepr-consts/src/oid.rs @@ -792,3 +792,4 @@ pub const VIEW_MZ_MCP_DATA_PRODUCT_DETAILS_OID: u32 = 17071; pub const VIEW_MZ_BUILTIN_MATERIALIZED_VIEWS_OID: u32 = 17072; pub const FUNC_PARSE_CATALOG_CREATE_SQL_OID: u32 = 17073; pub const FUNC_REDACT_SQL_OID: u32 = 17074; +pub const TABLE_MZ_CLUSTER_REPLICA_SIZE_DETAILS_OID: u32 = 17075; diff --git a/src/pgwire/src/protocol.rs b/src/pgwire/src/protocol.rs index 000282df247cb..186c637baa962 100644 --- a/src/pgwire/src/protocol.rs +++ b/src/pgwire/src/protocol.rs @@ -2283,6 +2283,8 @@ where | ExecuteResponse::CreatedView { .. } | ExecuteResponse::CreatedViews { .. } | ExecuteResponse::CreatedNetworkPolicy + | ExecuteResponse::CreatedClusterReplicaSize + | ExecuteResponse::DroppedClusterReplicaSize | ExecuteResponse::Comment | ExecuteResponse::Deallocate { .. } | ExecuteResponse::Deleted(..) diff --git a/src/repr/src/cluster_replica_size_id.rs b/src/repr/src/cluster_replica_size_id.rs new file mode 100644 index 0000000000000..dd83c7019a86b --- /dev/null +++ b/src/repr/src/cluster_replica_size_id.rs @@ -0,0 +1,108 @@ +// 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 std::fmt; +use std::str::FromStr; + +use anyhow::{Error, anyhow}; +use mz_lowertest::MzReflect; +use proptest_derive::Arbitrary; +use serde::{Deserialize, Serialize}; + +const SYSTEM_CHAR: char = 's'; +const USER_CHAR: char = 'u'; + +/// The identifier for a cluster replica size. +#[derive( + Arbitrary, + Clone, + Copy, + Debug, + Eq, + PartialEq, + Ord, + PartialOrd, + Hash, + Serialize, + Deserialize, + MzReflect +)] +pub enum ClusterReplicaSizeId { + System(u64), + User(u64), +} + +impl ClusterReplicaSizeId { + pub fn is_system(&self) -> bool { + matches!(self, Self::System(_)) + } + + pub fn is_user(&self) -> bool { + matches!(self, Self::User(_)) + } + + pub fn is_builtin(&self) -> bool { + self.is_system() + } +} + +impl FromStr for ClusterReplicaSizeId { + type Err = Error; + + fn from_str(s: &str) -> Result { + fn parse_u64(s: &str) -> Result { + if s.len() < 2 { + return Err(anyhow!("couldn't parse cluster replica size id '{s}'")); + } + s[1..] + .parse() + .map_err(|_| anyhow!("couldn't parse cluster replica size id '{s}'")) + } + + match s.chars().next() { + Some(SYSTEM_CHAR) => { + let val = parse_u64(s)?; + Ok(Self::System(val)) + } + Some(USER_CHAR) => { + let val = parse_u64(s)?; + Ok(Self::User(val)) + } + _ => Err(anyhow!("couldn't parse cluster replica size id '{s}'")), + } + } +} + +impl fmt::Display for ClusterReplicaSizeId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + Self::System(id) => write!(f, "{SYSTEM_CHAR}{id}"), + Self::User(id) => write!(f, "{USER_CHAR}{id}"), + } + } +} + +#[mz_ore::test] +fn test_cluster_replica_size_id_parsing() { + let s = "s42"; + let id: ClusterReplicaSizeId = s.parse().unwrap(); + assert_eq!(ClusterReplicaSizeId::System(42), id); + assert_eq!(s, id.to_string()); + + let s = "u666"; + let id: ClusterReplicaSizeId = s.parse().unwrap(); + assert_eq!(ClusterReplicaSizeId::User(666), id); + assert_eq!(s, id.to_string()); + + let s = "d23"; + mz_ore::assert_err!(s.parse::()); + + let s = ""; + mz_ore::assert_err!(s.parse::()); +} diff --git a/src/repr/src/lib.rs b/src/repr/src/lib.rs index 3ad159243e42a..9086245e40bc9 100644 --- a/src/repr/src/lib.rs +++ b/src/repr/src/lib.rs @@ -34,6 +34,7 @@ mod scalar; pub mod adt; pub mod bytes; pub mod catalog_item_id; +pub mod cluster_replica_size_id; pub mod explain; pub mod fixed_length; pub mod global_id; diff --git a/src/sql-lexer/src/keywords.txt b/src/sql-lexer/src/keywords.txt index e1aac2a6eb128..2696b3cec4da0 100644 --- a/src/sql-lexer/src/keywords.txt +++ b/src/sql-lexer/src/keywords.txt @@ -78,6 +78,7 @@ Cascade Case Cast Catalog +Cc Certificate Chain Chains @@ -120,6 +121,7 @@ Createnetworkpolicy Createrole Creation Credential +Credits Cross Cse Csv @@ -148,6 +150,7 @@ Delta Desc Details Direction +Disabled Discard Disk Distinct @@ -159,6 +162,7 @@ Eager Element Else Enable +Enabled End Endpoint Enforced @@ -171,6 +175,7 @@ Estimate Every Except Exclude +Exclusive Execute Exists Expected @@ -344,6 +349,7 @@ Partitions Password Path Pattern +Per Physical Plan Plans @@ -427,6 +433,7 @@ Secrets Security Seed Select +Selectors Sequences Serializable Server diff --git a/src/sql-parser/src/ast/defs/statement.rs b/src/sql-parser/src/ast/defs/statement.rs index a4721a7a2d5c1..172b5c7bb4038 100644 --- a/src/sql-parser/src/ast/defs/statement.rs +++ b/src/sql-parser/src/ast/defs/statement.rs @@ -63,6 +63,7 @@ pub enum Statement { CreateRole(CreateRoleStatement), CreateCluster(CreateClusterStatement), CreateClusterReplica(CreateClusterReplicaStatement), + CreateClusterReplicaSize(CreateClusterReplicaSizeStatement), CreateSecret(CreateSecretStatement), CreateNetworkPolicy(CreateNetworkPolicyStatement), AlterCluster(AlterClusterStatement), @@ -86,6 +87,7 @@ pub enum Statement { Discard(DiscardStatement), DropObjects(DropObjectsStatement), DropOwned(DropOwnedStatement), + DropClusterReplicaSize(DropClusterReplicaSizeStatement), SetVariable(SetVariableStatement), ResetVariable(ResetVariableStatement), Show(ShowStatement), @@ -143,6 +145,7 @@ impl AstDisplay for Statement { Statement::CreateType(stmt) => f.write_node(stmt), Statement::CreateCluster(stmt) => f.write_node(stmt), Statement::CreateClusterReplica(stmt) => f.write_node(stmt), + Statement::CreateClusterReplicaSize(stmt) => f.write_node(stmt), Statement::CreateNetworkPolicy(stmt) => f.write_node(stmt), Statement::AlterCluster(stmt) => f.write_node(stmt), Statement::AlterNetworkPolicy(stmt) => f.write_node(stmt), @@ -165,6 +168,7 @@ impl AstDisplay for Statement { Statement::Discard(stmt) => f.write_node(stmt), Statement::DropObjects(stmt) => f.write_node(stmt), Statement::DropOwned(stmt) => f.write_node(stmt), + Statement::DropClusterReplicaSize(stmt) => f.write_node(stmt), Statement::SetVariable(stmt) => f.write_node(stmt), Statement::ResetVariable(stmt) => f.write_node(stmt), Statement::Show(stmt) => f.write_node(stmt), @@ -224,6 +228,7 @@ pub fn statement_kind_label_value(kind: StatementKind) -> &'static str { StatementKind::CreateRole => "create_role", StatementKind::CreateCluster => "create_cluster", StatementKind::CreateClusterReplica => "create_cluster_replica", + StatementKind::CreateClusterReplicaSize => "create_cluster_replica_size", StatementKind::CreateSecret => "create_secret", StatementKind::CreateNetworkPolicy => "create_network_policy", StatementKind::AlterCluster => "alter_cluster", @@ -249,6 +254,7 @@ pub fn statement_kind_label_value(kind: StatementKind) -> &'static str { StatementKind::Discard => "discard", StatementKind::DropObjects => "drop_objects", StatementKind::DropOwned => "drop_owned", + StatementKind::DropClusterReplicaSize => "drop_cluster_replica_size", StatementKind::SetVariable => "set_variable", StatementKind::ResetVariable => "reset_variable", StatementKind::Show => "show", @@ -2544,6 +2550,115 @@ impl AstDisplay for CreateClusterReplicaStatement { } impl_display_t!(CreateClusterReplicaStatement); +/// `CREATE CLUSTER REPLICA SIZE ..` +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CreateClusterReplicaSizeStatement { + /// The name of the replica size. + pub name: Ident, + /// Any options that were attached, in the order they were presented. + pub options: Vec>, +} + +impl AstDisplay for CreateClusterReplicaSizeStatement { + fn fmt(&self, f: &mut AstFormatter) { + f.write_str("CREATE CLUSTER REPLICA SIZE "); + f.write_node(&self.name); + f.write_str(" ("); + f.write_node(&display::comma_separated(&self.options)); + f.write_str(")"); + } +} +impl_display_t!(CreateClusterReplicaSizeStatement); + +/// `DROP CLUSTER REPLICA SIZE ` +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DropClusterReplicaSizeStatement { + /// The name of the replica size to drop. + pub name: Ident, +} + +impl AstDisplay for DropClusterReplicaSizeStatement { + fn fmt(&self, f: &mut AstFormatter) { + f.write_str("DROP CLUSTER REPLICA SIZE "); + f.write_node(&self.name); + } +} +impl_display!(DropClusterReplicaSizeStatement); + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ClusterReplicaSizeOption { + pub name: ClusterReplicaSizeOptionName, + pub value: Option>, +} + +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub enum ClusterReplicaSizeOptionName { + /// The `WORKERS` option. + Workers, + /// The `SCALE` option. + Scale, + /// The `CREDITS PER HOUR` option. + CreditsPerHour, + /// The `MEMORY LIMIT` option. + MemoryLimit, + /// The `CPU LIMIT` option. + CpuLimit, + /// The `DISK LIMIT` option. + DiskLimit, + /// The `CPU EXCLUSIVE` option. + CpuExclusive, + /// The `DISABLED` option. + Disabled, + /// The `NODE SELECTORS` option (JSON object of key-value node selectors). + NodeSelectors, + /// The `IS CC` option. + IsCc, + /// The `SWAP ENABLED` option. + SwapEnabled, +} + +impl WithOptionName for ClusterReplicaSizeOptionName { + /// # WARNING + /// + /// Whenever implementing this trait consider very carefully whether or not + /// this value could contain sensitive user data. If you're uncertain, err + /// on the conservative side and return `true`. + fn redact_value(&self) -> bool { + match self { + ClusterReplicaSizeOptionName::Workers + | ClusterReplicaSizeOptionName::Scale + | ClusterReplicaSizeOptionName::CreditsPerHour + | ClusterReplicaSizeOptionName::MemoryLimit + | ClusterReplicaSizeOptionName::CpuLimit + | ClusterReplicaSizeOptionName::DiskLimit + | ClusterReplicaSizeOptionName::CpuExclusive + | ClusterReplicaSizeOptionName::Disabled + | ClusterReplicaSizeOptionName::NodeSelectors + | ClusterReplicaSizeOptionName::IsCc + | ClusterReplicaSizeOptionName::SwapEnabled => false, + } + } +} + +impl AstDisplay for ClusterReplicaSizeOptionName { + fn fmt(&self, f: &mut AstFormatter) { + match self { + ClusterReplicaSizeOptionName::Workers => f.write_str("WORKERS"), + ClusterReplicaSizeOptionName::Scale => f.write_str("SCALE"), + ClusterReplicaSizeOptionName::CreditsPerHour => f.write_str("CREDITS PER HOUR"), + ClusterReplicaSizeOptionName::MemoryLimit => f.write_str("MEMORY LIMIT"), + ClusterReplicaSizeOptionName::CpuLimit => f.write_str("CPU LIMIT"), + ClusterReplicaSizeOptionName::DiskLimit => f.write_str("DISK LIMIT"), + ClusterReplicaSizeOptionName::CpuExclusive => f.write_str("CPU EXCLUSIVE"), + ClusterReplicaSizeOptionName::Disabled => f.write_str("DISABLED"), + ClusterReplicaSizeOptionName::NodeSelectors => f.write_str("NODE SELECTORS"), + ClusterReplicaSizeOptionName::IsCc => f.write_str("IS CC"), + ClusterReplicaSizeOptionName::SwapEnabled => f.write_str("SWAP ENABLED"), + } + } +} +impl_display_for_with_option!(ClusterReplicaSizeOption); + #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] pub enum ReplicaOptionName { /// The `BILLED AS [=] ` option. diff --git a/src/sql-parser/src/parser.rs b/src/sql-parser/src/parser.rs index 91e78749566aa..c406918a0f35b 100644 --- a/src/sql-parser/src/parser.rs +++ b/src/sql-parser/src/parser.rs @@ -1943,7 +1943,10 @@ impl<'a> Parser<'a> { .map_parser_err(StatementKind::CreateRole) } else if self.peek_keyword(CLUSTER) { self.next_token(); - if self.peek_keyword(REPLICA) { + if self.peek_keywords(&[REPLICA, SIZE]) { + self.parse_create_cluster_replica_size() + .map_parser_err(StatementKind::CreateClusterReplicaSize) + } else if self.peek_keyword(REPLICA) { self.parse_create_cluster_replica() .map_parser_err(StatementKind::CreateClusterReplica) } else { @@ -4821,6 +4824,61 @@ impl<'a> Parser<'a> { )) } + fn parse_create_cluster_replica_size(&mut self) -> Result, ParserError> { + self.expect_keywords(&[REPLICA, SIZE])?; + let name = self.parse_identifier()?; + self.expect_token(&Token::LParen)?; + let options = self.parse_comma_separated(Parser::parse_cluster_replica_size_option)?; + self.expect_token(&Token::RParen)?; + Ok(Statement::CreateClusterReplicaSize( + CreateClusterReplicaSizeStatement { name, options }, + )) + } + + fn parse_cluster_replica_size_option( + &mut self, + ) -> Result, ParserError> { + let name = match self.expect_one_of_keywords(&[ + WORKERS, SCALE, CREDITS, MEMORY, CPU, DISK, DISABLED, NODE, IS, SWAP, + ])? { + WORKERS => ClusterReplicaSizeOptionName::Workers, + SCALE => ClusterReplicaSizeOptionName::Scale, + CREDITS => { + self.expect_keywords(&[PER, HOUR])?; + ClusterReplicaSizeOptionName::CreditsPerHour + } + MEMORY => { + self.expect_keyword(LIMIT)?; + ClusterReplicaSizeOptionName::MemoryLimit + } + CPU => match self.expect_one_of_keywords(&[LIMIT, EXCLUSIVE])? { + LIMIT => ClusterReplicaSizeOptionName::CpuLimit, + EXCLUSIVE => ClusterReplicaSizeOptionName::CpuExclusive, + _ => unreachable!(), + }, + DISK => { + self.expect_keyword(LIMIT)?; + ClusterReplicaSizeOptionName::DiskLimit + } + DISABLED => ClusterReplicaSizeOptionName::Disabled, + NODE => { + self.expect_keyword(SELECTORS)?; + ClusterReplicaSizeOptionName::NodeSelectors + } + IS => { + self.expect_keyword(CC)?; + ClusterReplicaSizeOptionName::IsCc + } + SWAP => { + self.expect_keyword(ENABLED)?; + ClusterReplicaSizeOptionName::SwapEnabled + } + _ => unreachable!(), + }; + let value = self.parse_optional_option_value()?; + Ok(ClusterReplicaSizeOption { name, value }) + } + fn parse_if_exists(&mut self) -> Result { if self.parse_keyword(IF) { self.expect_keyword(EXISTS)?; @@ -4901,6 +4959,9 @@ impl<'a> Parser<'a> { if self.parse_keyword(OWNED) { self.parse_drop_owned() .map_parser_err(StatementKind::DropOwned) + } else if self.peek_keywords(&[CLUSTER, REPLICA, SIZE]) { + self.parse_drop_cluster_replica_size() + .map_parser_err(StatementKind::DropClusterReplicaSize) } else { self.parse_drop_objects() .map_parser_err(StatementKind::DropObjects) @@ -5031,6 +5092,14 @@ impl<'a> Parser<'a> { })) } + fn parse_drop_cluster_replica_size(&mut self) -> Result, ParserError> { + self.expect_keywords(&[CLUSTER, REPLICA, SIZE])?; + let name = self.parse_identifier()?; + Ok(Statement::DropClusterReplicaSize( + DropClusterReplicaSizeStatement { name }, + )) + } + fn parse_drop_owned(&mut self) -> Result, ParserError> { self.expect_keyword(BY)?; let role_names = self.parse_comma_separated(Parser::parse_identifier)?; diff --git a/src/sql-parser/tests/testdata/ddl b/src/sql-parser/tests/testdata/ddl index 2dd03110b13a1..d72e856b6cc93 100644 --- a/src/sql-parser/tests/testdata/ddl +++ b/src/sql-parser/tests/testdata/ddl @@ -3480,3 +3480,10 @@ DROP NETWORK POLICY if exists q DROP NETWORK POLICY IF EXISTS q => DropObjects(DropObjectsStatement { object_type: NetworkPolicy, if_exists: true, names: [NetworkPolicy(Ident("q"))], cascade: false }) + +parse-statement +CREATE CLUSTER REPLICA SIZE "25cc" (WORKERS = 1, SCALE = 1, CREDITS PER HOUR = '1', MEMORY LIMIT = '4Gb', CPU LIMIT = '1', DISK LIMIT = '30Gb', CPU EXCLUSIVE = false, DISABLED = false) +---- +CREATE CLUSTER REPLICA SIZE "25cc" (WORKERS = 1, SCALE = 1, CREDITS PER HOUR = '1', MEMORY LIMIT = '4Gb', CPU LIMIT = '1', DISK LIMIT = '30Gb', CPU EXCLUSIVE = false, DISABLED = false) +=> +CreateClusterReplicaSize(CreateClusterReplicaSizeStatement { name: Ident("25cc"), options: [ClusterReplicaSizeOption { name: Workers, value: Some(Value(Number("1"))) }, ClusterReplicaSizeOption { name: Scale, value: Some(Value(Number("1"))) }, ClusterReplicaSizeOption { name: CreditsPerHour, value: Some(Value(String("1"))) }, ClusterReplicaSizeOption { name: MemoryLimit, value: Some(Value(String("4Gb"))) }, ClusterReplicaSizeOption { name: CpuLimit, value: Some(Value(String("1"))) }, ClusterReplicaSizeOption { name: DiskLimit, value: Some(Value(String("30Gb"))) }, ClusterReplicaSizeOption { name: CpuExclusive, value: Some(Value(Boolean(false))) }, ClusterReplicaSizeOption { name: Disabled, value: Some(Value(Boolean(false))) }] }) diff --git a/src/sql/src/catalog.rs b/src/sql/src/catalog.rs index e8c5b213d625e..b1c477b68dbbf 100644 --- a/src/sql/src/catalog.rs +++ b/src/sql/src/catalog.rs @@ -1407,6 +1407,8 @@ pub enum CatalogError { UnknownClusterReplica(String), /// Unknown cluster replica size. UnknownClusterReplicaSize(String), + /// Cluster replica size already exists. + ClusterReplicaSizeAlreadyExists(String), /// Duplicate Replica. #[error("cannot create multiple replicas named '{0}' on cluster '{1}'")] DuplicateReplica(String, String), /// Unknown item. @@ -1484,6 +1486,9 @@ impl fmt::Display for CatalogError { Self::UnknownClusterReplicaSize(name) => { write!(f, "unknown cluster replica size '{}'", name) } + Self::ClusterReplicaSizeAlreadyExists(name) => { + write!(f, "cluster replica size '{}' already exists", name) + } Self::DuplicateReplica(replica_name, cluster_name) => write!( f, "cannot create multiple replicas named '{replica_name}' on cluster '{cluster_name}'" diff --git a/src/sql/src/plan.rs b/src/sql/src/plan.rs index 20fe2d0012825..93860913878eb 100644 --- a/src/sql/src/plan.rs +++ b/src/sql/src/plan.rs @@ -41,6 +41,7 @@ use mz_expr::{CollectionPlan, ColumnOrder, MapFilterProject, MirScalarExpr, RowS use mz_ore::now::{self, NOW_ZERO}; use mz_pgcopy::CopyFormatParams; use mz_repr::adt::mz_acl_item::{AclMode, MzAclItem}; +use mz_repr::adt::numeric::Numeric; use mz_repr::explain::{ExplainConfig, ExplainFormat}; use mz_repr::network_policy_id::NetworkPolicyId; use mz_repr::optimize::OptimizerFeatureOverrides; @@ -144,6 +145,8 @@ pub enum Plan { CreateMaterializedView(CreateMaterializedViewPlan), CreateContinualTask(CreateContinualTaskPlan), CreateNetworkPolicy(CreateNetworkPolicyPlan), + CreateClusterReplicaSize(CreateClusterReplicaSizePlan), + DropClusterReplicaSize(DropClusterReplicaSizePlan), CreateIndex(CreateIndexPlan), CreateType(CreateTypePlan), Comment(CommentPlan), @@ -273,6 +276,8 @@ impl Plan { StatementKind::CreateDatabase => &[PlanKind::CreateDatabase], StatementKind::CreateIndex => &[PlanKind::CreateIndex], StatementKind::CreateNetworkPolicy => &[PlanKind::CreateNetworkPolicy], + StatementKind::CreateClusterReplicaSize => &[PlanKind::CreateClusterReplicaSize], + StatementKind::DropClusterReplicaSize => &[PlanKind::DropClusterReplicaSize], StatementKind::CreateMaterializedView => &[PlanKind::CreateMaterializedView], StatementKind::CreateContinualTask => &[PlanKind::CreateContinualTask], StatementKind::CreateRole => &[PlanKind::CreateRole], @@ -350,6 +355,8 @@ impl Plan { Plan::CreateIndex(_) => "create index", Plan::CreateType(_) => "create type", Plan::CreateNetworkPolicy(_) => "create network policy", + Plan::CreateClusterReplicaSize(_) => "create cluster replica size", + Plan::DropClusterReplicaSize(_) => "drop cluster replica size", Plan::Comment(_) => "comment", Plan::DiscardTemp => "discard temp", Plan::DiscardAll => "discard all", @@ -784,6 +791,27 @@ pub struct CreateNetworkPolicyPlan { pub rules: Vec, } +#[derive(Debug)] +pub struct CreateClusterReplicaSizePlan { + pub name: String, + pub workers: usize, + pub scale: u16, + pub credits_per_hour: Numeric, + pub memory_limit: Option, + pub cpu_limit: Option, + pub disk_limit: Option, + pub cpu_exclusive: bool, + pub disabled: bool, + pub selectors: BTreeMap, + pub is_cc: bool, + pub swap_enabled: bool, +} + +#[derive(Debug)] +pub struct DropClusterReplicaSizePlan { + pub name: String, +} + #[derive(Debug, Clone)] pub struct AlterNetworkPolicyPlan { pub id: NetworkPolicyId, diff --git a/src/sql/src/plan/statement.rs b/src/sql/src/plan/statement.rs index 874ffe5cba61d..6bea3ab351ef7 100644 --- a/src/sql/src/plan/statement.rs +++ b/src/sql/src/plan/statement.rs @@ -166,6 +166,12 @@ pub fn describe( } Statement::CreateContinualTask(stmt) => ddl::describe_create_continual_task(&scx, stmt)?, Statement::CreateNetworkPolicy(stmt) => ddl::describe_create_network_policy(&scx, stmt)?, + Statement::CreateClusterReplicaSize(stmt) => { + ddl::describe_create_cluster_replica_size(&scx, stmt)? + } + Statement::DropClusterReplicaSize(stmt) => { + ddl::describe_drop_cluster_replica_size(&scx, stmt)? + } Statement::DropObjects(stmt) => ddl::describe_drop_objects(&scx, stmt)?, Statement::DropOwned(stmt) => ddl::describe_drop_owned(&scx, stmt)?, @@ -361,6 +367,10 @@ pub fn plan( Statement::CreateMaterializedView(stmt) => ddl::plan_create_materialized_view(scx, stmt), Statement::CreateContinualTask(stmt) => ddl::plan_create_continual_task(scx, stmt), Statement::CreateNetworkPolicy(stmt) => ddl::plan_create_network_policy(scx, stmt), + Statement::CreateClusterReplicaSize(stmt) => { + ddl::plan_create_cluster_replica_size(scx, stmt) + } + Statement::DropClusterReplicaSize(stmt) => ddl::plan_drop_cluster_replica_size(scx, stmt), Statement::DropObjects(stmt) => ddl::plan_drop_objects(scx, stmt), Statement::DropOwned(stmt) => ddl::plan_drop_owned(scx, stmt), @@ -1085,6 +1095,8 @@ impl From<&Statement> for StatementClassifica Statement::CreateView(_) => DDL, Statement::CreateMaterializedView(_) => DDL, Statement::CreateNetworkPolicy(_) => DDL, + Statement::CreateClusterReplicaSize(_) => DDL, + Statement::DropClusterReplicaSize(_) => DDL, Statement::DropObjects(_) => DDL, Statement::DropOwned(_) => DDL, diff --git a/src/sql/src/plan/statement/ddl.rs b/src/sql/src/plan/statement/ddl.rs index e6283d2560f7b..154688a7096c5 100644 --- a/src/sql/src/plan/statement/ddl.rs +++ b/src/sql/src/plan/statement/ddl.rs @@ -53,9 +53,10 @@ use mz_sql_parser::ast::{ AlterSystemResetStatement, AlterSystemSetStatement, AlterTableAddColumnStatement, AvroSchema, AvroSchemaOption, AvroSchemaOptionName, ClusterAlterOption, ClusterAlterOptionName, ClusterAlterOptionValue, ClusterAlterUntilReadyOption, ClusterAlterUntilReadyOptionName, - ClusterFeature, ClusterFeatureName, ClusterOption, ClusterOptionName, - ClusterScheduleOptionValue, ColumnDef, ColumnOption, CommentObjectType, CommentStatement, - ConnectionOption, ConnectionOptionName, ContinualTaskOption, ContinualTaskOptionName, + ClusterFeature, ClusterFeatureName, ClusterOption, ClusterOptionName, ClusterReplicaSizeOption, + ClusterReplicaSizeOptionName, ClusterScheduleOptionValue, ColumnDef, ColumnOption, + CommentObjectType, CommentStatement, ConnectionOption, ConnectionOptionName, + ContinualTaskOption, ContinualTaskOptionName, CreateClusterReplicaSizeStatement, CreateClusterReplicaStatement, CreateClusterStatement, CreateConnectionOption, CreateConnectionOptionName, CreateConnectionStatement, CreateConnectionType, CreateContinualTaskStatement, CreateDatabaseStatement, CreateIndexStatement, @@ -68,19 +69,20 @@ use mz_sql_parser::ast::{ CreateTypeMapOption, CreateTypeMapOptionName, CreateTypeStatement, CreateViewStatement, CreateWebhookSourceStatement, CsrConfigOption, CsrConfigOptionName, CsrConnection, CsrConnectionAvro, CsrConnectionProtobuf, CsrSeedProtobuf, CsvColumns, DeferredItemName, - DocOnIdentifier, DocOnSchema, DropObjectsStatement, DropOwnedStatement, Expr, Format, - FormatSpecifier, IcebergSinkConfigOption, Ident, IfExistsBehavior, IndexOption, - IndexOptionName, KafkaSinkConfigOption, KeyConstraint, LoadGeneratorOption, - LoadGeneratorOptionName, MaterializedViewOption, MaterializedViewOptionName, MySqlConfigOption, - MySqlConfigOptionName, NetworkPolicyOption, NetworkPolicyOptionName, - NetworkPolicyRuleDefinition, NetworkPolicyRuleOption, NetworkPolicyRuleOptionName, - PgConfigOption, PgConfigOptionName, ProtobufSchema, QualifiedReplica, RefreshAtOptionValue, - RefreshEveryOptionValue, RefreshOptionValue, ReplicaDefinition, ReplicaOption, - ReplicaOptionName, RoleAttribute, SetRoleVar, SourceErrorPolicy, SourceIncludeMetadata, - SqlServerConfigOption, SqlServerConfigOptionName, Statement, TableConstraint, - TableFromSourceColumns, TableFromSourceOption, TableFromSourceOptionName, TableOption, - TableOptionName, UnresolvedDatabaseName, UnresolvedItemName, UnresolvedObjectName, - UnresolvedSchemaName, Value, ViewDefinition, WithOptionValue, + DocOnIdentifier, DocOnSchema, DropClusterReplicaSizeStatement, DropObjectsStatement, + DropOwnedStatement, Expr, Format, FormatSpecifier, IcebergSinkConfigOption, Ident, + IfExistsBehavior, IndexOption, IndexOptionName, KafkaSinkConfigOption, KeyConstraint, + LoadGeneratorOption, LoadGeneratorOptionName, MaterializedViewOption, + MaterializedViewOptionName, MySqlConfigOption, MySqlConfigOptionName, NetworkPolicyOption, + NetworkPolicyOptionName, NetworkPolicyRuleDefinition, NetworkPolicyRuleOption, + NetworkPolicyRuleOptionName, PgConfigOption, PgConfigOptionName, ProtobufSchema, + QualifiedReplica, RefreshAtOptionValue, RefreshEveryOptionValue, RefreshOptionValue, + ReplicaDefinition, ReplicaOption, ReplicaOptionName, RoleAttribute, SetRoleVar, + SourceErrorPolicy, SourceIncludeMetadata, SqlServerConfigOption, SqlServerConfigOptionName, + Statement, TableConstraint, TableFromSourceColumns, TableFromSourceOption, + TableFromSourceOptionName, TableOption, TableOptionName, UnresolvedDatabaseName, + UnresolvedItemName, UnresolvedObjectName, UnresolvedSchemaName, Value, ViewDefinition, + WithOptionValue, }; use mz_sql_parser::ident; use mz_sql_parser::parser::StatementParseResult; @@ -154,11 +156,12 @@ use crate::plan::{ AlterSourceTimestampIntervalPlan, AlterSystemResetAllPlan, AlterSystemResetPlan, AlterSystemSetPlan, AlterTablePlan, ClusterSchedule, CommentPlan, ComputeReplicaConfig, ComputeReplicaIntrospectionConfig, ConnectionDetails, CreateClusterManagedPlan, - CreateClusterPlan, CreateClusterReplicaPlan, CreateClusterUnmanagedPlan, CreateClusterVariant, - CreateConnectionPlan, CreateContinualTaskPlan, CreateDatabasePlan, CreateIndexPlan, - CreateMaterializedViewPlan, CreateNetworkPolicyPlan, CreateRolePlan, CreateSchemaPlan, - CreateSecretPlan, CreateSinkPlan, CreateSourcePlan, CreateTablePlan, CreateTypePlan, - CreateViewPlan, DataSourceDesc, DropObjectsPlan, DropOwnedPlan, HirRelationExpr, Index, + CreateClusterPlan, CreateClusterReplicaPlan, CreateClusterReplicaSizePlan, + CreateClusterUnmanagedPlan, CreateClusterVariant, CreateConnectionPlan, + CreateContinualTaskPlan, CreateDatabasePlan, CreateIndexPlan, CreateMaterializedViewPlan, + CreateNetworkPolicyPlan, CreateRolePlan, CreateSchemaPlan, CreateSecretPlan, CreateSinkPlan, + CreateSourcePlan, CreateTablePlan, CreateTypePlan, CreateViewPlan, DataSourceDesc, + DropClusterReplicaSizePlan, DropObjectsPlan, DropOwnedPlan, HirRelationExpr, Index, MaterializedView, NetworkPolicyRule, NetworkPolicyRuleAction, NetworkPolicyRuleDirection, Plan, PlanClusterOption, PlanNotice, PolicyAddress, QueryContext, ReplicaConfig, Secret, Sink, Source, Table, TableDataSource, Type, VariableValue, View, WebhookBodyFormat, @@ -167,7 +170,8 @@ use crate::plan::{ }; use crate::session::vars::{ self, ENABLE_CLUSTER_SCHEDULE_REFRESH, ENABLE_COLLECTION_PARTITION_BY, - ENABLE_CREATE_TABLE_FROM_SOURCE, ENABLE_KAFKA_SINK_HEADERS, ENABLE_REFRESH_EVERY_MVS, + ENABLE_CREATE_TABLE_FROM_SOURCE, ENABLE_CUSTOM_CLUSTER_REPLICA_SIZES, + ENABLE_KAFKA_SINK_HEADERS, ENABLE_REFRESH_EVERY_MVS, ENABLE_REPLICA_TARGETED_MATERIALIZED_VIEWS, }; use crate::{names, parse}; @@ -4804,6 +4808,151 @@ pub fn plan_create_network_policy( })) } +pub fn describe_create_cluster_replica_size( + _: &StatementContext, + _: CreateClusterReplicaSizeStatement, +) -> Result { + Ok(StatementDesc::new(None)) +} + +pub fn plan_create_cluster_replica_size( + scx: &StatementContext, + CreateClusterReplicaSizeStatement { name, options }: CreateClusterReplicaSizeStatement, +) -> Result { + // mz_system can always manage sizes; others need the feature flag. + if !scx.catalog.active_role_id().is_system() { + scx.require_feature_flag(&ENABLE_CUSTOM_CLUSTER_REPLICA_SIZES)?; + } + + let option_extracted: ClusterReplicaSizeOptionExtracted = options.try_into()?; + + let workers = mz_ore::cast::u64_to_usize(u64::from(option_extracted.workers.unwrap_or(1))); + let scale = option_extracted.scale.unwrap_or(1); + let credits_per_hour_str = option_extracted.credits_per_hour.ok_or_else(|| { + sql_err!("CREDITS PER HOUR must be specified when creating cluster replica sizes") + })?; + let credits_per_hour = strconv::parse_numeric(&credits_per_hour_str) + .map_err(|_| { + sql_err!( + "invalid CREDITS PER HOUR value: {}", + credits_per_hour_str.quoted() + ) + })? + .0; + + // Parse memory/disk limits: supports human-readable formats like '4GiB', '512MiB', '1GB', + // or raw byte counts. + let memory_limit = option_extracted + .memory_limit + .map(|s| parse_bytes_str(&s, "MEMORY LIMIT")) + .transpose()?; + let disk_limit = option_extracted + .disk_limit + .map(|s| parse_bytes_str(&s, "DISK LIMIT")) + .transpose()?; + + // Parse CPU limit: supports cores ('0.5', '2'), millicpus ('500m'), or raw nanocpus. + let cpu_limit = option_extracted + .cpu_limit + .map(|s| parse_cpu_str(&s)) + .transpose()?; + + let selectors = match option_extracted.node_selectors { + Some(s) => { + serde_json::from_str(&s).map_err(|e| sql_err!("invalid NODE SELECTORS value: {}", e))? + } + None => std::collections::BTreeMap::new(), + }; + + Ok(Plan::CreateClusterReplicaSize( + CreateClusterReplicaSizePlan { + name: normalize::ident(name), + workers, + scale, + credits_per_hour, + memory_limit, + cpu_limit, + disk_limit, + cpu_exclusive: option_extracted.cpu_exclusive.unwrap_or(false), + disabled: option_extracted.disabled.unwrap_or(false), + selectors, + is_cc: option_extracted.is_cc.unwrap_or(true), + swap_enabled: option_extracted.swap_enabled.unwrap_or(false), + }, + )) +} + +/// Parse a human-readable byte string into raw bytes. +/// Supports: '4GiB', '512MiB', '1GB', '1024MB', '1073741824', etc. +fn parse_bytes_str(s: &str, option_name: &str) -> Result { + // First try as raw u64 + if let Ok(bytes) = s.parse::() { + return Ok(bytes); + } + // Normalize GiB/MiB/TiB/KiB to GB/MB/TB/kB for mz_repr::bytes::ByteSize parser + let normalized = s + .replace("GiB", "GB") + .replace("MiB", "MB") + .replace("TiB", "TB") + .replace("KiB", "kB"); + let byte_size = normalized + .parse::() + .map_err(|e| sql_err!("invalid {} value '{}': {}", option_name, s, e))?; + Ok(byte_size.as_bytes()) +} + +/// Parse a CPU string into nanocpus. +/// Supports: '0.5' (cores), '500m' (millicpus), '2000000000' (nanocpus). +fn parse_cpu_str(s: &str) -> Result { + let trimmed = s.trim(); + if let Some(milli_str) = trimmed.strip_suffix('m') { + // Millicpus: '500m' -> 500_000_000 nanocpus + let millicpus = milli_str + .parse::() + .map_err(|_| sql_err!("invalid CPU LIMIT value '{}': expected millicpus", s))?; + Ok(millicpus * 1_000_000) + } else if trimmed.contains('.') { + // Fractional cores: '0.5' -> 500_000_000 nanocpus + let cores = trimmed + .parse::() + .map_err(|_| sql_err!("invalid CPU LIMIT value '{}': expected cores", s))?; + #[allow(clippy::as_conversions)] + Ok((cores * 1_000_000_000.0) as u64) + } else { + // Could be whole cores or raw nanocpus; treat values <= 1000 as cores + let val = trimmed + .parse::() + .map_err(|_| sql_err!("invalid CPU LIMIT value '{}'", s))?; + if val <= 1000 { + // Whole cores + Ok(val * 1_000_000_000) + } else { + // Raw nanocpus + Ok(val) + } + } +} + +pub fn describe_drop_cluster_replica_size( + _: &StatementContext, + _: DropClusterReplicaSizeStatement, +) -> Result { + Ok(StatementDesc::new(None)) +} + +pub fn plan_drop_cluster_replica_size( + scx: &StatementContext, + DropClusterReplicaSizeStatement { name }: DropClusterReplicaSizeStatement, +) -> Result { + if !scx.catalog.active_role_id().is_system() { + scx.require_feature_flag(&ENABLE_CUSTOM_CLUSTER_REPLICA_SIZES)?; + } + + Ok(Plan::DropClusterReplicaSize(DropClusterReplicaSizePlan { + name: normalize::ident(name), + })) +} + pub fn plan_alter_network_policy( ctx: &StatementContext, AlterNetworkPolicyStatement { name, options }: AlterNetworkPolicyStatement, @@ -4886,6 +5035,21 @@ generate_extracted_config!( (WorkloadClass, OptionalString) ); +generate_extracted_config!( + ClusterReplicaSizeOption, + (Workers, u32), + (Scale, u16), + (CreditsPerHour, String), + (MemoryLimit, String), + (CpuLimit, String), + (DiskLimit, String), + (CpuExclusive, bool), + (Disabled, bool), + (NodeSelectors, String), + (IsCc, bool), + (SwapEnabled, bool) +); + generate_extracted_config!( NetworkPolicyOption, (Rules, Vec>) diff --git a/src/sql/src/rbac.rs b/src/sql/src/rbac.rs index 5ee9436bc9b0a..ae80c10dc9396 100644 --- a/src/sql/src/rbac.rs +++ b/src/sql/src/rbac.rs @@ -455,6 +455,16 @@ fn generate_rbac_requirements( item_usage: &CREATE_ITEM_USAGE, ..Default::default() }, + Plan::CreateClusterReplicaSize(plan::CreateClusterReplicaSizePlan { .. }) => { + RbacRequirements { + superuser_action: Some("create cluster replica size".to_string()), + ..Default::default() + } + } + Plan::DropClusterReplicaSize(plan::DropClusterReplicaSizePlan { .. }) => RbacRequirements { + superuser_action: Some("drop cluster replica size".to_string()), + ..Default::default() + }, Plan::CreateCluster(plan::CreateClusterPlan { name: _, variant: _, diff --git a/src/sql/src/session/vars/definitions.rs b/src/sql/src/session/vars/definitions.rs index ddfd2336a47ab..1179e621bb844 100644 --- a/src/sql/src/session/vars/definitions.rs +++ b/src/sql/src/session/vars/definitions.rs @@ -2163,6 +2163,12 @@ feature_flags!( default: true, enable_for_item_parsing: true, }, + { + name: enable_custom_cluster_replica_sizes, + desc: "CREATE CLUSTER REPLICA SIZE", + default: false, + enable_for_item_parsing: false, + }, { name: enable_create_table_from_source, desc: "Whether to allow CREATE TABLE .. FROM SOURCE syntax.", diff --git a/test/sqllogictest/autogenerated/mz_internal.slt b/test/sqllogictest/autogenerated/mz_internal.slt index f3d1a2e7bfb50..9647ad6027daa 100644 --- a/test/sqllogictest/autogenerated/mz_internal.slt +++ b/test/sqllogictest/autogenerated/mz_internal.slt @@ -747,6 +747,7 @@ mz_cluster_replica_history mz_cluster_replica_metrics mz_cluster_replica_metrics_history mz_cluster_replica_name_history +mz_cluster_replica_size_details mz_cluster_replica_status_history mz_cluster_replica_statuses mz_cluster_replica_utilization diff --git a/test/sqllogictest/cluster_replica_size.slt b/test/sqllogictest/cluster_replica_size.slt new file mode 100644 index 0000000000000..66acae379fe37 --- /dev/null +++ b/test/sqllogictest/cluster_replica_size.slt @@ -0,0 +1,120 @@ +# Copyright Materialize, Inc. and contributors. All rights reserved. +# +# Use of this software is governed by the Business Source License +# included in the LICENSE file at the root of this repository. +# +# 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. + +# Tests for CREATE/DROP CLUSTER REPLICA SIZE. + +mode standard + +reset-server + +# Cannot create cluster replica size without feature flag. +statement error is not available +CREATE CLUSTER REPLICA SIZE custom1 (CREDITS PER HOUR = '1', WORKERS = 2, SCALE = 1) + +# Enable the feature flag. +simple conn=mz_system,user=mz_system +ALTER SYSTEM SET enable_custom_cluster_replica_sizes = on +---- +COMPLETE 0 + +# Create a custom cluster replica size. +simple conn=mz_system,user=mz_system +CREATE CLUSTER REPLICA SIZE custom1 (CREDITS PER HOUR = '2', WORKERS = 1, SCALE = 1) +---- +COMPLETE 0 + +# Verify the new size appears in mz_cluster_replica_sizes. +query TI +SELECT size, workers FROM mz_cluster_replica_sizes WHERE size = 'custom1' +---- +custom1 +1 + +# Creating a duplicate size should fail. +simple conn=mz_system,user=mz_system +CREATE CLUSTER REPLICA SIZE custom1 (CREDITS PER HOUR = '3', WORKERS = 1, SCALE = 1) +---- +db error: ERROR: cluster replica size 'custom1' already exists + +# Allow the custom size for use. +simple conn=mz_system,user=mz_system +ALTER SYSTEM SET allowed_cluster_replica_sizes = 'custom1' +---- +COMPLETE 0 + +# Create a cluster using the custom size. +statement ok +CREATE CLUSTER test_cluster REPLICAS (r1 (SIZE 'custom1')) + +# Attempting to drop the in-use size should fail. +simple conn=mz_system,user=mz_system +DROP CLUSTER REPLICA SIZE custom1 +---- +db error: ERROR: cannot drop cluster replica size 'custom1' because it is in use by an existing replica + +# Drop the cluster that uses the size. +statement ok +DROP CLUSTER test_cluster + +# Now we can drop the size. +simple conn=mz_system,user=mz_system +DROP CLUSTER REPLICA SIZE custom1 +---- +COMPLETE 0 + +# Verify the size is gone. +query I +SELECT count(*) FROM mz_cluster_replica_sizes WHERE size = 'custom1' +---- +0 + +# Dropping a nonexistent size should fail. +simple conn=mz_system,user=mz_system +DROP CLUSTER REPLICA SIZE nonexistent +---- +db error: ERROR: unknown cluster replica size 'nonexistent' + +# Create another custom size with more options. +simple conn=mz_system,user=mz_system +CREATE CLUSTER REPLICA SIZE custom2 (CREDITS PER HOUR = '5', WORKERS = 4, SCALE = 2, MEMORY LIMIT = '4GiB', CPU LIMIT = '0.5', DISK LIMIT = '512MiB') +---- +COMPLETE 0 + +# Verify the size properties (4GiB = 4294967296 bytes, 0.5 cores = 500000000 nanocpus). +query TIIII +SELECT size, workers, processes, memory_bytes, cpu_nano_cores FROM mz_cluster_replica_sizes WHERE size = 'custom2' +---- +custom2 +4 +2 +4294967296 +500000000 + +# Clean up. +simple conn=mz_system,user=mz_system +DROP CLUSTER REPLICA SIZE custom2 +---- +COMPLETE 0 + +# Test millicpus syntax for CPU. +simple conn=mz_system,user=mz_system +CREATE CLUSTER REPLICA SIZE custom3 (CREDITS PER HOUR = '1', CPU LIMIT = '250m', MEMORY LIMIT = '1GB') +---- +COMPLETE 0 + +query TI +SELECT size, cpu_nano_cores FROM mz_cluster_replica_sizes WHERE size = 'custom3' +---- +custom3 +250000000 + +simple conn=mz_system,user=mz_system +DROP CLUSTER REPLICA SIZE custom3 +---- +COMPLETE 0 diff --git a/test/sqllogictest/information_schema_tables.slt b/test/sqllogictest/information_schema_tables.slt index 2543bcc71425d..3e2e7d0d1d29a 100644 --- a/test/sqllogictest/information_schema_tables.slt +++ b/test/sqllogictest/information_schema_tables.slt @@ -317,6 +317,10 @@ mz_cluster_replica_name_history VIEW materialize mz_internal +mz_cluster_replica_size_details +BASE TABLE +materialize +mz_internal mz_cluster_replica_status_history SOURCE materialize diff --git a/test/sqllogictest/mz_catalog_server_index_accounting.slt b/test/sqllogictest/mz_catalog_server_index_accounting.slt index f90219444dabe..5a946c69fc805 100644 --- a/test/sqllogictest/mz_catalog_server_index_accounting.slt +++ b/test/sqllogictest/mz_catalog_server_index_accounting.slt @@ -37,100 +37,100 @@ mz_arrangement_heap_capacity_raw_s2_primary_idx CREATE␠INDEX␠"mz_arrangemen mz_arrangement_heap_size_raw_s2_primary_idx CREATE␠INDEX␠"mz_arrangement_heap_size_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_arrangement_heap_size_raw"␠("operator_id",␠"worker_id") mz_arrangement_records_raw_s2_primary_idx CREATE␠INDEX␠"mz_arrangement_records_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_arrangement_records_raw"␠("operator_id",␠"worker_id") mz_arrangement_sharing_raw_s2_primary_idx CREATE␠INDEX␠"mz_arrangement_sharing_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_arrangement_sharing_raw"␠("operator_id",␠"worker_id") -mz_cluster_deployment_lineage_ind CREATE␠INDEX␠"mz_cluster_deployment_lineage_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s741␠AS␠"mz_internal"."mz_cluster_deployment_lineage"]␠("cluster_id") +mz_cluster_deployment_lineage_ind CREATE␠INDEX␠"mz_cluster_deployment_lineage_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s742␠AS␠"mz_internal"."mz_cluster_deployment_lineage"]␠("cluster_id") mz_cluster_prometheus_metrics_s2_primary_idx CREATE␠INDEX␠"mz_cluster_prometheus_metrics_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_cluster_prometheus_metrics"␠("process_id",␠"metric_name",␠"labels") -mz_cluster_replica_frontiers_ind CREATE␠INDEX␠"mz_cluster_replica_frontiers_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s735␠AS␠"mz_catalog"."mz_cluster_replica_frontiers"]␠("object_id") -mz_cluster_replica_history_ind CREATE␠INDEX␠"mz_cluster_replica_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s598␠AS␠"mz_internal"."mz_cluster_replica_history"]␠("dropped_at") +mz_cluster_replica_frontiers_ind CREATE␠INDEX␠"mz_cluster_replica_frontiers_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s736␠AS␠"mz_catalog"."mz_cluster_replica_frontiers"]␠("object_id") +mz_cluster_replica_history_ind CREATE␠INDEX␠"mz_cluster_replica_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s599␠AS␠"mz_internal"."mz_cluster_replica_history"]␠("dropped_at") mz_cluster_replica_metrics_history_ind CREATE␠INDEX␠"mz_cluster_replica_metrics_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s506␠AS␠"mz_internal"."mz_cluster_replica_metrics_history"]␠("replica_id") mz_cluster_replica_metrics_ind CREATE␠INDEX␠"mz_cluster_replica_metrics_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s507␠AS␠"mz_internal"."mz_cluster_replica_metrics"]␠("replica_id") -mz_cluster_replica_name_history_ind CREATE␠INDEX␠"mz_cluster_replica_name_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s599␠AS␠"mz_internal"."mz_cluster_replica_name_history"]␠("id") +mz_cluster_replica_name_history_ind CREATE␠INDEX␠"mz_cluster_replica_name_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s600␠AS␠"mz_internal"."mz_cluster_replica_name_history"]␠("id") mz_cluster_replica_sizes_ind CREATE␠INDEX␠"mz_cluster_replica_sizes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s508␠AS␠"mz_catalog"."mz_cluster_replica_sizes"]␠("size") -mz_cluster_replica_status_history_ind CREATE␠INDEX␠"mz_cluster_replica_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s509␠AS␠"mz_internal"."mz_cluster_replica_status_history"]␠("replica_id") -mz_cluster_replica_statuses_ind CREATE␠INDEX␠"mz_cluster_replica_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s510␠AS␠"mz_internal"."mz_cluster_replica_statuses"]␠("replica_id") +mz_cluster_replica_status_history_ind CREATE␠INDEX␠"mz_cluster_replica_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s510␠AS␠"mz_internal"."mz_cluster_replica_status_history"]␠("replica_id") +mz_cluster_replica_statuses_ind CREATE␠INDEX␠"mz_cluster_replica_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s511␠AS␠"mz_internal"."mz_cluster_replica_statuses"]␠("replica_id") mz_cluster_replicas_ind CREATE␠INDEX␠"mz_cluster_replicas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s505␠AS␠"mz_catalog"."mz_cluster_replicas"]␠("id") mz_clusters_ind CREATE␠INDEX␠"mz_clusters_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s499␠AS␠"mz_catalog"."mz_clusters"]␠("id") mz_columns_ind CREATE␠INDEX␠"mz_columns_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s472␠AS␠"mz_catalog"."mz_columns"]␠("name") -mz_comments_ind CREATE␠INDEX␠"mz_comments_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s522␠AS␠"mz_internal"."mz_comments"]␠("id") +mz_comments_ind CREATE␠INDEX␠"mz_comments_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s523␠AS␠"mz_internal"."mz_comments"]␠("id") mz_compute_dataflow_global_ids_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_dataflow_global_ids_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_dataflow_global_ids_per_worker"␠("id",␠"worker_id") -mz_compute_dependencies_ind CREATE␠INDEX␠"mz_compute_dependencies_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s724␠AS␠"mz_internal"."mz_compute_dependencies"]␠("dependency_id") +mz_compute_dependencies_ind CREATE␠INDEX␠"mz_compute_dependencies_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s725␠AS␠"mz_internal"."mz_compute_dependencies"]␠("dependency_id") mz_compute_error_counts_raw_s2_primary_idx CREATE␠INDEX␠"mz_compute_error_counts_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_error_counts_raw"␠("export_id",␠"worker_id") mz_compute_exports_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_exports_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_exports_per_worker"␠("export_id",␠"worker_id") mz_compute_frontiers_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_frontiers_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_frontiers_per_worker"␠("export_id",␠"worker_id") -mz_compute_hydration_times_ind CREATE␠INDEX␠"mz_compute_hydration_times_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s731␠AS␠"mz_internal"."mz_compute_hydration_times"]␠("replica_id") +mz_compute_hydration_times_ind CREATE␠INDEX␠"mz_compute_hydration_times_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s732␠AS␠"mz_internal"."mz_compute_hydration_times"]␠("replica_id") mz_compute_hydration_times_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_hydration_times_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_hydration_times_per_worker"␠("export_id",␠"worker_id") mz_compute_import_frontiers_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_import_frontiers_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_import_frontiers_per_worker"␠("export_id",␠"import_id",␠"worker_id") mz_compute_lir_mapping_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_lir_mapping_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_lir_mapping_per_worker"␠("global_id",␠"lir_id",␠"worker_id") mz_compute_operator_durations_histogram_raw_s2_primary_idx CREATE␠INDEX␠"mz_compute_operator_durations_histogram_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_operator_durations_histogram_raw"␠("id",␠"worker_id",␠"duration_ns") mz_compute_operator_hydration_statuses_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_compute_operator_hydration_statuses_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_compute_operator_hydration_statuses_per_worker"␠("export_id",␠"lir_id") mz_connections_ind CREATE␠INDEX␠"mz_connections_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s503␠AS␠"mz_catalog"."mz_connections"]␠("schema_id") -mz_console_cluster_utilization_overview_ind CREATE␠INDEX␠"mz_console_cluster_utilization_overview_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s727␠AS␠"mz_internal"."mz_console_cluster_utilization_overview"]␠("cluster_id") -mz_continual_tasks_ind CREATE␠INDEX␠"mz_continual_tasks_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s527␠AS␠"mz_internal"."mz_continual_tasks"]␠("id") +mz_console_cluster_utilization_overview_ind CREATE␠INDEX␠"mz_console_cluster_utilization_overview_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s728␠AS␠"mz_internal"."mz_console_cluster_utilization_overview"]␠("cluster_id") +mz_continual_tasks_ind CREATE␠INDEX␠"mz_continual_tasks_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s528␠AS␠"mz_internal"."mz_continual_tasks"]␠("id") mz_databases_ind CREATE␠INDEX␠"mz_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s470␠AS␠"mz_catalog"."mz_databases"]␠("name") mz_dataflow_addresses_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_dataflow_addresses_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_dataflow_addresses_per_worker"␠("id",␠"worker_id") mz_dataflow_channels_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_dataflow_channels_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_dataflow_channels_per_worker"␠("id",␠"worker_id") mz_dataflow_operator_reachability_raw_s2_primary_idx CREATE␠INDEX␠"mz_dataflow_operator_reachability_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_dataflow_operator_reachability_raw"␠("id",␠"worker_id",␠"source",␠"port",␠"update_type",␠"time") mz_dataflow_operators_per_worker_s2_primary_idx CREATE␠INDEX␠"mz_dataflow_operators_per_worker_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_dataflow_operators_per_worker"␠("id",␠"worker_id") -mz_frontiers_ind CREATE␠INDEX␠"mz_frontiers_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s715␠AS␠"mz_internal"."mz_frontiers"]␠("object_id") -mz_hydration_statuses_ind CREATE␠INDEX␠"mz_hydration_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s737␠AS␠"mz_internal"."mz_hydration_statuses"]␠("object_id",␠"replica_id") +mz_frontiers_ind CREATE␠INDEX␠"mz_frontiers_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s716␠AS␠"mz_internal"."mz_frontiers"]␠("object_id") +mz_hydration_statuses_ind CREATE␠INDEX␠"mz_hydration_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s738␠AS␠"mz_internal"."mz_hydration_statuses"]␠("object_id",␠"replica_id") mz_indexes_ind CREATE␠INDEX␠"mz_indexes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s473␠AS␠"mz_catalog"."mz_indexes"]␠("id") mz_kafka_sources_ind CREATE␠INDEX␠"mz_kafka_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s467␠AS␠"mz_catalog"."mz_kafka_sources"]␠("id") -mz_materialized_views_ind CREATE␠INDEX␠"mz_materialized_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s525␠AS␠"mz_catalog"."mz_materialized_views"]␠("id") +mz_materialized_views_ind CREATE␠INDEX␠"mz_materialized_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s526␠AS␠"mz_catalog"."mz_materialized_views"]␠("id") mz_message_batch_counts_received_raw_s2_primary_idx CREATE␠INDEX␠"mz_message_batch_counts_received_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_message_batch_counts_received_raw"␠("channel_id",␠"from_worker_id",␠"to_worker_id") mz_message_batch_counts_sent_raw_s2_primary_idx CREATE␠INDEX␠"mz_message_batch_counts_sent_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_message_batch_counts_sent_raw"␠("channel_id",␠"from_worker_id",␠"to_worker_id") mz_message_counts_received_raw_s2_primary_idx CREATE␠INDEX␠"mz_message_counts_received_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_message_counts_received_raw"␠("channel_id",␠"from_worker_id",␠"to_worker_id") mz_message_counts_sent_raw_s2_primary_idx CREATE␠INDEX␠"mz_message_counts_sent_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_message_counts_sent_raw"␠("channel_id",␠"from_worker_id",␠"to_worker_id") -mz_notices_ind CREATE␠INDEX␠"mz_notices_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s807␠AS␠"mz_internal"."mz_notices"]␠("id") +mz_notices_ind CREATE␠INDEX␠"mz_notices_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s808␠AS␠"mz_internal"."mz_notices"]␠("id") mz_object_dependencies_ind CREATE␠INDEX␠"mz_object_dependencies_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s468␠AS␠"mz_internal"."mz_object_dependencies"]␠("object_id") -mz_object_history_ind CREATE␠INDEX␠"mz_object_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s537␠AS␠"mz_internal"."mz_object_history"]␠("id") -mz_object_lifetimes_ind CREATE␠INDEX␠"mz_object_lifetimes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s538␠AS␠"mz_internal"."mz_object_lifetimes"]␠("id") -mz_object_transitive_dependencies_ind CREATE␠INDEX␠"mz_object_transitive_dependencies_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s554␠AS␠"mz_internal"."mz_object_transitive_dependencies"]␠("object_id") -mz_objects_ind CREATE␠INDEX␠"mz_objects_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s534␠AS␠"mz_catalog"."mz_objects"]␠("schema_id") +mz_object_history_ind CREATE␠INDEX␠"mz_object_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s538␠AS␠"mz_internal"."mz_object_history"]␠("id") +mz_object_lifetimes_ind CREATE␠INDEX␠"mz_object_lifetimes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s539␠AS␠"mz_internal"."mz_object_lifetimes"]␠("id") +mz_object_transitive_dependencies_ind CREATE␠INDEX␠"mz_object_transitive_dependencies_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s555␠AS␠"mz_internal"."mz_object_transitive_dependencies"]␠("object_id") +mz_objects_ind CREATE␠INDEX␠"mz_objects_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s535␠AS␠"mz_catalog"."mz_objects"]␠("schema_id") mz_peek_durations_histogram_raw_s2_primary_idx CREATE␠INDEX␠"mz_peek_durations_histogram_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_peek_durations_histogram_raw"␠("worker_id",␠"type",␠"duration_ns") -mz_recent_activity_log_thinned_ind CREATE␠INDEX␠"mz_recent_activity_log_thinned_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s699␠AS␠"mz_internal"."mz_recent_activity_log_thinned"]␠("sql_hash") -mz_recent_sql_text_ind CREATE␠INDEX␠"mz_recent_sql_text_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s695␠AS␠"mz_internal"."mz_recent_sql_text"]␠("sql_hash") -mz_recent_storage_usage_ind CREATE␠INDEX␠"mz_recent_storage_usage_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s800␠AS␠"mz_catalog"."mz_recent_storage_usage"]␠("object_id") +mz_recent_activity_log_thinned_ind CREATE␠INDEX␠"mz_recent_activity_log_thinned_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s700␠AS␠"mz_internal"."mz_recent_activity_log_thinned"]␠("sql_hash") +mz_recent_sql_text_ind CREATE␠INDEX␠"mz_recent_sql_text_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s696␠AS␠"mz_internal"."mz_recent_sql_text"]␠("sql_hash") +mz_recent_storage_usage_ind CREATE␠INDEX␠"mz_recent_storage_usage_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s801␠AS␠"mz_catalog"."mz_recent_storage_usage"]␠("object_id") mz_roles_ind CREATE␠INDEX␠"mz_roles_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s491␠AS␠"mz_catalog"."mz_roles"]␠("id") mz_scheduling_elapsed_raw_s2_primary_idx CREATE␠INDEX␠"mz_scheduling_elapsed_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_scheduling_elapsed_raw"␠("id",␠"worker_id") mz_scheduling_parks_histogram_raw_s2_primary_idx CREATE␠INDEX␠"mz_scheduling_parks_histogram_raw_s2_primary_idx"␠IN␠CLUSTER␠[s2]␠ON␠"mz_introspection"."mz_scheduling_parks_histogram_raw"␠("worker_id",␠"slept_for_ns",␠"requested_ns") mz_schemas_ind CREATE␠INDEX␠"mz_schemas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s471␠AS␠"mz_catalog"."mz_schemas"]␠("database_id") mz_secrets_ind CREATE␠INDEX␠"mz_secrets_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s502␠AS␠"mz_catalog"."mz_secrets"]␠("name") -mz_show_all_objects_ind CREATE␠INDEX␠"mz_show_all_objects_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s582␠AS␠"mz_internal"."mz_show_all_objects"]␠("schema_id") -mz_show_cluster_replicas_ind CREATE␠INDEX␠"mz_show_cluster_replicas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s739␠AS␠"mz_internal"."mz_show_cluster_replicas"]␠("cluster") -mz_show_clusters_ind CREATE␠INDEX␠"mz_show_clusters_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s584␠AS␠"mz_internal"."mz_show_clusters"]␠("name") -mz_show_columns_ind CREATE␠INDEX␠"mz_show_columns_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s583␠AS␠"mz_internal"."mz_show_columns"]␠("id") -mz_show_connections_ind CREATE␠INDEX␠"mz_show_connections_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s592␠AS␠"mz_internal"."mz_show_connections"]␠("schema_id") -mz_show_databases_ind CREATE␠INDEX␠"mz_show_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s586␠AS␠"mz_internal"."mz_show_databases"]␠("name") -mz_show_indexes_ind CREATE␠INDEX␠"mz_show_indexes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s596␠AS␠"mz_internal"."mz_show_indexes"]␠("schema_id") -mz_show_materialized_views_ind CREATE␠INDEX␠"mz_show_materialized_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s595␠AS␠"mz_internal"."mz_show_materialized_views"]␠("schema_id") -mz_show_roles_ind CREATE␠INDEX␠"mz_show_roles_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s591␠AS␠"mz_internal"."mz_show_roles"]␠("name") -mz_show_schemas_ind CREATE␠INDEX␠"mz_show_schemas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s587␠AS␠"mz_internal"."mz_show_schemas"]␠("database_id") -mz_show_secrets_ind CREATE␠INDEX␠"mz_show_secrets_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s585␠AS␠"mz_internal"."mz_show_secrets"]␠("schema_id") -mz_show_sinks_ind CREATE␠INDEX␠"mz_show_sinks_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s594␠AS␠"mz_internal"."mz_show_sinks"]␠("schema_id") -mz_show_sources_ind CREATE␠INDEX␠"mz_show_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s593␠AS␠"mz_internal"."mz_show_sources"]␠("schema_id") -mz_show_tables_ind CREATE␠INDEX␠"mz_show_tables_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s588␠AS␠"mz_internal"."mz_show_tables"]␠("schema_id") -mz_show_types_ind CREATE␠INDEX␠"mz_show_types_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s590␠AS␠"mz_internal"."mz_show_types"]␠("schema_id") -mz_show_views_ind CREATE␠INDEX␠"mz_show_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s589␠AS␠"mz_internal"."mz_show_views"]␠("schema_id") -mz_sink_statistics_ind CREATE␠INDEX␠"mz_sink_statistics_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s712␠AS␠"mz_internal"."mz_sink_statistics"]␠("id",␠"replica_id") -mz_sink_status_history_ind CREATE␠INDEX␠"mz_sink_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s684␠AS␠"mz_internal"."mz_sink_status_history"]␠("sink_id") -mz_sink_statuses_ind CREATE␠INDEX␠"mz_sink_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s685␠AS␠"mz_internal"."mz_sink_statuses"]␠("id") +mz_show_all_objects_ind CREATE␠INDEX␠"mz_show_all_objects_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s583␠AS␠"mz_internal"."mz_show_all_objects"]␠("schema_id") +mz_show_cluster_replicas_ind CREATE␠INDEX␠"mz_show_cluster_replicas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s740␠AS␠"mz_internal"."mz_show_cluster_replicas"]␠("cluster") +mz_show_clusters_ind CREATE␠INDEX␠"mz_show_clusters_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s585␠AS␠"mz_internal"."mz_show_clusters"]␠("name") +mz_show_columns_ind CREATE␠INDEX␠"mz_show_columns_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s584␠AS␠"mz_internal"."mz_show_columns"]␠("id") +mz_show_connections_ind CREATE␠INDEX␠"mz_show_connections_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s593␠AS␠"mz_internal"."mz_show_connections"]␠("schema_id") +mz_show_databases_ind CREATE␠INDEX␠"mz_show_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s587␠AS␠"mz_internal"."mz_show_databases"]␠("name") +mz_show_indexes_ind CREATE␠INDEX␠"mz_show_indexes_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s597␠AS␠"mz_internal"."mz_show_indexes"]␠("schema_id") +mz_show_materialized_views_ind CREATE␠INDEX␠"mz_show_materialized_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s596␠AS␠"mz_internal"."mz_show_materialized_views"]␠("schema_id") +mz_show_roles_ind CREATE␠INDEX␠"mz_show_roles_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s592␠AS␠"mz_internal"."mz_show_roles"]␠("name") +mz_show_schemas_ind CREATE␠INDEX␠"mz_show_schemas_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s588␠AS␠"mz_internal"."mz_show_schemas"]␠("database_id") +mz_show_secrets_ind CREATE␠INDEX␠"mz_show_secrets_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s586␠AS␠"mz_internal"."mz_show_secrets"]␠("schema_id") +mz_show_sinks_ind CREATE␠INDEX␠"mz_show_sinks_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s595␠AS␠"mz_internal"."mz_show_sinks"]␠("schema_id") +mz_show_sources_ind CREATE␠INDEX␠"mz_show_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s594␠AS␠"mz_internal"."mz_show_sources"]␠("schema_id") +mz_show_tables_ind CREATE␠INDEX␠"mz_show_tables_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s589␠AS␠"mz_internal"."mz_show_tables"]␠("schema_id") +mz_show_types_ind CREATE␠INDEX␠"mz_show_types_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s591␠AS␠"mz_internal"."mz_show_types"]␠("schema_id") +mz_show_views_ind CREATE␠INDEX␠"mz_show_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s590␠AS␠"mz_internal"."mz_show_views"]␠("schema_id") +mz_sink_statistics_ind CREATE␠INDEX␠"mz_sink_statistics_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s713␠AS␠"mz_internal"."mz_sink_statistics"]␠("id",␠"replica_id") +mz_sink_status_history_ind CREATE␠INDEX␠"mz_sink_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s685␠AS␠"mz_internal"."mz_sink_status_history"]␠("sink_id") +mz_sink_statuses_ind CREATE␠INDEX␠"mz_sink_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s686␠AS␠"mz_internal"."mz_sink_statuses"]␠("id") mz_sinks_ind CREATE␠INDEX␠"mz_sinks_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s483␠AS␠"mz_catalog"."mz_sinks"]␠("id") -mz_source_statistics_ind CREATE␠INDEX␠"mz_source_statistics_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s710␠AS␠"mz_internal"."mz_source_statistics"]␠("id",␠"replica_id") -mz_source_statistics_with_history_ind CREATE␠INDEX␠"mz_source_statistics_with_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s708␠AS␠"mz_internal"."mz_source_statistics_with_history"]␠("id",␠"replica_id") -mz_source_status_history_ind CREATE␠INDEX␠"mz_source_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s686␠AS␠"mz_internal"."mz_source_status_history"]␠("source_id") -mz_source_statuses_ind CREATE␠INDEX␠"mz_source_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s703␠AS␠"mz_internal"."mz_source_statuses"]␠("id") +mz_source_statistics_ind CREATE␠INDEX␠"mz_source_statistics_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s711␠AS␠"mz_internal"."mz_source_statistics"]␠("id",␠"replica_id") +mz_source_statistics_with_history_ind CREATE␠INDEX␠"mz_source_statistics_with_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s709␠AS␠"mz_internal"."mz_source_statistics_with_history"]␠("id",␠"replica_id") +mz_source_status_history_ind CREATE␠INDEX␠"mz_source_status_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s687␠AS␠"mz_internal"."mz_source_status_history"]␠("source_id") +mz_source_statuses_ind CREATE␠INDEX␠"mz_source_statuses_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s704␠AS␠"mz_internal"."mz_source_statuses"]␠("id") mz_sources_ind CREATE␠INDEX␠"mz_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s476␠AS␠"mz_catalog"."mz_sources"]␠("id") mz_tables_ind CREATE␠INDEX␠"mz_tables_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s475␠AS␠"mz_catalog"."mz_tables"]␠("schema_id") mz_types_ind CREATE␠INDEX␠"mz_types_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s485␠AS␠"mz_catalog"."mz_types"]␠("schema_id") mz_views_ind CREATE␠INDEX␠"mz_views_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s484␠AS␠"mz_catalog"."mz_views"]␠("schema_id") -mz_wallclock_global_lag_recent_history_ind CREATE␠INDEX␠"mz_wallclock_global_lag_recent_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s719␠AS␠"mz_internal"."mz_wallclock_global_lag_recent_history"]␠("object_id") -mz_webhook_sources_ind CREATE␠INDEX␠"mz_webhook_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s523␠AS␠"mz_internal"."mz_webhook_sources"]␠("id") -pg_attrdef_all_databases_ind CREATE␠INDEX␠"pg_attrdef_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s624␠AS␠"mz_internal"."pg_attrdef_all_databases"]␠("oid",␠"adrelid",␠"adnum",␠"adbin",␠"adsrc") -pg_attribute_all_databases_ind CREATE␠INDEX␠"pg_attribute_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s617␠AS␠"mz_internal"."pg_attribute_all_databases"]␠("attrelid",␠"attname",␠"atttypid",␠"attlen",␠"attnum",␠"atttypmod",␠"attnotnull",␠"atthasdef",␠"attidentity",␠"attgenerated",␠"attisdropped",␠"attcollation",␠"database_name",␠"pg_type_database_name") -pg_authid_core_ind CREATE␠INDEX␠"pg_authid_core_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s634␠AS␠"mz_internal"."pg_authid_core"]␠("rolname") -pg_class_all_databases_ind CREATE␠INDEX␠"pg_class_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s605␠AS␠"mz_internal"."pg_class_all_databases"]␠("relname") -pg_description_all_databases_ind CREATE␠INDEX␠"pg_description_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s614␠AS␠"mz_internal"."pg_description_all_databases"]␠("objoid",␠"classoid",␠"objsubid",␠"description",␠"oid_database_name",␠"class_database_name") -pg_namespace_all_databases_ind CREATE␠INDEX␠"pg_namespace_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s602␠AS␠"mz_internal"."pg_namespace_all_databases"]␠("nspname") -pg_type_all_databases_ind CREATE␠INDEX␠"pg_type_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s611␠AS␠"mz_internal"."pg_type_all_databases"]␠("oid") +mz_wallclock_global_lag_recent_history_ind CREATE␠INDEX␠"mz_wallclock_global_lag_recent_history_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s720␠AS␠"mz_internal"."mz_wallclock_global_lag_recent_history"]␠("object_id") +mz_webhook_sources_ind CREATE␠INDEX␠"mz_webhook_sources_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s524␠AS␠"mz_internal"."mz_webhook_sources"]␠("id") +pg_attrdef_all_databases_ind CREATE␠INDEX␠"pg_attrdef_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s625␠AS␠"mz_internal"."pg_attrdef_all_databases"]␠("oid",␠"adrelid",␠"adnum",␠"adbin",␠"adsrc") +pg_attribute_all_databases_ind CREATE␠INDEX␠"pg_attribute_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s618␠AS␠"mz_internal"."pg_attribute_all_databases"]␠("attrelid",␠"attname",␠"atttypid",␠"attlen",␠"attnum",␠"atttypmod",␠"attnotnull",␠"atthasdef",␠"attidentity",␠"attgenerated",␠"attisdropped",␠"attcollation",␠"database_name",␠"pg_type_database_name") +pg_authid_core_ind CREATE␠INDEX␠"pg_authid_core_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s635␠AS␠"mz_internal"."pg_authid_core"]␠("rolname") +pg_class_all_databases_ind CREATE␠INDEX␠"pg_class_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s606␠AS␠"mz_internal"."pg_class_all_databases"]␠("relname") +pg_description_all_databases_ind CREATE␠INDEX␠"pg_description_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s615␠AS␠"mz_internal"."pg_description_all_databases"]␠("objoid",␠"classoid",␠"objsubid",␠"description",␠"oid_database_name",␠"class_database_name") +pg_namespace_all_databases_ind CREATE␠INDEX␠"pg_namespace_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s603␠AS␠"mz_internal"."pg_namespace_all_databases"]␠("nspname") +pg_type_all_databases_ind CREATE␠INDEX␠"pg_type_all_databases_ind"␠IN␠CLUSTER␠[s2]␠ON␠[s612␠AS␠"mz_internal"."pg_type_all_databases"]␠("oid") # Record all transitive dependencies (tables, sources, views, mvs) of indexes on # the mz_catalog_server cluster. diff --git a/test/sqllogictest/oid.slt b/test/sqllogictest/oid.slt index 319b8507359f9..c029b8fea158f 100644 --- a/test/sqllogictest/oid.slt +++ b/test/sqllogictest/oid.slt @@ -1182,3 +1182,4 @@ SELECT oid, name FROM mz_objects WHERE id LIKE 's%' AND oid < 20000 ORDER BY oid 17072 mz_builtin_materialized_views 17073 parse_catalog_create_sql 17074 redact_sql +17075 mz_cluster_replica_size_details diff --git a/test/testdrive/catalog.td b/test/testdrive/catalog.td index 10e3a74b7f3e5..0ec5bfc68f587 100644 --- a/test/testdrive/catalog.td +++ b/test/testdrive/catalog.td @@ -603,6 +603,7 @@ name comment ------------------------------------------------ mz_aggregates "" mz_aws_connections "" +mz_cluster_replica_size_details "" mz_cluster_schedules "" mz_comments "" mz_continual_tasks "" @@ -817,7 +818,7 @@ test_table "" # `SHOW TABLES` and `mz_tables` should agree. > SELECT COUNT(*) FROM mz_tables WHERE id LIKE 's%' -56 +57 # There is one entry in mz_indexes for each field_number/expression of the index. > SELECT COUNT(id) FROM mz_indexes WHERE id LIKE 's%'