From 12e2759f40a70ce2b4f7283c21f57e040699d06b Mon Sep 17 00:00:00 2001 From: Alexander Alexandrov Date: Mon, 19 Feb 2024 16:19:32 +0200 Subject: [PATCH 01/13] catalog: add `optimizer_feature_overrides` for managed clusters (memory) --- src/adapter/src/coord/sequencer/cluster.rs | 6 ++++++ src/catalog/src/durable/objects.rs | 1 + src/catalog/src/memory/objects.rs | 4 ++++ 3 files changed, 11 insertions(+) diff --git a/src/adapter/src/coord/sequencer/cluster.rs b/src/adapter/src/coord/sequencer/cluster.rs index dce65663140ce..7bd59d68d3949 100644 --- a/src/adapter/src/coord/sequencer/cluster.rs +++ b/src/adapter/src/coord/sequencer/cluster.rs @@ -68,6 +68,7 @@ impl Coordinator { idle_arrangement_merge_effort: plan.compute.idle_arrangement_merge_effort, replication_factor: plan.replication_factor, disk: plan.disk, + optimizer_feature_overrides: plan.optimizer_feature_overrides.clone(), }) } CreateClusterVariant::Unmanaged(_) => ClusterVariant::Unmanaged, @@ -576,6 +577,7 @@ impl Coordinator { idle_arrangement_merge_effort: None, replication_factor: 1, disk, + optimizer_feature_overrides: Default::default(), }); } } @@ -588,6 +590,7 @@ impl Coordinator { idle_arrangement_merge_effort, replication_factor, disk, + optimizer_feature_overrides: _, }) => { use AlterOptionParameter::*; match &options.size { @@ -707,6 +710,7 @@ impl Coordinator { logging, idle_arrangement_merge_effort, disk, + optimizer_feature_overrides: _, }, ClusterVariantManaged { size: new_size, @@ -715,6 +719,7 @@ impl Coordinator { logging: new_logging, idle_arrangement_merge_effort: new_idle_arrangement_merge_effort, disk: new_disk, + optimizer_feature_overrides: _, }, ) = (&config, &new_config); @@ -849,6 +854,7 @@ impl Coordinator { logging: _, idle_arrangement_merge_effort: _, disk: new_disk, + optimizer_feature_overrides: _, } = &mut new_config; // Validate replication factor parameter diff --git a/src/catalog/src/durable/objects.rs b/src/catalog/src/durable/objects.rs index a48833012bf25..bdd9d74bcf1ba 100644 --- a/src/catalog/src/durable/objects.rs +++ b/src/catalog/src/durable/objects.rs @@ -198,6 +198,7 @@ pub struct ClusterVariantManaged { pub idle_arrangement_merge_effort: Option, pub replication_factor: u32, pub disk: bool, + pub optimizer_feature_overrides: BTreeMap, } #[derive(Clone, Debug, PartialEq, Eq)] diff --git a/src/catalog/src/memory/objects.rs b/src/catalog/src/memory/objects.rs index e6cba55981093..b5df345106ed0 100644 --- a/src/catalog/src/memory/objects.rs +++ b/src/catalog/src/memory/objects.rs @@ -30,6 +30,7 @@ use mz_expr::refresh_schedule::RefreshSchedule; use mz_expr::{CollectionPlan, MirScalarExpr, OptimizedMirRelationExpr}; use mz_ore::collections::CollectionExt; use mz_repr::adt::mz_acl_item::{AclMode, PrivilegeMap}; +use mz_repr::optimize::OptimizerFeatureOverrides; use mz_repr::role_id::RoleId; use mz_repr::{GlobalId, RelationDesc}; use mz_sql::ast::display::AstDisplay; @@ -1753,6 +1754,7 @@ pub struct ClusterVariantManaged { pub idle_arrangement_merge_effort: Option, pub replication_factor: u32, pub disk: bool, + pub optimizer_feature_overrides: OptimizerFeatureOverrides, } impl From for durable::ClusterVariantManaged { @@ -1764,6 +1766,7 @@ impl From for durable::ClusterVariantManaged { idle_arrangement_merge_effort: managed.idle_arrangement_merge_effort, replication_factor: managed.replication_factor, disk: managed.disk, + optimizer_feature_overrides: managed.optimizer_feature_overrides.into(), } } } @@ -1777,6 +1780,7 @@ impl From for ClusterVariantManaged { idle_arrangement_merge_effort: managed.idle_arrangement_merge_effort, replication_factor: managed.replication_factor, disk: managed.disk, + optimizer_feature_overrides: managed.optimizer_feature_overrides.into(), } } } From 8104b295399748a3309a249482733bcfa7d55e79 Mon Sep 17 00:00:00 2001 From: Alexander Alexandrov Date: Wed, 14 Feb 2024 14:02:22 +0200 Subject: [PATCH 02/13] catalog: add `optimizer_feature_overridess` for managed clusters (durable) --- src/buf.yaml | 2 + src/catalog/protos/hashes.json | 6 +- src/catalog/protos/objects.proto | 6 + src/catalog/protos/objects_v47.proto | 788 ++++++++++++++++++ src/catalog/src/durable/initialize.rs | 1 + .../src/durable/objects/serialization.rs | 18 +- src/catalog/src/durable/upgrade.rs | 16 +- .../src/durable/upgrade/persist/v46_to_v47.rs | 205 +++++ .../durable/upgrade/snapshots/objects_v47.txt | 100 +++ .../src/durable/upgrade/stash/v46_to_v47.rs | 75 ++ .../debug__persist_opened_trace.snap | 1 + .../snapshots/debug__stash_opened_trace.snap | 1 + .../snapshots/open__initial_snapshot.snap | 1 + 13 files changed, 1216 insertions(+), 4 deletions(-) create mode 100644 src/catalog/protos/objects_v47.proto create mode 100644 src/catalog/src/durable/upgrade/persist/v46_to_v47.rs create mode 100644 src/catalog/src/durable/upgrade/snapshots/objects_v47.txt create mode 100644 src/catalog/src/durable/upgrade/stash/v46_to_v47.rs diff --git a/src/buf.yaml b/src/buf.yaml index 0e373965ab370..a1db7969f8efa 100644 --- a/src/buf.yaml +++ b/src/buf.yaml @@ -28,6 +28,8 @@ breaking: # reason: does currently not require backward-compatibility - catalog/protos/objects_v46.proto # reason: does currently not require backward-compatibility + - catalog/protos/objects_v47.proto + # reason: does currently not require backward-compatibility - cluster-client/src/client.proto # reason: does currently not require backward-compatibility - compute-client/src/logging.proto diff --git a/src/catalog/protos/hashes.json b/src/catalog/protos/hashes.json index a999f177bc7df..d55339e62f7d8 100644 --- a/src/catalog/protos/hashes.json +++ b/src/catalog/protos/hashes.json @@ -1,7 +1,7 @@ [ { "name": "objects.proto", - "md5": "531d0dc14d10a018edd65096e75b42e3" + "md5": "05e754e13c48a5d9ed134930a40af6e3" }, { "name": "objects_v42.proto", @@ -22,5 +22,9 @@ { "name": "objects_v46.proto", "md5": "d5d7092a8001d81e73448c07b9c2717f" + }, + { + "name": "objects_v47.proto", + "md5": "5cd2d06907da6131b05c01dcbd2064f0" } ] diff --git a/src/catalog/protos/objects.proto b/src/catalog/protos/objects.proto index 74330e2cc5649..6e14dd72c004d 100644 --- a/src/catalog/protos/objects.proto +++ b/src/catalog/protos/objects.proto @@ -315,6 +315,11 @@ message ReplicaMergeEffort { uint32 effort = 1; } +message OptimizerFeatureOverride { + string name = 1; + string value = 2; +} + message ClusterConfig { message ManagedCluster { string size = 1; @@ -323,6 +328,7 @@ message ClusterConfig { ReplicaLogging logging = 4; ReplicaMergeEffort idle_arrangement_merge_effort = 5; bool disk = 6; + repeated OptimizerFeatureOverride optimizer_feature_overrides = 7; } oneof variant { diff --git a/src/catalog/protos/objects_v47.proto b/src/catalog/protos/objects_v47.proto new file mode 100644 index 0000000000000..32dcae1d036ee --- /dev/null +++ b/src/catalog/protos/objects_v47.proto @@ -0,0 +1,788 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +// This protobuf file defines the types we store in the Stash. +// +// Before and after modifying this file, make sure you have a snapshot of the before version, +// e.g. a copy of this file named 'objects_v{CATALOG_VERSION}.proto', and a snapshot of the file +// after your modifications, e.g. 'objects_v{CATALOG_VERSION + 1}.proto'. Then you can write a +// migration using these two files, and no matter how they types change in the future, we'll always +// have these snapshots to facilitate the migration. + +// buf breaking: ignore (does currently not require backward-compatibility) + +syntax = "proto3"; + +package objects_v47; + +message ConfigKey { + string key = 1; +} + +message ConfigValue { + uint64 value = 1; +} + +message SettingKey { + string name = 1; +} + +message SettingValue { + string value = 1; +} + +message IdAllocKey { + string name = 1; +} + +message IdAllocValue { + uint64 next_id = 1; +} + +message GidMappingKey { + string schema_name = 1; + CatalogItemType object_type = 2; + string object_name = 3; +} + +message GidMappingValue { + uint64 id = 1; + string fingerprint = 2; +} + +message ClusterKey { + ClusterId id = 1; +} + +message ClusterValue { + reserved 2; + string name = 1; + RoleId owner_id = 3; + repeated MzAclItem privileges = 4; + ClusterConfig config = 5; +} + +message ClusterIntrospectionSourceIndexKey { + ClusterId cluster_id = 1; + string name = 2; +} + +message ClusterIntrospectionSourceIndexValue { + uint64 index_id = 1; +} + +message ClusterReplicaKey { + ReplicaId id = 1; +} + +message ClusterReplicaValue { + ClusterId cluster_id = 1; + string name = 2; + ReplicaConfig config = 3; + RoleId owner_id = 4; +} + +message DatabaseKey { + DatabaseId id = 1; +} + +message DatabaseValue { + string name = 1; + RoleId owner_id = 2; + repeated MzAclItem privileges = 3; +} + +message SchemaKey { + SchemaId id = 1; +} + +message SchemaValue { + DatabaseId database_id = 1; + string name = 2; + RoleId owner_id = 3; + repeated MzAclItem privileges = 4; +} + +message ItemKey { + GlobalId gid = 1; +} + +message ItemValue { + SchemaId schema_id = 1; + string name = 2; + CatalogItem definition = 3; + RoleId owner_id = 4; + repeated MzAclItem privileges = 5; +} + +message RoleKey { + RoleId id = 1; +} + +message RoleValue { + string name = 1; + RoleAttributes attributes = 2; + RoleMembership membership = 3; + RoleVars vars = 4; +} + +message TimestampKey { + string id = 1; +} + +message TimestampValue { + Timestamp ts = 1; +} + +message ServerConfigurationKey { + string name = 1; +} + +message ServerConfigurationValue { + string value = 1; +} + +message AuditLogKey { + oneof event { + AuditLogEventV1 v1 = 1; + } +} + +message StorageUsageKey { + message StorageUsageV1 { + uint64 id = 1; + StringWrapper shard_id = 2; + uint64 size_bytes = 3; + EpochMillis collection_timestamp = 4; + } + + oneof usage { + StorageUsageV1 v1 = 1; + } +} + +message CommentKey { + oneof object { + GlobalId table = 1; + GlobalId view = 2; + GlobalId materialized_view = 4; + GlobalId source = 5; + GlobalId sink = 6; + GlobalId index = 7; + GlobalId func = 8; + GlobalId connection = 9; + GlobalId type = 10; + GlobalId secret = 11; + RoleId role = 12; + DatabaseId database = 13; + ResolvedSchema schema = 14; + ClusterId cluster = 15; + ClusterReplicaId cluster_replica = 16; + } + oneof sub_component { + uint64 column_pos = 3; + } +} + +message CommentValue { + string comment = 1; +} + +// ---- Common Types +// +// Note: Normally types like this would go in some sort of `common.proto` file, but we want to keep +// our proto definitions in a single file to make snapshotting easier, hence them living here. + +message Empty { /* purposefully empty */ } + +// In protobuf a "None" string is the same thing as an empty string. To get the same semantics of +// an `Option` from Rust, we need to wrap a string in a message. +message StringWrapper { + string inner = 1; +} + +message Duration { + uint64 secs = 1; + uint32 nanos = 2; +} + +message EpochMillis { + uint64 millis = 1; +} + +// Opaque timestamp type that is specific to Materialize. +message Timestamp { + uint64 internal = 1; +} + +enum CatalogItemType { + CATALOG_ITEM_TYPE_UNKNOWN = 0; + CATALOG_ITEM_TYPE_TABLE = 1; + CATALOG_ITEM_TYPE_SOURCE = 2; + CATALOG_ITEM_TYPE_SINK = 3; + CATALOG_ITEM_TYPE_VIEW = 4; + CATALOG_ITEM_TYPE_MATERIALIZED_VIEW = 5; + CATALOG_ITEM_TYPE_INDEX = 6; + CATALOG_ITEM_TYPE_TYPE = 7; + CATALOG_ITEM_TYPE_FUNC = 8; + CATALOG_ITEM_TYPE_SECRET = 9; + CATALOG_ITEM_TYPE_CONNECTION = 10; +} + +message CatalogItem { + message V1 { + string create_sql = 1; + } + + oneof value { + V1 v1 = 1; + } +} + +message GlobalId { + oneof value { + uint64 system = 1; + uint64 user = 2; + uint64 transient = 3; + Empty explain = 4; + } +} + +message ClusterId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message DatabaseId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message ResolvedDatabaseSpecifier { + oneof spec { + Empty ambient = 1; + DatabaseId id = 2; + } +} + +message SchemaId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message SchemaSpecifier { + oneof spec { + Empty temporary = 1; + SchemaId id = 2; + } +} + +message ResolvedSchema { + ResolvedDatabaseSpecifier database = 1; + SchemaSpecifier schema = 2; +} + +message ReplicaId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message ClusterReplicaId { + ClusterId cluster_id = 1; + ReplicaId replica_id = 2; +} + +message ReplicaLogging { + bool log_logging = 1; + Duration interval = 2; +} + +message ReplicaMergeEffort { + uint32 effort = 1; +} + +message OptimizerFeatureOverride { + string name = 1; + string value = 2; +} + +message ClusterConfig { + message ManagedCluster { + string size = 1; + uint32 replication_factor = 2; + repeated string availability_zones = 3; + ReplicaLogging logging = 4; + ReplicaMergeEffort idle_arrangement_merge_effort = 5; + bool disk = 6; + repeated OptimizerFeatureOverride optimizer_feature_overrides = 7; + } + + oneof variant { + Empty unmanaged = 1; + ManagedCluster managed = 2; + } +} + +message ReplicaConfig { + message UnmanagedLocation { + repeated string storagectl_addrs = 1; + repeated string storage_addrs = 2; + repeated string computectl_addrs = 3; + repeated string compute_addrs = 4; + uint64 workers = 5; + } + + message ManagedLocation { + string size = 1; + optional string availability_zone = 2; + bool disk = 4; + bool internal = 5; + optional string billed_as = 6; + } + + oneof location { + UnmanagedLocation unmanaged = 1; + ManagedLocation managed = 2; + } + ReplicaLogging logging = 3; + ReplicaMergeEffort idle_arrangement_merge_effort = 4; +} + +message RoleId { + oneof value { + uint64 system = 1; + uint64 user = 2; + Empty public = 3; + } +} + +message RoleAttributes { + bool inherit = 1; +} + +message RoleMembership { + message Entry { + RoleId key = 1; + RoleId value = 2; + } + + repeated Entry map = 1; +} + +message RoleVars { + message SqlSet { + repeated string entries = 1; + } + + message Entry { + string key = 1; + oneof val { + string flat = 2; + SqlSet sql_set = 3; + } + } + + repeated Entry entries = 1; +} + +message AclMode { + // A bit flag representing all the privileges that can be granted to a role. + uint64 bitflags = 1; +} + +message MzAclItem { + RoleId grantee = 1; + RoleId grantor = 2; + AclMode acl_mode = 3; +} + +enum ObjectType { + OBJECT_TYPE_UNKNOWN = 0; + OBJECT_TYPE_TABLE = 1; + OBJECT_TYPE_VIEW = 2; + OBJECT_TYPE_MATERIALIZED_VIEW = 3; + OBJECT_TYPE_SOURCE = 4; + OBJECT_TYPE_SINK = 5; + OBJECT_TYPE_INDEX = 6; + OBJECT_TYPE_TYPE = 7; + OBJECT_TYPE_ROLE = 8; + OBJECT_TYPE_CLUSTER = 9; + OBJECT_TYPE_CLUSTER_REPLICA = 10; + OBJECT_TYPE_SECRET = 11; + OBJECT_TYPE_CONNECTION = 12; + OBJECT_TYPE_DATABASE = 13; + OBJECT_TYPE_SCHEMA = 14; + OBJECT_TYPE_FUNC = 15; +} + +message DefaultPrivilegesKey { + RoleId role_id = 1; + DatabaseId database_id = 2; + SchemaId schema_id = 3; + ObjectType object_type = 4; + RoleId grantee = 5; +} + +message DefaultPrivilegesValue { + AclMode privileges = 1; +} + +message SystemPrivilegesKey { + RoleId grantee = 1; + RoleId grantor = 2; +} + +message SystemPrivilegesValue { + AclMode acl_mode = 1; +} + +message AuditLogEventV1 { + enum EventType { + EVENT_TYPE_UNKNOWN = 0; + EVENT_TYPE_CREATE = 1; + EVENT_TYPE_DROP = 2; + EVENT_TYPE_ALTER = 3; + EVENT_TYPE_GRANT = 4; + EVENT_TYPE_REVOKE = 5; + } + + enum ObjectType { + OBJECT_TYPE_UNKNOWN = 0; + OBJECT_TYPE_CLUSTER = 1; + OBJECT_TYPE_CLUSTER_REPLICA = 2; + OBJECT_TYPE_CONNECTION = 3; + OBJECT_TYPE_DATABASE = 4; + OBJECT_TYPE_FUNC = 5; + OBJECT_TYPE_INDEX = 6; + OBJECT_TYPE_MATERIALIZED_VIEW = 7; + OBJECT_TYPE_ROLE = 8; + OBJECT_TYPE_SECRET = 9; + OBJECT_TYPE_SCHEMA = 10; + OBJECT_TYPE_SINK = 11; + OBJECT_TYPE_SOURCE = 12; + OBJECT_TYPE_TABLE = 13; + OBJECT_TYPE_TYPE = 14; + OBJECT_TYPE_VIEW = 15; + OBJECT_TYPE_SYSTEM = 16; + } + + message IdFullNameV1 { + string id = 1; + FullNameV1 name = 2; + } + + message FullNameV1 { + string database = 1; + string schema = 2; + string item = 3; + } + + message IdNameV1 { + string id = 1; + string name = 2; + } + + message RenameClusterV1 { + string id = 1; + string old_name = 2; + string new_name = 3; + } + + message RenameClusterReplicaV1 { + string cluster_id = 1; + string replica_id = 2; + string old_name = 3; + string new_name = 4; + } + + message RenameItemV1 { + string id = 1; + FullNameV1 old_name = 2; + FullNameV1 new_name = 3; + } + + message CreateClusterReplicaV1 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + string logical_size = 5; + bool disk = 6; + optional string billed_as = 7; + bool internal = 8; + } + + message DropClusterReplicaV1 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + } + + message CreateSourceSinkV1 { + string id = 1; + FullNameV1 name = 2; + StringWrapper size = 3; + } + + message CreateSourceSinkV2 { + string id = 1; + FullNameV1 name = 2; + StringWrapper size = 3; + string external_type = 4; + } + + message CreateSourceSinkV3 { + string id = 1; + FullNameV1 name = 2; + string external_type = 3; + } + + message AlterSourceSinkV1 { + string id = 1; + FullNameV1 name = 2; + StringWrapper old_size = 3; + StringWrapper new_size = 4; + } + + message AlterSetClusterV1 { + string id = 1; + FullNameV1 name = 2; + StringWrapper old_cluster = 3; + StringWrapper new_cluster = 4; + } + + message GrantRoleV1 { + string role_id = 1; + string member_id = 2; + string grantor_id = 3; + } + + message GrantRoleV2 { + string role_id = 1; + string member_id = 2; + string grantor_id = 3; + string executed_by = 4; + } + + message RevokeRoleV1 { + string role_id = 1; + string member_id = 2; + } + + message RevokeRoleV2 { + string role_id = 1; + string member_id = 2; + string grantor_id = 3; + string executed_by = 4; + } + + message UpdatePrivilegeV1 { + string object_id = 1; + string grantee_id = 2; + string grantor_id = 3; + string privileges = 4; + } + + message AlterDefaultPrivilegeV1 { + string role_id = 1; + StringWrapper database_id = 2; + StringWrapper schema_id = 3; + string grantee_id= 4; + string privileges = 5; + } + + message UpdateOwnerV1 { + string object_id = 1; + string old_owner_id = 2; + string new_owner_id = 3; + } + + message SchemaV1 { + string id = 1; + string name = 2; + string database_name = 3; + } + + message SchemaV2 { + string id = 1; + string name = 2; + StringWrapper database_name = 3; + } + + message RenameSchemaV1 { + string id = 1; + optional string database_name = 2; + string old_name = 3; + string new_name = 4; + } + + message UpdateItemV1 { + string id = 1; + FullNameV1 name = 2; + } + + uint64 id = 1; + EventType event_type = 2; + ObjectType object_type = 3; + StringWrapper user = 4; + EpochMillis occurred_at = 5; + + // next-id: 29 + oneof details { + CreateClusterReplicaV1 create_cluster_replica_v1 = 6; + DropClusterReplicaV1 drop_cluster_replica_v1 = 7; + CreateSourceSinkV1 create_source_sink_v1 = 8; + CreateSourceSinkV2 create_source_sink_v2 = 9; + AlterSourceSinkV1 alter_source_sink_v1 = 10; + AlterSetClusterV1 alter_set_cluster_v1 = 25; + GrantRoleV1 grant_role_v1 = 11; + GrantRoleV2 grant_role_v2 = 12; + RevokeRoleV1 revoke_role_v1 = 13; + RevokeRoleV2 revoke_role_v2 = 14; + UpdatePrivilegeV1 update_privilege_v1 = 22; + AlterDefaultPrivilegeV1 alter_default_privilege_v1 = 23; + UpdateOwnerV1 update_owner_v1 = 24; + IdFullNameV1 id_full_name_v1 = 15; + RenameClusterV1 rename_cluster_v1 = 20; + RenameClusterReplicaV1 rename_cluster_replica_v1 = 21; + RenameItemV1 rename_item_v1 = 16; + IdNameV1 id_name_v1 = 17; + SchemaV1 schema_v1 = 18; + SchemaV2 schema_v2 = 19; + RenameSchemaV1 rename_schema_v1 = 27; + UpdateItemV1 update_item_v1 = 26; + CreateSourceSinkV3 create_source_sink_v3 = 29; + } +} + +// Wrapper of key-values used by the persist implementation to serialize the catalog. +message StateUpdateKind { + message AuditLog { + AuditLogKey key = 1; + } + + message Cluster { + ClusterKey key = 1; + ClusterValue value = 2; + } + + message ClusterReplica { + ClusterReplicaKey key = 1; + ClusterReplicaValue value = 2; + } + + message Comment { + CommentKey key = 1; + CommentValue value = 2; + } + + message Config { + ConfigKey key = 1; + ConfigValue value = 2; + } + + message Database { + DatabaseKey key = 1; + DatabaseValue value = 2; + } + + message DefaultPrivileges { + DefaultPrivilegesKey key = 1; + DefaultPrivilegesValue value = 2; + } + + message Epoch { + int64 epoch = 1; + } + + message IdAlloc { + IdAllocKey key = 1; + IdAllocValue value = 2; + } + + message ClusterIntrospectionSourceIndex { + ClusterIntrospectionSourceIndexKey key = 1; + ClusterIntrospectionSourceIndexValue value = 2; + } + + message Item { + ItemKey key = 1; + ItemValue value = 2; + } + + message Role { + RoleKey key = 1; + RoleValue value = 2; + } + + message Schema { + SchemaKey key = 1; + SchemaValue value = 2; + } + + message Setting { + SettingKey key = 1; + SettingValue value = 2; + } + + message StorageUsage { + StorageUsageKey key = 1; + } + + message ServerConfiguration { + ServerConfigurationKey key = 1; + ServerConfigurationValue value = 2; + } + + message GidMapping { + GidMappingKey key = 1; + GidMappingValue value = 2; + } + + message SystemPrivileges { + SystemPrivilegesKey key = 1; + SystemPrivilegesValue value = 2; + } + + message Timestamp { + TimestampKey key = 1; + TimestampValue value = 2; + } + + oneof kind { + AuditLog audit_log = 1; + Cluster cluster = 2; + ClusterReplica cluster_replica = 3; + Comment comment = 4; + Config config = 5; + Database database = 6; + DefaultPrivileges default_privileges = 7; + Epoch epoch = 8; + IdAlloc id_alloc = 9; + ClusterIntrospectionSourceIndex cluster_introspection_source_index = 10; + Item item = 11; + Role role = 12; + Schema schema = 13; + Setting setting = 14; + StorageUsage storage_usage = 15; + ServerConfiguration server_configuration = 16; + GidMapping gid_mapping = 17; + SystemPrivileges system_privileges = 18; + Timestamp timestamp = 19; + } +} diff --git a/src/catalog/src/durable/initialize.rs b/src/catalog/src/durable/initialize.rs index 0fffb105c1069..42dcc96951805 100644 --- a/src/catalog/src/durable/initialize.rs +++ b/src/catalog/src/durable/initialize.rs @@ -628,6 +628,7 @@ fn default_cluster_config(args: &BootstrapArgs) -> ClusterConfig { }, idle_arrangement_merge_effort: None, disk: false, + optimizer_feature_overrides: Default::default(), }), } } diff --git a/src/catalog/src/durable/objects/serialization.rs b/src/catalog/src/durable/objects/serialization.rs index ce43d288be4d3..561c8eb59653d 100644 --- a/src/catalog/src/durable/objects/serialization.rs +++ b/src/catalog/src/durable/objects/serialization.rs @@ -20,7 +20,7 @@ use mz_audit_log::{ use mz_compute_client::controller::ComputeReplicaLogging; use mz_controller_types::ReplicaId; use mz_ore::cast::CastFrom; -use mz_proto::{IntoRustIfSome, ProtoType, RustType, TryFromProtoError}; +use mz_proto::{IntoRustIfSome, ProtoMapEntry, ProtoType, RustType, TryFromProtoError}; use mz_repr::adt::mz_acl_item::{AclMode, MzAclItem}; use mz_repr::role_id::RoleId; use mz_repr::{GlobalId, Timestamp}; @@ -64,6 +64,19 @@ impl TryFrom for proto::StateUpdateKind { } } +impl ProtoMapEntry for proto::OptimizerFeatureOverride { + fn from_rust<'a>(entry: (&'a String, &'a String)) -> Self { + proto::OptimizerFeatureOverride { + name: entry.0.into_proto(), + value: entry.1.into_proto(), + } + } + + fn into_rust(self) -> Result<(String, String), TryFromProtoError> { + Ok((self.name.into_rust()?, self.value.into_rust()?)) + } +} + impl RustType for ClusterConfig { fn into_proto(&self) -> proto::ClusterConfig { proto::ClusterConfig { @@ -88,6 +101,7 @@ impl RustType for ClusterVariant { idle_arrangement_merge_effort, replication_factor, disk, + optimizer_feature_overrides, }) => proto::cluster_config::Variant::Managed(proto::cluster_config::ManagedCluster { size: size.to_string(), availability_zones: availability_zones.clone(), @@ -96,6 +110,7 @@ impl RustType for ClusterVariant { .map(|effort| proto::ReplicaMergeEffort { effort }), replication_factor: *replication_factor, disk: *disk, + optimizer_feature_overrides: optimizer_feature_overrides.into_proto(), }), ClusterVariant::Unmanaged => proto::cluster_config::Variant::Unmanaged(proto::Empty {}), } @@ -116,6 +131,7 @@ impl RustType for ClusterVariant { .map(|e| e.effort), replication_factor: managed.replication_factor, disk: managed.disk, + optimizer_feature_overrides: managed.optimizer_feature_overrides.into_rust()?, })) } } diff --git a/src/catalog/src/durable/upgrade.rs b/src/catalog/src/durable/upgrade.rs index 68f854a35d782..44d8bf8d8b000 100644 --- a/src/catalog/src/durable/upgrade.rs +++ b/src/catalog/src/durable/upgrade.rs @@ -161,14 +161,14 @@ macro_rules! objects { } } -objects!(v42, v43, v44, v45, v46); +objects!(v42, v43, v44, v45, v46, v47); /// The current version of the `Catalog`. /// /// We will initialize new `Catalog`es with this version, and migrate existing `Catalog`es to this /// version. Whenever the `Catalog` changes, e.g. the protobufs we serialize in the `Catalog` /// change, we need to bump this version. -pub const CATALOG_VERSION: u64 = 46; +pub const CATALOG_VERSION: u64 = 47; /// The minimum `Catalog` version number that we support migrating from. /// @@ -196,6 +196,7 @@ pub(crate) mod stash { mod v43_to_v44; mod v44_to_v45; mod v45_to_v46; + mod v46_to_v47; #[mz_ore::instrument(name = "stash::upgrade", level = "debug")] pub(crate) async fn upgrade(stash: &mut Stash) -> Result<(), StashError> { @@ -223,6 +224,7 @@ pub(crate) mod stash { 43 => v43_to_v44::upgrade(), 44 => v44_to_v45::upgrade(&tx).await?, 45 => v45_to_v46::upgrade(&tx).await?, + 46 => v46_to_v47::upgrade(&tx).await?, // Up-to-date, no migration needed! CATALOG_VERSION => return Ok(CATALOG_VERSION), @@ -302,6 +304,7 @@ pub(crate) mod persist { mod v43_to_v44; mod v44_to_v45; mod v45_to_v46; + mod v46_to_v47; /// Describes a single action to take during a migration from `V1` to `V2`. #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] @@ -413,6 +416,15 @@ pub(crate) mod persist { ) .await } + 46 => { + run_versioned_upgrade( + unopened_catalog_state, + mode, + version, + v46_to_v47::upgrade, + ) + .await + } // Up-to-date, no migration needed! CATALOG_VERSION => Ok(CATALOG_VERSION), diff --git a/src/catalog/src/durable/upgrade/persist/v46_to_v47.rs b/src/catalog/src/durable/upgrade/persist/v46_to_v47.rs new file mode 100644 index 0000000000000..1dfbdd9ccbe50 --- /dev/null +++ b/src/catalog/src/durable/upgrade/persist/v46_to_v47.rs @@ -0,0 +1,205 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +use mz_stash::upgrade::WireCompatible; + +use crate::durable::upgrade::persist::MigrationAction; +use crate::durable::upgrade::{objects_v46 as v46, objects_v47 as v47}; + +/// Introduce empty `optimizer_feature_overrides` in `ManagedCluster`'s. +pub fn upgrade( + snapshot: Vec, +) -> Vec> { + snapshot + .into_iter() + .filter_map(|update| { + let update = update.kind.as_ref().expect("missing field"); + let v46::state_update_kind::Kind::Cluster(update) = update else { + return None; + }; + if !update.is_managed() { + return None; + }; + + let old = v46::StateUpdateKind { + kind: Some(v46::state_update_kind::Kind::Cluster( + v46::state_update_kind::Cluster { + key: update.key.clone(), + value: update.value.clone(), + }, + )), + }; + + let new = v47::StateUpdateKind { + kind: Some(v47::state_update_kind::Kind::Cluster( + v47::state_update_kind::Cluster { + key: update.key.as_ref().map(WireCompatible::convert), + value: update.value.as_ref().map(|old_val| v47::ClusterValue { + name: old_val.name.clone(), + owner_id: old_val.owner_id.as_ref().map(WireCompatible::convert), + privileges: old_val + .privileges + .iter() + .map(WireCompatible::convert) + .collect(), + config: old_val.config.as_ref().map(|config| v47::ClusterConfig { + variant: config.variant.as_ref().map(|variant| match variant { + v46::cluster_config::Variant::Unmanaged(_) => { + v47::cluster_config::Variant::Unmanaged(v47::Empty {}) + } + v46::cluster_config::Variant::Managed(c) => { + v47::cluster_config::Variant::Managed( + v47::cluster_config::ManagedCluster { + size: c.size.clone(), + replication_factor: c.replication_factor, + availability_zones: c.availability_zones.clone(), + logging: c + .logging + .as_ref() + .map(WireCompatible::convert), + idle_arrangement_merge_effort: c + .idle_arrangement_merge_effort + .as_ref() + .map(WireCompatible::convert), + disk: c.disk, + optimizer_feature_overrides: Vec::new(), + }, + ) + } + }), + }), + }), + }, + )), + }; + + Some(MigrationAction::Update(old, new)) + }) + .collect() +} + +impl v46::state_update_kind::Cluster { + fn is_managed(&self) -> bool { + let Some(cluster) = self.value.as_ref() else { + return false; + }; + let Some(config) = cluster.config.as_ref() else { + return false; + }; + match config.variant.as_ref() { + Some(v46::cluster_config::Variant::Managed(_)) => true, + _ => false, + } + } +} + +#[cfg(test)] +mod tests { + + use super::*; + + #[mz_ore::test(tokio::test)] + #[cfg_attr(miri, ignore)] // unsupported operation: can't call foreign function `TLS_client_method` on OS `linux` + async fn smoke_test_migration() { + let v46 = v46::StateUpdateKind { + kind: Some(v46::state_update_kind::Kind::Cluster( + v46::state_update_kind::Cluster { + key: Some(v46::ClusterKey { + id: Some(v46::ClusterId { + value: Some(v46::cluster_id::Value::User(Default::default())), + }), + }), + value: Some(v46::ClusterValue { + name: Default::default(), + owner_id: Some(v46::RoleId { + value: Some(v46::role_id::Value::Public(Default::default())), + }), + privileges: vec![], + config: Some(v46::ClusterConfig { + variant: Some(v46::cluster_config::Variant::Managed( + v46::cluster_config::ManagedCluster { + size: String::from("1cc"), + replication_factor: 2, + availability_zones: vec![ + String::from("az1"), + String::from("az2"), + ], + logging: Some(v46::ReplicaLogging { + log_logging: true, + interval: Some(v46::Duration { + secs: 3600, + nanos: 747, + }), + }), + idle_arrangement_merge_effort: Some(v46::ReplicaMergeEffort { + effort: 42, + }), + disk: true, + }, + )), + }), + }), + }, + )), + }; + + let v47 = v47::StateUpdateKind { + kind: Some(v47::state_update_kind::Kind::Cluster( + v47::state_update_kind::Cluster { + key: Some(v47::ClusterKey { + id: Some(v47::ClusterId { + value: Some(v47::cluster_id::Value::User(Default::default())), + }), + }), + value: Some(v47::ClusterValue { + name: Default::default(), + owner_id: Some(v47::RoleId { + value: Some(v47::role_id::Value::Public(Default::default())), + }), + privileges: vec![], + config: Some(v47::ClusterConfig { + variant: Some(v47::cluster_config::Variant::Managed( + v47::cluster_config::ManagedCluster { + size: String::from("1cc"), + replication_factor: 2, + availability_zones: vec![ + String::from("az1"), + String::from("az2"), + ], + logging: Some(v47::ReplicaLogging { + log_logging: true, + interval: Some(v47::Duration { + secs: 3600, + nanos: 747, + }), + }), + idle_arrangement_merge_effort: Some(v47::ReplicaMergeEffort { + effort: 42, + }), + disk: true, + optimizer_feature_overrides: Vec::new(), + }, + )), + }), + }), + }, + )), + }; + + let actions = upgrade(vec![v46.clone()]); + + match &actions[..] { + [MigrationAction::Update(old, new)] => { + assert_eq!(old, &v46); + assert_eq!(new, &v47); + } + o => panic!("expected single MigrationAction::Update, got {:?}", o), + } + } +} diff --git a/src/catalog/src/durable/upgrade/snapshots/objects_v47.txt b/src/catalog/src/durable/upgrade/snapshots/objects_v47.txt new file mode 100644 index 0000000000000..9d4accaf4f468 --- /dev/null +++ b/src/catalog/src/durable/upgrade/snapshots/objects_v47.txt @@ -0,0 +1,100 @@ +CjwKOroBNwoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgoLCgV2YWx1ZRICCAQ= +CigKJroBIwoJCgNrZXkSAggEChYKBGtpbmQSDkIMU3RvcmFnZVVzYWdl +Cm4KbLoBaQoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgo9CgV2YWx1ZRI0ugExCi8KBXZhbHVlEiZCJOCuqPCQi63wkJWy8JGNl0kiWHvqrJFKL/CQvKdeXj8v2JkkWw== +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +CloKWLoBVQonCgNrZXkSILoBHQobCgRuYW1lEhNCET0kUeCyrlB78J64uV5u4oKICh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgoLCgV2YWx1ZRICCAQ= +CjAKLroBKwoYCgVlcG9jaBIPwgEMCgoDACIRZUVgZlc9Cg8KBGtpbmQSB0IFRXBvY2g= +CpMBCpABugGMAQpQCgNrZXkSSboBRgoNCgdncmFudGVlEgIIBAo1CgdncmFudG9yEiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKChIJSZKHIxRzJVwKGgoEa2luZBISQhBTeXN0ZW1Qcml2aWxlZ2VzChwKBXZhbHVlEhO6ARAKDgoIYWNsX21vZGUSAggE +CjAKLroBKwoYCgVlcG9jaBIPwgEMCgo4KVAJiRQkiElcCg8KBGtpbmQSB0IFRXBvY2g= +CjAKLroBKwoYCgVlcG9jaBIPwgEMCgpxclR0eRgoNAdMCg8KBGtpbmQSB0IFRXBvY2g= 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 +Ci8KLboBKgoJCgNrZXkSAggEChAKBGtpbmQSCEIGQ29uZmlnCgsKBXZhbHVlEgIIBA== +CoUBCoIBugF/CgkKA2tleRICCAQKDgoEa2luZBIGQgRSb2xlCmIKBXZhbHVlElm6AVYKIAoKYXR0cmlidXRlcxISugEPCg0KB2luaGVyaXQSAggDChAKCm1lbWJlcnNoaXASAggEChQKBG5hbWUSDEIKceCpkeCznSU6IgoKCgR2YXJzEgIIBA== +Ck0KS7oBSAoJCgNrZXkSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKHgoFdmFsdWUSFboBEgoQCgpwcml2aWxlZ2VzEgIIBA== +CuMvCuAvugHcLwoJCgNrZXkSAggECg4KBGtpbmQSBkIESXRlbQq+LwoFdmFsdWUStC+6AbAvCn0KCmRlZmluaXRpb24Sb7oBbApqCgV2YWx1ZRJhugFeClwKAlYxEla6AVMKUQoKY3JlYXRlX3NxbBJDQkHwkLy74KaF8JCdpkQv8Ja9kfCen60/8J6Aj+KAiuK1r2Il0ajwn6yQ8JGciCbwnZOx4KuQ8JGkiS9I8JuKqCZ2ewo0CgRuYW1lEixCKsKlPSXwnoWOOeK1sHtT77mOKnvgtbzhh4km8J2EjTohePCen6siLjrCugoOCghvd25lcl9pZBICCAQKrS0KCnByaXZpbGVnZXMSni2yAZotCl26AVoKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoVEwiZlpCRUXIcCg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKXboBWgoOCghhY2xfbW9kZRICCAQKKwoHZ3JhbnRlZRIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBApPugFMCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKYSFxI3STCEc5PAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAp4ugF1CjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKGCdHODgwRhkijBD///////////8BCg0KB2dyYW50ZWUSAggECisKB2dyYW50b3ISILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACm66AWsKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBF4YzcJmQIjcCXAoNCgdncmFudGVlEgIIBAorCgdncmFudG9yEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAApPugFMCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKKFQkNIlhIkhlPAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApdugFaCg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECisKB2dyYW50b3ISILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACj+6ATwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApdugFaCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKlpFhYoFwaQZpfAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggECl26AVoKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgomUEMQlARGM5E8ChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRvchICCAQKbroBawotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFhIzJFcyl0iAlMCisKB2dyYW50ZWUSILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACg0KB2dyYW50b3ISAggEClu6AVgKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECjcKB2dyYW50b3ISLLoBKQonCgV2YWx1ZRIeugEbChkKBlN5c3RlbRIPwgEMCgpDg0GERTg5MEiMCl26AVoKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgomcVZkc5IZaYhcChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRvchICCAQKULoBTQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwERgSQWdDEoQlicCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggEClu6AVgKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECjcKB2dyYW50b3ISLLoBKQonCgV2YWx1ZRIeugEbChkKBlN5c3RlbRIPwgEMCgqGAYcZKHeEJWgcCm66AWsKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBWXGTdEEEMyYXLAoNCgdncmFudGVlEgIIBAorCgdncmFudG9yEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAAp6ugF3CiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKlxkCE2hlV5JFHAoNCgdncmFudGVlEgIIBAo4CgdncmFudG9yEi26ASoKKAoFdmFsdWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLAThHAFKDUDOZFJwKhwG6AYMBCjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKAUIUU4gnljKQTBD+//////////8BCisKB2dyYW50ZWUSILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEAChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKULoBTQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFHVBJBASiYJph8Cg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECmy6AWkKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBJUJUZgWSETFXTAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKXboBWgosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCoNwdoFDYJIwQIwKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApdugFaCg4KCGFjbF9tb2RlEgIIBAorCgdncmFudGVlEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECmm6AWYKDgoIYWNsX21vZGUSAggEChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKNwoHZ3JhbnRvchIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCnkiWJWTkQVVaJwKP7oBPAoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBApPugFMCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKNoIZAVYVVXMDLAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAqJAboBhQEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgolhVAxIGF0YUkcCjgKB2dyYW50ZWUSLboBKgooCgV2YWx1ZRIfugEcChoKBlN5c3RlbRIQwgENCgsBRAlWNSZiYBKZfAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECoQBugGAAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCnIQEGlpCUY3BxwKDQoHZ3JhbnRlZRICCAQKQQoHZ3JhbnRvchI2ugEzCjEKBXZhbHVlEii6ASUKIwoGU3lzdGVtEhnCARYKCROAcGhkdQQgnBD///////////8BClC6AU0KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBA1NxZicQAXeVfAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAptugFqCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKJTQzcXM4BkUZjAoNCgdncmFudGVlEgIIBAorCgdncmFudG9yEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAAo/ugE8Cg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECl26AVoKDgoIYWNsX21vZGUSAggEChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKKwoHZ3JhbnRvchIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKigG6AYYBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAXWVYnZZgnQVQ2wKOAoHZ3JhbnRlZRItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFhdEcGYncBlDYcChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKT7oBTAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCoJFYEAoUBEiNpwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKXLoBWQorCghhY2xfbW9kZRIfugEcChoKCGJpdGZsYWdzEg7CAQsKCRlHc5IIVnY4jAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggECj+6ATwKDgoIYWNsX21vZGUSAggEChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRvchICCAQKT7oBTAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCmcAhIRVEUAhmXwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKXroBWwotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFmJ2UHWANyUpccCg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKaroBZwoOCghhY2xfbW9kZRICCAQKOAoHZ3JhbnRlZRItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwF1kjQjJ4NoBngcChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKeroBdwosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCnMpIZZ1B3JoeGwKOAoHZ3JhbnRlZRItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwGCgGM4OYhJUQJ8Cg0KB2dyYW50b3ISAggECnq6AXcKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBJQUzlwFXQnZhLAoNCgdncmFudGVlEgIIBAo3CgdncmFudG9yEiy6ASkKJwoFdmFsdWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKkiRIQZBkVogRjApaugFXCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAo2CgdncmFudG9yEiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwERk4UGEmcnZSOMCj+6ATwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKMboBLgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKd7oBdAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKClAXhDOCkUUIZSwKDQoHZ3JhbnRlZRICCAQKNQoHZ3JhbnRvchIqugEnCiUKBXZhbHVlEhy6ARkKFwoEVXNlchIPwgEMCgoBAVN5OJAUEUhMCk+6AUwKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpEVQMAkEQ0YjacCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECk+6AUwKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqVmVUzAzhRk3GMCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECj+6ATwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKdroBcwo3CghhY2xfbW9kZRIrugEoCiYKCGJpdGZsYWdzEhrCARcKChCFmBMygziIKRwQ////////////AQobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKULoBTQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwF2dEFzZpk3VjcsCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECj+6ATwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKT7oBTAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKClA0JFeDkocEBiwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKeLoBdQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCnVxFFY4kTERZBwKDQoHZ3JhbnRlZRICCAQKNgoHZ3JhbnRvchIrugEoCiYKBXZhbHVlEh26ARoKGAoGU3lzdGVtEg7CAQsKCYZjGHQIBjYCfAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAp4ugF1Cg4KCGFjbF9tb2RlEgIIBAorCgdncmFudGVlEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAAo2CgdncmFudG9yEiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwEVdzcoRyAHQpV8CjG6AS4KDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggEClq6AVcKNwoIYWNsX21vZGUSK7oBKAomCghiaXRmbGFncxIawgEXCgoEYjkRgpMYJAIsEP///////////wEKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKa7oBaAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCkc3VoY3Q1BIUjwKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECl26AVoKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpBZWN1YTcghzF8Cg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKbboBagosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKChRIVTcURzVVmXwKDQoHZ3JhbnRlZRICCAQKKwoHZ3JhbnRvchIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKOQoJc2NoZW1hX2lkEiy6ASkKJwoFdmFsdWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKhiUjUphoIjI1XA== +CjgKNroBMwoUCgNrZXkSDboBCgoICgJpZBICCAQKDgoEa2luZBIGQgRSb2xlCgsKBXZhbHVlEgIIBA== +CjcKNboBMgoJCgNrZXkSAggEChgKBGtpbmQSEEIOQ2x1c3RlclJlcGxpY2EKCwoFdmFsdWUSAggE +CjAKLroBKwoYCgVlcG9jaBIPwgEMCgoWY5QhMDSJSRScCg8KBGtpbmQSB0IFRXBvY2g= +CjIKMLoBLQoJCgNrZXkSAggEChMKBGtpbmQSC0IJVGltZXN0YW1wCgsKBXZhbHVlEgIIBA== +Ck0KS7oBSAoJCgNrZXkSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKHgoFdmFsdWUSFboBEgoQCgpwcml2aWxlZ2VzEgIIBA== +CjAKLroBKwoYCgVlcG9jaBIPwgEMCgpQhyQ1kYMROAIdCg8KBGtpbmQSB0IFRXBvY2g= +CjIKMLoBLQoXCgNrZXkSELoBDQoLCgVldmVudBICCAQKEgoEa2luZBIKQghBdWRpdExvZw== +CkoKSLoBRQoJCgNrZXkSAggEChAKBGtpbmQSCEIGQ29uZmlnCiYKBXZhbHVlEh26ARoKGAoFdmFsdWUSD8IBDAoKNGI0NheFhUckLA== +CmUKY7oBYAo+CgNrZXkSN7oBNAoyCgJpZBIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCldJNFCARIAiY5wKEQoEa2luZBIJQgdDbHVzdGVyCgsKBXZhbHVlEgIIBA== +CogBCoUBugGBAQoiCgNrZXkSG7oBGAoWCgJpZBIQugENCgsKBXZhbHVlEgIIBAoOCgRraW5kEgZCBFJvbGUKSwoFdmFsdWUSQroBPwoQCgphdHRyaWJ1dGVzEgIIBAoQCgptZW1iZXJzaGlwEgIIBAoNCgRuYW1lEgVCA15YKAoKCgR2YXJzEgIIBA== +CmcKZboBYgpACgNrZXkSOboBNgo0CgRuYW1lEixCKmBMI/CflbREJyZ7dVkl6qyFRfCWqaE/dFw6wqVVXe++gzw6cuqVmeCyhgoRCgRraW5kEglCB1NldHRpbmcKCwoFdmFsdWUSAggE +CmgKZroBYwoJCgNrZXkSAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwo6CgV2YWx1ZRIxugEuCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKMFI3YwUIhJI1XA== +Cm8KbboBagoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudApKCgV2YWx1ZRJBugE+CjwKB2NvbW1lbnQSMUIvJvCWq4Yn77+9JdS+8J2qrSzhsod077ex4K6qMPCQjJrDu+GkiVjIuvCflbQuPSc= +CuoBCucBugHjAQqDAQoDa2V5Eny6AXkKGwoLb2JqZWN0X25hbWUSDEIKOci6dSR84aGBKgokCgtvYmplY3RfdHlwZRIVwgESCgUCGFYjfBD///////////8BCjQKC3NjaGVtYV9uYW1lEiVCI+CoiXdlKvCQlbXwn5W08J+VtOOIh+GltFlxJirgsbl54KaQChQKBGtpbmQSDEIKR2lkTWFwcGluZwpFCgV2YWx1ZRI8ugE5CiAKC2ZpbmdlcnByaW50EhFCDz/gqpFa4oCJyLohZuCroQoVCgJpZBIPwgEMCgqSVWGDWUEIFYVs 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 +CnQKcroBbwpNCgNrZXkSRroBQwpBCgRuYW1lEjlCN+GlgEAmJWIn8JCWvH5cXMi64LCgJs26IuCvqCRF4LCT4byPKmNaZMO9PNGo8J6FiFw4efCWpZEKEQoEa2luZBIJQgdJZEFsbG9jCgsKBXZhbHVlEgIIBA== +CkcKRboBQgojCgNrZXkSHLoBGQoXCgNnaWQSELoBDQoLCgV2YWx1ZRICCAQKDgoEa2luZBIGQgRJdGVtCgsKBXZhbHVlEgIIBA== +CjcKNboBMgoJCgNrZXkSAggEChgKBGtpbmQSEEIOQ2x1c3RlclJlcGxpY2EKCwoFdmFsdWUSAggE +CuoBCucBugHjAQp3CgNrZXkScLoBbQo5CgtvYmplY3RfbmFtZRIqQijgrIfwnrmd0ah74LaqPyLgrpLwkbKz6qSWYmPwnp+t8JGGoMO94K+AChkKC29iamVjdF90eXBlEgrCAQcKBWkmaZZNChUKC3NjaGVtYV9uYW1lEgZCBC4lVnYKFAoEa2luZBIMQgpHaWRNYXBwaW5nClIKBXZhbHVlEkm6AUYKLAoLZmluZ2VycHJpbnQSHUIb8J2Ts/CdlJMm8JGwiF8vPVRyOuCiv8K1Ii9rChYKAmlkEhDCAQ0KCwE4KZMoFEFyVyec +CrcBCrQBugGwAQoJCgNrZXkSAggEChgKBGtpbmQSEEIOQ2x1c3RlclJlcGxpY2EKiAEKBXZhbHVlEn+6AXwKOQoKY2x1c3Rlcl9pZBIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBclQTcwmGgjEzPAoMCgZjb25maWcSAggEChMKBG5hbWUSC0IJL/CdkL7wnoCjChwKCG93bmVyX2lkEhC6AQ0KCwoFdmFsdWUSAggE +CmsKaboBZgo9CgNrZXkSNroBMwoxCgJpZBIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBORkgQmh4l3MjjAoYCgRraW5kEhBCDkNsdXN0ZXJSZXBsaWNhCgsKBXZhbHVlEgIIBA== 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 +CkgKRroBQwoJCgNrZXkSAggECikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleAoLCgV2YWx1ZRICCAQ= +CsYBCsMBugG/AQqEAQoDa2V5En26AXoKOgoKY2x1c3Rlcl9pZBIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCplQBkmWmFSDgYwKPAoEbmFtZRI0QjJHQeKirO+/vSDwnoCh44STYPCflbRUyLrwnriiPCYw8J6frvCRgqPhpLTRqD0j0agiRgopCgRraW5kEiFCH0NsdXN0ZXJJbnRyb3NwZWN0aW9uU291cmNlSW5kZXgKCwoFdmFsdWUSAggE +CkwKSroBRwomCgNrZXkSH7oBHAoaCgNrZXkSE0IRJSpbPOC6iW3zoISj8J+VtD0KEAoEa2luZBIIQgZDb25maWcKCwoFdmFsdWUSAggE +CusCCugCugHkAgoJCgNrZXkSAggEChgKBGtpbmQSEEIOQ2x1c3RlclJlcGxpY2EKvAIKBXZhbHVlErICugGuAgoQCgpjbHVzdGVyX2lkEgIIBArbAQoGY29uZmlnEtABugHMAQo7Ch1pZGxlX2FycmFuZ2VtZW50X21lcmdlX2VmZm9ydBIaugEXChUKBmVmZm9ydBILwgEICgYBYzgCFxwKfgoIbG9jYXRpb24ScroBbwptCgdNYW5hZ2VkEmK6AV8KFwoRYXZhaWxhYmlsaXR5X3pvbmUSAggECg8KCWJpbGxlZF9hcxICCAQKCgoEZGlzaxICCAIKDgoIaW50ZXJuYWwSAggDChcKBHNpemUSD0INXC/wnritwr7IulomVgoNCgdsb2dnaW5nEgIIBAosCgRuYW1lEiRCIvCQoLBgw49j8JGTl/CQso3wmIGF8JGYu+CrrGDwnYOUYFwKDgoIb3duZXJfaWQSAggE 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 +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHSWRBbGxvYwoLCgV2YWx1ZRICCAQ= +CpwBCpkBugGVAQpHCgNrZXkSQLoBPQo7CgJpZBI1QjMqMPCdgow8evCQrofwlquzeyo4a1cm6p2lWuC6gi7wlry58J2NrvCflbTwkKCIL/CdhooKEwoEa2luZBILQglUaW1lc3RhbXAKNQoFdmFsdWUSLLoBKQonCgJ0cxIhugEeChwKCGludGVybmFsEhDCAQ0KCwEBNHczgWV3UVWM +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHSWRBbGxvYwoLCgV2YWx1ZRICCAQ= +CjIKMLoBLQoJCgNrZXkSAggEChMKBGtpbmQSC0IJVGltZXN0YW1wCgsKBXZhbHVlEgIIBA== +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwoLCgV2YWx1ZRICCAQ= +CtUBCtIBugHOAQqoAQoDa2V5EqABugGcAQpBCgtvYmplY3RfbmFtZRIyQjAsUS5D4KedW+KvqvCfrLJg6qmJP+KAtynwkKO78JG2kWw94Kqywr3wkLOeIuqfk3sKGQoLb2JqZWN0X3R5cGUSCsIBBwoFlJNlIBwKPAoLc2NoZW1hX25hbWUSLUIrOuCxoeCogu+/vSlbdOC3ni9uL04q4KeX4aSzN2jwnZSiwqU6cjpf8J+VtAoUCgRraW5kEgxCCkdpZE1hcHBpbmcKCwoFdmFsdWUSAggE +CpwBCpkBugGVAQpLCgNrZXkSRLoBQQo/CgRuYW1lEjdCNeC3rHvgsJDwkJa8WnZ9KvCRnKEnVuCnneCqiGIh8KyJhWLbufCflbTgqrfwnamUYCXgu4lXChEKBGtpbmQSCUIHSWRBbGxvYwozCgV2YWx1ZRIqugEnCiUKB25leHRfaWQSGsIBFwoKEDQEGElkWQF5HBD///////////8B +ClkKV7oBVAoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgooCgV2YWx1ZRIfugEcChoKBXZhbHVlEhFCD/CbsbhOfvCRg7PwkZmRSg== +CjAKLroBKwoYCgVlcG9jaBIPwgEMCgoVCUBGl0Vgc2hMCg8KBGtpbmQSB0IFRXBvY2g= +Ci8KLboBKgoJCgNrZXkSAggEChAKBGtpbmQSCEIGQ29uZmlnCgsKBXZhbHVlEgIIBA== +CjAKLroBKwoYCgVlcG9jaBIPwgEMCgoEZkIJSIhGFGlMCg8KBGtpbmQSB0IFRXBvY2g= +CjoKOLoBNQoJCgNrZXkSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKCwoFdmFsdWUSAggE +CjsKOboBNgojCgVlcG9jaBIawgEXCgoCECiHWWmWNmlsEP///////////wEKDwoEa2luZBIHQgVFcG9jaA== +CokBCoYBugGCAQooCgNrZXkSIboBHgoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAoaCgRraW5kEhJCEFN5c3RlbVByaXZpbGVnZXMKOgoFdmFsdWUSMboBLgosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCmcgGIMFJ2hjWYw= +CmsKaboBZgoJCgNrZXkSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKPAoFdmFsdWUSM7oBMAouCgpwcml2aWxlZ2VzEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKMVGECGZURpOWjA== +CjkKN7oBNAoVCgNrZXkSDroBCwoJCgNnaWQSAggECg4KBGtpbmQSBkIESXRlbQoLCgV2YWx1ZRICCAQ= +Cm4KbLoBaQoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudApJCgV2YWx1ZRJAugE9CjsKB2NvbW1lbnQSMEIuOe+/vcOSIicxPHQm8J64g+C1jDXhn6UxMUfwkaaleuCssy894Kaqwrrgp4FvaQ== +CnIKcLoBbQoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwpNCgV2YWx1ZRJEugFBCj8KBXZhbHVlEjZCNPCQqZZyWkjwkYyyZvCQlLDguoEiyLrguIhR8JCetS/CpSrwn4mE8K6SlSfwkr+WKfCRjbQ= +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ2x1c3RlcgoLCgV2YWx1ZRICCAQ= +CjMKMboBLgoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= +CjsKOboBNgojCgVlcG9jaBIawgEXCgoDgnBDAjRlJnF8EP///////////wEKDwoEa2luZBIHQgVFcG9jaA== +Ci0KK7oBKAoJCgNrZXkSAggECg4KBGtpbmQSBkIESXRlbQoLCgV2YWx1ZRICCAQ= +CjwKOroBNwoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgoLCgV2YWx1ZRICCAQ= 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 +Ci0KK7oBKAoJCgNrZXkSAggECg4KBGtpbmQSBkIEUm9sZQoLCgV2YWx1ZRICCAQ= +ClwKWroBVwoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgorCgV2YWx1ZRIiugEfCh0KBXZhbHVlEhRCEjt3ceG9rOCxnT/vtIsv8JCokA== +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ2x1c3RlcgoLCgV2YWx1ZRICCAQ= +CjIKMLoBLQoXCgNrZXkSELoBDQoLCgVldmVudBICCAQKEgoEa2luZBIKQghBdWRpdExvZw== +CigKJroBIwoJCgNrZXkSAggEChYKBGtpbmQSDkIMU3RvcmFnZVVzYWdl +Ck0KS7oBSAomCgNrZXkSH7oBHAoaCgRuYW1lEhJCEPCWq57gtL8nwqXgt5zvrYQKEQoEa2luZBIJQgdJZEFsbG9jCgsKBXZhbHVlEgIIBA== +CksKSboBRgoJCgNrZXkSAggEChAKBGtpbmQSCEIGQ29uZmlnCicKBXZhbHVlEh66ARsKGQoFdmFsdWUSEMIBDQoLAXYEV3UWAWEFCDw= +CqACCp0CugGZAgqpAQoDa2V5EqEBugGdAQpbCgtvYmplY3RfbmFtZRJMQkrRqPCflbQq8JCilz3wlr+w4ri18K+ogT8n8J6Fj/CdiYQuXNGo8JGCksKlcCUyPPCQhIDwnZGY4rWv0ajIuiNc8Jq/scKl8JCnhwoZCgtvYmplY3RfdHlwZRIKwgEHCgWUUkgoPAojCgtzY2hlbWFfbmFtZRIUQhJ78J+VtC/bgeCwsyc3by5rIigKFAoEa2luZBIMQgpHaWRNYXBwaW5nClUKBXZhbHVlEky6AUkKLwoLZmluZ2VycHJpbnQSIEIeO/CfoqDgsZXhv5rgs4hY8JGkk/CfqobwkKKq4KCwChYKAmlkEhDCAQ0KCwEUh3SZgVEZJDWc +Cm0Ka7oBaAo/CgNrZXkSOLoBNQozCgJpZBItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwE1KIiAgSVDgGJcChgKBGtpbmQSEEIOQ2x1c3RlclJlcGxpY2EKCwoFdmFsdWUSAggE +CjEKL7oBLAoJCgNrZXkSAggEChIKBGtpbmQSCkIIRGF0YWJhc2UKCwoFdmFsdWUSAggE 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 +Ci8KLboBKgoJCgNrZXkSAggEChAKBGtpbmQSCEIGU2NoZW1hCgsKBXZhbHVlEgIIBA== +CjEKL7oBLAoJCgNrZXkSAggEChIKBGtpbmQSCkIIRGF0YWJhc2UKCwoFdmFsdWUSAggE +CksKSboBRgoJCgNrZXkSAggEChAKBGtpbmQSCEIGQ29uZmlnCicKBXZhbHVlEh66ARsKGQoFdmFsdWUSEMIBDQoLAVeZZVJWNhFjdGw= +CjMKMboBLgoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= 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 +CooBCocBugGDAQooCgNrZXkSIboBHgoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAoaCgRraW5kEhJCEFN5c3RlbVByaXZpbGVnZXMKOwoFdmFsdWUSMroBLwotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFzlAlTkxk5ISlM +CkoKSLoBRQoiCgNrZXkSG7oBGAoWCgJpZBIQugENCgsKBXZhbHVlEgIIBAoSCgRraW5kEgpCCERhdGFiYXNlCgsKBXZhbHVlEgIIBA== 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 +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwoLCgV2YWx1ZRICCAQ= +CjwKOroBNwoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgoLCgV2YWx1ZRICCAQ= +CrkHCrYHugGyBwojCgNrZXkSHLoBGQoXCgNnaWQSELoBDQoLCgV2YWx1ZRICCAQKDgoEa2luZBIGQgRJdGVtCvoGCgV2YWx1ZRLwBroB7AYKEAoKZGVmaW5pdGlvbhICCAQKGwoEbmFtZRITQhEu4LS44YOHOvCRvLJH6p+QdQocCghvd25lcl9pZBIQugENCgsKBXZhbHVlEgIIBAqLBgoKcHJpdmlsZWdlcxL8BbIB+AUKP7oBPAoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAo/ugE8Cg4KCGFjbF9tb2RlEgIIBAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggEClm6AVYKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECjUKB2dyYW50b3ISKroBJwolCgV2YWx1ZRIcugEZChcKBFVzZXISD8IBDAoKaEV5dkM1FiSXHApZugFWCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAo1CgdncmFudG9yEiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKCoCXiEgHApWWAGwKT7oBTAoOCghhY2xfbW9kZRICCAQKKwoHZ3JhbnRlZRIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKDQoHZ3JhbnRvchICCAQKT7oBTAoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKKwoHZ3JhbnRvchIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKXLoBWQoOCghhY2xfbW9kZRICCAQKOAoHZ3JhbnRlZRItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwElk3mTSVJFYneMCg0KB2dyYW50b3ISAggECl66AVsKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBYWEXZoZWA5EEfAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECl66AVsKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBgCWSgydyFwFpTAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggECg8KCXNjaGVtYV9pZBICCAQ= +Cj0KO7oBOAoJCgNrZXkSAggEChMKBGtpbmQSC0IJVGltZXN0YW1wChYKBXZhbHVlEg26AQoKCAoCdHMSAggE +CpYBCpMBugGPAQpKCgNrZXkSQ7oBQAo+CgRuYW1lEjZCNDbgu47wlq2Y4KyB4L2S776LL9Go4KGCwqUxQGDRqPCRpIkm8JGksPCdlYbqrJbCpfCQgZIKHQoEa2luZBIVQhNTZXJ2ZXJDb25maWd1cmF0aW9uCiIKBXZhbHVlEhm6ARYKFAoFdmFsdWUSC0IJwqUyZCXhgqY8 +CpQBCpEBugGNAQpJCgNrZXkSQroBPwo9CgRuYW1lEjVCMzki77+9eyk3WcKlT0HwnYSzJPCRjZcg8JGNsvCRg4IkaSUu4K6/Lsi677iV8J2Rq+C/hAoRCgRraW5kEglCB1NldHRpbmcKLQoFdmFsdWUSJLoBIQofCgV2YWx1ZRIWQhRg4LK8M0XwnZWA4LeG4KyQYHQkKQ== +CpwBCpkBugGVAQpWCgNrZXkST7oBTApKCgRuYW1lEkJCQOCmkDxk8JC+sE/gv4p78JuykeCys2fgqLUmTi7wkaC0Pe+5q+G9tHvhnYDDn+qfk+CnueCvjWLhs4VtIuG9jCcKEQoEa2luZBIJQgdJZEFsbG9jCigKBXZhbHVlEh+6ARwKGgoHbmV4dF9pZBIPwgEMCgqAOZAWIFYwSJks +CnAKbroBawoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwpICgV2YWx1ZRI/ugE8CiIKC2ZpbmdlcnByaW50EhNCEeCyvTrigq/vv71uKmAn4LOKChYKAmlkEhDCAQ0KCwExdHAlhwNJAxKM +CigKJroBIwoJCgNrZXkSAggEChYKBGtpbmQSDkIMU3RvcmFnZVVzYWdl +CigKJroBIwoJCgNrZXkSAggEChYKBGtpbmQSDkIMU3RvcmFnZVVzYWdl +CmYKZLoBYQo+CgNrZXkSN7oBNAoyCgJpZBIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCiciaCmUiXkkSZwKEgoEa2luZBIKQghEYXRhYmFzZQoLCgV2YWx1ZRICCAQ= +Cj0KO7oBOAoUCgNrZXkSDboBCgoICgJpZBICQgAKEwoEa2luZBILQglUaW1lc3RhbXAKCwoFdmFsdWUSAggE +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +CjIKMLoBLQoJCgNrZXkSAggEChMKBGtpbmQSC0IJVGltZXN0YW1wCgsKBXZhbHVlEgIIBA== +CkgKRroBQwoJCgNrZXkSAggECikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleAoLCgV2YWx1ZRICCAQ= +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwoLCgV2YWx1ZRICCAQ= diff --git a/src/catalog/src/durable/upgrade/stash/v46_to_v47.rs b/src/catalog/src/durable/upgrade/stash/v46_to_v47.rs new file mode 100644 index 0000000000000..c74742c39f530 --- /dev/null +++ b/src/catalog/src/durable/upgrade/stash/v46_to_v47.rs @@ -0,0 +1,75 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +use mz_stash::upgrade::{wire_compatible, MigrationAction, WireCompatible}; +use mz_stash::{Transaction, TypedCollection}; +use mz_stash_types::StashError; + +use crate::durable::upgrade::{objects_v46 as v46, objects_v47 as v47}; + +wire_compatible!(v46::ClusterKey with v47::ClusterKey); +wire_compatible!(v46::MzAclItem with v47::MzAclItem); +wire_compatible!(v46::RoleId with v47::RoleId); +wire_compatible!(v46::ReplicaLogging with v47::ReplicaLogging); +wire_compatible!(v46::ReplicaMergeEffort with v47::ReplicaMergeEffort); + +const CLUSTER_COLLECTION: TypedCollection = + TypedCollection::new("clusters"); + +/// Introduce empty `optimizer_feature_overrides` in `ManagedCluster`'s. +pub async fn upgrade(tx: &Transaction<'_>) -> Result<(), StashError> { + CLUSTER_COLLECTION + .migrate_to::(tx, |entries| { + entries + .iter() + .map(|(old_key, old_val)| { + let new_key = WireCompatible::convert(old_key); + let new_val = v47::ClusterValue { + name: old_val.name.clone(), + owner_id: old_val.owner_id.as_ref().map(WireCompatible::convert), + privileges: old_val + .privileges + .iter() + .map(WireCompatible::convert) + .collect(), + config: old_val.config.as_ref().map(|config| v47::ClusterConfig { + variant: config.variant.as_ref().map(|variant| match variant { + v46::cluster_config::Variant::Unmanaged(_) => { + v47::cluster_config::Variant::Unmanaged(v47::Empty {}) + } + v46::cluster_config::Variant::Managed(c) => { + v47::cluster_config::Variant::Managed( + v47::cluster_config::ManagedCluster { + size: c.size.clone(), + replication_factor: c.replication_factor, + availability_zones: c.availability_zones.clone(), + logging: c + .logging + .as_ref() + .map(WireCompatible::convert), + idle_arrangement_merge_effort: c + .idle_arrangement_merge_effort + .as_ref() + .map(WireCompatible::convert), + disk: c.disk, + optimizer_feature_overrides: Vec::new(), + }, + ) + } + }), + }), + }; + + MigrationAction::Update(old_key.clone(), (new_key, new_val)) + }) + .collect() + }) + .await?; + Ok(()) +} diff --git a/src/catalog/tests/snapshots/debug__persist_opened_trace.snap b/src/catalog/tests/snapshots/debug__persist_opened_trace.snap index 4cf57968aa5f8..4c2d011d96d3c 100644 --- a/src/catalog/tests/snapshots/debug__persist_opened_trace.snap +++ b/src/catalog/tests/snapshots/debug__persist_opened_trace.snap @@ -516,6 +516,7 @@ Trace { ), idle_arrangement_merge_effort: None, disk: false, + optimizer_feature_overrides: [], }, ), ), diff --git a/src/catalog/tests/snapshots/debug__stash_opened_trace.snap b/src/catalog/tests/snapshots/debug__stash_opened_trace.snap index 80b05fdfd5970..68f0cd56f0e41 100644 --- a/src/catalog/tests/snapshots/debug__stash_opened_trace.snap +++ b/src/catalog/tests/snapshots/debug__stash_opened_trace.snap @@ -516,6 +516,7 @@ Trace { ), idle_arrangement_merge_effort: None, disk: false, + optimizer_feature_overrides: [], }, ), ), diff --git a/src/catalog/tests/snapshots/open__initial_snapshot.snap b/src/catalog/tests/snapshots/open__initial_snapshot.snap index b0d6dd3ce5f56..2bc218cff4b28 100644 --- a/src/catalog/tests/snapshots/open__initial_snapshot.snap +++ b/src/catalog/tests/snapshots/open__initial_snapshot.snap @@ -978,6 +978,7 @@ Snapshot { ), idle_arrangement_merge_effort: None, disk: false, + optimizer_feature_overrides: [], }, ), ), From 45ea0d59e21d189bd59a9b4f7a3fd4c4c530e090 Mon Sep 17 00:00:00 2001 From: Alexander Alexandrov Date: Mon, 12 Feb 2024 11:42:37 +0200 Subject: [PATCH 03/13] catalog: wire `optimizer_feature_overrides` overrides in `OptimizerConfig` --- .../src/coord/sequencer/inner/create_index.rs | 1 + .../inner/create_materialized_view.rs | 1 + src/adapter/src/coord/sequencer/inner/peek.rs | 1 + .../src/coord/sequencer/inner/subscribe.rs | 8 ++- src/adapter/src/optimize/mod.rs | 63 ++++++++++++++++++- src/catalog/src/memory/objects.rs | 9 +++ 6 files changed, 78 insertions(+), 5 deletions(-) diff --git a/src/adapter/src/coord/sequencer/inner/create_index.rs b/src/adapter/src/coord/sequencer/inner/create_index.rs index c412cad4ab575..bec62596da78e 100644 --- a/src/adapter/src/coord/sequencer/inner/create_index.rs +++ b/src/adapter/src/coord/sequencer/inner/create_index.rs @@ -229,6 +229,7 @@ impl Coordinator { self.allocate_transient_id()? }; let optimizer_config = optimize::OptimizerConfig::from(self.catalog().system_config()) + .override_from(&self.catalog.get_cluster(*cluster_id).config.features()) .override_from(&explain_ctx); // Build an optimizer for this INDEX. diff --git a/src/adapter/src/coord/sequencer/inner/create_materialized_view.rs b/src/adapter/src/coord/sequencer/inner/create_materialized_view.rs index e1f716f6af9fd..7956f2e6c8fc9 100644 --- a/src/adapter/src/coord/sequencer/inner/create_materialized_view.rs +++ b/src/adapter/src/coord/sequencer/inner/create_materialized_view.rs @@ -316,6 +316,7 @@ impl Coordinator { let internal_view_id = self.allocate_transient_id()?; let debug_name = self.catalog().resolve_full_name(name, None).to_string(); let optimizer_config = optimize::OptimizerConfig::from(self.catalog().system_config()) + .override_from(&self.catalog.get_cluster(*cluster_id).config.features()) .override_from(&explain_ctx); // Build an optimizer for this MATERIALIZED VIEW. diff --git a/src/adapter/src/coord/sequencer/inner/peek.rs b/src/adapter/src/coord/sequencer/inner/peek.rs index a8ecd7694b711..5281175280992 100644 --- a/src/adapter/src/coord/sequencer/inner/peek.rs +++ b/src/adapter/src/coord/sequencer/inner/peek.rs @@ -279,6 +279,7 @@ impl Coordinator { .expect("compute instance does not exist"); let view_id = self.allocate_transient_id()?; let optimizer_config = optimize::OptimizerConfig::from(self.catalog().system_config()) + .override_from(&self.catalog.get_cluster(cluster.id()).config.features()) .override_from(&explain_ctx); let optimizer = match copy_to_ctx { diff --git a/src/adapter/src/coord/sequencer/inner/subscribe.rs b/src/adapter/src/coord/sequencer/inner/subscribe.rs index da5d96c9c1ef7..2750ff276cb11 100644 --- a/src/adapter/src/coord/sequencer/inner/subscribe.rs +++ b/src/adapter/src/coord/sequencer/inner/subscribe.rs @@ -21,7 +21,7 @@ use crate::coord::{ SubscribeStage, SubscribeTimestampOptimizeLir, TargetCluster, }; use crate::error::AdapterError; -use crate::optimize::Optimize; +use crate::optimize::{Optimize, OverrideFrom}; use crate::session::{Session, TransactionOps}; use crate::util::ResultExt; use crate::{optimize, AdapterNotice, ExecuteContext, TimelineContext}; @@ -162,8 +162,9 @@ impl Coordinator { } = &plan; // Collect optimizer parameters. + let cluster_id = validity.cluster_id.expect("cluser_id"); let compute_instance = self - .instance_snapshot(validity.cluster_id.expect("cluser_id")) + .instance_snapshot(cluster_id) .expect("compute instance does not exist"); let id = self.allocate_transient_id()?; let conn_id = session.conn_id().clone(); @@ -171,7 +172,8 @@ impl Coordinator { .as_ref() .map(|expr| Coordinator::evaluate_when(self.catalog().state(), expr.clone(), session)) .transpose()?; - let optimizer_config = optimize::OptimizerConfig::from(self.catalog().system_config()); + let optimizer_config = optimize::OptimizerConfig::from(self.catalog().system_config()) + .override_from(&self.catalog.get_cluster(cluster_id).config.features()); // Build an optimizer for this SUBSCRIBE. let mut optimizer = optimize::subscribe::Optimizer::new( diff --git a/src/adapter/src/optimize/mod.rs b/src/adapter/src/optimize/mod.rs index 2c41b71a484d9..0e8349a93dda9 100644 --- a/src/adapter/src/optimize/mod.rs +++ b/src/adapter/src/optimize/mod.rs @@ -67,6 +67,7 @@ use mz_compute_types::plan::Plan; use mz_expr::{EvalError, MirRelationExpr, OptimizedMirRelationExpr, UnmaterializableFunc}; use mz_ore::stack::RecursionLimitError; use mz_repr::adt::timestamp::TimestampError; +use mz_repr::optimize::OptimizerFeatureOverrides; use mz_repr::GlobalId; use mz_sql::plan::PlanError; use mz_sql::session::vars::SystemVars; @@ -151,7 +152,39 @@ where // Optimizer configuration // ----------------------- -// Feature flags for the optimizer. +/// Feature flags for the optimizer. +/// +/// To add a new feature flag, do the following steps: +/// +/// 1. To make the flag available to all stages in our [`Optimize`] pipelines: +/// 1. Add the flag as an [`OptimizerConfig`] field. +/// +/// 2. To allow engineers to set a system-wide override for this feature flag: +/// 1. Add the flag to the `feature_flags!(...)` macro call. +/// 2. Extend the `From<&SystemVars>` implementation for [`OptimizerConfig`]. +/// +/// 3. To enable `EXPLAIN ... WITH(...)` overrides which will allow engineers to +/// inspect plan differences before deploying the optimizer changes: +/// 1. Add the flag as a [`mz_repr::explain::ExplainConfig`] field. +/// 2. Add the flag to the `ExplainPlanOptionName` definition. +/// 3. Add the flag to the `generate_extracted_config!(ExplainPlanOption, +/// ...)` macro call. +/// 4. Extend the `TryFrom` implementation for +/// [`mz_repr::explain::ExplainConfig`]. +/// 5. Extend the `OverrideFrom` implementation for +/// [`OptimizerConfig`]. +/// +/// 4. To enable `CLUSTER ... FEATURES(...)` overrides which will allow +/// engineers to experiment with runtime differences before deploying the +/// optimizer changes: +/// 1. Add the flag to the `optimizer_feature_flags!(...)` macro call. +/// 2. Add the flag to the `ClusterFeatureName` definition. +/// 3. Add the flag to the `generate_extracted_config!(ClusterFeature, ...)` +/// macro call. +/// 4. Extend the `let optimizer_feature_overrides = ...` call in +/// `plan_create_cluster`. +/// 4. Extend the `OverrideFrom` implementation +/// for [`OptimizerConfig`]. #[derive(Clone, Debug)] pub struct OptimizerConfig { /// The mode in which the optimizer runs. @@ -209,6 +242,32 @@ pub trait OverrideFrom { fn override_from(self, layer: &T) -> Self; } +/// [`OptimizerConfig`] overrides coming from an optional `T`. +impl OverrideFrom> for OptimizerConfig +where + Self: OverrideFrom, +{ + fn override_from(self, layer: &Option<&T>) -> Self { + match layer { + Some(layer) => self.override_from(layer), + None => self, + } + } +} + +/// [`OptimizerConfig`] overrides coming from a [`OptimizerFeatureOverrides`]. +impl OverrideFrom for OptimizerConfig { + fn override_from(mut self, overrides: &OptimizerFeatureOverrides) -> Self { + if let Some(feature_value) = overrides.enable_new_outer_join_lowering { + self.enable_new_outer_join_lowering = feature_value; + } + if let Some(feature_value) = overrides.enable_eager_delta_joins { + self.enable_eager_delta_joins = feature_value; + } + self + } +} + /// [`OptimizerConfig`] overrides coming from an [`ExplainContext`]. impl OverrideFrom for OptimizerConfig { fn override_from(mut self, ctx: &ExplainContext) -> Self { @@ -229,7 +288,7 @@ impl OverrideFrom for OptimizerConfig { self.enable_eager_delta_joins = explain_flag; } - // Return final result. + // Return the final result. self } } diff --git a/src/catalog/src/memory/objects.rs b/src/catalog/src/memory/objects.rs index b5df345106ed0..f2aead5d831cd 100644 --- a/src/catalog/src/memory/objects.rs +++ b/src/catalog/src/memory/objects.rs @@ -1730,6 +1730,15 @@ pub struct ClusterConfig { pub variant: ClusterVariant, } +impl ClusterConfig { + pub fn features(&self) -> Option<&OptimizerFeatureOverrides> { + match &self.variant { + ClusterVariant::Managed(managed) => Some(&managed.optimizer_feature_overrides), + ClusterVariant::Unmanaged => None, + } + } +} + impl From for durable::ClusterConfig { fn from(config: ClusterConfig) -> Self { Self { From cdee144cacc0a2168f70aae14ce2b75e6284a2ec Mon Sep 17 00:00:00 2001 From: Alexander Alexandrov Date: Mon, 12 Feb 2024 18:14:00 +0200 Subject: [PATCH 04/13] optimize: add `reoptimize_imported_views` feature flag Forcing `DataflowBuilder::reoptimize_imported_views` to reoptimize all catalog-backed views imported in the `DataflowDescription` in every possible `EXPLAIN` run is a bit of an overkill. Instead, we should enable work in this method call only when one of the overrides of `OptimizerConfig` (`CREATE CLUSTER ... FEATURES(...)` or `EXPLAIN PLAN WITH(...)`) explicitly sets the value of a feature flag that influences an optimizer stage that runs before we produce the locally optimized `MirRelationExpr`. To do this, we introduce a dedicated optimizer feature flag for that. Engineers should enable this flag in conjunction with any other flags that modify the view optimization pipeline in order to see differences in catalog items that depend on the view. --- src/adapter/src/optimize/copy_to.rs | 2 +- src/adapter/src/optimize/dataflows.rs | 48 ++++++++++--------- src/adapter/src/optimize/index.rs | 2 +- src/adapter/src/optimize/materialized_view.rs | 2 +- src/adapter/src/optimize/mod.rs | 10 ++++ src/adapter/src/optimize/peek.rs | 2 +- src/adapter/src/optimize/subscribe.rs | 2 +- src/repr/src/explain/mod.rs | 4 ++ src/repr/src/optimize.rs | 1 + src/sql-lexer/src/keywords.txt | 2 + src/sql-parser/src/ast/defs/statement.rs | 2 + src/sql/src/plan/statement/ddl.rs | 3 ++ src/sql/src/plan/statement/dml.rs | 2 + test/sqllogictest/outer_join_lowering.slt | 4 +- 14 files changed, 56 insertions(+), 30 deletions(-) diff --git a/src/adapter/src/optimize/copy_to.rs b/src/adapter/src/optimize/copy_to.rs index c929b46d3eb52..01e9e0a83b497 100644 --- a/src/adapter/src/optimize/copy_to.rs +++ b/src/adapter/src/optimize/copy_to.rs @@ -218,7 +218,7 @@ impl<'s> Optimize>> for Optimizer { let mut df_desc = MirDataflowDescription::new(debug_name.to_string()); df_builder.import_view_into_dataflow(&self.select_id, &expr, &mut df_desc)?; - df_builder.reoptimize_imported_views(&mut df_desc, &self.config)?; + df_builder.maybe_reoptimize_imported_views(&mut df_desc, &self.config)?; // Creating an S3 sink as currently only s3 sinks are supported. It // might be possible in the future for COPY TO to write to different diff --git a/src/adapter/src/optimize/dataflows.rs b/src/adapter/src/optimize/dataflows.rs index 3225a5e9e7b7d..cc7d51e12b87d 100644 --- a/src/adapter/src/optimize/dataflows.rs +++ b/src/adapter/src/optimize/dataflows.rs @@ -43,7 +43,7 @@ use tracing::warn; use crate::catalog::CatalogState; use crate::coord::id_bundle::CollectionIdBundle; -use crate::optimize::{view, Optimize, OptimizeMode, OptimizerConfig, OptimizerError}; +use crate::optimize::{view, Optimize, OptimizerConfig, OptimizerError}; use crate::session::{Session, SERVER_MAJOR_VERSION, SERVER_MINOR_VERSION}; use crate::util::viewable_variables; @@ -302,33 +302,35 @@ impl<'a> DataflowBuilder<'a> { } // Re-optimize the imported view plans using the current optimizer - // configuration if we are running in `EXPLAIN`. - pub fn reoptimize_imported_views( + // configuration if reoptimization is requested. + pub fn maybe_reoptimize_imported_views( &self, df_desc: &mut DataflowDesc, config: &OptimizerConfig, ) -> Result<(), OptimizerError> { - if config.mode == OptimizeMode::Explain { - for desc in df_desc.objects_to_build.iter_mut().rev() { - if matches!(desc.id, GlobalId::Explain | GlobalId::Transient(_)) { - // Skip descriptions that do not reference proper views. - continue; - } - if let CatalogItem::View(view) = &self.catalog.get_entry(&desc.id).item { - let _span = tracing::span!( - target: "optimizer", - tracing::Level::DEBUG, - "view", - path.segment = desc.id.to_string() - ) - .entered(); - - let mut view_optimizer = view::Optimizer::new(config.clone()); - desc.plan = view_optimizer.optimize(view.raw_expr.clone())?; + if !config.reoptimize_imported_views { + return Ok(()); // Do nothing is not explicitly requested. + } - // Report the optimized plan under this span. - trace_plan(desc.plan.as_inner()); - } + let mut view_optimizer = view::Optimizer::new(config.clone()); + for desc in df_desc.objects_to_build.iter_mut().rev() { + if matches!(desc.id, GlobalId::Explain | GlobalId::Transient(_)) { + continue; // Skip descriptions that do not reference proper views. + } + if let CatalogItem::View(view) = &self.catalog.get_entry(&desc.id).item { + let _span = tracing::span!( + target: "optimizer", + tracing::Level::DEBUG, + "view", + path.segment = desc.id.to_string() + ) + .entered(); + + // Reoptimize the view and update the resulting `desc.plan`. + desc.plan = view_optimizer.optimize(view.raw_expr.clone())?; + + // Report the optimized plan under this span. + trace_plan(desc.plan.as_inner()); } } diff --git a/src/adapter/src/optimize/index.rs b/src/adapter/src/optimize/index.rs index 9080ce9e6a7b9..f59f85766e634 100644 --- a/src/adapter/src/optimize/index.rs +++ b/src/adapter/src/optimize/index.rs @@ -151,7 +151,7 @@ impl Optimize for Optimizer { let mut df_desc = MirDataflowDescription::new(full_name.to_string()); df_builder.import_into_dataflow(&index.on, &mut df_desc)?; - df_builder.reoptimize_imported_views(&mut df_desc, &self.config)?; + df_builder.maybe_reoptimize_imported_views(&mut df_desc, &self.config)?; for desc in df_desc.objects_to_build.iter_mut() { prep_relation_expr(&mut desc.plan, ExprPrepStyle::Index)?; diff --git a/src/adapter/src/optimize/materialized_view.rs b/src/adapter/src/optimize/materialized_view.rs index 8823ead177aa7..50cdb1e7cdb3e 100644 --- a/src/adapter/src/optimize/materialized_view.rs +++ b/src/adapter/src/optimize/materialized_view.rs @@ -203,7 +203,7 @@ impl Optimize for Optimizer { let mut df_desc = MirDataflowDescription::new(self.debug_name.clone()); df_builder.import_view_into_dataflow(&self.internal_view_id, &expr, &mut df_desc)?; - df_builder.reoptimize_imported_views(&mut df_desc, &self.config)?; + df_builder.maybe_reoptimize_imported_views(&mut df_desc, &self.config)?; for BuildDesc { plan, .. } in &mut df_desc.objects_to_build { prep_relation_expr(plan, ExprPrepStyle::Index)?; diff --git a/src/adapter/src/optimize/mod.rs b/src/adapter/src/optimize/mod.rs index 0e8349a93dda9..064422637d74f 100644 --- a/src/adapter/src/optimize/mod.rs +++ b/src/adapter/src/optimize/mod.rs @@ -194,6 +194,9 @@ pub struct OptimizerConfig { /// This means that it will not consider catalog items (more specifically /// indexes) with [`GlobalId`] greater or equal than the one provided here. pub replan: Option, + /// Reoptimize imported views when building and optimizing a + /// [`DataflowDescription`] in the global MIR optimization phase. + pub reoptimize_imported_views: bool, /// Enable fast path optimization. pub enable_fast_path: bool, /// Enable consolidation of unions that happen immediately after negate. @@ -225,6 +228,7 @@ impl From<&SystemVars> for OptimizerConfig { Self { mode: OptimizeMode::Execute, replan: None, + reoptimize_imported_views: false, enable_fast_path: true, // Always enable fast path if available. enable_consolidate_after_union_negate: vars.enable_consolidate_after_union_negate(), persist_fast_path_limit: vars.persist_fast_path_limit(), @@ -258,6 +262,9 @@ where /// [`OptimizerConfig`] overrides coming from a [`OptimizerFeatureOverrides`]. impl OverrideFrom for OptimizerConfig { fn override_from(mut self, overrides: &OptimizerFeatureOverrides) -> Self { + if let Some(feature_value) = overrides.reoptimize_imported_views { + self.reoptimize_imported_views = feature_value; + } if let Some(feature_value) = overrides.enable_new_outer_join_lowering { self.enable_new_outer_join_lowering = feature_value; } @@ -281,6 +288,9 @@ impl OverrideFrom for OptimizerConfig { self.enable_fast_path = !ctx.config.no_fast_path; // Override feature flags that can be enabled in the EXPLAIN config. + if let Some(explain_flag) = ctx.config.reoptimize_imported_views { + self.reoptimize_imported_views = explain_flag; + } if let Some(explain_flag) = ctx.config.enable_new_outer_join_lowering { self.enable_new_outer_join_lowering = explain_flag; } diff --git a/src/adapter/src/optimize/peek.rs b/src/adapter/src/optimize/peek.rs index 6dfae4ac22397..10040127f7dd6 100644 --- a/src/adapter/src/optimize/peek.rs +++ b/src/adapter/src/optimize/peek.rs @@ -222,7 +222,7 @@ impl<'s> Optimize>> for Optimizer { let mut df_desc = MirDataflowDescription::new(debug_name.to_string()); df_builder.import_view_into_dataflow(&self.select_id, &expr, &mut df_desc)?; - df_builder.reoptimize_imported_views(&mut df_desc, &self.config)?; + df_builder.maybe_reoptimize_imported_views(&mut df_desc, &self.config)?; // Resolve all unmaterializable function calls except mz_now(), because // we don't yet have a timestamp. diff --git a/src/adapter/src/optimize/subscribe.rs b/src/adapter/src/optimize/subscribe.rs index 9d8f3b1c158b5..3c96d3c67e091 100644 --- a/src/adapter/src/optimize/subscribe.rs +++ b/src/adapter/src/optimize/subscribe.rs @@ -236,7 +236,7 @@ impl Optimize for Optimizer { let mut df_desc = MirDataflowDescription::new(sink_name); df_builder.import_view_into_dataflow(&from_id, &expr, &mut df_desc)?; - df_builder.reoptimize_imported_views(&mut df_desc, &self.config)?; + df_builder.maybe_reoptimize_imported_views(&mut df_desc, &self.config)?; let df_meta = df_builder.build_sink_dataflow_into(&mut df_desc, from_id, sink_desc)?; diff --git a/src/repr/src/explain/mod.rs b/src/repr/src/explain/mod.rs index eebd45eef4548..45881ff2cd90b 100644 --- a/src/repr/src/explain/mod.rs +++ b/src/repr/src/explain/mod.rs @@ -195,6 +195,8 @@ pub struct ExplainConfig { // ------------- // Feature flags // ------------- + /// Re-optimize view imported directly in DataflowDescriptions. + pub reoptimize_imported_views: Option, /// Enable outer join lowering implemented in #22347 and #22348. pub enable_new_outer_join_lowering: Option, /// Enable the eager delta join planning implemented in #23318. @@ -223,6 +225,7 @@ impl Default for ExplainConfig { subtree_size: false, timing: false, types: false, + reoptimize_imported_views: None, enable_new_outer_join_lowering: None, enable_eager_delta_joins: None, } @@ -897,6 +900,7 @@ mod tests { subtree_size: false, timing: true, types: false, + reoptimize_imported_views: None, enable_new_outer_join_lowering: None, enable_eager_delta_joins: None, }; diff --git a/src/repr/src/optimize.rs b/src/repr/src/optimize.rs index 82c53eb0d3e5d..c5af6126aac92 100644 --- a/src/repr/src/optimize.rs +++ b/src/repr/src/optimize.rs @@ -84,6 +84,7 @@ macro_rules! optimizer_feature_flags { optimizer_feature_flags!({ enable_consolidate_after_union_negate: bool, persist_fast_path_limit: usize, + reoptimize_imported_views: bool, enable_new_outer_join_lowering: bool, enable_eager_delta_joins: bool, enable_reduce_mfp_fusion: bool, diff --git a/src/sql-lexer/src/keywords.txt b/src/sql-lexer/src/keywords.txt index 15c0f7b0aa4f9..4adfa979946e7 100644 --- a/src/sql-lexer/src/keywords.txt +++ b/src/sql-lexer/src/keywords.txt @@ -190,6 +190,7 @@ If Ignore Ilike Implementations +Imported In Include Index @@ -329,6 +330,7 @@ Regex Region Registry Rename +Reoptimize Repeatable Replace Replan diff --git a/src/sql-parser/src/ast/defs/statement.rs b/src/sql-parser/src/ast/defs/statement.rs index 5b04cfc901500..ec33b972d1508 100644 --- a/src/sql-parser/src/ast/defs/statement.rs +++ b/src/sql-parser/src/ast/defs/statement.rs @@ -1729,6 +1729,7 @@ impl AstDisplay for ClusterOption { // enum are generated automatically by this crate's `build.rs`. #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] pub enum ClusterFeatureName { + ReoptimizeImportedViews, EnableNewOuterJoinLowering, EnableEagerDeltaJoins, } @@ -3089,6 +3090,7 @@ pub enum ExplainPlanOptionName { SubtreeSize, Timing, Types, + ReoptimizeImportedViews, EnableNewOuterJoinLowering, EnableEagerDeltaJoins, } diff --git a/src/sql/src/plan/statement/ddl.rs b/src/sql/src/plan/statement/ddl.rs index cdc5e4b3d202f..1b95a1c40b8bc 100644 --- a/src/sql/src/plan/statement/ddl.rs +++ b/src/sql/src/plan/statement/ddl.rs @@ -3280,6 +3280,7 @@ generate_extracted_config!( generate_extracted_config!( ClusterFeature, + (ReoptimizeImportedViews, Option, Default(None)), (EnableEagerDeltaJoins, Option, Default(None)), (EnableNewOuterJoinLowering, Option, Default(None)) ); @@ -3355,11 +3356,13 @@ pub fn plan_create_cluster( // Plan OptimizerFeatureOverrides. let ClusterFeatureExtracted { + reoptimize_imported_views, enable_eager_delta_joins, enable_new_outer_join_lowering, seen: _, } = ClusterFeatureExtracted::try_from(features)?; let optimizer_feature_overrides = OptimizerFeatureOverrides { + reoptimize_imported_views, enable_eager_delta_joins, enable_new_outer_join_lowering, ..Default::default() diff --git a/src/sql/src/plan/statement/dml.rs b/src/sql/src/plan/statement/dml.rs index 71529084a811e..b75e75c7a4aad 100644 --- a/src/sql/src/plan/statement/dml.rs +++ b/src/sql/src/plan/statement/dml.rs @@ -346,6 +346,7 @@ generate_extracted_config!( (SubtreeSize, bool, Default(false)), (Timing, bool, Default(false)), (Types, bool, Default(false)), + (ReoptimizeImportedViews, Option, Default(None)), (EnableNewOuterJoinLowering, Option, Default(None)), (EnableEagerDeltaJoins, Option, Default(None)) ); @@ -387,6 +388,7 @@ impl TryFrom for ExplainConfig { subtree_size: v.subtree_size, timing: v.timing, types: v.types, + reoptimize_imported_views: v.reoptimize_imported_views, enable_eager_delta_joins: v.enable_eager_delta_joins, enable_new_outer_join_lowering: v.enable_new_outer_join_lowering, }) diff --git a/test/sqllogictest/outer_join_lowering.slt b/test/sqllogictest/outer_join_lowering.slt index ba45c2229d3d3..1e76edf2ae759 100644 --- a/test/sqllogictest/outer_join_lowering.slt +++ b/test/sqllogictest/outer_join_lowering.slt @@ -827,7 +827,7 @@ FROM # EXPLAIN a SELECT * FROM with the feature turned in the EXPLAIN config. query T multiline -EXPLAIN OPTIMIZED PLAN WITH(enable new outer join lowering, humanized expressions, arity) FOR +EXPLAIN OPTIMIZED PLAN WITH(enable new outer join lowering, reoptimize imported views, humanized expressions, arity) FOR SELECT * FROM v; ---- Explained Query: @@ -868,7 +868,7 @@ EOF # EXPLAIN a CREATE INDEX with the feature turned in the EXPLAIN config. query T multiline -EXPLAIN OPTIMIZED PLAN WITH(enable new outer join lowering, humanized expressions, arity) FOR +EXPLAIN OPTIMIZED PLAN WITH(enable new outer join lowering, reoptimize imported views, humanized expressions, arity) FOR CREATE INDEX ON v(facts_k01); ---- materialize.public.v_facts_k01_idx: From 09f6e379783df78f5e215edb26cab97684beb191 Mon Sep 17 00:00:00 2001 From: Alexander Alexandrov Date: Mon, 19 Feb 2024 17:25:31 +0200 Subject: [PATCH 05/13] test: add test cluster-specific optimizer features --- test/sqllogictest/cluster_features.slt | 524 ++++++++++++++++++++++++- 1 file changed, 523 insertions(+), 1 deletion(-) diff --git a/test/sqllogictest/cluster_features.slt b/test/sqllogictest/cluster_features.slt index b577f63a7d7c2..a7ff5c9f002ca 100644 --- a/test/sqllogictest/cluster_features.slt +++ b/test/sqllogictest/cluster_features.slt @@ -18,4 +18,526 @@ mode cockroach # Regular users cannot create clusters with FEATURES yet. statement error db error: ERROR: FEATURES not supported for non\-system users -CREATE CLUSTER foo SIZE = '1' FEATURES (enable eager delta joins = true); +CREATE CLUSTER FOO SIZE = '1' FEATURES (ENABLE EAGER DELTA JOINS = TRUE); + +# Cluster and system config for the test DDL statements below +# ----------------------------------------------------------- + +simple conn=mz_system,user=mz_system +CREATE CLUSTER c1 SIZE = '1' FEATURES (ENABLE EAGER DELTA JOINS = TRUE); +---- +COMPLETE 0 + +simple conn=mz_system,user=mz_system +CREATE CLUSTER c2 SIZE = '1' FEATURES (ENABLE EAGER DELTA JOINS = FALSE); +---- +COMPLETE 0 + +simple conn=mz_system,user=mz_system +GRANT ALL ON CLUSTER c1 TO materialize; +---- +COMPLETE 0 + +simple conn=mz_system,user=mz_system +GRANT ALL ON CLUSTER c2 TO materialize; +---- +COMPLETE 0 + +# Schema for the test DDL statements below +# ---------------------------------------- + +statement ok +CREATE TABLE t1 ( + x int, + y int +); + +statement ok +CREATE TABLE t2 ( + x int, + y int +); + +statement ok +CREATE TABLE t3 ( + x int, + y int +); + +# Test materialized views +# ----------------------- + +# Should be created with the feature flag turned on. +statement ok +CREATE MATERIALIZED VIEW mv1 IN CLUSTER c1 AS +SELECT + t1.y as f1, + t2.y as f2, + t3.y as f3 +FROM + t1, t2, t3 +where + t1.x = t2.x AND + t2.y = t3.y; + +# Should be created with the feature flag turned off. +statement ok +CREATE MATERIALIZED VIEW mv2 IN CLUSTER c2 AS +SELECT + t1.y as f1, + t2.y as f2, + t3.y as f3 +FROM + t1, t2, t3 +where + t1.x = t2.x AND + t2.y = t3.y; + +# EXPLAIN mv1 in c1 (should be running with the feature flag turned on). +query T multiline +EXPLAIN WITH(JOIN IMPLEMENTATIONS) +MATERIALIZED VIEW mv1; +---- +materialize.public.mv1: + Project (#1, #3, #3) + Join on=(#0 = #2 AND #3 = #4) type=delta + implementation + %0:t1 » %1:t2[#0]K » %2:t3[#0]K + %1:t2 » %0:t1[#0]K » %2:t3[#0]K + %2:t3 » %1:t2[#1]K » %0:t1[#0]K + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL + ReadStorage materialize.public.t1 + ArrangeBy keys=[[#0], [#1]] + Filter (#0) IS NOT NULL AND (#1) IS NOT NULL + ReadStorage materialize.public.t2 + ArrangeBy keys=[[#0]] + Project (#1) + Filter (#1) IS NOT NULL + ReadStorage materialize.public.t3 + +Source materialize.public.t1 + filter=((#0) IS NOT NULL) +Source materialize.public.t2 + filter=((#0) IS NOT NULL AND (#1) IS NOT NULL) +Source materialize.public.t3 + filter=((#1) IS NOT NULL) + +EOF + +# EXPLAIN mv2 in c2 (should be running with the feature flag turned off). +query T multiline +EXPLAIN WITH(JOIN IMPLEMENTATIONS) +MATERIALIZED VIEW mv2; +---- +materialize.public.mv2: + Project (#1, #3, #3) + Join on=(#0 = #2 AND #3 = #4) type=differential + implementation + %0:t1[#0]K » %1:t2[#0]K » %2:t3[#0]K + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL + ReadStorage materialize.public.t1 + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL AND (#1) IS NOT NULL + ReadStorage materialize.public.t2 + ArrangeBy keys=[[#0]] + Project (#1) + Filter (#1) IS NOT NULL + ReadStorage materialize.public.t3 + +Source materialize.public.t1 + filter=((#0) IS NOT NULL) +Source materialize.public.t2 + filter=((#0) IS NOT NULL AND (#1) IS NOT NULL) +Source materialize.public.t3 + filter=((#1) IS NOT NULL) + +EOF + +# EXPLAIN REPLAN mv1 in c1 (should be running with the feature flag turned on). +query T multiline +EXPLAIN WITH(JOIN IMPLEMENTATIONS) +REPLAN MATERIALIZED VIEW mv1; +---- +materialize.public.mv1: + Project (#1, #3, #3) + Join on=(#0 = #2 AND #3 = #4) type=delta + implementation + %0:t1 » %1:t2[#0]K » %2:t3[#0]K + %1:t2 » %0:t1[#0]K » %2:t3[#0]K + %2:t3 » %1:t2[#1]K » %0:t1[#0]K + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL + ReadStorage materialize.public.t1 + ArrangeBy keys=[[#0], [#1]] + Filter (#0) IS NOT NULL AND (#1) IS NOT NULL + ReadStorage materialize.public.t2 + ArrangeBy keys=[[#0]] + Project (#1) + Filter (#1) IS NOT NULL + ReadStorage materialize.public.t3 + +Source materialize.public.t1 + filter=((#0) IS NOT NULL) +Source materialize.public.t2 + filter=((#0) IS NOT NULL AND (#1) IS NOT NULL) +Source materialize.public.t3 + filter=((#1) IS NOT NULL) + +EOF + +# EXPLAIN REPLAN mv1 in c1 with an explain-level feature override (should be +# running with the feature flag turned off). +query T multiline +EXPLAIN WITH(JOIN IMPLEMENTATIONS, ENABLE EAGER DELTA JOINS = FALSE) +REPLAN MATERIALIZED VIEW mv1; +---- +materialize.public.mv1: + Project (#1, #3, #3) + Join on=(#0 = #2 AND #3 = #4) type=differential + implementation + %0:t1[#0]K » %1:t2[#0]K » %2:t3[#0]K + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL + ReadStorage materialize.public.t1 + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL AND (#1) IS NOT NULL + ReadStorage materialize.public.t2 + ArrangeBy keys=[[#0]] + Project (#1) + Filter (#1) IS NOT NULL + ReadStorage materialize.public.t3 + +Source materialize.public.t1 + filter=((#0) IS NOT NULL) +Source materialize.public.t2 + filter=((#0) IS NOT NULL AND (#1) IS NOT NULL) +Source materialize.public.t3 + filter=((#1) IS NOT NULL) + +EOF + +# EXPLAIN CREATE in c1 with an explain-level feature override (should be +# running with the feature flag turned off). +query T multiline +EXPLAIN WITH(JOIN IMPLEMENTATIONS, ENABLE EAGER DELTA JOINS = FALSE) +CREATE MATERIALIZED VIEW mv1 IN CLUSTER c1 AS +SELECT + t1.y as f1, + t2.y as f2, + t3.y as f3 +FROM + t1, t2, t3 +where + t1.x = t2.x AND + t2.y = t3.y; +---- +materialize.public.mv1: + Project (#1, #3, #3) + Join on=(#0 = #2 AND #3 = #4) type=differential + implementation + %0:t1[#0]K » %1:t2[#0]K » %2:t3[#0]K + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL + ReadStorage materialize.public.t1 + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL AND (#1) IS NOT NULL + ReadStorage materialize.public.t2 + ArrangeBy keys=[[#0]] + Project (#1) + Filter (#1) IS NOT NULL + ReadStorage materialize.public.t3 + +Source materialize.public.t1 + filter=((#0) IS NOT NULL) +Source materialize.public.t2 + filter=((#0) IS NOT NULL AND (#1) IS NOT NULL) +Source materialize.public.t3 + filter=((#1) IS NOT NULL) + +EOF + +# Test indexed views +# ------------------ + +# Same as the mv1 / mv2 definitions above. +statement ok +CREATE VIEW v AS +SELECT + t1.y as f1, + t2.y as f2, + t3.y as f3 +FROM + t1, t2, t3 +where + t1.x = t2.x AND + t2.y = t3.y; + +statement ok +CREATE INDEX v_idx_in_c1 IN CLUSTER c1 ON v(f1); + +statement ok +CREATE INDEX v_idx_in_c2 IN CLUSTER c2 ON v(f1); + +# EXPLAIN v in c2 (should be running with the feature flag turned on). +query T multiline +EXPLAIN WITH(JOIN IMPLEMENTATIONS) +INDEX v_idx_in_c1; +---- +materialize.public.v_idx_in_c1: + ArrangeBy keys=[[#0]] + ReadGlobalFromSameDataflow materialize.public.v + +materialize.public.v: + Project (#1, #3, #3) + Join on=(#0 = #2 AND #3 = #4) type=delta + implementation + %0:t1 » %1:t2[#0]K » %2:t3[#0]K + %1:t2 » %0:t1[#0]K » %2:t3[#0]K + %2:t3 » %1:t2[#1]K » %0:t1[#0]K + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL + ReadStorage materialize.public.t1 + ArrangeBy keys=[[#0], [#1]] + Filter (#0) IS NOT NULL AND (#1) IS NOT NULL + ReadStorage materialize.public.t2 + ArrangeBy keys=[[#0]] + Project (#1) + Filter (#1) IS NOT NULL + ReadStorage materialize.public.t3 + +Source materialize.public.t1 + filter=((#0) IS NOT NULL) +Source materialize.public.t2 + filter=((#0) IS NOT NULL AND (#1) IS NOT NULL) +Source materialize.public.t3 + filter=((#1) IS NOT NULL) + +EOF + +# EXPLAIN v in c2 (should be running with the feature flag turned off). +query T multiline +EXPLAIN WITH(JOIN IMPLEMENTATIONS) +INDEX v_idx_in_c2; +---- +materialize.public.v_idx_in_c2: + ArrangeBy keys=[[#0]] + ReadGlobalFromSameDataflow materialize.public.v + +materialize.public.v: + Project (#1, #3, #3) + Join on=(#0 = #2 AND #3 = #4) type=differential + implementation + %0:t1[#0]K » %1:t2[#0]K » %2:t3[#0]K + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL + ReadStorage materialize.public.t1 + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL AND (#1) IS NOT NULL + ReadStorage materialize.public.t2 + ArrangeBy keys=[[#0]] + Project (#1) + Filter (#1) IS NOT NULL + ReadStorage materialize.public.t3 + +Source materialize.public.t1 + filter=((#0) IS NOT NULL) +Source materialize.public.t2 + filter=((#0) IS NOT NULL AND (#1) IS NOT NULL) +Source materialize.public.t3 + filter=((#1) IS NOT NULL) + +EOF + +# EXPLAIN REPLAN v in c1 (should be running with the feature flag turned on). +query T multiline +EXPLAIN WITH(JOIN IMPLEMENTATIONS) +REPLAN INDEX v_idx_in_c1; +---- +materialize.public.v_idx_in_c1: + ArrangeBy keys=[[#0]] + ReadGlobalFromSameDataflow materialize.public.v + +materialize.public.v: + Project (#1, #3, #3) + Join on=(#0 = #2 AND #3 = #4) type=delta + implementation + %0:t1 » %1:t2[#0]K » %2:t3[#0]K + %1:t2 » %0:t1[#0]K » %2:t3[#0]K + %2:t3 » %1:t2[#1]K » %0:t1[#0]K + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL + ReadStorage materialize.public.t1 + ArrangeBy keys=[[#0], [#1]] + Filter (#0) IS NOT NULL AND (#1) IS NOT NULL + ReadStorage materialize.public.t2 + ArrangeBy keys=[[#0]] + Project (#1) + Filter (#1) IS NOT NULL + ReadStorage materialize.public.t3 + +Source materialize.public.t1 + filter=((#0) IS NOT NULL) +Source materialize.public.t2 + filter=((#0) IS NOT NULL AND (#1) IS NOT NULL) +Source materialize.public.t3 + filter=((#1) IS NOT NULL) + +EOF + +# EXPLAIN REPLAN v in c1 with an explain-level feature override (should be +# running with the feature flag turned off). +query T multiline +EXPLAIN WITH(JOIN IMPLEMENTATIONS, ENABLE EAGER DELTA JOINS = FALSE) +REPLAN INDEX v_idx_in_c1; +---- +materialize.public.v_idx_in_c1: + ArrangeBy keys=[[#0]] + ReadGlobalFromSameDataflow materialize.public.v + +materialize.public.v: + Project (#1, #3, #3) + Join on=(#0 = #2 AND #3 = #4) type=differential + implementation + %0:t1[#0]K » %1:t2[#0]K » %2:t3[#0]K + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL + ReadStorage materialize.public.t1 + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL AND (#1) IS NOT NULL + ReadStorage materialize.public.t2 + ArrangeBy keys=[[#0]] + Project (#1) + Filter (#1) IS NOT NULL + ReadStorage materialize.public.t3 + +Source materialize.public.t1 + filter=((#0) IS NOT NULL) +Source materialize.public.t2 + filter=((#0) IS NOT NULL AND (#1) IS NOT NULL) +Source materialize.public.t3 + filter=((#1) IS NOT NULL) + +EOF + +# Delete the existing index in order to get the expected output in the next +# test. +statement ok +DROP INDEX v_idx_in_c1; + +# EXPLAIN CREATE in c1 with an explain-level feature override (should be +# running with the feature flag turned off). +query T multiline +EXPLAIN WITH(JOIN IMPLEMENTATIONS, ENABLE EAGER DELTA JOINS = FALSE) +CREATE INDEX v_idx_in_c1 IN CLUSTER c1 ON v(f1); +---- +materialize.public.v_idx_in_c1: + ArrangeBy keys=[[#0]] + ReadGlobalFromSameDataflow materialize.public.v + +materialize.public.v: + Project (#1, #3, #3) + Join on=(#0 = #2 AND #3 = #4) type=differential + implementation + %0:t1[#0]K » %1:t2[#0]K » %2:t3[#0]K + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL + ReadStorage materialize.public.t1 + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL AND (#1) IS NOT NULL + ReadStorage materialize.public.t2 + ArrangeBy keys=[[#0]] + Project (#1) + Filter (#1) IS NOT NULL + ReadStorage materialize.public.t3 + +Source materialize.public.t1 + filter=((#0) IS NOT NULL) +Source materialize.public.t2 + filter=((#0) IS NOT NULL AND (#1) IS NOT NULL) +Source materialize.public.t3 + filter=((#1) IS NOT NULL) + +EOF + +# Test peeks +# ---------- + +statement ok +SET cluster = c1; + +# EXPLAIN in c1 (should be running with the feature flag turned on). +query T multiline +EXPLAIN +SELECT + t1.y as f1, + t2.y as f2, + t3.y as f3 +FROM + t1, t2, t3 +where + t1.x = t2.x AND + t2.y = t3.y; +---- +Explained Query: + Project (#1, #3, #3) + Join on=(#0 = #2 AND #3 = #4) type=delta + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL + ReadStorage materialize.public.t1 + ArrangeBy keys=[[#0], [#1]] + Filter (#0) IS NOT NULL AND (#1) IS NOT NULL + ReadStorage materialize.public.t2 + ArrangeBy keys=[[#0]] + Project (#1) + Filter (#1) IS NOT NULL + ReadStorage materialize.public.t3 + +Source materialize.public.t1 + filter=((#0) IS NOT NULL) +Source materialize.public.t2 + filter=((#0) IS NOT NULL AND (#1) IS NOT NULL) +Source materialize.public.t3 + filter=((#1) IS NOT NULL) + +EOF + +statement ok +SET cluster = c2; + +# EXPLAIN in c2 (should be running with the feature flag turned off). +query T multiline +EXPLAIN +SELECT + t1.y as f1, + t2.y as f2, + t3.y as f3 +FROM + t1, t2, t3 +where + t1.x = t2.x AND + t2.y = t3.y; +---- +Explained Query: + Project (#1, #3, #3) + Join on=(#0 = #2 AND #3 = #4) type=differential + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL + ReadStorage materialize.public.t1 + ArrangeBy keys=[[#0]] + Filter (#0) IS NOT NULL AND (#1) IS NOT NULL + ReadStorage materialize.public.t2 + ArrangeBy keys=[[#0]] + Project (#1) + Filter (#1) IS NOT NULL + ReadStorage materialize.public.t3 + +Source materialize.public.t1 + filter=((#0) IS NOT NULL) +Source materialize.public.t2 + filter=((#0) IS NOT NULL AND (#1) IS NOT NULL) +Source materialize.public.t3 + filter=((#1) IS NOT NULL) + +EOF From 94d1f2062adea0c64950703acf47ebe8168964b6 Mon Sep 17 00:00:00 2001 From: Alexander Alexandrov Date: Mon, 5 Feb 2024 13:47:12 +0200 Subject: [PATCH 06/13] design: Cluster-specific `Optimize` pipelines Design doc for the #25273 epic. --- .../20240205_cluster_specific_optimization.md | 319 ++++++++++++++++++ .../problem.png | Bin 0 -> 289126 bytes 2 files changed, 319 insertions(+) create mode 100644 doc/developer/design/20240205_cluster_specific_optimization.md create mode 100644 doc/developer/design/static/20240205_cluster_specific_optimization/problem.png diff --git a/doc/developer/design/20240205_cluster_specific_optimization.md b/doc/developer/design/20240205_cluster_specific_optimization.md new file mode 100644 index 0000000000000..06869805e1eaf --- /dev/null +++ b/doc/developer/design/20240205_cluster_specific_optimization.md @@ -0,0 +1,319 @@ +# Cluster-specific optimization + +- Associated: + - [optimizer: Flag for controlling join + planning (#23318)](https://github.com/MaterializeInc/materialize/pull/23318) + - [DNM: Draft for variadic outer join + lowering (#24345)](https://github.com/MaterializeInc/materialize/pull/24345) + - [misc: add `mzexplore` command for catalog + exploration (#22892)](https://github.com/MaterializeInc/materialize/pull/22892) + - [explain: control outer join lowering via + `ExplainConfig` (#22744)](https://github.com/MaterializeInc/materialize/pull/22744) + - [design: A unified optimizer + interface (#20569)](https://github.com/MaterializeInc/materialize/pull/20569) + + + +## The Problem + + + +Optimizer changes are tricky to implement and deploy in a robust and predictable +manner. The main problem is depicted by the following diagram. + +![Problem](./static/20240205_cluster_specific_optimization/problem.png) + +Most of the time, a change to our optimizer will not only improve the +performance of some SQL queries (hopefully a majority), but also introduce +performance regressions to others. + +The expected plan regressions and improvements of an optimizer change _in +general_ can be identified by running random query workloads using one of the +fuzzers available in our CI pipeline (RQG, SQLSmith, SQLLancer). However, we +currently lack the right tooling to determine the _specific impact_ of such +changes to our current `production` environments. + +The latter is of particular practical importance when prototyping and validating +possible optimizer changes behind a feature flag: + +1. It will help us to quickly get a feeling of the potential improvements that + our customers will see. This in turn can help us determine whether it is + worthwhile to invest the necessary time to make the change production-ready. +2. It will help us to identify potential performance regressions that will be + observed by our customers once we roll out the change. This in turn can help + us to improve the robustness of our rollout strategy for optimizer changes. + +There are two dimensions of assessing the quality of SQL queries in production: + +1. **Assessing the quality of the optimized plans.** To a large extent this is + already supported with the introduction of the `mzexplore` tool + (MaterializeInc/materialize#22892) and with adding the ability to control + optimizer feature flags using the `EXPLAIN WITH(...)` syntax + (MaterializeInc/materialize#22744). There are some known issues with the + current state of the code, but we have fixes for those that should be merged + soon (pending review). +2. **Assessing the quality of the running dataflows.** This is needed because + sometimes the impact of an optimizer change is not directly evident in the + optimized plan. Instead, we need to deploy and run the modified dataflow and + compare its performance against its current version. + +The current document proposes tooling and workflows in aid of (2). + +## Success Criteria + + + +- Members of the compute team have agreed upon the developed the minimal amount of + tooling and code infrastructure required to enable the evaluation of proposed + optimizer changes in production. + +- The new feature has been used to asses the potential impact of the following + optimizer changes: + - [optimizer: Flag for controlling join + planning (#23318)](https://github.com/MaterializeInc/materialize/pull/23318) + - [DNM: Draft for variadic outer join + lowering (#24345)](https://github.com/MaterializeInc/materialize/pull/24345) + +## Out of Scope + + + +Things that will be nice to have, but are intentionally left out of scope from +the current proposal are listed below with a brief motivation for that decision. + +- **Not requiring `mz_system` access in order to do a runtime validation + experiment.** This doesn't seem urgent because we will always use + `mzexplore` to first identify a small set of candidate dataflows. For those, + we will in turn run a dedicated experiment together with a designated + engineer that can temporarily request `mz_system` privileges with Teleport + (similar to the `lgalloc` experiments). +- **Provide tooling to automatically duplicate dataflow-backed catalog items + from a reference cluster to a temporary cluster used to run an experiment.** + While this might be very helpful in general, we believe that most of our + customers deploy their DDL statements with a script. For the first iteration + of this feature it should be therefore sufficient to ask them to run a + modified version of this script (with changed catalog item names) against + the temporary cluster while running our experiments. +- **Support experimentation on unmanaged clusters.** Extending the syntax for + managed clusters should be sufficient for an MVP. Since the clusters will be + short-lived it doesn't make a huge difference which syntax the Materialize + employees will use to create them. Adding `FEATURES` support for unmanaged + clusters will require more code changes. Since the syntax is now deprecated, + there is no need to additionally complicate this code. +- **Support changes of `CLUSTER`-specific features with `ALTER CLUSTER`.** For + the same reasons as above—for experimentation purposes we only need + short-lived clusters. + +## Solution Proposal + +The suggested high-level workflow for assessing the potential impact of an +optimizer feature will be: + +1. Use `bin/mzexplore` to identify dataflows and clusters that might be affected + by an optimizer change gated behind a feature flag. +2. For each such cluster, run the following experiment: + +The suggested workflow for running an experiment on a specific customer +environment will be: + +1. Obtain `mz_system` privileges through Teleport. +2. Create a dedicated cluster for the experiment. Use the feature flag to + enable the tested feature in the `CREATE CLUSTER` definition. +3. Create an `UNBILLED` replica for that cluster. +4. Ask the customer to replicate (a subset of) dataflow-backed catalog items + defined on the the original cluster to the experiment cluster. +5. Monitor and record observed differences between the dataflows running in the + original cluster and the (modified) dataflows running in the experiment + cluster. + + + +In order to facilitate this workflow, we propose the the following changes +(discussed in detail below): + +- Extensions to the `CREATE CLUSTER` syntax. +- Extensions to the optimizer API. + +### Extensions to the `CREATE CLUSTER` syntax + +Extend the `CREATE CLUSTER SYNTAX` for managed cluster plans as follows: + +```sql +CREATE CLUSTER ... FEATURES (...) +``` + +The newly added `FEATURES` clause will be only visible by `mz_system`. We will +extend `CreateClusterManagedPlan` and `CreateClusterManaged` with a new +`ClusterFeatures` struct that models the feature flag configuration that can be +overridden on a per-cluster level. + +### Extensions to the `optimize` API + +Here we can benefit from the unified optimizer interface introduced with +MaterializeInc/materialize#20569. As part of the associated changes we +introduced an `mz_adapter::optimize::OptimizerConfig` struct that currently can +can already be configured in a layered way: + +1. A top layer of settings bound from `SystemVars`. +2. A layer of `EXPLAIN`-specific overrides bound from the `ExplainContext`, + which is available when the `Coordinator` methods that drive the optimization + process are initiated from `sequence_explain_plan`. + +Since all `Optimizer::new(...)` constructor calls in the `Coordinator` happen at +a time where the target cluster for the optimized statement is already resolved, +we can just add a new layer for cluster-specific overrides between (1) and (2). + +## Minimal Viable Prototype + +An sketch of the proposed design can be found in the MVP draft PR[^3]. + + + +Nothing is done yet, but once we agree on the SQL extensions the changes to get +something working end-to-end should be done quite quickly. + +## Alternatives + + + +### Managing cluster-specific parameters with LaunchDarkly + +There is prior art for this in PostgreSQL: you can set (most) system +parameters at the database level, and they take precedence in order of: + +``` +system < database < role < session +``` + +or something lke that. If we get more use cases for such layering we can invest +the time to teach the `SystemVars` about cluster-specific parameters. Once we do +that, we should be able to enable feature flags on a per-cluster basis through +LaunchDarkly. + +The approach is rejected (for now) because it requires more substantial changes +to the current state of our LaunchDarkly setup in `main`. Basically at the +moment we pull parameters from LaunchDarkly in a loop using a fixed +`ld::Context`[^1] that consists of: + +1. A context of `kind = environment` that models the current Materialize + environment. +2. A context of `kind = organization` that models the environment owner. + +If we want to provide cluster-specific configuration through LaunchDarkly, we +would need to extend the `system_parameter_sync` loop[^2] to run a +`frontend.pull(...)` call with a different `ld::Context` for each cluster. We +would then use the `CLUSTER`-specific `ALTER SYSTEM` extensions in `SystemVars` +in the `backend.push(...)` call. + +## Open questions + + + +N/A + +## Future work + +From @benesch: + +> As future work, it seems like it'd also be interesting to allow users to use the +> `FEATURES` flag, limited to a restricted set of features that are worth allowing +> users to control. +> +> We might also consider introducing +> +> ```sql +> CREATE TEMPORARY CLUSTER ... FEATURES(...) +> ``` +> +> and limit certain features for use only in temporary clusters. These clusters +> would only last for a single SQL session, and therefore wouldn't survive an +> `envd` restart, and therefore wouldn't prevent us from removing the feature +> flag in a future version of Materialize. + +--- + +[Automatically duplicate dataflow-backed catalog items for experimentation](https://github.com/MaterializeInc/materialize/issues/25166) + +--- + +[^1]: [`ld_ctx` definition](https://github.com/MaterializeInc/materialize/blob/d44bd11b02e0c4cf11aa8307e44ffc5c5132eb12/src/adapter/src/config/frontend.rs#L145C1-L208C2) +[^2]: [`system_parameter_sync` definition](https://github.com/MaterializeInc/materialize/blob/d44bd11b02e0c4cf11aa8307e44ffc5c5132eb12/src/adapter/src/config/sync.rs#L23-L78) +[^3]: [MVP sketch (draft PR)](https://github.com/MaterializeInc/materialize/pull/25165) diff --git a/doc/developer/design/static/20240205_cluster_specific_optimization/problem.png b/doc/developer/design/static/20240205_cluster_specific_optimization/problem.png new file mode 100644 index 0000000000000000000000000000000000000000..33a683aab0287db7b966534516961c893e6c8b28 GIT binary patch literal 289126 zcma%CcRbbq_vgBHR`!ZiHrX>=MMYM!Wh8r#?6@wKnG(t-A$#w2DP@oBeT{6ovbpZP zzc=dh`96OCe82xxj~lOX&Uro0^E}VF;aVE^$Viw-aBy(QRPHNjNtKt+e@zn$~!DxlM8y#HnQEJzRzltd<+m*c-1iyab_?*Ct{1ndr@ zA)=hqROEW7{J)r$XxoG0e{dE1TM%$7p4IF5VgJ>wz;d{Ozy23Hfwh5KDd49n(Ng^n zPGE28m-`>=6a*mw6K#Lah|OIvCy9Ff`gP*_lEOkCY)RY>MxpP4gGu=tW+o=yMEw*G zX@dWD%6B}#0Ta=;i$r+MgAX{(U4r*j^Bz+D4n8n)kPTy#eT(3TrJs{*g=Xt)BP8(^ zo?eDTCb2~SYa<97cr(1E_4=H7aLKWTOMctWS@~y|J}CV^PiEW$;>#c0YejH}ox!m{ zuOK!M2LT@Lg(hbN6u?j;L5)91gLmAnhY;hnmZ|1-O06W8L9n&TMf>X38LoDAcEZbb zEU*6E76-&iDb!C}yzxt@pK`e&Ai1A9hqJ)2F*v-r_3%08kypkiZqWa`JWL)493-C1 z2Q@gP^fJONWhHU+NbyukaqnGKusqQmTebf5GlwemVO6&5;oZVb-2HX7Vc#E~Gs#3p zpRt&1{C`8fldfZB*Q09gv`?lgs;h@~c9iee&joSn=V%*d&SOs0L5A1AKYac#JV8hh zw8aG{31Pra6oD$RSpe_o6LtiTh;VYJy&n<&C;;yHiBG-vhKWUN%Q9X84*8D-hN+0s zZWtxD$lki;SPnIL$b~nS)DoByWvs}mMq5<$rBS6>z5IERhMJd&H(TuUy59c?xBE2^ zp#wH&<(n=_9504?e*l{dbfOmfY*U1rAp{+RA46kEgg! ztYoz#(ry%D;ilJDlG7`>VwAU=j6buXTkun=@4Z)ZNGR8lMCY$>*UbXO{{tBBCqSe; zN}4=Nv4xkpc3mZnX!~wiTM)^0T2H_JuEhybp$2fT^2$efIV#($32c{|x5Q~l33oy$ z`pqqZ%zRz6ZZfbqJZ&kV4G|9s`H1@^IT-5g{!Kl%cRv`DW9rY^J~7q@dCG^w68Uc! zK_tOFhqH7dzRJ2+kBYBwt(uh(A7mtSW>nSNe|M~*&H7!Uu4P)N!)q+FM7ir59t8c| z!bA9PT){X&REQtF9(VcrnOZrT#PzjRS*f2Al~af2S1uc|MnT7?n35k9Yk*fRABQks zf)x@|&h;C;8BBW$wjkHQXJg4W%2#zM@vU&5RedULPcFoV>cvW`*f7@6M;q2rds=WS zYw)p+&o4x)tgY49&G{;W60x@(&N*3j19!^+_0o8P4`~V&@xEHp|nXZSFF2d%LTmaIzo{f1FAv@ zm!nK9b{5Als)_rnse|5df@FxU_<_7w(WRrR!K?GFiXO${5L>-HpG2^Q#(g4AmV|gk z$;6YI-FeMYc>I;02LD76ERZBY4$0asj7YZOSf5wdAtPv?Ja%qOt2PYrvz~LX=_&WC z&TpPL41{jry6ikF*|IQlWB8Bk89)!jh)c<{oA|h=8Mp^}@MRmj&O!$lX6yAW8{SCj zG4^f5VZ#TKy|d6)*snXN2XCTpCKr|)HbtwLtU>R$O?X@P66Q$X9KZJcxk1hno``K@ z(|XQJiY`wwN(tt@r&iedKzu32e_|m+8OEu&I}#LF_jq>3;)ej6Glk_b%JO@vYh%*Y zZcCI1o;exkzL(`?mx}NB{Y=&mLS*`_3;Jo}Rlg;RwUYj`4h~F_rWEg_>foNbShNMP z&343tnv+}R8bovl_!E&^w{IuDXsS6~i5pRV9mrUa7~W7-Dx9mYqjv3k@ORH|Vhdl~ zSwLty_7(*4%G^mAc#?Rzop)UGT4%E$$Hzo>+4aH`7yqDv^{=e^gGYxJ?BdG-txx_9 zBF4+51V6su*_xJ4yQKuArnESG{%@42T=a^QliH@QbTeD-42>rvTbAJzH4W-|P5$h+R&}{X zuWRE+YS)nhwkq70~W9yMDOqdUsxH!rBUL8H$IRcQkIb z3?2!`v*vIcpmZ347EqINh>|9_C#%~#zZ$=-_Lb&a+oE+wW4ZxAA;PzkTJsDD^;g(- zTWe-1LR!~e`Up5ZiHA=(c$l$Z=kWBEHVbiQqv~s|+6v_EUHvEFTbi_xtS8HDY$@iv z=Xy7}#%`?k(IsIko^Mv-$qdn4%}}~9L1R7BcF8VU!M1Dt0M9M$#-yFX%72iX0W#S9 z{Je^Szdm2VUK0|2P;uM#8E6X0_W1Yr{&mP}#B{b9Fua zLe^y0)vyE%-=>X2iqiQ>$z zRiA2$0&?revyOZcGh3TRUIQ~?gSRLug>cQqk6fzJBK_P&){fC-Z_5f|(+D@mUMzd5 z05AN5InRL&h-^?;;;FrFf2TG6PT(Q_LKdQD$vyJ*fmBh&PX3av{)~%&{=YnJ^#i10 z(pKkpVS<6p%9vRw#qH8MGh8eKb?6~^Fccn`UMu)-{M>>uCBVZQ(R3FpgV_FgS=%`Sl{O|` zVm!a#p?OmLg21fy{2VkY9(%BxmdHI^Izz}avcsCZ56uYA89VEq8zt~Os=p>0P=Q$& z?5mf0TUlB4Z2C?(ibomxJ_#NK?@Vocv_@?7nkP&hPy~rzuFzsr`2(fLKZ`U^qFU>0# z&AzY!a^)V=O5wdA9IW3S!O?Vr-QiY~R#LWR_@LMdl5-%viMcn4#^OL)9F=?}ww#+c zJ3l5@wAO)O-%C;zl`f}j^x`jLur$l~VIM#ZalSlYgHzO9b6+TIx&BwQ3^kujeLXz3 zH4t7{r>*`Byeup7`!1^*qJQOebP7hT0<8U4aD_{~EtT@!tm@Ky52lHx6FiC|sr(`+$5Cu+cgyIBh)#kB_9>bWx6cYJ8TA zL?+Br2d?KL0}K+)153M_A9f|_;guXepUrBXFyw7ItTA@D<T zW~3X>+w&sQz(&M>OP<&6~;f?Qa9B4nwX4{g-FaWX%Xdbj^79)`Se>W(iPMaAw=s zQjCnCibhr@UwBiE-1%FG5SV6|nk#e&PG2wW7gZrZX0YRxX?I!XNKCc(7991$jUWGj zb2k475AS3AnWN%FLOJI`E!h3}xWGz{dZW0Rf>3iKyU?(I?w-*7JFW`d-p1(a5tVOd z-lNG?Y#OD68Z#=mAv~%Df0;MTlBBJJ##%q6P`z{WdrlPz{`{xvwVhz}hWcv+`#3x) zP@zvWr>V$*`z05jThf69;Xgp$Ngu|bDUmlt?@>2h*(o*6UfN&lvC~jfAbv>?n;Z$A z$O{So;x>r&<}EPPXI7aHrw54fk>I*IKJ%q~@f6rH;lWlo&hy&+oNj_;-q!@Hnc6$| zHnZ&rcD&jd+n5=2m?Hkh^L2>1rKRO(?XFFy30uvtPs?B3$XM6;hzDxA{~D2J4!3h2 z#wmr%vGy~u*0TLuPyv|Jc2rik7iCyzi}~s~!x|{Tg_3?*d#^->8*j|+-IE^Yt7Vaw z_PpUqKn5|}A+B|<$O!y2a!6G%c628$NWRyPmZ@l+;`2cigOFfdv25>bq9Oc&E!!WY zxNgF3@y=Bzo)PlE@19p_ps@Dl&HCa77dga|EbXRCwWI@~Aveii1cYRSfcC5X#N8;V zhf9iPC5^=s)gHA*Za!h%V;jya>@nvYfgW91G-V!U{)D&1*@D1rtE7GCvZOd{zv?=b zsdtZBOnr*=?dy~8hKi4DZnv1WyLlxKOHaJbp#2->5E-xq_y9Q0J$AgK-HP<#J3x<|%oj!UDqDYbq@T z1PQUB@?h_$o)#*@C)#e$Q9Xpc*4t=TF*9}XVrFw+Yra{og(4_8IV3pbI&`7)OOp5# z91tV?)7HvVGVR|$k}XP|3h|S?zl0&eL`T2@PVNciEOTxRin zESZ$kb5u_&8TqDxwcXcr>lO$#EgwK@`@WN3W3#w~Y;GZd7I>%nnAyjTeX5KuuZ&W3 zdmdIy5p5pkAZt~h<8FK%m~Hp$HFs0WNLQ>mYGVoi8$^}YDa(rVkDga+*{j5bFyk*) zjV?D}n;#3-Fsw*Rs#bJbf_66twi%PczfFJo$D$(O%;pb?=6Txom3m)0S^_JOex0_A zRUP>)e(B2P>$e-$Nr75vb>>HS0Pfedqu$Nx$AXeGzsyzc=Gp0e0WW}0?!@XD2){3t z&yxAG=v!x)6f8iGBdg&}tQLwPPvEe=*nennaL___zbKZchep@l3wwFhU$0=DiU=PmYO9AR#{9KVOAE}RZ}Ti zM|4s1o&3Fei?xB~Xnt0MXxz{|9h}&#mC1Zn52^TO~!zEF^I0lTLcv$65b8gj@3b+eZ zM~`;N=K_Hl@`HwA=E8Lf5#3>v5i_nOxG&vAuY}K9eMzpsUvPN9p5C9_(wu6SXNu3b ztFAZpFj)eeWF_eQ>Ar?a9zas!yi)SKJ`bXm)hOpe1iu~P>$(VPaSgZ}EQ{f}x0BPzH!<;%hKcs{oPBRAhTaOCo9J9?ZHG<0a}_l_XKo*Tyh-aQJ(6Zt!oE zX~4pc?pxle9F44d?3|<$zqV;(&nlp00}^KBC0KoRwIzM9kDMYmks?nuyF5F7S&59l zv_6McF9F4lvrfCCWK3CFOR1% z5=0h^o|P}+C@)Dx^D}4nUUDI&+`sips*jE!tzrB(&FeppFp+ATUf_!DAUmC_RZhFz zeK}kZI>g@v5K0XZ_X?}&i}s%tgiuhi1r<(ePBcM0Ww|J4({3w88}{~_8?Q9-5dQ(w zK`u(#s69N?r>fDnxI6(Ss;>iJcUuE@A7@lG=Z&mvoq^J;Zc@2L(bfc6>c0qV%Rw2V z&i|YMkyjf@pb-SYws_V7TdSns%TBiAs*1us2z*(^r5@g5rRogIpU{Q*<%ysXv@YV% z20PgXBR7(Je?zmLpE5ogQFymlufSt8KOolPd40F;M;~xK?*R8qGcgby4K8+eooWQp z=m;MI$(3T?YIAX@qXzjO!4ZZ_7nb-g{bdy1^EU%~pN##1U-)EArPg+srZ9f{roT5K zE{0~$F7=tH0932Y9?)jhX;Ff6P@JSa4bEH_5lepF>>k274S6Eeteno@Q~7b9oodsh zuDo1iSxVzAd2HnexlL-p5m}hIdEvn=Av<+TLsk|KlfxXnVD!G;@OW&PVK1Tqv!wbr zXar%~2~J8|h8+pTg4xw3bnF8Nt2r=@W{?7I>Od|DRe_b!6-a@kQ2T5kG4gr-m?TW5 z;J67OeD=P<>IkNxa#eWyp~P~faWO9ro+#BPG6K4w z-XZ4cNZ@VR1pDmU8GWJY`rZVUkAA$=x%|h|Ml`vHrH`v4#wKOx+o zw6_H#OKTrdhVcy8azJ}Hr1+lziW2qc)f}05LfDM6UGj?$ss!$ z`vv|m1JHc~KB7f^G53emZ=3x2WdO&iVxyXN!aNHj<6{XQvvZ8LS}w%RQlA~g?IW$I zlU!qky~2}JRZo$t13<(X!#^iNKK{j!x5Th8!qbs>A%M_=51Qh;EQPw1yobUBiNO6N zRfw2Q*HSZwCfUAxj0`nFW2=P10JOzyO_OO-aPOa*7g7$s9UB$WB|ITzIHTmG&8v0O z2`U@;`jP6}aC_=GO)be+dOhdTU6D>dHd|~Btw%U#P=$zKZ|4|zoG}}k&ggSZ-N{2C z`cK-2SrWg{-y)>gn;#LW+WL~S2ohoy=I3xj=zy}za`Dm(d6B;Q@NcLk&tUzT%%7o8IYXJK08P}&?)iiCyh;; z&U`fZ*>zn8ZrFgi&wy96E%~qsWv?4QLVxu zA^hg*`uq1%HmvY+(Jt@e&}gKw{oevDl`1#(UAo(7-?lahNFCpx7ZJzpMhLVFo_=@{ zf+`|U6QAU(c+T>vYN1jppU1XO(Y_INmzK z?iQS=lVI*nnTy>=yXYNOeBqoh(cJpOK{8+vsT&IY9MghCdz$PVv9D@O7>p10OElL_ z5`oK}w2}AK?80N8Qxn`j;1A@ok{)jp@5x!xTYDzfE_IL7 zG&HvIh(Qz7wx#)qP2akb*|ZN-Yobmp+6OjBy^qQlsAQ?f&ij@jP@~gv(T)K`OuyYu z)H7<{>h+{e_VTC=_y{#{6%%r5vOHKsaLBwBKM|Vassg4g1$X4PZv8cy3QcLq;lqBm zYuBz3#%XiT)cDFLT3ZKR_K%UV(#`1054=eR->64zhD*T|Q#)~6r@+S*eiZ|P7t})J zI%QIjqtV@Mp*!dYkIJu7R+%I$N*S-K-|f3wFf>F0I+goXun#^otU@gIEw~d^UZwo~ zvHio41dBBOA4nR#IpFB-dK56`S)+tcJ!VF&3bY8N0Ig>`xsa*htCbkhUTnDnxm5dK z3T*}s^VoZt8p$zG4LS0zuFhB3InLT5b+s@CfM?3W0h#3$f}+Cn$m(${A(bM9r4heS z*h`og74;MRs{?R`&W?{KY}A{M3RNh0OO04@?+yqfLx9#Hnz|Hp=%uRWq6=S?YWT`$ zeM;-!4CCi(f9tP>CXdLJpnT(maz=|dj zf1Loq5FC&b(F?-Ss?i1&-zkFYpa0(B0q8(fNk8KsU}D;TTk8N}B|DHYDGJ7))vK z86wruPdF>1D9!rEx=bW52>PNsPe*=L5N{H(517GZa8I9>ySyOmM;let=fG#$M=qWm zg8?j8?T#avL}?8kS$`O$O_UJWXrKms)DSh>*M$z#p+9whR+r9w1?EihBKUM!`&7f5 zI;H&2Z$n_))uu)pYp%=e!6-bRrvpEGh=)n{rY62{e5Z-RQ^fSlkcknUovK9oa>w6U z034VlsS+4>f{A~^?{7HvxIE*W~V@DQ(pO%K|PpR?U9rD>y%51<-O6@D)Zz>5RCf zDC%j7lG;4oNZMwTP3DNZ8Ehc%G3sNV_{H5jsv+F2Y|^%OT@|Jdaf+B7aiRQAw0S(0 zbutv}msk`rt<5&Jau-LPp$VH5^}(oDME|7X3+|qR`FPtm>&$ws+Vqf@Z)c^t}u(kNuy}b|PL%JpcEllK?h9d^6WTAV~_s zyH2S(0k01j$D!J*%mW|E_BcTk>WUkz0CspwiEWqT1~hb@ha471td!k#-BZ0wCT9IY zT^``Vl{GeK+BEZWHFJsJ0ngB+3$ zCi-5J zpfzhj@EHXzhWz8CBI+)mW#JxL+aN-X>hs3d6<$RqIep?ko4tWFyG16>f16hcQa(G4_)Fdl{lKx_#I{0?~WluQQ zc!4d0!D97o92hsQgIP~172gTtv&Cw~KM_+8`smj4Zq%>q8eIrzkUKEH#PCH&HiEO-l#&S8gWvfvwn;Gv%KGY{P`uqu zA|AklfC?kgaixn;D_(R@0e+d0p2!MCWYj%p^c|JDd?CkD-Y{1<9qp#E?z>joj|L2t z3OG`^xODKK;vJm2G!Ay2?I98Pn>J)rhOD2i*QPIM0CBYU5Fib|FEK_@%m?#Fp)w`d|Lq8}~ z1oT3TnkbqjZhi%vAQS|ehhGC96K->6be^w($2VZ@iU7}zlQ^0qnV6y>D_{eg?T+dB;=A5&ZVcQ8pfMhj%C5kJ@*lx{e9^Io$rBHE ztFe&(`T%I-0r?yslyP8DM3g_xp!Y7%x%?O~HQbQu%hAr$0k9)7>}<$I9sdj7scN3E zg2Vmrn?KZ#rTzr94vCWbb#lq;zeun;AT2vE<^3o~)7fU!L&`ef3y_T_0YG(AN3}Qc z_SdNw6L!apA2zvVUtSd&0Kk823=KXq-mbtqF5Yl9G%_-B+-n`X{e$H!u2`;_Q_Lm9 z#HbR*6ft-Ge}DNqk+en=CVG}6QUe|oQQa?qtopV&6Y!vhCi8}wFZLvYJ(qU@p=8lD zqtE-=eKl}tfzNIA**QA;EAFbPflh@#_B=U$juC|77kP(F6da=sH#hw!g1JIDf*>Ba z4woOQI5Zjac)rAXhXvRr?Ye<4pd*j6G@UOvylp;W%1$_O^FxGl_B$d=Kq(!jw5Q}j ziT?O1c0O!l{ucks6nSX6GSM%Jof*X`s?}5=(H;~MZ?`|I7_wS+uUi9@pcQ1ellG{Z zJ}+%W{rj^?x&b#_hXMG{`d^icQiP|GLdivolQb8%hPdEomcLLQVb?gp%#NlMTn%c; zAbLS3Io`|Jp};MPyLDdoccefnoI=hBaOC zq7j{b}((2#yba*j$C?Oe6u}}TdqkQ28i>mH1r^HnjPoQJPvnIBcADP+waJV`C0%062|fjVrQ zBWnC!DlF+8L;G*w6P!HMFaE3Iz6RQ% z(={P>mx|qhrZfbO{{^-8YW=G!CeWL5>_VOa3Y8;|TkFSP$T7R8ty@4MKwl0^FaQd# zOi`k3$=W;DtRoUW)y16b8~1urK_G?j2eUXv0=ii8UGH##JGIgmFZKQ#NJ<=P-s#IY z9lsp_M?P~u;otNrt&K#4T$9f(F_;_Wfv zi17_roLDcC3n+A9SBMPQoM-i}&O;9~NFM*4_yRHmLEk#Tmsg>oT&(TV=7OzVi4q^B z$#B8-oB(<`RMJFUfN4AaZMSG(n@*NdH!l(;93W8)cV77pa_o-Bfu<(&$0aGa>rKfZ zH8svmFnO6MpmxiX#m2kJDD{!5`bpkN(;m9(Og7gDJQ1 zGwGBQY^b1`W_mjwf9U&L99+~y=4|y>x3q_s2WavE$Ki1U$8rOB)SGSM?BzEpBN9RI z2V#JjeEB*hlUA}Di%t4Qy>&K%p*0BXNuzs_TwCbFDtHl?=OvOjgxrAD-qOHwoyd9- zg3txwr#vca-0SBlL+CBYEf@vtMR57e-D^P*3ou7{Xc_wyk`;9NaZ0R@(9GhOBX2Np z2my1lTwgv*Jw3her_Y+7caZI+DlVSWwRhZa`&W?mVpRQUi5jj7;d1v=ffuIQGFvj% zh$KAf&3d{EZ(4Fs+_aefBgXF;u!|Aj6yY=ACKmxXmKx_3(=)#=oNXQ>tfoY?ZCsO& zZf(ynS_llyqXZEt5sjmc-UG-ynr8UC!|hMG_LdT6jw-p^&)^oVa^EAD0Jvr;FJ)Qg z_eL8K*cv5N9_dzcQ4|e4#r5Aw9hDJr?XNbM`$Z!diUZo93+uQdvHhC@bc%7Z!vEHo z9@lNm>rf&D{izgbEYsQ#qbeQ4})gk$iRLj0OD7o6F0{F`$2|@&g)FnGlYY;XQ{w zfL>P-YB?nty6i`xgStFAaHc86s9;e53C{hkztf)plLXYUPr;WMmof~2?SV7wJ!aQ% zMd(EIJdr~(2?DFI(u5K1P;6G4KyKE=06aoe&lvf;6w?c19QXj#^%8fKd_1e>8J3Mloh7%kKl zD@<4mq<6)?AljouVh?)RRPE&6Qhb^g0Zc6b8#s7ky4b@(vWs=R`o5?+NBsPRomA|# z=_$<_oPZCRVSdIhba`n->wL^j@tEgo4(s-Y43af$%$>}g1DGNp2jEN){y`V!421oQ za{eeE*B`Op?=^F=3al7GcRJEmov}_WzIw5{JL?&I_76$i$EGP*pyBB6)_<0n-jtDeX^A#|D(=nhc7m})xVqLj3CLF)Hb zo1-^w76U+)N?(d?KF+2X2K-1rP#uC={y6BCA}t!3LQ&I)b$EJ@d4G$ounVWuY0nvnwJ{ z;wq*r(ECh10ffV90dihRp?)Sj+PODGzZ6PF7e%c#YtPgz!y3-2GyIvPK67Ki!B#vv zdeM<5Ue!A2_204hXId?3I`rZ}-*Joy%XolB?PY;EtlTYgr*LlT&2KtJJXVAIu_pXK z;Wby~7j zUYOVIFEWz0e$LibymKyB8MDZtXiH_}`X$(w6N{&?4(P?>3-OaMy zu6R^)zyOaTlhlSy4^#gRtHu;1gE_AMNb~WOO-bgHvlVkxUteQhQ=^U>Tz+auRI>V8|hU zp;Kf?q!q^S+Ac0;yDLC+z`FlgLGN5gqv9ddvlgi3u0IUYL91-iuAf(8ZR`^6})0Cp$oOfJN1%z#a_!c zi7lEBee%GYjPT6(#B{l_`B=e6R@(bqwTrn-=TOQE-n5Bwwa3)@TjpebJa0c3ghDEG z(1xal732~c7d=GCg8U<;Z+GU-W;_Vg*)81NIz4CBva_?l6&hNKw3s39^e44ip9t@w zZdz_xXUhS2k%p6ZGUc)OXP#(*$e^FW!TRNtXnUd-{k?Zjfuzwz1H`q~o+xl}SsA0vE)eQ1wQ z1!ydo%Yj~N?~h@w{5qev;~kjOhBNdRGoxPx z-F~ix6*j6TEII3h%)(?nYaL^jxS5q0*HqUY8Tg-P|(>@QsH?OF~1?9N^Q^5mqq z5hQq*hXc(W8ZFEyvvEvl2^9Qb%n#I`g|jV{XXB+rq++TgY>rmJ=OzXoNE>}A!E_E^ zd<3z!?@c~AYfhW+cKU_;;1ez(`G);G)fD4XCYp$s$90&ISA2w^hXr=0hu;%?dIB!; zT}waEgg<2dcBk}=gA*9C+q=7s(goP?o*Dk8Sfo=K(3)cW$(&q$EvRLV!~oBJHmb^X z0P1RGD}8ni98eMQFzV6`IctY#me-IPFlX`X$uqZQ*w%E zq^$F)bIPK0jyTXdJW+qIToIvAfO=Y;)Ar+hr4T`Lb%ytMBi$F&Kn%|wOahragpX3Z zZrm+Jz|inC6%f)t>56!9m8*KXLKE$P{li`y;z>-X<&UhVXxqP|6`j6%z7Sv(V6xvk zF-Yg=nB&N|C`+92+ro#Q7`&^lz1{A~NbHY>stymOVU&T%m69<@LV@EeXjIvv?h;RdXgv0NR?S$U6ICe>D#Z}D#^l?Ot zvm%pzngRoVEa+liq!fK24ztUG9!@#lt%{xt^g2m-fBw`mIq4mWL@S7HQR8Cn7FZfI zAyUmQsR9M;9?3W#d2f{X(B&~t^|zVxg>!q=2}u`2C1B;dr|11T4|y05yN&qMp0CF}c6Sob-`p*kJ(-^Lo=J{w z{tP$b=f5SZ!TSBsaVk5m-YD|iZG^M{VySfg9feJN|0)MH#>!4rQ z$vKa?ZkTaUm#2>2WT(kHj-7tmS&$5`KaJ#gx9i}YE;X`3<9+3*=I4lnv^Z1x%z^Zc z^@WVPM%}uhUcFc^9kOy_e8 zL!=e;_3x55dAZqXH8spQ`@buL7LBkg6dW}aX&#@4xe5(YH7Z|H;vT@|o9>=*`8Ci- zr$~DAR>UKPJgE`fz>OzbnbwttD6{wFLd@6J;Ma#KaKVE&%s;P70%~OFi(zPOb^+JL zPzJ;Zycv4?T|hw%Rq%i`8g zE3m>#Rip&n8vXL+`B=%!N7BbWOFy6LM^Cwy(MhX2NUw%9>nUltd^|!`cEEWb);RpY z&gaIzVNEe@>`ze;ZrD=hSeMyFsCK>&8QP5$i0l3+Ky(CsL~&Gb*b9Ct>dWi%TWv7- z2B2&JzREJon3XVB?B49}<=?uRib?wfe3|Dh0j|Gd?J@H@;qjx?e1$4pjCI9GQUH6- z{HssVfSDkY__x>W8u_{Of`WBVXWBjkf;*7p0P$xlv{OPdZ?nrMel)XhM%H)P&HeN@ zp?4srl>2wJwe4R0+x_Xd$L*?FnaWTNiY3h2K(^$qfx;*$q)S@z^Qewj zLvK>{628`$xo^eftk^!J2Sn^*z7t91pJU2D3%8{wbsvQaPO)WGx)@oOP}G|DA5`RL zV%2!uB3~X$5{#uMq@L7; zrOB-sIGF4ZPBt!AL_oEEfhN!EeoC%u46zY)nrGKKz+cZ^_hzwqQ0nsuJ&5wKw#Pdi zT|a$lZP0cM*`$!vKg+rAZct+U?d(^iq79Y5MkHE#(w=ic%GHV>xmGCvl^h4%(hGW) zrf8(R5jue(1z4@h$Gn+Wmgt{?cE|WvESC>hcb9TACHv7e!bSSc{2Vr8b$i|>Tg?a6 zCX%KIjS<1doo`%%EgwheQLe9tj+H9L9g>j0PwA#D~EZqh-c_)z0nkK{axa&7oT-eFira*>CcS->Nup0-f4-%wK?y5(KBVp(~~{chDrn>=OA8~}AC ziz)5GTf{H8SSupna`!IUA;1@_hLtQDlt(3=M2%%P6yyOdn!SfD5ib)QqgoHl^JZq{ z;{S%!!Eem`+58Yt|9;`4F#HD0jc49Ie~HADrD?)?TnxL@Kj6`I+g+rRg^p5N6&xqG z1$JJi=f=~2$f0L**7+13VB8<*vlNp)UADoeP~<(`wt1i*S&OUzp&ZCZI24|-9x@`P zeHUxCB>NidrxNc-@6!tGykOvEJ1sLhp0VDq>Sj!zInlY7;=mMFqFjLB{xylso4e%^ zeR+kGO8PiKhNtdT6JEt9mVMDXW2^H{TeJ0T43X9SE3MPC*$$s@F zJ%{5A@5VvwC#fd$!TOTs?&!e#w?}D45W6^i2OfoGpb=><;-n_yn6lrYKnH`$5f}J?^Kh2Mn$V)*nQc3swn-!Q* z=>2}vuhDcT{4~)dNAH9zG>3i`(JAk!H`=zT<2iCyDPrmP@pL?ry5doP$qcjg13Xc$ z-$7ofW?rxMcqYZEuMDey`+|vNGJ#t353^!M!QJ21j$gZp(D_P8)1}Q;xm+deL7b1yNs8O--z8njR|!Oe^fc zr(aVjl>Lr4?QCCNAIMo4eD21f;29d0a!qxMM*|6WRL3j!HFRFUu+4B}az;CAE{Ke@^rNF)o`fNdIsV3}XuYYxuD&Ia;Nz+Jt z%$*XG$NBo>M`?K$ZzrL)$Fqw}Rxb^P#+ZLLf5PhN(~+XgxN>d=o_s2J(-}6Go)s6k z27KR4Q__isP>iND{oW~FQ-JWXarbMW5(mIi7iKQ}bl9@mdWyzoJ$R(B_OKgz%_z`+i+6S8>3ij$2(?QlN_}Sj;sGXQrP~F|Hq`z( z@;6jXEiere`Oly)n~1ZLX%2NwOc*Odz9ie!m=!2vbD%}2_*}T>H}or=0&HVze5k&} z&p<<^rlI_Pxo^N%ou`mZoCl8nk=*;$pRj{2d~|fhVFhCHvYri>kCmyUwfK8ns`{q@ za?e~j2&F$&bExZb`?iA*4n=Q34O7yv)NtfYsvB5y%#`QMin5iw!B+AFkEq*X=Q5(3 zE4}{r!GmJC!NNrABghREB(Ef~fZX-bdW%jQ+kiNu3vuQ$qA`Rv{caYg~_IIt^;S^h}ycT!hp?WNv*sGkwYj278WU>CdT79ao=@m zi0&o5%$S~Pq{Goq9iv(%lupt2JER9e6;rVox5y@H%-@5IkO@4!L!bIF|CjTR9eXP2 z37NZmF&j#2-YhAmM}DMZ5do`hn{kPyZpAB~3N+;_H(FRVo9x%=3#1KG!!nfQJxYP& zW(L!V1I#XFB#M;7jQjnH8D-W!;+CX%UR8n|wfY=X-_37!&*i6sh1dEN$BxhL^1u%9 z8C&$EkSI7h3Kf)5DXKk0wVPZsxZk3BvbA=buYZmF)fE}U4l{CCqbR2QMr*YpwFT?Jfb5o?1&^+yddz1I~)y zgM;rTMEHM~=m1T`qIY%&feZdHk~8{4e7RI%yzz-zHYcOj11-XbwCAXrMr^Q_+0=5G z&u;V{l28L`k3Zz{DB2I*nu>y3e0V+|e^cJg>gyfJ(F0THtNmSB4S|xB8mWp}i$Dos zSxR4 z(M&7a&%ah7sp{hdO7A_$cMe0=o=nW*z-8idooX)q&>{rbhl7F4u znOi*|FE&hck=eonvf$kK(|i$m*?rF&I}eu0?n$J$In1Bgr;zm zp=R-UogdWV2hOa|JQ%~sJ(}WhJoGF6T6d0;`}l>*tl8$Y(4=a@2g*V43EsrH zJDTUSAU$~OH_u%tfqy$s*ro>$zu;)9?WfrJXF8f=MkZvf4pZ-~~M+}*s#TB31O7mo$8Cad9ihjUl-A8KByg??o; zJqY^5R{_;jQh214*o>{dT-Ql^_%xJ6GVq$C3}8>g8#|y9PE~7i_5SuNVKcWHwp=Q6 z5&KiWBP^b@K9Ex=vzdBaifAaOxE2gC>aRYV*|3p!~*+{IB?E2b5cBgX}GNmp1DS; zi0ZA!DQOB1<5qh;uuf_lv`Ft6KV8;`Q_cdLlCjEqWzOC#t$_mlOFMP?mJn^;h`{2%W z%n=SeH4W$q`Qtep@EIt_<`~kdG{xkdH7h8IhE-mx7^yj*k7&YRRHb?w{^?Lh;?cxn zpr#k$>(Sg%9a5(aquLMop!=U-gIX^d*K0Ha+pw-9OTe{mLu(4B#rZ z(YmV8hjzZ`BCd3=_LqmV9_w9hbq^e<78t4ax#9d3D~(SvvP66GOY1A?5yIgQv*)&c^ScF0y4s}5-L|GJcfNGm8UphzR#pr9zJbb}(@-2+6WyBmQK!sxEi4Wk=|)acO- zdmsG%UjByd;S=|sd+s^+0UqM;7rtq2`c4SX{6j4+mv`l5D4V|x#j}=D18*IsZzepO zg-`{4G#3T8^9n)&TpEW?0srW_TmyPbDsEJzT|QJjPq1yqnkeC_dkmN?buXR!-4*c$ zyIf7ojY*=Fu6Q_d&aV5HnPkcjRKh25fToQ1OQ#%H$a;8|6`W!o|L51||LFj~KAeF) z-+0{P&?F9hW*v&Bg(%}MJbgzyk!`1vtx$HR&2V%)Wr2FZ5P6DfRslc=E=4_19}1d- zQB!i4c7z^UG6E%+$r^MN>vxhQry9^OD}Y;1j2u#=^$nrrnHDHz1UO_fxZ`DZy{&vH zuuxnjrqm-xmn$Wgp{wNFEoR#);LZUBqtZLzj5KJ=fG*92ue!S0+at)eyQcUv(*o}Xlf z#m^|W`GNW&a-#7JsPo-qLh*VVyBznHl1O;{SCghU#8r89`ku6`&WHSbfPyL}{MfTQ z=6#w}3;)bMm}-r^qU_FXaUC$72vjM3p3_Od0ggpiprRE%T*FanzKlr?@Um=n#`I~4 zZSBh@GF4FV=`VoY5mWULSK&2)}bHuB8;O=WLh0G=N-Fowr?Rig=An7RwkqlrLwpy&=DqMSFg4DZ}DQ|NEj?L%qBH4F{d*}X?@rU5ia zM+P?hn^>+Tb~#b#$#y`cZ}t^FRSDi^*Y07r1j9WybH`gKIbp>ou#cxAB>WClB1g4A zsbd#19`U}%dZ}_xU8m5#>~49)asR=7RNCJ^+W`G%MkZACA16XpW97OnLgEqq>e2vc zClq`3C=J^BRtE{32YQIpXT$SlgmpTLtB82W7j|sDFYs!cw+EKaNXRPZLAo;f&*BO@ zea_n2!wn&B;fM7$D18eqHviYx@k$CITBRNu!$go3L5r&)B)N81#aLU_eSCZR$=`^I z+iQ%n@Dk_5Gz(AyM&Y7M5`HCjNkW8Aa)bi2bYj-5S%V1<1XHU`hYF$`>(gdjnO635 zN$&$;D#ldtN{(@Y4p#+^R%%k(zqw6Ol;~ckEh?6Sx&3RrWloENEoK9;as577HMM8C z>f7l$g;3Ei9U}|V20pjSgD_^(d|Hy|RhhNMuJ#-IW=gSBAa<>aOxBu5Bc{g|GGApA zh9tnY2!@N(r%>O;VVMPg;@wyvwE94QB`s%Ki)?T*dm>`xyK?PNSc{M`>7ra50sR^?h-S zU^1b?GCX&$G^9W_bTi7qS?5Y)$NnDyHr6-rlCkZWL3q^nIL=09_89iQLV(Z z!-SX2#5wgS>iVAHuC%hwn7_k-RO21_wtq7&aJ%`b*>cetPe9}&FSD(P;odvBZ?{mh z)4dbG!`bAx9T!jV^(D>C_nh`ndIwv{UaC2|5 zWNmFbq^0$lqrva0CVTVQS%-mjLvC&Kuh1s63l`b;p`zq>nLcB{WkQmJeSJ^ObR>`> zM}f79FgQ7<_wmA-v5bH<1;jA-o&KwA81d+X*g3fJxZPQ#V9}vdIcweolp6ZQ+>3jb zVM>^QPz0bA%|wJxDZvxIH6s4m2IYwT)c(wavKv5Qgz#M`0G$coPC3X{^)gp&)-Gsh zT_|1L{Oh(%GWOVr@cFDlvSkFVpnaWLdbjW6o#4;*drT2WAY=am^_y=`R{!Hl012kM z=vONqs#P0{J+*BB3?>toX&$B`!hx<^46xk7tw?bh**%A6SSamxvB7XENM^VO` zccK1*!?gW6>_6pS6_*jXhmXiPr#i;eecv4JByJV~Q}R&@ZW@dGt&g~oPFy?~I*rpr zF60z$Eh>lhszQwSHRXJztxjzqChu5owMb4w8IIQMg>^JDz0IfnMMd;$%j^4Al^p^l zUdb64$M0E2+r5J9KbD0v>nM>$HwB69%`7*AfU3MK#qzGHSvQk=ZNt@Kl8Z}orTZr0X5584z2NLbmO8Sr%HLJgb(vc$qbWo)qW z<@1qXSFF;lQ~jDwZ1i%{^uM}}Hk!9nTVmKH{aT>m{B|>8z)m|tTO#oJh^qexD~MO4 zleH(~42|O7G>Oe0QbNY%{N+h|+@k0T&wv}#D)M00y8DdvF4s0QW&#bRU%h;%rABFf z-4>y3v(u#e&rTD>VuU01^iybX_kZ)23dwLEL@V5CH^X}jPR<1cuk$na)TN82Dctr@ zQi4T%e*qIbVThd;4hxiDOv z0{G)MkEV?C=eW7j>Pl4GwUc4}vEsDkSn!StHpWL{T*wMna&S-ait=07r+a=J&0hoS z`^n8q`e!zBxGkE#=S(q+M;(yLP5oROh?lGOn7XUl7f^p;e@CN{PyY>?fKuPI4 zJaYep`Q|T;eCqHpEr+Vy0c!*Rufj3fLVPrk%=zd4&#zwc|6$bx?Jb)eXYP3tm~{#x zcWv^C2!tbxSmUW2oz`{nr{UwLJKc5vDw|j7qD6lua`gAS&r_K*9o?GauU?0&65r>4 z#nw69fmfzAx>KP&TFW5cxxAz2*zjidd$9;W|%QOxXse5Ku8cMXIGJ3M;U(AKl`hKc0X*h-pM?;pn{ALNnmO7i?~A-ssP_s45JZD zNPvjZIzA??iU+O&UnPX4U>3xZ@#TP$gPP&uEc2L>rut(`{kx@?Y7 zfkte#(*T|07VwXYViOpRIfyjI=-l_rjf=22#H8nu+`Q2b&2}-1Re^x$!EROow)E zUjb$@AZ7M=Z2z%WX|-d$wF<+*zr(W`ixyjQg#|PDr;BNLX=H+*ssZTb@n4tMSuOmN z=vKWTp5tME74Wgg#=?>GJ~>I1Vilj<6eT|Dk@QrjDEUWh5-ZaurJ1}mwSc%WJ3R5d z|3V2qS7La^-)y#b5Ap+Vrn2HT&ZkjQ#^-2VO!#bcbUyc26DxAFgyhgiB+bAkdab ztuuN2(v@O?_4a@CP>aoSkZHAi4yA>c(gw==2%G^L^c~@E)t}iP_9>ypNbjFT9`Jba z{_P6awzL|Xf7`^cB`$MI{2{}yxwjn9tjOtzF_EC(c@~`ns3qq@J}!kX7QYAl1@L!k z!E%KZG!otyR|kiHHIz$J&PPwimNRhxW~o7oWY+b&Q*cE&7rAzHbj02j^PjQolk@yH ze9&2)zA3v~FYHZiNsOuxu+n9==-0xXti|837pL@v9{k%5`jI#OBe_+{bL5?kqFQ3_ zs_CVgvLCP$0)iNI|7B!dua;SR%JR(Y;+GCs zvc?PkkpI){>#=uBl$1#)?6?+&^hI5tSNZY}@7AK-&LU|y;ir4ay*JJKhLZnFlxJAG z=z^*knI?O}FaH)hm3quN)P}09$5<78EKnxhv2V-RGh5tYM-}ij_pWU-xe~irex#2( znn}&=%3V#s6$SzlaKi^MTx+;%Vzzi(!&ZVdJEgWqo&#IO%+A3fKJk0y6}ErNLz&zy zcwts@BRj#4_EG0?)rz$NT`Q8wG3Oo35IUZ%N6 z1ZZ~jruiNATDVBJto-1#YWNasyK%R>zR62o5}7d6Cm8@l`LZVtaN*VFp50MdA)(VZ zz`#U&Iq+E9NsYiFKOHTt1TbkpIi#1lfBh)4YMk<_lBU`^jf_%@%#_J2$I#**Cc?!4 zCI+OMQ&+{q%1+L%F1>2R$3Jfuf$&>^s#Q|38M0+RWY(GdbP-f(etYt%uVm_IAE4VM zNnbQ{Xo7_R%dZg!A&Uh>Uas)tUBdZ~jL?7Aqmvj{BLBiV#D6kCI!N;b?Q-+26q%uW zetpW+)n2^ZI;6RtNApdV7sk{NNVBQ@Wv=yW_%xdDSSWILxeXp4l4Cy6z`mxi%ToWr1 zct^b}I;b>mrvZxt6#W4lZ+HI1_!v$jWmdxN{y!It-5n1 z0a{ER1$vyBGZ9a2XCri6hw=7&`&jRGojEw}>3tqHBSk*Kxy_;WVe0_irLzBNOdfQdz5YfLFaDNA&-01W4hk@1NQ>c z24}D?Mw`astesE2ver-GgL>h;1;Ve@4^OM;9B{jZ)Ru*4`aS?Qxmz+5=9`l+d5M9t zq+>}ODBT*0pKs|O+1%Vr)t~lJ1FO6ydq0$5+C(h$zEx=)T2)o`^v+GP_lkVE_WNZK zFZFjmAcSxAKt}4V4BY?zq}s1XWH5q)QH?-|G^jfn9UX;^=%5NO>sN*H6Xd|xBAS?T zmhS)^8=Qk7a$F}7u-=)oA+USKGWQBh5NSc`Q9kMQ2{hU||0Dt<9QQ~~W71i^L2zAZ zP)VPef$ON$)v%n~m(PAk{$7y4!~i3S#`%??*=<|zeF%LtaG_3Nqay5+4s_mnWTG+~ zUw|>%esEMe8nUSWF?l?%ZT0ZkbJe-bdwz(x_q$(nP`LnJcyK4)rrOGr=A9qj5-3%m zQKa{o<#ekfkO*4krfGL82gH8m$+=Wq8*<1K%R>^o_E%h3?HE%GvPf;l3tc$u(N`b* z16`soG5paVlbRl2+5(VmZ2|vD zsz;ESx?)4)1XlR~Lq&rnsxy{O=x{^c7W8U;X#2w{vuUlS%t;x!&n>{{*wMY%0yIL@sghFlD?mPorn zr5&>A7(HMaYPG9#szHYC*mJ;H@>;k(ha>lD>ocCYoS3a#H6xx>s7A5??JTt&4+{G? z|G-fa#@~~hM-5#+-rUYZ;nmS1iA6>^7J zqKRmL?jWwAw2(E_v@$lB|~&k4`_yrvNF&xx;pvh(7@6UO(xXmMS1O z$&kI`?@e&#+6DkLfamo6559fn`ROt(YP;3Rwju{X)&Y}b;3{&rbVYHxKoIAGluqnt zh>M6^u|rNZZ;HHufn+$ze<=-wGGUU9XK5xiSs)`|u-DaoBl3&~eAr(ir6vWZG~AZ2 zNoc{k*duDtVa4p)zO`OF0aB@%Xhh{&?Y82&xR!Mm<9WPAliTM*&|5q-=(y6}7R+^`!bOQYV5s;z9|v!M zC6+?PWKY#S<_ErB^zWcv(em~HL zKgl{F>iP$ewM4!GSqmAbVpmpj_S>=ETYCWe^kdiM%A<72wz}FjQ zRo~%P2KAIKTK-7}Y^SCPd*{AHhF%v3e~acV(C<^=*>L&TNh)+t^y;)NL0tR4VW}f5 z_u*c})K#v=cU@sn@rld;Z4ov~4?s1QzWj2-@vwW5Vtv|Cg-h_19ml>7Hw)8F3y=lw zN`r11f);duU*s3&0IFd=3fzo$AI9MeA&mb*S_307XsST}XJ6;yZ`*nx(sRUCyS$ai zL`4NPb&Fhb0W$(JtJJk9lss=%>3sVcBgJ?CSD{jA7n5xD6k=KfX@{q=(o?sF0IoFt zkOPp^C+1YAo-jDp2T}W;M9WJ;R0?mb!W@N|z!+!n7$Y&3q=j`e$Aj;8&7P-ht;jtD zA|G*XDj3yYuc^OuyR&xeK~{#!tB+CH{&~M0dKZ7HjTJ^vfQWYoxZGQdrRqE-_QS#m zYdr%4P{`Dk9;7kRZ_K@v9Yl-k4aE(eaX)DoOO9AFuC;-8<7g(&R7*1 zuG?vF18P>TBx6}%GYYHEOw%nOhJZ)??zJh+6tzGBumkD|uyV;knQwHlwG|8VRe;Nt z_(Q&w4LHBKREW)TY&P7=QXFW7dcHWiTMm?4GX}c)rGrxAQ;R>Ck@IIxR7L&s_$t9S zr$ED#j*s=^`>c&>Nx``}hp&(Mbkno6)t^8;Q>+lpTYU)b*wD_U3$QLk&&dXE4PY>& zD9hlNYg_3C_!aW{!|h76!;mFsDPT7O=e`fi7Z>Rpa3)I5q!tOb$Vp^EKe4#@*rcwE z>lQ@z{j$b5tF?ll7!wD4fC2l-nUI!Yk)7fmLIQ&1_?vtJ0)oBUVYim!Rq}qs$m54I zWTA-(3FLcO&}3_C&{UD>saUHW_|I%nbxR)+S~;C!sb>?;^nFgwo4P96P|?{z+^^eD zu2dL8(eILhr2f8O-FZ`elK;9m7Vt>AP&3or+2hjW0H)y~ z5I3|ij;F|SIK+HJtzM6Ctgq7&+1uNj8n1$Ujl%}c@VPknQVQ4cf#gUIef!Bf#9pgX z=sYuj6su|ZV3+R}WI2er;h#56XI=Opcjezw=|92EA6z>wELsp}^Zsf(j||m75^@$) zrAX9S`LbfGWO@woD!Xs`#|F|l(%szAG`1X#3z?@PYM=_Ccl@JYYo5;($h72Fvsyw* zgq>#zmY8;yUH-89s2cpu}e zb7hX~GXpOFcX0c5VzGmOO^k=fF!U6(kNtV@D za^Q(dnKi__CiIGsOGao##gVcb+~+*tw7(B=3<&HWCspy8LK8eoXxb|P$9-TfaEa~`B~jX?fKilaSuF_z&ayY~ zG}7P+FvHO+XcjOXYnq*l3$_4!;=0CMTRAYb3*1d@ysqGQ^(*E6G6irFDFbJ4*o>^km+Z| zA1V24nCMNeO@Wc)>AwUw|<{OJ{$a=V!*;3=V*YLT}2N<~Zt}A6D-lqZ? z5La(=d~Q$gNRH8hNj*dH$UPm6-FZ3K-15jyQ~$zf*lnwA?yPjWmfs-YM_NQkD9xVY zUgLIqJmyjnz73aQ^VK|}C+x!sC5F&r^qA#VpCY%^E1ZjiTW?}D`{em4=LG2kZ7iX& z#^7{4)Gu6A^HtMXCJ$96r2J|suavQs;@EkDeD5dhY^p8X`>N9x@7lVtM@sf4)bibKnak{Q4PMS^yc1 z-+YG6mR2HBPRG8`7FGv$ONLTrx7UZ^!@hNbw+(qk^^7^6UOyd{*4GWF)+Lzkh~^Et zc=GX?1_3X#z(b7he)QY|#JG8oIKS@x)ba9G%`zT)Wn~yr%u$l6SCsg0PKM!79L>J{ z$=K25wa3wApkssw+Ol~1y3lY(-?yX4*?ksQU|7!py3uoZBB9Ez91|%)SIuYZTX(VH zH_@2zoZymjcD7?$o0N@knUh(mYu(^YVVPZYztv_K2c(*H>Q~z~QJ``EWQ}0vK8SH| z*CBOE1PLi+d5#^`^QktFnB`Q{yj$pmZaM&XNT@W1P=vb4H4k3|^vJqE6Vg zMZP%~Ml)ha#@o_FUw(q-zQi3?)Y#aFFVf4ac>IXL(~p2Ldp5zOIcnYih#l>qW6c2K z!p$Y$*PRo$g4svsxx+ET8GC&`SL3tyi-77b7SiEyyfJA#SGC2%up-9VxW*kqhvD{~ zA=;{A^jwbR&Y>CbI}0#KD9ec5X^s=c3qI;_7r8CFHmNJINRch;f0q#CThb5D$tO89 zu??W>)!9i6Ieit{vkH~!B(e{PSfx%OtP-Dxq@$`h>5YV{QYsmG(GMbYA$0NQZ@Hq zIV(0cPgtene55W_U6rQCz4ua8Q)A{}Kq{MrdIT%ET~e%LCtry}_wv z-+m(uAfTOVct!i>S`KaX)si0Cic|DspYtvJIaK#4Wdi37E4@!4lGZb~5}b3gZ8R_( zHeu%xj^{zE{2?4a7I&EFeB>-V;GJ&ew>vB<-(P5o^&0`iE%3<&S}}LWA^~=NcVYTP z?hCQ6q<&AGB&zTeXs}w9W?<;c#}RvCP~+<#zQxUJztb=0ilN4%zs-ee(OMfF=M+YM z;%YkAR5dCs{Z$Fu`!TGoKSYE1co~~cuyvv4rxTtzbV)z&&UGjdi3n&&TMwE~C9EN+ zqa=7ucYvSC zv-6X=nPr6qhnY$<$vYhlZ=KYV2Y#jN+oe$_4?DDV1Hvm)N^s5@G8WmVp<@-rBtt*7 z6_bJ?z`dcz#l-->X@y(a)91(@M4CS~vv~j61A=Q9olGXpa*B`UZirralCQ>kS{_a% z=orON_QRWr^pc#xam|-gBFZBZuuR&S=5Oiw*h?{z_)wA%VW5G0?^HdZ=QNP&>x`nf zud?Wg?6RF)%%s5}WL=&`MhfBAo8ZKnq;!%C_@x{lZDeY_JH|L)>5J?%!3wefo!K1!2oX0%pl)s#m7JASLAs!1L7c$LMtD+B^* zPFKgH?x`0`R%o~m*J5`~`ttPljH-#?5b^sd71;I=7fU@X;2TJ*0eX=T3N_}#1qo96 z3u==#8{YhgUnPWH?-+2+iD^=}SwSwJbDKNMeY&g4%QMZS0C<>n`y4rz;dkE{RycxX zR>r}!i7MODTkt&-4_cjt_4o5N%JXGkq|M5FVLPFC=8|(J+{Xq=u}O%Rv3-&kPcS3c zlfA|-^=)fxuCLzajCXuCHISx}ajrJeMhPZ;{=Gv2p0NE(cbSzQu{t3daopY+OqNeJ zs@CIh=19%_B>cVM9|%Oh)^sQ(E%4jV;rvM81G25>(y zu2K2#Z}`+e_YFlwcbd~=+yv7ULxMsLdizNU}Kf9w2#&53tU@g zkWkm8l8gw*#i<81$z{_(OLFBnz-TZz+q5zt;G(sA`fKW?E9ITS-SsAH)If|w6HBD% z8Sy*e^eGa5S5mA4u3bhL^JOOESoY))4ciS=pGO2kAC34_LLP0o6umGu$eLbgM1Hjk z$41W`rr&D-f8%$Gbs#9^9?@G5En1JxulE-ggk_SZKfdK*D68~`BaKFGn_T;+Hkc)D zI?uk$WH4kMTX`O8&a1L`4ZUOI?YAP3r=sxl*F=Bw$ggDAdg}rLhy8`%D?9svh|sE~ z4)T?XZn3m@xE+IcrfUU!Xwlu%FQSkBI*6w_G93G~OH60&%qxk|^cg)K9oo*@eww=zk{{rz!7uhB-QX7Wii~ck#-?e zh9TM%He2V#lw8_c|`bH=|T!!*Zkib?9GKe0Q=n zo!SBT8Ve1+o^IczF>K?ROmnZPbyN}JH>3BBxojR)-5&bq*GK zxs=*?9nP0{iU&E}OADbFmmM@aowq}4)z{g%yAJ<~&EOLHmYyn^Zu$8A?m09{(f2dv zfTr+CnG;3o2jhfCOV9Z`C5K~~l})wXB*%WP>(b)*LG#54$$out_5z0QwYm3mhy4s# z3kd|0v4P(1-h)Cl%S3CQvpfsOwM%DM$4YwcsW&?BIK}A+1%XBOWork$#C=~5fuQJmNC;wSif6l1wZYe zf73kakQN)$x0V%64}#}efYO7mKH8IxzI$Vl{MJELuG|~eC*vGrqP_bOK@NV5*g7QI zH8?WBsJP{9!b2lsSaBl@?&SRo!cT^|i`{*eY2vbvI=coU=tp?!2;a~HnUgGv_4S#W zW;f2CKi~FnoW7^^FT>H*V&zR%sBruJ_`lQ$oCz5cToI)Rm;B0KQ$OjHW$k^L4_Z>& zQg9m@$ZLtBK8oE$#47Y~3o(Ekp}}voA_erCXlhaA`WcIr* z=GaL$b)NxE=^E>YySC5!!IHYt?!Os;Vz!v{?sTF${u+| zFDcAi*V&+VD!XOWt{5b&X1eK)@3R+0qM4mm2MD^<6dR>2k~(tFDAhQ8n0_#TvsO_I z%{k0@+GdB=#*U_g>9?EaqZREgW*y-028-IYE{UwcjSAg+seFr~xjVv!tnkd7Z}WTA z%6zh2^XfR`=+fNy?Fqhgc{*BBL1qXV4wV%0L=|nKR^ay8^;na`?8NLsi{R=sb6})* z@0RS~@u_MB%R{~@0T4dg?PC)?q%f9yieCfzYjnaiyiM9)E#|}-cY`ZWl-Jvl2Vne2 z=P11%E37(!vFo|h!p#Y|`+1<<&g`4{{0B7F?KQ-$s>Sc4F}zN(c+Q+!>z?y2wVt!j z9N155L|f&o6a}6$v`9A=1gqan1pEI>v}*hqZ3u#VZIkbYDx^d{az9HqVVc}A=%;$; zx9V0t?m|7@^y-I*@#}&`p{}w-24S&hlJ?YyjgPS}x71i&%53J%7#YaUTU1@fyxeql z;01AC?_T8t@95HA$d3D(?5=^tp07dt!eonA8GK#$rzPkj90)dCw@)LzFhhyaT1_GR zk$oJ$t2%B*RU=ltSt!FxUS{74IZAS$*;zmqZ!Jr{rff(yo%A;ASS`()C?=D)z~x78 zaM8r_stq2Ol`>JQiqT4vjxHkXTTiOJkj>|(T+o{%JL2ebw!dSQHuE(WsRA~0VkdT) z3)-(R-mG)Oli5<8eShx}R4)aQ-e@z#y!&HXz^nQF+7y=2tgEc7+=x_vfaa?JR-rq` zn{Fi{l~t@8OJVo;sy&s6bNL2fLcI$%%^{4l+pORPfy$57kKD}jEI40gi@x2ncBMv~ zeB-&Cxw}R}-R$hRyy`ATc_XbLz$+nTS-OlHIh~P;I#x>hBg)NwCi(()OE=GCnj|<1 zdsi2NgDOdbJE6@14h4MrLo8a~$8RQ|XteB*WTi4u*o zhJC00ZMlkE`N^F%gN~*4)TMtt0qM<8zMjuFbYnWaB$+G$Lx`|vylQ-u>(Z+_Eq$uC zbwWW~pzFO_FV^@K5xZ3p04_%4)b|qS(1rDf2Z4d`iHA?v@P&Y($!QQ3Sma?6>jn3X5s|i4RBk=uyknrT21ql;bMFmDe}QP zXhOD(%%|STK~^ca`#1Z|uc>Y?v?x`D2j!Pk@6&#!BP1%?7(IlizhyFk$Qf#WLk?x7 z+@q&kL$QV%Z$EfIN9!Tsn#4w#S7_}%=|g+T5>z^=7c{ex!zdLqc~L~tpf=^cr5Lea z&3m_|L&ra+ktj^5=|W6&I(k1dbaNt%86uMH>ooMYFW%)#KSoW*7M^f^B_&ZZTx|O4 zQs>!`j!%frJa#tKa>Rl2^Yf$-3@d&p^8*0V$8nh zqin#Ji_aeok(Ix>Zl4WA(WTBEv+jI`R7`A5g_=L?{rMc4nLZAs2eB_dhi70T=6t zv(Z27E_p^v^AQ!P)`JBm?=Gp9uT#a^*E2QgAJY|Nn6(n(dBIPd$n9D#H{SgEa`P%m zH)9m}CHYQcf>mrgl! ztfpUQm6Ysj^*AhfM!xhkU+D~{!+k$8Jvlk#LfzvNX{v5AP;vC9JUOqg-~3e1_v&Pe zOar3RmDZQl#Wz$r&hkh5St_dw-9R`{7+3rXjDaJVY|3@& zIMGPwPV`0l(-Wi8Lc>hhsPE`g^-1^`RmARux(bvEnHph9>ceNpqR;gkKo+ZCWlqwZuD1oN1P&WF`+T}veMU2Y z>Bo%i0cU(w{EHY^)HW-L`J%dW9w?QHv9hWyIzQsUjt@cZGEtiu^HY48xI&Hr=hG~h zmZoCkM^RqxE}MJdr_s0-yFPFb+81G=x`p87emqexQgQz1#YcYl=uwO|dVTJ18w!f* z15|&Zvy1YMm96t9G?|$NE%z2l z-X?YsWH93wr2{YlHfg4RqETp%Sa~2)1JLt%L8TF(H4%mR31&m^t-uFHg@JV zdN3?W`FS!SLw>YNKTfjh4p$j3!_*O7-c!&Ztzz7!wFN9qe1gkH1czk*Xcs;~37 zAT5A()wZ2LIE|hU1R(WQp^CtPIdd-RWR7NOI)6KATtfX>50IDSi|Q|>kT!DVcmtw5 zT;oEO;Q+Czc-=qFe>$!I%Ntl2f3wKpIqLdgSKk2f`yS#nW=;BohM$f?2`t zu-MN;@<-3>C;mYTv!F9v!KhtglC&KNpj6S)&)hK z9d$Vt4b|h1w{+%^4novVc8Wq(CXD(E!c2;1g{?6pj28h*_+jzZWg&X6UzFIUY_!R+ z&u=D#8)U?xf2*`efxlpgFo4A!L^{pzfhPpf{hYF!3aVXm$^*Ivey`GzgLw1<@h)TH z0WAI_(XHF=n7@PD)Y;ALTr^7op;6DRcmUs4Z_u>5H3YZ`k^?@kk5)s4ctR^Ic882J z!pQI`Pn40#IG^w|0og5eFdfs?Y{tCJe9O}Le*a`}zDVonC+a@3!8iRxQ#i?fwd@1& zR(%=@<9dBW&(O-Mrus|C7%nuyDuqNpo>147sD#Ah3L*20)}kb;8WgPd`ZEayGA$fY z#P*CoANFHzr@AUp_IP1;0BZl27;V!00~O?D@w4BoSjRof<^Go(ik}m!kWj^1@+d4B zcYf)5iPCp6siIiQWTW$zo^NON-!#v#!fG&<#VScLH-7&mgnG5CSTSQF=A5HB~t07y&iU zb|vSilG`5Q1uRXN2|}TC+mp?8mEd$nzoUeD`P3FE++y4Ad{@NDTV%-ZxqY&m*0Iaw z4PqB3k2AIpf;e#`2GaIR(nj_=I7&aIn&(v;A@%0#~4(L;&?uHwu;LEf`;lqWz?q} ziH$wdZl)umrCnOUvrw(BW~Qzt>^@`qv>T(xL1-jb*Gl{oBs--0MczO1g&tQ8*u@|p z0G5Xu&yFBIUOYU11VS_X3vND*F9zjTgOs1Y>RCOcW5}kfzk}-R5D~Z<0vMZBakr7> zS8xGf-R@fmaD(sZSSb?}`N|)<-%!fjAU|EBMs%)OzY&LaZ8t9*>e+-(r3eQUcZDt? zZi9*@egz?zN%78s5z_G3$oQ`x>u)#rmk`p*>*wp+}8zu<_K*(v7XtGB1 z@ePq{d?P$<9(PD1i|xy8gdcoY;Jqe*xJW*!Y}?Q)A)-Nt|7Lp%$>gZ;-4uTWLIjcA z{OwJSJ~Dbr{ryl|nx*UWx}b;T6tb3mXZi~hz*C*N&etSQtak(%Z8=aQqV$fo@+_8; zB5pR)lEn>%V?cslDxxi#ll)sEyTqR=vg1~y>z3Ozr-r=6XyJ4u`graPSD_}_JwHL- zqE%Ch0nbcRHrN?7DdPt4b#`WF_mhR4Oxa0;tI*KAhA&4C^x{oakusfjFGz#Y>-hp~ z90;@L=H?n=l<2lWidKutrZGrOx!Xr*3v_NB+)Ep5IIqC2*c<0^5Er<= zUIOqG9do=*^2sKvdI; zA4y#jzJKxo`7aHJiDKPI3nJ4?XDiqvgMBPM7wZb3iX)yd!nbi70ugZj1?qR|d4cbY2$Y@tYi|*ryQ6d?~XT zHtZzo%_1kXa+Vjc2Q)5bbwzaN^ey_|%KPlJi<0!l&oRxEDLI&?+$RhT>3z+UxNd!JheXwJlWeBs zKjvD`%!K|261afJ2GxeiKI4UCZnNN8w%n-^O`OBD;f*JlX^~V30{RbdZ_g@jCn%a| zDH8<532~7Mva@1KvtuAJUut_x^dO(#eJ7#czf})q&#(df z_IIguM&g%_7&kph&a9m0VYr5Wu|E(jv#lInY|~a@;eljsRGuUD z-VnkV6AWc#1RnzWQDYw!;hB17Mp(qOLiaIk%sFRC4p5Cd`J8?MPo!0?9v?3?ms z`$)9<btQ)>)< zjGSD!{WUeWX!n6d664Dg<9&zR_%PY9WukY(b;1_?MCB(@`2GL_;AH^KT|3x*cp1Cz zA82Sgm_!o!K8Jd8nNH#`5(~wB&2tDH)q!&L5HZAd8ZKM?`l7J6zYh|ha0Phw#cdxA zmDwntvstsmU@~S$tWRZSSVPYN42mj0^}U#pABC$aKFdurGT;0#jrnO+z}Ceb2LK$qZ`2LJP!U z^Ab2fBui_9AJZ`z^q&T8<|LSu#}Pmdyv8abh)p+x^!Pe{{ zAl~T8ytYPD*LXSRrBs_sX zd#+Blxb;+&xp`ZCKlzVp<0Enpxa148+xklIYP!=rC0u#!y~lwrf-#+g<`NE0R!bjq zl0<7jj>()5@Yz2hu0wXn9Q-cn+Phr}Zw}fdl*~>&?pMyJSWmOjb^VKLvs5HDKRdR+ zp-gR?>?J$i*yjg7v%>k}v&X4RgeUrGP`}}T;q7*)74Sx0+G^F(Pa^Q^Tan*DpVcfwxx~qRr=5%@>xluY|Fm@~VZ{44 z1e0ghSds(lqCenL$b%uO9|SV^q7-go{k}jo;1EZek2xUIjbn0zw>eeN1M!qa>!*6XlS9y(=K{ej>&4 zZs{QU_6VgPqtyMGv0bxHW)H2Uoo|SXIGQR>GmO|+ zRVLbS{Q2Ct71&kZAmhpd;7%y+J#n zr-t(H=b_SF3j0peE1F|Mk7mriG2RXQoDPcKZR>p&p)sXH6y*78njXC9kDHWt`9fJB zgNt)qC$r1Y8yT3u*etAK`s>{Ij)|e-(K?CuLFX1>GdVI@!slv5z358b6#F;_$Y}vn zrG}`;s0V4W;OXm8m@F%WxXWKPVt;JXpgMZu=Wwq4Fyvy~-RK&f6zGG(wwLJ`4#&U> z-39s!+DN+KAn&McM1qHDe;i8>wo{e8vu{bk%{_w_v0AoE==JrI}iR`p0dmd`1e`>0CwSH zJbzODx)G-k>NUEQ}qlh~B(ac~8>n>sDQ5IBU>Iq-$&Wo`#NnuW2=7MDAcCAA^s*i<9h>n}zbn zEO?_cGOn=ay&%-}N|zPwWPP}cCOP2Mu(0h@cOr%pk_#-vl4C1vcp+IQ89WpI4h$EdQNj(Un||y%Dorcx_?Q&FNR_R#WB6@>EfYP{1V} z`kjU>g!R-Wyob@m(e}H|cneH_q^%@b&~+zo0K_p1J}qc(s_S9n#ShR zi>w8s;^@h9JszebBVK^BE|ghwdXyTpsWnic6(XS*2Bf~13`@IYr!vl!Cfb>Jf6$0W z@e)i-(m?SlyEFY;k@}9AK_E+Qawi1^Z{WRMXU?r(pc8%Q3@JskX>(yYE3tiRJ1#CR zvZ4_kJSb)lY{!G_Ox8Vwj+G#dPSA-d=XwZ0u_>WTzpP$8yoe+|WUvKLf@*Bvw-J`P zPjcm~=#gfAJP@GPJ5G|vFkFJFQOByVmcjjoetn_dWaGtQe(k>RA0*2}8f=EGOXuiw zfs1uc4NCcH7k<_0I}6KtAF~WwE5_eodMXh%*8Yh&sOu{)LC3PR)S1vqJC1|*r%sR0 zT5lJ*h>#2Q$6<*Eo_*qjuN7l`owXeoxv1As&mq;w!cNHw&3qI1t#ktKc=RENc6deKv==N&xi>|)@VtGdG96WgQEwBrJ zOr-$XOG-+LRZwsEjk2VI!QcO*>AK^g{{Q$nCr8E|LXmMYvogv)&kx*KhDX!GFUypo1;r<(-COr95pKLQ-ko8r8C4+cEMQ!LV6OUQ^ zKOfPo!iKnuWLV>FT}`=}6#{4EGhSvYy)~YZUJfWx8}<6Y1u8?H4@w+{Qa(*)8*qsw zPe7DYAZWKGpUh5e-3woq?&IIsViU=IS-e7)9_&dOpKxA^TRTuG@% z$vrY%Md-saw4PI1BW7jfS7Gw8Pv-U?qWw}su`xv%dRvkbLo?;ecSIOvy0BC&zaK_T zR4#_|J|VveN@|h!H;LimIw

14xrZnd{N_iB(f<%>(z?EcKuf!apBi>a zC=v8oDrF(xBiLBFWg92rTIY5Ip$F=EYW4M&mt%jk1_!X2tv(;_xo$#9g@bJ!mn`n> z@48_0p-Le(^9{dcU|R_#$$OPAH!JTEgfHJBnazPWzcX8(ozg>$D6eu(zgBPMFCVLNM_4xvu*glm$rY

8i*I2(ic>Ousoa|n{-;3tkzw{ z>SP-9xV_uVU_Qu@EBhw5@Un!v9-S1oF3>*C^Z4pr+pO8fHo<73*oCcZ1D()&YtJI5 z{+W6%XroSQDHSaT?)uPrq^R0KZ7c^v3mD0xpb8FCPni;T|Dv;T#O$g8wN34o~(mA^>&t(Lx_@RJ&j3MW=bIle9f{ zS)}X5M|@ms_tI(iaQzxo}cxCJ`7Ey2d_3x@2-PS6`JBSqk`Y{=GV> z0NpF8s;bHy91J-4wI-7!BlXc@0>B89fP%AVsyHapw;29m^U;_^SJQ1L&l9`ijU1!}R?AB4p-xXINrHZD9n z<$(tTqcL30qXx32djFCq;qQhv=Y67>B4(zG0>tYR`(m*!X4is!s92dbi70b|dmMxUW%kt7 zlqCaxd>{8@g?uD7gl*-(hZxtDW9e+v#7LP)GV}zD=f2|U46cl)j}UCXq%K~yTXA$z zqtyWq3<6E9S>5zs3_w2qV3wQ_W}E=PnV58HJu_SDz8jzMHUs708szytwXKfk&x0j! z2DSLMMfONmO*ZP!c@eB!#~>S#OnqlkAiM&`460G{>C&j=+(Th zUECV!;2_?TgG}yT*kgL`(!eJvtkZN@Rj5A~1R1Y47@zXZ3$NynRBoPo^UjW9bAn)7 zpT$4}6F?LxHI`)5cp-VW;L&w(RvnFts?$%8`v^Fy?Q2-)eQ#g7Up2@bb{?4Bae~7R zV!w@fq;8dp;^Z7=S|wEVTQ1lrM-F@!4t;j!%M}YMOAf{r^1%K zQi4H8QTz^s^wP_k@YOIhMQ#xm~(~#c_ft7LHSwSa57Ip8Y93y~Mce z?P72;F8ld)V1nR6Wq{!Kq&4Ea_0z0HBca~&2~Z8b*Mq zTLf7?@DTm!VyeemAu^b6XUUd~`75#KNY(?w_)PUXHw}~T4F!D`+)6SemSbUxyTyiD zvYhED`igcfdhkaY7ik6L%D zY)ALH_1+}ThqTohCPJQanAQe!K@Wjcw@7Oy>bS`MI%=b6e7?y3k*RR|w zx6il)>+N$k{h~>Rws^p9NMb|C1 z3d5IuSvO^`hQ7}V!pZ=JD09*4EjZ-7DtHc}I479aJ zqpxMci5)`njoe>krBAuFe2pe_WL_pj`i<{R-lL>*jx#B2bnCwX>1Bt1@6z6W z>2nLwY_4+9e79)7B}wi6pT@ajA+m`je*2Hn2#0IU^~Y~15TlZLMXH@)b;uFGkZPjupLlFv{q;hRB{K!JoY?17NVj7`v z4Fpn@JXKg_jC>RI+S*tRvqaUu#M|wh-0h-GGU9-s#yH5+v`NExdaGp?KH1Zfifp3y1)6L zaGf~ZztiIx*Hn#;!Pih(eiS<6qm%d@M(*I8rk^D=rZ%A zK5cg^Wj%}ppF2o!>znf~pt|XSO9-0|=A#^X+vQbxX)_ojFspVGv9AkueL&*g7ykT& zvea4R^R+_z3A7TX*TcYSF1)7@_my|h#L)2g9_r&Yz0bFk!%ih0wLS}#>mE>HEV{i}t;q4_b*o-dXJXx73C zE(VaQIBduhEHKe4xFGLxXrJ0v4Ns7C<>MNZGTJhk=Jaqlhnw`(!- zG*{~_wW5saWnq@qTe+*^YkutDVy+vM0 z7x~?u(KzLhX>wUk$gDcduCk@B4T6&!UorDqn%`rlwZa8Enbkxa>{qh) zaQ@Q;j~bttE==e2a-m0;W#3sJ1NpE!M|pjpVO?boEZ}8`$^5UiUDUL24brsj;l)LI zcUNc1%WD-|}VTH|hI)QCQ!7csI>s;!`@9rLx-Nu6r^S<$l9% ziPw47Q`WT5PR94DqjB3?s{1t`c9^cHmRCQB$bBPsSNqrOO9P3##d47^r*FhA>-EDT z-~J1U#i01K6y|TKe0fc+;dlBMNlf|!yg~JuAfReNY?M9W_Wk**IuY$=K3BrZOBckD zfX4yqGWqca?cdrnmub^EK^3DXa19HtoRR>{K6d1zA3 zx)PoZ*IsPUTO}tCGQu>LIv8!7bgCe6nVZqlPS=*kzK=vq-eZBjgyZ{Oy9_w~#J`~{ z7?O;@US�^!N3xOtdpOWbQA47-O1{?>*J0xh_i%`8 z39*qU^<8N;Dz*Qt+B*^g6P_6Ry&bdr2`9hGs$N!Yb3=Y6-e&+z2g~IAxbmSV&u5iC zx9Qy~o%KypOgS3qP(wV|4Q?nPRoc>$Kgb{`yK(hxBZF9(01Km}>`By?Wmc4)@B3xV zUt#Z*OdTe0($7)K60lB!c}W7(r?Q?z-|KP)|1JhxT93!8N zp7nX@U7wPSY8WDGGkuG1{qu3Jz~8goDKm<%`^YP;P%&MA5LzcSjO+UqSWK3ymhfMo zei?vgH6QZJ*X5+{f(p`sqnQUwZ6QFw#4C*cuzlCcV}6MrTXawEVAOg0^r0(Nu#1Vo z73Uc!gCkbvKN6dN&L?B?8>>=u}ve~J&doVinScosGnnlmG;ytBYE)ATkKuoWJ zx&KZ)EP%U1zsKJ5(1V{au#&*k*@~C<_{b7t6pOtMgee*Ih5K$#ZM5Qq%a?6p=^sDq z1ZgdeJFcDWSo1O)Vlt$Q)o{kQ_Qn29hxq{N?*$L}uHK5ltKX|80+qcSrPhowRm)Tu zy5`35YhBKb3fs*w+2+mG@K7Z!cv&oDVlbZLy466ea<=rblRGRK1t*IPd|$kdAfg;b zY+qmb^lIlJ)&8eccBd#cKhNY90m6d*h#sgIMFO|y* z@So$eusNx?gg9~%oeZ0ooci-lwdQ7ZTNpd>)F^t!Gd=|WE zKgKw$@MX=I$LCd6c?ei;&7x516*6ScZW22#XC2+q>zxu0^!v+DWvs9onsb7I5g(jwJH*PvprSDvv(ZnzudGfm4bo%czLN;-(&jEGhm1Ebe zO5CsQGTJcVj$B_iIq{u3Jp}zD7?gn1Ln77%U;%Md{i=Y^5naYTko8|( zie8>YeerSBGP6Qk(#u2$!Q6FKNS+8Q{4N(Dz{L6XpA=mAs)E3+4HDbBp+fGz<4$nD zpdicrSKxj#EO6Lht&O-yU=*0CTwnOl7kMOKccVO94!2U0&n*{yDf|E_vS3dsw6u7r zYr_F<%z5^=C`0l-Y^mvG)ru{|kq=_GYG<7zV?3&KW5Jxic#cfS^Qy-D{&jB|F;0yDik7igf6(rz|#5WI&Gub&$8rfSWvtY zOAbu{|DUG2H)CNfT6XUdVg>0!)|P^>M4cvrz`+J@Wt(C>a`!kR0LBIVVR^0<`FfJF z_D{5m!KMEc$rT1Awp&ok4j4;|592G9CV(h!Ga~0L9`;=KpY7B01C%estRHr_6LgPo z-anGM|IAOV+3Jo)DYSWGoxa>nO+)?h?sc;#pW$-3EU;E>VHsAo!}yEAT0A8GAcDto zpeG?mqr#+_8Ws$Po3O6QA?WKtlTh1-k)D?Ln)q;EezCtoqt-DG0i&Nge7lH zdctAUARv$GH%$gCXgg3=hCAJtvS~XoCR+Pny*gJ4egNKFBfAN|cX%TjQw(`WL6rrf z>rTJ$sr{0-9lf`&Kwd-ov$CQjkL)G7g{jT+he1>23~RHs)D?`FkDJS}R!2wIW18UR z16dZ&H(^*4xzC5O3%mfwz1~R-6;eI7X0RX~)N?+a!IbrsB{lANCPRA?lN;5Gx=L(t z7_y6QHdWwb6Af1^yahc?F{*mw#z4n+ zyEK1kCh3wcJ(S#DgHN_>sHmZ$vf!b!2i=9NAu1RTG$?RzluDC1EqNI&VE^OAhp#`~ zEgj&Ra4*q94ooSqb|H79D?Qtl^f95VcSdgp3~c=5VN*9xJ4?`3LZ`T^&H!R61YD`d zb5F28!194iC6(PJhI0!Ck{sqBJ4+)xUO|UO508s^9oniF&2cnP!*a(M=A5PQi|thH zk#-#k{_i>~-?VK(DvxzOJq%C{$S^ojh}6rf#zga^$U2i%AYR!OL>H%`?uL{|0Ym7A zb1wnJK@NvGo3(n%m=>9Q+-e9MiiG$OEs+y!7*7rOJBWU>U?2NY_Q8n&GOemIvuv|c zTlB(?+VISSp`k5rE~7s73Pvll$Gm!fv^HlRQN-p;< z{O5w$*R+m;Nm!HGJJJ@DcNVDM|F*;rPLmq01W3tGZQ9MwzlVn+C{TB-HlRdg(rrM! zA|?Yl>o<)l2JH}WC!OX360aZ#VWN1GrmfH;G=re2`ls|Tu8{xhLYu-5(~ z0^$Xyrc?R_U4b_0v*XUf36*Kd;k)-(oRG0wX^YtTdfeLbW&NFhf8qiAbGtv$@b!~V z<^l`n;JxW5Ru=Bo3%#CxhJ)o{gq@n14+f8Zb~1ard@3fnTnbb<`Y9~fy5+%`;-71A zn}1pI|NWU5{8}QawKmONCJ9LXMONhEqe_!X{Ek zhv)xTrYMxaOI;gLw3vE*xjLr9;)D+dFWHX5}6$;ta@ zG5Qo{^A))>gBE0iVX39Nz0|JGVwM5Rzq_Cw+4FB-_@QIH)z|)ZFZV|5@}G-~okfs7 z!lcAfaSZN1GrPO^cC6yP%i78k$@Y^n7XQ{g;b(&*gjWvAgi*B6m_`&KLH^ z7Z!|60a1NY?0mr8%&6-D)1T%4X&-rzoipxGN9TU}iCNr#&gT%(wJ*h$GOi|0;&1lm z*{r}!@a33f01y9ExmMBalo^6>^5}Hh(BMcosldIOUsX)GvqKIBUiB;f>MgK>f2?g08UO z7isY-ug07*|BmgkD{RVb(EM{=^px;tBv-`yu4Gj5<2rw2>RnD^x#IxCs1MuEy7!A1G4xM|n_0-U>i&_@x!a^<5(KGxX~bA;8y z;is$@&o(bCM7ELZe~s( zEVX{gKFfShwSB;iG<637*AK6)D>U}K|CSCK2ypKjzvTokkssd7Vr=Kzbw8!2&3>0R zIs04#5U_VdL4ih#XMxh)s426;|6aI@1>wp?yEGr)V&r`uYnlQUtiM0J#pFbo7pMHU z?`1TIK51Y$m$x6J)dqq%M~Qy(jPB&|_VWb=1!BJ6{rZPzG8O>CP?RwVgp*MAn(NX{ z$N>q`4br@gO&u}_V1Q)WNq;sg*9BehR?nwL>BF4d0ZDjO{(W@k0<+@h9Os9fPMScM z0=Rz4ywx=Tq0FXwX2!L{p72GF zxL&y=g^6HLL^9${wjl>9HrW;mso#~p9c4}w_02{rGlO4$tbG49yV7oi`?usVdj__fHo;-3)s)NeChK%xMV1UIcAj!iOxnswbBqv8X)F?us9`WxsNn;e8bJkm>QSuL`;mVpxs;tayPU3yWKaW;m6!u7PKP=sz0? z1Ljs~T+Xi%fipKVut5B?fAmms&_dp&P4h^}?n>Br{1&r1focRo^WY> zikhiH)vxF^7$I@|Edo?&ZE5N8b+?$}0!WbojH~v<$f`as^Ad5$(lNzWU3f;+4P;l7JvFrW*cAf1Xw12I;YB*od^mnNpCQ%s+d zLX6;$gj#Eq#Mg@Vg{nVdL`1_7TO@e9Rel-qg|~88^B?r-9+&@-rhX~0q%x^fjDC%& z{_wAw;D$nc^Z9Zdzsn^?FV{=+&PAf#=6vx=j6rsC*Bc{K*X5LaB_dbv9K_|#zW7Q2 zl=AtnJ7iGv;8{wt;7)wDl{I;($nzz}R_s6_QC) z+mwNA1nqNEW7y*~VM`|Z2n?PQ;=Z$S_-y28&+g=UK_d}F?~iDw)0Hrrr8^xQ`;V2I zT?S@V@Y4DH%UNq9#Xk9y4~B<_e?OYodxRAuMkXzYG1yHQ-&a4vI!|!@ro^z!D3llp zi3(Bvx1r|D1O)2fTsJok1lP|xFL zQ>0aHzvTBaZw*Lf9B>-V-C|yF_!=%X>l_Xfr@cUuAL;(&uR3bN5i9@bW!QUaUE4ZuB+_<=uuXby?%09aidP8 zy#y38VqLs1Fwp3vCrulraUt+W>{UtQb2wEVaz{0b1hPp8$qtEFfu97pNWdTup6HLb zgnrPL&9Zv<@FAc;+xg6e(i!vT%B(k?;(hjacQb>qpYChI0#%k9JF7-I=?0RAE=$9F zsW>t>D}Y?`Z|SV)|1(OauMk_eZs$RTb+Bsab7|dW28wvTF~zXrq<#v_T@wZ-5{Mvk;XZbBid+_CSM;66<_SzAAS*8Pf*ARQhse4y69dKq_F z_{ke9k*`RD3rN4wiuZkVKlW;i0QXxTv#Spg8(@$s>^WdS;XMHU&V8)?m=H9Rl~(F1 z@i!kJK*hq>{f+h!VE2V!OCW(Bgt9|xOY9h2KagnS{#l+w{`ab=#!drheT5_YAb})x zcIKS0?uy0O`Y$CF1eAZCFSv~rS7qO`XrprZ&lxF^1m(JvBSiB>NCt|}?c2RT+2>d% z#=iddTpmWBm0CCVGLR7b?xlOw`20u?TgJ5XxZ^Gl`!|TB z%vmkv?~a-d$r9!-+~tJQ96#8c$7F-jYur>HdDaTsx0U`oIo8g;H~3>o%F)Qj}#El zYPNQ@Q{1O)`QSffv|bI!%%ddCvNy9%56tfXy(vNpC4c;iMH5a>BCXR?sQbx@Ow+IB zRq}Qp1rQDWEusgEeOb)sMkNZgV6| zxcrs$JKE(2LkjS5%<-C-9MBP*?CajKu-(KmF9kWs9XV=oeAuhDDW(~o(%RgV2?-1! zXs#bvB~5_t^9~r4Zk^uL*fB+|l46E;{NB%gzm2(xVoGhq%R$7t>N$xZONDI3o9So# z3ZM0I<-YMMTaU#uX234{jja`PJQ0O>k|F`N<$CIJPONsk1Or_b7UR`ZS8Wm^PKs*m zCr0jDeGNip`mDTz!2WoNrLa+I5OCbSbS`>W5RX!GirCIHbLed8d>zf;xq5Tmg0{Fm zVr&tB1=Jx^_Ws#LNjRt&xG(A)#69XO*kUGRrNNv3=(e#FL9iTb{&eMU(LN;LDInA2 zR)#eJcWBDTQ?TghDh_en-Q|DDTCAz8nFByN{9*tTaJkR0GOPgwBS%NRf?NfSBoN*@ z|Co^@f)a*EmecBy^sD5caoqq8>25$1WAL%GKS7w7c+eSv{jCcT6qbGAa_uMpv5m&; zK5Y}^UjuEZ^|waYuvYh)H~gRZcuIl3QAnF0e#Nghesw)Co?E>_D_hEo2*tGES4#wu zDXwZvIbq+Mc-l1OG7Mrt;pN_?bU!x*%f3vIyvUBCMXO{S@ z5dR$aJF@}k7x(==)omNNCZqtqZ;m>;J3C(Eu`zil3T7JIdTQJQsKBjji$1@$H|cyTO9Bg_&9?4c1=dM8&u-D^HD}um=XV?oiWDGBC)#&%Qkv58_gQ-dZ(* zKu#BiPwfpN@w=uuti(}t$n7b>;a@SmS}=48vSq(ndHi97nR2$f_lkq749cH7Ud2~> zCiO{grWXs!0SqnJiNI#To2!2xfZ-it8VawUb&Oqv&^ZnTl*Mw!{Vd7f{Y!4JmKp$D zW|kTKh3g7K7dFPCv7;IpH-EprS9ISgL+2el$aJH7*T7Uce%6~6uRt;O&Pu-h?!S-* z8PxnT-8NJTt>h&1%J%%(I|$gRr8k!`KMAWPoG6NdBdDp*w+mFXfen(myhtjjr_Kc> zm_t{Du;aqFm=%3vUcCc3%w#wMSD~Xs8T4VNqYkpQ02w>__>cG9ME@`9tZ)mtt^O=; z`!IQlU^cu_3JnoN_I}Rkp*ws8-d@>G>!%cZvc=U~-dvE+3)@;K)ODKm^mYmku2F(! zwH5e&K4Cx3$gOh3`xYKFFy}8dZB7L=jU2TdcDzbFVuLVl&K=(Xf$m%jU-^Ug)4-4H zuuUs>Bb~&N#bB~R1aPQ+&PO4AE{++a9g4{o+eXe20ME#RNb>BS^-hdRIUk>V1A9M( z-XE9hui&j7tg)?lM1KnM0^`|MO_<$&j*X2?wi_d{?%N?^#C8*bX`j&pu7W)_)P1bu zs9x>^?14STXnbm_$A(1b9gJWG$?KcSfyCVt3Nm|r?lmt319*06pXn^C!&;k#{g)~b zp%B;12O`auNLoyS5=7J!JYxqpVLQn33Bl+!0H?HBpN5TvOrBL27A^&qeE|8gxeGh| zwEtFVYrvE0=|Z62 z4^q@oCSdOCs!sKak2UlqpACGGGz2Ippw^a&J&>AkLwy{n;N|d}0+eD!^)2rJxZnM2Aj`AZ26_CeRtLRcu(ZLC&!^7)uuLN5#MCX!FC!<{TQp_>g8wsZaiP z`pG%drp@0Ib(UVSZwqU0u3!(rMbnB7!DufTZeu;Y8i2r_?ri{q zLbi^TAwiv6EY2iT<(klsGi6|#?+L9Yf=qxzH@7xgYFQX)CswxFG7NFVETgW|PL`Q> z#v1DHHDU3uR=HRai5~!&Fjk6ny(E1={Az!^m$LEpR9kS4P(L&-hcIrJ2J4~ za2qBPDU;sfui^VDHS3$ggeUId_ZF1KIaahljMzZ|)dv}l#8GZs2|zFeykdf#|wk28fj@IG$A+&CH9%rm1tJiFicmtd_fG?^Az5 zYmFMXNCawgtG;c5HftL%m7?a`>(?u~32jH-uaI1MmH3ea!cXBlqJVMnHIu>kqu*5d zKdmP4S|wsUY^({8<_bldcaVYkS))GjhZzILt2nbSUm=w)kljo$OT|$Yb_ym35L5SG z+1%taShM>I)6Xa>Dw6DSVyuqqE(T+ti57pGfQf6KH<9J}tzX2~&3OB6U!!Vburt#b zlnTa*Sr8~2sgn-PU@$Wijef_JQTlx$e>q3h;$%H_X&wm6Z>2CfSfAqpK{ujg1w|i7 zkm|zmHzWsz1kZOyHAGgBlcNTU1)sbyuKkq#V%_HWwWSyNGNNXnIQ9gA2yT)n1ipBF zN#h_6p9+#@+?6Yv9zRJO-rEJEmwQkG1DBej#anUhA4KrRkS!rpBO0_xXa^1hqL|g6 z(?6@z1ywQvv{B`ZlFCUx4{?08_iR=a^|1xeC}C(Y+eoTu zW<$Q%&4<7}xj+@vm}0Qx#tV8jfINzRK%c`vFkA6`>4YK+tUnfuUmw0L9=p>EsI9$( zX+q{5(c@MkAEA(GY0gkXY_0sdP8`NzTfGq<0S?cJ;oY5sHQaybCyeFb@HO5ZW{ zNcKHj7C$sY1Cx)% z(xFhwb6P}!OORYJG`;?enb2}{(Krt96cF2_kOLS*ox*6r?Lekjw9x;#P7nac@{tjE z(oEhPx6ji&Ql;hq2TuZxb7u=`Qqh43T)q^6#i|TlT@D55b2wh;5q}RU zbOA}gdQjv%0t`;;2a?l%W|28`SQ)nCkk2ca;d;g_%6gNQEiV-iB&(1dn%0riCG#}?3M;dm@UyN;! z&XNC(M4cijXg1m>0^55nukavF<(e}OvV5l*KTR%mKjc&clT*PPb^It8{f6fItEvrp zJF>Yoa9%wzxcpPEYgA(%fHWa+X*^cPrk?qBj%tDX*cnlJPz0@lIb9n&cI&Qayldq% z=Ur*pmtE_!)Z4(@ZKfPYVDWE=iQgrNuMndD^qu_#Ip7kgP*j=JmHNVAlq121FG6Pp zm>2)6!J3l?m6?~Tn8#LKPTu|pPk6(i?-JIdd*8NV4C;0Td%!O^ac@x<0&5=g4}08#lmx#Uf3^n2Pk~* z18Jvnn9behWJhB!jt+g2mrM`}(hq&ylwwrbS!}hR)ND@*O;16jO5Y}!OxWxY)Hj9< zI=#rl;CStb3Q{{$l#&U$vHXkf7q8w^b^0umFrkhMI8S{gl?Fw$P{niZk_@O%=}giIezSgeEsCz*#srJcxdD%&IkJVZ?)TTcK9q~wENvUANN`V?@`nqDS)Po}Kx zQf(Gb{5{vI0w&PfvY>o1V=cXxMfhB9P zm;JHlOb~V_YU(sLvtU4%ALfa+o^WUAGpUvkDy(n^`ot>RMND!ExMM)U=kRW%Y+qQRLi;?eC2qHxQiPHl0 z#uh*<-uPzuE+ylq5K4jwx%P?6Ew)w*fmAjv9WOWUoGJxi39SPdsdYFX(9v=L`L2M` zNVYgZH>0)&C%YAjNgE*T@RUZnw%z#&d4ED0uU#b0~jWTYv8eI-KgffRP}1s?M0T zsq`Ea1!aZOj52zb0S2R$Cgt^qZcvqwnIOqs;|+!xT^uQSc>DwjQB2gC?3f@h1+2%)sQBtz8apB=vlpiXV8&Ss zA23p!*n=C)%%EcbZSkjIY8Dvnp@G?doVFi>tqsNEb}y>a9BZN`*Fo*R>Q*5c{d>wf znLqGnzW`-B)x)Ovu%2DwsLxtFR4I3aK!Lq5dS~cYuTfeD0<1c)`>^{fH z>@p(xjW}GUO5ABqgD^otKF>bh=ba@7K`@jm`BnWp;$SO8YBqM3w1r4cTU#4#5oKHx zwRW#=Blx2CR0)FvS5$rQ{8zWo*|6Z-lyYn;FIFUmsh?vA2!p=4jvlV^twvk&Obr^k zX$hQqGcgHG74~}dZQk{8%Q~$OY|ces3ynthsl~4BcU*#;}#+xpd!z-3vhB9^5MZnTTuL z+_cvpaji3&=6+_1)H^*T=&n!#cPa$|uO^P<(^HjZDZshDNF1YO{Vb=Tpm6%*lb5h^ zLZ$HM_4qH3`Kjb_oK3lj5*<6A(Cp%k8{O6R?!5;u`)?`t=Fq)rx9s=pMJm>zwc#!L z$n4K{*kv7eO_n^Z3zwn((`1Df-N|E7bOPX7+GM`{Wdh-}Zxyn$O-a~fOldjwXP*>a z{Xb)%+e@=koqEh}Zy8)`LB{&|wko$Wd`^{nOeuClW*QU@JHN7g3r{#crQ~LpyfC{g z58Vc3`-6JNcvC8PAO!AugP`H%YYno`X_y?_kDjZ7YQ@o=ytaj$haPtEeK~ESD9QVjeUn-nzy6XGa=$8Q^%9KaSiVok=>Ghcs&iAEi zmO8LyC!N z6S~L72lPnt6@q7o003RwgO}gq{`;K8?L-da%82}JafS8SLGs#1i2)hyW7H%3S1#e8 zjbjSbIKo$t1{xlVL>Z`JicrVjwm0FbqKxlNW)oFGSB}q3WR@aE3(iROW2{Z8R;rbD zWMr|&-#mLe2!U7TW`5U7x*zNjpZEnFj?0OJhh1tM|4qQ6g^uYl1ar*4AD@{fxL zE)?^=SrFsoDQGm7<0>8Dvt&GQ0@s&WORf#Y#l}j2s~kvC60d^}r;PYh`ZCkgKfe7c z-U^Uj-fnNKj?L)z@88i3ylUSAxvj=2pdBZu=+uZ&A=}Q>W$J&6LBr|wO*@ zWbY>62{F4is4MqXAO7^3w)J+}1H$l;#}5A3xN;#!Nh0!WXF+>~t6R!R2uAHwd!~omGSC?uz#&yLk%A$}D^R zEMN|I8<`;X({jFI$K7+4)_~1J(MY*WYie89i%=E_^hBxIlVUE~S$|UDqf2Q1c)_TW z?cIJAu>-fI@fIG$vL4vhV>b)BC&oanmncs1z1+nrU10MqF;dQwP{xTXEtEk`E_CYX z*hI}jJveLY(Vy%k`;B(-Cqiiogh4s^-`xywl()HOMk4BX4Xf??&PG>S=o5nrPJV-f zo&5V7%bm?kv0*%jlY9I3i7&Fc^Ba7?{yx%cSjvAG04~iK1e5LDil-Cb{u~}*7H;PS z>-ZQ0dHM}DBh3kCB~^X97OXC3dodLH^v}XF650{+g4Xg5x=wk7;z=;r%Vv4%HwYvJ zXL+bGjX6%`2U^l|1$X7i-1Lm%+67%%Qv@7Hl;yqi(h~e6Uv%+1+F&8PazZ&*=YtFk zzqhT_$MXFqRQu{t4n69Wx*)O1ej;$09_AewNPFNWA^b3fL&fDL>C0kbS_DV1Y#h}a z#9^^ztNgY_kjtu@%J%q4R8dyz0aI(dUl)Gh#P-5PxwFG!2&eC3eR&%T-AqnOOQ?30 z$$$Q$$tRgCIj~t4DVWW!&{-z?iA4Cr1q)7U@?1u)H>q|rXPR|OEh6F?hJ|UeYs$T$ zIj*Pr*?s1z-Kzw99iT)fjoIa5{VWMCwfVTo5kV3pO9;#BiXQW}IBJ1I0|*iQG~kyX zLANzdc&?UNeM-(hmhP*6KPTrXKS5$uC`fBj>n{YuSF?3OfL^eCzXfC2@|e+4vTbFb zsD0e(OPse?|Mbul2`3{Xfa3@&hf=K)V7UPzBou{z*@HYC*|aJwVg3zcwDd8|Gk#uP zW;*9zBSA1YaXGuMcn3oX{$E9c=~Y~J^w9i0^5~-GLSOLdFU0ZMwUMAFN7*gy zTOJUJFkpQkK{BkSVpqb2jNHrM!?RN5j=_Oc#Q@!Q_B@OxsSO#43cnDNoiUSweNjQ9vW$=Rv*&XNU|d1)|~ zsy*WM^ZpC+vzvdrDfdFo&iygTGW?tAwUW}V)0cRQ<8pHtFoY-@7M*WDL%Z<&b>2WE zU*wy~&dsA7I2v^R{duBdlHM0G`*O>k={(0D1&7v1h+jl?hEYF5#P(m0+N*^6UmYVm z7z$2w{&1-~dggAiYkr^oSoXDOS!R~+{NPI_6lqV+R8=;B3QH_fosV%cg!y09AS{24 z7Eu32diK)5ifENb`zTS}?I#8wl!j6L_(s<5KeI2Oh4OyKl+nK^2Yqt2k}Ho4iK`Vm zJL(YF6_hESLKYUFux#MKShl3Dx<2`EZMi!-S3=ab_{-?AKSI3ejjXf!$J0LHAqA?rc&CQhf5l0&0b+)}_fv{bT zST;&Ac>?ZaLqoExkNxY4g-%1IP7<95T;*NJ6ZiI`6p44Q(hHJ~N^cYyxZN}isW=`R z9#Ff_$eEq(obA;&`gC|d*mk;j#ImY9JS@z8?dhGtq?R>xe z!IW>zv~xmXfB$>2Xs3IlNoiT%F&2a_8aksUMK1HU%4prHuMHhfzrR+u|8-d+yC;vE z(2P@VRx22Fw0s}zPQ9CjDcyOPz!^jeZ8B2}S-%@WG|f4JWVjI2Bq?z1foLskZzkZh zVgHADT$^;CVdpO*;uP4E=@=MU5L%?K;(fovSl5b@@vxnZ(6Fa~2D195R&Jh)Tow6( z_o{6L_b?+h&)?H<>2m#-NAj!$ zS#`H1A6G9l_R|LC+!_N^q?-}mcWP;YGNyByPV6mVm+xVAS-F2rq;HZ~2Fw0|&99KK zZr$n>+u-Uq5)iux8&}G`Zd<67A?&SCc{M@nT4>X>>tff9ELQXHS;S=ht2iq{CTM_U ziRms0R0HvbmYk`N>s9?t;nNRCQ?Hvwd+ZeM30>^rG-GGA;+(&m6__iX_T04dZ{Mhh zllZbmF~;+Q!Pg?gXMbOn2Z8v*V6D_l*&$HSIoTw6*C*K_71h(4ts7+&H{ zh@{y>vDV#t)G#fvw39@|^C6vQ%JEH+7x}lrTnkp+C?lo&M8aluB{U~?CPl$EY*O!% zI_76oil2B|S=?9^uL&YE=d-}P=}f+f>8W{Ksm&jp74rlg!23L-$;Hc|*!R|G+v|++ z)B?n=A73&NyK8TH>0_g<3`hH-oPGzhfj4}M`$knu>GxG7L~OL0s&C~BOlYgsnbbWp z28Z8;1eV_ORkrf*V$rcA@D|04&?7&bT^UCxVU(sD=e=s^_ z_w}%^+mq{K`h4?_HO#t{ueaWN4yp7R{{7^2)2%2g0b|f(e8P1v(q_J{%v^4nK9_Pw z_+_cyj)X{_k^G$4BbG;Z0}}5y>Wq(m3^#le%_(~G3w1u{w z3j9M)%e{~6!xslPORGu5#`nSaV zR*kTt-^{+aj}z_8#hy}n*TBWGxo^`Pf)Wzmp1_l{r?+2(PAx_{WN1rd$;c$B_SBXf zA3IbQ>#av*8Y^h$VEHLGW>TtG?=a=~Oc41`{`CIkZ1_M@obNVI(owX|Y8plagP~L7 zHYqQ={};a;){JH^Q0ElS@9)7Q@I@L;T z#eT2C+K-4cG&1j=(egW;dRNf8*hqA-`i5S3?vEGt+XH-jy!X^J&9(3D`Yd*fJsPL= zcs;PmUBGYEKE}d9b2BD?Sfx+(ZQod`_n}oAU$?#rnvBYsAzUZSa zUmz)V$>w@E-njn#a5QHzeShgvHESDGS-!+!Z(px<@7fB^+h2ZER&5{m%x-zbVRz@w z-R#uRD{!2~doI^Nj@-G#MwBTjP9B?5UvgaFke&;m4Me{lTZRmKfiD{;!!iehPfKz( z^?_5uT4?vXW4jOb8EoAFwAiEWF^PhqeczdYiJ_sPnU8(r(-m9^Uwrl8+eWC5%Bpo* zFGegY$3lE(a?CjQ-pnw(N{r*o(|NIwTZ(5lm659XI5ypsC|K#h@!d)ZlHJWhaxtEZ zUP;t-M`AC~{!v88tF_{r!kb<~Vb83e=zn*x5N@O(4)*SG_|nh9Eol&gTBDWxsG_ow zY%qO$=;qVI9UZpeeP8SUG4&QuQGd_-xO53DA<`X!lu9?a0xklwpaN3TO1I?FEK;I$ z3ofCAz?)8`L^`BPknZl?-vvM4^Z%d2IUW~wd2#QZxiil^^USDKxhZGtK-LU7*F=DV zIE65iw*F=DR<5T&oPe8@Nl$L&D7)YL+=CNq@;lurI&9u>^)P>Zm*Rb+F9;ha*IOj5 zqq~^YTj4h2!N(Z&tlq=dgnD;T7)n>M-(pp+q&%CB{cjRdLTR!!86KWn`@Z^w^ItDS z_CPMcRm%6Xg&sq8a{ax2JGlY%@-n+~SN8eAzCR%S1`_}s)~;7_B{}_=-1V`r`!0J3Eu%jGM7FiCTWefZZgTh$3AH>Y>U@ zZeLV2-3KPY96}GA9{xp?#C;eto4*l|g8ScX261R*VoLQ{qoM(SOrC*#R{IX)y&Cx0 zU#T38I<2^3>HB3cN&Lp>rGrekhjI)W~Ta`Hxrhua7T}WBr&g z2&yhH_@sQ_*nPK;eN^2ttiM8^5ILB>O3-KfH8s(V_|~Bhr~bPSFvpKI&!j0I`_6p9 zAuLhT(XO<7oHEVq71BTJ8~%GQy13~%k{@L<(urEIDH~Z)w!y~BqqdiEGob0KPykw7aA#uSjJ+?$@4#r@a|W=NM$%J1*-bWa zX7f-DSn@8ubB|2xG&kZ5KCvA3&?DTX9d#S6GUGoOH^%J_TYg@@aUKEl=xwK-RsYiv z2(i&%r8fEU*=}^RRtvh_`)Gyi>zm)7%uF@{QxSUOuOI<*Uy%wz#a)5G{mWp8QdLqZH1_P5ISt~Zmq1mg;!A`C9GvZt1xv-CQT#C?jDz0qFN8pRJ) ziP{eQex^mB3(#papaVCBKoDdZT0+~{-NJ0jSq!6h`fW2H)?!WJPh=nT+cl0vkywGC zEqo5y%G>W$2AbKxkg0AbS*JmuNrKCyB<;S_iCo4TrhrOpf- z4me+_ebusgJl3!7+luG+Adov;ecC?dt}WIzh-J+J{C-iXosz4qS2LJ1mMVtJL&g{Y z)7T<4rzi2ONO|_|Jb(Viy>*?QKAp#s31n03;`d&0;B=pAS@IHIxH)gUU}F8)d65X2 zHzT)q%5RbBn>65|6j_G^*c;?1lzYC(8o!X4V2~C73pUHfNJ?66+V(E2ySv*K4ii|U z3W1b386IbcO404KD@$ez3*T9tt+b;$$-!$95vHH1#POqek?P0&u|}WJ$@w7X_^)Z{ zPxgD!xI|->J+TKhtRcU)KgVs*jU;e@X#2FW&urJ@T}hmmgkS%Ecy7jSZ$766HD@;e za(B)Vz;Zc9MSP*)+$}9K=Dc zCdqopwh9h2E}Ev8GmZEvn_?AKV?C;)^L|chz~Cn1@?XktRSbST|D6T*Q>BY&n;Qfv zAWgkV8vw&b44SGpv2VU$0uk#zas`p?=8cNmi*PIc^Az0Y-*ovkevdQvq;U5Cpcj=i z-5k1~++7|Fkw@w~uX*?Wn2HBA%My-kP33mGSU7Y0ndS@n$q;2aY=pJppvAk709x^F z-w!$v83ox57-U|%^JNYDV>ao8KrE|IP~6^_pzzo2C*SP6IVfa5$o}{oC-tLIVBeK- zITcoL+i5xA#pt7q<%V1VoKHiIY+2gFJHh&oUyh0^=%=Y(5Il^S7HD0)g=aYQp4e^C zgKBI!f^yXN_s8e84B}K@Q8!ECn5QBI!|%D8M%2CZ_4aFuDVG#+Nx%2OGhK3i)DUke z?e~{toa`XQBBghJ?%Z+&sc(7=^d$(cQf~aj8@TADkr_zk7dJ<}1LdN<`)3}%C-UuU zyP{Kmwhv9!&hZ0eqnASXesj{SNBD^L)|9Q3IQ)SW7!&}m(_@MOUljax4=}VUkKXw+ zm0#xf9d0Z6uuiCWMy%Je6fN6MR`wBoaP>)6TZi!?UiL{^4>1N+c ztjbwmasp#(`9}}k`oBNF`=Xe!2FO2Ql%ZboyRN*8@k}D0^1|+8Gq!kg76tsLK4+yl z$;!0OiP2rAPnK;U7M61Yh6*rtIa)WLFL8Sv;pBm2ot2xDNb3;zns>&sY)QH*AXz_# zikEXxQf%@kb{&C;L4HD#`)tb&`#XN@-~-jOrIAVVl=8+NY>a)yXb#J#+!eap8ZAH9 z-e~>4FcN>a(lfA)DWC7fnswWDeJ?l$&hN`TMHwN+bqxcY4o&LCt4~uUjTU#4jhWY z$!1s^lljM)Wi=gu@{WPLmzDAaG$&a5v!uB5Vl8m{=Ed!qd_J`9QyQ=AaYK+1q0isN z?QI-I?rj_4#A2kOu3iT@ONPbkjZM>L*_atlh~{R}K~Ir*!GD$&8br*G%6s2!Di3?B zW6ea`hMmkzc+G7fsDz7qBo~R|;N^&8r*{7Y!4OuCkvGutO?QDFDM%{seYTw{*MdLh zR~QcM9e`voyxfu++!G)9Gc~dS(Vw%TA;c7!wAKK_PiHleV!VqIM5c|$x)tGHSi0VL zfIq*+HQ(3A-Z^L9QW>sd?VnxJ8=46<7ELnSm%s$bxf~hFWQ6%%My%f}* zb5N-~uOzyF{}PqDbRKlWTYDJxd>Y33?f|W3KI;KCWBd6_?`grwO1=ICmRp&JGTT$` zeLMjE22RsVq<1z^&@e?0Xi7Y(>v)7|P-#A4W1t7H^zjIUCJ12pNpv{fl(?4d{&!v~ z6j9>XE-`ilx=*CL&YqCUCR)n`&bkUNS;c%l&5^%aDuAzW-Uw(abt~c!MVK*-*vqE= zFpfZPAa4?YHurvP0HQYFb}v)R9*<_pIN8ngtlg-z+h!nKNGpxv2)n(n3MyzaedpSn zT9ZRpwFuu?V|%?3EX4y+t8Q5sp%XEM(~fD+LqewvV9U=*NK zb&k>(v6va^@!bV2_BdPB3({U4N zg=GqT-~RJ;*Y8NVwd1b;N>45BCu69U45-r&xp)`57}j6euiv`+oIfQwSyG9&0?z9u zK{3r0e3Bdom!|k{&{s3lW>RdH@rWloMwPd3y%hvt-7LY74rSw`Jn-8tH6kPKc||DH zt@jc zv|_gEh|H9(u9q9wb{ttjSD8Y{Nk zj85~n4Na=hhoq6)L~J9xD0?lK-HuF*P4T%8sMGgxX0z-zeM%QqaLvelT%vXV`Lit` zN8u6=&-~+|h8i?_2@cYD@9u{cY3JHx_H0?CwIyH$cnV2ybKX0Ceug9h(<eJ7 zVY4oCVzRO!0;wDf*>*QP_9gAMyOY|J3yOlhJ*nceN>);EXd1Sf18 zpw!f9d{nAR1S|NJm3Fg=(EZ%O+e)@1f#gk(p-rG3IkI10^xM{haT$slE;;dKYo#k* z_ml1P%pH17^J<7(W~Z5HvdUpL)_m6OfD25kX93g3wNdcZUT~+`mn@_uq;fVW3owXi z5(HT8S1Od(yuXzG99Q5T9dAAhbOL|O`f6o5#KHa8JJIK*LgmBHq+R#iNiNcqL&W8& zj-RY_v@yp?CW|V^!7)-6occHDkmo*xlElZLGI(+eDTf?NE1s7gg$Msmo z?E7M(psw%XYfH_Ze<%&h^Yp8Wk+|ZiOGkh$hXO9t_sFhqydO;BP`{30Y)5EXruI~nw&S7S{z6a4X8o%w-XN4w1-r6bjN54J(#hpc22tAC=GEBz zg^~N@^1M4b?(Lglyd<1ZTr7yL!j-!YnteysKc-4vIfKAl9?!V+$r@9clNBdPlcTKlBE0{)9iTGCG_ z+Jg9E^XEuxelyFg`NN5Bqx!!S4!}m_z_eM?0aeVNFDA>h^ev(&Rz0Rkcd`sJFU0Rd zH6S09IwqT7QRHEG{6*h)?;I3GUn?Oo?Ac)|*$49BNbN~XTUlY%En>W*ew&V~`~fhf zr=Q-Twl5G-kV>BcP&+-_#Sa%rKf}rB|S=&+Hv3NK?VP2 z?XSX(ymRUP8A$72HkYmjHsX!th68c{mF~Y{DvqiGsG*NpGbp5~tLr6d@FjNfeA{6O zM_){SP1nM_J+ggM;Rq-P{@jo$c}pDnpwS!3avkQ-X^t8bfbE zK|yNuC0iKdUOyb@h(DaN?3oKMUJq6Bx~szdQI9)#PWEgvXz)MGa_yEIqc0#JX(Ls) zy^Z-%f4kd6V*q>+XQB6LTJ-+5zEly$CtX>p88AyX3*3E_V4d@b`LG3v99Tgn)xbNx zbeEdIj|QWc>pnqX+^i~!nq;;Emo5uPKY4Sc=dPTCV5M!I^mnhOSJeDMp?<}iw}4N; z*wCvNRUNsI5o@=xQ99ygh?cwa8%G=q`!)fIQ;z@xpar;<_$Up|cOn@5IEt)^RpVHAV;u5V z#hGT_P*+47JK}ptN0~*}5hFdllrit22>V2KoLBgtpUv~=W8{k7g~d-4{^vM(u@2-f z$c0qxr)NwVbZ;{{#DgVO3N>a(P;s*bgW*5T@82e2>xL6~l!`x}BNC(WWDm{zU*uS! zJ63sFYvLo~&v058CvI}4nfQ>1wE$LKo` zKl@=v7YB~@eLr(uZ%m7-glvN@(IGHoaZvBg>$Z2d$dfZN8hIu>(4otoLVpmGl|A0;Y4Ia6 z_AhH)S1GP=?t;FlcKxX6XlCG(-R5RSKgXrHRWHSY$~~yDzZ~8Pg8!;YR1UOw*YGrR1HS!nkbq;SIUlL?6#Y05x^D6{pZtP~s9KE<6C zEPL|2umOQ|D$v%3e%Bz4k52WSmH(v6@9bzftx|4dPWBDxSayT^S~JR)v@S|0_-)O4 zt?`!*;mJy&g+Y}xL$-cfSA68oFiI^^aNI0LcBY3eIqGItMeSwf_PNa$yaDC$TQg6f z8(Ga{cvVybeeR$Ur&d`_0>mufzSoGj=@l5a=TQ;K@b_3fs+j5gIf#$ypDuAT3|f-y zp`))(Yvk2TZ!T)w8<8o0f99KO=2#UQ`q zxPW#bdh@C}!Qxgn1Mw^rW3D%%O%n2B`uABx*^O^`!-aVnyD4&;Zt!24Dw$NpntNWC z_$nO)8P8)x&#Uatn}Qg2!uTRuUS2OPxog<|Ajknq9bL6^3ct-BcsCK zLNnXs*b{nTITrj~^E!IS?3EZ4ph#pb6Vk?>{b_%~!0qU_W9VU6s%tPA+DK5`1?!_Z z%Lr7j2&iKeesvY@T8H1*ViEZB^8LqCj~gl=4x_UCg3;H)Y*=>^+`l96^Vh4VkQE{9 z+##m}Usvq1@7+!9Ju5e+%yhmS)3euVz&f#9%Rx5JC|du5)dX`NLYuiJ(JSqVsQAq0ReGucp;D#?ppTir>+gM#k-DcPjGds zr@^lKQJCM75c7(uxyXzA5JZ2=N;D}s`Lru`@5`ifH!e}97;;SClO~LVp)yI>HdaIhUv;04Gxm2%4K~HWZ>wzkK8AI25iiL` z_O(XAe|5AL+l{y^A<@wPw0RGgfRSu(j+L4%XLxUQF7HSbmb?x_+5nDRfm36pT_%Ok zbGaX=%mrm9e1EV1GLn4DQ{o}>T;Mv&8Sx=Fy>z$vy9qhr@eIm z00Kn}ug--)FzdB~d7UL*P!{|nW$9My)*ly%;KQXW?WgH;b4uKxMt*6yDSBn*ogY?LUzgg97RwW}S++T%h5`M<`vtg4sHPx- z1v??NgHN>0CdI6{ka^ZM&Yd5)gs%A8uJ6f0np&G6_jF>B7)0&t6Yl+$xeA6;2h=dw z+;erGCzF+#n$Q=}l5(DfE>v7%>gM3;ff+cB74v2=Sf>X0K6C6cs}I> zBbfNWlJppeM#h5K3$>xzOLtMa&3}Vzx|^O6I=v%{UJzL>UPoJ%+sMs&f*?NBlt~MH zp7o@NE=~7vI6uvwjQavOlV{LYI)o&48V)vY$NCM6Sf;56!CbX6kI?f}^-4&xdN>AJ4=rJ^3{>G=%91i1oTyIm-}WVhw&< z2I96P_@Qu_x&a4j7%P9u?`NgmmUpW}jkVrLL5R{T_89Uo?5jlnjoTK6{5c-Wio?hnW=9bRRd)xctAZ^N^vNn3vX^k32cxK$j51r3{ zqL9dEpNNjFz6#@7av20S-{9I#qJ=3MxV$p)*7AnW_96zu>l2YiUE;Di4m1n$R(c~H zz&A4OYk>seLv!7`q1c_>I^fESqw`iv?YwWPY%yGJ+)3=p0jvQ7eUmDVF~)vu`BG~= z!NghW-&)CbUDyav;d}fZ7MgQH(Scl(Qjepp(k^;}+~x#d z{4_N%^&-h0Ao>}c!E;^;w%USzRDd()4eqnAf1u5xj@8fmwnM|hBp0LZ#KZE4*d!Xz zep*d0RC$e`u78QX&$)q|a7xBm3c|ttSzTZV8tU;NCr(;dtk4hsyG(Hh-&DV6iVW~w zw&Bsq*tinPgkIsw0dgGRp6;We9=iS?8HF&OAN#!Qj7zudG+FY1ON&Sj4ghey`)8w% z8e)!RV${arpUE%o1~w}p?mXQ)s)o$pO5^r*bv&&>udGTk%@yypQGJ{^OKu|D(y?-vxFAj+(S-SCk0lD&Xr9$$DJEvTEQi&*K^nHxy zQ+G$Z0v%^Spkb!`Y>KdW+L57M9;P(|D{uiJiLI>I$eRU;UXFM;gInDjUlm0p3rQyyv{e1(-C+IP5vNU{a(BUik^7LKuqit!on&o`EX%v2nVNQO%i(EB63tiM{Z1v?u z?Sg~@P%juxdakZQK3O@AWg<#(sQ^1oqXjodM?DaQl?6xYgPNd@47(MD#>YNWOfS6P z?>DLtyGaKUMm#|gjapE5@fvm06WU|yctvWnZCYCWy>c^;l0w>)9}Y_gX`M8_j*RW3 zA2-G2o!SheHShxMT)tBCRM6x@~7x&Bane z#(-*RE=)NY8$nG`(na1a_5$YQOR3RPvOeI$4c)f?89u^Vn(|ttJsMwh7l}R zN!%?El;0n9Yl*B5fb@?0wp?zH?c(z;@*LWHN1q*jM@y0X^?>n`7uuOF2xL!eq=h8L zOb-^lSl?~NA)m4t$bQ85?I%Ivealiz_sX^@px`b6$X6ZYXZ@_CXLefnvxCKkbw>jO z3#EeuhqO)i29U!Q`Yxr9c^+A3i7F>hwSNgm^?UJcqbsYd?bxB93#&B;p5#hc$t z8!^GXedeBGEn7bW;y^XrxP>6RKyiX_=WqF*GHNiocXRP%zIMcHjf=Hgmb-$@;!=j4Azgx73qu%>Hl zTj|jth@zFZ(RWp+5y15}m4w~SBYTX33vsa*vpI}V{L$e^Bw~~M3-0I}>;j4rxLh+g%}<;0!24u8v@7L`^EYUDIg{jS8QhdVtM~l9N zeU==YsVMPCUOuLIy!vQyFrVywk0r~Wb2+QD#f5!1YzC8OE9Pwg;gqn-OvTxn*Ruk+ zWfOdjsotW|b#?I3?#;#uf#PX)?qLA&I8z^{wN%;_dt&_9y`p9&LogpA%3=w4L8QG)wSYI<`SggU}zw?!{cCj)IS$mXQpX zc|&HlB?F8d($>@~PiBL@Stps9;j$~HhwR{FKky)CGkRK*)V=&alJp^r4OgXkozT;7 zU5>4F9K?!=n5!I=i0wy;G$=y!@Txws;fN8`h@}KMNvmuVHkKEb4X!F`fGwgxIaws7swYKABYP0uCShJT^j?x8De}(kiDd+Sb zeqv=Q8F(NiwFcij>FKp+TGZ=UQsvlbU<~eo~VV)QDX<=1@*O$w!Re9-FVyD z_~$<@LNT@fTC8vD5>o-M1-@$I{bP+J`AfqH(e{SCW7jz5^kaai43u-GMKS2+D!cmI ziq*wzpL;x-o@Gbf97+HkMD$i|qM_-GbaZr+|GoaGG0D;hYBd1O{luLW=M}l^DK2L6 zW?CIg=uJg3)8n$D4Z%ne)=*zu_HPWEA2Iyzu&sDPY^e{-qqUEGF@QsMkH6+CxYlOr zKWku2L}EO=GL8e1Xm;IsxtjV4HjJNu&UXKrFi{Zsud!-$j>)#DLpL!!$LC%ks+u78o7wGbAu|oB4+PEYOK2M?| zBMT!-yyHvhjdGeBn;fw%+_RAP6@vAnO9eHfU0Dp-1KpCWR*vK04qp=1W-2!skSj^B zMUFuFV=Bd{^PHSRzYoivP00=ox_zbm>$jmIjE?np!5v(t!uGrj zV6(BL!%z}+u3}!kRy78dUyE||XxJV7#^!46t$Cu?a9zJ~R9SbpgsIXu>V<`hkIy4` zWSP&_$+2TQMk-?anf$g1+2rJbM;##+U)FlSH_Hi(9{}Bb6&5G$c@FtgqYn&68z!96 zJRTKXp8mJ3%6ppo!l>fS@107!Nh4Kg8a6`jpzTXqQr!Di-IbhULRwL)A2)>{C*BUEukH~ZkYJfT%pHk?6d6Z61p~0H2wKXO!*1Vb z3Akcsvp|F&oUN!<%O%m|UKcZ1``NJD9}sQNI=}OiU=VL^qyXh`yJ#t+?rD&pHGuT2 z_Cdz!bHd%5GsiKhCht}%vOh2gBdT&is^QP5vX$tuIdS+jT`7|xcW8AH;0rk)e_TFA zd%QQw3^Aj5-?JbKhY3EGSw_Y)qT}QCcmWto+gmVrn)Dk-KUpPbS-E1fMn*9SFS+dv zYIwEHG`1XnR0jAnKssPN=U`w5GW3Ww`ldrKIq|Zh)nWO4fMN_b*fO>)OkYF469z#fF;VCA_klWN(@1>F3>T z!$yjJ%=JAamp$+YJuST>&CxtQQ!LO!#B;)XpW;jt_*Yz3gCrMALLe-ThR5mgy3Vg7 zn|J5FG}kQUuUtxcY4_l<^y4c(PMm?9lPYxAEu@4U(Xf-U4LSue6LDh zs&s`JZ-HaeVWT*u`rQR+2gGMAuckILa$n$ygM)jt5|I$HWT%7-+b0KYY$sjn-p`#T zQk$p-IIx`%*rvT%BB|9*|m@c##REd9o zSAVOaf2+f(_ZcjtLI*JCBxZ2|+Aw_f$wU8r;1Yupp*ys{13Cw3&Um@e+?;&lziI?v zFO*6>08P9x;7uqpfGvRf8vV55)8$3ZqnQY_5zBCJ_-Od+6?zv&D;?f8GD-u%Ki^jV z5@3^mEA8y;e95qOGwM7+p(0=H^RulQ%v+mG~Iz+xCo5BSp89E=WQ5g=b!3`k3V8Z7ImLw zeTW-yic$nq8S!MC6M`CY@Qb(4^JpR-6&o7wT3bf(nZK*%T1%^l`Bv%MiqP0GXAMS# zAbUk-F!{@#fG=BQH)&vc`g#h~^v-U4)YkC}Nau7tUFlH_UA;RV@T07dAP$}kh7y+J zZQP1lxQjAc@SItWvHx5TB=;3}tisgHt(n#m?%1>!YZ%%z zNND(AN_p5%=v?c?EHAc=3~r81(P593u|^& zPdPDFf8^;Wn{wU`=j&2#k=4mMcWX9rmKQfKjc*^p9;N?df9?AU=i&qk2i z&FbQ>HVq z3aAYsCxS9TQ6|eP-wCp5A}o$Q=gI`T#3cL&|L%LxLzVpK3GXxiawnIF=V}CVMp3eR zlc=~?Bh&ez)N61k zV^ioKuPf(Suz4cVo;bU06qEvA-Y2-TRz{NcXAX$LNzA!C7ZxX76xo3u9J~$oqrU9> z9wCMN7_tu6Jn@JP??pp1A?40J=OX@ zE`XR>Z#10Oh(>~`X2W$jy!4*(IxZ-5jviB)2ft1i^13dbD6*PJgeuOl1mkruUbWe= zzQQgY-nP-38~x5tME?7Dx+f23=Pyvgd&Juo;P?VyAKtca9pmYw!_%HA=KWV9cGC)teo5`blDijE z1}SeYD#zaM+MwMjXz~5995H z@8FyHdhnvEIa}+#uFC!&x2p*T6+%Yx60v1`ezdE)FdvB%F}C}CUxth(-33JOW|D34 z1eTNo0i{)Waq!Vyx4BwDgq(znYa7Qe!W~*voIvp03Wkn-FAmO3(2AcK^&p$dSP1oZ zko*tm;J%{D=8hM@VSFf~r~EXSvFP>u*)x$$$+z~KKM&vzUZJ65?T;9c5~P0~F06Ew z8wetTLrn4E0DA=(->U|CG{rN)#2QP&QNn`b6PZ!PdkiJIrKST12M0O77Vjgzql-Xw zNIf%!0JCFqZ>o%+?wlf4zsA|(%Y=HKWe52PjHoG+Gyv21v+ikThJK~3-b#_g{rhD_ zAMzc*^x3>)00L+cmi{a&i~$4-=}4j1y^PJP`{UlR>dK+r#Kv+dFJdaVPY}SiM0m})&`_}Ax8zy4qmDTZcX*El-iBwBx zM+PnE!8a7!6}AOOe&!4N;Vbu`2i6?b_x*k)15^!_JPSg&5*^s)r??3?*hsw?(v43*+G6kOw-W+P~v=dkSMK14L=u6=<268@-*KowXa1S#>{aqTn&agS(g+x9O%7 zm-$0&m~49a3pL)R2eUqjLdF>yC^-3{ul(XUdgLwrrI+rrE4WcS9xn85Mp_A0qg7RI zm&!!q`uv6<)lR2jox5SSn!dR75^H*1Io-PCab$Bz2qV)YZQl4LRsqhX2^m1Z?@>B~ z1HR%d`@k6T`cMg}OI{^H=_9#WYQ1iB#rApTc7h(=B-o@`gLSS;XtT2dW?|s+(SPn;qPp6_cP>Fkn3KXwbNAwqrb;}C$WAKZ2#lP{_b1e;vn zym?oCbB^{YAfLJ@FNIMKygEcCZ2)9EUn%-Gsx4&d$dgeK9z=Yus55)=T*M zGT7x?z5S3YyH+sCBGTc*gcJ(n_&zq-yWVvO))gUJSt@-cKy7(*zvy*&nPdYEy&yd zao$%1uq{PManUpS(pOx)8`#sJW!XB?_LtJ}O2ThCTj?w2oE2ZZ)L2;|4oJC=+9Gc6 z&-neGI0#a=akR?R$YU|n8(~TIhs=X`(C9(6$cN0DnVk7O0a@Oijv;e)JIlS>L|z-l zV5>4!pqQ2iKv_!O(hab*9Nx9VPYQ4>qspRTJK9i>-`PvPD;T1xT(?8*FZ*2&QcAA zg-L&8diBj4T$6+OK5Dw{At8Q%`pBb>65u@>|M`}hH2cj5BdLSYK3v9*KXFpV3zB@O z3=qVVpLsSWy#zy+#6?iUfGv5Ft1R_J{_Tz0ClTmNb*%D#nir}c{G%I(Q?2h1C2$)4 zqtXF@UA3V5qpjMPZZs+^`CmAjgd2JPm6X!{MYGce_S5T##h&#WKr*<1U~5N2xHTMh z8ZmY}dJaf_oY|Z3U#Mvl2l??VreI z`5f2x<~V7E1$W{Rt5I10_j?FB$sgU~jtYJb6{XbK;=YHC$b+gxOy598LwSr1*5MaY^=@RH(`_oGW)`VN3 z<=-l~@Lc4-{a^&FH@7VOldnBF`;|6^YYg;THWdg! zgRiXe0lQbqKsp>|c#E)?jG}0MGz8)RIGbifq~Z3asPK6B=wV?qSTV(kCkC^uPvrvu zT5ZkN8Z|%%qD##ZjO~B80b8t31>nY`pGx^{{(E}Ik?#THmDz%?r{V!`D~06--bMjo z5knv>GBV9Zf29Kef(u-%2BEf(k3KId@Jn)E@3kF=iQLCKC}Jff)ehsJ*c1?lm z4rBIO!2&=}CY6#*)vp2zRNSWL%m{v+^1dfwk{6-)x?X@hvmQE~X#U{DUf=`|rAxh~)%2q>6?H{Pru`qznK|k)MzuwY!8buO%z?aS!$% zi|kndl6HC(Hpjo`1c2GXshI%D#rOL6Ar;0nxA(7P8{S{nDyoB#%rvQkFFwav9e0Y< zS<>e+&!3~c12+Vh@1Q0=v{e`Jo-M?R=0}W+j?&(|1|^~);87mVZ4>(4#J*Z0U-hiP z@(@ANp#1JeBd;f9S1vn+J1g^HHW}-VxH=`zzo!t!x_t7ZkA;6{K@xWqa4i+YDM4V~ zCD2uiL}oCJS2->BrgzxQHu|cFPfT`+CD(@0oKMD2ql&QQg#zjHS`eVBEMV{2;N$tj z{pu*^$N1Ce1r~O?i1mJHFfuN&zJ{W~^N>>_tw z3IvMmS(%Rm3DpJVlNT{+yeco(sCljrS1KW(Pc8V&%G;Zp|NQ`@X)nL3x7@U?+Rggt zp2%xo*X*D?f?JUwbnJ_u6t4|vXuRhH4j~qM)_M=FcE-ny?!t$_iCN$T<7(r9{0Ix8 z`d&fw9*f0y%HYW2tKXd!Lr5Fl{-&4PdpT8bQ-bmt9ZWIe){jT8XjhS zNOF*%<+xw&kwBSnwe|{=M6}0Yj{Jldb}G?WS8p|8C0wzhOwW~1I!IGU4Dk1V{BMsO z#}m|oZXCOuNCr6(vI*K*DW6x8T!h|!d1s9y8~=sm^{L0l+WbUg?m#C%O`P_HUuI&n zMvT_=p4vb6vXZgKJfrZS>pQEud@AjH_iS`?k-b5{pY`L1XvPU6WkZrsnYI# z-7c4gb8Tt;bl8?AW;F(K0f3QvI?pNax~{peJteylGB2C<1wUi(u^`9UwG-cBhm?rt z6h-6}tO|a8MSAsA{t6`&3Mpu#m-oi5FH;f~1&8X_B=7Z{|BPUBTyL&Ch42Gf0woQa z#qjgjZuf3qJzRdKKi$|^`298}iW4&|g*4Oqd`zR~ry#usoj=5j^ zF0t9Qjd>I4JRV}nebn+m<+zxEA1A<_s`@CHDpYy9@jQyNbw)!D(a5?tDa(DfZIA8M zqW+R7ps8+@WaJv2E`bQAN5{kQ$m|b%5pJcr=1jOiDg-=#^9=}colW^PK{R98aD)sO zJWx++8sO4_J{6jRHxs34|KyNrgA_!`MVUl{_ywm+HNJsHha1;Sb8XKN&nGGabICa@ z&uM}D#1bL(^CEhlS>q0?yKF{MwSKbF=s8*w?A+#<^OhUNgh|)=(SHH{Y<~+a0_172 z0|e~mA_cGi!k0v}-r9+ec}J60&wBRS9#70t1Z0wmHQdUs#lhoUwEpl>@qcygX~nDw z((WhPLre)ji2v=j5syi3>u}%g(4c#4O68+3Xpe#vTyQHHeXsaNXJ)QP;^n6o5$mhr z9GDkVZleLosrD&f@?<9t@Ub|ul^GcA>kmT@zfoTOT?$!~M4($x;)C1yyYF&WAFrCA zATw7=C8f%Phj!5&TTXrXw@o?0BC4{>g>4+A=m#IK$+nbJM>}%~az+Ju9Q7G)lK{Bz z4HL;BrKKIQkS3DZ+w(l*hwGVoeRsA_PUyf;6Ot~kvU2-rhjmE;yV^_zya1Ni_~|BF z&}|DI-Ye99)%6K-r4= z3iUIQl{FLV4Z=KQ*U2ht|1|D@d9Egl_OH)MYeuGR#PdgPwRdQ8pc-%YG;N%tdBdh$ zhx!QORT}mM|2m6P3}|VcSMBxxK;DP6Dlw>cmYV*Q`uZzE&JpjX#dlfObARepT#?D6IAHd80N zK22(>6$WfA*VB^lJGa!=?Ejo=I@;H+3i&?h6npadeV3s+l&8;KptTLGu(8(b{2wPL z;h%>~vX65g7eqWp`i8GKg6b%R06V)H#iiOEH$`{T`SmGxXIuVmIaR2K<^Czoq%f&# z%?(^vXw*#158qcyl7&z7AmF;;2LPn6O=K!T~){ zwUHk@IG$ktVRZFC)`1E#-?Y|QH{JQR@|zv(>mNlrezci4{my%30{uO>2TOE$IRow~ zqC!2Rb)L-sVm*bdDngyT_hQ->Kzz^JM){jNgzyggpQsr5?>tg43OjnkCbZRNhIovg zZpE78r(xJUCitmRfxOh|h0vs|JN(kYu;LAdZdQK$#T$7_QzeL@B2C_K|%; z61z15e@aiO z{$%!lvy?N!A@jlR5z-CnH%G4hH3EVp5PLqTGI4Jxn)pHni$fhD!6KtmVWv00bG0V? zHv`@rT0j(Qgx3SKuKbqCdqN%9kb@k;#KrD?aj5wcJ@KCoMiZ{B4+bbgLZxGc72C5%II0flzK}LDSz|sz97KBmRGgJln(9MjV~t-xXRPHMMjvebJvnhw zDj?9~J51PUZB<#9B)6+g^!KCrbACfbTgi5HrXtYd`mC?xMv7e81Va+{G;f(xt{*-N zxx9M)X}W?ze@x!G15aHv$;GX~gG?6au5o|w<7|h27TpUG7V8@UJp?nq(rOmdRzBhD zy_71yN&ByfH9=uc^fJR_&xPIMeQuMyP?&s?zUYPUEGC>){}FWkx1mS6l>QwV;aS^; zoERg&Sse0|Tf<)TDg%9sXt#dj?C{0vezuG5g)#hl?&Bq8s0VSjw-0LT zr^XYXFB$xJ6-&1fvptJ)`N$di26Th19Hw6RtlF;a-J=%oZC@M;rdt_#!_UUUiF%bF z%m}?2XY-Or5pwx)`lh^xU;lji#3BTmF?gh*PtMVXP?2n;Jwwm(vYTW7r5zoM{4e-g z?#i}@)&A-6v$7WydVxP3%muCMgs=Q6%}G4GypNB>j6(TecngFFm-dnHcj@x6xlP8m z8TPNjGc5LZBxk#>mz%-EP63%bX3)3J>U9+v%SHCfoCD%lmg}!zMX2*dDCpoK{Z)+C zl|#OPi~JIPs+=q=aogiGRic4LHVP4#XhSCNbG6Mz$k`v5R$`sS8Fj)cbu~*W61*&9PYfdd`vhOl8 zUJ3?Rha!(e>A&6RSw*whjMZuLR!rq{AqwDph2r*%O=WRjsj~N+%<=?7z~$<}F2zc} zU2H4YWXxf9+qou&VgT`I*_H-1c<)$KGZDVH=UQZYBgA0Kom~ovd^hf6WF?#AaROWz zyvm6~@j#I$6H(_GC@tsr1-_;Yje8D#ah~8d0_=2p=x17gB@lJgk%& zU#@TiJDd_kzfh;_2Ull%#S1$(tFQg6v9I@liOAIe5+Hx%A0i@ZhzS3oaPRI~4 z=AV~KddLL+E&m4&liar9ar4M!av5*VFsay#Y}XYbEog`G>t*t^TZQoxib@wjNHj0f zK7*OgbNUtHVxj5noRVNipb$xu&j$a?k+M_ha}V2%MHo^@d2=?dXIb7}!{mOVcP#6f zlnr8F{Y7GEs8PjyJ41tGJun&dghLMYiHOYcu+T7a)mcZJN#&|VXSJ~Kt^Q@=>^|w! zi?0j*Kj`mvLDiLVzHs1h z9Rrzg8`jDZ5jl7W|9?!qcRbba|38i>QaO^H5tWzh%rcJ3C>cfeDl$*V$mST8laZ9n zP$Y?C?{&z`3?X|v_QAn%9Os%{s?_~^Ja9H43a@Vtz4!Q>>Gy* z-&q(_ULZn}b+nl{pT=3dt1mjI!`Vzxc@VE8slTpR&(Jk)9lI?s3b4^u$r4`MV^S2s zB^dclF#XKN$v5D3ArQ%aGd$9YdUn(6iJ;5xLP$3s#X@c#S9S>u*yF;%Vw@8usU=JE zArWG330}#8=eystUyB!`5NNWbt7yD`sI-*3`jcntS1z}V9F%|Yxbb1C=!*%m6ewZx zxu1VX<6^L<4f&Ab@&?5@!mIv3l3^X22X;xqumb^kVw@8L+$U=3>+jF=w9)a&up2tp znJuqoTMWA2k>o%2N{x*WU__y&&fs=1)yIvL9MQLiRMI$VaHSe{5EsFjqZhAR8Q(` z$!esmSEis&9&3LrP%MXS*sJaByt}#RmzWWRR;<9f>0R^%+#+}|SmaOOB2EkV2g?lC zhb<3UWT+U5lbgV%KGw*c56l*qSszX4LBHtq>%F>F@K_vkR_BsG#!-cw?(YPgPK?^_ zUH#QD5H{Z|`GMc?yqDY8-Eg&~^(W3vlo>fG_^~E$fnch>tE;~IY*GWlGrNGDK!-ab z@{(GN+@LuzEj+ zT#|!HLIy_Z(NmrbgfwO=-sHdR{a&= zT^^EZCFS;&&(Fz_D&MXbX#9|r^JZZ9BIu3&V?)XJ>FrGAxnHcqXdDP>fuy{e*{9+- zzgxSVTW-y5DLl$1&LO4uE*2u{`U9ti(coGoHUTp$J?O*K`z83Ju50Df$AK?LpZ&i~ zX@ujOevRUJHLYCSI17usoTSmD4rBF%HNx>q#!O;Ytisdg*XE4#^Xq>e-xN4{E|bB; z!}>Fyw) s($kZGYc-An8KdFx=zWI_;&F@;GXVt|e?@cj@B6HUmY_#Tu zB8)S*{h{W@p6az1nDDOL2Emt)DGc+vOub!g@5py~Mm%7!pG$wa!L6M*lmFuam|2Kp zJb%AFiyKSX0OHd>B-`h8?eje;^QGVaUC9_dMO{A0v;9tnq$B}q&7+L(nX}VxN zx3Wv&e}7tt#67RM6SWe#Y=1x3SdoPVB`r2q<2;l;xVR&Gxuv+YP~^qhf(k*&d2g)z zN-z>+20Z$!yURp*J1jodIOXF-K6qx~g^{9>zJ}CNyi!gJQ|xVVA1UTnx!ZL8r|#t{ z$3qGiMUPky=i`ZJN~V;G(Rmva1Xvnj;K0WU85Za5S?wmA$?l;jE914b93wx)JZAUx zi%=#k?B))*2UT2T>-V*wV4ptA+TI(F=i4466?jj8!zAz11O+7oE-83e<&c1SAUTA<1^^OgS=Jl4y$9E06nFNZYm;9cx%fByYDe;2_A>1QhUREyu9?LAF& zVa*<3NlSIJZ;#sgFFJ;J%Q{CZcPNX6vmgX|+01zm#}@wn9e)X7*MPI@4-V#ChvU1TJ)Uy0F+2(9!_rPA za24v=Vf`$b(pwjPH8!i!wr7{~O3JN9}2# zld~Y-_3~2KH@Rl-GN6JNpEMZ%t%UUT6j;MQ^5y^sdFK3_z;NiiZDQx*3FBvfCAkeP zl~%ud34g5lh}b_Ze3e_P7TQZBDk{jNPF^dh3X_JcdxKOX-Hy4~;Ac|sU|F`+xuG$gB@ZaO+IoDWFr#&D z{G2TBkA6(ql@^2by*0Q&t|dqcGXTO9fX$wgh>i(*{Zc{R!se1LFWBdtQqRjJ6UD_b zq4RCC7o#(J(9HupuHu#Y%-bBKkNO<9_)z(FF^ZoRqI3RTW4v zQo0eBKf67)*Xepym3x-oUz_t^bmXP^sJ|njHYOuFfMRITU-MMK`5hg-O1 z*w;#4A%nw8G2$2cK?@AuXSf<6cxWf?^ZJmyKFRp$va#tF8U3f*Rs0?IOZs1~K6)jy zZ12<3FNHpzG=!-CW|#dbGH3tr!uH8S_IJkJ1p)_={NMkxdhVlc_3m>+Bs=X3c`F39 z{STiLO-VZ6asti^E?kl4|F!9r28Y%gHjj?2j%!>0_yH&4w=O9f1g(C;s2#LlgL zoP2qnT#<}?WxGj$C2UGP*r^R?PDU0wSLag`DqoWW&3}Q{JmS8;ONdBgX-~4XRzu-O zIr=13SZ``<2 z9MdTQpV#ey*$aeNotwdauAAAzV@wsJsiY^i-7j9Xwpyczogxw`R+g6ZU3+|>wGi%5 zxgRExNbWK<+3LD7?IuREj9#?gg3j1$$XnBgQN9aDRhcR>`gP#?m{7ZVA`=h4*^xTZ-aQg(xoVg-RXhzytQ zZogf-gG8l!%1|VvIz>13alz*YV#DcVp#PMFGR7*4YnsQ{V*9e2^D0pwGr&f(Fl%^h z+Ddt&EGTixYw!dzwb=vDjBFGa@JR@S->)SNp_eLfgIos8aVQrVF8D&i z9xBUXYBTMx1abX62C6w8MdyiR9yQzzvXuOdUHi&kQjQTZyaw&Zrs_o-l0ohVT%t5RXC9$7N`CSSXFaG_>%ZQ_qxj8X6GeW0JE6|#rU^5Q+a@|;6Kbxe zd)?JIpZM2th-Km|&q+~#`CXk7%0vl}9juk{)d>|Q*I>M zkL)0)ZxiKxR`rOhd3`292eZxoft8&nCfizZr-UGrvCFYZ_L$h4srJtWzg#&MRQ~BI zoWPUhVC3aTHhD$)z5fw4fPv}KD-8YI2a3dR(Rd}x>VeWe6^d{xM>4Q+8#K~s=%3!_ z=k4}UnK3E*h|K+3Ns*K|-Fvpo>QNa{N#5x)m^a=X#^<7hK{;Gw?U{hCEXJ#l&3@s= z?T*|Wsd`E_raY;7R_IH z?5&(UJU)bbk+rd!Vq|AeS1meDOs_nvExBbf^%ls5UlKxHc^Q?^W?^c2qXj*r>KHL~ z7x;^K`R{F6^IqB>-_`qN$~a-PQ1ezSmD->Dz8O?aDb1GR-;+bXm% zZ6735JQjv;;lL5?o0Fe>(i7I<9|tQoPZXM8yeKPxqZ?Lf{i0{Ng z|KrV!LWJ}G-Z0jhH+k?Wk_vvb6eUV}X4$>VMooLwxKT`#1^K`eI`enL*Q4;P24!o$ z-s2aJ%7~P9O8K(TAnGUxg9L zN!$OJBO!VbQyg^e4*w91t{=$=YU=xGbtTi2VkiZ4KU>?7GqG(-U^1(0fp(w89ccw1 z_s429u1YOt0pUjWoFn_#T>7o{uAJf;e>G!)oLgW!ZV#{s*H4gKRBzoF&GrAqYZL_HSinf0mNskK{sh%-gyYL?ZSV4Th8Sc;GXk z@Y>zwe$A8aR%5FCQ8fKw^WQO9Q;gD4_Pd-Et$plE(_eZ$#!p*EXX98uy`DWSO^PL|g)YyU?h?j=k~9*|u%A7a%NXs%DcHk`XoBp1llFLYP!@D( zbTos-HdySa^F*pLhJjsN)KN}Z0&L#QWoq=O{@R+T(h?0t)R4R3Ay|A_4t~@t9PMXT zfzo1wbJ<6zP!?LxsKyXmb5}&P4_ZOjn#-_NYnRp>XI&kVlg4A?9{j>Gf$~8D`h3&QofE|25`z%qNuHI%FNtRhD+kF_d-YFz{q|7msB+K zY|p!}9~7={j?Nr`k5bXZg_Nqh8&;l)DmgGkw8 z*_ARref)+L+RRt2Tz}--93MOKMfDHJ+}WiA?^+g}xvKDblwb?;KxG{rkkrKr>pGn% zIl#ZUO_9(w2;FY^MO3Xn(kO33*C}y@jq+_&G%!wr>x_{9UkynFBQ5xzjsn#(svBHQ zRr^1?3;2~aDf`UvEu?m65ljZy=gYOeSY5Gu?|?K9gDJ8#~as>)$~I zHEFpiCE?o>*75HWdc73iw<|tle{;1q^Sw+;&vbyu#W(+cbeV3q$*c@*7hjyQTi%b0 zmZqe-^!dh(_c)wnr8Xm6)_6`~?ogh$qf+(Jlqq|rUwWl{_grC#p-BTet^ZPp>OS2k z-;PVR(I*euNwtcGp&SmZ=8SD(<_3i$KKA7Ek7+4dq(W=6h-X@j;IfOsN>xTvqE!+t zwZr1x*jdwok*iH%Qj{MyWq{iKve7DvK z${!xkp07ADI6az+c=c7hu~2#@Va1w~Hv}i$sTOwvMhsatZ}bbPfCggA*I9<;1>KH| zue)!kOpk<<5xh0-&)eUwB%k8lY8_*YDK8W=x;BE_s(5o_VSi&hLt)Vmen~)YXiwN? zBS+bG>cJMVPv;EHiL|?+juPF^x1M73fOtMrBEUL>3=~xW+xL$(Xgzpra!H!i^vftq zb~|N}&uQlvBL^=q-m?pV9)?7Ho-lODZ{zJ%*UF=8yabJ_U+|=^`t*kcR#^RRhV60q zfFKwZu1J}W_bil${RLxGuE92VZM#z=8_31^mJCB4cxPsO+5ULsQCBnuDgm?QFoGiy z#v+MsWdg>ny%qb3ZwINa69YkuzV?0A+bVWk8@h$smqz>Rm{%B z1d|C23MPrz7C=djCkksQ0r~aNsWJ7(7il(|EB-s-agjLl39N-;{hA@7q`mLkyp-Sb zqS>Zvbvj;}b&inLw`rnTiWYzLrv98ZWs803fL+U0>Ftwzb6%EG3NiXKcN>4rxqWQ$ zy6*hr7G!1U$^D@HbcVA8XCN!> zbrNW*>fd}605rHnH=#SzSCRLh>ruB1?oXIJNRR{|Ahs8?A8jiV_UA?*lIyF()NeVYVK;ZqKm8K^rX*Kx5ev&p1A`o zV11wKRh8~FF^U%&xgQiUopcy-S89nQ@uR=A-$v303tSi23y`yV^GOXYm-FP2Q* zE416t187JxKtr~_|9qtDU;9q(`1SeZaK!NaonP{Ekq)?MIs2 z^S5N-Gr(%Ogjm1IjCkfc8t%K2lAqY6-SbiPIK??fqx<`gNKSmm`&p0U9Hk>wRlmHb z?&w>tl&z=ekcy@W2tUh!4|*AWF%xuoyjY_Us{UhvfUio zM|QaN9+32e($+xXt~>5EY?=Xy8o<;~0iIG7(^6W%|$Hz=*QMLmf2(Q2Tt14D9|u)GG68=dcfI(;k;| zHjzXzTR+J2FdpRWyZVd>Q@b3T{P9R7EnDPqwFSva z#G`%?4Jzv>Q?BNsLo<;?i8E@OXU55k?=fVXTF=S-XopYrD}Rfd&0_AUsQ|SRi5QXq z9>auYQzdC4@yz{XN)Ap9@!60VG;SD$PA}Okt0G*edDs0BEEW zjkmrjV$fz$^TK`GF~R=3nK-J(v}5ChZU(u2fne<51U%dtk6yr-ykDx^Bu@o7>dG{E zQ5XFqp$mRhU|Ov0AiK4-`rn?vRt=n$!d+>8@J;8~klYy*sI!%O`l`4yMZwV;Z=*cJ z$?HIcD6Z`tCH->Jy{;D&G9C2UC~wGqqT2S#_`AZVDVkKFZ`cuujhFA+&q**)QIuzb z@v1k6 zDBXzAcI5BmzKy<_1_RTkZt?H9>Me`_Ag8@~m3>1%(lPYq^<<$dp=S;Q%Z|&~kjC$H zU>D03(3H$fmlYv)t)Ojw!0Gz^pb+cgOx57P?3aWui9^p)WGv4dC&CEE3#VUY7e&L? z%%A>x9&_yGwZl}WN)ABd03{;Zp%CSP*Drhp`R!!#+F4+|W@Ybs;Y9bH&86y}gL98*c;P2U?r1 zDQI?tRJ1@qzPdQ?FV@qeJV@Kbgpkr>j`NJ^NJN%vwqi+jRaL$n2-^8obF*G^)Otz# z-`reAyTNY}uF$po#k7cX$buZVwd#st&-Ai7A)~9(Lrh}>HX6|5Xk8*Sb5+J4WTf;o zLE^?&_T%cSzk<;JPKUZO#eK~7QZlH7jSH(2)yq=C@&}%gihjdD?NA6ZJ!pfWmVbb5 z-|^Q#{#L2hnVBS%9ssnHEZ(McM{QFWPnwr2kRD_EQCjN8Y#V$<31(Z0Rwn&?^@_!G z?L;ur!o4+NC^xs#Brb&8%p$0VPM{jR1iUWI++0Xw#MMS{*0t}vQ zk{kFJv5eC5s~#7=oZdGU6qB1PuT2+fB;y;0aP%W}nYD9y1_3=F9IoU9tOIPwTGYUx zu%t~%N3EB|c2jP6_ymmH@F@4lvvMX7AT!>~`1{PGf4(uvpNwhSjEcQj{h~fddyw!) zBq^Q5Ts-U>(}rPnYrwzNCDvwH1gA6mr84_fAbe+waZ%-N!iLveUq!xcw!oBsyjmMf zIFFLJM+mP7Zg1Z{b{_NqQ;@Y4>*1pfb+rx@D`qNSrr7oYjq83eTQJ5R6yt$KY44R& z9^Ljl80@CtE}=(^EhSG|uyvgKN1fz4aGNRRk1RBs0=7X_->kcwPwIeWYl%D-@i6{{ zlNejR2s1rs+n$HQ)MY-`8j6skIuiHbZAnZQ*xAWnGdwTW?{p#u+hb9`I6SkGD-3{|=K8&@eC-igYEoQi+6Gj4-F_FxE@yb#;n`=)5cW}dF zede|epUE&V;2oLBt9*DjM~(ual1(5-KM-|hi40{o_FV;c-u?s!U+7rALO zF2qUK?2?~|>_|&DkZYBrvGI4x3S&(O1BNj2q5kv;tY8BM8CiiVt=w}+b6-k^^S3E2 zDDQOixe|Y}?>gKAcq}UL8vVI99kxHuO*k1DORP@c*Ze;&fW%ZFw*DRu@M|c30n|iA zsq(YJqBs~#dDzK6*4$8(5g5i(P3!+N3~^EKl7rkI$@RI%CLt9nYKIYVxk__1)_*l$ z#c}k5mo&S?m*isD>rG1SmCN!tw(E}$0}rJ#hH!+dD#4&prbj;UUFv#YxpsmmJq*i~ zG-V$!daQWBQOSO246D=^@PI3(HcIpDqj9?g&7+}>ai2&u@fG6JpuJWDFG6X}W*R!t z6)%?91+`O`QH1h7g140JSHIF)ECtDxHH)oTKo@tMJbMrsjvMfXwm<4xoOU)+ICuj_ zVt6%Utpb1j{7Jmmo|`AN#0M}(JgEc$Fzi0&xWTMKZWyW@*pzb*@VKB(U}jD}hpKp{ z?ge|*JUsS#yG}?BMV=JcSs2FYiN0K347R#IC-J7-TBa><%71Dv`_-#fBNhSsYK!5| z4gM+>nuW~+j&=E73y6d$mwMOnij6WIaIcn_O?T^TB5#oZxzhB>j7IVPCBYp9+in1t zd!{)+;8k9|H=ss!==650BYYp(=TCxt>$py8@V)#r7o+nBf4k@A(w77Nfx|9iyKVv= zZ(PkEBZG#uv(HrUU2371=YBg;>@qsJug!(jU zn3%$4+_i|~h|5@Af+=H?r5PFJ&mNAgdQX+Xq5fff#;)Ha|4D+ zquczx?G=KW4Hux_Zp!1X7wqyZE$F_qttp>7Y+SSKS zuA67u#(XN3uZrG4Jrd`W6o7tjH-%Y44RY&z?yztNU6?!8))@y?cknW6=Jls3ajg@&pJUvh`NFq0z5P7Dy63(B$`JiBHa;3OVJpzmsjs! zn(&CP{Z-v(Gd0`AK6VvK3b?VyaWYr8M#@BYEE0Vk6Ug8Ok`ZlrE;lxqwNGbNjGr5X z7Q@(Z2+j#-@ewb~`xRb*S+9xyG)ca0j~;Gq%{rU{y#r-|o#O92ux=51Hg>Yil&g#P zey8ffq)oKA_dyM_Um&mu`s(+wQ_NK3c9Vas@5cmI+Q=LqqYy=6qgDYsN7hsh@12 z4l#at+B$~a+w<&EQf9@ot43Itw$grBUIt9irM(6f-rTT}JLDWNIIMSgj6H-jf{S!t zwiP`hH!Te(Ux96Gg3bZ_H#$q1;?@V~N)qb%rta7~jAb%ad>vw$WTSfO5Kn>QARL8M zOapCeeWSrvGx&t!5a!;c!yUDjRYTgYU<{;Q5BYd;;;;bA*?J(;e`^xbVbxF2+}lx3BP_AsP<-SmSUBF|oR zwaZzUh``SG!tqACHY%hJ9D$md_!cbl+=K4#rqoVJD9i7gPE=gF_r{-2ZtD`;581|wDFHe zy14?yKp_TS#P4IO&0pIs`nZnitQ?o3s&cfuqZV2He;uMn`_HUnDu<_3+2C?ZZ>>P1 zb)WW=y5Sg}2oMS%HjTLCGr_IvY%Q_Sz^u`u=cxix&<{@b^2=j?=|P&y%G>f-%y&@K?0-1M7z)SQ$E7IvO)0@;D;J|JPe_BX5M zB8B`647gtYAr2uyqb@2c3eJ-;3P6GO)}+Mzpvk1lL||IR1FS`0)XLAuy6=0+wkl<# zNqp7MpUkdp+uAnS68C|+pilW3f@p58zVJpjwZb$Z$n~3k|6|X!av8#8ffW~Pld7oDf$b|ZlR;JUt_iQ(WQkkAIxm>r$9~9d@Nw_xx( zkZtL%K?|$xo$<^45w{8R?Rf?3F9YS4y1Ol7Mf-X{H~1AJiq3AwJ1ea?LPBS7%ygpMq^@Kl%p$ZzR_s(>m`Q zq9b{>aZ|dj?sHXDRgscnK#c4+)<2bPbw2j)+k3OJ*qpW`3}Y;GY^yFu$OZG6IuO>) zq64V|_Zx1#c?>@oTP`1Zab7=AHL$BF|B=o;DPhZhU~iJDD79v#_%KRSc1BMkbg{Wy5Hwsr}PQqH+eIbEtkUNT>VlG(xo?>&-Qku3G|St}fme>_;KX?aq2g z^z_z*cD9`H@7bEVtnYJuqdd9r4cgMo%;Z4AXDUGgb)=-Ij5Mcvc0NvGV%~3&(lm?h z+t@ie@_Yt4@?38i@)t0lyS2V&#qQJ7m*FQ$U-tFzO(WsWh!6-q8{2YuizTjlTajC9 zP>UTR(=yx`y`*w&*lJLd&$Spgr3f`Zs^nu#Yj!%@Q-_8+mSI<>;a+?$X@S9gwUV2Y z1<1b@RB$5zVr_U&86^kVs<80lG(p+<1!yiD6gUHgegej9fn?9gv3`sqbucj};Q+b_ zte$AJAUiw908A&O(P4Ouwq<+f>*PjQ+ULW#+8ZGUCLi+`jzHhY_ODw<8V6RbWbqk_2Ki3?QMYSRP z!CWj+_5uFyuzY@yU9moX3xEz+m~U8@qCq9=Re9O}PosWyVB@cK?{OEp&`Al=zMgu( z5!v2)z1yQc4SiTK<%hI*F=T5T%SZNM9%TzQEnRWY^Xh5{{-*DT;V_`L7~8F z^8t#|H2qU2_FJ>VpbVJX)R99Lnr~B#s~-{7DRtg3ptlfHa>zp>)+t@cYpJi zv!#5f4~S6|ciAcB>>;IH#xLm_y6pLoojv0Ki&h&Y<;TC{t>i;fI#4$mszwQ>c~3u8 zp9xMw=$alK67x5re#KJIi+3kO|2mgzf6TfU&KL9#S*cVFtSz#KRK>pvl3Yu)+)rv- z>LE*{fb50Rf`>~uRlK$GTO3{)GMvN&*X(Uc(pv?0W6!ys@25g(43je-K5%6aImK#{TnaLjIY?528^LI@_B@>RLBloLLgbKNG{MxW7o+c9UrT)(7AP=FZCvI zm+u*9ktd`>MHw(H4nUO;yOs*;e|UOA#fM4Wj{Rd2 zK~CP@iQ@DMO}5k5f$GoCyyY2WpN5lh=3;%WNO3I_Rv3E>I!NH4)0m{tIT6eC)~@wb zE0~a(x>ji1o^A#3dSnmX$r`4*1O$0MxwTbqcc(48x*Ep;gWpt=E56=*Z$2Xf9tI{? z2wVRtJaua;Gm43i^c0B3>`~2Bx0DqNu$$I&uf0{D^w44KCI`nQ>-pluT0BThOwP5}Hpd#OuZ1l>J zVV7OKRmNwGtN_$hZh3qcr)4Wkqbhss|99KBbI zbLElhz;T{_71H{CugmmW58qkA55T)TfPwC_SGk!!e))jnf)A=GeKJ54$r~zp;88_D zC>+y6KwIo|%l$o{8X?a0Wcgt;5PqIzpexOajk@~b=DGT&U8^G!5dlFk;hmfa2f~

!yUd+u50%!}=Mi8 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 z

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 literal 0 HcmV?d00001 From f367f783864040f0f2081040da580fe72de177f3 Mon Sep 17 00:00:00 2001 From: Alexander Alexandrov Date: Tue, 27 Feb 2024 12:03:07 +0200 Subject: [PATCH 07/13] =?UTF-8?q?explain,sql:=20rename=20`ExplainStage::{O?= =?UTF-8?q?ptimizedPlan=20=E2=87=92=20GlobalPlan}`?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/adapter/src/coord/sequencer/inner.rs | 4 +-- src/repr/src/explain/tracing.rs | 4 +-- src/sql-parser/src/ast/defs/statement.rs | 24 +++++++++----- src/sql-parser/src/parser.rs | 31 +++++++++--------- src/sql-parser/tests/testdata/explain | 40 ++++++++++++------------ src/sql/src/plan/statement/dml.rs | 19 +++++------ 6 files changed, 67 insertions(+), 55 deletions(-) diff --git a/src/adapter/src/coord/sequencer/inner.rs b/src/adapter/src/coord/sequencer/inner.rs index f1fc0fc8baa5c..d5d521386e44c 100644 --- a/src/adapter/src/coord/sequencer/inner.rs +++ b/src/adapter/src/coord/sequencer/inner.rs @@ -1915,7 +1915,7 @@ impl Coordinator { }; let explain = match stage { - ExplainStage::OptimizedPlan => { + ExplainStage::GlobalPlan => { let Some(plan) = self.catalog().try_get_optimized_plan(&id).cloned() else { tracing::error!("cannot find {stage} for materialized view {id} in catalog"); coord_bail!("cannot find {stage} for materialized view in catalog"); @@ -1974,7 +1974,7 @@ impl Coordinator { }; let explain = match stage { - ExplainStage::OptimizedPlan => { + ExplainStage::GlobalPlan => { let Some(plan) = self.catalog().try_get_optimized_plan(&id).cloned() else { tracing::error!("cannot find {stage} for index {id} in catalog"); coord_bail!("cannot find {stage} for index in catalog"); diff --git a/src/repr/src/explain/tracing.rs b/src/repr/src/explain/tracing.rs index 007f7ae440351..42f7de093f8e4 100644 --- a/src/repr/src/explain/tracing.rs +++ b/src/repr/src/explain/tracing.rs @@ -321,8 +321,8 @@ impl PlanTrace { // Compute the path from which we are going to lookup the `UsedIndexes` // instance from the requested path. let path = match NamedPlan::of_path(plan_path) { - Some(NamedPlan::Optimized) => Some(NamedPlan::Optimized), - Some(NamedPlan::Physical) => Some(NamedPlan::Optimized), + Some(NamedPlan::Global) => Some(NamedPlan::Global), + Some(NamedPlan::Physical) => Some(NamedPlan::Global), Some(NamedPlan::FastPath) => Some(NamedPlan::FastPath), _ => None, }; diff --git a/src/sql-parser/src/ast/defs/statement.rs b/src/sql-parser/src/ast/defs/statement.rs index ec33b972d1508..4787b081a3a88 100644 --- a/src/sql-parser/src/ast/defs/statement.rs +++ b/src/sql-parser/src/ast/defs/statement.rs @@ -3552,8 +3552,8 @@ pub enum ExplainStage { RawPlan, /// The mz_expr::MirRelationExpr after decorrelation DecorrelatedPlan, - /// The mz_expr::MirRelationExpr after optimization - OptimizedPlan, + /// The mz_expr::MirRelationExpr after global optimization + GlobalPlan, /// The mz_compute_types::plan::Plan PhysicalPlan, /// The complete trace of the plan through the optimizer @@ -3567,7 +3567,7 @@ impl ExplainStage { match self { Self::RawPlan => Some(Raw.path()), Self::DecorrelatedPlan => Some(Decorrelated.path()), - Self::OptimizedPlan => Some(Optimized.path()), + Self::GlobalPlan => Some(Global.path()), Self::PhysicalPlan => Some(Physical.path()), Self::Trace => None, } @@ -3579,7 +3579,7 @@ impl ExplainStage { match self { Self::RawPlan => false, Self::DecorrelatedPlan => false, - Self::OptimizedPlan => true, + Self::GlobalPlan => true, Self::PhysicalPlan => true, Self::Trace => false, } @@ -3591,7 +3591,7 @@ impl AstDisplay for ExplainStage { match self { Self::RawPlan => f.write_str("RAW PLAN"), Self::DecorrelatedPlan => f.write_str("DECORRELATED PLAN"), - Self::OptimizedPlan => f.write_str("OPTIMIZED PLAN"), + Self::GlobalPlan => f.write_str("OPTIMIZED PLAN"), Self::PhysicalPlan => f.write_str("PHYSICAL PLAN"), Self::Trace => f.write_str("OPTIMIZER TRACE"), } @@ -3604,7 +3604,7 @@ impl_display!(ExplainStage); pub enum NamedPlan { Raw, Decorrelated, - Optimized, + Global, Physical, FastPath, } @@ -3615,7 +3615,7 @@ impl NamedPlan { match value { "optimize/raw" => Some(Self::Raw), "optimize/hir_to_mir" => Some(Self::Decorrelated), - "optimize/global" => Some(Self::Optimized), + "optimize/global" => Some(Self::Global), "optimize/finalize_dataflow" => Some(Self::Physical), "optimize/fast_path" => Some(Self::FastPath), _ => None, @@ -3628,7 +3628,7 @@ impl NamedPlan { match self { Self::Raw => "optimize/raw", Self::Decorrelated => "optimize/hir_to_mir", - Self::Optimized => "optimize/global", + Self::Global => "optimize/global", Self::Physical => "optimize/finalize_dataflow", Self::FastPath => "optimize/fast_path", } @@ -3650,6 +3650,14 @@ pub enum Explainee { CreateIndex(Box>, bool), } +impl Explainee { + pub fn default_stage(&self) -> ExplainStage { + match self { + _ => ExplainStage::GlobalPlan, + } + } +} + impl AstDisplay for Explainee { fn fmt(&self, f: &mut AstFormatter) { match self { diff --git a/src/sql-parser/src/parser.rs b/src/sql-parser/src/parser.rs index 942d2705a15a5..15f89fb075b0f 100644 --- a/src/sql-parser/src/parser.rs +++ b/src/sql-parser/src/parser.rs @@ -7329,39 +7329,42 @@ impl<'a> Parser<'a> { /// Parse an `EXPLAIN ... PLAN` statement, assuming that the `EXPLAIN` token /// has already been consumed. fn parse_explain_plan(&mut self) -> Result, ParserError> { - let stage = match self.parse_one_of_keywords(&[ - PLAN, + let (expect_for, stage) = match self.parse_one_of_keywords(&[ RAW, DECORRELATED, OPTIMIZED, PHYSICAL, OPTIMIZER, + PLAN, ]) { - Some(PLAN) => { - // EXPLAIN PLAN = EXPLAIN OPTIMIZED PLAN - Some(ExplainStage::OptimizedPlan) - } Some(RAW) => { self.expect_keyword(PLAN)?; - Some(ExplainStage::RawPlan) + (true, Some(ExplainStage::RawPlan)) } Some(DECORRELATED) => { self.expect_keyword(PLAN)?; - Some(ExplainStage::DecorrelatedPlan) + (true, Some(ExplainStage::DecorrelatedPlan)) } Some(OPTIMIZED) => { self.expect_keyword(PLAN)?; - Some(ExplainStage::OptimizedPlan) + (true, Some(ExplainStage::GlobalPlan)) } Some(PHYSICAL) => { self.expect_keyword(PLAN)?; - Some(ExplainStage::PhysicalPlan) + (true, Some(ExplainStage::PhysicalPlan)) } Some(OPTIMIZER) => { self.expect_keyword(TRACE)?; - Some(ExplainStage::Trace) + (true, Some(ExplainStage::Trace)) + } + Some(PLAN) => { + // Use the default plan for the explainee. + (true, None) + } + None => { + // Use the default plan for the explainee. + (false, None) } - None => None, _ => unreachable!(), }; @@ -7390,14 +7393,14 @@ impl<'a> Parser<'a> { ExplainFormat::Text }; - if stage.is_some() { + if expect_for { self.expect_keyword(FOR)?; } let explainee = self.parse_explainee()?; Ok(Statement::ExplainPlan(ExplainPlanStatement { - stage: stage.unwrap_or(ExplainStage::OptimizedPlan), + stage: stage.unwrap_or_else(|| explainee.default_stage()), with_options, format, explainee, diff --git a/src/sql-parser/tests/testdata/explain b/src/sql-parser/tests/testdata/explain index 90085127b6bee..9654d4ac880fd 100644 --- a/src/sql-parser/tests/testdata/explain +++ b/src/sql-parser/tests/testdata/explain @@ -23,7 +23,7 @@ EXPLAIN SELECT 665 ---- EXPLAIN OPTIMIZED PLAN AS TEXT FOR SELECT 665 => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [], format: Text, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) parse-statement EXPLAIN RAW PLAN FOR SELECT 665 @@ -44,7 +44,7 @@ EXPLAIN OPTIMIZED PLAN FOR SELECT 665 ---- EXPLAIN OPTIMIZED PLAN AS TEXT FOR SELECT 665 => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [], format: Text, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) parse-statement EXPLAIN PHYSICAL PLAN FOR SELECT 665 @@ -58,77 +58,77 @@ EXPLAIN SELECT 665 ---- EXPLAIN OPTIMIZED PLAN AS TEXT FOR SELECT 665 => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [], format: Text, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) parse-statement EXPLAIN OPTIMIZED PLAN FOR VIEW foo ---- EXPLAIN OPTIMIZED PLAN AS TEXT FOR VIEW foo => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [], format: Text, explainee: View(Name(UnresolvedItemName([Ident("foo")]))) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: View(Name(UnresolvedItemName([Ident("foo")]))) }) parse-statement EXPLAIN OPTIMIZED PLAN FOR MATERIALIZED VIEW foo ---- EXPLAIN OPTIMIZED PLAN AS TEXT FOR MATERIALIZED VIEW foo => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [], format: Text, explainee: MaterializedView(Name(UnresolvedItemName([Ident("foo")]))) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: MaterializedView(Name(UnresolvedItemName([Ident("foo")]))) }) parse-statement EXPLAIN OPTIMIZED PLAN FOR INDEX foo ---- EXPLAIN OPTIMIZED PLAN AS TEXT FOR INDEX foo => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [], format: Text, explainee: Index(Name(UnresolvedItemName([Ident("foo")]))) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: Index(Name(UnresolvedItemName([Ident("foo")]))) }) parse-statement EXPLAIN OPTIMIZED PLAN FOR REPLAN VIEW foo ---- EXPLAIN OPTIMIZED PLAN AS TEXT FOR REPLAN VIEW foo => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [], format: Text, explainee: ReplanView(Name(UnresolvedItemName([Ident("foo")]))) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: ReplanView(Name(UnresolvedItemName([Ident("foo")]))) }) parse-statement EXPLAIN OPTIMIZED PLAN FOR REPLAN MATERIALIZED VIEW foo ---- EXPLAIN OPTIMIZED PLAN AS TEXT FOR REPLAN MATERIALIZED VIEW foo => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [], format: Text, explainee: ReplanMaterializedView(Name(UnresolvedItemName([Ident("foo")]))) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: ReplanMaterializedView(Name(UnresolvedItemName([Ident("foo")]))) }) parse-statement EXPLAIN OPTIMIZED PLAN FOR REPLAN INDEX foo ---- EXPLAIN OPTIMIZED PLAN AS TEXT FOR REPLAN INDEX foo => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [], format: Text, explainee: ReplanIndex(Name(UnresolvedItemName([Ident("foo")]))) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: ReplanIndex(Name(UnresolvedItemName([Ident("foo")]))) }) parse-statement EXPLAIN OPTIMIZED PLAN WITH(types) FOR VIEW foo ---- EXPLAIN OPTIMIZED PLAN WITH (TYPES) AS TEXT FOR VIEW foo => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [ExplainPlanOption { name: Types, value: None }], format: Text, explainee: View(Name(UnresolvedItemName([Ident("foo")]))) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [ExplainPlanOption { name: Types, value: None }], format: Text, explainee: View(Name(UnresolvedItemName([Ident("foo")]))) }) parse-statement EXPLAIN OPTIMIZED PLAN WITH(arity, types) FOR VIEW foo ---- EXPLAIN OPTIMIZED PLAN WITH (ARITY, TYPES) AS TEXT FOR VIEW foo => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [ExplainPlanOption { name: Arity, value: None }, ExplainPlanOption { name: Types, value: None }], format: Text, explainee: View(Name(UnresolvedItemName([Ident("foo")]))) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [ExplainPlanOption { name: Arity, value: None }, ExplainPlanOption { name: Types, value: None }], format: Text, explainee: View(Name(UnresolvedItemName([Ident("foo")]))) }) parse-statement EXPLAIN ((SELECT 1)) ---- EXPLAIN OPTIMIZED PLAN AS TEXT FOR SELECT 1 => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [], format: Text, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) parse-statement EXPLAIN OPTIMIZED PLAN AS TEXT FOR WITH a AS (SELECT 1) SELECT * FROM a ---- EXPLAIN OPTIMIZED PLAN AS TEXT FOR WITH a AS (SELECT 1) SELECT * FROM a => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [], format: Text, explainee: Select(SelectStatement { query: Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("a"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: Select(SelectStatement { query: Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("a"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) # regression test for #16029 parse-statement @@ -136,7 +136,7 @@ EXPLAIN WITH a AS (SELECT 1) SELECT * FROM a ---- EXPLAIN OPTIMIZED PLAN AS TEXT FOR WITH a AS (SELECT 1) SELECT * FROM a => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [], format: Text, explainee: Select(SelectStatement { query: Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("a"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: Select(SelectStatement { query: Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("a"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) parse-statement EXPLAIN TIMESTAMP FOR SELECT 1 @@ -150,7 +150,7 @@ EXPLAIN AS JSON SELECT * FROM foo ---- EXPLAIN OPTIMIZED PLAN AS JSON FOR SELECT * FROM foo => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [], format: Json, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("foo")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Json, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("foo")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) parse-statement EXPLAIN OPTIMIZER TRACE WITH (types) AS TEXT FOR BROKEN SELECT 1 + 1 @@ -166,28 +166,28 @@ EXPLAIN WITH (humanized expressions) CREATE MATERIALIZED VIEW mv AS SELECT 665 ---- EXPLAIN OPTIMIZED PLAN WITH (HUMANIZED EXPRESSIONS) AS TEXT FOR CREATE MATERIALIZED VIEW mv AS SELECT 665 => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [ExplainPlanOption { name: HumanizedExpressions, value: None }], format: Text, explainee: CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("mv")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }, false) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [ExplainPlanOption { name: HumanizedExpressions, value: None }], format: Text, explainee: CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("mv")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }, false) }) parse-statement EXPLAIN BROKEN CREATE MATERIALIZED VIEW mv AS SELECT 665 ---- EXPLAIN OPTIMIZED PLAN AS TEXT FOR BROKEN CREATE MATERIALIZED VIEW mv AS SELECT 665 => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [], format: Text, explainee: CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("mv")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }, true) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("mv")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }, true) }) parse-statement EXPLAIN BROKEN CREATE DEFAULT INDEX ON q1 ---- EXPLAIN OPTIMIZED PLAN AS TEXT FOR BROKEN CREATE DEFAULT INDEX ON q1 => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [], format: Text, explainee: CreateIndex(CreateIndexStatement { name: None, in_cluster: None, on_name: Name(UnresolvedItemName([Ident("q1")])), key_parts: None, with_options: [], if_not_exists: false }, true) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: CreateIndex(CreateIndexStatement { name: None, in_cluster: None, on_name: Name(UnresolvedItemName([Ident("q1")])), key_parts: None, with_options: [], if_not_exists: false }, true) }) parse-statement EXPLAIN OPTIMIZED PLAN FOR CREATE INDEX ON v(auction_id) ---- EXPLAIN OPTIMIZED PLAN AS TEXT FOR CREATE INDEX ON v (auction_id) => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [], format: Text, explainee: CreateIndex(CreateIndexStatement { name: None, in_cluster: None, on_name: Name(UnresolvedItemName([Ident("v")])), key_parts: Some([Identifier([Ident("auction_id")])]), with_options: [], if_not_exists: false }, false) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: CreateIndex(CreateIndexStatement { name: None, in_cluster: None, on_name: Name(UnresolvedItemName([Ident("v")])), key_parts: Some([Identifier([Ident("auction_id")])]), with_options: [], if_not_exists: false }, false) }) parse-statement EXPLAIN VALUE SCHEMA AS TEXT FOR CREATE SINK foo FROM bar INTO KAFKA CONNECTION baz (TOPIC 'topic') FORMAT AVRO USING CONFLUENT SCHEMA REGISTRY CONNECTION conn2 ENVELOPE UPSERT @@ -222,7 +222,7 @@ EXPLAIN SELECT 665 AS OF 3 ---- EXPLAIN OPTIMIZED PLAN AS TEXT FOR SELECT 665 AS OF 3 => -ExplainPlan(ExplainPlanStatement { stage: OptimizedPlan, with_options: [], format: Text, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(At(Value(Number("3")))) }, false) }) +ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(At(Value(Number("3")))) }, false) }) parse-statement EXPLAIN FILTER PUSHDOWN FOR SELECT * FROM numbers where value > 10 diff --git a/src/sql/src/plan/statement/dml.rs b/src/sql/src/plan/statement/dml.rs index b75e75c7a4aad..493c1d09f4748 100644 --- a/src/sql/src/plan/statement/dml.rs +++ b/src/sql/src/plan/statement/dml.rs @@ -255,20 +255,21 @@ pub fn describe_explain_plan( match stage { ExplainStage::RawPlan => { - relation_desc = - relation_desc.with_column("Raw Plan", ScalarType::String.nullable(false)); + let name = "Raw Plan"; + relation_desc = relation_desc.with_column(name, ScalarType::String.nullable(false)); } ExplainStage::DecorrelatedPlan => { - relation_desc = - relation_desc.with_column("Decorrelated Plan", ScalarType::String.nullable(false)); + let name = "Decorrelated Plan"; + relation_desc = relation_desc.with_column(name, ScalarType::String.nullable(false)); } - ExplainStage::OptimizedPlan => { - relation_desc = - relation_desc.with_column("Optimized Plan", ScalarType::String.nullable(false)); + } + ExplainStage::GlobalPlan => { + let name = "Optimized Plan"; + relation_desc = relation_desc.with_column(name, ScalarType::String.nullable(false)); } ExplainStage::PhysicalPlan => { - relation_desc = - relation_desc.with_column("Physical Plan", ScalarType::String.nullable(false)); + let name = "Physical Plan"; + relation_desc = relation_desc.with_column(name, ScalarType::String.nullable(false)); } ExplainStage::Trace => { relation_desc = relation_desc From d8f58a422fe9879e83ad1da070defbe90a76fd68 Mon Sep 17 00:00:00 2001 From: Alexander Alexandrov Date: Tue, 27 Feb 2024 12:29:20 +0200 Subject: [PATCH 08/13] explain,sql: support `EXPLAIN ... VIEW` variants Add parser and planner support for the following `EXPLAIN ... VIEW` statements: - `EXPLAIN CREATE VIEW ...` - `EXPLAIN REPLAN VIEW ...` - `EXPLAIN VIEW ...` To do this, introduce new enum variants `ExplainStage::LocalPlan` and `NamedPlan::Local` that correspond to the `optimize/local` stage and teach the parser to default to this stage for the above variants if an explicitly defined stage is not present. --- src/adapter/src/coord/sequencer/inner.rs | 12 +++++++ src/adapter/src/explain/mod.rs | 28 +++++++++++++++ src/sql-lexer/src/keywords.txt | 1 + src/sql-parser/src/ast/defs/statement.rs | 16 +++++++++ src/sql-parser/src/parser.rs | 18 +++++++++- src/sql-parser/tests/testdata/explain | 28 +++++++++++++++ src/sql/src/plan.rs | 18 ++++++++-- src/sql/src/plan/statement/dml.rs | 46 ++++++++++++++++++------ src/sql/src/rbac.rs | 8 +++-- 9 files changed, 159 insertions(+), 16 deletions(-) diff --git a/src/adapter/src/coord/sequencer/inner.rs b/src/adapter/src/coord/sequencer/inner.rs index d5d521386e44c..5652d13cf3a1a 100644 --- a/src/adapter/src/coord/sequencer/inner.rs +++ b/src/adapter/src/coord/sequencer/inner.rs @@ -1861,6 +1861,10 @@ impl Coordinator { ) { match &plan.explainee { plan::Explainee::Statement(stmt) => match stmt { + plan::ExplaineeStatement::CreateView { .. } => { + let msg = "EXPLAIN CREATE VIEW is currently not supported"; + ctx.retire(Err(AdapterError::Unsupported(msg))); + } plan::ExplaineeStatement::CreateMaterializedView { .. } => { self.explain_create_materialized_view(ctx, plan).await; } @@ -1871,6 +1875,10 @@ impl Coordinator { self.explain_peek(ctx, plan, target_cluster).await; } }, + plan::Explainee::View(_) => { + let msg = "EXPLAIN VIEW is currently not supported"; + ctx.retire(Err(AdapterError::Unsupported(msg))); + } plan::Explainee::MaterializedView(_) => { let result = self.explain_materialized_view(&ctx, plan); ctx.retire(result); @@ -1879,6 +1887,10 @@ impl Coordinator { let result = self.explain_index(&ctx, plan); ctx.retire(result); } + plan::Explainee::ReplanView(_) => { + let msg = "EXPLAIN REPLAN VIEW is currently not supported"; + ctx.retire(Err(AdapterError::Unsupported(msg))); + } plan::Explainee::ReplanMaterializedView(_) => { self.explain_replan_materialized_view(ctx, plan).await; } diff --git a/src/adapter/src/explain/mod.rs b/src/adapter/src/explain/mod.rs index b5d7f24e4a981..c3b7a82ea3433 100644 --- a/src/adapter/src/explain/mod.rs +++ b/src/adapter/src/explain/mod.rs @@ -74,3 +74,31 @@ where Ok(Explainable::new(&mut plan).explain(&format, &context)?) } + +/// Convenience method to explain a single plan. +/// +/// In the long term, this method and [`explain_dataflow`] should be unified. In +/// order to do that, however, we first need to generalize the role +/// [`DataflowMetainfo`] as a carrier of metainformation for the optimization +/// pass in general, and not for a specific strucutre representing an +/// intermediate result. +pub(crate) fn explain_plan( + mut plan: T, + format: ExplainFormat, + config: &ExplainConfig, + humanizer: &dyn ExprHumanizer, +) -> Result +where + for<'a> Explainable<'a, T>: Explain<'a, Context = ExplainContext<'a>>, +{ + let context = ExplainContext { + config, + humanizer, + used_indexes: Default::default(), + finishing: Default::default(), + duration: Default::default(), + optimizer_notices: Default::default(), + }; + + Ok(Explainable::new(&mut plan).explain(&format, &context)?) +} diff --git a/src/sql-lexer/src/keywords.txt b/src/sql-lexer/src/keywords.txt index 4adfa979946e7..d8853065ed78d 100644 --- a/src/sql-lexer/src/keywords.txt +++ b/src/sql-lexer/src/keywords.txt @@ -232,6 +232,7 @@ Linear List Load Local +Locally Log Logical Login diff --git a/src/sql-parser/src/ast/defs/statement.rs b/src/sql-parser/src/ast/defs/statement.rs index 4787b081a3a88..28d726f8b96f1 100644 --- a/src/sql-parser/src/ast/defs/statement.rs +++ b/src/sql-parser/src/ast/defs/statement.rs @@ -3552,6 +3552,8 @@ pub enum ExplainStage { RawPlan, /// The mz_expr::MirRelationExpr after decorrelation DecorrelatedPlan, + /// The mz_expr::MirRelationExpr after local optimization + LocalPlan, /// The mz_expr::MirRelationExpr after global optimization GlobalPlan, /// The mz_compute_types::plan::Plan @@ -3567,6 +3569,7 @@ impl ExplainStage { match self { Self::RawPlan => Some(Raw.path()), Self::DecorrelatedPlan => Some(Decorrelated.path()), + Self::LocalPlan => Some(Local.path()), Self::GlobalPlan => Some(Global.path()), Self::PhysicalPlan => Some(Physical.path()), Self::Trace => None, @@ -3579,6 +3582,7 @@ impl ExplainStage { match self { Self::RawPlan => false, Self::DecorrelatedPlan => false, + Self::LocalPlan => false, Self::GlobalPlan => true, Self::PhysicalPlan => true, Self::Trace => false, @@ -3591,6 +3595,7 @@ impl AstDisplay for ExplainStage { match self { Self::RawPlan => f.write_str("RAW PLAN"), Self::DecorrelatedPlan => f.write_str("DECORRELATED PLAN"), + Self::LocalPlan => f.write_str("LOCALLY OPTIMIZED PLAN"), Self::GlobalPlan => f.write_str("OPTIMIZED PLAN"), Self::PhysicalPlan => f.write_str("PHYSICAL PLAN"), Self::Trace => f.write_str("OPTIMIZER TRACE"), @@ -3604,6 +3609,7 @@ impl_display!(ExplainStage); pub enum NamedPlan { Raw, Decorrelated, + Local, Global, Physical, FastPath, @@ -3615,6 +3621,7 @@ impl NamedPlan { match value { "optimize/raw" => Some(Self::Raw), "optimize/hir_to_mir" => Some(Self::Decorrelated), + "optimize/local" => Some(Self::Local), "optimize/global" => Some(Self::Global), "optimize/finalize_dataflow" => Some(Self::Physical), "optimize/fast_path" => Some(Self::FastPath), @@ -3628,6 +3635,7 @@ impl NamedPlan { match self { Self::Raw => "optimize/raw", Self::Decorrelated => "optimize/hir_to_mir", + Self::Local => "optimize/local", Self::Global => "optimize/global", Self::Physical => "optimize/finalize_dataflow", Self::FastPath => "optimize/fast_path", @@ -3646,6 +3654,7 @@ pub enum Explainee { ReplanMaterializedView(T::ItemName), ReplanIndex(T::ItemName), Select(Box>, bool), + CreateView(Box>, bool), CreateMaterializedView(Box>, bool), CreateIndex(Box>, bool), } @@ -3653,6 +3662,7 @@ pub enum Explainee { impl Explainee { pub fn default_stage(&self) -> ExplainStage { match self { + Self::View(_) | Self::ReplanView(_) | Self::CreateView(_, _) => ExplainStage::LocalPlan, _ => ExplainStage::GlobalPlan, } } @@ -3691,6 +3701,12 @@ impl AstDisplay for Explainee { } f.write_node(select); } + Self::CreateView(statement, broken) => { + if *broken { + f.write_str("BROKEN "); + } + f.write_node(statement); + } Self::CreateMaterializedView(statement, broken) => { if *broken { f.write_str("BROKEN "); diff --git a/src/sql-parser/src/parser.rs b/src/sql-parser/src/parser.rs index 15f89fb075b0f..51b0b539f4a96 100644 --- a/src/sql-parser/src/parser.rs +++ b/src/sql-parser/src/parser.rs @@ -7295,7 +7295,18 @@ impl<'a> Parser<'a> { } else { let broken = self.parse_keyword(BROKEN); - if self.peek_keywords(&[CREATE, MATERIALIZED, VIEW]) + if self.peek_keywords(&[CREATE, VIEW]) + || self.peek_keywords(&[CREATE, OR, REPLACE, VIEW]) + { + // Parse: `BROKEN? CREATE [OR REPLACE] VIEW ...` + let _ = self.parse_keyword(CREATE); // consume CREATE token + let stmt = match self.parse_create_view()? { + Statement::CreateView(stmt) => stmt, + _ => panic!("Unexpected statement type return after parsing"), + }; + + Explainee::CreateView(Box::new(stmt), broken) + } else if self.peek_keywords(&[CREATE, MATERIALIZED, VIEW]) || self.peek_keywords(&[CREATE, OR, REPLACE, MATERIALIZED, VIEW]) { // Parse: `BROKEN? CREATE [OR REPLACE] MATERIALIZED VIEW ...` @@ -7332,6 +7343,7 @@ impl<'a> Parser<'a> { let (expect_for, stage) = match self.parse_one_of_keywords(&[ RAW, DECORRELATED, + LOCALLY, OPTIMIZED, PHYSICAL, OPTIMIZER, @@ -7345,6 +7357,10 @@ impl<'a> Parser<'a> { self.expect_keyword(PLAN)?; (true, Some(ExplainStage::DecorrelatedPlan)) } + Some(LOCALLY) => { + self.expect_keywords(&[OPTIMIZED, PLAN])?; + (true, Some(ExplainStage::LocalPlan)) + } Some(OPTIMIZED) => { self.expect_keyword(PLAN)?; (true, Some(ExplainStage::GlobalPlan)) diff --git a/src/sql-parser/tests/testdata/explain b/src/sql-parser/tests/testdata/explain index 9654d4ac880fd..7509c7349989c 100644 --- a/src/sql-parser/tests/testdata/explain +++ b/src/sql-parser/tests/testdata/explain @@ -88,6 +88,13 @@ EXPLAIN OPTIMIZED PLAN AS TEXT FOR REPLAN VIEW foo => ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: ReplanView(Name(UnresolvedItemName([Ident("foo")]))) }) +parse-statement +EXPLAIN PLAN FOR REPLAN VIEW foo +---- +EXPLAIN LOCALLY OPTIMIZED PLAN AS TEXT FOR REPLAN VIEW foo +=> +ExplainPlan(ExplainPlanStatement { stage: LocalPlan, with_options: [], format: Text, explainee: ReplanView(Name(UnresolvedItemName([Ident("foo")]))) }) + parse-statement EXPLAIN OPTIMIZED PLAN FOR REPLAN MATERIALIZED VIEW foo ---- @@ -102,6 +109,13 @@ EXPLAIN OPTIMIZED PLAN AS TEXT FOR REPLAN INDEX foo => ExplainPlan(ExplainPlanStatement { stage: GlobalPlan, with_options: [], format: Text, explainee: ReplanIndex(Name(UnresolvedItemName([Ident("foo")]))) }) +parse-statement +EXPLAIN PLAN FOR VIEW foo +---- +EXPLAIN LOCALLY OPTIMIZED PLAN AS TEXT FOR VIEW foo +=> +ExplainPlan(ExplainPlanStatement { stage: LocalPlan, with_options: [], format: Text, explainee: View(Name(UnresolvedItemName([Ident("foo")]))) }) + parse-statement EXPLAIN OPTIMIZED PLAN WITH(types) FOR VIEW foo ---- @@ -161,6 +175,20 @@ ExplainPlan(ExplainPlanStatement { stage: Trace, with_options: [ExplainPlanOptio # TODO (aalexandrov): Add negative tests for new explain API. +parse-statement +EXPLAIN CREATE VIEW mv AS SELECT 665 +---- +EXPLAIN LOCALLY OPTIMIZED PLAN AS TEXT FOR CREATE VIEW mv AS SELECT 665 +=> +ExplainPlan(ExplainPlanStatement { stage: LocalPlan, with_options: [], format: Text, explainee: CreateView(CreateViewStatement { if_exists: Error, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("mv")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } } }, false) }) + +parse-statement +EXPLAIN CREATE OR REPLACE VIEW mv AS SELECT 665 +---- +EXPLAIN LOCALLY OPTIMIZED PLAN AS TEXT FOR CREATE OR REPLACE VIEW mv AS SELECT 665 +=> +ExplainPlan(ExplainPlanStatement { stage: LocalPlan, with_options: [], format: Text, explainee: CreateView(CreateViewStatement { if_exists: Replace, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("mv")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } } }, false) }) + parse-statement EXPLAIN WITH (humanized expressions) CREATE MATERIALIZED VIEW mv AS SELECT 665 ---- diff --git a/src/sql/src/plan.rs b/src/sql/src/plan.rs index 202defe94d3b0..1325508eaa928 100644 --- a/src/sql/src/plan.rs +++ b/src/sql/src/plan.rs @@ -605,7 +605,7 @@ pub struct CreateTablePlan { pub if_not_exists: bool, } -#[derive(Debug)] +#[derive(Debug, Clone)] pub struct CreateViewPlan { pub name: QualifiedItemName, pub view: View, @@ -806,10 +806,14 @@ pub struct ExplainPlanPlan { /// The type of object to be explained #[derive(Clone, Debug)] pub enum Explainee { + /// Lookup and explain a plan saved for an view. + View(GlobalId), /// Lookup and explain a plan saved for an existing materialized view. MaterializedView(GlobalId), /// Lookup and explain a plan saved for an existing index. Index(GlobalId), + /// Replan an existing view. + ReplanView(GlobalId), /// Replan an existing materialized view. ReplanMaterializedView(GlobalId), /// Replan an existing index. @@ -829,6 +833,12 @@ pub enum ExplaineeStatement { plan: plan::SelectPlan, desc: RelationDesc, }, + /// The object to be explained is a CREATE VIEW. + CreateView { + /// Broken flag (see [`ExplaineeStatement::broken()`]). + broken: bool, + plan: plan::CreateViewPlan, + }, /// The object to be explained is a CREATE MATERIALIZED VIEW. CreateMaterializedView { /// Broken flag (see [`ExplaineeStatement::broken()`]). @@ -847,6 +857,7 @@ impl ExplaineeStatement { pub fn depends_on(&self) -> BTreeSet { match self { Self::Select { plan, .. } => plan.source.depends_on(), + Self::CreateView { plan, .. } => plan.view.expr.depends_on(), Self::CreateMaterializedView { plan, .. } => plan.materialized_view.expr.depends_on(), Self::CreateIndex { plan, .. } => btreeset! {plan.index.on}, } @@ -865,6 +876,7 @@ impl ExplaineeStatement { pub fn broken(&self) -> bool { match self { Self::Select { broken, .. } => *broken, + Self::CreateView { broken, .. } => *broken, Self::CreateMaterializedView { broken, .. } => *broken, Self::CreateIndex { broken, .. } => *broken, } @@ -876,8 +888,9 @@ impl ExplaineeStatementKind { use ExplainStage::*; match self { Self::Select => true, + Self::CreateView => ![GlobalPlan, PhysicalPlan].contains(stage), Self::CreateMaterializedView => true, - Self::CreateIndex => ![RawPlan, DecorrelatedPlan].contains(stage), + Self::CreateIndex => ![RawPlan, DecorrelatedPlan, LocalPlan].contains(stage), } } } @@ -886,6 +899,7 @@ impl std::fmt::Display for ExplaineeStatementKind { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::Select => write!(f, "SELECT"), + Self::CreateView => write!(f, "CREATE VIEW"), Self::CreateMaterializedView => write!(f, "CREATE MATERIALIZED VIEW"), Self::CreateIndex => write!(f, "CREATE INDEX"), } diff --git a/src/sql/src/plan/statement/dml.rs b/src/sql/src/plan/statement/dml.rs index 493c1d09f4748..fec18713f7f63 100644 --- a/src/sql/src/plan/statement/dml.rs +++ b/src/sql/src/plan/statement/dml.rs @@ -262,6 +262,9 @@ pub fn describe_explain_plan( let name = "Decorrelated Plan"; relation_desc = relation_desc.with_column(name, ScalarType::String.nullable(false)); } + ExplainStage::LocalPlan => { + let name = "Locally Optimized Plan"; + relation_desc = relation_desc.with_column(name, ScalarType::String.nullable(false)); } ExplainStage::GlobalPlan => { let name = "Optimized Plan"; @@ -405,16 +408,20 @@ fn plan_explainee( let is_replan = matches!( explainee, - Explainee::ReplanView(_) | Explainee::ReplanMaterializedView(_) | Explainee::ReplanIndex(_), + Explainee::ReplanView(_) | Explainee::ReplanMaterializedView(_) | Explainee::ReplanIndex(_) ); let explainee = match explainee { - Explainee::View(_) | Explainee::ReplanView(_) => { - bail_never_supported!( - "EXPLAIN ... VIEW ", - "sql/explain-plan", - "Use `EXPLAIN ... SELECT * FROM ` (if the view is not indexed) or `EXPLAIN ... INDEX ` (if the view is indexed) instead." - ); + Explainee::View(name) | Explainee::ReplanView(name) => { + let item = scx.get_item_by_resolved_name(&name)?; + let item_type = item.item_type(); + if item_type != CatalogItemType::View { + sql_bail!("Expected {name} to be a view, not a {item_type}"); + } + match is_replan { + true => crate::plan::Explainee::ReplanView(item.id()), + false => crate::plan::Explainee::View(item.id()), + } } Explainee::MaterializedView(name) | Explainee::ReplanMaterializedView(name) => { let item = scx.get_item_by_resolved_name(&name)?; @@ -439,15 +446,32 @@ fn plan_explainee( } } Explainee::Select(select, broken) => { - let copy_to = None; - let (plan, desc) = plan_select_inner(scx, *select, params, copy_to)?; - + let (plan, desc) = plan_select_inner(scx, *select, params, None)?; if broken { scx.require_feature_flag(&vars::ENABLE_EXPLAIN_BROKEN)?; } - crate::plan::Explainee::Statement(ExplaineeStatement::Select { broken, plan, desc }) } + Explainee::CreateView(mut stmt, broken) => { + if stmt.if_exists != IfExistsBehavior::Skip { + // If we don't force this parameter to Skip planning will + // fail for names that already exist in the catalog. This + // can happen even in `Replace` mode if the existing item + // has dependencies. + stmt.if_exists = IfExistsBehavior::Skip; + } else { + sql_bail!( + "Cannot EXPLAIN a CREATE VIEW that explictly sets IF NOT EXISTS \ + (the behavior is implied within the scope of an enclosing EXPLAIN)" + ); + } + + let Plan::CreateView(plan) = ddl::plan_create_view(scx, *stmt, params)? else { + sql_bail!("expected CreateViewPlan plan"); + }; + + crate::plan::Explainee::Statement(ExplaineeStatement::CreateView { broken, plan }) + } Explainee::CreateMaterializedView(mut stmt, broken) => { if stmt.if_exists != IfExistsBehavior::Skip { // If we don't force this parameter to Skip planning will diff --git a/src/sql/src/rbac.rs b/src/sql/src/rbac.rs index 7a2593cde274c..5d747ad7405aa 100644 --- a/src/sql/src/rbac.rs +++ b/src/sql/src/rbac.rs @@ -767,8 +767,10 @@ fn generate_rbac_requirements( }) | Plan::ExplainPushdown(plan::ExplainPushdownPlan { explainee }) => RbacRequirements { privileges: match explainee { - Explainee::MaterializedView(id) + Explainee::View(id) + | Explainee::MaterializedView(id) | Explainee::Index(id) + | Explainee::ReplanView(id) | Explainee::ReplanMaterializedView(id) | Explainee::ReplanIndex(id) => { let item = catalog.get_item(id); @@ -786,8 +788,10 @@ fn generate_rbac_requirements( .collect(), }, item_usage: match explainee { - Explainee::MaterializedView(..) + Explainee::View(..) + | Explainee::MaterializedView(..) | Explainee::Index(..) + | Explainee::ReplanView(..) | Explainee::ReplanMaterializedView(..) | Explainee::ReplanIndex(..) => &EMPTY_ITEM_USAGE, Explainee::Statement(_) => &DEFAULT_ITEM_USAGE, From 9c150f7135de180c55cbbf48d3562c6d275086c6 Mon Sep 17 00:00:00 2001 From: Alexander Alexandrov Date: Tue, 27 Feb 2024 11:49:32 +0200 Subject: [PATCH 09/13] explain,coord: implement `EXPLAIN ... VIEW` variants Add coordinator support for sequencing the following `EXPLAIN ... VIEW` statements: - `EXPLAIN CREATE VIEW ...` - `EXPLAIN REPLAN VIEW ...` - `EXPLAIN VIEW ...` --- src/adapter/src/coord.rs | 12 + src/adapter/src/coord/sequencer/inner.rs | 10 +- .../src/coord/sequencer/inner/create_view.rs | 287 ++++++++++++++++-- src/adapter/src/optimize/view.rs | 5 +- 4 files changed, 289 insertions(+), 25 deletions(-) diff --git a/src/adapter/src/coord.rs b/src/adapter/src/coord.rs index 7274c08cad293..0dd961114e49e 100644 --- a/src/adapter/src/coord.rs +++ b/src/adapter/src/coord.rs @@ -558,6 +558,7 @@ pub struct CreateIndexExplain { pub enum CreateViewStage { Optimize(CreateViewOptimize), Finish(CreateViewFinish), + Explain(CreateViewExplain), } #[derive(Debug)] @@ -565,6 +566,9 @@ pub struct CreateViewOptimize { validity: PlanValidity, plan: plan::CreateViewPlan, resolved_ids: ResolvedIds, + /// An optional context set iff the state machine is initiated from + /// sequencing an EXPALIN for this statement. + explain_ctx: ExplainContext, } #[derive(Debug)] @@ -576,6 +580,14 @@ pub struct CreateViewFinish { optimized_expr: OptimizedMirRelationExpr, } +#[derive(Debug)] +pub struct CreateViewExplain { + validity: PlanValidity, + id: GlobalId, + plan: plan::CreateViewPlan, + explain_ctx: ExplainPlanContext, +} + #[derive(Debug)] pub enum ExplainContext { /// The ordinary, non-explain variant of the statement. diff --git a/src/adapter/src/coord/sequencer/inner.rs b/src/adapter/src/coord/sequencer/inner.rs index 5652d13cf3a1a..cc71b0555eb8e 100644 --- a/src/adapter/src/coord/sequencer/inner.rs +++ b/src/adapter/src/coord/sequencer/inner.rs @@ -1862,8 +1862,7 @@ impl Coordinator { match &plan.explainee { plan::Explainee::Statement(stmt) => match stmt { plan::ExplaineeStatement::CreateView { .. } => { - let msg = "EXPLAIN CREATE VIEW is currently not supported"; - ctx.retire(Err(AdapterError::Unsupported(msg))); + self.explain_create_view(ctx, plan).await; } plan::ExplaineeStatement::CreateMaterializedView { .. } => { self.explain_create_materialized_view(ctx, plan).await; @@ -1876,8 +1875,8 @@ impl Coordinator { } }, plan::Explainee::View(_) => { - let msg = "EXPLAIN VIEW is currently not supported"; - ctx.retire(Err(AdapterError::Unsupported(msg))); + let result = self.explain_view(&ctx, plan); + ctx.retire(result); } plan::Explainee::MaterializedView(_) => { let result = self.explain_materialized_view(&ctx, plan); @@ -1888,8 +1887,7 @@ impl Coordinator { ctx.retire(result); } plan::Explainee::ReplanView(_) => { - let msg = "EXPLAIN REPLAN VIEW is currently not supported"; - ctx.retire(Err(AdapterError::Unsupported(msg))); + self.explain_replan_view(ctx, plan).await; } plan::Explainee::ReplanMaterializedView(_) => { self.explain_replan_materialized_view(ctx, plan).await; diff --git a/src/adapter/src/coord/sequencer/inner/create_view.rs b/src/adapter/src/coord/sequencer/inner/create_view.rs index eb35795a03273..2bb044449357e 100644 --- a/src/adapter/src/coord/sequencer/inner/create_view.rs +++ b/src/adapter/src/coord/sequencer/inner/create_view.rs @@ -7,10 +7,13 @@ // the Business Source License, use of this software will be governed // by the Apache License, Version 2.0. +use maplit::btreemap; use mz_catalog::memory::objects::{CatalogItem, View}; use mz_expr::CollectionPlan; use mz_ore::instrument; -use mz_repr::RelationDesc; +use mz_repr::explain::{ExprHumanizerExt, TransientItem}; +use mz_repr::{Datum, RelationDesc, Row}; +use mz_sql::ast::ExplainStage; use mz_sql::catalog::CatalogError; use mz_sql::names::{ObjectId, ResolvedIds}; use mz_sql::plan::{self}; @@ -19,11 +22,13 @@ use tracing::Span; use crate::command::ExecuteResponse; use crate::coord::sequencer::inner::return_if_err; use crate::coord::{ - Coordinator, CreateViewFinish, CreateViewOptimize, CreateViewStage, Message, PlanValidity, - StageResult, Staged, + Coordinator, CreateViewExplain, CreateViewFinish, CreateViewOptimize, CreateViewStage, + ExplainContext, ExplainPlanContext, Message, PlanValidity, StageResult, Staged, }; use crate::error::AdapterError; -use crate::optimize::{self, Optimize}; +use crate::explain::explain_plan; +use crate::explain::optimizer_trace::OptimizerTrace; +use crate::optimize::{self, Optimize, OverrideFrom}; use crate::session::Session; use crate::{catalog, AdapterNotice, ExecuteContext}; @@ -32,6 +37,7 @@ impl Staged for CreateViewStage { match self { Self::Optimize(stage) => &mut stage.validity, Self::Finish(stage) => &mut stage.validity, + Self::Explain(stage) => &mut stage.validity, } } @@ -43,6 +49,7 @@ impl Staged for CreateViewStage { match self { CreateViewStage::Optimize(stage) => coord.create_view_optimize(stage).await, CreateViewStage::Finish(stage) => coord.create_view_finish(ctx.session(), stage).await, + CreateViewStage::Explain(stage) => coord.create_view_explain(ctx.session(), stage), } } @@ -63,18 +70,157 @@ impl Coordinator { resolved_ids: ResolvedIds, ) { let stage = return_if_err!( - self.create_view_validate(ctx.session(), plan, resolved_ids), + self.create_view_validate(ctx.session(), plan, resolved_ids, ExplainContext::None), ctx ); self.sequence_staged(ctx, Span::current(), stage).await; } + #[instrument] + pub(crate) async fn explain_create_view( + &mut self, + ctx: ExecuteContext, + plan::ExplainPlanPlan { + stage, + format, + config, + explainee, + }: plan::ExplainPlanPlan, + ) { + let plan::Explainee::Statement(stmt) = explainee else { + // This is currently asserted in the `sequence_explain_plan` code that + // calls this method. + unreachable!() + }; + let plan::ExplaineeStatement::CreateView { broken, plan } = stmt else { + // This is currently asserted in the `sequence_explain_plan` code that + // calls this method. + unreachable!() + }; + + // Create an OptimizerTrace instance to collect plans emitted when + // executing the optimizer pipeline. + let optimizer_trace = OptimizerTrace::new(broken, stage.path()); + + // Not used in the EXPLAIN path so it's OK to generate a dummy value. + let resolved_ids = ResolvedIds(Default::default()); + + let explain_ctx = ExplainContext::Plan(ExplainPlanContext { + broken, + config, + format, + stage, + replan: None, + desc: None, + optimizer_trace, + }); + let stage = return_if_err!( + self.create_view_validate(ctx.session(), plan, resolved_ids, explain_ctx), + ctx + ); + self.sequence_staged(ctx, Span::current(), stage).await; + } + + #[instrument] + pub(crate) async fn explain_replan_view( + &mut self, + ctx: ExecuteContext, + plan::ExplainPlanPlan { + stage, + format, + config, + explainee, + }: plan::ExplainPlanPlan, + ) { + let plan::Explainee::ReplanView(id) = explainee else { + unreachable!() // Asserted in `sequence_explain_plan`. + }; + let CatalogItem::View(item) = self.catalog().get_entry(&id).item() else { + unreachable!() // Asserted in `plan_explain_plan`. + }; + + let state = self.catalog().state(); + let plan_result = state.deserialize_plan(id, item.create_sql.clone(), true); + let (plan, resolved_ids) = return_if_err!(plan_result, ctx); + + let plan::Plan::CreateView(plan) = plan else { + unreachable!() // We are parsing the `create_sql` of a `MaterializedView` item. + }; + + // It is safe to assume that query optimization will always succeed, so + // for now we statically assume `broken = false`. + let broken = false; + + // Create an OptimizerTrace instance to collect plans emitted when + // executing the optimizer pipeline. + let optimizer_trace = OptimizerTrace::new(broken, stage.path()); + + let explain_ctx = ExplainContext::Plan(ExplainPlanContext { + broken, + config, + format, + stage, + replan: Some(id), + desc: None, + optimizer_trace, + }); + let stage = return_if_err!( + self.create_view_validate(ctx.session(), plan, resolved_ids, explain_ctx), + ctx + ); + self.sequence_staged(ctx, Span::current(), stage).await; + } + + #[instrument] + pub(crate) fn explain_view( + &mut self, + ctx: &ExecuteContext, + plan::ExplainPlanPlan { + stage, + format, + config, + explainee, + }: plan::ExplainPlanPlan, + ) -> Result { + let plan::Explainee::View(id) = explainee else { + unreachable!() // Asserted in `sequence_explain_plan`. + }; + let CatalogItem::View(view) = self.catalog().get_entry(&id).item() else { + unreachable!() // Asserted in `plan_explain_plan`. + }; + + let explain = match stage { + ExplainStage::RawPlan => explain_plan( + view.raw_expr.clone(), + format, + &config, + &self.catalog().for_session(ctx.session()), + )?, + ExplainStage::LocalPlan => explain_plan( + view.optimized_expr.as_inner().clone(), + format, + &config, + &self.catalog().for_session(ctx.session()), + )?, + _ => { + coord_bail!("cannot EXPLAIN {} FOR MATERIALIZED VIEW", stage); + } + }; + + let rows = vec![Row::pack_slice(&[Datum::from(explain.as_str())])]; + + Ok(Self::send_immediate_rows(rows)) + } + #[instrument] fn create_view_validate( &mut self, session: &Session, plan: plan::CreateViewPlan, resolved_ids: ResolvedIds, + // An optional context set iff the state machine is initiated from + // sequencing an EXPALIN for this statement. + explain_ctx: ExplainContext, ) -> Result { let plan::CreateViewPlan { view: plan::View { expr, .. }, @@ -102,6 +248,7 @@ impl Coordinator { validity, plan, resolved_ids, + explain_ctx, })) } @@ -112,30 +259,80 @@ impl Coordinator { validity, plan, resolved_ids, + explain_ctx, }: CreateViewOptimize, ) -> Result>, AdapterError> { let id = self.catalog_mut().allocate_user_id().await?; // Collect optimizer parameters. - let optimizer_config = optimize::OptimizerConfig::from(self.catalog().system_config()); + let optimizer_config = optimize::OptimizerConfig::from(self.catalog().system_config()) + .override_from(&explain_ctx); + + // Build an optimizer for this VIEW. + let mut optimizer = optimize::view::Optimizer::new(optimizer_config); let span = Span::current(); Ok(StageResult::Handle(mz_ore::task::spawn_blocking( || "optimize create view", move || { span.in_scope(|| { - // Build an optimizer for this VIEW. - let mut optimizer = optimize::view::Optimizer::new(optimizer_config); - // HIR ⇒ MIR lowering and MIR ⇒ MIR optimization (local) - let raw_expr = plan.view.expr.clone(); - let optimized_expr = optimizer.catch_unwind_optimize(raw_expr)?; - Ok(Box::new(CreateViewStage::Finish(CreateViewFinish { - validity, - id, - plan, - optimized_expr, - resolved_ids, - }))) + let mut pipeline = + || -> Result { + let _dispatch_guard = explain_ctx.dispatch_guard(); + + // HIR ⇒ MIR lowering and MIR ⇒ MIR optimization (local) + let raw_expr = plan.view.expr.clone(); + let optimized_expr = optimizer.catch_unwind_optimize(raw_expr)?; + + Ok(optimized_expr) + }; + + let stage = match pipeline() { + Ok(optimized_expr) => { + if let ExplainContext::Plan(explain_ctx) = explain_ctx { + CreateViewStage::Explain(CreateViewExplain { + validity, + id, + plan, + explain_ctx, + }) + } else { + CreateViewStage::Finish(CreateViewFinish { + validity, + id, + plan, + optimized_expr, + resolved_ids, + }) + } + } + // Internal optimizer errors are handled differently + // depending on the caller. + Err(err) => { + let ExplainContext::Plan(explain_ctx) = explain_ctx else { + // In `sequence_~` contexts, immediately return the error. + return Err(err.into()); + }; + + if explain_ctx.broken { + // In `EXPLAIN BROKEN` contexts, just log the error + // and move to the next stage with default + // parameters. + tracing::error!("error while handling EXPLAIN statement: {}", err); + CreateViewStage::Explain(CreateViewExplain { + validity, + id, + plan, + explain_ctx, + }) + } else { + // In regular `EXPLAIN` contexts, immediately return the error. + return Err(err.into()); + } + } + }; + + Ok(Box::new(stage)) }) }, ))) @@ -206,4 +403,58 @@ impl Coordinator { Err(err) => Err(err), } } + + #[instrument] + fn create_view_explain( + &mut self, + session: &Session, + CreateViewExplain { + id, + plan: + plan::CreateViewPlan { + name, + view: plan::View { column_names, .. }, + .. + }, + explain_ctx: + ExplainPlanContext { + broken, + config, + format, + stage, + optimizer_trace, + .. + }, + .. + }: CreateViewExplain, + ) -> Result>, AdapterError> { + let session_catalog = self.catalog().for_session(session); + let expr_humanizer = { + let full_name = self.catalog().resolve_full_name(&name, None); + let transient_items = btreemap! { + id => TransientItem::new( + Some(full_name.to_string()), + Some(full_name.item.to_string()), + Some(column_names.iter().map(|c| c.to_string()).collect()), + ) + }; + ExprHumanizerExt::new(transient_items, &session_catalog) + }; + + let rows = optimizer_trace.into_rows( + format, + &config, + &expr_humanizer, + None, + Default::default(), + stage, + plan::ExplaineeStatementKind::CreateView, + )?; + + if broken { + tracing_core::callsite::rebuild_interest_cache(); + } + + Ok(StageResult::Response(Self::send_immediate_rows(rows))) + } } diff --git a/src/adapter/src/optimize/view.rs b/src/adapter/src/optimize/view.rs index 17cfca2ecff14..44606ceb2e725 100644 --- a/src/adapter/src/optimize/view.rs +++ b/src/adapter/src/optimize/view.rs @@ -13,7 +13,7 @@ use mz_expr::OptimizedMirRelationExpr; use mz_sql::plan::HirRelationExpr; use mz_transform::typecheck::{empty_context, SharedContext as TypecheckContext}; -use crate::optimize::{optimize_mir_local, Optimize, OptimizerConfig, OptimizerError}; +use crate::optimize::{optimize_mir_local, trace_plan, Optimize, OptimizerConfig, OptimizerError}; pub struct Optimizer { /// A typechecking context to use throughout the optimizer pipeline. @@ -35,6 +35,9 @@ impl Optimize for Optimizer { type To = OptimizedMirRelationExpr; fn optimize(&mut self, expr: HirRelationExpr) -> Result { + // Trace the pipeline input under `optimize/raw`. + trace_plan!(at: "raw", &expr); + // HIR ⇒ MIR lowering and decorrelation let expr = expr.lower(&self.config)?; From dd6f3b90213f57da0e9fa501184eb6ec1b538f78 Mon Sep 17 00:00:00 2001 From: Alexander Alexandrov Date: Tue, 27 Feb 2024 11:24:13 +0200 Subject: [PATCH 10/13] explain,coord: move `explain_materialized_view` Move `explain_materialized_view` to `inner/create_materialized_view.rs`. --- src/adapter/src/coord/sequencer/inner.rs | 63 ------------ .../inner/create_materialized_view.rs | 96 ++++++++++++++++--- 2 files changed, 82 insertions(+), 77 deletions(-) diff --git a/src/adapter/src/coord/sequencer/inner.rs b/src/adapter/src/coord/sequencer/inner.rs index cc71b0555eb8e..c7f4b78113801 100644 --- a/src/adapter/src/coord/sequencer/inner.rs +++ b/src/adapter/src/coord/sequencer/inner.rs @@ -1898,69 +1898,6 @@ impl Coordinator { }; } - fn explain_materialized_view( - &mut self, - ctx: &ExecuteContext, - plan::ExplainPlanPlan { - stage, - format, - config, - explainee, - }: plan::ExplainPlanPlan, - ) -> Result { - let plan::Explainee::MaterializedView(id) = explainee else { - unreachable!() // Asserted in `sequence_explain_plan`. - }; - let CatalogItem::MaterializedView(_) = self.catalog().get_entry(&id).item() else { - unreachable!() // Asserted in `plan_explain_plan`. - }; - - let Some(dataflow_metainfo) = self.catalog().try_get_dataflow_metainfo(&id) else { - tracing::error!( - "cannot find dataflow metainformation for materialized view {id} in catalog" - ); - coord_bail!( - "cannot find dataflow metainformation for materialized view {id} in catalog" - ); - }; - - let explain = match stage { - ExplainStage::GlobalPlan => { - let Some(plan) = self.catalog().try_get_optimized_plan(&id).cloned() else { - tracing::error!("cannot find {stage} for materialized view {id} in catalog"); - coord_bail!("cannot find {stage} for materialized view in catalog"); - }; - explain_dataflow( - plan, - format, - &config, - &self.catalog().for_session(ctx.session()), - dataflow_metainfo, - )? - } - ExplainStage::PhysicalPlan => { - let Some(plan) = self.catalog().try_get_physical_plan(&id).cloned() else { - tracing::error!("cannot find {stage} for materialized view {id} in catalog"); - coord_bail!("cannot find {stage} for materialized view in catalog"); - }; - explain_dataflow( - plan, - format, - &config, - &self.catalog().for_session(ctx.session()), - dataflow_metainfo, - )? - } - _ => { - coord_bail!("cannot EXPLAIN {} FOR MATERIALIZED VIEW", stage); - } - }; - - let rows = vec![Row::pack_slice(&[Datum::from(explain.as_str())])]; - - Ok(Self::send_immediate_rows(rows)) - } - fn explain_index( &mut self, ctx: &ExecuteContext, diff --git a/src/adapter/src/coord/sequencer/inner/create_materialized_view.rs b/src/adapter/src/coord/sequencer/inner/create_materialized_view.rs index 7956f2e6c8fc9..f76389c5b8ad1 100644 --- a/src/adapter/src/coord/sequencer/inner/create_materialized_view.rs +++ b/src/adapter/src/coord/sequencer/inner/create_materialized_view.rs @@ -16,6 +16,9 @@ use mz_ore::collections::CollectionExt; use mz_ore::instrument; use mz_ore::soft_panic_or_log; use mz_repr::explain::{ExprHumanizerExt, TransientItem}; +use mz_repr::Datum; +use mz_repr::Row; +use mz_sql::ast::ExplainStage; use mz_sql::catalog::CatalogError; use mz_sql::names::{ObjectId, ResolvedIds}; use mz_sql::plan; @@ -33,6 +36,7 @@ use crate::coord::{ ExplainPlanContext, Message, PlanValidity, StageResult, Staged, }; use crate::error::AdapterError; +use crate::explain::explain_dataflow; use crate::explain::optimizer_trace::OptimizerTrace; use crate::optimize::dataflows::dataflow_import_id_bundle; use crate::optimize::{self, Optimize, OverrideFrom}; @@ -137,7 +141,7 @@ impl Coordinator { optimizer_trace, }); let stage = return_if_err!( - self.create_materialized_view_validate(ctx.session(), plan, resolved_ids, explain_ctx,), + self.create_materialized_view_validate(ctx.session(), plan, resolved_ids, explain_ctx), ctx ); self.sequence_staged(ctx, Span::current(), stage).await; @@ -193,6 +197,70 @@ impl Coordinator { self.sequence_staged(ctx, Span::current(), stage).await; } + #[instrument] + pub(super) fn explain_materialized_view( + &mut self, + ctx: &ExecuteContext, + plan::ExplainPlanPlan { + stage, + format, + config, + explainee, + }: plan::ExplainPlanPlan, + ) -> Result { + let plan::Explainee::MaterializedView(id) = explainee else { + unreachable!() // Asserted in `sequence_explain_plan`. + }; + let CatalogItem::MaterializedView(_) = self.catalog().get_entry(&id).item() else { + unreachable!() // Asserted in `plan_explain_plan`. + }; + + let Some(dataflow_metainfo) = self.catalog().try_get_dataflow_metainfo(&id) else { + tracing::error!( + "cannot find dataflow metainformation for materialized view {id} in catalog" + ); + coord_bail!( + "cannot find dataflow metainformation for materialized view {id} in catalog" + ); + }; + + let explain = match stage { + ExplainStage::GlobalPlan => { + let Some(plan) = self.catalog().try_get_optimized_plan(&id).cloned() else { + tracing::error!("cannot find {stage} for materialized view {id} in catalog"); + coord_bail!("cannot find {stage} for materialized view in catalog"); + }; + explain_dataflow( + plan, + format, + &config, + &self.catalog().for_session(ctx.session()), + dataflow_metainfo, + )? + } + ExplainStage::PhysicalPlan => { + let Some(plan) = self.catalog().try_get_physical_plan(&id).cloned() else { + tracing::error!("cannot find {stage} for materialized view {id} in catalog"); + coord_bail!("cannot find {stage} for materialized view in catalog"); + }; + explain_dataflow( + plan, + format, + &config, + &self.catalog().for_session(ctx.session()), + dataflow_metainfo, + )? + } + _ => { + coord_bail!("cannot EXPLAIN {} FOR MATERIALIZED VIEW", stage); + } + }; + + let rows = vec![Row::pack_slice(&[Datum::from(explain.as_str())])]; + + Ok(Self::send_immediate_rows(rows)) + } + #[instrument] fn create_materialized_view_validate( &mut self, @@ -338,22 +406,22 @@ impl Coordinator { move || { span.in_scope(|| { let mut pipeline = || -> Result<( - optimize::materialized_view::LocalMirPlan, - optimize::materialized_view::GlobalMirPlan, - optimize::materialized_view::GlobalLirPlan, - ), AdapterError> { - let _dispatch_guard = explain_ctx.dispatch_guard(); + optimize::materialized_view::LocalMirPlan, + optimize::materialized_view::GlobalMirPlan, + optimize::materialized_view::GlobalLirPlan, + ), AdapterError> { + let _dispatch_guard = explain_ctx.dispatch_guard(); - let raw_expr = plan.materialized_view.expr.clone(); + let raw_expr = plan.materialized_view.expr.clone(); - // HIR ⇒ MIR lowering and MIR ⇒ MIR optimization (local and global) - let local_mir_plan = optimizer.catch_unwind_optimize(raw_expr)?; - let global_mir_plan = optimizer.catch_unwind_optimize(local_mir_plan.clone())?; - // MIR ⇒ LIR lowering and LIR ⇒ LIR optimization (global) - let global_lir_plan = optimizer.catch_unwind_optimize(global_mir_plan.clone())?; + // HIR ⇒ MIR lowering and MIR ⇒ MIR optimization (local and global) + let local_mir_plan = optimizer.catch_unwind_optimize(raw_expr)?; + let global_mir_plan = optimizer.catch_unwind_optimize(local_mir_plan.clone())?; + // MIR ⇒ LIR lowering and LIR ⇒ LIR optimization (global) + let global_lir_plan = optimizer.catch_unwind_optimize(global_mir_plan.clone())?; - Ok((local_mir_plan, global_mir_plan, global_lir_plan)) - }; + Ok((local_mir_plan, global_mir_plan, global_lir_plan)) + }; let stage = match pipeline() { Ok((local_mir_plan, global_mir_plan, global_lir_plan)) => { From a0ff4533e3cd76eedee6c3508c9c3b18808f9e97 Mon Sep 17 00:00:00 2001 From: Alexander Alexandrov Date: Tue, 27 Feb 2024 11:27:06 +0200 Subject: [PATCH 11/13] explain,coord: move `explain_index` Move `explain_index` to `inner/create_index.rs`. --- src/adapter/src/coord/sequencer/inner.rs | 62 +----------------- .../src/coord/sequencer/inner/create_index.rs | 63 +++++++++++++++++++ 2 files changed, 64 insertions(+), 61 deletions(-) diff --git a/src/adapter/src/coord/sequencer/inner.rs b/src/adapter/src/coord/sequencer/inner.rs index c7f4b78113801..59a632c4c0150 100644 --- a/src/adapter/src/coord/sequencer/inner.rs +++ b/src/adapter/src/coord/sequencer/inner.rs @@ -33,7 +33,7 @@ use mz_repr::explain::json::json_string; use mz_repr::explain::{ExplainFormat, ExprHumanizer}; use mz_repr::role_id::RoleId; use mz_repr::{Datum, Diff, GlobalId, Row, RowArena, Timestamp}; -use mz_sql::ast::{ExplainStage, IndexOptionName}; +use mz_sql::ast::IndexOptionName; use mz_sql::catalog::{ CatalogCluster, CatalogClusterReplica, CatalogDatabase, CatalogError, CatalogItem as SqlCatalogItem, CatalogItemType, CatalogRole, CatalogSchema, CatalogTypeDetails, @@ -87,7 +87,6 @@ use crate::coord::{ RealTimeRecencyContext, StageResult, Staged, TargetCluster, }; use crate::error::AdapterError; -use crate::explain::explain_dataflow; use crate::notice::{AdapterNotice, DroppedInUseIndex}; use crate::optimize::dataflows::{prep_scalar_expr, EvalTime, ExprPrepStyle}; use crate::optimize::{self, Optimize}; @@ -1898,65 +1897,6 @@ impl Coordinator { }; } - fn explain_index( - &mut self, - ctx: &ExecuteContext, - plan::ExplainPlanPlan { - stage, - format, - config, - explainee, - }: plan::ExplainPlanPlan, - ) -> Result { - let plan::Explainee::Index(id) = explainee else { - unreachable!() // Asserted in `sequence_explain_plan`. - }; - let CatalogItem::Index(_) = self.catalog().get_entry(&id).item() else { - unreachable!() // Asserted in `plan_explain_plan`. - }; - - let Some(dataflow_metainfo) = self.catalog().try_get_dataflow_metainfo(&id) else { - tracing::error!("cannot find dataflow metainformation for index {id} in catalog"); - coord_bail!("cannot find dataflow metainformation for index {id} in catalog"); - }; - - let explain = match stage { - ExplainStage::GlobalPlan => { - let Some(plan) = self.catalog().try_get_optimized_plan(&id).cloned() else { - tracing::error!("cannot find {stage} for index {id} in catalog"); - coord_bail!("cannot find {stage} for index in catalog"); - }; - explain_dataflow( - plan, - format, - &config, - &self.catalog().for_session(ctx.session()), - dataflow_metainfo, - )? - } - ExplainStage::PhysicalPlan => { - let Some(plan) = self.catalog().try_get_physical_plan(&id).cloned() else { - tracing::error!("cannot find {stage} for index {id} in catalog"); - coord_bail!("cannot find {stage} for index in catalog"); - }; - explain_dataflow( - plan, - format, - &config, - &self.catalog().for_session(ctx.session()), - dataflow_metainfo, - )? - } - _ => { - coord_bail!("cannot EXPLAIN {} FOR INDEX", stage); - } - }; - - let rows = vec![Row::pack_slice(&[Datum::from(explain.as_str())])]; - - Ok(Self::send_immediate_rows(rows)) - } - #[instrument] pub async fn sequence_explain_timestamp( &mut self, diff --git a/src/adapter/src/coord/sequencer/inner/create_index.rs b/src/adapter/src/coord/sequencer/inner/create_index.rs index bec62596da78e..d5930afcf551d 100644 --- a/src/adapter/src/coord/sequencer/inner/create_index.rs +++ b/src/adapter/src/coord/sequencer/inner/create_index.rs @@ -13,6 +13,8 @@ use maplit::btreemap; use mz_catalog::memory::objects::{CatalogItem, Index}; use mz_ore::instrument; use mz_repr::explain::{ExprHumanizerExt, TransientItem}; +use mz_repr::{Datum, Row}; +use mz_sql::ast::ExplainStage; use mz_sql::catalog::CatalogError; use mz_sql::names::ResolvedIds; use mz_sql::plan; @@ -25,6 +27,7 @@ use crate::coord::{ ExplainContext, ExplainPlanContext, Message, PlanValidity, StageResult, Staged, }; use crate::error::AdapterError; +use crate::explain::explain_dataflow; use crate::explain::optimizer_trace::OptimizerTrace; use crate::optimize::dataflows::dataflow_import_id_bundle; use crate::optimize::{self, Optimize, OverrideFrom}; @@ -173,6 +176,66 @@ impl Coordinator { self.sequence_staged(ctx, Span::current(), stage).await; } + #[instrument] + pub(crate) fn explain_index( + &mut self, + ctx: &ExecuteContext, + plan::ExplainPlanPlan { + stage, + format, + config, + explainee, + }: plan::ExplainPlanPlan, + ) -> Result { + let plan::Explainee::Index(id) = explainee else { + unreachable!() // Asserted in `sequence_explain_plan`. + }; + let CatalogItem::Index(_) = self.catalog().get_entry(&id).item() else { + unreachable!() // Asserted in `plan_explain_plan`. + }; + + let Some(dataflow_metainfo) = self.catalog().try_get_dataflow_metainfo(&id) else { + tracing::error!("cannot find dataflow metainformation for index {id} in catalog"); + coord_bail!("cannot find dataflow metainformation for index {id} in catalog"); + }; + + let explain = match stage { + ExplainStage::GlobalPlan => { + let Some(plan) = self.catalog().try_get_optimized_plan(&id).cloned() else { + tracing::error!("cannot find {stage} for index {id} in catalog"); + coord_bail!("cannot find {stage} for index in catalog"); + }; + explain_dataflow( + plan, + format, + &config, + &self.catalog().for_session(ctx.session()), + dataflow_metainfo, + )? + } + ExplainStage::PhysicalPlan => { + let Some(plan) = self.catalog().try_get_physical_plan(&id).cloned() else { + tracing::error!("cannot find {stage} for index {id} in catalog"); + coord_bail!("cannot find {stage} for index in catalog"); + }; + explain_dataflow( + plan, + format, + &config, + &self.catalog().for_session(ctx.session()), + dataflow_metainfo, + )? + } + _ => { + coord_bail!("cannot EXPLAIN {} FOR INDEX", stage); + } + }; + + let rows = vec![Row::pack_slice(&[Datum::from(explain.as_str())])]; + + Ok(Self::send_immediate_rows(rows)) + } + // `explain_ctx` is an optional context set iff the state machine is initiated from // sequencing an EXPALIN for this statement. #[instrument] From e31e3bdaeed45828c15c6bd05a6125745d847691 Mon Sep 17 00:00:00 2001 From: Alexander Alexandrov Date: Tue, 27 Feb 2024 11:32:58 +0200 Subject: [PATCH 12/13] explain,coord: more stages in `EXPLAIN MATERIALIZED VIEW` Add support for handling the `RAW` and `LOCALLY OPTIMIZED` stages using the plans stored in the catalog entry (as in `EXPLAIN VIEW`). --- .../sequencer/inner/create_materialized_view.rs | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/src/adapter/src/coord/sequencer/inner/create_materialized_view.rs b/src/adapter/src/coord/sequencer/inner/create_materialized_view.rs index f76389c5b8ad1..9e28b786cef0e 100644 --- a/src/adapter/src/coord/sequencer/inner/create_materialized_view.rs +++ b/src/adapter/src/coord/sequencer/inner/create_materialized_view.rs @@ -37,6 +37,7 @@ use crate::coord::{ }; use crate::error::AdapterError; use crate::explain::explain_dataflow; +use crate::explain::explain_plan; use crate::explain::optimizer_trace::OptimizerTrace; use crate::optimize::dataflows::dataflow_import_id_bundle; use crate::optimize::{self, Optimize, OverrideFrom}; @@ -211,7 +212,7 @@ impl Coordinator { let plan::Explainee::MaterializedView(id) = explainee else { unreachable!() // Asserted in `sequence_explain_plan`. }; - let CatalogItem::MaterializedView(_) = self.catalog().get_entry(&id).item() else { + let CatalogItem::MaterializedView(view) = self.catalog().get_entry(&id).item() else { unreachable!() // Asserted in `plan_explain_plan`. }; @@ -225,6 +226,18 @@ impl Coordinator { }; let explain = match stage { + ExplainStage::RawPlan => explain_plan( + view.raw_expr.clone(), + format, + &config, + &self.catalog().for_session(ctx.session()), + )?, + ExplainStage::LocalPlan => explain_plan( + view.optimized_expr.as_inner().clone(), + format, + &config, + &self.catalog().for_session(ctx.session()), + )?, ExplainStage::GlobalPlan => { let Some(plan) = self.catalog().try_get_optimized_plan(&id).cloned() else { tracing::error!("cannot find {stage} for materialized view {id} in catalog"); From 71fa86d24d343e905b68757528d110cfedb909a8 Mon Sep 17 00:00:00 2001 From: Alexander Alexandrov Date: Tue, 27 Feb 2024 12:44:31 +0200 Subject: [PATCH 13/13] explain,slt: add `EXPLAIN ... VIEW` test --- test/sqllogictest/explain/view.slt | 249 +++++++++++++++++++++++++++++ 1 file changed, 249 insertions(+) create mode 100644 test/sqllogictest/explain/view.slt diff --git a/test/sqllogictest/explain/view.slt b/test/sqllogictest/explain/view.slt new file mode 100644 index 0000000000000..c7b26956df484 --- /dev/null +++ b/test/sqllogictest/explain/view.slt @@ -0,0 +1,249 @@ +# 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. + +simple conn=mz_system,user=mz_system +ALTER SYSTEM SET enable_new_outer_join_lowering TO false; +---- +COMPLETE 0 + +statement ok +CREATE TABLE accounts(id int, balance int); + +# Use `id bigint` instead of `id int` to force differences in planning based on +# the `enable_new_outer_join_lowering` feature flag value. +statement ok +CREATE TABLE account_details(id bigint, address string); + +statement ok +CREATE OR REPLACE VIEW v AS +SELECT + * +FROM + accounts a + LEFT JOIN account_details ad USING(id) +WHERE + balance = 100; + +mode cockroach + +# Must explain the "Raw Plan". +query T multiline +EXPLAIN RAW PLAN FOR VIEW v; +---- +Project (#0, #1, #3) + Filter (#1 = 100) + LeftOuterJoin (true AND (integer_to_bigint(#0) = #2)) + Get materialize.public.accounts + Get materialize.public.account_details + +EOF + +# Must explain the "Locally Optimized Plan". +query T multiline +EXPLAIN VIEW v; +---- +Return + Project (#0, #1, #3) + Union + Get l0 + Project (#0, #3..=#5) + Map (100, null, null) + Join on=(#0 = #1) + Union + Negate + Distinct project=[#0] + Get l0 + Distinct project=[#0] + Get l1 + Get l1 +With + cte l1 = + Filter (#1 = 100) + Get materialize.public.accounts + cte l0 = + Join on=(#2 = integer_to_bigint(#0)) + Filter (#0) IS NOT NULL AND (#1 = 100) + Get materialize.public.accounts + Filter (#0) IS NOT NULL + Get materialize.public.account_details + +EOF + +# Must explain the "Locally Optimized Plan" (same as above). +query T multiline +EXPLAIN LOCALLY OPTIMIZED PLAN FOR VIEW v; +---- +Return + Project (#0, #1, #3) + Union + Get l0 + Project (#0, #3..=#5) + Map (100, null, null) + Join on=(#0 = #1) + Union + Negate + Distinct project=[#0] + Get l0 + Distinct project=[#0] + Get l1 + Get l1 +With + cte l1 = + Filter (#1 = 100) + Get materialize.public.accounts + cte l0 = + Join on=(#2 = integer_to_bigint(#0)) + Filter (#0) IS NOT NULL AND (#1 = 100) + Get materialize.public.accounts + Filter (#0) IS NOT NULL + Get materialize.public.account_details + +EOF + +# Must explain the "Locally Optimized Plan" (same as above). +query T multiline +EXPLAIN PLAN FOR REPLAN VIEW v; +---- +Return + Project (#0, #1, #3) + Union + Get l0 + Project (#0, #3..=#5) + Map (100, null, null) + Join on=(#0 = #1) + Union + Negate + Distinct project=[#0] + Get l0 + Distinct project=[#0] + Get l1 + Get l1 +With + cte l1 = + Filter (#1 = 100) + Get materialize.public.accounts + cte l0 = + Join on=(#2 = integer_to_bigint(#0)) + Filter (#0) IS NOT NULL AND (#1 = 100) + Get materialize.public.accounts + Filter (#0) IS NOT NULL + Get materialize.public.account_details + +EOF + +# Must explain the "Locally Optimized Plan" after changing the feature flag +# (same as below). +query T multiline +EXPLAIN PLAN WITH(ENABLE NEW OUTER JOIN LOWERING = TRUE) FOR REPLAN VIEW v; +---- +Return + Project (#0, #1, #3) + Union + Map (null, null) + Union + Project (#0, #1) + Negate + Join on=(#2 = integer_to_bigint(#0)) + Get l1 + Distinct project=[integer_to_bigint(#0)] + Get l0 + Get l1 + Filter (#1 = 100) + Get l0 +With + cte l1 = + Filter (#1 = 100) + Get materialize.public.accounts + cte l0 = + Join on=(#2 = integer_to_bigint(#0)) + Filter (#0) IS NOT NULL + Get materialize.public.accounts + Filter (#0) IS NOT NULL + Get materialize.public.account_details + +EOF + +# Change the feature flag value +simple conn=mz_system,user=mz_system +ALTER SYSTEM SET enable_new_outer_join_lowering TO true; +---- +COMPLETE 0 + +# Must be planning with the feature flag turned on. +statement ok +CREATE OR REPLACE VIEW v AS +SELECT + * +FROM + accounts a + LEFT JOIN account_details ad USING(id) +WHERE + balance = 100; + +# Ensure that the index is now used by the view +query T multiline +EXPLAIN VIEW v; +---- +Return + Project (#0, #1, #3) + Union + Map (null, null) + Union + Project (#0, #1) + Negate + Join on=(#2 = integer_to_bigint(#0)) + Get l1 + Distinct project=[integer_to_bigint(#0)] + Get l0 + Get l1 + Filter (#1 = 100) + Get l0 +With + cte l1 = + Filter (#1 = 100) + Get materialize.public.accounts + cte l0 = + Join on=(#2 = integer_to_bigint(#0)) + Filter (#0) IS NOT NULL + Get materialize.public.accounts + Filter (#0) IS NOT NULL + Get materialize.public.account_details + +EOF + +# Must be re-planning with the feature flag turned off. +query T multiline +EXPLAIN PLAN WITH(ENABLE NEW OUTER JOIN LOWERING = FALSE) FOR REPLAN VIEW v; +---- +Return + Project (#0, #1, #3) + Union + Get l0 + Project (#0, #3..=#5) + Map (100, null, null) + Join on=(#0 = #1) + Union + Negate + Distinct project=[#0] + Get l0 + Distinct project=[#0] + Get l1 + Get l1 +With + cte l1 = + Filter (#1 = 100) + Get materialize.public.accounts + cte l0 = + Join on=(#2 = integer_to_bigint(#0)) + Filter (#0) IS NOT NULL AND (#1 = 100) + Get materialize.public.accounts + Filter (#0) IS NOT NULL + Get materialize.public.account_details + +EOF