From 670228720fa313f2632693fc61976628860df39c Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Wed, 23 Sep 2026 11:07:40 +0700 Subject: [PATCH 1/5] feat(sidebar): find tables in every schema from Open Quickly and the sidebar filter --- CHANGELOG.md | 5 + .../PostgreSQLPluginDriver.swift | 19 +- .../PostgreSQLSchemaQueries.swift | 52 +++- .../PluginDatabaseDriver.swift | 7 + .../Core/Concurrency/CatalogFreshness.swift | 43 +++ .../Core/Database/BackupScopeLoader.swift | 40 ++- .../Core/Database/CatalogTableListing.swift | 87 ++++++ TablePro/Core/Database/DatabaseDriver.swift | 6 + .../Core/Plugins/PluginDriverAdapter.swift | 5 + ...aseTreeMetadataService+CatalogChange.swift | 16 +- .../Query/DatabaseTreeMetadataService.swift | 127 ++++++++ .../Query/QuickSwitcherCatalogStore.swift | 6 +- .../Utilities/UI/QualifiedSearchQuery.swift | 88 ++++++ .../Core/Utilities/UI/SidebarSearch.swift | 62 ++++ TablePro/Models/UI/QuickSwitcherItem.swift | 32 ++- .../ViewModels/QuickSwitcherViewModel.swift | 272 ++++++++++++++---- TablePro/ViewModels/SidebarViewModel.swift | 56 +++- ...MainContentCoordinator+QuickSwitcher.swift | 6 +- .../QuickSwitcherPanelView.swift | 16 +- .../Views/Sidebar/DatabaseTreeFilter.swift | 188 ++++++++++-- ...baseTreeOutlineCoordinator+Expansion.swift | 8 +- ...DatabaseTreeOutlineCoordinator+Nodes.swift | 103 ++++++- .../DatabaseTreeOutlineCoordinator.swift | 2 + TablePro/Views/Sidebar/SidebarView.swift | 29 +- .../Autocomplete/SQLSchemaProviderTests.swift | 33 +++ .../Concurrency/CatalogFreshnessTests.swift | 71 +++++ .../Database/CatalogTableListingTests.swift | 122 ++++++++ .../DatabaseTreeAllSchemaTablesTests.swift | 221 ++++++++++++++ .../DatabaseTreeCatalogRefreshPlanTests.swift | 40 +++ ...PostgreSQLFetchTablesAllSchemasTests.swift | 64 +++++ .../QuickSwitcherCatalogStoreTests.swift | 42 --- .../Utilities/QualifiedSearchQueryTests.swift | 105 +++++++ .../Utilities/SidebarSearchTests.swift | 84 ++++++ .../QuickSwitcherCrossSchemaTests.swift | 246 ++++++++++++++++ ...tabaseTreeFilterQualifiedSearchTests.swift | 252 ++++++++++++++++ docs/features/connection-window.mdx | 13 + docs/features/open-quickly.mdx | 28 +- .../check-postgres-table-listing-parity.sh | 182 ++++++++++++ 38 files changed, 2582 insertions(+), 196 deletions(-) create mode 100644 TablePro/Core/Concurrency/CatalogFreshness.swift create mode 100644 TablePro/Core/Database/CatalogTableListing.swift create mode 100644 TablePro/Core/Utilities/UI/QualifiedSearchQuery.swift create mode 100644 TablePro/Core/Utilities/UI/SidebarSearch.swift create mode 100644 TableProTests/Core/Concurrency/CatalogFreshnessTests.swift create mode 100644 TableProTests/Core/Database/CatalogTableListingTests.swift create mode 100644 TableProTests/Core/Services/Query/DatabaseTreeAllSchemaTablesTests.swift create mode 100644 TableProTests/Plugins/PostgreSQLFetchTablesAllSchemasTests.swift create mode 100644 TableProTests/Utilities/QualifiedSearchQueryTests.swift create mode 100644 TableProTests/Utilities/SidebarSearchTests.swift create mode 100644 TableProTests/ViewModels/QuickSwitcherCrossSchemaTests.swift create mode 100644 TableProTests/Views/Sidebar/DatabaseTreeFilterQualifiedSearchTests.swift create mode 100755 scripts/check-postgres-table-listing-parity.sh diff --git a/CHANGELOG.md b/CHANGELOG.md index e2e438bd59..6d62bd3d3b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -38,6 +38,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - **File > Session**, with the agent session commands and the assistant's conversation commands. - Eight more rebindable commands in **Settings > Keyboard**, among them the sidebar's lists and the session commands. - **Global** on a saved query folder's menu, for a folder every connection shows. +- Tables from every schema in Open Quickly and the sidebar filter, and `schema.table` searches in both. (#3048) ### Changed @@ -70,6 +71,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Fixed +- Tables in an expanded Oracle or Snowflake schema missing from Open Quickly until the next refresh. +- Schemas missing from Open Quickly on every reopen after one failed to load. +- Unexpanded schemas hidden by the sidebar filter in the Tree layout. +- **Drop View** offered in Recent for a sequence or materialized view opened from Open Quickly. - Unresponsive app and a dropped keystroke when typing in the row inspector's JSON field. (#3051) - Raw Oracle driver error in the schema switch failure dialog. (#3053) - Oracle health check closing a connection a statement was still running on. (#3053) diff --git a/Plugins/PostgreSQLDriverPlugin/PostgreSQLPluginDriver.swift b/Plugins/PostgreSQLDriverPlugin/PostgreSQLPluginDriver.swift index 7a4e86f3bc..e571277e77 100644 --- a/Plugins/PostgreSQLDriverPlugin/PostgreSQLPluginDriver.swift +++ b/Plugins/PostgreSQLDriverPlugin/PostgreSQLPluginDriver.swift @@ -166,10 +166,17 @@ class PostgreSQLPluginDriver: LibPQBackedDriver, @unchecked Sendable { // MARK: - Schema func fetchTables(schema: String?) async throws -> [PluginTableInfo] { - let schemaName = schema ?? core.currentSchema + try await listTables(in: .schema(schema ?? core.currentSchema)) + } + + func fetchTablesInAllSchemas() async throws -> [PluginTableInfo]? { + try await listTables(in: .allSchemas) + } + + private func listTables(in listing: PostgreSQLTableListingScope) async throws -> [PluginTableInfo] { func query(_ attempt: PostgreSQLTableListingAttempt) -> String { PostgreSQLSchemaQueries.fetchTables( - schema: schemaName, + in: listing, includeMaterializedViews: attempt.includeOptionalCatalogs && includesMaterializedViews(), includeForeignTables: attempt.includeOptionalCatalogs && includesForeignTables(), includeComments: attempt.includeComments, @@ -203,7 +210,13 @@ class PostgreSQLPluginDriver: LibPQBackedDriver, @unchecked Sendable { } let comment = row[safe: 2]?.asText?.nilIfEmpty let partitionCount = row[safe: 3]?.asText.flatMap(Int.init) - return PluginTableInfo(name: name, type: type, comment: comment, partitionCount: partitionCount) + return PluginTableInfo( + name: name, + type: type, + schema: row[safe: 4]?.asText, + comment: comment, + partitionCount: partitionCount + ) } } diff --git a/Plugins/PostgreSQLDriverPlugin/PostgreSQLSchemaQueries.swift b/Plugins/PostgreSQLDriverPlugin/PostgreSQLSchemaQueries.swift index 3996634c53..4cb314d931 100644 --- a/Plugins/PostgreSQLDriverPlugin/PostgreSQLSchemaQueries.swift +++ b/Plugins/PostgreSQLDriverPlugin/PostgreSQLSchemaQueries.swift @@ -15,6 +15,11 @@ enum PostgreSQLSchemaProbe: Equatable { case failed } +enum PostgreSQLTableListingScope: Sendable, Equatable { + case schema(String) + case allSchemas +} + enum PostgreSQLSchemaQueries { /// Returns the first schema on the effective search path, or SQL NULL /// when the path is empty (neither `$user` nor `public` exists). @@ -110,7 +115,38 @@ enum PostgreSQLSchemaQueries { includeComments: Bool = true, includePartitionAwareness: Bool = true ) -> String { - let schemaLiteral = PostgreSQLObjectQueries.quoteLiteral(schema) + fetchTables( + in: .schema(schema), + includeMaterializedViews: includeMaterializedViews, + includeForeignTables: includeForeignTables, + includeComments: includeComments, + includePartitionAwareness: includePartitionAwareness + ) + } + + /// The same listing over one schema or over every schema `listSchemas` returns. The second + /// filters by that query itself rather than restating its predicate, so a table is listed here + /// exactly when its schema is listed there, and projects each row's schema, which the + /// one-schema listing leaves to the caller. + static func fetchTables( + in listing: PostgreSQLTableListingScope, + includeMaterializedViews: Bool, + includeForeignTables: Bool, + includeComments: Bool = true, + includePartitionAwareness: Bool = true + ) -> String { + func schemaFilter(_ column: String) -> String { + switch listing { + case .schema(let schema): + return "\(column) = \(PostgreSQLObjectQueries.quoteLiteral(schema))" + case .allSchemas: + return "\(column) IN (\n\(listSchemas)\n)" + } + } + func schemaColumn(_ column: String) -> String { + listing == .allSchemas ? ",\n \(column) AS schema_name" : "" + } + let orderBy = listing == .allSchemas ? "ORDER BY schema_name, table_name" : "ORDER BY table_name" func commentColumn(_ oidExpression: String) -> String { includeComments ? "obj_description(\(oidExpression), 'pg_class')" : "NULL::text" } @@ -140,9 +176,9 @@ enum PostgreSQLSchemaQueries { """ SELECT t.table_name, \(tableTypeColumn) AS table_type, \(commentColumn("pc.oid")) AS table_comment, - \(partitionCountColumn) AS partition_count + \(partitionCountColumn) AS partition_count\(schemaColumn("t.table_schema")) FROM information_schema.tables t\(classJoin) - WHERE t.table_schema = \(schemaLiteral) + WHERE \(schemaFilter("t.table_schema")) AND t.table_type IN ('BASE TABLE', 'VIEW')\(partitionFilter) """ ] @@ -157,9 +193,9 @@ enum PostgreSQLSchemaQueries { """ SELECT m.matviewname AS table_name, 'MATERIALIZED VIEW' AS table_type, \(commentColumn("mc.oid")) AS table_comment, - NULL::bigint AS partition_count + NULL::bigint AS partition_count\(schemaColumn("m.schemaname")) FROM pg_matviews m\(matviewJoin) - WHERE m.schemaname = \(schemaLiteral) + WHERE \(schemaFilter("m.schemaname")) """ ) } @@ -172,16 +208,16 @@ enum PostgreSQLSchemaQueries { """ SELECT c.relname AS table_name, 'FOREIGN TABLE' AS table_type, \(commentColumn("c.oid")) AS table_comment, - NULL::bigint AS partition_count + NULL::bigint AS partition_count\(schemaColumn("n.nspname")) FROM pg_foreign_table ft JOIN pg_class c ON c.oid = ft.ftrelid JOIN pg_namespace n ON n.oid = c.relnamespace - WHERE n.nspname = \(schemaLiteral)\(foreignPartitionFilter) + WHERE \(schemaFilter("n.nspname"))\(foreignPartitionFilter) """ ) } - return unions.joined(separator: "\nUNION ALL\n") + "\nORDER BY table_name" + return unions.joined(separator: "\nUNION ALL\n") + "\n" + orderBy } /// The predicate that keeps a partition out of a flat listing. A foreign diff --git a/Plugins/TableProPluginKit/PluginDatabaseDriver.swift b/Plugins/TableProPluginKit/PluginDatabaseDriver.swift index d6b2a0308e..dc6ce2314a 100644 --- a/Plugins/TableProPluginKit/PluginDatabaseDriver.swift +++ b/Plugins/TableProPluginKit/PluginDatabaseDriver.swift @@ -93,6 +93,11 @@ public protocol PluginDatabaseDriver: AnyObject, Sendable { func executeBoundedQuery(query: String, rowCap: Int) async throws -> PluginQueryResult? func fetchTables(schema: String?) async throws -> [PluginTableInfo] + + /// What `fetchTables(schema:)` lists for every schema `fetchSchemas()` lists, in one call, each + /// row carrying its own schema. Nil means the engine has no single call for it, and the host + /// asks each schema in turn instead. + func fetchTablesInAllSchemas() async throws -> [PluginTableInfo]? func fetchPartitions(table: String, schema: String?) async throws -> [PluginTableInfo] /// The same partitions as `fetchPartitions`, with the bound, the ordinal position and the row @@ -641,6 +646,8 @@ public extension PluginDatabaseDriver { func fetchSchemas() async throws -> [String] { [] } + func fetchTablesInAllSchemas() async throws -> [PluginTableInfo]? { nil } + /// Schemas whose objects live in a catalog outside the database itself, such /// as Redshift external schemas backed by Glue, Hive, or a federated source. /// Engines without that concept keep the empty default. diff --git a/TablePro/Core/Concurrency/CatalogFreshness.swift b/TablePro/Core/Concurrency/CatalogFreshness.swift new file mode 100644 index 0000000000..c2b4384032 --- /dev/null +++ b/TablePro/Core/Concurrency/CatalogFreshness.swift @@ -0,0 +1,43 @@ +// +// CatalogFreshness.swift +// TablePro +// + +import Foundation + +/// Which cached lists a catalog change has overtaken, for a cache that refetches when it is next +/// read rather than the moment the catalog changes. +/// +/// A change moves its key's revision, and a fetch carries the revision it started under. A fetch +/// that was already running when the change landed still delivers its rows, but it cannot make +/// the key current again, so the next read fetches once more. A key whose fetch failed was never +/// committed, which leaves it stale and retried on the next read too. +struct CatalogFreshness { + private var revisions: [Key: Int] = [:] + private var committed: [Key: Int] = [:] + + func revision(for key: Key) -> Int { + revisions[key, default: 0] + } + + func isCurrent(_ key: Key) -> Bool { + committed[key] == revision(for: key) + } + + mutating func markChanged(_ key: Key) { + revisions[key, default: 0] &+= 1 + } + + /// False when a fetch that started later has already committed, so an older fetch finishing + /// last cannot put its rows back over newer ones. + mutating func commit(_ revision: Int, for key: Key) -> Bool { + if let current = committed[key], current > revision { return false } + committed[key] = revision + return true + } + + mutating func removeAll(where shouldRemove: (Key) -> Bool) { + revisions = revisions.filter { !shouldRemove($0.key) } + committed = committed.filter { !shouldRemove($0.key) } + } +} diff --git a/TablePro/Core/Database/BackupScopeLoader.swift b/TablePro/Core/Database/BackupScopeLoader.swift index 15931fbb13..1675b4fd42 100644 --- a/TablePro/Core/Database/BackupScopeLoader.swift +++ b/TablePro/Core/Database/BackupScopeLoader.swift @@ -92,32 +92,26 @@ enum BackupScopeLoader { } } + /// A schema that could not be listed fails the whole list, as it did when each schema was read + /// in turn: a picker that silently lacks a schema would back up less than the user chose. @MainActor private static func schemaQualifiedObjects(scope: DatabaseScope) async throws -> [NativeDumpObject] { - let schemas = try await DatabaseManager.shared.withMetadataDriver(scope: scope) { driver in - try await driver.fetchSchemas() - } - var objects: [NativeDumpObject] = [] - for schema in schemas { - let qualified = DatabaseScope( - connectionId: scope.connectionId, database: scope.database, schema: schema - ) - let tables = try await DatabaseManager.shared.withMetadataDriver( - scope: qualified, workload: .bulk - ) { driver in - try await driver.fetchTables(schema: schema) + let listing = try await CatalogTableListing.tables(in: scope, excludingSchemas: []) + guard listing.unlistedSchemas.isEmpty else { throw BackupScopeLoadError.schemasNotListed } + return listing.tables + .filter(\.type.isBackupSelectable) + .compactMap { table in + guard let schema = table.schema else { return nil } + return NativeDumpObject( + name: table.name, + schema: schema, + isPartitionedParent: table.type == .partitionedTable + ) } - objects += tables - .filter(\.type.isBackupSelectable) - .map { - NativeDumpObject( - name: $0.name, - schema: schema, - isPartitionedParent: $0.type == .partitionedTable - ) - } - } - return objects + } + + private enum BackupScopeLoadError: Error { + case schemasNotListed } /// Everything the dump tool has to be told about to reproduce the chosen objects. diff --git a/TablePro/Core/Database/CatalogTableListing.swift b/TablePro/Core/Database/CatalogTableListing.swift new file mode 100644 index 0000000000..e4af96372a --- /dev/null +++ b/TablePro/Core/Database/CatalogTableListing.swift @@ -0,0 +1,87 @@ +// +// CatalogTableListing.swift +// TablePro +// + +import Foundation +import os + +/// Every table one database holds, across all of its schemas. +/// +/// An engine that answers `fetchTablesInAllSchemas()` is asked once. Any other is asked schema by +/// schema, and each of those reads queues on the metadata lane by itself, so a sidebar expansion +/// that arrives in the middle waits behind one schema rather than behind all of them. Every read +/// goes through the one scope the caller names: a scope per schema would open a pooled connection +/// per schema. +@MainActor +internal enum CatalogTableListing { + /// A schema whose own read failed is named rather than dropped. Read as empty, it would tell a + /// search that nothing in it matches, and hide exactly the table the search was looking for. + internal struct Result: Sendable, Equatable { + internal let tables: [TableInfo] + internal let unlistedSchemas: Set + + /// This listing with another read of some of its unlisted schemas folded in. A schema the + /// read listed moves across; one it still could not list stays unlisted. + internal func merging(_ retry: Result, retried schemas: Set) -> Result { + let kept = tables.filter { table in + guard let schema = table.schema else { return true } + return !schemas.contains(schema) + } + return Result( + tables: kept + retry.tables, + unlistedSchemas: unlistedSchemas.subtracting(schemas).union(retry.unlistedSchemas) + ) + } + } + + private static let logger = Logger(subsystem: "com.TablePro", category: "CatalogTableListing") + + internal static func tables( + in scope: DatabaseScope, + excludingSchemas excluded: Set, + metadata: ScopedMetadataProviding = DatabaseManager.shared + ) async throws -> Result { + let listed = try await metadata.withMetadataDriver(scope: scope, workload: .bulk) { driver in + try await driver.fetchTablesInAllSchemas() + } + if let listed { + let tables = listed.filter { table in + guard let schema = table.schema else { return true } + return !excluded.contains(schema) + } + return Result(tables: tables, unlistedSchemas: []) + } + let schemas = try await metadata.withMetadataDriver(scope: scope, workload: .bulk) { driver in + try await driver.fetchSchemas() + } + return try await tables(inSchemas: schemas.filter { !excluded.contains($0) }, scope: scope, metadata: metadata) + } + + /// The named schemas one by one, which is also how a listing asks again for the schemas it + /// could not read the first time. + internal static func tables( + inSchemas schemas: [String], + scope: DatabaseScope, + metadata: ScopedMetadataProviding = DatabaseManager.shared + ) async throws -> Result { + var tables: [TableInfo] = [] + var unlisted: Set = [] + for schema in schemas { + try Task.checkCancellation() + do { + tables += try await metadata.withMetadataDriver(scope: scope, workload: .bulk) { driver in + try await driver.fetchTables(schema: schema) + } + } catch is CancellationError { + throw CancellationError() + } catch { + logger.warning( + "[catalog] schema not listed schema=\(schema, privacy: .private(mask: .hash)) error=\(error.publicLogShape, privacy: .public)" + ) + unlisted.insert(schema) + } + } + return Result(tables: tables, unlistedSchemas: unlisted) + } +} diff --git a/TablePro/Core/Database/DatabaseDriver.swift b/TablePro/Core/Database/DatabaseDriver.swift index 7504bdadf9..44750ccafc 100644 --- a/TablePro/Core/Database/DatabaseDriver.swift +++ b/TablePro/Core/Database/DatabaseDriver.swift @@ -99,6 +99,10 @@ protocol DatabaseDriver: AnyObject, Sendable { func fetchTables(schema: String?) async throws -> [TableInfo] + /// Every schema's tables in one call, or nil when the engine has no such call and the caller + /// has to ask each schema itself. `CatalogTableListing` is the caller that does. + func fetchTablesInAllSchemas() async throws -> [TableInfo]? + /// Fetch the direct partitions of one partitioned table, with each one's bound, position and /// row estimate. A partition is not a table on every engine, so this cannot answer `TableInfo`: /// a MySQL or Oracle partition name is unique only within its own table. @@ -704,6 +708,8 @@ extension DatabaseDriver { try await fetchTables() } + func fetchTablesInAllSchemas() async throws -> [TableInfo]? { nil } + func fetchRoutines(schema: String?) async throws -> [RoutineInfo] { [] } func fetchRoutineDDL(_ routine: RoutineInfo) async throws -> String { diff --git a/TablePro/Core/Plugins/PluginDriverAdapter.swift b/TablePro/Core/Plugins/PluginDriverAdapter.swift index 97df2999f9..0cb62ee45e 100644 --- a/TablePro/Core/Plugins/PluginDriverAdapter.swift +++ b/TablePro/Core/Plugins/PluginDriverAdapter.swift @@ -234,6 +234,11 @@ final class PluginDriverAdapter: DatabaseDriver, SchemaSwitchable, DatabaseRepor return pluginTables.map { mapPluginTable($0, schemaFallback: resolvedSchema) } } + func fetchTablesInAllSchemas() async throws -> [TableInfo]? { + guard let pluginTables = try await pluginDriver.fetchTablesInAllSchemas() else { return nil } + return pluginTables.map { mapPluginTable($0, schemaFallback: nil) } + } + func fetchPartitionDetails(table: String, schema: String?) async throws -> [PartitionInfo] { let resolvedSchema = schema ?? pluginDriver.currentSchema let partitions = try await pluginDriver.fetchPartitionDetails(table: table, schema: resolvedSchema) diff --git a/TablePro/Core/Services/Query/DatabaseTreeMetadataService+CatalogChange.swift b/TablePro/Core/Services/Query/DatabaseTreeMetadataService+CatalogChange.swift index 5a4054c375..0b86f6fd9e 100644 --- a/TablePro/Core/Services/Query/DatabaseTreeMetadataService+CatalogChange.swift +++ b/TablePro/Core/Services/Query/DatabaseTreeMetadataService+CatalogChange.swift @@ -20,10 +20,12 @@ struct CatalogTreeRefreshPlan: Equatable, Sendable { var routines: Set = [] var triggers: Set = [] var types: Set = [] + /// Marked stale rather than refetched, for the reason `loadAllSchemaTables` gives. + var allSchemaTables: Set = [] var isEmpty: Bool { !refreshesDatabaseList && schemaLists.isEmpty && tables.isEmpty && partitions.isEmpty - && routines.isEmpty && triggers.isEmpty && types.isEmpty + && routines.isEmpty && triggers.isEmpty && types.isEmpty && allSchemaTables.isEmpty } } @@ -41,9 +43,11 @@ extension DatabaseTreeMetadataService { partitionKeys: partitionsState.keys, routineKeys: routinesState.keys, triggerKeys: triggersState.keys, - typeKeys: typesState.keys + typeKeys: typesState.keys, + allSchemaTableKeys: allSchemaTablesState.keys ) guard !plan.isEmpty else { return } + markAllSchemaTablesChanged(plan.allSchemaTables) let databaseType = DatabaseManager.shared.session(for: change.connectionId)?.connection.type await withTaskGroup(of: Void.self) { group in if plan.refreshesDatabaseList, let databaseType { @@ -88,7 +92,8 @@ extension DatabaseTreeMetadataService { partitionKeys: some Sequence = EmptyCollection(), routineKeys: some Sequence, triggerKeys: some Sequence, - typeKeys: some Sequence + typeKeys: some Sequence, + allSchemaTableKeys: some Sequence = EmptyCollection() ) -> CatalogTreeRefreshPlan { func reached(_ key: ObjectsKey) -> Bool { key.connectionId == change.connectionId && change.reaches(database: key.database, schema: key.schema) @@ -117,6 +122,11 @@ extension DatabaseTreeMetadataService { plan.routines = objectKeys(routineKeys, for: .routines) plan.triggers = objectKeys(triggerKeys, for: .triggers) plan.types = objectKeys(typeKeys, for: .types) + if !change.kinds.isDisjoint(with: [.tables, .schemas]) { + plan.allSchemaTables = Set(allSchemaTableKeys.filter { key in + key.connectionId == change.connectionId && change.reaches(database: key.database) + }) + } return plan } } diff --git a/TablePro/Core/Services/Query/DatabaseTreeMetadataService.swift b/TablePro/Core/Services/Query/DatabaseTreeMetadataService.swift index fcac01c8e6..a15cc28536 100644 --- a/TablePro/Core/Services/Query/DatabaseTreeMetadataService.swift +++ b/TablePro/Core/Services/Query/DatabaseTreeMetadataService.swift @@ -30,6 +30,15 @@ final class DatabaseTreeMetadataService: ObservableObject, CatalogChangeTarget { let table: String } + /// Keyed by the revision it was started under as well as the database, so a read that arrives + /// after a catalog change starts its own fetch instead of joining one that began before it. + /// `retrying` names the schemas a second read asks for, and is empty for a whole listing. + struct AllSchemaTablesLoadKey: Hashable, Sendable { + let database: DatabaseKey + let revision: Int + let retrying: Set + } + @Published private(set) var databaseList: [UUID: MetadataLoadState<[DatabaseMetadata]>] = [:] @Published private(set) var schemaList: [DatabaseKey: MetadataLoadState<[String]>] = [:] @Published private(set) var tablesState: [ObjectsKey: MetadataLoadState<[TableInfo]>] = [:] @@ -37,6 +46,7 @@ final class DatabaseTreeMetadataService: ObservableObject, CatalogChangeTarget { @Published private(set) var triggersState: [ObjectsKey: MetadataLoadState<[TriggerInfo]>] = [:] @Published private(set) var typesState: [ObjectsKey: MetadataLoadState<[UserDefinedTypeInfo]>] = [:] @Published private(set) var partitionsState: [PartitionsKey: MetadataLoadState<[PartitionInfo]>] = [:] + @Published private(set) var allSchemaTablesState: [DatabaseKey: MetadataLoadState] = [:] private let databaseDedup = OnceTask() private let schemaDedup = OnceTask() @@ -45,6 +55,7 @@ final class DatabaseTreeMetadataService: ObservableObject, CatalogChangeTarget { private let triggersDedup = OnceTask() private let typesDedup = OnceTask() private let partitionsDedup = OnceTask() + private let allSchemaTablesDedup = OnceTask() private var databaseListFence = CommitFence() private var schemaListFence = CommitFence() @@ -53,6 +64,8 @@ final class DatabaseTreeMetadataService: ObservableObject, CatalogChangeTarget { private var triggersFence = CommitFence() private var typesFence = CommitFence() private var partitionsFence = CommitFence() + private var allSchemaTablesFence = CommitFence() + private var allSchemaTablesFreshness = CatalogFreshness() nonisolated private static let logger = Logger( subsystem: "com.TablePro", category: "SidebarTree" @@ -119,6 +132,110 @@ final class DatabaseTreeMetadataService: ObservableObject, CatalogChangeTarget { return partitionsState[key] ?? .idle } + func allSchemaTablesLoadState( + connectionId: UUID, database: String + ) -> MetadataLoadState { + allSchemaTablesState[DatabaseKey(connectionId: connectionId, database: database)] ?? .idle + } + + /// Engines whose tables live in schemas the sidebar does not list until they are opened. The + /// rest list a whole database in the one table list they already load. + nonisolated static func listsTablesPerSchema(_ strategy: GroupingStrategy) -> Bool { + switch strategy { + case .bySchema, .hierarchicalSchema: return true + case .flat, .byDatabase: return false + } + } + + // MARK: - All-schema tables + + /// Every schema's tables in one database, for the searches that have to judge a schema nobody + /// has expanded. Unlike the lists the tree draws, it refreshes when it is next read rather than + /// on every catalog change: a COMMIT reports a catalog change too, and relisting every schema + /// of the database on each one would pay for a listing nobody asked for. + func loadAllSchemaTables(connectionId: UUID, database: String) async { + guard isConnected(connectionId) else { return } + let key = DatabaseKey(connectionId: connectionId, database: database) + if allSchemaTablesFreshness.isCurrent(key) { + await retryUnlistedSchemas(key) + return + } + let revision = allSchemaTablesFreshness.revision(for: key) + allSchemaTablesState[key] = (allSchemaTablesState[key] ?? .idle).enteringLoad + let token = allSchemaTablesFence.token(for: key) + let outcome: MetadataFetchOutcome + do { + let listing = try await allSchemaTablesDedup.execute( + key: AllSchemaTablesLoadKey(database: key, revision: revision, retrying: []) + ) { [self] in + try await fetchAllSchemaTables(key) + } + outcome = .fetched(listing) + } catch is CancellationError { + outcome = .cancelled + } catch { + outcome = .failed(error.localizedDescription) + Self.logger.warning( + "all-schema tables load failed db=\(database, privacy: .private(mask: .hash)) error=\(error.publicLogShape, privacy: .public)" + ) + } + guard allSchemaTablesFence.isCurrent(token, for: key) else { return } + if case .fetched = outcome, !allSchemaTablesFreshness.commit(revision, for: key) { return } + allSchemaTablesState[key] = (allSchemaTablesState[key] ?? .idle).settled(by: outcome, discardingValue: false) + } + + /// A listing that could not read some schemas stays current for the rest, and only those are + /// asked for again on the next read. Relisting the whole database each time would repeat a + /// schema-by-schema listing for the one schema the role may never be able to read. + private func retryUnlistedSchemas(_ key: DatabaseKey) async { + guard let listing = allSchemaTablesState[key]?.value, !listing.unlistedSchemas.isEmpty else { return } + let schemas = listing.unlistedSchemas + let revision = allSchemaTablesFreshness.revision(for: key) + let token = allSchemaTablesFence.token(for: key) + let retry: CatalogTableListing.Result + do { + retry = try await allSchemaTablesDedup.execute( + key: AllSchemaTablesLoadKey(database: key, revision: revision, retrying: schemas) + ) { [self] in + try await fetchSchemaTables(key, schemas: schemas) + } + } catch { + return + } + guard allSchemaTablesFence.isCurrent(token, for: key), + allSchemaTablesFreshness.revision(for: key) == revision, + let current = allSchemaTablesState[key]?.value else { return } + allSchemaTablesState[key] = .loaded(current.merging(retry, retried: schemas)) + } + + func markAllSchemaTablesChanged(_ keys: some Sequence) { + for key in keys { + allSchemaTablesFreshness.markChanged(key) + } + } + + /// System schemas stay out, as they stay out of the tree until Show System is on. + private func fetchAllSchemaTables(_ key: DatabaseKey) async throws -> CatalogTableListing.Result { + guard let session = DatabaseManager.shared.session(for: key.connectionId) else { + throw DatabaseError.notConnected + } + let systemSchemas = Set(PluginManager.shared.systemSchemaNames(for: session.connection.type)) + return try await CatalogTableListing.tables(in: try listingScope(key), excludingSchemas: systemSchemas) + } + + private func fetchSchemaTables(_ key: DatabaseKey, schemas: Set) async throws -> CatalogTableListing.Result { + try await CatalogTableListing.tables(inSchemas: schemas.sorted(), scope: try listingScope(key)) + } + + private func listingScope(_ key: DatabaseKey) throws -> DatabaseScope { + guard let scope = DatabaseManager.shared.resolvedScope( + database: key.database, schema: nil, for: key.connectionId + ) else { + throw DatabaseError.notConnected + } + return scope + } + // MARK: - Loads func loadDatabases(connectionId: UUID, databaseType: DatabaseType) async { @@ -658,6 +775,7 @@ final class DatabaseTreeMetadataService: ObservableObject, CatalogChangeTarget { func handleReconnect(connectionId: UUID) async { supersedeEveryKey(of: connectionId) SchemaForeignKeyStore.shared.invalidate(connectionId: connectionId) + markAllSchemaTablesChanged(allSchemaTablesState.keys.filter { $0.connectionId == connectionId }) await resetPending(connectionId: connectionId) } @@ -684,6 +802,9 @@ final class DatabaseTreeMetadataService: ObservableObject, CatalogChangeTarget { for key in connectionPartitionKeys(connectionId) { await partitionsDedup.cancel(key: key) } + await allSchemaTablesDedup.cancel { $0.database.connectionId == connectionId } + allSchemaTablesFreshness.removeAll { $0.connectionId == connectionId } + allSchemaTablesState = allSchemaTablesState.filter { $0.key.connectionId != connectionId } databaseList.removeValue(forKey: connectionId) schemaList = schemaList.filter { $0.key.connectionId != connectionId } tablesState = tablesState.filter { $0.key.connectionId != connectionId } @@ -716,6 +837,9 @@ final class DatabaseTreeMetadataService: ObservableObject, CatalogChangeTarget { for key in connectionPartitionKeys(connectionId) { partitionsFence.supersede(key) } + for key in allSchemaTablesState.keys where key.connectionId == connectionId { + allSchemaTablesFence.supersede(key) + } } private func resetPending(connectionId: UUID) async { @@ -744,6 +868,9 @@ final class DatabaseTreeMetadataService: ObservableObject, CatalogChangeTarget { for key in partitionKeys where isPending(partitionsState[key]) { await partitionsDedup.cancel(key: key) } + let allSchemaKeys = allSchemaTablesState.keys.filter { $0.connectionId == connectionId } + await allSchemaTablesDedup.cancel { $0.database.connectionId == connectionId } + for key in allSchemaKeys where isPending(allSchemaTablesState[key]) { allSchemaTablesState[key] = .idle } if isPending(databaseList[connectionId]) { databaseList[connectionId] = .idle } for key in schemaKeys where isPending(schemaList[key]) { schemaList[key] = .idle } diff --git a/TablePro/Core/Services/Query/QuickSwitcherCatalogStore.swift b/TablePro/Core/Services/Query/QuickSwitcherCatalogStore.swift index 80548632f5..74fa7e9fc5 100644 --- a/TablePro/Core/Services/Query/QuickSwitcherCatalogStore.swift +++ b/TablePro/Core/Services/Query/QuickSwitcherCatalogStore.swift @@ -93,9 +93,9 @@ internal final class QuickSwitcherCatalogStore { return items[connectionId] } - /// Stored without any open-tab state. Which tables have a tab changes between presentations - /// while none of the version's inputs move, so a cached `isOpenInTab` would badge a table the - /// user has since closed. + /// The panel keeps no tables here. They change without any of the version's inputs moving, a + /// schema listed after the panel opened or a tab opened since, so it merges them in live. Open + /// state is stripped all the same, so nothing stored can badge a tab the user has closed. internal func store(_ catalog: [QuickSwitcherItem], for connectionId: UUID, version: Version) { items[connectionId] = catalog.map { item in var stored = item diff --git a/TablePro/Core/Utilities/UI/QualifiedSearchQuery.swift b/TablePro/Core/Utilities/UI/QualifiedSearchQuery.swift new file mode 100644 index 0000000000..93a3b32688 --- /dev/null +++ b/TablePro/Core/Utilities/UI/QualifiedSearchQuery.swift @@ -0,0 +1,88 @@ +// +// QualifiedSearchQuery.swift +// TablePro +// + +import Foundation + +/// A search that says where an object lives as well as what it is called: `attendance.timesheet`, +/// `attendance.` for everything in one schema, or `shop.attendance.timesheet`. +/// +/// It parses text that is still being typed rather than finished SQL, so it is lenient where an +/// identifier parser would refuse: spaces around a dot are ignored, an unterminated quote runs to +/// the end of the text, and the quotes of every engine the app speaks are accepted, `"x"`, `[x]` +/// and `` `x` ``, each with its doubled closing character as an escape. A dot inside quotes belongs +/// to the name. Text with no unquoted dot is not qualified, and neither is text with an empty +/// container such as `.orders` or `a..b`, so both stay ordinary searches. +internal struct QualifiedSearchQuery: Equatable, Sendable { + /// Outermost first: `["shop", "attendance"]` for `shop.attendance.timesheet`. + internal let containers: [String] + /// Empty when the text ends in a dot, which asks for everything in the container. + internal let name: String + + internal init?(_ text: String) { + let segments = Self.segments(of: text) + guard segments.count > 1, let name = segments.last else { return nil } + let containers = Array(segments.dropLast()) + guard !containers.contains(where: \.isEmpty) else { return nil } + self.containers = containers + self.name = name + } + + /// Pairs each container the query names with the part of `location` it has to match, right to + /// left, so `attendance.timesheet` reaches the schema of `[database, schema]` and + /// `shop.attendance.timesheet` reaches both. Nil when the query names more containers than the + /// location has, which no match can satisfy. + internal func containerPairs(with location: [String]) -> [(query: String, candidate: String)]? { + guard containers.count <= location.count else { return nil } + return Array(zip(containers, location.suffix(containers.count))) + } + + /// Where an object lives, outermost first, as a qualified query addresses it. A schema that + /// only repeats the database, which is how some engines report a schema-less object, is not a + /// second level. + internal static func location(database: String?, schema: String?) -> [String] { + var location: [String] = [] + if let database, !database.isEmpty { + location.append(database) + } + if let schema, !schema.isEmpty, schema != database { + location.append(schema) + } + return location + } + + private static let closingQuotes: [Character: Character] = ["\"": "\"", "`": "`", "[": "]"] + + private static func segments(of text: String) -> [String] { + var segments: [String] = [] + var current = "" + var closingQuote: Character? + var characters = Array(text)[...] + while let character = characters.popFirst() { + if let closing = closingQuote { + guard character == closing else { + current.append(character) + continue + } + if characters.first == closing { + current.append(closing) + characters.removeFirst() + } else { + closingQuote = nil + } + continue + } + if let closing = closingQuotes[character] { + closingQuote = closing + } else if character == "." { + segments.append(current.trimmingCharacters(in: .whitespaces)) + current = "" + } else { + current.append(character) + } + } + segments.append(current.trimmingCharacters(in: .whitespaces)) + return segments + } +} diff --git a/TablePro/Core/Utilities/UI/SidebarSearch.swift b/TablePro/Core/Utilities/UI/SidebarSearch.swift new file mode 100644 index 0000000000..e562bb8200 --- /dev/null +++ b/TablePro/Core/Utilities/UI/SidebarSearch.swift @@ -0,0 +1,62 @@ +// +// SidebarSearch.swift +// TablePro +// + +import Foundation + +/// The sidebar filter's text, read either as a name or as a qualified path. +/// +/// A plain query matches object names, and a container whose own name matches it shows everything +/// inside. A qualified one, `attendance.timesheet`, splits the two: its containers decide which +/// schemas and databases may hold a match, and only its last part is matched against object names, +/// so `attendance.` lists everything in `attendance` and nothing anywhere else. The text still +/// matches as a plain name too, or a table actually named `audit.events` could no longer be found +/// by typing its name. Matching is the same substring match the plain filter uses, never fuzzy. +internal struct SidebarSearch: Equatable, Sendable { + internal let text: String + internal let qualified: QualifiedSearchQuery? + + internal init(_ text: String) { + let trimmed = text.trimmingCharacters(in: .whitespaces) + self.text = trimmed + self.qualified = QualifiedSearchQuery(trimmed) + } + + internal var isEmpty: Bool { + text.isEmpty + } + + /// What object names are matched against. Empty for `attendance.`, where every object in an + /// admitted container matches. + internal var nameQuery: String { + qualified?.name ?? text + } + + internal func matchesName(_ name: String) -> Bool { + SidebarNameFilter.matches(query: nameQuery, candidate: name) + } + + /// An object matches as a path, or by holding the whole text in its own name. + internal func matchesObject(named name: String, database: String?, schema: String?) -> Bool { + if SidebarNameFilter.matches(query: text, candidate: name) { return true } + guard qualified != nil else { return false } + return admits(database: database, schema: schema) && matchesName(name) + } + + /// Whether a container at this location may hold a match. Every container may for a plain + /// query, which matches on object names alone. + internal func admits(database: String?, schema: String?) -> Bool { + guard let qualified else { return true } + let location = QualifiedSearchQuery.location(database: database, schema: schema) + guard let pairs = qualified.containerPairs(with: location) else { return false } + return pairs.allSatisfy { SidebarNameFilter.matches(query: $0.query, candidate: $0.candidate) } + } + + /// Whether the container itself answers the search: its name matches a plain query, or a + /// qualified query admits it and asks for everything inside. + internal func matchesContainer(database: String?, schema: String) -> Bool { + guard let qualified else { return SidebarNameFilter.matches(query: text, candidate: schema) } + return qualified.name.isEmpty && admits(database: database, schema: schema) + } +} diff --git a/TablePro/Models/UI/QuickSwitcherItem.swift b/TablePro/Models/UI/QuickSwitcherItem.swift index b37a3d67e0..03891a2e56 100644 --- a/TablePro/Models/UI/QuickSwitcherItem.swift +++ b/TablePro/Models/UI/QuickSwitcherItem.swift @@ -114,6 +114,23 @@ internal struct QuickSwitcherItem: Identifiable, Hashable, Sendable { /// Set on a routine or trigger row, which opens its source rather than a table tab. var objectRef: DatabaseObjectRef? var target: QuickSwitcherTarget? + /// The database of an object in the connection that opened the panel, which a query like + /// `shop.public.orders` names. `target` carries it for a result in another connection. + var databaseName: String? + /// Carried to the tab so Recent remembers what the object is. A sequence opened as a plain + /// view came back from Recent offering Drop View. + var tableType: TableInfo.TableType? + /// A table in a schema other than the one being browsed, whose row names that schema even + /// while selected, because two such rows can differ in nothing else. + var isOutsideBrowsedSchema: Bool = false + + /// Where the object lives, outermost first, for a qualified query to match. + var searchLocation: [String] { + guard let target else { + return QualifiedSearchQuery.location(database: databaseName, schema: schemaName) + } + return QualifiedSearchQuery.location(database: target.databaseName, schema: target.schemaName) + } /// The frecency identity of a table, produced identically by the two places that record one: /// the quick switcher, which knows the object's `TableInfo.TableType`, and the tab open @@ -126,9 +143,20 @@ internal struct QuickSwitcherItem: Identifiable, Hashable, Sendable { /// and those objects could never reach the Recent section or earn a frecency boost no matter /// how often they were opened. A name and a schema identify one object in a database whatever /// its type, so the type buys nothing here. + /// + /// A dot or backslash inside a name is escaped, or schema `a` with table `b.c` and schema `a.b` + /// with table `c` would share one id, one row selection and one Recent entry. A name with + /// neither keeps the id it always had, so no Recent history is lost. static func tableItemId(name: String, schema: String?) -> String { - guard let schema, !schema.isEmpty else { return "table_\(name)" } - return "table_\(schema).\(name)" + guard let schema, !schema.isEmpty else { return "table_\(escapedIdComponent(name))" } + return "table_\(escapedIdComponent(schema)).\(escapedIdComponent(name))" + } + + private static func escapedIdComponent(_ component: String) -> String { + guard component.contains(where: { $0 == "." || $0 == "\\" }) else { return component } + return component + .replacingOccurrences(of: "\\", with: "\\\\") + .replacingOccurrences(of: ".", with: "\\.") } /// SF Symbol name for this item's icon diff --git a/TablePro/ViewModels/QuickSwitcherViewModel.swift b/TablePro/ViewModels/QuickSwitcherViewModel.swift index 849dc33d6a..308a2308a3 100644 --- a/TablePro/ViewModels/QuickSwitcherViewModel.swift +++ b/TablePro/ViewModels/QuickSwitcherViewModel.swift @@ -14,6 +14,8 @@ private enum QuickSwitcherRanking { static let keywordMatchWeight = 1.0 static let frecencyBoost = 0.5 static let openTabBoost = 1.2 + static let containerMatchWeight = 0.5 + static let otherSchemaWeight = 0.97 } @MainActor @@ -46,6 +48,14 @@ internal final class QuickSwitcherViewModel: ObservableObject { let items: [QuickSwitcherItem] } + /// What the panel's own connection is browsing, which is what its table rows are built for. + struct TableSource { + let database: String? + let browseSchema: String? + let openTables: Set + let listsTablesPerSchema: Bool + } + nonisolated private static let logger = Logger(subsystem: "com.TablePro", category: "QuickSwitcherViewModel") private static let recentLimit = 10 private static let filterDebounceNanoseconds: UInt64 = 40_000_000 @@ -71,6 +81,10 @@ internal final class QuickSwitcherViewModel: ObservableObject { internal var crossConnectionQueryItems: [QuickSwitcherItem] = [] { didSet { scheduleFilter(debounced: false) } } + private var baseItems: [QuickSwitcherItem]? + private var tableItems: [QuickSwitcherItem] = [] + private var tableSource: TableSource? + private var tableSourceObservations: [AnyCancellable] = [] private var filterTask: Task? private var selectionQuery: String? private var selectionScope: QuickSwitcherScope? @@ -86,6 +100,9 @@ internal final class QuickSwitcherViewModel: ObservableObject { /// for a beat after the catalog arrives. Without this the panel calls that emptiness "no /// results" and says so, for the whole first sort. @Published private(set) var isFiltering = false + /// The tables of schemas other than the browsed one arrive after the rest of the catalog, so a + /// search that finds nothing yet is still loading rather than a miss. + @Published private(set) var isLoadingTables = false @Published private(set) var isLoadingCrossConnections = false @Published private(set) var isLoadingCrossConnectionQueries = false @Published private(set) var crossConnectionQueryContentRevision = 0 @@ -129,7 +146,8 @@ internal final class QuickSwitcherViewModel: ObservableObject { return isLoadingCrossConnectionQueries } guard scope != .all || !trimmedSearchText.isEmpty else { return false } - return isLoading || isFiltering + let awaitsTables = isLoadingTables && scope.includedKinds.map { $0.contains(.table) } ?? true + return isLoading || isFiltering || awaitsTables } private var trimmedSearchText: String { @@ -172,8 +190,10 @@ internal final class QuickSwitcherViewModel: ObservableObject { self.init(connectionId: connectionId, services: .live) } + /// Tables are not part of the cached catalog. They are merged in from the services that own + /// them, every time either one changes while the panel is open, so a list the sidebar loads or + /// the all-schema listing arriving after the panel opened still reaches it. func loadItems( - schemaProvider: SQLSchemaProvider, databaseType: DatabaseType, openTables: Set = [], browseSchema: String? = nil @@ -183,40 +203,47 @@ internal final class QuickSwitcherViewModel: ObservableObject { let loadId = UUID() activeLoadId = loadId + let tableSource = TableSource( + database: services.databaseManager.browseScope(for: connectionId)?.database, + browseSchema: browseSchema, + openTables: openTables, + listsTablesPerSchema: DatabaseTreeMetadataService.listsTablesPerSchema( + services.pluginManager.databaseGroupingStrategy(for: databaseType) + ) + ) + self.tableSource = tableSource + observeTableSources() + async let tablesLoaded: Void = loadTables(from: tableSource, loadId: loadId) + /// Read once and used both to key the catalog and to build it. Reading it again after the /// awaits below let the two disagree: the items were filtered by whatever the sidebar held /// when the fetches finished, and stored under whatever it held when they started. let databaseFilter = SharedSidebarState.forConnection(connectionId).databaseFilterSelected let catalogVersion = self.catalogVersion(databaseFilter: databaseFilter) if let cached = catalogStore.catalog(for: connectionId, version: catalogVersion) { - allItems = Self.applyingOpenState(to: cached, openTables: openTables, browsing: browseSchema) - return + baseItems = cached + } else { + let catalog = await loadBaseCatalog(databaseType: databaseType, databaseFilter: databaseFilter) + guard activeLoadId == loadId, !Task.isCancelled else { return } + if catalog.isComplete { + catalogStore.store(catalog.items, for: connectionId, version: catalogVersion) + } + baseItems = catalog.items } + tableItems = currentTableItems() + publishItems() + await tablesLoaded + } + /// Everything but the tables, which is what the catalog store keeps. Incomplete when a fetch + /// failed, and then it is not stored: a cached catalog is served without fetching anything, so + /// a schema list that timed out once would have stayed missing on every reopen. + private func loadBaseCatalog( + databaseType: DatabaseType, + databaseFilter: Set + ) async -> (items: [QuickSwitcherItem], isComplete: Bool) { var items: [QuickSwitcherItem] = [] - - if let scope = services.databaseManager.browseScope(for: connectionId) { - await SchemaProviderRegistry.shared.prepare( - for: scope, - connection: services.databaseManager.session(for: connectionId)?.connection - ) - } - - let tables = await schemaProvider.getTables() - for table in tables { - let presentation = Self.tablePresentation(for: table.type) - items.append(QuickSwitcherItem( - id: QuickSwitcherItem.tableItemId(name: table.name, schema: table.schema), - name: table.name, - kind: presentation.kind, - subtitle: presentation.subtitle, - isOpenInTab: openTables.contains( - QuickSwitcherOpenTable(schema: table.schema, name: table.name, browsing: browseSchema) - ), - isReadOnly: !table.type.allowsRowEditing, - schemaName: table.schema - )) - } + var isComplete = true let switchTarget = services.pluginManager.containerSwitchTarget(for: databaseType) let activeDatabase = services.databaseManager.session(for: connectionId) @@ -249,6 +276,7 @@ internal final class QuickSwitcherViewModel: ObservableObject { )) } } catch { + isComplete = false Self.logger.warning("Failed to fetch databases: \(error.publicLogShape, privacy: .public)") } } @@ -270,6 +298,7 @@ internal final class QuickSwitcherViewModel: ObservableObject { )) } } catch { + isComplete = false Self.logger.warning("Failed to fetch schemas: \(error.publicLogShape, privacy: .public)") } } @@ -304,10 +333,7 @@ internal final class QuickSwitcherViewModel: ObservableObject { )) } - guard activeLoadId == loadId, !Task.isCancelled else { return } - - catalogStore.store(items, for: connectionId, version: catalogVersion) - allItems = items + return (items, isComplete) } /// The catalog is a function of these, so a presentation that finds them unchanged can serve @@ -338,21 +364,64 @@ internal final class QuickSwitcherViewModel: ObservableObject { return names } - /// Which tables have a tab is not part of the catalog's version, so it is applied on the way - /// out rather than stored. A cached flag would badge a table the user has since closed. - nonisolated static func applyingOpenState( - to catalog: [QuickSwitcherItem], - openTables: Set, - browsing browseSchema: String? - ) -> [QuickSwitcherItem] { - catalog.map { item in - guard item.kind == .table || item.kind == .view || item.kind == .systemTable else { return item } - var updated = item - updated.isOpenInTab = openTables.contains( - QuickSwitcherOpenTable(schema: item.schemaName, name: item.name, browsing: browseSchema) - ) - return updated + /// The browse schema's tables come from the schema service, which the sidebar loaded on + /// connect; every other schema's come from the all-schema listing, which is asked for here. + private func loadTables(from source: TableSource, loadId: UUID) async { + isLoadingTables = true + defer { + if activeLoadId == loadId { isLoadingTables = false } } + _ = await services.schemaRefreshService.loadBrowseCatalogs(connectionIds: [connectionId]) + guard activeLoadId == loadId else { return } + mergeTableItems() + guard source.listsTablesPerSchema, let database = source.database else { return } + await DatabaseTreeMetadataService.shared.loadAllSchemaTables(connectionId: connectionId, database: database) + guard activeLoadId == loadId else { return } + mergeTableItems() + } + + /// A change to either source while the panel is open reaches it. A change that leaves the + /// tables as they were costs a comparison and no refilter. + private func observeTableSources() { + tableSourceObservations = [ + services.schemaService.onMainActorChange { [weak self] in self?.mergeTableItems() }, + DatabaseTreeMetadataService.shared.onMainActorChange { [weak self] in self?.mergeTableItems() } + ] + } + + private func mergeTableItems() { + let items = currentTableItems() + guard items != tableItems else { return } + tableItems = items + publishItems() + } + + private func currentTableItems() -> [QuickSwitcherItem] { + guard let tableSource else { return [] } + let allSchemaTables = tableSource.database.flatMap { database -> [TableInfo]? in + guard tableSource.listsTablesPerSchema else { return nil } + return DatabaseTreeMetadataService.shared + .allSchemaTablesLoadState(connectionId: connectionId, database: database).value?.tables + } ?? [] + let tables = Self.mergedTables( + local: services.schemaService.allLoadedTables(for: connectionId), + loadedFrom: services.schemaService.loadedScope(for: connectionId)?.database, + allSchemas: allSchemaTables, + browsing: tableSource.database + ) + return Self.makeTableItems( + tables, + database: tableSource.database, + browseSchema: tableSource.browseSchema, + openTables: tableSource.openTables + ) + } + + /// Nothing is shown before the rest of the catalog has arrived, as before tables were merged + /// separately: assigning `allItems` is what ends the load. + private func publishItems() { + guard let baseItems else { return } + allItems = tableItems + baseItems } /// Loading is keyed on a version of the world, so it must always record the version it @@ -559,6 +628,62 @@ internal final class QuickSwitcherViewModel: ObservableObject { ) } + /// The schema service answers for every schema it holds a list of, because it refreshes that + /// list the moment the catalog changes. The all-schema listing fills in the schemas it does not + /// hold, and may be a read behind for those until it is next asked. + /// + /// The schema service keeps its lists until a reload replaces them, so while a database switch + /// settles it still holds the old database's tables, which would open against the new one. + /// They count only once the database they were loaded from is the one being browsed. + nonisolated static func mergedTables( + local loaded: [TableInfo], + loadedFrom loadedDatabase: String?, + allSchemas: [TableInfo], + browsing database: String? + ) -> [TableInfo] { + let local = loadedDatabase == database ? loaded : [] + let localSchemas = Set(local.map { $0.schema ?? "" }) + var seen: Set = [] + return (local + allSchemas.filter { !localSchemas.contains($0.schema ?? "") }) + .filter { seen.insert(TableIdentity(schema: $0.schema ?? "", name: $0.name)).inserted } + } + + private struct TableIdentity: Hashable { + let schema: String + let name: String + } + + /// A table outside the browsed schema names its schema, and one inside it does not, the way + /// SQL written against the browsed schema would spell them. + nonisolated static func makeTableItems( + _ tables: [TableInfo], + database: String?, + browseSchema: String?, + openTables: Set + ) -> [QuickSwitcherItem] { + tables.map { table in + let presentation = tablePresentation(for: table.type) + let otherSchema = SchemaQualifiedName.explicitSchema(table.schema, implicitSchemaName: browseSchema) + let subtitle = [otherSchema, presentation.subtitle] + .compactMap { $0?.isEmpty == false ? $0 : nil } + .joined(separator: " ยท ") + return QuickSwitcherItem( + id: QuickSwitcherItem.tableItemId(name: table.name, schema: table.schema), + name: table.name, + kind: presentation.kind, + subtitle: subtitle, + isOpenInTab: openTables.contains( + QuickSwitcherOpenTable(schema: table.schema, name: table.name, browsing: browseSchema) + ), + isReadOnly: !table.type.allowsRowEditing, + schemaName: table.schema, + databaseName: database, + tableType: table.type, + isOutsideBrowsedSchema: otherSchema != nil + ) + } + } + nonisolated static func makeCrossConnectionItems( tables: [TableInfo], target: QuickSwitcherTarget @@ -579,7 +704,8 @@ internal final class QuickSwitcherViewModel: ObservableObject { kind: presentation.kind, subtitle: connectionPath(for: resolvedTarget), isReadOnly: !table.type.allowsRowEditing, - target: resolvedTarget + target: resolvedTarget, + tableType: table.type ) } } @@ -794,7 +920,10 @@ internal final class QuickSwitcherViewModel: ObservableObject { for kind in QuickSwitcherItemKind.displayOrder { let kindItems = items .filter { $0.kind == kind && !recentIdSet.contains($0.id) } - .sorted { $0.name.localizedStandardCompare($1.name) == .orderedAscending } + .sorted { lhs, rhs in + if lhs.isOutsideBrowsedSchema != rhs.isOutsideBrowsedSchema { return rhs.isOutsideBrowsedSchema } + return lhs.name.localizedStandardCompare(rhs.name) == .orderedAscending + } guard !kindItems.isEmpty else { continue } result.append(Group( id: "kind-\(kind.rawValue)", @@ -845,13 +974,17 @@ internal final class QuickSwitcherViewModel: ObservableObject { query: String, frecencyScores: [String: Double] ) async -> [Group] { + let qualified = QualifiedSearchQuery(query) var ranked = items.compactMap { item -> (item: QuickSwitcherItem, rank: Double)? in - guard let (matchScore, matchedIndices) = bestMatch(for: item, query: query) else { return nil } + guard let (matchScore, matchedIndices) = bestMatch(for: item, query: query, qualified: qualified) else { + return nil + } var matched = item matched.matchedIndices = matchedIndices let frecency = 1 + (frecencyScores[item.id] ?? 0) * QuickSwitcherRanking.frecencyBoost let openBoost = item.isOpenInTab ? QuickSwitcherRanking.openTabBoost : 1 - return (matched, matchScore * item.kind.rankWeight * frecency * openBoost) + let location = item.isOutsideBrowsedSchema ? QuickSwitcherRanking.otherSchemaWeight : 1 + return (matched, matchScore * item.kind.rankWeight * frecency * openBoost * location) } ranked.sort { lhs, rhs in if lhs.rank != rhs.rank { return lhs.rank > rhs.rank } @@ -868,7 +1001,39 @@ internal final class QuickSwitcherViewModel: ObservableObject { return [Group(id: "results", header: nil, items: items)] } + /// A dotted query is read both ways and the better reading wins: as a path, and as plain text, + /// which is what still finds a table literally named `b.c` and a connection path in a subtitle. nonisolated private static func bestMatch( + for item: QuickSwitcherItem, + query: String, + qualified: QualifiedSearchQuery? + ) -> (score: Double, matchedIndices: [Int])? { + let plain = plainMatch(for: item, query: query) + guard let qualified, let path = pathMatch(for: item, query: qualified) else { return plain } + guard let plain, plain.score >= path.score else { return path } + return plain + } + + /// Each container the query names has to match the part of the item's location it lines up + /// with, and the name has to match the item's name. An empty name, `attendance.`, takes every + /// item in the matched container. + nonisolated static func pathMatch( + for item: QuickSwitcherItem, + query: QualifiedSearchQuery + ) -> (score: Double, matchedIndices: [Int])? { + guard let pairs = query.containerPairs(with: item.searchLocation) else { return nil } + var containerScore = 0.0 + for pair in pairs { + guard let match = FuzzyMatcher.match(query: pair.query, candidate: pair.candidate) else { return nil } + containerScore += Double(match.score) + } + let weightedContainers = containerScore * QuickSwitcherRanking.containerMatchWeight + guard !query.name.isEmpty else { return (weightedContainers, []) } + guard let nameMatch = FuzzyMatcher.match(query: query.name, candidate: item.name) else { return nil } + return (Double(nameMatch.score) + weightedContainers, nameMatch.matchedIndices) + } + + nonisolated private static func plainMatch( for item: QuickSwitcherItem, query: String ) -> (score: Double, matchedIndices: [Int])? { @@ -953,7 +1118,8 @@ internal final class QuickSwitcherViewModel: ObservableObject { kind: routine.kind == .procedure ? .procedure : .function, subtitle: routine.schema ?? database ?? "", schemaName: routine.schema, - objectRef: DatabaseObjectRef(routine: routine, database: database ?? "") + objectRef: DatabaseObjectRef(routine: routine, database: database ?? ""), + databaseName: database ) } } @@ -966,7 +1132,8 @@ internal final class QuickSwitcherViewModel: ObservableObject { kind: .trigger, subtitle: trigger.table ?? trigger.schema ?? database ?? "", schemaName: trigger.schema, - objectRef: DatabaseObjectRef(trigger: trigger, database: database ?? "") + objectRef: DatabaseObjectRef(trigger: trigger, database: database ?? ""), + databaseName: database ) } } @@ -979,7 +1146,8 @@ internal final class QuickSwitcherViewModel: ObservableObject { kind: .userType, subtitle: type.schema ?? database ?? "", schemaName: type.schema, - objectRef: DatabaseObjectRef(userType: type, database: database ?? "") + objectRef: DatabaseObjectRef(userType: type, database: database ?? ""), + databaseName: database ) } } diff --git a/TablePro/ViewModels/SidebarViewModel.swift b/TablePro/ViewModels/SidebarViewModel.swift index 55dd8dfb92..d9cbb88457 100644 --- a/TablePro/ViewModels/SidebarViewModel.swift +++ b/TablePro/ViewModels/SidebarViewModel.swift @@ -6,6 +6,7 @@ import Combine import os import SwiftUI +import TableProPluginKit @MainActor final class SidebarViewModel: ObservableObject { @@ -103,7 +104,10 @@ final class SidebarViewModel: ObservableObject { } @Published private(set) var filterQuery = "" { - didSet { invalidateFilterCaches() } + didSet { + invalidateFilterCaches() + loadAllSchemaTablesForSearch() + } } private var filterDebounceTask: Task? @@ -426,9 +430,10 @@ final class SidebarViewModel: ObservableObject { } func filteredRecentTables(_ tables: [TableInfo]) -> [TableInfo] { - let query = filterQuery - guard !query.isEmpty else { return tables } - return tables.filter { SidebarNameFilter.matches(query: query, candidate: $0.name) } + let search = SidebarSearch(filterQuery) + guard !search.isEmpty else { return tables } + let database = browsedDatabase + return tables.filter { search.matchesObject(named: $0.name, database: database, schema: $0.schema) } } func filteredRoutines(of kind: SidebarObjectKind, from routines: [RoutineInfo]) -> [RoutineInfo] { @@ -452,7 +457,7 @@ final class SidebarViewModel: ObservableObject { if cachedFilteredTriggersFingerprint?.count != fingerprint.count || cachedFilteredTriggersFingerprint?.generation != fingerprint.generation || cachedFilteredTriggersFingerprint?.query != fingerprint.query { - cachedFilteredTriggers = DatabaseTreeFilter.filteredTriggers(triggers, searchText: query) + cachedFilteredTriggers = DatabaseTreeFilter.filteredTriggers(triggers, searchText: query, database: browsedDatabase) cachedFilteredTriggersFingerprint = fingerprint } return cachedFilteredTriggers @@ -464,7 +469,9 @@ final class SidebarViewModel: ObservableObject { if cachedFilteredUserTypesFingerprint?.count != fingerprint.count || cachedFilteredUserTypesFingerprint?.generation != fingerprint.generation || cachedFilteredUserTypesFingerprint?.query != fingerprint.query { - cachedFilteredUserTypes = DatabaseTreeFilter.filteredUserTypes(types, searchText: query) + cachedFilteredUserTypes = DatabaseTreeFilter.filteredUserTypes( + types, searchText: query, database: browsedDatabase + ) cachedFilteredUserTypesFingerprint = fingerprint } return cachedFilteredUserTypes @@ -475,8 +482,13 @@ final class SidebarViewModel: ObservableObject { return expanded[kind] } + /// A qualified search reaches this list only when it names the schema being browsed: the flat + /// list holds that schema alone, and the other schemas it names are listed below it. private func applyQuery(_ query: String, to tables: [TableInfo]) -> [TableInfo] { - SidebarNameFilter.ranked(tables, query: query, name: { $0.name }) + let search = SidebarSearch(query) + let database = browsedDatabase + let admitted = tables.filter { search.matchesObject(named: $0.name, database: database, schema: $0.schema) } + return SidebarNameFilter.ranked(admitted, query: search.nameQuery, name: { $0.name }) } /// Goes through DatabaseTreeFilter so the flat root and the tree share one dedup owner. The @@ -484,7 +496,35 @@ final class SidebarViewModel: ObservableObject { /// handed NSOutlineView the same node object at several row indices and selection snapped back /// to the first of them. private func applyRoutineQuery(_ query: String, to routines: [RoutineInfo]) -> [RoutineInfo] { - DatabaseTreeFilter.filteredRoutines(routines, searchText: query) + DatabaseTreeFilter.filteredRoutines(routines, searchText: query, database: browsedDatabase) + } + + /// Every object the flat list holds lives in this database, which a qualified search can name. + private var browsedDatabase: String? { + DatabaseManager.shared.browseScope(for: connectionId)?.database + } + + /// A search has to judge schemas nobody has opened, and the all-schema listing is what answers + /// for them. It is asked for here rather than by the outline, because a flat list with no local + /// match shows "No Results" in place of the outline, which then never sees the search at all. + /// Asked for the browsed database and for every database whose schemas the tree already shows, + /// never for one the user has not opened. + private func loadAllSchemaTablesForSearch() { + guard !filterQuery.isEmpty, + PluginManager.shared.databaseGroupingStrategy(for: databaseType) == .bySchema else { return } + let service = DatabaseTreeMetadataService.shared + let connectionId = connectionId + var databases = Set( + service.schemaList.compactMap { key, state in + key.connectionId == connectionId && state.value != nil ? key.database : nil + } + ) + if let browsedDatabase, !browsedDatabase.isEmpty { + databases.insert(browsedDatabase) + } + for database in databases { + Task { await service.loadAllSchemaTables(connectionId: connectionId, database: database) } + } } private func rebuildKindBuckets(from tables: [TableInfo]) { diff --git a/TablePro/Views/Main/Extensions/MainContentCoordinator+QuickSwitcher.swift b/TablePro/Views/Main/Extensions/MainContentCoordinator+QuickSwitcher.swift index 3294a4bd9c..57a7aafce3 100644 --- a/TablePro/Views/Main/Extensions/MainContentCoordinator+QuickSwitcher.swift +++ b/TablePro/Views/Main/Extensions/MainContentCoordinator+QuickSwitcher.swift @@ -23,8 +23,6 @@ extension MainContentCoordinator { FeatureTipSignals.quickSwitcherOpened() } let browseSchema = services.databaseManager.session(for: connectionId)?.browseSchema - let switcherScope = browseScope - ?? DatabaseScope(connectionId: connectionId, database: connection.database, schema: nil) let openTables = Set( tabManager.tabs .filter { $0.tabType == .table } @@ -38,7 +36,6 @@ extension MainContentCoordinator { } ) let panelView = QuickSwitcherPanelView( - schemaProvider: SchemaProviderRegistry.shared.getOrCreate(for: switcherScope), connectionId: connectionId, databaseType: connection.type, openTables: openTables, @@ -69,6 +66,7 @@ extension MainContentCoordinator { schema: schemaName, showStructure: intent == .openStructure, isView: item.isReadOnly, + objectType: item.tableType, activateGridFocus: true, forceNewTab: intent == .openInNewWindowTab ) @@ -79,6 +77,7 @@ extension MainContentCoordinator { schema: schemaName, showStructure: intent == .openStructure, isView: true, + objectType: item.tableType, activateGridFocus: true, forceNewTab: intent == .openInNewWindowTab ) @@ -121,6 +120,7 @@ extension MainContentCoordinator { item.name, schema: target.schemaName, isView: item.kind == .view || item.isReadOnly, + objectType: item.tableType, activateGridFocus: true, forceNewTab: intent == .openInNewWindowTab ) diff --git a/TablePro/Views/QuickSwitcher/QuickSwitcherPanelView.swift b/TablePro/Views/QuickSwitcher/QuickSwitcherPanelView.swift index ce6ad28f14..86156a88dc 100644 --- a/TablePro/Views/QuickSwitcher/QuickSwitcherPanelView.swift +++ b/TablePro/Views/QuickSwitcher/QuickSwitcherPanelView.swift @@ -7,7 +7,6 @@ import AppKit import SwiftUI struct QuickSwitcherPanelView: View { - let schemaProvider: SQLSchemaProvider let connectionId: UUID let databaseType: DatabaseType let openTables: Set @@ -18,7 +17,6 @@ struct QuickSwitcherPanelView: View { @StateObject private var viewModel: QuickSwitcherViewModel init( - schemaProvider: SQLSchemaProvider, connectionId: UUID, databaseType: DatabaseType, openTables: Set = [], @@ -26,7 +24,6 @@ struct QuickSwitcherPanelView: View { onSelect: @escaping (QuickSwitcherItem, QuickSwitcherCommitIntent) -> Void, onDismiss: @escaping () -> Void ) { - self.schemaProvider = schemaProvider self.connectionId = connectionId self.databaseType = databaseType self.openTables = openTables @@ -44,7 +41,6 @@ struct QuickSwitcherPanelView: View { } .task { await viewModel.loadItems( - schemaProvider: schemaProvider, databaseType: databaseType, openTables: openTables, browseSchema: browseSchema @@ -296,6 +292,7 @@ struct QuickSwitcherPanelContent: View { .contextMenu { contextMenuActions(for: item) } .accessibilityElement(children: .combine) .accessibilityLabel(Text(item.name)) + .accessibilityValue(Text(namesLocation(item) ? item.subtitle : "")) .accessibilityAddTraits(isSelected ? [.isButton, .isSelected] : .isButton) .accessibilityAction { onCommit(item, .open) } .id(item.id) @@ -345,10 +342,17 @@ struct QuickSwitcherPanelContent: View { } /// A cross-connection result keeps its path while selected, because it names the connection - /// the commit is about to open and nothing else on the row carries that. + /// the commit is about to open and nothing else on the row carries that. A table in another + /// schema keeps its schema for the same reason. private func showsSubtitle(for item: QuickSwitcherItem, isSelected: Bool) -> Bool { guard !item.subtitle.isEmpty else { return false } - return !isSelected || item.target != nil + return !isSelected || namesLocation(item) + } + + /// Spoken as well as shown, or two rows named `timesheet` in different schemas would read the + /// same to VoiceOver. + private func namesLocation(_ item: QuickSwitcherItem) -> Bool { + item.target != nil || item.isOutsideBrowsedSchema } private func commitHint(for item: QuickSwitcherItem) -> String { diff --git a/TablePro/Views/Sidebar/DatabaseTreeFilter.swift b/TablePro/Views/Sidebar/DatabaseTreeFilter.swift index ddb18fff15..acbcffff5f 100644 --- a/TablePro/Views/Sidebar/DatabaseTreeFilter.swift +++ b/TablePro/Views/Sidebar/DatabaseTreeFilter.swift @@ -58,31 +58,53 @@ enum DatabaseTreeFilter { SidebarNameFilter.matches(query: query, candidate: candidate) } - static func filteredTables(_ tables: [TableInfo], searchText: String) -> [TableInfo] { - let matched = SidebarNameFilter.ranked(tables, query: searchText, name: { $0.name }) + /// `database` is where the objects live when the caller knows it. A qualified search matches + /// each object's own schema, and the database only when the search names one. + static func filteredTables(_ tables: [TableInfo], searchText: String, database: String? = nil) -> [TableInfo] { + let search = SidebarSearch(searchText) + let admitted = tables.filter { search.matchesObject(named: $0.name, database: database, schema: $0.schema) } + let matched = SidebarNameFilter.ranked(admitted, query: search.nameQuery, name: { $0.name }) return deduplicated(matched, by: \.id) } - static func filteredRoutines(_ routines: [RoutineInfo], searchText: String) -> [RoutineInfo] { - let matched = SidebarNameFilter.ranked(routines, query: searchText, name: { $0.name }) + static func filteredRoutines( + _ routines: [RoutineInfo], + searchText: String, + database: String? = nil + ) -> [RoutineInfo] { + let search = SidebarSearch(searchText) + let admitted = routines.filter { search.matchesObject(named: $0.name, database: database, schema: $0.schema) } + let matched = SidebarNameFilter.ranked(admitted, query: search.nameQuery, name: { $0.name }) return deduplicated(matched, by: \.id) } /// A trigger is findable by its own name and by the table it fires for, because a reader who /// knows only the table is exactly the reader the database-level list exists for. - static func filteredTriggers(_ triggers: [TriggerInfo], searchText: String) -> [TriggerInfo] { - let matched = SidebarNameFilter.ranked(triggers, query: searchText, name: { $0.name }) - let byTable = searchText.isEmpty + static func filteredTriggers( + _ triggers: [TriggerInfo], + searchText: String, + database: String? = nil + ) -> [TriggerInfo] { + let search = SidebarSearch(searchText) + let named = triggers.filter { search.matchesObject(named: $0.name, database: database, schema: $0.schema) } + let matched = SidebarNameFilter.ranked(named, query: search.nameQuery, name: { $0.name }) + let byTable = search.nameQuery.isEmpty ? [] : triggers.filter { trigger in - guard let table = trigger.table, matches(searchText, table) else { return false } - return true + guard let table = trigger.table else { return false } + return search.matchesObject(named: table, database: database, schema: trigger.schema) } return deduplicated(matched + byTable, by: \.id) } - static func filteredUserTypes(_ types: [UserDefinedTypeInfo], searchText: String) -> [UserDefinedTypeInfo] { - let matched = SidebarNameFilter.ranked(types, query: searchText, name: { $0.name }) + static func filteredUserTypes( + _ types: [UserDefinedTypeInfo], + searchText: String, + database: String? = nil + ) -> [UserDefinedTypeInfo] { + let search = SidebarSearch(searchText) + let admitted = types.filter { search.matchesObject(named: $0.name, database: database, schema: $0.schema) } + let matched = SidebarNameFilter.ranked(admitted, query: search.nameQuery, name: { $0.name }) return deduplicated(matched, by: \.id) } @@ -91,21 +113,22 @@ enum DatabaseTreeFilter { routines: [RoutineInfo], triggers: [TriggerInfo], userTypes: [UserDefinedTypeInfo] = [], - searchText: String + searchText: String, + database: String? = nil ) -> DatabaseTreeObjectBuckets { var tableBuckets: [SidebarObjectKind: [TableInfo]] = [:] - for table in filteredTables(tables, searchText: searchText) { + for table in filteredTables(tables, searchText: searchText, database: database) { tableBuckets[SidebarObjectKind.resolve(tableType: table.type), default: []].append(table) } var routineBuckets: [SidebarObjectKind: [RoutineInfo]] = [:] - for routine in filteredRoutines(routines, searchText: searchText) { + for routine in filteredRoutines(routines, searchText: searchText, database: database) { routineBuckets[routine.kind.sidebarObjectKind, default: []].append(routine) } return DatabaseTreeObjectBuckets( tables: tableBuckets, routines: routineBuckets, - triggers: filteredTriggers(triggers, searchText: searchText), - userTypes: filteredUserTypes(userTypes, searchText: searchText) + triggers: filteredTriggers(triggers, searchText: searchText, database: database), + userTypes: filteredUserTypes(userTypes, searchText: searchText, database: database) ) } @@ -122,8 +145,9 @@ enum DatabaseTreeFilter { triggers: [TriggerInfo], userTypes: [UserDefinedTypeInfo] ) -> Bool { - if matches(searchText, schema) { return true } - guard isLoaded else { return true } + let search = SidebarSearch(searchText) + if search.matchesContainer(database: nil, schema: schema) { return true } + guard isLoaded else { return search.admits(database: nil, schema: schema) } return !objectBuckets( tables: tables, routines: routines, @@ -148,16 +172,19 @@ enum DatabaseTreeFilter { routines: routines, triggers: triggers, userTypes: userTypes, - searchText: matches(searchText, schema) ? "" : searchText + searchText: SidebarSearch(searchText).matchesContainer(database: nil, schema: schema) ? "" : searchText ) } + /// `contentMatches` answers for what is inside a schema, and for a qualified search it has to + /// apply the search's containers itself, as `schemaSearchVerdict` does. static func visibleSchemas( _ schemas: [String], systemSchemas: Set, activeSchema: String?, showsSystem: Bool, searchText: String, + database: String? = nil, contentMatches: (String) -> Bool ) -> [String] { let browsable = DatabaseTreeVisibility.visibleSchemas( @@ -166,12 +193,131 @@ enum DatabaseTreeFilter { activeSchema: activeSchema, showsSystem: showsSystem ) - let matched = searchText.isEmpty + let search = SidebarSearch(searchText) + let matched = search.isEmpty ? browsable - : browsable.filter { matches(searchText, $0) || contentMatches($0) } + : browsable.filter { search.matchesContainer(database: database, schema: $0) || contentMatches($0) } return deduplicated(matched, by: { $0 }) } + /// What a search can say about one schema of a database-grouped tree. `unknown` is a schema + /// whose objects neither the tree nor the all-schema listing can answer for yet, which stays on + /// screen collapsed, for the reason `hierarchicalSchemaIsVisible` keeps an unloaded schema. + enum SchemaSearchVerdict: Equatable { + case match + case noMatch + case unknown + + var isVisible: Bool { + self != .noMatch + } + } + + /// One pass over a database's all-schema listing, recording which schemas hold a match. A tree + /// judges hundreds of schemas against the same listing, and scanning it once per schema cost a + /// comparison per table per schema on every redraw. + struct SchemaListingMatches: Equatable { + let listed: Set + let matched: Set + let unlisted: Set + + init(listing: CatalogTableListing.Result, database: String, searchText: String) { + let search = SidebarSearch(searchText) + var listed: Set = [] + var matched: Set = [] + for table in listing.tables { + guard let schema = table.schema else { continue } + listed.insert(schema) + guard !matched.contains(schema), + search.matchesObject(named: table.name, database: database, schema: schema) else { continue } + matched.insert(schema) + } + self.listed = listed + self.matched = matched + self.unlisted = listing.unlistedSchemas + } + } + + /// The schema's own loaded lists answer first. A schema the tree has not loaded is judged from + /// the database's all-schema listing, and is unknown while that listing is missing, failed, or + /// says it could not read the schema, unless a qualified search names another schema: holding + /// every schema on screen for an object literally named with a dot is not worth it. + /// + /// `listingCoversSchema` is false for a schema the listing leaves out on purpose, a system + /// schema, which is judged by its loaded lists alone, as every unloaded schema used to be. + /// `countsSchemaName` is false where a schema that matches only by its own name would be + /// noise, as in the flat list, which names a schema only for the objects found in it. + static func schemaSearchVerdict( + schema: String, + database: String, + searchText: String, + loadedContent: DatabaseTreeObjectBuckets?, + listingMatches: SchemaListingMatches?, + listingCoversSchema: Bool = true, + countsSchemaName: Bool = true + ) -> SchemaSearchVerdict { + let search = SidebarSearch(searchText) + let namesContainer = search.qualified != nil || countsSchemaName + if namesContainer, search.matchesContainer(database: database, schema: schema) { return .match } + if let loadedContent { return loadedContent.isEmpty ? .noMatch : .match } + guard listingCoversSchema else { return .noMatch } + guard let listingMatches, !listingMatches.unlisted.contains(schema) else { + return search.admits(database: database, schema: schema) ? .unknown : .noMatch + } + return listingMatches.matched.contains(schema) ? .match : .noMatch + } + + /// A schema's objects as the tree has loaded them, filtered by the search. Nil until its tables + /// are loaded, so a search can tell a schema holding no match from one nobody has listed yet. + @MainActor + static func loadedObjectBuckets( + in service: DatabaseTreeMetadataService, + connectionId: UUID, + database: String, + schema: String?, + searchText: String + ) -> DatabaseTreeObjectBuckets? { + guard case .loaded(let tables) = service.tablesLoadState( + connectionId: connectionId, database: database, schema: schema + ) else { return nil } + return objectBuckets( + tables: tables, + routines: service.routines(connectionId: connectionId, database: database, schema: schema), + triggers: service.triggers(connectionId: connectionId, database: database, schema: schema), + userTypes: service.userDefinedTypes(connectionId: connectionId, database: database, schema: schema), + searchText: searchText, + database: database + ) + } + + /// The schemas besides the browsed one that a search found objects in, which the flat list adds + /// below its own sections. Only confirmed matches are named: a flat list that also named every + /// schema whose listing had not arrived would read as a list of results. + static func otherSchemaMatches( + database: String, + browsedSchema: String?, + searchText: String, + hiddenSchemas: Set, + allSchemaTables: MetadataLoadState, + loadedContent: (String) -> DatabaseTreeObjectBuckets? + ) -> [String] { + guard !SidebarSearch(searchText).isEmpty, let listing = allSchemaTables.value else { return [] } + let listingMatches = SchemaListingMatches(listing: listing, database: database, searchText: searchText) + return listingMatches.listed + .filter { schema in + guard schema != browsedSchema, !hiddenSchemas.contains(schema) else { return false } + return schemaSearchVerdict( + schema: schema, + database: database, + searchText: searchText, + loadedContent: loadedContent(schema), + listingMatches: listingMatches, + countsSchemaName: false + ) == .match + } + .sorted { $0.localizedStandardCompare($1) == .orderedAscending } + } + private static func deduplicated( _ items: [Element], by key: (Element) -> Key diff --git a/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Expansion.swift b/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Expansion.swift index 96f2edf371..9917236bd6 100644 --- a/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Expansion.swift +++ b/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Expansion.swift @@ -25,6 +25,12 @@ extension DatabaseTreeOutlineCoordinator { if outlineView.isItemExpanded(sectionNode) { restorePartitionExpansion(under: sectionNode) } case .redisKeysSection: setExpanded(sectionNode, searching || (viewModel?.isRedisKeysExpanded ?? true)) + case .schema: + setExpanded(sectionNode, true) + if outlineView.isItemExpanded(sectionNode) { + triggerLoad(for: sectionNode) + restoreObjectGroupExpansion(under: sectionNode) + } case .hierarchicalSchemaSection(let schema): let want = searching ? hierarchicalSchemaMatches(schema) @@ -53,7 +59,7 @@ extension DatabaseTreeOutlineCoordinator { for schemaNode in resolvedChildren(of: databaseNode) { guard case .schema(let database, let schema) = schemaNode.kind else { continue } let wantSchema = searching - ? DatabaseTreeFilter.matches(searchText, schema) || schemaContentMatchesSearch(database: database, schema: schema) + ? schemaSearchVerdict(database: database, schema: schema) == .match : windowState?.expandedTreeDatabaseSchemas.contains(DatabaseSchemaKey(database: database, schema: schema)) ?? false setExpanded(schemaNode, wantSchema) if outlineView.isItemExpanded(schemaNode) { diff --git a/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Nodes.swift b/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Nodes.swift index eca161ea7c..39d0fc113d 100644 --- a/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Nodes.swift +++ b/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Nodes.swift @@ -156,6 +156,11 @@ extension DatabaseTreeOutlineCoordinator { nodes += visibleObjectKinds().map { node(id: DatabaseTreeNode.objectKindSectionId($0), kind: .objectKindSection($0)) } + if let database = browsingDatabase { + nodes += flatOtherSchemaMatches(database: database).map { + node(id: DatabaseTreeNode.schemaId(database: database, schema: $0), kind: .schema(database: database, schema: $0)) + } + } if sidebarState?.redisKeyTreeViewModel != nil { nodes.append(node(id: DatabaseTreeNode.redisKeysSectionId, kind: .redisKeysSection)) } @@ -353,12 +358,36 @@ extension DatabaseTreeOutlineCoordinator { private func recentTableRefs() -> [DatabaseTreeTableRef] { guard let sidebarState, showRecentTables else { return [] } let database = browsingDatabase + let search = SidebarSearch(searchText) return sidebarState.recentEntries(inDatabase: database).compactMap { entry -> DatabaseTreeTableRef? in - if !searchText.isEmpty, !DatabaseTreeFilter.matches(searchText, entry.name) { return nil } + if !search.isEmpty { + guard search.matchesObject(named: entry.name, database: database, schema: entry.schema) else { + return nil + } + } return DatabaseTreeTableRef(database: database, schema: entry.schema, table: entry.tableInfo) } } + /// The flat list shows the browsed schema's objects only, so a search also names the other + /// schemas it found objects in. Each is the tree's own schema row, which expands, loads and + /// offers its menus exactly as it does in the tree. + private func flatOtherSchemaMatches(database: String) -> [String] { + guard !searchText.isEmpty, listsTablesPerSchema else { return [] } + return DatabaseTreeFilter.otherSchemaMatches( + database: database, + browsedSchema: activeSchema, + searchText: searchText, + hiddenSchemas: showSystemContainers ? [] : systemSchemas, + allSchemaTables: service.allSchemaTablesLoadState(connectionId: connectionId, database: database), + loadedContent: { self.loadedObjectBuckets(database: database, schema: $0) } + ) + } + + internal var listsTablesPerSchema: Bool { + DatabaseTreeMetadataService.listsTablesPerSchema(PluginManager.shared.databaseGroupingStrategy(for: databaseType)) + } + private func schemaNodes(database: String) -> [DatabaseTreeNode] { let parentId = DatabaseTreeNode.databaseId(database) switch service.schemaListState(connectionId: connectionId, database: database) { @@ -373,7 +402,8 @@ extension DatabaseTreeOutlineCoordinator { activeSchema: database == browsingDatabase ? activeSchema : nil, showsSystem: showSystemContainers, searchText: searchText, - contentMatches: { schemaContentMatchesSearch(database: database, schema: $0) } + database: database, + contentMatches: { schemaSearchVerdict(database: database, schema: $0).isVisible } ) if visible.isEmpty { return [statusNode(parentId: parentId, status: .empty)] } return visible.map { @@ -409,13 +439,23 @@ extension DatabaseTreeOutlineCoordinator { routines: service.routines(connectionId: connectionId, database: database, schema: schema), triggers: service.triggers(connectionId: connectionId, database: database, schema: schema), userTypes: service.userDefinedTypes(connectionId: connectionId, database: database, schema: schema), - searchText: searchText + searchText: searchText, + database: database ) } objectBucketsCache[key] = buckets return buckets } + /// Nil until the tree has loaded this schema's tables, so a search can tell a schema that holds + /// no match from one nobody has listed yet. + private func loadedObjectBuckets(database: String, schema: String?) -> DatabaseTreeObjectBuckets? { + guard case .loaded = service.tablesLoadState(connectionId: connectionId, database: database, schema: schema) else { + return nil + } + return objectBuckets(database: database, schema: schema) + } + /// A fetch the engine never runs stays idle for good, and idle is not loaded: counting it /// would hold every empty container on a spinner for a list that is never coming. So only the /// kinds this engine declares take part in deciding between "empty" and "loading". @@ -541,24 +581,57 @@ extension DatabaseTreeOutlineCoordinator { // MARK: - Search + /// A database is kept when its name answers a plain search, when a schema of it is kept, or when + /// objects it holds outside any schema match. Only schemas the tree would show are asked, so a + /// hidden system schema cannot keep a database on screen that shows nothing matching. internal func databaseMatchesSearch(_ metadata: DatabaseMetadata) -> Bool { - if DatabaseTreeFilter.matches(searchText, metadata.name) { return true } + let search = SidebarSearch(searchText) + if search.qualified == nil, DatabaseTreeFilter.matches(searchText, metadata.name) { return true } if case .loaded(let schemas) = service.schemaListState(connectionId: connectionId, database: metadata.name) { - if schemas.contains(where: { DatabaseTreeFilter.matches(searchText, $0) }) { return true } - for schema in schemas where schemaContentMatchesSearch(database: metadata.name, schema: schema) { + let browsable = DatabaseTreeVisibility.visibleSchemas( + schemas, + systemSchemas: systemSchemas, + activeSchema: metadata.name == browsingDatabase ? activeSchema : nil, + showsSystem: showSystemContainers + ) + if browsable.contains(where: { schemaSearchVerdict(database: metadata.name, schema: $0).isVisible }) { return true } } - return schemaContentMatchesSearch(database: metadata.name, schema: nil) + return databaseContentMatchesSearch(database: metadata.name) } - internal func schemaContentMatchesSearch(database: String, schema: String?) -> Bool { - if let schema, DatabaseTreeFilter.matches(searchText, schema) { return true } - let tables = service.tables(connectionId: connectionId, database: database, schema: schema) - if tables.contains(where: { DatabaseTreeFilter.matches(searchText, $0.name) }) { return true } - let routines = service.routines(connectionId: connectionId, database: database, schema: schema) - if routines.contains(where: { DatabaseTreeFilter.matches(searchText, $0.name) }) { return true } - let types = service.userDefinedTypes(connectionId: connectionId, database: database, schema: schema) - return types.contains { DatabaseTreeFilter.matches(searchText, $0.name) } + internal func schemaSearchVerdict(database: String, schema: String) -> DatabaseTreeFilter.SchemaSearchVerdict { + DatabaseTreeFilter.schemaSearchVerdict( + schema: schema, + database: database, + searchText: searchText, + loadedContent: loadedObjectBuckets(database: database, schema: schema), + listingMatches: listingMatches(database: database), + listingCoversSchema: listsTablesPerSchema && !systemSchemas.contains(schema) + ) + } + + /// Worked out once per database per redraw, since every schema of the database is judged + /// against the same listing. + private func listingMatches(database: String) -> DatabaseTreeFilter.SchemaListingMatches? { + let key = DatabaseTreeContainerKey(database: database, schema: nil, searchText: searchText) + if let cached = listingMatchesCache[key] { return cached } + guard let listing = service.allSchemaTablesLoadState(connectionId: connectionId, database: database).value else { + return nil + } + let matches = DatabaseTreeFilter.SchemaListingMatches(listing: listing, database: database, searchText: searchText) + listingMatchesCache[key] = matches + return matches + } + + /// The objects a database holds outside any schema, which is every object on an engine with no + /// schema level. `shop.` asks for all of them, and a schema engine has none to give. + private func databaseContentMatchesSearch(database: String) -> Bool { + let search = SidebarSearch(searchText) + if search.qualified != nil, search.nameQuery.isEmpty { + return !supportsSchemaLevel && search.admits(database: database, schema: nil) + } + return !objectBuckets(database: database, schema: nil).isEmpty } } diff --git a/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator.swift b/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator.swift index b52be414bd..67166daef1 100644 --- a/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator.swift +++ b/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator.swift @@ -38,6 +38,7 @@ final class DatabaseTreeOutlineCoordinator: NSObject, NSTextFieldDelegate { internal var nodeCache: [String: DatabaseTreeNode] = [:] internal var childrenCache: [String: [DatabaseTreeNode]] = [:] internal var objectBucketsCache: [DatabaseTreeContainerKey: DatabaseTreeObjectBuckets] = [:] + internal var listingMatchesCache: [DatabaseTreeContainerKey: DatabaseTreeFilter.SchemaListingMatches] = [:] /// Whether a routine row shows its signature depends on the other rows in its own section, so /// the label is decided where the section is built and looked up here when the row draws. internal var routineDisplayLabels: [String: String] = [:] @@ -293,6 +294,7 @@ final class DatabaseTreeOutlineCoordinator: NSObject, NSTextFieldDelegate { isReloading = true childrenCache.removeAll() objectBucketsCache.removeAll() + listingMatchesCache.removeAll() routineDisplayLabels.removeAll() invalidateRowConfiguration() outlineView.reloadData() diff --git a/TablePro/Views/Sidebar/SidebarView.swift b/TablePro/Views/Sidebar/SidebarView.swift index 523948eabd..bbcf32d05e 100644 --- a/TablePro/Views/Sidebar/SidebarView.swift +++ b/TablePro/Views/Sidebar/SidebarView.swift @@ -16,6 +16,7 @@ struct SidebarView: View { @State private var showsSchemaProgress = false @ObservedObject private var schemaService = SchemaService.shared + @ObservedObject private var treeMetadata = DatabaseTreeMetadataService.shared @ObservedObject var sidebarState: SharedSidebarState @ObservedObject var windowState: WindowSidebarState @@ -44,7 +45,33 @@ struct SidebarView: View { private var hasAnyMatch: Bool { SidebarObjectKind.allCases.contains { kind in countFor(kind: kind) > 0 - } + } || !otherSchemaMatches.isEmpty + } + + /// The schemas the flat outline lists below its own sections. Counted here too, or a search + /// whose only matches are in another schema is shown as "No Results" and the outline that would + /// have listed them is never drawn. + private var otherSchemaMatches: [String] { + guard rootShape == .flat, !viewModel.filterQuery.isEmpty, let database = activeDatabase, + DatabaseTreeMetadataService.listsTablesPerSchema(groupingStrategy) else { return [] } + let searchText = viewModel.filterQuery + let systemSchemas = Set(PluginManager.shared.systemSchemaNames(for: viewModel.databaseType)) + return DatabaseTreeFilter.otherSchemaMatches( + database: database, + browsedSchema: coordinator?.toolbarState.currentSchema, + searchText: searchText, + hiddenSchemas: settingsManager.general.showSystemContainers ? [] : systemSchemas, + allSchemaTables: treeMetadata.allSchemaTablesLoadState(connectionId: connectionId, database: database), + loadedContent: { schema in + DatabaseTreeFilter.loadedObjectBuckets( + in: treeMetadata, + connectionId: connectionId, + database: database, + schema: schema, + searchText: searchText + ) + } + ) } private var groupingStrategy: GroupingStrategy { diff --git a/TableProTests/Core/Autocomplete/SQLSchemaProviderTests.swift b/TableProTests/Core/Autocomplete/SQLSchemaProviderTests.swift index bf46b5c4c3..b36d3d9693 100644 --- a/TableProTests/Core/Autocomplete/SQLSchemaProviderTests.swift +++ b/TableProTests/Core/Autocomplete/SQLSchemaProviderTests.swift @@ -151,9 +151,42 @@ final class MockDatabaseDriver: DatabaseDriver, SchemaSwitchable, @unchecked Sen } guard let schema else { return tablesToReturn } fetchSchemaTablesCalls.append(schema) + if let error = schemaTablesErrors[schema] { + throw error + } return schemaTablesToReturn[schema] ?? tablesToReturn } + /// Nil leaves the driver without a single call, so the host lists each schema itself. + var allSchemaTablesToReturn: [TableInfo]? + var allSchemaTablesError: Error? + var schemaTablesErrors: [String: Error] = [:] + var fetchTablesInAllSchemasCallCount = 0 + var pausesNextAllSchemaTablesFetch = false + var onAllSchemaTablesFetchPaused: (@Sendable () -> Void)? + private var allSchemaTablesGate: CheckedContinuation? + + func resumeAllSchemaTablesFetch() { + allSchemaTablesGate?.resume() + allSchemaTablesGate = nil + } + + func fetchTablesInAllSchemas() async throws -> [TableInfo]? { + fetchTablesInAllSchemasCallCount += 1 + if let allSchemaTablesError { + throw allSchemaTablesError + } + let snapshot = allSchemaTablesToReturn + if pausesNextAllSchemaTablesFetch { + pausesNextAllSchemaTablesFetch = false + await withCheckedContinuation { continuation in + allSchemaTablesGate = continuation + onAllSchemaTablesFetchPaused?() + } + } + return snapshot + } + func fetchColumns(table: String) async throws -> [ColumnInfo] { fetchColumnsCallCount += 1 fetchColumnsCalls.append(table) diff --git a/TableProTests/Core/Concurrency/CatalogFreshnessTests.swift b/TableProTests/Core/Concurrency/CatalogFreshnessTests.swift new file mode 100644 index 0000000000..d53c229c41 --- /dev/null +++ b/TableProTests/Core/Concurrency/CatalogFreshnessTests.swift @@ -0,0 +1,71 @@ +// +// CatalogFreshnessTests.swift +// TableProTests +// + +import Foundation +@testable import TablePro +import Testing + +@Suite("CatalogFreshness") +struct CatalogFreshnessTests { + @Test("A key never fetched is not current") + func neverFetched() { + let freshness = CatalogFreshness() + #expect(!freshness.isCurrent("shop")) + } + + @Test("A committed fetch makes the key current") + func committedFetch() { + var freshness = CatalogFreshness() + let revision = freshness.revision(for: "shop") + #expect(freshness.commit(revision, for: "shop")) + #expect(freshness.isCurrent("shop")) + } + + @Test("A change after the commit makes the key stale again") + func changeAfterCommit() { + var freshness = CatalogFreshness() + _ = freshness.commit(freshness.revision(for: "shop"), for: "shop") + freshness.markChanged("shop") + #expect(!freshness.isCurrent("shop")) + } + + @Test("A fetch that started before a change commits its rows but leaves the key stale") + func fetchOvertakenByChange() { + var freshness = CatalogFreshness() + let started = freshness.revision(for: "shop") + freshness.markChanged("shop") + #expect(freshness.commit(started, for: "shop")) + #expect(!freshness.isCurrent("shop")) + } + + @Test("An older fetch finishing last cannot replace a newer one") + func olderFetchFinishingLast() { + var freshness = CatalogFreshness() + let older = freshness.revision(for: "shop") + freshness.markChanged("shop") + let newer = freshness.revision(for: "shop") + #expect(freshness.commit(newer, for: "shop")) + #expect(!freshness.commit(older, for: "shop")) + #expect(freshness.isCurrent("shop")) + } + + @Test("A change to one key leaves another current") + func keysAreIndependent() { + var freshness = CatalogFreshness() + _ = freshness.commit(freshness.revision(for: "shop"), for: "shop") + _ = freshness.commit(freshness.revision(for: "blog"), for: "blog") + freshness.markChanged("blog") + #expect(freshness.isCurrent("shop")) + #expect(!freshness.isCurrent("blog")) + } + + @Test("Removed keys are fetched again") + func removedKeys() { + var freshness = CatalogFreshness() + _ = freshness.commit(freshness.revision(for: "shop"), for: "shop") + freshness.removeAll { $0 == "shop" } + #expect(!freshness.isCurrent("shop")) + } +} diff --git a/TableProTests/Core/Database/CatalogTableListingTests.swift b/TableProTests/Core/Database/CatalogTableListingTests.swift new file mode 100644 index 0000000000..54e8c52cca --- /dev/null +++ b/TableProTests/Core/Database/CatalogTableListingTests.swift @@ -0,0 +1,122 @@ +// +// CatalogTableListingTests.swift +// TableProTests +// + +import Foundation +@testable import TablePro +import TableProPluginKit +import Testing + +@Suite("CatalogTableListing") +@MainActor +struct CatalogTableListingTests { + private struct ListingFailed: Error {} + + private let scope = DatabaseScope(connectionId: UUID(), database: "shop", schema: nil) + + private func table(_ name: String, _ schema: String) -> TableInfo { + TestFixtures.makeTableInfo(name: name, schema: schema) + } + + @Test("A single call answers for every schema, less the excluded ones") + func singleCall() async throws { + let driver = MockDatabaseDriver() + driver.allSchemaTablesToReturn = [table("users", "public"), table("pg_class", "pg_catalog")] + let metadata = RecordingMetadataProvider(driver: driver) + + let listing = try await CatalogTableListing.tables(in: scope, excludingSchemas: ["pg_catalog"], metadata: metadata) + + #expect(listing.tables.map(\.name) == ["users"]) + #expect(listing.unlistedSchemas.isEmpty) + #expect(driver.fetchSchemasCallCount == 0) + } + + /// A scope per schema would open a pooled connection per schema, one for every schema of a + /// database with hundreds of them. + @Test("Every per-schema read goes through the one scope it was given") + func perSchemaReadsShareOneScope() async throws { + let driver = MockDatabaseDriver() + driver.schemasToReturn = ["public", "attendance", "sales"] + driver.schemaTablesToReturn = [ + "public": [table("users", "public")], + "attendance": [table("timesheet", "attendance")], + "sales": [table("orders", "sales")] + ] + let metadata = RecordingMetadataProvider(driver: driver) + + let listing = try await CatalogTableListing.tables(in: scope, excludingSchemas: ["sales"], metadata: metadata) + + #expect(listing.tables.map(\.name) == ["users", "timesheet"]) + #expect(driver.fetchSchemaTablesCalls == ["public", "attendance"]) + #expect(Set(metadata.requestedScopes) == [scope]) + #expect(metadata.requestedWorkloads.allSatisfy { $0 == .bulk }) + } + + @Test("A schema whose read fails is named, not read as empty") + func failedSchemaIsNamed() async throws { + let driver = MockDatabaseDriver() + driver.schemasToReturn = ["public", "attendance"] + driver.schemaTablesToReturn = ["public": [table("users", "public")]] + driver.schemaTablesErrors = ["attendance": ListingFailed()] + + let listing = try await CatalogTableListing.tables( + in: scope, excludingSchemas: [], metadata: RecordingMetadataProvider(driver: driver) + ) + + #expect(listing.tables.map(\.name) == ["users"]) + #expect(listing.unlistedSchemas == ["attendance"]) + } + + @Test("A second read of unlisted schemas folds in what it listed and keeps what it could not") + func mergingARetry() { + let first = CatalogTableListing.Result( + tables: [table("users", "public")], + unlistedSchemas: ["attendance", "payroll"] + ) + let retry = CatalogTableListing.Result( + tables: [table("timesheet", "attendance")], + unlistedSchemas: ["payroll"] + ) + + let merged = first.merging(retry, retried: ["attendance", "payroll"]) + + #expect(merged.tables.map(\.name) == ["users", "timesheet"]) + #expect(merged.unlistedSchemas == ["payroll"]) + } + + @Test("A failed schema list fails the whole listing") + func failedSchemaListThrows() async { + let driver = MockDatabaseDriver() + driver.fetchSchemasError = ListingFailed() + + await #expect(throws: ListingFailed.self) { + try await CatalogTableListing.tables( + in: scope, excludingSchemas: [], metadata: RecordingMetadataProvider(driver: driver) + ) + } + } +} + +@MainActor +private final class RecordingMetadataProvider: ScopedMetadataProviding { + private let driver: MockDatabaseDriver + private(set) var requestedScopes: [DatabaseScope] = [] + private(set) var requestedWorkloads: [MetadataConnectionPool.Workload] = [] + + init(driver: MockDatabaseDriver) { + self.driver = driver + } + + func withMetadataDriver( + scope: DatabaseScope, + workload: MetadataConnectionPool.Workload, + _ body: @Sendable @escaping (DatabaseDriver) async throws -> T + ) async throws -> T { + requestedScopes.append(scope) + requestedWorkloads.append(workload) + return try await body(driver) + } + + func browseScope(for connectionId: UUID) -> DatabaseScope? { nil } +} diff --git a/TableProTests/Core/Services/Query/DatabaseTreeAllSchemaTablesTests.swift b/TableProTests/Core/Services/Query/DatabaseTreeAllSchemaTablesTests.swift new file mode 100644 index 0000000000..21779d11dd --- /dev/null +++ b/TableProTests/Core/Services/Query/DatabaseTreeAllSchemaTablesTests.swift @@ -0,0 +1,221 @@ +// +// DatabaseTreeAllSchemaTablesTests.swift +// TableProTests +// + +import Foundation +@testable import TablePro +import TableProPluginKit +import Testing + +/// Uses PGlite because it cannot open a pooled connection, so every read stays on the injected +/// session driver, and because it groups by schema with `pg_catalog` as a system schema. +@Suite("DatabaseTreeMetadataService all-schema tables") +@MainActor +struct DatabaseTreeAllSchemaTablesTests { + private struct ListingFailed: Error {} + + private let service = DatabaseTreeMetadataService.shared + + private func connect(_ configure: (MockDatabaseDriver) -> Void) -> (DatabaseConnection, MockDatabaseDriver) { + let connection = TestFixtures.makeConnection(type: .pglite) + let driver = MockDatabaseDriver(connection: connection) + configure(driver) + var session = ConnectionSession(connection: connection, driver: driver) + session.status = .connected + DatabaseManager.shared.injectSession(session, for: connection.id) + return (connection, driver) + } + + private func disconnect(_ connection: DatabaseConnection) async { + await service.handleDisconnect(connectionId: connection.id) + DatabaseManager.shared.removeSession(for: connection.id) + } + + private func listing(_ connection: DatabaseConnection) -> CatalogTableListing.Result? { + service.allSchemaTablesLoadState(connectionId: connection.id, database: connection.database).value + } + + private func load(_ connection: DatabaseConnection) async { + await service.loadAllSchemaTables(connectionId: connection.id, database: connection.database) + } + + private func table(_ name: String, _ schema: String) -> TableInfo { + TestFixtures.makeTableInfo(name: name, schema: schema) + } + + @Test("An engine with a single call is asked once, and system schemas stay out") + func singleCall() async { + let (connection, driver) = connect { driver in + driver.allSchemaTablesToReturn = [ + table("users", "public"), table("timesheet", "attendance"), table("pg_class", "pg_catalog") + ] + } + await load(connection) + + #expect(listing(connection)?.tables.map(\.name) == ["users", "timesheet"]) + #expect(driver.fetchTablesInAllSchemasCallCount == 1) + #expect(driver.fetchSchemasCallCount == 0) + await disconnect(connection) + } + + @Test("Any other engine is asked schema by schema, skipping system schemas") + func perSchemaFallback() async { + let (connection, driver) = connect { driver in + driver.schemasToReturn = ["public", "attendance", "pg_catalog"] + driver.schemaTablesToReturn = [ + "public": [table("users", "public")], + "attendance": [table("timesheet", "attendance")], + "pg_catalog": [table("pg_class", "pg_catalog")] + ] + } + await load(connection) + + #expect(listing(connection)?.tables.map(\.name) == ["users", "timesheet"]) + #expect(driver.fetchSchemaTablesCalls == ["public", "attendance"]) + await disconnect(connection) + } + + @Test("A schema that cannot be listed is named, and the rest are still listed") + func unlistedSchema() async { + let (connection, _) = connect { driver in + driver.schemasToReturn = ["public", "attendance"] + driver.schemaTablesToReturn = ["public": [table("users", "public")]] + driver.schemaTablesErrors = ["attendance": ListingFailed()] + } + await load(connection) + + #expect(listing(connection)?.tables.map(\.name) == ["users"]) + #expect(listing(connection)?.unlistedSchemas == ["attendance"]) + await disconnect(connection) + } + + @Test("A schema that could not be listed is asked for again on the next read, alone") + func unlistedSchemaIsRetriedAlone() async { + let (connection, driver) = connect { driver in + driver.schemasToReturn = ["public", "attendance"] + driver.schemaTablesToReturn = [ + "public": [table("users", "public")], + "attendance": [table("timesheet", "attendance")] + ] + driver.schemaTablesErrors = ["attendance": ListingFailed()] + } + await load(connection) + #expect(listing(connection)?.unlistedSchemas == ["attendance"]) + + driver.schemaTablesErrors = [:] + await load(connection) + + #expect(driver.fetchSchemaTablesCalls == ["public", "attendance", "attendance"]) + #expect(driver.fetchSchemasCallCount == 1) + #expect(listing(connection)?.tables.map(\.name) == ["users", "timesheet"]) + #expect(listing(connection)?.unlistedSchemas.isEmpty == true) + await disconnect(connection) + } + + @Test("A second read is served without fetching again") + func secondReadIsCached() async { + let (connection, driver) = connect { $0.allSchemaTablesToReturn = [table("users", "public")] } + await load(connection) + await load(connection) + + #expect(driver.fetchTablesInAllSchemasCallCount == 1) + await disconnect(connection) + } + + @Test("A catalog change marks the listing stale without fetching, and the next read refetches") + func catalogChangeMarksStale() async { + let (connection, driver) = connect { $0.allSchemaTablesToReturn = [table("users", "public")] } + await load(connection) + + driver.allSchemaTablesToReturn = [table("users", "public"), table("timesheet", "attendance")] + await service.refreshCatalog(for: CatalogChange(connectionId: connection.id, kinds: .tables)) + #expect(driver.fetchTablesInAllSchemasCallCount == 1) + #expect(listing(connection)?.tables.map(\.name) == ["users"]) + + await load(connection) + #expect(driver.fetchTablesInAllSchemasCallCount == 2) + #expect(listing(connection)?.tables.map(\.name) == ["users", "timesheet"]) + await disconnect(connection) + } + + @Test("A change that cannot touch the tables leaves the listing current") + func unrelatedChangeKeepsListing() async { + let (connection, driver) = connect { $0.allSchemaTablesToReturn = [table("users", "public")] } + await load(connection) + + await service.refreshCatalog(for: CatalogChange(connectionId: connection.id, kinds: .routines)) + await service.refreshCatalog( + for: CatalogChange(connectionId: connection.id, database: "elsewhere", kinds: .tables) + ) + await load(connection) + + #expect(driver.fetchTablesInAllSchemasCallCount == 1) + await disconnect(connection) + } + + @Test("A failed refresh keeps the rows it had and is retried on the next read") + func failedRefreshKeepsRows() async { + let (connection, driver) = connect { $0.allSchemaTablesToReturn = [table("users", "public")] } + await load(connection) + await service.refreshCatalog(for: CatalogChange(connectionId: connection.id, kinds: .tables)) + + driver.allSchemaTablesError = ListingFailed() + await load(connection) + #expect(listing(connection)?.tables.map(\.name) == ["users"]) + + driver.allSchemaTablesError = nil + driver.allSchemaTablesToReturn = [table("orders", "public")] + await load(connection) + #expect(listing(connection)?.tables.map(\.name) == ["orders"]) + #expect(driver.fetchTablesInAllSchemasCallCount == 3) + await disconnect(connection) + } + + @Test("A first read that fails reports the failure") + func firstReadFails() async { + let (connection, _) = connect { $0.allSchemaTablesError = ListingFailed() } + await load(connection) + + guard case .failed = service.allSchemaTablesLoadState( + connectionId: connection.id, database: connection.database + ) else { + Issue.record("expected a failed state") + await disconnect(connection) + return + } + await disconnect(connection) + } + + @Test("A fetch that started before a catalog change delivers its rows but leaves the listing stale") + func fetchOvertakenByChange() async { + let (connection, driver) = connect { driver in + driver.allSchemaTablesToReturn = [table("users", "public")] + driver.pausesNextAllSchemaTablesFetch = true + } + var first: Task? + await withCheckedContinuation { (paused: CheckedContinuation) in + driver.onAllSchemaTablesFetchPaused = { paused.resume() } + first = Task { await load(connection) } + } + await service.refreshCatalog(for: CatalogChange(connectionId: connection.id, kinds: .tables)) + driver.resumeAllSchemaTablesFetch() + await first?.value + #expect(listing(connection)?.tables.map(\.name) == ["users"]) + + driver.allSchemaTablesToReturn = [table("users", "public"), table("orders", "public")] + await load(connection) + #expect(driver.fetchTablesInAllSchemasCallCount == 2) + #expect(listing(connection)?.tables.map(\.name) == ["users", "orders"]) + await disconnect(connection) + } + + @Test("A disconnect drops the listing") + func disconnectDropsListing() async { + let (connection, _) = connect { $0.allSchemaTablesToReturn = [table("users", "public")] } + await load(connection) + await disconnect(connection) + + #expect(listing(connection) == nil) + } +} diff --git a/TableProTests/Core/Services/Query/DatabaseTreeCatalogRefreshPlanTests.swift b/TableProTests/Core/Services/Query/DatabaseTreeCatalogRefreshPlanTests.swift index 8fd03444bb..a7ed3c8cea 100644 --- a/TableProTests/Core/Services/Query/DatabaseTreeCatalogRefreshPlanTests.swift +++ b/TableProTests/Core/Services/Query/DatabaseTreeCatalogRefreshPlanTests.swift @@ -160,4 +160,44 @@ struct DatabaseTreeCatalogRefreshPlanTests { #expect(result.schemaLists == [shop]) } + + private func allSchemaPlan(_ change: CatalogChange, keys: [DatabaseKey]) -> CatalogTreeRefreshPlan { + DatabaseTreeMetadataService.catalogRefreshPlan( + for: change, + hasDatabaseList: false, + schemaListKeys: [DatabaseKey](), + tableKeys: [ObjectsKey](), + routineKeys: [ObjectsKey](), + triggerKeys: [ObjectsKey](), + typeKeys: [ObjectsKey](), + allSchemaTableKeys: keys + ) + } + + @Test("a table or schema change reaches the all-schema listing of its database only") + func allSchemaListingFollowsItsDatabase() { + let shop = DatabaseKey(connectionId: connectionId, database: "shop") + let warehouse = DatabaseKey(connectionId: connectionId, database: "warehouse") + let other = DatabaseKey(connectionId: UUID(), database: "shop") + + let tables = allSchemaPlan( + CatalogChange(connectionId: connectionId, database: "shop", kinds: .tables), + keys: [shop, warehouse, other] + ) + let schemas = allSchemaPlan(CatalogChange(connectionId: connectionId, kinds: .schemas), keys: [shop, warehouse]) + + #expect(tables.allSchemaTables == [shop]) + #expect(schemas.allSchemaTables == [shop, warehouse]) + #expect(!tables.isEmpty) + } + + @Test("a change that cannot touch a table leaves the all-schema listing alone") + func routineChangeLeavesAllSchemaListing() { + let shop = DatabaseKey(connectionId: connectionId, database: "shop") + + let result = allSchemaPlan(CatalogChange(connectionId: connectionId, kinds: .routines), keys: [shop]) + + #expect(result.allSchemaTables.isEmpty) + #expect(result.isEmpty) + } } diff --git a/TableProTests/Plugins/PostgreSQLFetchTablesAllSchemasTests.swift b/TableProTests/Plugins/PostgreSQLFetchTablesAllSchemasTests.swift new file mode 100644 index 0000000000..abdc219826 --- /dev/null +++ b/TableProTests/Plugins/PostgreSQLFetchTablesAllSchemasTests.swift @@ -0,0 +1,64 @@ +import Foundation +import TableProPluginKit +import Testing + +@Suite("PostgreSQLSchemaQueries.fetchTables across every schema") +struct PostgreSQLFetchTablesAllSchemasTests { + private static let attempts = PostgreSQLTableListingLadder.degradableAttempts + + [PostgreSQLTableListingLadder.leastCapableAttempt] + + private func query( + _ listing: PostgreSQLTableListingScope, + _ attempt: PostgreSQLTableListingAttempt = PostgreSQLTableListingLadder.degradableAttempts[0] + ) -> String { + PostgreSQLSchemaQueries.fetchTables( + in: listing, + includeMaterializedViews: attempt.includeOptionalCatalogs, + includeForeignTables: attempt.includeOptionalCatalogs, + includeComments: attempt.includeComments, + includePartitionAwareness: attempt.includePartitionAwareness + ) + } + + private func occurrences(of needle: String, in text: String) -> Int { + text.components(separatedBy: needle).count - 1 + } + + /// Every union arm filters by the schema list itself, so a table is listed exactly when its + /// schema is one `fetchSchemas()` returns, on every rung of the ladder. + @Test("Every arm is filtered by the schema list query, on every rung") + func everyArmUsesTheSchemaList() { + for attempt in Self.attempts { + let sql = query(.allSchemas, attempt) + let arms = occurrences(of: "UNION ALL", in: sql) + 1 + #expect(occurrences(of: PostgreSQLSchemaQueries.listSchemas, in: sql) == arms, "\(attempt.label)") + #expect(occurrences(of: "AS schema_name", in: sql) == arms, "\(attempt.label)") + #expect(sql.hasSuffix("ORDER BY schema_name, table_name"), "\(attempt.label)") + } + } + + @Test("The one-schema listing is the listing it always was") + func oneSchemaListingUnchanged() { + for attempt in Self.attempts { + let sql = query(.schema("public"), attempt) + #expect(!sql.contains("schema_name"), "\(attempt.label)") + #expect(!sql.contains(PostgreSQLSchemaQueries.listSchemas), "\(attempt.label)") + #expect(sql.hasSuffix("ORDER BY table_name"), "\(attempt.label)") + #expect(sql.contains("t.table_schema = 'public'"), "\(attempt.label)") + } + } + + @Test("The all-schema listing keeps the partition exclusion and the comment column") + func allSchemaListingKeepsItsColumns() { + let sql = query(.allSchemas) + #expect(sql.contains("pg_catalog.pg_inherits")) + #expect(sql.contains("obj_description(pc.oid, 'pg_class')")) + #expect(sql.contains("pg_matviews")) + #expect(sql.contains("pg_foreign_table")) + } + + @Test("A schema name is quoted as a literal in the one-schema listing") + func schemaLiteralIsQuoted() { + #expect(query(.schema("it's")).contains("t.table_schema = 'it''s'")) + } +} diff --git a/TableProTests/Services/QuickSwitcherCatalogStoreTests.swift b/TableProTests/Services/QuickSwitcherCatalogStoreTests.swift index 5e5e70249d..367c2ded68 100644 --- a/TableProTests/Services/QuickSwitcherCatalogStoreTests.swift +++ b/TableProTests/Services/QuickSwitcherCatalogStoreTests.swift @@ -220,46 +220,4 @@ struct QuickSwitcherCatalogStoreTests { store.removeConnection(dropped) #expect(store.catalog(for: kept, version: key)?.map(\.name) == ["users"]) } - - // MARK: - Open state applied on read - - @Test("Open state is applied to a cached catalog on the way out") - func openStateAppliedOnRead() { - let openTables: Set = [ - QuickSwitcherOpenTable(schema: "public", name: "users", browsing: "public") - ] - let applied = QuickSwitcherViewModel.applyingOpenState( - to: [table("users"), table("orders")], - openTables: openTables, - browsing: "public" - ) - #expect(applied.first { $0.name == "users" }?.isOpenInTab == true) - #expect(applied.first { $0.name == "orders" }?.isOpenInTab == false) - } - - /// The same defect #2191 fixed, reached through the cache instead of a fresh load. - @Test("A table of the same name in another schema is not badged from the cache") - func openStateRespectsSchemaOnRead() { - let openTables: Set = [ - QuickSwitcherOpenTable(schema: "public", name: "users", browsing: "analytics") - ] - let applied = QuickSwitcherViewModel.applyingOpenState( - to: [table("users", schema: "analytics")], - openTables: openTables, - browsing: "analytics" - ) - #expect(applied.first?.isOpenInTab == false) - } - - /// The function is unconditionally authoritative rather than skipping an empty set, so a badge - /// can never survive from whatever it was handed. - @Test("No open tabs clears the badge on every row") - func noOpenTabsClearsBadge() { - let applied = QuickSwitcherViewModel.applyingOpenState( - to: [table("users", isOpen: true)], - openTables: [], - browsing: "public" - ) - #expect(applied.first?.isOpenInTab == false) - } } diff --git a/TableProTests/Utilities/QualifiedSearchQueryTests.swift b/TableProTests/Utilities/QualifiedSearchQueryTests.swift new file mode 100644 index 0000000000..3db412a52b --- /dev/null +++ b/TableProTests/Utilities/QualifiedSearchQueryTests.swift @@ -0,0 +1,105 @@ +// +// QualifiedSearchQueryTests.swift +// TableProTests +// + +import Foundation +@testable import TablePro +import Testing + +@Suite("QualifiedSearchQuery") +struct QualifiedSearchQueryTests { + @Test("A schema and a name") + func schemaAndName() throws { + let query = try #require(QualifiedSearchQuery("attendance.timesheet")) + #expect(query.containers == ["attendance"]) + #expect(query.name == "timesheet") + } + + @Test("A trailing dot asks for everything in the container") + func trailingDot() throws { + let query = try #require(QualifiedSearchQuery("attendance.")) + #expect(query.containers == ["attendance"]) + #expect(query.name.isEmpty) + } + + @Test("A database, a schema and a name") + func threeParts() throws { + let query = try #require(QualifiedSearchQuery("shop.attendance.timesheet")) + #expect(query.containers == ["shop", "attendance"]) + #expect(query.name == "timesheet") + } + + @Test("Spaces around a dot are ignored") + func spacesAroundDot() throws { + let query = try #require(QualifiedSearchQuery("attendance . timesheet")) + #expect(query.containers == ["attendance"]) + #expect(query.name == "timesheet") + } + + @Test("Text with no dot is not qualified") + func plainText() { + #expect(QualifiedSearchQuery("timesheet") == nil) + #expect(QualifiedSearchQuery("") == nil) + } + + @Test("An empty container keeps the text an ordinary search") + func emptyContainer() { + #expect(QualifiedSearchQuery(".orders") == nil) + #expect(QualifiedSearchQuery("a..b") == nil) + } + + @Test("A dot inside quotes belongs to the name", arguments: [ + "attendance.\"time.sheet\"", + "attendance.[time.sheet]", + "attendance.`time.sheet`" + ]) + func quotedDot(_ text: String) throws { + let query = try #require(QualifiedSearchQuery(text)) + #expect(query.containers == ["attendance"]) + #expect(query.name == "time.sheet") + } + + @Test("A quoted schema keeps its case and its dot") + func quotedSchema() throws { + let query = try #require(QualifiedSearchQuery("\"My.Schema\".\"TimeSheet\"")) + #expect(query.containers == ["My.Schema"]) + #expect(query.name == "TimeSheet") + } + + @Test("A doubled closing quote is a literal quote") + func doubledQuote() throws { + let query = try #require(QualifiedSearchQuery("\"a\"\"b\".c")) + #expect(query.containers == ["a\"b"]) + #expect(query.name == "c") + } + + @Test("An unterminated quote runs to the end of the text") + func unterminatedQuote() throws { + let query = try #require(QualifiedSearchQuery("attendance.\"time.sh")) + #expect(query.containers == ["attendance"]) + #expect(query.name == "time.sh") + } + + @Test("Containers line up with a location from the right") + func containerPairs() throws { + let query = try #require(QualifiedSearchQuery("attendance.timesheet")) + let pairs = try #require(query.containerPairs(with: ["shop", "attendance"])) + #expect(pairs.map { $0.query } == ["attendance"]) + #expect(pairs.map { $0.candidate } == ["attendance"]) + } + + @Test("A query naming more containers than the location has cannot match") + func tooManyContainers() throws { + let query = try #require(QualifiedSearchQuery("shop.attendance.timesheet")) + #expect(query.containerPairs(with: ["attendance"]) == nil) + } + + @Test("A location drops a schema that only repeats the database") + func locationDropsRepeatedSchema() { + #expect(QualifiedSearchQuery.location(database: "shop", schema: "shop") == ["shop"]) + #expect(QualifiedSearchQuery.location(database: "shop", schema: "public") == ["shop", "public"]) + #expect(QualifiedSearchQuery.location(database: nil, schema: "public") == ["public"]) + #expect(QualifiedSearchQuery.location(database: "", schema: nil).isEmpty) + } +} diff --git a/TableProTests/Utilities/SidebarSearchTests.swift b/TableProTests/Utilities/SidebarSearchTests.swift new file mode 100644 index 0000000000..fd10d5b9b3 --- /dev/null +++ b/TableProTests/Utilities/SidebarSearchTests.swift @@ -0,0 +1,84 @@ +// +// SidebarSearchTests.swift +// TableProTests +// + +import Foundation +@testable import TablePro +import Testing + +@Suite("SidebarSearch") +struct SidebarSearchTests { + @Test("A plain search admits every container and matches names") + func plainSearch() { + let search = SidebarSearch("sheet") + #expect(search.qualified == nil) + #expect(search.admits(database: "shop", schema: "attendance")) + #expect(search.matchesName("timesheet")) + #expect(!search.matchesName("orders")) + } + + @Test("A plain search matches a container by its own name") + func plainContainerName() { + let search = SidebarSearch("attend") + #expect(search.matchesContainer(database: "shop", schema: "attendance")) + #expect(!search.matchesContainer(database: "shop", schema: "public")) + } + + @Test("A qualified search admits only the container it names") + func qualifiedAdmits() { + let search = SidebarSearch("attendance.time") + #expect(search.admits(database: "shop", schema: "attendance")) + #expect(!search.admits(database: "shop", schema: "public")) + #expect(search.nameQuery == "time") + #expect(search.matchesName("timesheet")) + } + + @Test("A qualified search matches its container by substring, like the plain filter") + func qualifiedSubstring() { + #expect(SidebarSearch("tend.sheet").admits(database: nil, schema: "attendance")) + #expect(!SidebarSearch("atd.sheet").admits(database: nil, schema: "attendance")) + } + + @Test("A trailing dot matches the container and every name in it") + func trailingDot() { + let search = SidebarSearch("attendance.") + #expect(search.matchesContainer(database: "shop", schema: "attendance")) + #expect(search.matchesName("anything")) + } + + @Test("A qualified search with a name does not match the container by itself") + func namedQueryDoesNotMatchContainer() { + #expect(!SidebarSearch("attendance.time").matchesContainer(database: "shop", schema: "attendance")) + } + + @Test("A database, a schema and a name need both containers to match") + func threeParts() { + let search = SidebarSearch("shop.attendance.time") + #expect(search.admits(database: "shop", schema: "attendance")) + #expect(!search.admits(database: "other", schema: "attendance")) + #expect(!search.admits(database: nil, schema: "attendance")) + } + + @Test("A name that holds a dot matches its own text anywhere") + func literalDottedName() { + let search = SidebarSearch("audit.events") + #expect(search.matchesObject(named: "audit.events", database: "shop", schema: "public")) + #expect(search.matchesObject(named: "events", database: "shop", schema: "audit")) + #expect(!search.matchesObject(named: "events", database: "shop", schema: "public")) + } + + @Test("A plain search matches objects by name alone") + func plainObjectMatch() { + let search = SidebarSearch("sheet") + #expect(search.matchesObject(named: "timesheet", database: "shop", schema: "attendance")) + #expect(!search.matchesObject(named: "orders", database: "shop", schema: "attendance")) + } + + @Test("On an engine with no schemas the container is the database") + func schemaLessEngine() { + let search = SidebarSearch("shop.orders") + #expect(search.admits(database: "shop", schema: nil)) + #expect(!search.admits(database: "blog", schema: nil)) + } +} diff --git a/TableProTests/ViewModels/QuickSwitcherCrossSchemaTests.swift b/TableProTests/ViewModels/QuickSwitcherCrossSchemaTests.swift new file mode 100644 index 0000000000..e88f79b766 --- /dev/null +++ b/TableProTests/ViewModels/QuickSwitcherCrossSchemaTests.swift @@ -0,0 +1,246 @@ +// +// QuickSwitcherCrossSchemaTests.swift +// TableProTests +// + +import Foundation +@testable import TablePro +import TableProPluginKit +import Testing + +@Suite("Quick switcher across schemas") +@MainActor +struct QuickSwitcherCrossSchemaTests { + private func table(_ name: String, _ schema: String?, type: TableInfo.TableType = .table) -> TableInfo { + TableInfo(name: name, type: type, rowCount: nil, schema: schema) + } + + private func items( + _ tables: [TableInfo], + browsing browseSchema: String? = "public", + openTables: Set = [] + ) -> [QuickSwitcherItem] { + QuickSwitcherViewModel.makeTableItems( + tables, database: "shop", browseSchema: browseSchema, openTables: openTables + ) + } + + private func search(_ query: String, in catalog: [QuickSwitcherItem]) async -> [QuickSwitcherItem] { + guard let defaults = UserDefaults(suiteName: "QuickSwitcherCrossSchemaTests.\(UUID().uuidString)") else { + return [] + } + let viewModel = QuickSwitcherViewModel(connectionId: UUID(), services: .live, defaults: defaults) + viewModel.allItems = catalog + viewModel.searchText = query + await viewModel.flushPendingFilter() + return viewModel.flatItems + } + + // MARK: - Rows + + @Test("A table outside the browsed schema names its schema, and one inside does not") + func rowsNameOtherSchemas() { + let rows = items([table("users", "public"), table("timesheet", "attendance")]) + + #expect(rows.map(\.subtitle) == ["", "attendance"]) + #expect(rows.map(\.isOutsideBrowsedSchema) == [false, true]) + } + + @Test("A view in another schema names both its schema and its kind") + func viewNamesSchemaAndKind() { + let rows = items([table("active", "attendance", type: .view), table("summary", "public", type: .materializedView)]) + + #expect(rows.map(\.subtitle) == ["attendance ยท View", "Materialized View"]) + } + + @Test("A table on an engine without schemas names nothing") + func schemaLessEngine() { + let rows = items([table("orders", nil)], browsing: nil) + + #expect(rows.first?.subtitle == "") + #expect(rows.first?.isOutsideBrowsedSchema == false) + } + + @Test("A row keeps its table type for the tab it opens") + func rowsKeepTableType() { + let rows = items([table("order_seq", "public", type: .sequence), table("summary", "public", type: .materializedView)]) + + #expect(rows.map(\.tableType) == [.sequence, .materializedView]) + } + + @Test("A row knows where it lives for a qualified query") + func rowsCarryLocation() { + #expect(items([table("timesheet", "attendance")]).first?.searchLocation == ["shop", "attendance"]) + } + + // MARK: - Open state + + @Test("An open table is badged, one without a tab is not") + func openState() { + let open: Set = [QuickSwitcherOpenTable(schema: "public", name: "users", browsing: "public")] + let rows = items([table("users", "public"), table("orders", "public")], openTables: open) + + #expect(rows.first { $0.name == "users" }?.isOpenInTab == true) + #expect(rows.first { $0.name == "orders" }?.isOpenInTab == false) + } + + /// The defect #2191 fixed: a tab on `public.users` badged `analytics.users` as open. + @Test("A table of the same name in another schema is not badged") + func openStateRespectsSchema() { + let open: Set = [QuickSwitcherOpenTable(schema: "public", name: "users", browsing: "analytics")] + let rows = items([table("users", "analytics")], browsing: "analytics", openTables: open) + + #expect(rows.first?.isOpenInTab == false) + } + + // MARK: - Merging + + @Test("The schema service answers for its own schemas and the listing fills in the rest") + func mergedTables() { + let local = [table("users", "public")] + let allSchemas = [table("users", "public"), table("dropped", "public"), table("timesheet", "attendance")] + + let merged = QuickSwitcherViewModel.mergedTables( + local: local, loadedFrom: "shop", allSchemas: allSchemas, browsing: "shop" + ) + + #expect(merged.map(\.name) == ["users", "timesheet"]) + } + + @Test("A table listed twice is merged once") + func mergedTablesDeduplicate() { + let allSchemas = [table("timesheet", "attendance"), table("timesheet", "attendance")] + + let merged = QuickSwitcherViewModel.mergedTables( + local: [], loadedFrom: "shop", allSchemas: allSchemas, browsing: "shop" + ) + + #expect(merged.count == 1) + } + + /// While a database switch settles, the schema service still holds the old database's tables, + /// and each would open against the new database. + @Test("Tables loaded from the database the connection left are not offered") + func tablesFromThePreviousDatabaseAreWithheld() { + let merged = QuickSwitcherViewModel.mergedTables( + local: [table("invoices", "public")], + loadedFrom: "billing", + allSchemas: [table("timesheet", "attendance")], + browsing: "shop" + ) + + #expect(merged.map(\.name) == ["timesheet"]) + } + + // MARK: - Qualified queries + + @Test("A schema-qualified query finds the table in that schema only") + func qualifiedQuery() async { + let catalog = items([table("timesheet", "public"), table("timesheet", "attendance")]) + + let results = await search("attendance.timesheet", in: catalog) + + #expect(results.map(\.schemaName) == ["attendance"]) + #expect(results.first?.matchedIndices.isEmpty == false) + } + + @Test("A trailing dot lists everything in the schema") + func trailingDot() async { + let catalog = items([table("timesheet", "attendance"), table("shift", "attendance"), table("users", "public")]) + + let results = await search("attendance.", in: catalog) + + #expect(Set(results.map(\.name)) == ["timesheet", "shift"]) + } + + @Test("Each part of a qualified query matches fuzzily") + func fuzzyParts() async { + let catalog = items([table("timesheet", "attendance"), table("orders", "sales")]) + + #expect(await search("att.time", in: catalog).map(\.name) == ["timesheet"]) + } + + @Test("A database, schema and name reach the database the connection is browsing") + func threePartQuery() async { + let catalog = items([table("timesheet", "attendance")]) + + #expect(await search("shop.attendance.timesheet", in: catalog).count == 1) + #expect(await search("blog.attendance.timesheet", in: catalog).isEmpty) + } + + @Test("A quoted schema with a dot in it is one schema") + func quotedSchema() async { + let catalog = items([table("orders", "my.schema"), table("orders", "my")]) + + let results = await search("\"my.schema\".orders", in: catalog) + + #expect(results.map(\.schemaName) == ["my.schema"]) + } + + @Test("A table whose own name holds a dot is still found by that name") + func dottedTableName() async { + let catalog = items([table("b.c", "public")]) + + #expect(await search("b.c", in: catalog).map(\.name) == ["b.c"]) + } + + @Test("A bare name finds the table in every schema, the browsed schema first") + func bareNameBrowsedFirst() async { + let catalog = items([table("timesheet", "attendance"), table("timesheet", "public")]) + + let results = await search("timesheet", in: catalog) + + #expect(results.map(\.schemaName) == ["public", "attendance"]) + } + + @Test("A qualified query reaches a result from another connection through its target") + func qualifiedQueryInConnectionsScope() async throws { + let target = QuickSwitcherTarget( + connectionId: UUID(), connectionName: "Primary", databaseName: "app", schemaName: "fallback" + ) + let remote = QuickSwitcherViewModel.makeCrossConnectionItems( + tables: [table("timesheet", "attendance"), table("timesheet", "public")], + target: target + ) + guard let defaults = UserDefaults(suiteName: "QuickSwitcherCrossSchemaTests.\(UUID().uuidString)") else { + Issue.record("no defaults suite") + return + } + let viewModel = QuickSwitcherViewModel(connectionId: UUID(), services: .live, defaults: defaults) + viewModel.crossConnectionItems = remote + viewModel.scope = .connections + viewModel.searchText = "attendance.timesheet" + await viewModel.flushPendingFilter() + + #expect(viewModel.flatItems.map { $0.target?.schemaName } == ["attendance"]) + } + + @Test("A path match needs every container it names") + func pathMatchNeedsEveryContainer() throws { + let row = try #require(items([table("timesheet", "attendance")]).first) + let named = try #require(QualifiedSearchQuery("attendance.timesheet")) + let other = try #require(QualifiedSearchQuery("payroll.timesheet")) + + #expect(QuickSwitcherViewModel.pathMatch(for: row, query: named) != nil) + #expect(QuickSwitcherViewModel.pathMatch(for: row, query: other) == nil) + } + + // MARK: - Identity + + @Test("A name without a dot keeps the id it always had") + func idUnchangedWithoutDots() { + #expect(QuickSwitcherItem.tableItemId(name: "users", schema: "public") == "table_public.users") + #expect(QuickSwitcherItem.tableItemId(name: "users", schema: nil) == "table_users") + } + + @Test("Dotted names in different schemas never share an id") + func dottedNamesStayDistinct() { + let first = QuickSwitcherItem.tableItemId(name: "b.c", schema: "a") + let second = QuickSwitcherItem.tableItemId(name: "c", schema: "a.b") + let unqualified = QuickSwitcherItem.tableItemId(name: "a.b", schema: nil) + let qualified = QuickSwitcherItem.tableItemId(name: "b", schema: "a") + + #expect(first != second) + #expect(unqualified != qualified) + } +} diff --git a/TableProTests/Views/Sidebar/DatabaseTreeFilterQualifiedSearchTests.swift b/TableProTests/Views/Sidebar/DatabaseTreeFilterQualifiedSearchTests.swift new file mode 100644 index 0000000000..48f64433b1 --- /dev/null +++ b/TableProTests/Views/Sidebar/DatabaseTreeFilterQualifiedSearchTests.swift @@ -0,0 +1,252 @@ +// +// DatabaseTreeFilterQualifiedSearchTests.swift +// TableProTests +// + +import Foundation +@testable import TablePro +import TableProPluginKit +import Testing + +@Suite("DatabaseTreeFilter qualified and cross-schema search") +struct DatabaseTreeFilterQualifiedSearchTests { + private func table(_ name: String, schema: String?) -> TableInfo { + TableInfo(name: name, type: .table, rowCount: 0, schema: schema) + } + + private func listing(_ tables: [TableInfo], unlisted: Set = []) -> MetadataLoadState { + .loaded(CatalogTableListing.Result(tables: tables, unlistedSchemas: unlisted)) + } + + private func buckets(_ tables: [TableInfo], searchText: String) -> DatabaseTreeObjectBuckets { + DatabaseTreeFilter.objectBuckets(tables: tables, routines: [], triggers: [], searchText: searchText, database: "shop") + } + + // MARK: - Object filters + + @Test("A qualified search keeps only objects in the schema it names") + func qualifiedTablesFilter() { + let tables = [table("timesheet", schema: "attendance"), table("timesheet", schema: "public")] + let result = DatabaseTreeFilter.filteredTables(tables, searchText: "attendance.time", database: "shop") + #expect(result.map(\.schema) == ["attendance"]) + } + + @Test("A trailing dot keeps every object in the schema") + func trailingDotKeepsEverything() { + let tables = [table("timesheet", schema: "attendance"), table("shift", schema: "attendance")] + let result = DatabaseTreeFilter.filteredTables(tables, searchText: "attendance.", database: "shop") + #expect(result.map(\.name) == ["timesheet", "shift"]) + } + + @Test("A table named with a dot is found by typing its name") + func dottedTableNameStillMatches() { + let tables = [table("audit.events", schema: "public"), table("orders", schema: "public")] + let result = DatabaseTreeFilter.filteredTables(tables, searchText: "audit.events", database: "shop") + #expect(result.map(\.name) == ["audit.events"]) + } + + @Test("A schema holding a table named with a dot is kept for that name") + func dottedTableNameKeepsItsSchema() { + let matches = DatabaseTreeFilter.SchemaListingMatches( + listing: CatalogTableListing.Result(tables: [table("audit.events", schema: "public")], unlistedSchemas: []), + database: "shop", + searchText: "audit.events" + ) + #expect(matches.matched == ["public"]) + } + + @Test("A plain search is unchanged by the database it is told about") + func plainSearchUnchanged() { + let tables = [table("timesheet", schema: "attendance"), table("orders", schema: "public")] + let result = DatabaseTreeFilter.filteredTables(tables, searchText: "sheet", database: "shop") + #expect(result.map(\.name) == ["timesheet"]) + } + + // MARK: - Schema verdicts + + /// Nil `tables` stands for a listing that has not arrived, which is all a verdict can be told. + private func verdict( + _ schema: String, + search searchText: String, + tables: [TableInfo]?, + unlisted: Set = [], + loadedContent: DatabaseTreeObjectBuckets? = nil, + listingCoversSchema: Bool = true + ) -> DatabaseTreeFilter.SchemaSearchVerdict { + let matches = tables.map { + DatabaseTreeFilter.SchemaListingMatches( + listing: CatalogTableListing.Result(tables: $0, unlistedSchemas: unlisted), + database: "shop", + searchText: searchText + ) + } + return DatabaseTreeFilter.schemaSearchVerdict( + schema: schema, + database: "shop", + searchText: searchText, + loadedContent: loadedContent, + listingMatches: matches, + listingCoversSchema: listingCoversSchema + ) + } + + @Test("An unloaded schema is judged from the all-schema listing") + func unloadedSchemaJudgedByListing() { + let tables = [table("timesheet", schema: "attendance"), table("orders", schema: "sales")] + + #expect(verdict("attendance", search: "timesheet", tables: tables) == .match) + #expect(verdict("sales", search: "timesheet", tables: tables) == .noMatch) + } + + @Test("An unloaded schema is unknown while the listing has not arrived") + func unloadedSchemaUnknownWithoutListing() { + let result = verdict("attendance", search: "timesheet", tables: nil) + + #expect(result == .unknown) + #expect(result.isVisible) + } + + @Test("A schema the listing could not read is unknown, not empty") + func unlistedSchemaIsUnknown() { + #expect(verdict("attendance", search: "timesheet", tables: [], unlisted: ["attendance"]) == .unknown) + } + + @Test("A schema's own loaded lists answer before the listing") + func loadedContentWins() { + let loadedWithoutMatch = buckets([table("shift", schema: "attendance")], searchText: "timesheet") + + let result = verdict( + "attendance", search: "timesheet", + tables: [table("timesheet", schema: "attendance")], loadedContent: loadedWithoutMatch + ) + + #expect(result == .noMatch) + } + + @Test("A system schema the listing leaves out is not kept unknown") + func uncoveredSchemaIsNotUnknown() { + #expect(verdict("pg_catalog", search: "timesheet", tables: nil, listingCoversSchema: false) == .noMatch) + } + + @Test("A qualified search drops every schema it does not name") + func qualifiedSearchDropsOtherSchemas() { + let tables = [table("timesheet", schema: "attendance"), table("timesheet", schema: "public")] + + #expect(verdict("public", search: "attendance.timesheet", tables: tables) == .noMatch) + #expect(verdict("attendance", search: "attendance.timesheet", tables: tables) == .match) + } + + @Test("A plain search matching a schema's own name keeps it") + func plainSchemaNameMatches() { + #expect(verdict("attendance", search: "attend", tables: nil) == .match) + } + + @Test("One pass records every schema listed and every schema holding a match") + func listingMatchesOnePass() { + let matches = DatabaseTreeFilter.SchemaListingMatches( + listing: CatalogTableListing.Result( + tables: [table("timesheet", schema: "attendance"), table("orders", schema: "sales")], + unlistedSchemas: ["locked"] + ), + database: "shop", + searchText: "sheet" + ) + + #expect(matches.listed == ["attendance", "sales"]) + #expect(matches.matched == ["attendance"]) + #expect(matches.unlisted == ["locked"]) + } + + // MARK: - Flat list + + @Test("The flat list names the other schemas holding a match, sorted, never the browsed one") + func otherSchemaMatches() { + let allSchemas = listing([ + table("timesheet", schema: "public"), + table("timesheet", schema: "payroll"), + table("timesheet", schema: "attendance"), + table("orders", schema: "sales") + ]) + let schemas = DatabaseTreeFilter.otherSchemaMatches( + database: "shop", browsedSchema: "public", searchText: "timesheet", + hiddenSchemas: [], allSchemaTables: allSchemas, loadedContent: { _ in nil } + ) + #expect(schemas == ["attendance", "payroll"]) + } + + @Test("The flat list does not name a schema that matched only by its own name") + func otherSchemaMatchesIgnoresSchemaNames() { + let allSchemas = listing([table("orders", schema: "timesheets")]) + let schemas = DatabaseTreeFilter.otherSchemaMatches( + database: "shop", browsedSchema: "public", searchText: "timesheet", + hiddenSchemas: [], allSchemaTables: allSchemas, loadedContent: { _ in nil } + ) + #expect(schemas.isEmpty) + } + + @Test("A trailing dot names the schema it asks for") + func otherSchemaMatchesTrailingDot() { + let allSchemas = listing([table("orders", schema: "attendance"), table("orders", schema: "sales")]) + let schemas = DatabaseTreeFilter.otherSchemaMatches( + database: "shop", browsedSchema: "public", searchText: "attendance.", + hiddenSchemas: [], allSchemaTables: allSchemas, loadedContent: { _ in nil } + ) + #expect(schemas == ["attendance"]) + } + + @Test("The flat list names nothing until the listing arrives, and nothing hidden") + func otherSchemaMatchesWithoutListing() { + let pending = DatabaseTreeFilter.otherSchemaMatches( + database: "shop", browsedSchema: "public", searchText: "timesheet", + hiddenSchemas: [], allSchemaTables: .loading, loadedContent: { _ in nil } + ) + let hidden = DatabaseTreeFilter.otherSchemaMatches( + database: "shop", browsedSchema: "public", searchText: "timesheet", + hiddenSchemas: ["attendance"], + allSchemaTables: listing([table("timesheet", schema: "attendance")]), + loadedContent: { _ in nil } + ) + #expect(pending.isEmpty) + #expect(hidden.isEmpty) + } + + // MARK: - Hierarchical shape + + @Test("A qualified search hides the hierarchical schemas it does not name") + func hierarchicalQualified() { + let other = DatabaseTreeFilter.hierarchicalSchemaIsVisible( + "HR", searchText: "SALES.ORDERS", isLoaded: false, + tables: [], routines: [], triggers: [], userTypes: [] + ) + let named = DatabaseTreeFilter.hierarchicalSchemaIsVisible( + "SALES", searchText: "SALES.ORDERS", isLoaded: false, + tables: [], routines: [], triggers: [], userTypes: [] + ) + #expect(!other) + #expect(named) + } + + @Test("A trailing dot shows everything in the hierarchical schema it names") + func hierarchicalTrailingDot() { + let buckets = DatabaseTreeFilter.hierarchicalObjectBuckets( + schema: "SALES", + tables: [table("ORDERS", schema: "SALES"), table("LINES", schema: "SALES")], + routines: [], triggers: [], userTypes: [], searchText: "SALES." + ) + #expect(buckets.itemCounts[.table] == 2) + } + + @Test("visibleSchemas keeps a qualified search's schema and drops the rest") + func visibleSchemasQualified() { + let visible = DatabaseTreeFilter.visibleSchemas( + ["attendance", "public", "sales"], + systemSchemas: [], + activeSchema: nil, + showsSystem: false, + searchText: "attendance.", + database: "shop", + contentMatches: { _ in false } + ) + #expect(visible == ["attendance"]) + } +} diff --git a/docs/features/connection-window.mdx b/docs/features/connection-window.mdx index 47a76e5454..fe0546b288 100644 --- a/docs/features/connection-window.mdx +++ b/docs/features/connection-window.mdx @@ -86,6 +86,19 @@ The palette offers a tile for a control the tab you are on has hidden. Drag **Re In [Agent mode](/features/agent-mode) the chooser and the filter field go, and the session list takes their height. +## Filtering the sidebar + +The filter field matches any part of a name, so `sheet` finds `timesheet`. How far it reaches depends on the layout: + +| Layout | Searches | +|---|---| +| **View > Sidebar as List** | The browsed schema, then every other schema holding a match, each listed below as a row to expand | +| **View > Sidebar as Tree** | Every schema of every database whose schemas the tree has shown, expanded or not | + +A schema whose tables have not been read yet stays in the tree, collapsed, until they arrive. + +Type a dot to filter by schema. `attendance.time` keeps the objects in `attendance` whose names contain `time`, `attendance.` shows everything in `attendance`, and `shop.attendance.time` names the database too. [Open Quickly](/features/open-quickly#other-schemas) takes the same form with fuzzy matching. + ## The trailing pane One column on the trailing edge, holding one surface at a time. Its header keeps one height across all three, so switching surface moves nothing beneath it. diff --git a/docs/features/open-quickly.mdx b/docs/features/open-quickly.mdx index 6f65de919e..05807e514d 100644 --- a/docs/features/open-quickly.mdx +++ b/docs/features/open-quickly.mdx @@ -30,8 +30,8 @@ The segmented control under the search field sets the scope. It stays on screen, | Scope | Key | Covers | |-------|-----|--------| -| **All** | `Cmd+1` | Tables, views, databases, schemas, and saved queries in this connection, plus its last 50 queries | -| **Tables** | `Cmd+2` | Tables, views, and system tables | +| **All** | `Cmd+1` | Tables and views in every schema of this connection's database, plus its databases, schemas, saved queries, and last 50 queries | +| **Tables** | `Cmd+2` | Tables, views, and system tables in every schema | | **Databases** | `Cmd+3` | Databases and schemas | | **Queries** | `Cmd+4` | Saved queries and recent queries, from every connected window | | **Connections** | `Cmd+5` | Tables, views, and system tables in every connected window | @@ -40,6 +40,22 @@ Leave the search empty in any scope other than All and everything in it is liste Opening a table or view opens a table tab, a database or schema switches the connection to it, and a query loads into the SQL editor without running it. +## Other schemas + +A table outside the schema the sidebar is browsing shows its schema at the end of the row, `attendance` or `attendance ยท View`, and keeps it while selected. Opening it leaves the connection on the schema it was browsing. + +Type a dot to search by where a table lives: + +| Search | Finds | +|--------|-------| +| `attendance.timesheet` | `timesheet` in `attendance`, and no other `timesheet` | +| `attendance.` | Everything in `attendance` | +| `att.time` | The same table, since each part matches fuzzily | +| `shop.attendance.timesheet` | The table, when `shop` is the database the connection is browsing | +| `"my.schema".orders` | `orders` in a schema whose name holds a dot. Backticks and square brackets quote too | + +The browsed schema's tables are listed as the panel opens, and the rest arrive after one catalog query on PostgreSQL or one query per schema on other engines. Until then the panel reads **Loadingโ€ฆ** rather than reporting no results. + ## Across connections The **Connections** and **Queries** scopes reach into every connected window, and that catalog is read the first time you open one of them, not before. @@ -60,13 +76,15 @@ A table already open in a tab shows an **Open** badge, and the hint on the selec ## Ranking -An empty search shows **Recent**: the last 10 items you opened through the panel on this connection. Once you type, a match on the name beats a match on the connection and database path beside it, tables rank above other kinds, and anything you open often through the panel or already have open in a tab moves up. The list stops at 200 results. +An empty search shows **Recent**: the last 10 items you opened through the panel on this connection. Once you type, a match on the name beats a match on the connection and database path beside it, tables rank above other kinds, and anything you open often through the panel or already have open in a tab moves up. Between two equal matches, the table in the browsed schema comes first. The list stops at 200 results. ## When a table is not listed -- The list covers the database the connection is browsing. To reach a table somewhere else, switch database first, then search again. +- The list covers every schema of the database the connection is browsing. To reach a table in another database, switch database first, then search again. +- System schemas such as `pg_catalog` and `information_schema` are left out. +- A table created in another schema since the panel last listed that schema appears the next time you open the panel. - The **Databases** scope offers the databases the sidebar's database filter keeps, plus every system database. Clear the filter with **View > Show All Databases**. -- The **Connections** scope covers connected windows only, and only the database each one is browsing. +- The **Connections** scope covers connected windows only, and only the database and schema each one is browsing. ## Right-click actions diff --git a/scripts/check-postgres-table-listing-parity.sh b/scripts/check-postgres-table-listing-parity.sh new file mode 100755 index 0000000000..b231bdb56c --- /dev/null +++ b/scripts/check-postgres-table-listing-parity.sh @@ -0,0 +1,182 @@ +#!/usr/bin/env bash +# +# Check that PostgreSQL's all-schema table listing lists exactly what the per-schema listing does. +# +# Open Quickly and the sidebar filter find tables in schemas nobody has opened through one query, +# PostgreSQLSchemaQueries.fetchTables(in: .allSchemas). The sidebar lists each schema through +# fetchTables(in: .schema(name)). The two have to agree row for row, on every rung of the +# degradation ladder: a table the one-schema listing shows and the search cannot find is the bug +# this listing exists to fix, and one the search finds that the sidebar hides is a result that +# opens nothing. +# +# This builds a database with every shape the listing treats specially (declarative partitions, +# a partition in another schema than its parent, legacy inheritance, a materialized view, a +# foreign table, a schema the role cannot use, quoted names with dots and mixed case), compiles +# the plugin's real query builder into a small harness, and compares the two listings as a role +# with ordinary privileges. +# +# Usage: +# scripts/check-postgres-table-listing-parity.sh [host] [port] [user] +# +# Needs psql, a reachable PostgreSQL 10 or newer the user may create a database and a role on, and +# a Debug build of TableProPluginKit in DerivedData (run verify.sh build first). Exits non-zero on +# a disagreement. + +set -uo pipefail + +HOST="${1:-127.0.0.1}" +PORT="${2:-5432}" +USER_NAME="${3:-postgres}" +ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" +DATABASE="tablepro_listing_parity_check" +READER="tablepro_listing_reader" +WORK="$(mktemp -d)" +trap 'rm -rf "$WORK"' EXIT + +command -v psql > /dev/null || { + echo "psql not found" >&2 + exit 3 +} + +DEVELOPER_DIR="${DEVELOPER_DIR:-$(xcode-select -p)}" +export DEVELOPER_DIR +FRAMEWORK_DIR="$(find "$HOME/Library/Developer/Xcode/DerivedData" -type d -path '*/Build/Products/Debug/TableProPluginKit.framework' -print 2> /dev/null \ + | while read -r path; do echo "$(stat -f %m "$path") $(dirname "$path")"; done \ + | sort -rn | head -1 | cut -d' ' -f2-)" +[ -n "$FRAMEWORK_DIR" ] || { + echo "no Debug TableProPluginKit.framework in DerivedData; build the app first" >&2 + exit 3 +} + +psql_do() { + psql -X -q -h "$HOST" -p "$PORT" -U "$USER_NAME" -d "$1" -v ON_ERROR_STOP=1 "${@:2}" +} + +if ! psql_do postgres -Atc "SELECT 1" > /dev/null 2>&1; then + echo "no PostgreSQL at $HOST:$PORT as $USER_NAME" >&2 + exit 3 +fi + +# The same plugin sources the test target compiles, read out of project.yml so the list cannot +# drift from what the tests exercise. +SOURCES=() +while IFS= read -r source; do + SOURCES+=("$ROOT/$source") +done < <(grep -oE 'Plugins/PostgreSQLDriverPlugin/[A-Za-z+]+\.swift' "$ROOT/project.yml" | sort -u) + +cat > "$WORK/main.swift" << 'SWIFT' +@main +enum ListingSQL { + static func main() { + let arguments = CommandLine.arguments + let attempts = PostgreSQLTableListingLadder.degradableAttempts + [PostgreSQLTableListingLadder.leastCapableAttempt] + if arguments[1] == "rungs" { + print(attempts.count) + return + } + if arguments[1] == "schemas" { + print(PostgreSQLSchemaQueries.listSchemas) + return + } + let attempt = attempts[Int(arguments[2]) ?? 0] + let listing: PostgreSQLTableListingScope = arguments[1] == "all" ? .allSchemas : .schema(arguments[3]) + print(PostgreSQLSchemaQueries.fetchTables( + in: listing, + includeMaterializedViews: attempt.includeOptionalCatalogs, + includeForeignTables: attempt.includeOptionalCatalogs, + includeComments: attempt.includeComments, + includePartitionAwareness: attempt.includePartitionAwareness + )) + } +} +SWIFT + +xcrun swiftc -swift-version 6 -parse-as-library -module-name ListingSQL -Onone \ + -F "$FRAMEWORK_DIR" -framework TableProPluginKit -Xlinker -rpath -Xlinker "$FRAMEWORK_DIR" \ + "${SOURCES[@]}" "$WORK/main.swift" -o "$WORK/listing-sql" > "$WORK/compile.log" 2>&1 || { + echo "harness failed to compile:" >&2 + grep -E 'error:' "$WORK/compile.log" | sort -u | head -20 >&2 + exit 3 +} +HARNESS="$WORK/listing-sql" + +VERSION="$(psql_do postgres -Atc "SHOW server_version")" +echo "Checking the all-schema table listing against PostgreSQL $VERSION at $HOST:$PORT" + +psql_do postgres -c "DROP DATABASE IF EXISTS $DATABASE" > /dev/null +psql_do postgres -c "DROP ROLE IF EXISTS $READER" > /dev/null 2>&1 +psql_do postgres -c "CREATE DATABASE $DATABASE" > /dev/null +psql_do postgres -c "CREATE ROLE $READER" > /dev/null +trap 'rm -rf "$WORK"; psql -X -q -h "$HOST" -p "$PORT" -U "$USER_NAME" -d postgres -c "DROP DATABASE IF EXISTS $DATABASE" > /dev/null 2>&1; psql -X -q -h "$HOST" -p "$PORT" -U "$USER_NAME" -d postgres -c "DROP ROLE IF EXISTS $READER" > /dev/null 2>&1' EXIT + +psql_do "$DATABASE" > /dev/null << SQL +CREATE SCHEMA attendance; +CREATE SCHEMA "Attendance"; +CREATE SCHEMA "my.schema"; +CREATE SCHEMA archive; +CREATE SCHEMA locked; +CREATE SCHEMA empty_schema; +CREATE TABLE public.timesheet (id int); +CREATE TABLE attendance.timesheet (id int); +CREATE TABLE attendance."time.sheet" (id int); +CREATE TABLE "Attendance"."TimeSheet" (id int); +CREATE TABLE "my.schema".orders (id int); +CREATE TABLE locked.secret (id int); +CREATE TABLE public.events (at date) PARTITION BY RANGE (at); +CREATE TABLE public.events_2025 PARTITION OF public.events FOR VALUES FROM ('2025-01-01') TO ('2026-01-01'); +CREATE TABLE archive.events_2024 PARTITION OF public.events FOR VALUES FROM ('2024-01-01') TO ('2025-01-01'); +CREATE TABLE public.parent_legacy (id int); +CREATE TABLE public.child_legacy () INHERITS (public.parent_legacy); +CREATE VIEW attendance.active AS SELECT id FROM attendance.timesheet; +CREATE MATERIALIZED VIEW attendance.summary AS SELECT count(*) FROM attendance.timesheet; +CREATE EXTENSION IF NOT EXISTS postgres_fdw; +CREATE SERVER loopback FOREIGN DATA WRAPPER postgres_fdw OPTIONS (dbname '$DATABASE'); +CREATE FOREIGN TABLE archive.remote_orders (id int) SERVER loopback OPTIONS (table_name 'orders'); +GRANT USAGE ON SCHEMA public, attendance, "Attendance", "my.schema", archive, empty_schema TO $READER; +GRANT SELECT ON ALL TABLES IN SCHEMA public, attendance, "Attendance", "my.schema", archive TO $READER; +REVOKE ALL ON SCHEMA locked FROM PUBLIC; +SQL + +as_reader() { + psql_do "$DATABASE" -Atq -F '|' -c "SET ROLE $READER" -c "$1" +} + +FAILURES=0 +RUNGS="$("$HARNESS" rungs)" +SCHEMA_LIST="$("$HARNESS" schemas)" +for ((rung = 0; rung < RUNGS; rung++)); do + : > "$WORK/one.txt" + while IFS= read -r schema; do + [ -n "$schema" ] || continue + as_reader "$("$HARNESS" one "$rung" "$schema")" | while IFS='|' read -r name type _; do + printf '%s|%s|%s\n' "$schema" "$name" "$type" + done >> "$WORK/one.txt" + done < <(as_reader "$SCHEMA_LIST") + as_reader "$("$HARNESS" all "$rung")" | while IFS='|' read -r name type _ _ schema; do + printf '%s|%s|%s\n' "$schema" "$name" "$type" + done > "$WORK/all.txt" + + sort -o "$WORK/one.txt" "$WORK/one.txt" + sort -o "$WORK/all.txt" "$WORK/all.txt" + if diff -u "$WORK/one.txt" "$WORK/all.txt" > "$WORK/diff.txt"; then + echo "rung $rung: $(wc -l < "$WORK/all.txt" | tr -d ' ') tables, listings agree" + else + echo "FAIL rung $rung: per-schema (-) and all-schema (+) listings differ" >&2 + cat "$WORK/diff.txt" >&2 + FAILURES=$((FAILURES + 1)) + fi +done + +for expected in "attendance|timesheet|BASE TABLE" "attendance|time.sheet|BASE TABLE" "Attendance|TimeSheet|BASE TABLE" "my.schema|orders|BASE TABLE"; do + grep -qxF "$expected" "$WORK/all.txt" || { + echo "FAIL: the all-schema listing is missing $expected" >&2 + FAILURES=$((FAILURES + 1)) + } +done +if grep -q '^locked|' "$WORK/all.txt"; then + echo "FAIL: the all-schema listing shows a schema the role cannot use" >&2 + FAILURES=$((FAILURES + 1)) +fi + +[ "$FAILURES" -eq 0 ] || exit 1 +echo "PASS" From 29af3baeb282f8aa874c7b253cca71670b864ce5 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Wed, 23 Sep 2026 11:26:03 +0700 Subject: [PATCH 2/5] fix(sidebar): keep cross-schema search correct across failed reads, database switches and dotted names --- .../Core/Database/CatalogTableListing.swift | 28 +++++++++- .../Query/DatabaseTreeMetadataService.swift | 22 +++++++- .../Core/Services/Query/SchemaService.swift | 9 ++++ .../ViewModels/QuickSwitcherViewModel.swift | 39 +++++++++++--- TablePro/ViewModels/SidebarViewModel.swift | 34 +++++++++++- .../Views/Sidebar/DatabaseTreeFilter.swift | 22 +++++--- ...DatabaseTreeOutlineCoordinator+Nodes.swift | 6 ++- TablePro/Views/Sidebar/SidebarTreeView.swift | 3 +- .../Concurrency/CatalogFreshnessTests.swift | 12 +++-- .../Database/CatalogTableListingTests.swift | 54 +++++++++++++++++++ .../DatabaseTreeAllSchemaTablesTests.swift | 21 ++++++++ .../QuickSwitcherCrossSchemaTests.swift | 22 ++++++-- ...tabaseTreeFilterQualifiedSearchTests.swift | 15 ++++++ docs/features/connection-window.mdx | 4 +- .../check-postgres-table-listing-parity.sh | 32 +++++++---- 15 files changed, 281 insertions(+), 42 deletions(-) diff --git a/TablePro/Core/Database/CatalogTableListing.swift b/TablePro/Core/Database/CatalogTableListing.swift index e4af96372a..a4476fde1d 100644 --- a/TablePro/Core/Database/CatalogTableListing.swift +++ b/TablePro/Core/Database/CatalogTableListing.swift @@ -22,17 +22,30 @@ internal enum CatalogTableListing { internal let unlistedSchemas: Set /// This listing with another read of some of its unlisted schemas folded in. A schema the - /// read listed moves across; one it still could not list stays unlisted. + /// read listed replaces what was known of it; one it still could not list keeps its rows + /// and stays unlisted. internal func merging(_ retry: Result, retried schemas: Set) -> Result { + let listedNow = schemas.subtracting(retry.unlistedSchemas) let kept = tables.filter { table in guard let schema = table.schema else { return true } - return !schemas.contains(schema) + return !listedNow.contains(schema) } return Result( tables: kept + retry.tables, unlistedSchemas: unlistedSchemas.subtracting(schemas).union(retry.unlistedSchemas) ) } + + /// A refresh that could not read a schema says nothing new about it, so the rows an earlier + /// listing had for that schema are carried over rather than dropped. + internal func keepingRows(from previous: Result?) -> Result { + guard let previous, !unlistedSchemas.isEmpty else { return self } + let carried = previous.tables.filter { table in + guard let schema = table.schema else { return false } + return unlistedSchemas.contains(schema) + } + return Result(tables: tables + carried, unlistedSchemas: unlistedSchemas) + } } private static let logger = Logger(subsystem: "com.TablePro", category: "CatalogTableListing") @@ -60,6 +73,10 @@ internal enum CatalogTableListing { /// The named schemas one by one, which is also how a listing asks again for the schemas it /// could not read the first time. + /// + /// Only a failure that belongs to one schema is recorded against it. A lost connection fails + /// every schema the same way, and recording that as a listing of nothing would read as a + /// database with no tables, so it fails the whole read instead, as does every schema failing. internal static func tables( inSchemas schemas: [String], scope: DatabaseScope, @@ -67,6 +84,7 @@ internal enum CatalogTableListing { ) async throws -> Result { var tables: [TableInfo] = [] var unlisted: Set = [] + var lastError: Error? for schema in schemas { try Task.checkCancellation() do { @@ -75,13 +93,19 @@ internal enum CatalogTableListing { } } catch is CancellationError { throw CancellationError() + } catch let error as DatabaseError { + throw error } catch { logger.warning( "[catalog] schema not listed schema=\(schema, privacy: .private(mask: .hash)) error=\(error.publicLogShape, privacy: .public)" ) unlisted.insert(schema) + lastError = error } } + if let lastError, !schemas.isEmpty, unlisted.count == schemas.count { + throw lastError + } return Result(tables: tables, unlistedSchemas: unlisted) } } diff --git a/TablePro/Core/Services/Query/DatabaseTreeMetadataService.swift b/TablePro/Core/Services/Query/DatabaseTreeMetadataService.swift index a15cc28536..3fa78e87a5 100644 --- a/TablePro/Core/Services/Query/DatabaseTreeMetadataService.swift +++ b/TablePro/Core/Services/Query/DatabaseTreeMetadataService.swift @@ -180,8 +180,13 @@ final class DatabaseTreeMetadataService: ObservableObject, CatalogChangeTarget { ) } guard allSchemaTablesFence.isCurrent(token, for: key) else { return } - if case .fetched = outcome, !allSchemaTablesFreshness.commit(revision, for: key) { return } - allSchemaTablesState[key] = (allSchemaTablesState[key] ?? .idle).settled(by: outcome, discardingValue: false) + let current = allSchemaTablesState[key] ?? .idle + guard case .fetched(let listing) = outcome else { + allSchemaTablesState[key] = current.settled(by: outcome, discardingValue: false) + return + } + guard allSchemaTablesFreshness.commit(revision, for: key) else { return } + allSchemaTablesState[key] = .loaded(listing.keepingRows(from: current.value)) } /// A listing that could not read some schemas stays current for the rest, and only those are @@ -208,12 +213,25 @@ final class DatabaseTreeMetadataService: ObservableObject, CatalogChangeTarget { allSchemaTablesState[key] = .loaded(current.merging(retry, retried: schemas)) } + /// Announced, so a search holding the listing on screen can ask for it again rather than keep + /// matching against rows a catalog change has overtaken. func markAllSchemaTablesChanged(_ keys: some Sequence) { + var changed = false for key in keys { allSchemaTablesFreshness.markChanged(key) + changed = true + } + if changed { + objectWillChange.send() } } + /// Moves with every catalog change that reaches the database, so a caller that asked for the + /// listing at one revision knows to ask again at the next and not before. + func allSchemaTablesRevision(connectionId: UUID, database: String) -> Int { + allSchemaTablesFreshness.revision(for: DatabaseKey(connectionId: connectionId, database: database)) + } + /// System schemas stay out, as they stay out of the tree until Show System is on. private func fetchAllSchemaTables(_ key: DatabaseKey) async throws -> CatalogTableListing.Result { guard let session = DatabaseManager.shared.session(for: key.connectionId) else { diff --git a/TablePro/Core/Services/Query/SchemaService.swift b/TablePro/Core/Services/Query/SchemaService.swift index 1a7864dd41..9750d96364 100644 --- a/TablePro/Core/Services/Query/SchemaService.swift +++ b/TablePro/Core/Services/Query/SchemaService.swift @@ -229,6 +229,15 @@ final class SchemaService: ObservableObject { perSchemaSideObjects[connectionId]?[schema]?.userDefinedTypes ?? .idle } + /// The schemas whose own table list is loaded, empty ones included, which is what a caller + /// merging another source needs: an empty schema here is an answer, not a gap. + func schemasWithLoadedTables(for connectionId: UUID) -> Set { + Set((perSchemaStates[connectionId] ?? [:]).compactMap { schema, state in + guard case .loaded = state else { return nil } + return schema + }) + } + /// Flat tables plus the union of every loaded per-schema table list. For /// hierarchicalSchema plugins the flat list is empty and this is the only /// way to see tables across schemas (e.g. for autocomplete). diff --git a/TablePro/ViewModels/QuickSwitcherViewModel.swift b/TablePro/ViewModels/QuickSwitcherViewModel.swift index 308a2308a3..8d8a981f75 100644 --- a/TablePro/ViewModels/QuickSwitcherViewModel.swift +++ b/TablePro/ViewModels/QuickSwitcherViewModel.swift @@ -53,7 +53,11 @@ internal final class QuickSwitcherViewModel: ObservableObject { let database: String? let browseSchema: String? let openTables: Set - let listsTablesPerSchema: Bool + let grouping: GroupingStrategy + + var listsTablesPerSchema: Bool { + DatabaseTreeMetadataService.listsTablesPerSchema(grouping) + } } nonisolated private static let logger = Logger(subsystem: "com.TablePro", category: "QuickSwitcherViewModel") @@ -207,9 +211,7 @@ internal final class QuickSwitcherViewModel: ObservableObject { database: services.databaseManager.browseScope(for: connectionId)?.database, browseSchema: browseSchema, openTables: openTables, - listsTablesPerSchema: DatabaseTreeMetadataService.listsTablesPerSchema( - services.pluginManager.databaseGroupingStrategy(for: databaseType) - ) + grouping: services.pluginManager.databaseGroupingStrategy(for: databaseType) ) self.tableSource = tableSource observeTableSources() @@ -403,9 +405,11 @@ internal final class QuickSwitcherViewModel: ObservableObject { return DatabaseTreeMetadataService.shared .allSchemaTablesLoadState(connectionId: connectionId, database: database).value?.tables } ?? [] + let loadedScope = services.schemaService.loadedScope(for: connectionId) let tables = Self.mergedTables( local: services.schemaService.allLoadedTables(for: connectionId), - loadedFrom: services.schemaService.loadedScope(for: connectionId)?.database, + loadedFrom: loadedScope?.database, + coveredSchemas: coveredSchemas(loadedScope: loadedScope, grouping: tableSource.grouping), allSchemas: allSchemaTables, browsing: tableSource.database ) @@ -635,19 +639,38 @@ internal final class QuickSwitcherViewModel: ObservableObject { /// The schema service keeps its lists until a reload replaces them, so while a database switch /// settles it still holds the old database's tables, which would open against the new one. /// They count only once the database they were loaded from is the one being browsed. + /// + /// `coveredSchemas` names the schemas the schema service answers for even when it found them + /// empty. Judged from its rows alone, a schema whose last table was dropped would have no rows, + /// so no say, and the listing's stale copy of that table would come back. nonisolated static func mergedTables( local loaded: [TableInfo], loadedFrom loadedDatabase: String?, + coveredSchemas: Set, allSchemas: [TableInfo], browsing database: String? ) -> [TableInfo] { - let local = loadedDatabase == database ? loaded : [] - let localSchemas = Set(local.map { $0.schema ?? "" }) + let isCurrent = loadedDatabase == database + let local = isCurrent ? loaded : [] + let authoritative = (isCurrent ? coveredSchemas : []).union(local.map { $0.schema ?? "" }) var seen: Set = [] - return (local + allSchemas.filter { !localSchemas.contains($0.schema ?? "") }) + return (local + allSchemas.filter { !authoritative.contains($0.schema ?? "") }) .filter { seen.insert(TableIdentity(schema: $0.schema ?? "", name: $0.name)).inserted } } + /// The schemas the schema service holds an answer for. On a schema-grouped engine its flat list + /// is the browsed schema's; on a hierarchical one each schema keeps a list of its own, and the + /// flat list is empty whatever the browsed schema holds. + private func coveredSchemas(loadedScope: DatabaseScope?, grouping: GroupingStrategy) -> Set { + var covered = services.schemaService.schemasWithLoadedTables(for: connectionId) + if grouping != .hierarchicalSchema, + services.schemaService.hasLoadedContent(for: connectionId), + let schema = loadedScope?.schema { + covered.insert(schema) + } + return covered + } + private struct TableIdentity: Hashable { let schema: String let name: String diff --git a/TablePro/ViewModels/SidebarViewModel.swift b/TablePro/ViewModels/SidebarViewModel.swift index d9cbb88457..fd39e6aef0 100644 --- a/TablePro/ViewModels/SidebarViewModel.swift +++ b/TablePro/ViewModels/SidebarViewModel.swift @@ -106,10 +106,17 @@ final class SidebarViewModel: ObservableObject { @Published private(set) var filterQuery = "" { didSet { invalidateFilterCaches() + requestedListingRevisions.removeAll() loadAllSchemaTablesForSearch() } } + /// The listing revision each database was last asked for at, so a search asks again after a + /// catalog change, a reconnect or a database switch, and never twice for the same revision: + /// a read that failed would otherwise be retried on every change the sidebar observes. + private var requestedListingRevisions: [String: Int] = [:] + private var listingDemandObservations: [AnyCancellable] = [] + private var filterDebounceTask: Task? @Published var expanded: ExpansionState { @@ -209,6 +216,14 @@ final class SidebarViewModel: ObservableObject { /// initializer instead ran on every view-graph pass. self.filterQuery = self.sharedState.searchText observeSearchText() + observeListingDemand() + } + + private func observeListingDemand() { + listingDemandObservations = [ + DatabaseTreeMetadataService.shared.onMainActorChange { [weak self] in self?.loadAllSchemaTablesForSearch() }, + DatabaseManager.shared.onMainActorChange { [weak self] in self?.loadAllSchemaTablesForSearch() } + ] } private static func loadInitialExpansion(connectionId: UUID) -> ExpansionState { @@ -522,11 +537,28 @@ final class SidebarViewModel: ObservableObject { if let browsedDatabase, !browsedDatabase.isEmpty { databases.insert(browsedDatabase) } - for database in databases { + for database in databases where needsListingRequest(database: database, service: service) { + requestedListingRevisions[database] = service.allSchemaTablesRevision( + connectionId: connectionId, database: database + ) Task { await service.loadAllSchemaTables(connectionId: connectionId, database: database) } } } + /// A listing nobody holds is asked for; one in flight is left alone; one loaded or failed is + /// asked for again only once its revision has moved past the one this search last asked at. + private func needsListingRequest(database: String, service: DatabaseTreeMetadataService) -> Bool { + switch service.allSchemaTablesLoadState(connectionId: connectionId, database: database) { + case .loading: + return false + case .idle: + return true + case .loaded, .failed: + let revision = service.allSchemaTablesRevision(connectionId: connectionId, database: database) + return requestedListingRevisions[database] != revision + } + } + private func rebuildKindBuckets(from tables: [TableInfo]) { var buckets: [SidebarObjectKind: [TableInfo]] = [:] for kind in SidebarObjectKind.allCases { diff --git a/TablePro/Views/Sidebar/DatabaseTreeFilter.swift b/TablePro/Views/Sidebar/DatabaseTreeFilter.swift index acbcffff5f..3e719a8122 100644 --- a/TablePro/Views/Sidebar/DatabaseTreeFilter.swift +++ b/TablePro/Views/Sidebar/DatabaseTreeFilter.swift @@ -136,6 +136,9 @@ enum DatabaseTreeFilter { /// unloaded schema as an empty one hides it for the whole life of the filter and blanks the /// pane while the search-driven load is still running. A match on a procedure, trigger or type /// keeps the schema as surely as a match on a table. + /// + /// `database` is the one being browsed, when the engine has one, so a search that names it + /// (`shop.hr.employees`) can match. static func hierarchicalSchemaIsVisible( _ schema: String, searchText: String, @@ -143,17 +146,19 @@ enum DatabaseTreeFilter { tables: [TableInfo], routines: [RoutineInfo], triggers: [TriggerInfo], - userTypes: [UserDefinedTypeInfo] + userTypes: [UserDefinedTypeInfo], + database: String? = nil ) -> Bool { let search = SidebarSearch(searchText) - if search.matchesContainer(database: nil, schema: schema) { return true } - guard isLoaded else { return search.admits(database: nil, schema: schema) } + if search.matchesContainer(database: database, schema: schema) { return true } + guard isLoaded else { return search.admits(database: database, schema: schema) } return !objectBuckets( tables: tables, routines: routines, triggers: triggers, userTypes: userTypes, - searchText: searchText + searchText: searchText, + database: database ).isEmpty } @@ -165,14 +170,17 @@ enum DatabaseTreeFilter { routines: [RoutineInfo], triggers: [TriggerInfo], userTypes: [UserDefinedTypeInfo], - searchText: String + searchText: String, + database: String? = nil ) -> DatabaseTreeObjectBuckets { - objectBuckets( + let matchesSchema = SidebarSearch(searchText).matchesContainer(database: database, schema: schema) + return objectBuckets( tables: tables, routines: routines, triggers: triggers, userTypes: userTypes, - searchText: SidebarSearch(searchText).matchesContainer(database: nil, schema: schema) ? "" : searchText + searchText: matchesSchema ? "" : searchText, + database: database ) } diff --git a/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Nodes.swift b/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Nodes.swift index 39d0fc113d..91bc4919a3 100644 --- a/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Nodes.swift +++ b/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Nodes.swift @@ -284,7 +284,8 @@ extension DatabaseTreeOutlineCoordinator { tables: schemaService.tables(for: connectionId, schema: schema), routines: schemaService.routines(for: connectionId, schema: schema), triggers: schemaService.triggers(for: connectionId, schema: schema), - userTypes: schemaService.userDefinedTypes(for: connectionId, schema: schema) + userTypes: schemaService.userDefinedTypes(for: connectionId, schema: schema), + database: browsingDatabase ) } @@ -335,7 +336,8 @@ extension DatabaseTreeOutlineCoordinator { routines: schemaService.routines(for: connectionId, schema: schema), triggers: schemaService.triggers(for: connectionId, schema: schema), userTypes: schemaService.userDefinedTypes(for: connectionId, schema: schema), - searchText: searchText + searchText: searchText, + database: browsingDatabase ) } diff --git a/TablePro/Views/Sidebar/SidebarTreeView.swift b/TablePro/Views/Sidebar/SidebarTreeView.swift index 7205bb70c2..d55e497437 100644 --- a/TablePro/Views/Sidebar/SidebarTreeView.swift +++ b/TablePro/Views/Sidebar/SidebarTreeView.swift @@ -114,7 +114,8 @@ struct SidebarTreeView: View { tables: schemaService.tables(for: connectionId, schema: schema), routines: schemaService.routines(for: connectionId, schema: schema), triggers: schemaService.triggers(for: connectionId, schema: schema), - userTypes: schemaService.userDefinedTypes(for: connectionId, schema: schema) + userTypes: schemaService.userDefinedTypes(for: connectionId, schema: schema), + database: activeDatabase ) } diff --git a/TableProTests/Core/Concurrency/CatalogFreshnessTests.swift b/TableProTests/Core/Concurrency/CatalogFreshnessTests.swift index d53c229c41..19c1c26d52 100644 --- a/TableProTests/Core/Concurrency/CatalogFreshnessTests.swift +++ b/TableProTests/Core/Concurrency/CatalogFreshnessTests.swift @@ -19,7 +19,8 @@ struct CatalogFreshnessTests { func committedFetch() { var freshness = CatalogFreshness() let revision = freshness.revision(for: "shop") - #expect(freshness.commit(revision, for: "shop")) + let committed = freshness.commit(revision, for: "shop") + #expect(committed) #expect(freshness.isCurrent("shop")) } @@ -36,7 +37,8 @@ struct CatalogFreshnessTests { var freshness = CatalogFreshness() let started = freshness.revision(for: "shop") freshness.markChanged("shop") - #expect(freshness.commit(started, for: "shop")) + let committed = freshness.commit(started, for: "shop") + #expect(committed) #expect(!freshness.isCurrent("shop")) } @@ -46,8 +48,10 @@ struct CatalogFreshnessTests { let older = freshness.revision(for: "shop") freshness.markChanged("shop") let newer = freshness.revision(for: "shop") - #expect(freshness.commit(newer, for: "shop")) - #expect(!freshness.commit(older, for: "shop")) + let newerCommitted = freshness.commit(newer, for: "shop") + let olderCommitted = freshness.commit(older, for: "shop") + #expect(newerCommitted) + #expect(!olderCommitted) #expect(freshness.isCurrent("shop")) } diff --git a/TableProTests/Core/Database/CatalogTableListingTests.swift b/TableProTests/Core/Database/CatalogTableListingTests.swift index 54e8c52cca..3b06ea1f36 100644 --- a/TableProTests/Core/Database/CatalogTableListingTests.swift +++ b/TableProTests/Core/Database/CatalogTableListingTests.swift @@ -85,6 +85,60 @@ struct CatalogTableListingTests { #expect(merged.unlistedSchemas == ["payroll"]) } + @Test("A retry that still cannot read a schema keeps what was known of it") + func mergingARetryThatFailsAgain() { + let first = CatalogTableListing.Result( + tables: [table("users", "public"), table("payslips", "payroll")], + unlistedSchemas: ["payroll"] + ) + let retry = CatalogTableListing.Result(tables: [], unlistedSchemas: ["payroll"]) + + let merged = first.merging(retry, retried: ["payroll"]) + + #expect(merged.tables.map(\.name) == ["users", "payslips"]) + #expect(merged.unlistedSchemas == ["payroll"]) + } + + @Test("A refresh that cannot read a schema carries that schema's earlier rows over") + func keepingRowsFromAnEarlierListing() { + let earlier = CatalogTableListing.Result( + tables: [table("users", "public"), table("timesheet", "attendance")], + unlistedSchemas: [] + ) + let refresh = CatalogTableListing.Result(tables: [table("orders", "public")], unlistedSchemas: ["attendance"]) + + let kept = refresh.keepingRows(from: earlier) + + #expect(kept.tables.map(\.name) == ["orders", "timesheet"]) + #expect(kept.unlistedSchemas == ["attendance"]) + } + + @Test("A lost connection fails the whole listing rather than reading as empty") + func lostConnectionFailsTheListing() async { + let driver = MockDatabaseDriver() + driver.schemasToReturn = ["public", "attendance"] + driver.schemaTablesErrors = ["attendance": DatabaseError.notConnected] + + await #expect(throws: DatabaseError.self) { + try await CatalogTableListing.tables( + in: scope, excludingSchemas: [], metadata: RecordingMetadataProvider(driver: driver) + ) + } + } + + @Test("Every schema failing fails the whole listing") + func everySchemaFailingFailsTheListing() async { + let driver = MockDatabaseDriver() + driver.schemasToReturn = ["public", "attendance"] + driver.schemaTablesErrors = ["public": ListingFailed(), "attendance": ListingFailed()] + + await #expect(throws: ListingFailed.self) { + try await CatalogTableListing.tables( + in: scope, excludingSchemas: [], metadata: RecordingMetadataProvider(driver: driver) + ) + } + } + @Test("A failed schema list fails the whole listing") func failedSchemaListThrows() async { let driver = MockDatabaseDriver() diff --git a/TableProTests/Core/Services/Query/DatabaseTreeAllSchemaTablesTests.swift b/TableProTests/Core/Services/Query/DatabaseTreeAllSchemaTablesTests.swift index 21779d11dd..850b309a2e 100644 --- a/TableProTests/Core/Services/Query/DatabaseTreeAllSchemaTablesTests.swift +++ b/TableProTests/Core/Services/Query/DatabaseTreeAllSchemaTablesTests.swift @@ -113,6 +113,27 @@ struct DatabaseTreeAllSchemaTablesTests { await disconnect(connection) } + @Test("A refresh that cannot read a schema keeps the rows it had for it") + func refreshKeepsRowsOfAnUnreadableSchema() async { + let (connection, driver) = connect { driver in + driver.schemasToReturn = ["public", "attendance"] + driver.schemaTablesToReturn = [ + "public": [table("users", "public")], + "attendance": [table("timesheet", "attendance")] + ] + } + await load(connection) + await service.refreshCatalog(for: CatalogChange(connectionId: connection.id, kinds: .tables)) + + driver.schemaTablesToReturn["public"] = [table("users", "public"), table("orders", "public")] + driver.schemaTablesErrors = ["attendance": ListingFailed()] + await load(connection) + + #expect(listing(connection)?.tables.map(\.name) == ["users", "orders", "timesheet"]) + #expect(listing(connection)?.unlistedSchemas == ["attendance"]) + await disconnect(connection) + } + @Test("A second read is served without fetching again") func secondReadIsCached() async { let (connection, driver) = connect { $0.allSchemaTablesToReturn = [table("users", "public")] } diff --git a/TableProTests/ViewModels/QuickSwitcherCrossSchemaTests.swift b/TableProTests/ViewModels/QuickSwitcherCrossSchemaTests.swift index e88f79b766..e7321f09f5 100644 --- a/TableProTests/ViewModels/QuickSwitcherCrossSchemaTests.swift +++ b/TableProTests/ViewModels/QuickSwitcherCrossSchemaTests.swift @@ -101,18 +101,31 @@ struct QuickSwitcherCrossSchemaTests { let allSchemas = [table("users", "public"), table("dropped", "public"), table("timesheet", "attendance")] let merged = QuickSwitcherViewModel.mergedTables( - local: local, loadedFrom: "shop", allSchemas: allSchemas, browsing: "shop" + local: local, loadedFrom: "shop", coveredSchemas: ["public"], allSchemas: allSchemas, browsing: "shop" ) #expect(merged.map(\.name) == ["users", "timesheet"]) } + /// The last table of `public` was dropped: the schema service reloaded `public` as empty, and + /// the all-schema listing still holds the table until it is next asked. + @Test("A schema the schema service found empty keeps the listing's stale rows out") + func emptyCoveredSchemaKeepsStaleRowsOut() { + let allSchemas = [table("users", "public"), table("timesheet", "attendance")] + + let merged = QuickSwitcherViewModel.mergedTables( + local: [], loadedFrom: "shop", coveredSchemas: ["public"], allSchemas: allSchemas, browsing: "shop" + ) + + #expect(merged.map(\.name) == ["timesheet"]) + } + @Test("A table listed twice is merged once") func mergedTablesDeduplicate() { let allSchemas = [table("timesheet", "attendance"), table("timesheet", "attendance")] let merged = QuickSwitcherViewModel.mergedTables( - local: [], loadedFrom: "shop", allSchemas: allSchemas, browsing: "shop" + local: [], loadedFrom: "shop", coveredSchemas: [], allSchemas: allSchemas, browsing: "shop" ) #expect(merged.count == 1) @@ -125,11 +138,12 @@ struct QuickSwitcherCrossSchemaTests { let merged = QuickSwitcherViewModel.mergedTables( local: [table("invoices", "public")], loadedFrom: "billing", - allSchemas: [table("timesheet", "attendance")], + coveredSchemas: ["public"], + allSchemas: [table("orders", "public"), table("timesheet", "attendance")], browsing: "shop" ) - #expect(merged.map(\.name) == ["timesheet"]) + #expect(merged.map(\.name) == ["orders", "timesheet"]) } // MARK: - Qualified queries diff --git a/TableProTests/Views/Sidebar/DatabaseTreeFilterQualifiedSearchTests.swift b/TableProTests/Views/Sidebar/DatabaseTreeFilterQualifiedSearchTests.swift index 48f64433b1..8d08273c25 100644 --- a/TableProTests/Views/Sidebar/DatabaseTreeFilterQualifiedSearchTests.swift +++ b/TableProTests/Views/Sidebar/DatabaseTreeFilterQualifiedSearchTests.swift @@ -226,6 +226,21 @@ struct DatabaseTreeFilterQualifiedSearchTests { #expect(named) } + @Test("A hierarchical search can name the browsed database, and only that one") + func hierarchicalThreeParts() { + let loaded = [table("EMPLOYEES", schema: "HR")] + let browsed = DatabaseTreeFilter.hierarchicalSchemaIsVisible( + "HR", searchText: "SHOP.HR.EMP", isLoaded: true, + tables: loaded, routines: [], triggers: [], userTypes: [], database: "SHOP" + ) + let other = DatabaseTreeFilter.hierarchicalSchemaIsVisible( + "HR", searchText: "BLOG.HR.EMP", isLoaded: true, + tables: loaded, routines: [], triggers: [], userTypes: [], database: "SHOP" + ) + #expect(browsed) + #expect(!other) + } + @Test("A trailing dot shows everything in the hierarchical schema it names") func hierarchicalTrailingDot() { let buckets = DatabaseTreeFilter.hierarchicalObjectBuckets( diff --git a/docs/features/connection-window.mdx b/docs/features/connection-window.mdx index fe0546b288..3ac94fcaa3 100644 --- a/docs/features/connection-window.mdx +++ b/docs/features/connection-window.mdx @@ -92,12 +92,12 @@ The filter field matches any part of a name, so `sheet` finds `timesheet`. How f | Layout | Searches | |---|---| -| **View > Sidebar as List** | The browsed schema, then every other schema holding a match, each listed below as a row to expand | +| **View > Sidebar as List** | The browsed schema, then every other schema holding a match, listed below it and opened to show the matches | | **View > Sidebar as Tree** | Every schema of every database whose schemas the tree has shown, expanded or not | A schema whose tables have not been read yet stays in the tree, collapsed, until they arrive. -Type a dot to filter by schema. `attendance.time` keeps the objects in `attendance` whose names contain `time`, `attendance.` shows everything in `attendance`, and `shop.attendance.time` names the database too. [Open Quickly](/features/open-quickly#other-schemas) takes the same form with fuzzy matching. +Type a dot to filter by schema. `attendance.time` keeps the objects in `attendance` whose names contain `time`, `attendance.` shows everything in `attendance`, and `shop.attendance.time` names the database too. A table whose own name holds a dot, such as `audit.events`, still matches when you type that name. [Open Quickly](/features/open-quickly#other-schemas) takes the same form with fuzzy matching. ## The trailing pane diff --git a/scripts/check-postgres-table-listing-parity.sh b/scripts/check-postgres-table-listing-parity.sh index b231bdb56c..48be63a421 100755 --- a/scripts/check-postgres-table-listing-parity.sh +++ b/scripts/check-postgres-table-listing-parity.sh @@ -28,10 +28,25 @@ HOST="${1:-127.0.0.1}" PORT="${2:-5432}" USER_NAME="${3:-postgres}" ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" -DATABASE="tablepro_listing_parity_check" -READER="tablepro_listing_reader" +# Named per run and never dropped unless this run created them, so pointing the check at a shared +# server cannot touch anything that was already there, and two runs cannot remove each other's. +RUN_ID="$$_$RANDOM" +DATABASE="tablepro_listing_parity_$RUN_ID" +READER="tablepro_listing_reader_$RUN_ID" +CREATED_DATABASE=0 +CREATED_READER=0 WORK="$(mktemp -d)" -trap 'rm -rf "$WORK"' EXIT + +cleanup() { + rm -rf "$WORK" + if [ "$CREATED_DATABASE" -eq 1 ]; then + psql -X -q -h "$HOST" -p "$PORT" -U "$USER_NAME" -d postgres -c "DROP DATABASE $DATABASE" > /dev/null 2>&1 + fi + if [ "$CREATED_READER" -eq 1 ]; then + psql -X -q -h "$HOST" -p "$PORT" -U "$USER_NAME" -d postgres -c "DROP ROLE $READER" > /dev/null 2>&1 + fi +} +trap cleanup EXIT command -v psql > /dev/null || { echo "psql not found" >&2 @@ -103,13 +118,12 @@ HARNESS="$WORK/listing-sql" VERSION="$(psql_do postgres -Atc "SHOW server_version")" echo "Checking the all-schema table listing against PostgreSQL $VERSION at $HOST:$PORT" -psql_do postgres -c "DROP DATABASE IF EXISTS $DATABASE" > /dev/null -psql_do postgres -c "DROP ROLE IF EXISTS $READER" > /dev/null 2>&1 -psql_do postgres -c "CREATE DATABASE $DATABASE" > /dev/null -psql_do postgres -c "CREATE ROLE $READER" > /dev/null -trap 'rm -rf "$WORK"; psql -X -q -h "$HOST" -p "$PORT" -U "$USER_NAME" -d postgres -c "DROP DATABASE IF EXISTS $DATABASE" > /dev/null 2>&1; psql -X -q -h "$HOST" -p "$PORT" -U "$USER_NAME" -d postgres -c "DROP ROLE IF EXISTS $READER" > /dev/null 2>&1' EXIT +psql_do postgres -c "CREATE DATABASE $DATABASE" > /dev/null || exit 3 +CREATED_DATABASE=1 +psql_do postgres -c "CREATE ROLE $READER" > /dev/null || exit 3 +CREATED_READER=1 -psql_do "$DATABASE" > /dev/null << SQL +psql_do "$DATABASE" > /dev/null << SQL || exit 3 CREATE SCHEMA attendance; CREATE SCHEMA "Attendance"; CREATE SCHEMA "my.schema"; From c5461dffa3d83958ae2e706efbbe1aa7856fa22b Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Wed, 23 Sep 2026 12:22:59 +0700 Subject: [PATCH 3/5] fix(sidebar): keep cross-schema listings fresh across reconnects and database switches --- .../Query/AllSchemaTablesDemand.swift | 49 +++++++++++ .../Utilities/UI/QualifiedSearchQuery.swift | 17 ++-- .../ViewModels/QuickSwitcherViewModel.swift | 48 ++++++++--- TablePro/ViewModels/SidebarViewModel.swift | 32 ++------ .../Query/AllSchemaTablesDemandTests.swift | 82 +++++++++++++++++++ .../Utilities/QualifiedSearchQueryTests.swift | 11 ++- .../QuickSwitcherCrossSchemaTests.swift | 44 ++++++++-- 7 files changed, 231 insertions(+), 52 deletions(-) create mode 100644 TablePro/Core/Services/Query/AllSchemaTablesDemand.swift create mode 100644 TableProTests/Core/Services/Query/AllSchemaTablesDemandTests.swift diff --git a/TablePro/Core/Services/Query/AllSchemaTablesDemand.swift b/TablePro/Core/Services/Query/AllSchemaTablesDemand.swift new file mode 100644 index 0000000000..47d5e8e877 --- /dev/null +++ b/TablePro/Core/Services/Query/AllSchemaTablesDemand.swift @@ -0,0 +1,49 @@ +// +// AllSchemaTablesDemand.swift +// TablePro +// + +import Foundation + +/// When a reader holding a database's all-schema listing on screen should ask for it again. +/// +/// A reader asks when nothing is held, and otherwise once the listing's revision has moved past +/// the one it last asked at: after a catalog change, a reconnect or a database switch. It never +/// asks twice for the same revision, or a read that failed would be retried on every change the +/// reader observes. And it never asks while the session is not connected, because the load would +/// return without starting and the revision would count as asked for all the same, which left a +/// search stale after every reconnect. +@MainActor +internal struct AllSchemaTablesDemand { + private var requested: [String: Int] = [:] + + internal mutating func reset() { + requested.removeAll() + } + + internal mutating func noteRequested(connectionId: UUID, database: String, service: DatabaseTreeMetadataService) { + requested[database] = service.allSchemaTablesRevision(connectionId: connectionId, database: database) + } + + internal mutating func requestIfNeeded( + connectionId: UUID, + database: String, + isConnected: Bool, + service: DatabaseTreeMetadataService + ) { + guard isConnected, needsRequest(connectionId: connectionId, database: database, service: service) else { return } + noteRequested(connectionId: connectionId, database: database, service: service) + Task { await service.loadAllSchemaTables(connectionId: connectionId, database: database) } + } + + internal func needsRequest(connectionId: UUID, database: String, service: DatabaseTreeMetadataService) -> Bool { + switch service.allSchemaTablesLoadState(connectionId: connectionId, database: database) { + case .loading: + return false + case .idle: + return true + case .loaded, .failed: + return requested[database] != service.allSchemaTablesRevision(connectionId: connectionId, database: database) + } + } +} diff --git a/TablePro/Core/Utilities/UI/QualifiedSearchQuery.swift b/TablePro/Core/Utilities/UI/QualifiedSearchQuery.swift index 93a3b32688..6b231002a9 100644 --- a/TablePro/Core/Utilities/UI/QualifiedSearchQuery.swift +++ b/TablePro/Core/Utilities/UI/QualifiedSearchQuery.swift @@ -38,18 +38,15 @@ internal struct QualifiedSearchQuery: Equatable, Sendable { return Array(zip(containers, location.suffix(containers.count))) } - /// Where an object lives, outermost first, as a qualified query addresses it. A schema that - /// only repeats the database, which is how some engines report a schema-less object, is not a - /// second level. + /// Where an object lives, outermost first, as a qualified query addresses it. Both levels stay + /// even when they share a name: a PostgreSQL database `shop` can hold a schema `shop`, and + /// `shop.shop.orders` has to reach it. An engine that reports its database as the schema of a + /// schema-less object still matches `shop.orders`, since the query lines up from the right. internal static func location(database: String?, schema: String?) -> [String] { - var location: [String] = [] - if let database, !database.isEmpty { - location.append(database) + [database, schema].compactMap { part in + guard let part, !part.isEmpty else { return nil } + return part } - if let schema, !schema.isEmpty, schema != database { - location.append(schema) - } - return location } private static let closingQuotes: [Character: Character] = ["\"": "\"", "`": "`", "[": "]"] diff --git a/TablePro/ViewModels/QuickSwitcherViewModel.swift b/TablePro/ViewModels/QuickSwitcherViewModel.swift index 8d8a981f75..6ec786dd98 100644 --- a/TablePro/ViewModels/QuickSwitcherViewModel.swift +++ b/TablePro/ViewModels/QuickSwitcherViewModel.swift @@ -89,6 +89,7 @@ internal final class QuickSwitcherViewModel: ObservableObject { private var tableItems: [QuickSwitcherItem] = [] private var tableSource: TableSource? private var tableSourceObservations: [AnyCancellable] = [] + private var listingDemand = AllSchemaTablesDemand() private var filterTask: Task? private var selectionQuery: String? private var selectionScope: QuickSwitcherScope? @@ -377,20 +378,37 @@ internal final class QuickSwitcherViewModel: ObservableObject { guard activeLoadId == loadId else { return } mergeTableItems() guard source.listsTablesPerSchema, let database = source.database else { return } - await DatabaseTreeMetadataService.shared.loadAllSchemaTables(connectionId: connectionId, database: database) + let service = DatabaseTreeMetadataService.shared + listingDemand.noteRequested(connectionId: connectionId, database: database, service: service) + await service.loadAllSchemaTables(connectionId: connectionId, database: database) guard activeLoadId == loadId else { return } mergeTableItems() } /// A change to either source while the panel is open reaches it. A change that leaves the - /// tables as they were costs a comparison and no refilter. + /// tables as they were costs a comparison and no refilter. A catalog change or a reconnect + /// while it is open asks for the listing again. private func observeTableSources() { tableSourceObservations = [ services.schemaService.onMainActorChange { [weak self] in self?.mergeTableItems() }, - DatabaseTreeMetadataService.shared.onMainActorChange { [weak self] in self?.mergeTableItems() } + DatabaseTreeMetadataService.shared.onMainActorChange { [weak self] in + self?.requestListingIfStale() + self?.mergeTableItems() + }, + services.databaseManager.onMainActorChange { [weak self] in self?.requestListingIfStale() } ] } + private func requestListingIfStale() { + guard let tableSource, tableSource.listsTablesPerSchema, let database = tableSource.database else { return } + listingDemand.requestIfNeeded( + connectionId: connectionId, + database: database, + isConnected: services.databaseManager.session(for: connectionId)?.status == .connected, + service: DatabaseTreeMetadataService.shared + ) + } + private func mergeTableItems() { let items = currentTableItems() guard items != tableItems else { return } @@ -400,18 +418,19 @@ internal final class QuickSwitcherViewModel: ObservableObject { private func currentTableItems() -> [QuickSwitcherItem] { guard let tableSource else { return [] } - let allSchemaTables = tableSource.database.flatMap { database -> [TableInfo]? in + let listing = tableSource.database.flatMap { database -> [TableInfo]? in guard tableSource.listsTablesPerSchema else { return nil } return DatabaseTreeMetadataService.shared .allSchemaTablesLoadState(connectionId: connectionId, database: database).value?.tables - } ?? [] + } let loadedScope = services.schemaService.loadedScope(for: connectionId) let tables = Self.mergedTables( local: services.schemaService.allLoadedTables(for: connectionId), loadedFrom: loadedScope?.database, coveredSchemas: coveredSchemas(loadedScope: loadedScope, grouping: tableSource.grouping), - allSchemas: allSchemaTables, - browsing: tableSource.database + listing: listing, + browsing: tableSource.database, + grouping: tableSource.grouping ) return Self.makeTableItems( tables, @@ -643,18 +662,25 @@ internal final class QuickSwitcherViewModel: ObservableObject { /// `coveredSchemas` names the schemas the schema service answers for even when it found them /// empty. Judged from its rows alone, a schema whose last table was dropped would have no rows, /// so no say, and the listing's stale copy of that table would come back. + /// + /// A hierarchical engine is the exception. Its per-schema lists are keyed by schema alone and + /// keep the rows of a database the connection has just switched away from until each one + /// reloads, so once the listing, which is keyed by database, has arrived it answers for every + /// schema, and the schema service only stands in until then. nonisolated static func mergedTables( local loaded: [TableInfo], loadedFrom loadedDatabase: String?, coveredSchemas: Set, - allSchemas: [TableInfo], - browsing database: String? + listing: [TableInfo]?, + browsing database: String?, + grouping: GroupingStrategy ) -> [TableInfo] { - let isCurrent = loadedDatabase == database + let listingAnswersAll = grouping == .hierarchicalSchema && listing != nil + let isCurrent = loadedDatabase == database && !listingAnswersAll let local = isCurrent ? loaded : [] let authoritative = (isCurrent ? coveredSchemas : []).union(local.map { $0.schema ?? "" }) var seen: Set = [] - return (local + allSchemas.filter { !authoritative.contains($0.schema ?? "") }) + return (local + (listing ?? []).filter { !authoritative.contains($0.schema ?? "") }) .filter { seen.insert(TableIdentity(schema: $0.schema ?? "", name: $0.name)).inserted } } diff --git a/TablePro/ViewModels/SidebarViewModel.swift b/TablePro/ViewModels/SidebarViewModel.swift index fd39e6aef0..f96378c398 100644 --- a/TablePro/ViewModels/SidebarViewModel.swift +++ b/TablePro/ViewModels/SidebarViewModel.swift @@ -106,15 +106,12 @@ final class SidebarViewModel: ObservableObject { @Published private(set) var filterQuery = "" { didSet { invalidateFilterCaches() - requestedListingRevisions.removeAll() + listingDemand.reset() loadAllSchemaTablesForSearch() } } - /// The listing revision each database was last asked for at, so a search asks again after a - /// catalog change, a reconnect or a database switch, and never twice for the same revision: - /// a read that failed would otherwise be retried on every change the sidebar observes. - private var requestedListingRevisions: [String: Int] = [:] + private var listingDemand = AllSchemaTablesDemand() private var listingDemandObservations: [AnyCancellable] = [] private var filterDebounceTask: Task? @@ -537,25 +534,14 @@ final class SidebarViewModel: ObservableObject { if let browsedDatabase, !browsedDatabase.isEmpty { databases.insert(browsedDatabase) } - for database in databases where needsListingRequest(database: database, service: service) { - requestedListingRevisions[database] = service.allSchemaTablesRevision( - connectionId: connectionId, database: database + let isConnected = DatabaseManager.shared.session(for: connectionId)?.status == .connected + for database in databases { + listingDemand.requestIfNeeded( + connectionId: connectionId, + database: database, + isConnected: isConnected, + service: service ) - Task { await service.loadAllSchemaTables(connectionId: connectionId, database: database) } - } - } - - /// A listing nobody holds is asked for; one in flight is left alone; one loaded or failed is - /// asked for again only once its revision has moved past the one this search last asked at. - private func needsListingRequest(database: String, service: DatabaseTreeMetadataService) -> Bool { - switch service.allSchemaTablesLoadState(connectionId: connectionId, database: database) { - case .loading: - return false - case .idle: - return true - case .loaded, .failed: - let revision = service.allSchemaTablesRevision(connectionId: connectionId, database: database) - return requestedListingRevisions[database] != revision } } diff --git a/TableProTests/Core/Services/Query/AllSchemaTablesDemandTests.swift b/TableProTests/Core/Services/Query/AllSchemaTablesDemandTests.swift new file mode 100644 index 0000000000..8648d29b95 --- /dev/null +++ b/TableProTests/Core/Services/Query/AllSchemaTablesDemandTests.swift @@ -0,0 +1,82 @@ +// +// AllSchemaTablesDemandTests.swift +// TableProTests +// + +import Foundation +@testable import TablePro +import TableProPluginKit +import Testing + +@Suite("AllSchemaTablesDemand") +@MainActor +struct AllSchemaTablesDemandTests { + private let service = DatabaseTreeMetadataService.shared + + private func connectedListing() async -> DatabaseConnection { + let connection = TestFixtures.makeConnection(type: .pglite) + let driver = MockDatabaseDriver(connection: connection) + driver.allSchemaTablesToReturn = [TestFixtures.makeTableInfo(name: "users", schema: "public")] + var session = ConnectionSession(connection: connection, driver: driver) + session.status = .connected + DatabaseManager.shared.injectSession(session, for: connection.id) + await service.loadAllSchemaTables(connectionId: connection.id, database: connection.database) + return connection + } + + private func disconnect(_ connection: DatabaseConnection) async { + await service.handleDisconnect(connectionId: connection.id) + DatabaseManager.shared.removeSession(for: connection.id) + } + + @Test("A listing nobody holds is asked for") + func idleListingIsRequested() { + let demand = AllSchemaTablesDemand() + #expect(demand.needsRequest(connectionId: UUID(), database: "shop", service: service)) + } + + @Test("A listing is not asked for twice at one revision, and is asked again once it moves") + func oncePerRevision() async { + let connection = await connectedListing() + var demand = AllSchemaTablesDemand() + demand.noteRequested(connectionId: connection.id, database: connection.database, service: service) + #expect(!demand.needsRequest(connectionId: connection.id, database: connection.database, service: service)) + + service.markAllSchemaTablesChanged([ + DatabaseTreeMetadataService.DatabaseKey(connectionId: connection.id, database: connection.database) + ]) + #expect(demand.needsRequest(connectionId: connection.id, database: connection.database, service: service)) + await disconnect(connection) + } + + /// A reconnect moves the revision while the session is still connecting. Counting that revision + /// as asked for, when the load could not start, left the search stale once the session was back. + @Test("A request while not connected is not counted, so the next one after connecting goes out") + func notConnectedIsNotCounted() async { + let connection = await connectedListing() + var demand = AllSchemaTablesDemand() + demand.noteRequested(connectionId: connection.id, database: connection.database, service: service) + service.markAllSchemaTablesChanged([ + DatabaseTreeMetadataService.DatabaseKey(connectionId: connection.id, database: connection.database) + ]) + + demand.requestIfNeeded( + connectionId: connection.id, database: connection.database, isConnected: false, service: service + ) + + #expect(demand.needsRequest(connectionId: connection.id, database: connection.database, service: service)) + await disconnect(connection) + } + + @Test("Starting a new search asks again whatever was asked before") + func resetForgetsEarlierRequests() async { + let connection = await connectedListing() + var demand = AllSchemaTablesDemand() + demand.noteRequested(connectionId: connection.id, database: connection.database, service: service) + + demand.reset() + + #expect(demand.needsRequest(connectionId: connection.id, database: connection.database, service: service)) + await disconnect(connection) + } +} diff --git a/TableProTests/Utilities/QualifiedSearchQueryTests.swift b/TableProTests/Utilities/QualifiedSearchQueryTests.swift index 3db412a52b..225fb86218 100644 --- a/TableProTests/Utilities/QualifiedSearchQueryTests.swift +++ b/TableProTests/Utilities/QualifiedSearchQueryTests.swift @@ -95,11 +95,16 @@ struct QualifiedSearchQueryTests { #expect(query.containerPairs(with: ["attendance"]) == nil) } - @Test("A location drops a schema that only repeats the database") - func locationDropsRepeatedSchema() { - #expect(QualifiedSearchQuery.location(database: "shop", schema: "shop") == ["shop"]) + @Test("A location keeps a schema named like its database as a level of its own") + func locationKeepsBothLevels() throws { + #expect(QualifiedSearchQuery.location(database: "shop", schema: "shop") == ["shop", "shop"]) #expect(QualifiedSearchQuery.location(database: "shop", schema: "public") == ["shop", "public"]) #expect(QualifiedSearchQuery.location(database: nil, schema: "public") == ["public"]) #expect(QualifiedSearchQuery.location(database: "", schema: nil).isEmpty) + + let full = try #require(QualifiedSearchQuery("shop.shop.orders")) + let short = try #require(QualifiedSearchQuery("shop.orders")) + #expect(full.containerPairs(with: ["shop", "shop"]) != nil) + #expect(short.containerPairs(with: ["shop", "shop"]) != nil) } } diff --git a/TableProTests/ViewModels/QuickSwitcherCrossSchemaTests.swift b/TableProTests/ViewModels/QuickSwitcherCrossSchemaTests.swift index e7321f09f5..a690e34419 100644 --- a/TableProTests/ViewModels/QuickSwitcherCrossSchemaTests.swift +++ b/TableProTests/ViewModels/QuickSwitcherCrossSchemaTests.swift @@ -101,7 +101,8 @@ struct QuickSwitcherCrossSchemaTests { let allSchemas = [table("users", "public"), table("dropped", "public"), table("timesheet", "attendance")] let merged = QuickSwitcherViewModel.mergedTables( - local: local, loadedFrom: "shop", coveredSchemas: ["public"], allSchemas: allSchemas, browsing: "shop" + local: local, loadedFrom: "shop", coveredSchemas: ["public"], listing: allSchemas, browsing: "shop", + grouping: .bySchema ) #expect(merged.map(\.name) == ["users", "timesheet"]) @@ -114,7 +115,8 @@ struct QuickSwitcherCrossSchemaTests { let allSchemas = [table("users", "public"), table("timesheet", "attendance")] let merged = QuickSwitcherViewModel.mergedTables( - local: [], loadedFrom: "shop", coveredSchemas: ["public"], allSchemas: allSchemas, browsing: "shop" + local: [], loadedFrom: "shop", coveredSchemas: ["public"], listing: allSchemas, browsing: "shop", + grouping: .bySchema ) #expect(merged.map(\.name) == ["timesheet"]) @@ -125,7 +127,8 @@ struct QuickSwitcherCrossSchemaTests { let allSchemas = [table("timesheet", "attendance"), table("timesheet", "attendance")] let merged = QuickSwitcherViewModel.mergedTables( - local: [], loadedFrom: "shop", coveredSchemas: [], allSchemas: allSchemas, browsing: "shop" + local: [], loadedFrom: "shop", coveredSchemas: [], listing: allSchemas, browsing: "shop", + grouping: .bySchema ) #expect(merged.count == 1) @@ -139,13 +142,44 @@ struct QuickSwitcherCrossSchemaTests { local: [table("invoices", "public")], loadedFrom: "billing", coveredSchemas: ["public"], - allSchemas: [table("orders", "public"), table("timesheet", "attendance")], - browsing: "shop" + listing: [table("orders", "public"), table("timesheet", "attendance")], + browsing: "shop", + grouping: .bySchema ) #expect(merged.map(\.name) == ["orders", "timesheet"]) } + /// A hierarchical engine keys its per-schema lists by schema alone, so after a database switch + /// they can still hold the database the connection left while the listing names the new one. + @Test("On a hierarchical engine the listing answers for every schema once it has arrived") + func hierarchicalListingWins() { + let merged = QuickSwitcherViewModel.mergedTables( + local: [table("OLD_ORDERS", "PUBLIC")], + loadedFrom: "SALES", + coveredSchemas: ["PUBLIC"], + listing: [table("ORDERS", "PUBLIC")], + browsing: "SALES", + grouping: .hierarchicalSchema + ) + + #expect(merged.map(\.name) == ["ORDERS"]) + } + + @Test("On a hierarchical engine the schema service stands in until the listing arrives") + func hierarchicalBeforeListing() { + let merged = QuickSwitcherViewModel.mergedTables( + local: [table("ORDERS", "PUBLIC")], + loadedFrom: "SALES", + coveredSchemas: ["PUBLIC"], + listing: nil, + browsing: "SALES", + grouping: .hierarchicalSchema + ) + + #expect(merged.map(\.name) == ["ORDERS"]) + } + // MARK: - Qualified queries @Test("A schema-qualified query finds the table in that schema only") From 0770dbce592eac75c2751abf940613df5fd8c437 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Wed, 23 Sep 2026 13:07:37 +0700 Subject: [PATCH 4/5] fix(sidebar): open only matching sections while filtering, and list a schema alphabetically in Open Quickly --- CHANGELOG.md | 1 + .../ViewModels/QuickSwitcherViewModel.swift | 3 ++- .../Views/Sidebar/DatabaseTreeFilter.swift | 7 ++++++ ...baseTreeOutlineCoordinator+Expansion.swift | 6 ++++- ...DatabaseTreeOutlineCoordinator+Nodes.swift | 4 ++++ .../QuickSwitcherCrossSchemaTests.swift | 23 +++++++++++++++++++ ...tabaseTreeFilterQualifiedSearchTests.swift | 12 ++++++++++ 7 files changed, 54 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6d62bd3d3b..a2f50371a7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -74,6 +74,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Tables in an expanded Oracle or Snowflake schema missing from Open Quickly until the next refresh. - Schemas missing from Open Quickly on every reopen after one failed to load. - Unexpanded schemas hidden by the sidebar filter in the Tree layout. +- Empty object sections opened as "No items" under every match while filtering the sidebar tree. - **Drop View** offered in Recent for a sequence or materialized view opened from Open Quickly. - Unresponsive app and a dropped keystroke when typing in the row inspector's JSON field. (#3051) - Raw Oracle driver error in the schema switch failure dialog. (#3053) diff --git a/TablePro/ViewModels/QuickSwitcherViewModel.swift b/TablePro/ViewModels/QuickSwitcherViewModel.swift index 6ec786dd98..9b2c2e882b 100644 --- a/TablePro/ViewModels/QuickSwitcherViewModel.swift +++ b/TablePro/ViewModels/QuickSwitcherViewModel.swift @@ -1024,6 +1024,7 @@ internal final class QuickSwitcherViewModel: ObservableObject { frecencyScores: [String: Double] ) async -> [Group] { let qualified = QualifiedSearchQuery(query) + let prefersShorterNames = qualified.map { !$0.name.isEmpty } ?? true var ranked = items.compactMap { item -> (item: QuickSwitcherItem, rank: Double)? in guard let (matchScore, matchedIndices) = bestMatch(for: item, query: query, qualified: qualified) else { return nil @@ -1042,7 +1043,7 @@ internal final class QuickSwitcherViewModel: ObservableObject { if lhsOrder != rhsOrder { return lhsOrder < rhsOrder } let lhsLength = (lhs.item.name as NSString).length let rhsLength = (rhs.item.name as NSString).length - if lhsLength != rhsLength { return lhsLength < rhsLength } + if prefersShorterNames, lhsLength != rhsLength { return lhsLength < rhsLength } return lhs.item.name.localizedStandardCompare(rhs.item.name) == .orderedAscending } let items = Array(ranked.prefix(QuickSwitcherRanking.maxResults).map(\.item)) diff --git a/TablePro/Views/Sidebar/DatabaseTreeFilter.swift b/TablePro/Views/Sidebar/DatabaseTreeFilter.swift index 3e719a8122..686150f71e 100644 --- a/TablePro/Views/Sidebar/DatabaseTreeFilter.swift +++ b/TablePro/Views/Sidebar/DatabaseTreeFilter.swift @@ -208,6 +208,13 @@ enum DatabaseTreeFilter { return deduplicated(matched, by: { $0 }) } + /// While searching, a container's kind section opens only when it holds a match. Opening every + /// section put a "No items" row under each empty kind of each matching container, burying the + /// match it was opened for. Outside a search the user's own choice stands. + static func objectGroupIsExpanded(searching: Bool, matchCount: Int, stored: Bool) -> Bool { + searching ? matchCount > 0 : stored + } + /// What a search can say about one schema of a database-grouped tree. `unknown` is a schema /// whose objects neither the tree nor the all-schema listing can answer for yet, which stays on /// screen collapsed, for the reason `hierarchicalSchemaIsVisible` keeps an unloaded schema. diff --git a/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Expansion.swift b/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Expansion.swift index 9917236bd6..37edf3c2d7 100644 --- a/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Expansion.swift +++ b/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Expansion.swift @@ -124,7 +124,11 @@ extension DatabaseTreeOutlineCoordinator { let searching = !searchText.isEmpty for groupNode in resolvedChildren(of: parent) { guard case .containerObjectKindSection(let group) = groupNode.kind else { continue } - let expanded = searching || (windowState?.isTreeObjectGroupExpanded(group) ?? group.kind.isExpandedByDefault) + let expanded = DatabaseTreeFilter.objectGroupIsExpanded( + searching: searching, + matchCount: searching ? matchCount(in: group) : 0, + stored: windowState?.isTreeObjectGroupExpanded(group) ?? group.kind.isExpandedByDefault + ) setExpanded(groupNode, expanded) if outlineView.isItemExpanded(groupNode) { restorePartitionExpansion(under: groupNode) } } diff --git a/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Nodes.swift b/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Nodes.swift index 91bc4919a3..26faf593f1 100644 --- a/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Nodes.swift +++ b/TablePro/Views/Sidebar/DatabaseTreeOutlineCoordinator+Nodes.swift @@ -449,6 +449,10 @@ extension DatabaseTreeOutlineCoordinator { return buckets } + internal func matchCount(in group: DatabaseTreeObjectGroup) -> Int { + objectBuckets(database: group.database, schema: group.schema).itemCounts[group.kind] ?? 0 + } + /// Nil until the tree has loaded this schema's tables, so a search can tell a schema that holds /// no match from one nobody has listed yet. private func loadedObjectBuckets(database: String, schema: String?) -> DatabaseTreeObjectBuckets? { diff --git a/TableProTests/ViewModels/QuickSwitcherCrossSchemaTests.swift b/TableProTests/ViewModels/QuickSwitcherCrossSchemaTests.swift index a690e34419..606aea9cb3 100644 --- a/TableProTests/ViewModels/QuickSwitcherCrossSchemaTests.swift +++ b/TableProTests/ViewModels/QuickSwitcherCrossSchemaTests.swift @@ -201,6 +201,29 @@ struct QuickSwitcherCrossSchemaTests { #expect(Set(results.map(\.name)) == ["timesheet", "shift"]) } + /// A shorter name is a tighter match only when there is a name to match. `attendance.` names + /// none, so the schema's tables come back the way a list does. + @Test("A trailing dot lists the schema alphabetically") + func trailingDotIsAlphabetical() async { + let catalog = items([ + table("timesheet", "attendance"), table("leave_requests", "attendance"), + table("shifts", "attendance"), table("holidays", "attendance") + ]) + + let results = await search("attendance.", in: catalog) + + #expect(results.map(\.name) == ["holidays", "leave_requests", "shifts", "timesheet"]) + } + + @Test("A named table still ranks its shorter matches first") + func namedQueryKeepsShorterFirst() async { + let catalog = items([table("timesheet_archive", "attendance"), table("timesheet", "attendance")]) + + let results = await search("attendance.timesheet", in: catalog) + + #expect(results.map(\.name) == ["timesheet", "timesheet_archive"]) + } + @Test("Each part of a qualified query matches fuzzily") func fuzzyParts() async { let catalog = items([table("timesheet", "attendance"), table("orders", "sales")]) diff --git a/TableProTests/Views/Sidebar/DatabaseTreeFilterQualifiedSearchTests.swift b/TableProTests/Views/Sidebar/DatabaseTreeFilterQualifiedSearchTests.swift index 8d08273c25..dd58ac42ff 100644 --- a/TableProTests/Views/Sidebar/DatabaseTreeFilterQualifiedSearchTests.swift +++ b/TableProTests/Views/Sidebar/DatabaseTreeFilterQualifiedSearchTests.swift @@ -264,4 +264,16 @@ struct DatabaseTreeFilterQualifiedSearchTests { ) #expect(visible == ["attendance"]) } + + @Test("While searching, a kind section opens only when it holds a match") + func searchOpensOnlyMatchingSections() { + #expect(DatabaseTreeFilter.objectGroupIsExpanded(searching: true, matchCount: 1, stored: false)) + #expect(!DatabaseTreeFilter.objectGroupIsExpanded(searching: true, matchCount: 0, stored: true)) + } + + @Test("Outside a search a kind section keeps the user's choice") + func noSearchKeepsStoredExpansion() { + #expect(DatabaseTreeFilter.objectGroupIsExpanded(searching: false, matchCount: 0, stored: true)) + #expect(!DatabaseTreeFilter.objectGroupIsExpanded(searching: false, matchCount: 3, stored: false)) + } } From 18d0f4404764c08d7576cd67fea70cf1bc2f8a6c Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Wed, 23 Sep 2026 13:12:44 +0700 Subject: [PATCH 5/5] docs(sidebar): screenshots of other-schema results in Open Quickly and the sidebar filter --- docs/features/connection-window.mdx | 5 +++++ docs/features/open-quickly.mdx | 5 +++++ .../quick-switcher-other-schemas-dark.png | Bin 0 -> 71417 bytes docs/images/quick-switcher-other-schemas.png | Bin 0 -> 72487 bytes .../sidebar-filter-other-schemas-dark.png | Bin 0 -> 296571 bytes docs/images/sidebar-filter-other-schemas.png | Bin 0 -> 293623 bytes 6 files changed, 10 insertions(+) create mode 100644 docs/images/quick-switcher-other-schemas-dark.png create mode 100644 docs/images/quick-switcher-other-schemas.png create mode 100644 docs/images/sidebar-filter-other-schemas-dark.png create mode 100644 docs/images/sidebar-filter-other-schemas.png diff --git a/docs/features/connection-window.mdx b/docs/features/connection-window.mdx index 3ac94fcaa3..814c058979 100644 --- a/docs/features/connection-window.mdx +++ b/docs/features/connection-window.mdx @@ -97,6 +97,11 @@ The filter field matches any part of a name, so `sheet` finds `timesheet`. How f A schema whose tables have not been read yet stays in the tree, collapsed, until they arrive. + + Sidebar with timesheet in public at the top, and attendance and payroll below it, each opened to its timesheet table + Sidebar with timesheet in public at the top, and attendance and payroll below it, each opened to its timesheet table + + Type a dot to filter by schema. `attendance.time` keeps the objects in `attendance` whose names contain `time`, `attendance.` shows everything in `attendance`, and `shop.attendance.time` names the database too. A table whose own name holds a dot, such as `audit.events`, still matches when you type that name. [Open Quickly](/features/open-quickly#other-schemas) takes the same form with fuzzy matching. ## The trailing pane diff --git a/docs/features/open-quickly.mdx b/docs/features/open-quickly.mdx index 05807e514d..cd04a3e8b2 100644 --- a/docs/features/open-quickly.mdx +++ b/docs/features/open-quickly.mdx @@ -44,6 +44,11 @@ Opening a table or view opens a table tab, a database or schema switches the con A table outside the schema the sidebar is browsing shows its schema at the end of the row, `attendance` or `attendance ยท View`, and keeps it while selected. Opening it leaves the connection on the schema it was browsing. + + Open Quickly searching timesheet, with rows for public, attendance and payroll + Open Quickly searching timesheet, with rows for public, attendance and payroll + + Type a dot to search by where a table lives: | Search | Finds | diff --git a/docs/images/quick-switcher-other-schemas-dark.png b/docs/images/quick-switcher-other-schemas-dark.png new file mode 100644 index 0000000000000000000000000000000000000000..117a1ef05140b175cea7f62d35d47ab5b29eb19f GIT binary patch literal 71417 zcmcG$1yodPA2&KP4jlpt2uKJbD5-Q0E#2KpcZW2Hh)5{iNOyM|ba!{h(4BYVIq&

;zWB}=FRmeu8c0xj*wB7e}t{qHCd2L)3z=Jh?BUGbP-fxQ7 z>Qs?~fb-qzu8dY2Z^?bEa3`QLipI~%H&lO+DqNk{OjKND9K0V$&>p5FE)Bj;u~$jEE-U(suU9xISi)I)H7opQxeuU{ zE!=T7^1s)UP2%));r6BMugjYO0~F{`zsV2_l|u$61|H1m?*?k zf;ta&HM3BnhR~R%DP2(%d>tT$66EXLaAv1d679llw zp^$^xmX`Hc7!(>x{xof*PYKWLM(6d(7UW&0%WI&!(u~8^dV~e_H79JZ!f=KQ4@af#d!pN{BHk?lq&_lc)OtVO@6^#y1w98T9szas3i zR-qTX3;9a7i*U;6c9+CU=j%Ocug?NcQ_5sBs5w6bpb9l7L{>`8BUGo~Ju zHG4d24|Me-+K*zJm@0uO-l^wPE>jj$jN262sD%NQ-(2Tk??Ns`+@3aIdSZGK-9Y$+ zLn+s=AEJ0e=^sTEC0IxINmq$Icp{0t{2o!r=+%SgF;(8GBIab;yP4Rx8^Dh;sf&`aU7N2niC1oh$pYn<|7UNs8o(K;L zhZR<99Mr8y#6p7jCDJ4MYm67wP1SkTU*$i`C&_z&>1iBlgDisOIR&5ym0K5!+_vM#uwdq9XKt^bHIWqR$vw7=swO z7(0Y|L2DvUMUXyP5`1r|Xc23{ZDEtry~lO0p&cAH(;VH58Hf;=i+>XLS&|?_E#oM| z*YJbkwINZrdbf7mW^8Np4)YG{jiH{|CsUiTg-_{q>4nQ8osONA$}P$db5V0^NA%4Y zHXTMRMy$*w&7E11EVd`*&7&qPE8t~Urbbp&C1yoL<)h^xrL$JEGMNLuYZ~h+4;eAH zF*hIfu)Eoo*>%}-ub*ayWh;D8NEmFx@ujSz^p8U4Fykss$c;zRG^V$q=c_@lGOaGr z%GFA$Uazv5Hl5OD{P>{#5NxY$pAAV& z()8!fm`zQNxRyKl-)(8_HOiFXlSpXR8!l;ahr5rSI-Y&H6u9cRN<1UF2)vw(`X=EX zwXJ^64r72}^${XN)VymUNl*f4I?@%+M+{8V0%Q-8R|KC)2Z+T{vo3+`W(|@^E@jz2jNK&fn$BSMA*GP=ki59$; zV>&j~#L~+R)M4Cgnx2AiwRY|C`~CreA9DjQzG3RClu|9I?OiOka!B@Q_s|p&Ik7o~ zuXfSQ*T1xurWSi3W-mPz!5+I5s~F4NVzl3RX7$zygB?heqL*?wR2D-N8wmiX-#NNe^ozM}J+>S?SRPQHdq-eerjWbkoBn zaTT@3Cl@?4Cz^ESPxGfFrf6okWLI=XDrB5ygWYvH!a8=8s#KV_RVEt^ZkE8?-jhhv zn5>F9DtIa$*Pm_{ub%DXM4Dc03oB$Gtl?`SsFeEZ^&X0~fZM`yuMOWx!XelAxR8}8d%BaU zCsTTL7J_NJ1%Z{6DY0>&RoD*KDZ#vX&(y^Ia zG2fV8nAwGB$#hCx#9356v@AcNU*~a}JUaH{B5|UhHJGmVV3^ak(s7=>x*ogszL>h8 zxGPUu=MsHnz0rT(8r>=^qn{MctK_PF71wVSbjR_I5fTrg6*rpuvGIGR!;O=VvyJHZ z+*EuF?qAMQ9DkTDb!CmNaS6#1hh63T}s76=LWloe#o$i5BG+zgr1eWz1T- zXYOyexyGF&+~dC|!IlfglO ziuXKb2(nC=b^NegD4GoEwI?}|WZ64Dz3GgbeIn+nQM0n^;+r-HxmG%F4l>hn)O&qW`}BSf_!r$^T}u zwEJ^gzy=v^uP{8PXJq*A*ubsax8HKgnm8Mns|lG{05k*U;ALTc!Tt01zg_v?jDNXP z^?!Fhf5Fc9*IWN`>DOD8>%~8B)#2c3U@3lN$Y zm7C$eOyfnxwf>R|@bRIEkc=X51f=Zt1-=XXq5k7|d;ST-ogY^d1cHIYg!mPm!CMJP z$q$vr-}Oq>RD`x>MV3P5b4`XP)a(PCd`Nl4?}>nbaMc|AO67y1 z987#I0s8V$+KFRW+!Ei;V|?3+G|)7|;* z=~^eN?U8(qkjThLLydG2_w&Q`{&F*w{7uVDo><@oFBFZU*LpJs=hti=ty{2~sjIG* zsI=_X+A3Lr^YXyoT$Sm_T$O1n)E3kZ6dy=wRG6ETbgI46JZG&HUs34)p;+{ambUOi zM7=7n*o*!>37kfuDRs%*ycYo>1{R-nZCedD3)*`zmY?>pCeT?nKu_f3?lFxiL;0qE zn6P7dkT@pK4U36T9j#G-?)qj^wCZJdQ~@v*Jn&=&a#6%O8CZCmkyCWxu9o z9R9Vya$F+Qn4{iVuC(|VV^u9HPmW;Bp?Kf=;@!bSg|-PYETv2{R&MaELz_g((28#w%v0}nnKk{PF3mj@@tImZlcUQf zoj5`co%2_kYH&v`jmxTcCr6Q5Ghc=KG)P%C7ep**s_An+`fVtaJ&*E?wId&6)AM+P z=-`4!Ex)u;=l*%6ny$HyncVJa@xV%)Yviz7z#5!2cUxS5=(Dw~GONcf?KFMAJ`GM( zHEcgZT(n(I)WS> z>)l7phZXs13x=;ptR~8ys#@*j7f%!wO z&1R)=Sp7tWbSIdtc~pP`K}9cN*s?+EiYPSj!BS5Cg_y@6_4^#+T26KBp-Oix2i{?K zcVE=C2Q@~%mx}}sEiYQ9r%Y=aIHhYE5d184LUij-L>;o%-{8{f?kz4W70;P>leYR$ z7WTdCvEI($$DW!C+g{@}(jMumFHJZp5um3id&e7g7`iQt)bYzL)kmG<@n3)d&s*fdcNt(imH zQ%c13Mzz5Vaw{B`eCCrIIS;jny17r(JCk9}2<<#omPpEGe!T_Uc!9Z&j7L59oZ_ND zR!YPHTp9?1TC-cdvjr~jMwac7vus7i&JaqOb?sNc9kf_vj+Inn&uCl zIAAstQ-U&w^@;R+v#0``JLLu4E#t26>H1eNvt}@lhRF%Yu4Nqc6tSzP-EZWdFg@(N*GrGt&F@cj0flaoAvD0 zH?k`&Pheb@TZ=kqUGrjeU-H6>ZJ{|1Q~8rM!y{EvjV!V1-DcUtb=SttP5wGA%MmfT%K7S= z)#@!W+20XhT)O_lSB@^e#A%BbBLh|?4mo49*XL^eR>|f23T!i{=^+GRQLWL*&#*8? zaJ^pQV0nR{@>p}{aS*~04O7&PhJy z94A*#v;2jIrDtKjTImW^sZnntuTf8Y46!$(9UAQHgow>@%A=xl2Pto^GFOQcNh7dv zUd;W>0gAp446~&IMhyExa7$X?6B!7YD48CG9sI*HqpfItBImN#4L2hQvHFeXua>YnSs>nyTbo$#?ZmHKnB`f)shVMxKsZd07a7=NQ z)$H|w>+zP&B%li(7ncXUGBS~-dt(vzL9SAX+%6l*{J!*MTJEBSs>QF;td64m`XYs6 zn{A45|Hq8KOp=U^B81|!Y`Z%c&Y}yLxz#btuceWIss*)@dS3FzT~F8^^j+g(gDk$j z+pbTM1_?p(` zloOtoMWu84UO_{-vsP!sBF!_-Kyr^%%KDyX#t3(2JU=iDYIEmwKZ# zby~o{q~6E!g3;l$)fV7V>&COo)td56QaXS20^eDgIB6#3yVxqNR1Iw6kh57VpxKPD z1me8fk3?+S7ObUA`KN5A@QHHY1;ecc+&6o4Wi#;B|IGR;v&w~%L)TP{-HS_3Hipfz zaluBD?0iYjU$-Oy&VE z;hMKg@OL`?)SpCTArw!!P1NCRKo@C%P~lX((sJ74>>C=x<)eJ$XmL;(K}gB8$E==k zZD}6LLV;uSLW3Xb#)v42o7|?RTgHD?@$VC?(Lz(+HfA}@pR=;D6_(JSYFF4;6-|5J z=wj^Y<3>|I#sk59Ai6tuFxltwm0h?!+dosjh8sUdaK9D~02V5a z8w&rom6}6Sgn*S6%+S%%Ngx6Kc<}hg)wbYWoMG0R3^ z*ha4V;@skEf$A#8o+JN8+0uLOaV}FvI4~XU=gum)b|twU>@1Jq>?&6_3^7-L*bTd) z?>LPcM0J{1&hjYdsXl-9Y@YfPgQ?a~L!R$HSs*~(C~)56T&0WzNC7HkG`Yu-=(-%C z(r~(wTgdysUxgNIz1H_-aVwdWRI}C*K8eSm&CLr8`sM#+&_5O$aO;`1w}x{^liNx=}kJZJh>(7 z>dtrWKkWPOQXm@*Q{7eQ+T}C@SM?oFxNnz_YF~VlV5qmZnjhL~Xl9)N^R-nO?JF6``w;pqC8^Q87E)Mw4N6ik zHSETf;okc}inc5-3n~*tl_?wXjH1)3Ic!qORSvR8dE4BuTN3!w5Wu3F+OB$;YDql2 z)k>X%V_Z%s4af65{ZfnmK{a6Sy%^3-!WyS4t!6otTV4Cq!5;k^&b{v(G4Rk(y)NLD zv+G*5j#qi**KxOj4p|Aq@!5eKN+~A5JTIB#on0}*1&y2DLy{NNsysLAT-~Lfu8pLA zF8`o}AFy`)_}FICCGdk#FHbY1;u_A{C_*lun4Y`@_XU%e_?KT_)ZpG6mtNmE4g@#M zt@esic5vPfqz9?@mu5!tm|L0JU zO42CNZ?~IQBu9XqU7MMhRF4H;ay6^puyB0smHHm=lPJme!O$l8w_}*U*^c)zO#z;< z>NHJsjzV*yqxl*q<8c6E@q`m1TI?}2BEq3fzIS;~>oAB|-F}?kOnwhh&3Az|ntr0vK~{_eL39mVJ`?^* z(;-Z6b!=!pY18VP!?nHdNF>g4rb*I?AY&3Y#=i17?ov1|ai{2r4m@E% zwnqoZ89XmZ|EtxM)q)J)zXR7LJIKeK6Le&rlhGLUV0sw94YuAID;Ax28O5MkwF{cO zs*DR9l2drw7)&n3i?!wqLG~i*V%7?#~yxb-Z%!<420As9-(V{eCwpiR@_^1zF38fHK7G9hq?1z}?r;(AGAVyQO&svjt3bJe{H|_MDnzP1$(Noyu4gz zWUUkTM&FOcbcnhX$Wk6mHdY(kuvtv#YkOWfycUH$uUHUX99eAXb>FsIiMQ)%r#S~Y z{KR&{N-E3wufK2u3|Zb21kr|&y8i0IU|09nkg@v+Tl354uSqfK23%j16v z^y_@iQ(P{^U9j3Bt;!`4yLEC5w~MXVJdkPfdjJlptF)I_qjZ|Jc}2?VO<1vegM~K=C&N zvd{S%mGoFAkCU^_ij=s696XF`942`)0`gza)!xcnHM6Nf%ZDQV@yq?TZ#$KZSNV<4 ztgff*dRg$bo%LpF0M9aXxgXVd%QY83VbKl(2Q9II!)vr(^^BRso7N9@k$7DubyFL{ zb37&^Jc8n-1z5@BVS~=d1jFVstrD0v%AQqM^mD_)`r{5RU*dVP@IC-fY0x)Y&fE`>w4Y_jkBy?#(f5LyTgi3bL;}* zU(PWJncMPo8cF60v65emQh@LfA7oCGgYZ^b@qRUG#+ned_g>1I8dZzIT-T%T0L!&g z4g-~an47srC0#dw`U+{>vbb4v=%q9Fvq#t2TsxmcNeDjf=5Dcc+y;6vMUOR7&C=$w z6*5=cws=ma?7q&CW#e?}W&$fg9RIA3ek(?gn*UXd;$Z2*Ftf{wiJBi5g>a4wlgY)C zb{GiAaF@!kDMZ|cgVA3M2S*d-2F;NWg5WYat!jD8_G&UHg4@1dttxUcd^nP zcXGyIw=zZa-W^bC_F|`<86C|!=e>rAA6h72Szo8N%7hGv-UU4o#<`rOtctD~D#7Ce zASjQ<*KsSJdaSU+XF8M>ZzZTk?QylK(<>oy$E!`}3mW0tQbFyuZ6JS?;p&YH4W;Rf z#|8ZBkg)v89N;&`=m^hb?n@w;;h9SFo-OHGMM<*8K!S zgfx=z$<4?8+^nyv88S(hmJMfyskTorIO%bWnuYE(WMO32o|qNZ8v+rX-a*ryyN{(_ z6diK|8Vc!@31}32hmJBfc1)7yelqP82NWe|V%WVvx$<@MxRZ|Q&Tk|&)`tN3 zX>ELLdn%($8FW*fi3>44pvajZNg)s8C=oJM>Mc`6Fj}kJD{ei{oamGu{9HG!Y z#~;|DP%*U!Ea?V!R8e=pfcZAfG672`XR?KuRV%GsxwT$DV__CW4NRJBTsnqt(*7P`AUI8@4 zA$LMbLqnq*FjmAGMO@dXi`_1(2}Z|&fpIiBquJUWUP0nJiE z>`mlJO<5WV820BqeDqr8!&J?#6XA?XrzgPopy2WejrdT6dr?-D z1JV2>V_#7>p5VWMM|_oVsbK@?Rq%8n=@*fT2M+5-9~GH8nn}e zPk-sF6m*&x#{tJckm_z|Dfm}UK^96O`xM(6D0(wYkTmjD6dV?yLt&FV`$QFSt6UcN zJ04gSctgAjbU5 z0Awz1<}jn_X7>DO^G>5z;1v1Oj1pa*><%ltg_u`}zm0!kARbz!WO%2O zl`k{SvgT>;2kC~R>%9=qrIfUFNc`k@Pn%Pc8*0aF5|sbUFN}J0YHCZ=jE$kuWnb#_ z$32;7o5hwGAb9S3=rAM)UuY-&Lc9EJ{_Qhpk7^^n%Y-4abjLPte&&+-5q&=oR}e21O^ zdnFB@4K90qJofso-H4izuwx-FVE4N%DyLU=NV))96rjQhPlG#lM?T7Mxb&;$T)e~R z??dpb>+yn-c#9)@RX8n~ac#3-Zr5(ttj0f~VF#Kaz2%O(?*#MO4C@aw??&L=DB=X* ziK~!DAev?A_j%z(&B;MIgjp=n;VG@DpDpt+;pmhN{)n6y2bGd*Yl!tsJD+y9e z+?RTQNr*1Asl{bCnJUyz8>1gnv2j0h`UPqc*ZDsrqvB&z%2e=ZW8vFIn8u|3YIKl~}q84qR#Uf2|w`?Zp zAjvPWf3FqpA&1j|CK3}m-`yqkxcPpU@3Q#GB&oBE8T`n?49w~P#C{s0Ki;bZ*Qu(# z_v|2(AoT*`5Ok4mO1#5|;H*on_Y`SWRhF^Jpm5pM5cI79yTQmvyo0UM-kRnqMXk3{ zv}&Ix4CJ(Kw!yhohaMOusIaUQP{#+*o85Za#T5G z8+g_x%Da#fT?9H^2xN!_A|d)p9#fI&D1-S`pBk3URex$UScL0DnF*X0@9K(~A@Ez# zEZ-UR&^5h&`{T|srR&=euaDT|_qv<6GqeL6?0UFX+)+ba+q*%8&x}FvLcas>y2lta zAQDseq@#~f?iZ?RC|=jpO%ZtO@l{z9SrQqS=*nETyf%=e0VTR0k9*HHTEDq2q1|Lw z{eT9P=q*>7dM)e}&XmFt5=eWv4$qJkSAW$dz%ow-tx zYgU}MuGvRMl9}KbtAU;orTxYvO{b~uB_&=86n1w1q(yIGR_f_G2Opx3{>l|Suq3T;>Gkk^yVcQUPwU%Oe%1TSr4qvG?Bxnu^i3$%xVe{jD#f9<#DV; zzxMg$r8E!3@oZFwkLj~2eQSy*YLLtlUAH-yUbmoInH?D}B0rrUNXG^(`&t5t`Fz?0 zoj(FB$Ts&Y`v*Vp9mMEX5?5M=4-6pFw|Z)qXJ1kKL<~OMW9GDR-o+}%c0z|^jq+FO z2K^wyWwn^Nj~spjSmPj%3I;b?enxRn_}D2BK8PBGRnm*!KSF5wX@+w3;{ngSX8iou zv=)r~gDO-RRQ4L%ytp26!vnN@B;rJZ2p!6Z)8-@`u|fqGjS@(iB*3y9XAS2|uG`*7 zB-HD6bd7J%Byip>9Y}pu=gFu*?vyEiA#uw=>7yqgk6m9OR{Mp;IFj~ z*s43|5qXu4I7f|}x6|2#Ba?b<$`~r}2w1Qc|JegtTz#AKr7)Ql;e-DyS@!?DWJS!1 z)g8~Rxhx&il4;M7$`!9Db+jhI1*3W%!;ys~+l`s}+J5Sil1urbj6jjp;|vr+ApwdX z&!qg+39d$mDT6~77HUlDQM_)$x{o5;`TDzb=vp-tA|Dx(&bo}cP^jXuR6}cynlo@f zl+nUxzFqR5u3N*#75US!rT(`Y@xS0V^dn3iyH6c7W96#lk!~_oWkWTw9iCK)rXjWP zdD)6n0HpXS?uLm+ney37Ap-RQr53 z@UHugYf^vmLytZ(+U2)}9!I%`BYA3{#16NoC*z$L0z`Z**G{8QH*nklFC62rIkGI= z{hx)x{*Ma<_idQmEl@39$dy`b4dEMil&Nb&^+I~w`NnK37zY#)SFX%VSoIA7;a)`$K9_8MPH(Nw z4&RXjrU#*9nrs#&_RkDm6yP(?EOXU+Qfa=cLtPlArr=1#@=QOOnFK}nR%cp ztCBn^e}@~4C<%%j@x#x2jgR@i&2_~v1&IVi=+67AV}k+Z_o!yk0f_Z>oGQ_oypXW* zw3(p`zhT#}&Vjhv`a1?&w8>z`vOzUq2A0ks{}nskf9GaAj1areRCh2Rt!{_;wjSg;R335%E1Oav#d*q86GlAzq4zReaAt}d*K{Amb@rnn1-pLzt89MQ zeN3(`M!SAt{N;+L(1G?`g zA0>K>-7nis%46sr0IK1d9zhruAU2pOQy44Ll*r?X=z($dEwUsyR}?J!Y8F>Tb6#ao zHB8ZNK#VGefXQ$v{{;VubiDCxV11g~1r#)`W&n4Av>D8MZcK6G?okCqjNK6`+Utd; zY&SqCIq}eK_p8e$9K_*r=Z8KW$go)`qT|K?c_W12zT*`4u5Bl!Fx(JcU89~-Jo&KC zhB`D5-2vO$(|xoD1}Lf)*t`9rq%0dNTLNZgW{kScKqR-VyezdT2O83S2y|jJ7#Ra~ z2r$<6`$IgKA4E6n6ux#i9yf}U@jM^&ZrijPq^@+Db$2QfC*K8%G3!>CD=ZtkfTf_h z$E&6oj7DG8)RxnCml%FW*2Sp#@n#uurTlHA^6AxWxApJB{Zg7N&*X=g9+0QWs9tSv zWIR>KaBFk?bY)F}>IG4fgbuAWnas6tfSMOB=kIzl9#<_1k5}2GRxd|td=!GIb(q}O zQmJ@zAEd+))N;|vcm2FD(Q+Q3;&UK=Rg@hqe%%_2a_-<2tE=SIXNL*#M#WmK znufxde%p5`h=~( zEWv9zDw5ETi(x(K3fb$Ev)9L;wUk>!NUa{DJ{!sfWtDU~%^E~$WsLur2Z{wOJ8wp7 zKN9zFTIr~PJB${tFERD$Att>i8n{GQ-6Ltu|o0cU*?ix_Y= z*2-(hd)6)^V#!dp573q6Hds2KMb(vcQ|BjaAbK* zCN}SG9om*Ife}j$hb5SSV;lHskk|bjI_-27wBy{$^|59X z4|U(g`FuSSX~gQg|6PXrbh}5HV4kH^25Bs$v(r)mr>|?TzHB#aDCd7lLG$ZR6^(P< zuBNg&nD-~OH0(`GsH8XjqEe_0@3`!7YA9XHYE^qKcUB_)bBiBM3I3sf`-1`qfXso` z)t7el7%gLjP$mnuj)1+ANs?S9HBgPZSd(nj#1}#TSm8iCgp>$k`f-bb4#ij9w*hV5 z#A8Hy?Yc4UtHVL1rxGJEIl=qwl|bVZfiJ*rbF`3cABEj%d#X;(B`jQc+6TyxWtg0I z=X5K9<|`4`zQde?oK`@t`^UgxN}4AfOr2%l;f`u%d`zeBcb0R+@#h|*8vdR>QKF<_ zgYrrC^H_$?UBZZ=^RLXVPPTy_yV3m{@y|~nP_ociP%0=>q&4^#VFOy9UNCuVSx7R_ z!OP7M#N=2C1iEW(QMe$g$9e&v=(l(_KpO}OoA|xUoy-k+3T;}wINChXK=INkhRkIv zgQj@Iu(3d4edP2|GB40eqQA@b?b5?V$^1a4KDZ#yS^Kpw{@Qx(UlPpS^MhpMq0pws zW$)3z$Yh`a#NT(hjQ#Q%Nd3l>L7nu<)07jaU^bKkz_la)%d#_zc#%4}=UyY|1%;uIvF}{cxHA;A1 zqd?#Mbv~%dY>#%ok{q;hpo;>*0{Vx4Y3ee*XTMpm?E;#*o_h&nznfz(STGC~ylY?v zKJCr8&68{V(C|s>9pMvNw%N_m{GgBE0BQhyK;r%BBFV^+=W-Az%2pe$Oh-i2OT&tP~I&p@n4oIg$-QK{?4!WyCnXx zLN%a=5wR?0`kPAq;Y72Z0@qm_*s1@iZ+?5vGYOy%RKhKW@v8^;b3ztj;CcoolArg# ztk3|345S=MmHoR9`8h&z267r6C==*th208CF@QYQ3LDDG&VDLpzwmnu`{%3%Sb+P% zBx2o4d;)EHkyT3bTP*&Eo8o*A&=<-33DLjt#}~NHk`+eve|l)j1}oQu{{DsA|=-U3zzz^0e$B3dExR)eECxs0fk8x2d?Kr6V3nc@0UmO z@&_6~4rq9^>>v1HIrd9!c>hA0=RZw4P-|2Hh=N`t^lus#ajRixpirKF5#o}^UO?)q zH2|Pb{)zFh|F8EKm_fR`yEA|=1!&>%W&kV`=>)LPjKIStcRhfdmSwuefk~^z{(0=E z%)z;dyMls(Wxd7-C*axt&Kbp!ri|{mt`(^`ppz9hUS<;Zi81A@JB|&BFCWdr(PglL z9l-4}pIeL-eJ!h~Amk#;QLA+X0KSG&MVj>!p-j*P!0df&4Ny%8_u>LG6Eho!60lqA z?rx4YHm=VW>X2QUXnaX38p}TqL#t*M+_b}v{*`#%6J)v;%&}X1e%!u6eQzuR&-1Oc ztdwbW^pp!UO(Gd|Eb$oB%p(~z5+!IDx+k)pryI*cq;ubET-`bb0t9w?x`km{FxA>P zqJ`s>jp%Ela-cT)Qn!B9^T_5Pb|X-BD)jKjhdBDZUp5a*-iLlhb||2V-UP3lAP&~f zr3eRh0j2XUAb}!LMdh3?+E0HXd|TjB%mjAX8yU^=5{9AuD)DWjT&hS6&{&QJ!Z4(j z=@+Y!ZJ8#Y13fX6!^nR%uP`K>zS@i_VX=opiYapd`lRdf?4UcI!_H^>8xFe5=vI@j zfbuQ;;J~`5F9zl1X&9+L5SAh>=y*rA_?ePjQR{XutGd)KPs@HcnSJr*5{&t88PV>h9F=R zhN~?v5}?Aw=8JR}Gw+J|RTx?gRxP#%iw^b6I_Wpx?u!Q=1xdi*{Xq|(=*9kBz=!U7 zKi=`XzDS*t6+_o7(GPH0PmhA+Hoe+OIud;Qc?1pI$kXza38MQ@{6{tcq@-eCtpVre z{1{GTe=^L8pmy2*Om-ou=KLHip_GJppoSHCN=2jSew7+%jrUgU-e2tnu_#$^RSJpG zo11W}CZKxRPpehKyyiDzlm0kUM(kbJrl2c?{{VQ(|RlK^k_+ zbNL8TfI`d!_s!+OZS~~6SGnsNr&9Z+g~vyG4adq8-=MMsAst3$rag_>o^dUzj;5H`#oyPvNbKmNG}|4 z63|W1eYOdMKuaFW=4ib;m@x!9Q$cj2(K}fLVXr>WXSr?_`xl!!^mWTedY14;>>4SV zBc^7@qzdyt1Z#cF7j__n);Iw9wzn}Pj7kQR_10bWW2>ThON;9QSuC3AF#tcbA0U*c zLl(L>S3}zESAHY`>%H#5uZOFd0Oj!NCS6MNH2FrBw59TwK%}sO?-z&i>iV-30C_oN?h|S2sdTh)Hx!A6?l3fIP3T&#~ z*_NsI#*C8OAy5G1qnetUe2pOjJpABGysMsXsc_-L67xO+p1M5p7U2OE#MEBb0ZG}4 zWh!IY`niH0Wd2y?nF}pQ0{fM#5=vI?PLbaCE^Sx1!IW|Cvrzgpy*-AFZ-npN-@7XD zybDUKrtiQ3uVYTF(RrWaQ+VMjKIb&w?1CC!B%H0uSH1#Hn%9c*Gmuqz7{%|?KB;Tt ztAE=B;1oJ&HLDoc2sITPQWz87!HOLpD7ABg`(krQn#suIqE%HeAU&N7$V|cHsf7yIMf+?s>i3gg&YPvFtI3Q zQF$*JZe{dU^9WgpAT<1$)YOR-+l$?MGThjY368eapD|PjCg1l?<7}zmhi#*}fyhCT z-#U+jA1CwQ7YQM-XbB=VVn%*16b=+zp}t-(p@(-OJ$Nxz%szSj;Nw7;sdKTT!wY%A zpPU0socGM*MIkwO!UK0c%s~mI?>P5EQWp(>vX?=!gt|`>A~@!`-Mg5hjl3rJh{=}w zkO*?wNRV;20)Si}YI*Whl5m(??EHs?BxGZordX!IW@uUklI(+c+1HEkmQU2jga@lH znd}^BB6_<)>X3mXD%%FR@0e&+RbkK#Qg-D=LOcB2n_M6n3abWxPEsKNXK65kArX&( zSfy;DLvr(#MJ@svM3?d|f=PrRY{Zj7G?*Dck)XNVRHGRJ$WVwL)_mc^nk@}Fh-oX3 z3!_iimv_J#u(E`K=|&dhzDN@DdsWP0hqtHV0lPEX%aY9~K^8*xeqsD+jSXn%Fd6kc z%mZ~ox_aaQCy<&|R8WBY@^SwhsX~S%irY;)p)9}04fDR$fQYtAL}pP!qSp@#;6L;L zfzc$&E_qb~f?bd>Fo9}o+=L|+Y;qQ0WREb}lpui0xpg+FA-sg>h~#piAa9^lloO;2 zR(-mkrtloHA2CvCrNiX1ztpsIiv*Be8=VDkw>Dq%9<1S@WN#iJ@$PziUD@^W7+nK! zhn3@KRtxn$9u55X+v*GO^cQ($P|O0f2twOK6_^jyn)5i;l6`#&@c96=O&9Q_0*-;g z_I1Duv%a=EWJAxnW!}ZGq)UC>05bn2&$CXQlHTx#;yA`{D`qogNSWMDt(gETm5kpC zIAI^T=LXn1g?g>TPRzI66`wcL_JdL@g`QVt^~&j{%iC=ge9pVNuWRdK_BP1oilOWf$fUtbW$)2%}B4H2Z!XR^*iniw)c1Bxo@#m2eq?T1&U>k zlR&#aBo<%>r|Jz*#hR$w@1TJ%+}DuXzHS~coK%JopOLG6JX2E9!gcfd@FDfU5qQkO z5KxsB0Mf_O%X?w2SQe{AwYLn^L~UdnfXH>s4L}JMj+d~?e>F{q1KLVzE5knjcFtFC zj9lc52Pi15?0DYPx&TF!k~ZE!=9^W|>(+R;{dRtmbL*?blRBgm5|jX=>Eq#*+YE8E#IA^D9DS;P=7d}IrC=s8o-7o z0j+g1(7OOdOEupK=A7ZQh6WwatD|h)8344y0j3axETcLDj|ZmZ1rf4s;(x8uJR*N^ z(s_AX-UTYbCM!J&L~LiOdxu{{MsREiJ%HXp^8}UjV`vk5I47@ke%Y1yh~~FW0D)>E z&AFbY+Wr$LSMClJaf%m41s(^8?*Kh9-;}lQO&qK7zJalCk)Cu`6w*hLUW~Ouz(tD1 z+RpO`2i;a4Og1}S^6RVv$6{emVgTeTS5`@0CjfWduG?TcJS&lchT|slUf;sPzj{U5 z-{~^evF;3u(2b3-vmo_6AYeQcZnqJFdhY`z^nF*RjA98fakX zB?8>noU%32Pp2xDo+sXM7Ht+nfHv8NNU~mxicc2m!>y z5bGk;BQtYmpw%>Zp484d1hVi&#N7`de8XG6n&{dU$k3pAU{FvFF&sZOfbYD?$(q5@ zzCJ4Sj5#}4MdHzWA{njg2s{n*5T_ckzcmVofL2GI-%Dze6D2n20T9-@NJm3`^+R_t zJR4N8Wi9g#FUio{&MHp|J$Y$XfVdN83hp~UJnsi0^WciRrLV*EH~5gL#zU&G-jgRs zJyk=77q^m#EF`g9Gu4=6O_Dw00lOQV-->gA*(5+I*HnfbIWU;UjR2uBt1Y+0ntJ+_t0U;f$t2*E0uxYP|>(x)G2{e4Mr2x)A* zjLw!=)ByT@Q>FoD`}rzQJq?k)ILa`d|393)by$?^`o}wTDJ7va(yb^UAl)D(-3Zbh z1Jb1;AYCFgfOIzuFo4oXmkiwv62s7(m$l=!_g-sV=UnGsE@s~Msr$L(`?*Jh!=d$c z#a(vxc#S7OkR_q@=3-|(!sN6pMzbid|k@H0eafaU`Bmi%}<6|5;z+oNCCJPFR zdcf4i!O8^N|C)=Z6wadkjHnRU*S_GlCz~Vf$-dxx?WUv&i0I?@Qo3y#&473K6~NIR zw!Gh#cr{6>$iV&{8GS@w5dB7IXnexhrs&lX;_+=tRUH?}_?+gN+O>s(nOFw~LJc|U zy^XI^;O{bJ1)N=h0P^w#(B^VFP|9CV&`@!SSg)ILe0FCMUHcuG6%71-P|g#&i`|@c zi#Y=FHgZN6pooa2QM<#M8FFEocbao7p&fo?lj~99L4prxnV^Fl3qbURPKHwz73=h? z;J8PXM*()@&mIDY_RYfK6bU*T8ihe#Z@n6)jD0XvuE1qBgkga1#Qx=CD|BOL>8dEP zj@B~SV@QohPjhw}`tpp~Y^^S^x!!0DsZ`CL|De4g#7?t~zi2D6^BWh;KVlx3nRvR_ zxO`e3YNPF7QuZhfoVnjwg*omg%1-6A8Y`jm#$k-Lw90tG1sPH%2vsRE+7vDIXmMWp zZYqvdJ5WIACnUPPapqK0wAOP@N7JM-^{M&C5jTY| zkxk?Uc)!C~G9JF=u`|{)U~kxIx?1QIG;voQtxgyed#W+7m^0jHgriOEl}Tt|M4-je zvOr9yhI5yfgve89F+eD5xv!vE4UkZ=IdtqT9N$eTTHZVFI3^JDcvwdj>8xo@NPymU z(!8=;7|L4f`CS{;1w&j9tG|2*xI%{U)6uJo%V9#u#jVF@s2RrhPGX9%4xQft!pq>~ zk>6-#tpVe7kA;%QOZEI`zDw}nR9TMyFn$5Zu0+=XDmA*sc`~F9`a@yZ=6%dWgz0M! z;LCF_W21c;H?$>|L#}AgvmN5+ zcT~u758wOuQexJ$_dgO_ge5YYzbr_1>#zf8_Ych$?;A!kZz1ulVSPTpgw@W%UU zhB)PS;!h=ZCw-m`9pDCe`HqeJWH)bR3I3KULKNrzom!3V8=C>nqRNxz^{;lpK-KJi z=_w8As)qJCSruG)%>U$#W^i=yd%ts}8+a57xE5SzYNeN9!G;=VXt@|1dzsI@lHJN0 ze0MCq%FHA?uZnhU=AJ2;T)d`RCNq1CqJtK1vnYWcR&q!jlMr5xTa9o_mk3VNbzRlWi zGCRaVI(uDe9FC|`MWpixwax=*Mk-JVEt{(~-r9PkhBI z4k5mClO$rF7s-ligD5~9x9pGU6-}bBx3GKa;ee!S4-yeVlg*?_1&F8H(Mn$5l~y0i zY0H3Kbqnts6XPoCwR9*KKkJBK0DWvql9@0NkZ5^cWYn~X_s)AUiT1msL{u@8|5^Kj z7$<1EQ)BSQbu`%x?CaEz44MKyu!Q6%W9+MB#rgqdL`7*cWjl*H8BcJOd7KR~irU`h zoho_%;kL}!IqEC8HX>HZi`##pq5>fLhtWtzax&7%ane9wN+;(JVimA>nx zL87UNX-FI!mN0W9&`AKX@K_zKiDpb^=FVdZlD?ZT22fsaQ<__6VrfR6Ud^?6w8&%{ z5R{@|g2kppYBYyyN9KN5^lpg`0@-oS--qlR4Q3L1&v#Y2our6ye=KJzsSa^&m+cxf zBvqG>DvzDkWWE5z+U8kc^`+>5D|6?Au{zJz%ekO(c)>e;Wa`2d^I3z2B8ZcTk)2Bq zJ0j5utcPE0JIA8w-v}M?Ap>F-pn|506aGz|57pZ=K@fIZ!Svu%l1E01!4EBow!XDYHFwCTkpm^rvVote4^J)LiH9pl zrU6NA@XkkR@(+OAk8RU~jPsWmEHEGJ{cs9z9T+v)S?9~u7^$B`a#UH$5-~Ep0|E=X zWXGpS3~`a+oroG5ds4;*);S>AgK5-x$0k7Ra_b74w{i266);TXW8HjPPKqvLp@Uof zE!DEtB$?8B&DfZb2R90jLF_hRo%^~*K6|z607+mKWB#?SD47Q*sH)F{$8>+~PUzXV z^8x+|o*rDr;M!1DS3+R%N7zIHO;!fe`vbbxkOrWlTv8G6oT9lzknyBfUxw_1_mG+e1bn;IujU!!-cJssVP5 z+Bwt9&73&sRB`$?jmE2C`BYE18x#JD{^xj^86-xb>lMzW`s0iwOXigP^GOIH;~}| zLUJOScT_ZMUeb>#!m@Rf4Y^R8YT`?+t)3+RZV$?~PXJ<@*dYM5P`Q$n>z^`L@I)3OTmu?$1WZ z-KF?2PL?)_F$_=VU8=I|dbP-?&ibmS6Q?^%ea5ug{g>+zpQ-<-r zKn>2x61-!yr%1pXvEW=7v#^-u8r3LH4sr%sX}zFEN;h4iHd= zjoQX9)v@3avd|S>Z_B)*cYwiISD)b$*9OcZ$~-Yd1#3B#BsLx>CGG6bGiBPfUQCqF za<`w9R1fm9q`SXy_A%P^qCMU1*_HZvgVPn=K0i)l}m4-W7G{RJp-;$S9J$uM+W&x|c9 z4FNe3`F>&@GE7{tYSF-x+F2y+#;H?+4Pg0geld}PELxZ&9$@GxU7h5MMJ76A)fJ^H z;RNRL{sN@qZb>?@FT`XZKNCCuuT_SLfn_nP7*I7BtRaV7F)X|)kB#iamAPHD1;sr* zpydVK8yJRpW8usjaH3p8}|s|3wS3O$2NLe$D&y)k)VfEqBokK#LvzPG^-|E zJ(+Vr$=MyJ_zV!NYy1P$SQm(}(9 z?q8xTu_|-^2vi_(v>+}Yzo3RgSf&&SBW&_uLs2Ej$0fEloJ!bZb4-tC@ZP8ankqn# z*v~HeL-RQENme7e?w941g~6g*>4L9wuq>w>WC=knj{+{^=UGDonK%g*Fbef3fV|C8m8t{Q;_XIVEh!D)( z1J|5#Psf6K*wx5j;E=2Q*8Vyu2!l=wy%GAfc|C$XT_*fBO0I#@YSh=FbHkvkK$Id- zS~40sX2bZi0uT4r8?y7QTJj|P(a)l$)G`!Y?{g1Yt?jKp;skNdH z#Ovy+{eYKHexS)1n@UukcQ_?2Yum~GdR zu|opTqe*G0f!|70#8ytItR~!UuTO{8mc&9ufCPK&h99@X%8Pw zmq~*-r9UFH=!fY;0(C{oGh|vCuw;2`ps{_S*}<|52n^BE_ycx7KaCis55DNoK+vZA z+h-PpF}`ItA$IgAYN(+lNhhO_QzK3iVvvO%@&5k)s5&`SB!3aa@o>y(F23+WT~5%*%dyy`OrU(uW+G**c!Hpk%>&!_2Ay0y&RiT}+=3Sue)7y#xT#Uvk! zL~VKpg9(@my7>L1-2EithY=qnQ6bU-EsL@kIJRQd+J(4Krv?e?nlxsUz5HWEGAi|r z()~-Jsgu!y{cBt&-xbQ^qx;%PXADY&VH>yzcmD~+8J-}4Nz1T@gZVi;tBLS)KwFL{ zdc&S^>zb(z;;g?u%MKQOcM*c$03{)Q-Zvn;)wtZJ5j_T2W<%Saa6O4R*L3;Rgy<`^ zZ9!cL?fJo6`4`lP5*HZgdL!b6L(jo$19=eV_)YdHSN>ja-^hKB*Cnu}i>9?2RLHDo zqlCe#)H$GRZB*iQD!MGW{Ia&t+P7r5Et++yKsNN|9%`JYwO#=rqiVwyXAIjW8tyTm zm>$+UEMSC+3&*m9dnu$(j?eGnLg&T(at?kTJC=oQT$GB3rAPI>+oO@sb^L7+nUZWM zYDq;DY@>p!+L27zeM0h+ue>2~ki9bM59s24Hc4(51&ggfWIqPJWM>5Rv1=#k;FiNK zY~R+CiqYy3zSua`FBjUvkTB1yfnh8|jYmb7@JCQqe_g!Uui$4VG_Q$nq3;RgSR$X@%d*e4$-2pp9| zy@VqmuP?WSSR|AsXc^X;UelL?bR93l7}$Xa^$!>zR9wqg{aZc)%Z0AFp{lCwSp`#i z;4U)aqBh)(w~_ihEy?$?k!aelzww0wt73=7g$)u|sI8oQ9~k>v1Vvd>YZ`zC5g0Yv zs}EzR;lS^iE8q5wC~B1?as;7{ zIDnjWyZGw^T??YeV$8SzNTSBCA(*J`!(z{*1|SaNdF4B}+srxbsEl>;yUy(gRT}c3 zgz`s%XB$<*hf~grzYc)_}l$s$<%#oKfytmBG@9YbDe$e@DWPcZ%gmYeV*Q z@41Z52vZ6&1$6NRxWYy?G(h1OPkw39&s=ozu(uRkni6E(N5G^$_}!#QN(|CcNfet! zXxkJSG*xRRYMtHQ9NgN1=>~Iq1%3&h$nl778?%s;3L%Y#@iL%6g?82bQvuU%hjA)) z=Xb_4Gr>mF7d(|{oev==4r3tpFp3f1yn3fVmmnr@gmj-xk10dxn_Wax0gZ!=MMuB$ z2*TwyO7gtBT;@*u9mHIufwOMf=q0S}sK0IKa=7gR#LhaNhTwiJHJ_1|Mm3~S_bUgb zDP@eXA=_%((4)jsh*h+t2v*u!8oZ!{Af41LjbGCSr6R2^--;Prt>rwmWJdN_?IW=E;{F511H;*~7z(uu!Ppg0ru z`-8~bQB88w%Sz-Rpm%y*@N1q3{jC`f9*y6YOQfFm(_E;aOj2o3r`UPLC^?6fI^zNj zF-lG_%@+cpO^9iH+OH-e;Lzk)YdNNKdf1sqcxTVesm)cDL6V+xGqckO$UQ5?nz_Xi5WbgZK0kv`H-ovsNLycJ1W;vZ*8@Be;CT5;Qsky zlRhAITfc-Z(?uxx#6=G=eqM6Xzx>qJM1+UcA)R)AMXM#}{E+2T&vQB56c~HuZ~E^6ZK@qb&qkY2n-c#fzRwNF+k6 zu7Eu7$c0{ovZw~6t1=@D(5tSfP|O3D?6l(OyrbBw)B0ACcOM(i*He%8X@PLVfmrrh zZP#}MVhv^9Tq!F-`LWTsox8!mp*r2_nY)&@E;>?ISZYtC296~#oU5M`{yG%q1ytr2 z=XI9%BR~(6Ne+eH2O1Nm3D!|m`|Er7vzd`+1KZ$foES0EwTN5YyN8wJj`J|o;Sgc% z4Og56pkSinpWa~->I~^x%!mu6Tp&dn;Q-?inb0)*B#j3SaLI}R73@)Al$0eiC|uqxFWPoC_QV5c?E_p@vSDD&L^n!LFg4Etm^E-u2_ zC-xP(!r0Q-RI_dI6-cR#Ufdbzr;16~RT*Q4>cbIh0Lz;BV7bqxSaImUoB62>Y}`;S zHEwthon+x4ec76hs)e;N+OiW}Jkek|_12~5AS(AHZB0q=ylAGyIDu(YVfJ2h5|_s* zLroPPG(b=+9G07d*{yDb_`DcAIxd702uJqeXZjLi=SNYGU<|_i87}ehui_-W?oKOnTN9$0K)C{d$Ad+6@xfyTcDT_;E)&%dvw z57KNLt@CM(C>@POlwuONOTgYR%?no=i^e#$AhheJ&ye^np6`ba&43#`q8=z?-nA|` zj!N_u+P>Hi7WEY@M%JW_&9m&L+Sn4Q4c)ug5>!WW`sp&O2v7*ceNK=ro#R0{V^+aRju` zNFLrM4^<}Ibr18v8is4kxtyr+&`a|W4K8=&>H~Z*mB?G$fLb3tNY6n^FiqdvryQ{( z7`II09;9nFF(*w z%nlo!bl@oZW#%*tx=qptvczzJq&V^XO zeXq+#h2-`t(fs9yHPpQ3tZ|DcG13VSqX6@BMsZ; z>_74<{-AQn0AF<-g>AG@**?Ds|KDmpafv0>pFQ+sBVX)Yx@k1uE({?FV?C_1B68iW8$+~U_?3pfaPC{G+_G^nqwsEwi# zPc_lr^pG#F_Qty{XL@s6kAnqlfiB2+pS-(95&Bb>bD81kJl;3)s$!m{$wNAO9A)v$ z%DAJGhibzRsw#X>dae!E{RaRKTFZw(9T71&Z>rna{!W5wgVV54({Oo-x>$Sq9U(jO zq+ZxOEH+%2-dvgq7u}3#7%$Axv?|zTZvG_h!1z-HbMP7Y%a~2Pyg_9nLT>10cJN>X zwUWr^oj3Xt1i!XVKY$)C_N+!rJ1#79#J}3+9C?ijfmbhJFdB-~g7qqd=*t0Lp_Rj% zkc;F5L(D#FRgB~k6*3z0kg>h%TsA^c$6{>CUChXDWK!Ozb3e=5I>{p2DT_4G-%2-m zEy9#oR0Z_8IvSqZ(F#bNp7MALI%wgX!=kR<&utbFZ@F_fBr}Octs{=Ul_lW<_ZZkE z9;Cr~A7=vUc{Wv8bG~h1z~ecX<*!yTOqcIw*huMN2eM1SJ<18# ziFuhE$#9Fxp}LnX)Fe8z86CrOKC?FzbJtyzPMqu@_Oht>eZl>lsF{V#?Uh(ejzcNI zwEjlbZ$v0s0_V45SRz)r2U9?EwQo!is{+P1si1eEcj6dkdb!!3*gZjIC9WqEazMdN zax1%#2i9qfstGaU8A~B;=prT)5RvED?9}8b$PMlw2V-aqM`Sq`2w_&;BXK(qJG%Dj zVM)PcAI6X)*odT4OE7!r*#xgP);!@$sYnmxTsToHbUOnIefMb?>z(F=^6OYLUv6*j z_-@)naEADwR%c=)Nq1AZy&C2Q<2S@gO;8()&Wsx)Bq7{KRaIkn!FW~pG3GX{N)a>b z2M1SZjSgS8B~;8Z`quE+`&1`Uz0W3+Pn=^Q*%t*nmB!BvV=5STILC)}j^)wl;mC@Ed(#b8e(J!|EvuO{DXePNpGi{v-&V96IPCH3!^=d_2oHtY}j_bs1 zjwZ_3feL^vx~Uak4g$K+YK!qQ@@kuaEX#p=(>KxNM@3?JSx!}qR$H*Dc7RxU)IKw!<m z3>lR)&rgnbIJA$lIFW1@FCLKs_%vx6PZ?HRh8-hln|#Ap-DkLweIdhtxYqba62ZB4 zPipqmRWH#kbNHIqarjzyPyKN*b%PBd0qO^AMwXfX z-oM-=!#F|Lsp?IrX4g~rI2^Xofv^l&!RqpsxJi$&lSDlNO=80DA#@#Vji-q+agJZT zAqks#cB+CB1WiX+-^e9JHWeOv5}b67Y8jr>jn)DUPGC$LmDfUJbtNX~#l1yob?kT= zwFI?etWR~#g3$Stncg=MvBr<jK0+&G!fcjK`g(O}likI1S{U=X{G1b??4YX~ z$yxA`v5a4wPo&Jighjp2lR-J=_mmQXx(*tHI`2#ixvfU9PnBprEe2?pc>Vr^}QXS3lz8{)kJt*v+-kvhu8*MQuvH zgAdek+e>yxQOF7m>$1od+M%Jh6w-;`&G(zwPppUbZ$lvjPHUo>Y;$Jx1AdRgNFlnL z(<)_F9kPZvgav@)ZQ~)TX>L!viVV)?k})jltpg;Y6{wlM+m_Yd%r2w^5~#JW#P=TV zwCamWCY0)<3vJ6(=pz_Rut^>dZ#tOFO{de!pXX?Lx=5N6TA$P{Jd|s6o8pc7osHB6 z`g-$Zm#{=oRJ%JGj&n1hy1=tC`A{LMA?IJ|=|)t8GfF^++z!2w9ukvQ50sr&4|!d6 zAM_I@O|d&-OEr+Z9T2ne;Rne&T~;-_@N{@jMpU^wq)iU%@;LyH(v@p+o8*rog>asO zjp7lR?%>YE!z!Y6qJgh?(m;V57ee! zrrcW1MP|7xd_oC=GqgpR?omHb9DfSv6sdot7}`dI99mDKaF`TjAqk)Y0xBTnzZS5Y zESc?&dfP}yiP{NhCV{FDjRJQZ+QfR@UDpD9$AB1C?g?k}0~Dq! z1@v(Uow8902IN{U5a?k!+^LJ^Pj@rXN0dcX`^xlawO8WsIW8*-YNRxXqd-;&K0d+H z242W-_Z1<=_C%SiZhdeIw3oI2Ltz^#f)+5oGE$n!%K(}js?7d|gI#c0j(Hn{{VU(e zWX!e{H9cC~Ps?U&!VC%?pw$ZFZpQ&VsLe(n=V!Va*{jdiRk-(`ie)W&pj!=4p}(j7 zbAz*r^BPMiA&OOS;b7qsYFMotejDmIVp{WPZv`qY7Lc=l?4Qajq z#=G{!R!qowAR#08IWEe1q2`SH4LfD-{P=%Ku_Gl-kCO(v?5Fh&^v-)(Wy%7^_dM@} z(E*X8ghhs`=xyw@psJyyKKbUg3(v9^P0!6b+4~9WEzjI{bEvY9}VE#O9h=Jm8 zzMi0Ay6N>~`ft>yzy!6kgS1{*+uyNc0Vs_20%~uP!*YKDuerq8+8+%VLwX<@k6&-5 z0JZM#hnGh}{D77|v?2}wBsnC+gH7%_{@pcA!z7@g($&ZCpDY2Iq@%dQ$e&-lewvAA z+oYiSMKK}sxez&uUREC*n5Lbi`9@oLhyR2ahP`kYy?Dkib9Qbx0#3X)?gZ|!XZ2>C zxE-y7Gp}r`EEN#rLN+rf)IJv3W^$hvPl zycY`C;{@$ckeYTkGbEw}p6PGvbivf}yKC_Cr~ej$PvD#lT@G%m9wbxjd9MFVk>G)t zb+KrbgD^G|(62lmrow?XiOM>)Dk|-WR;JgDtX1 zs2PPI#+onLq9Syx*+Gs5%HJVsVc2KniUJ3!dL!8Guow>5nGq!W)mzR1+oL!lj3Dr<*J{t4XB!r3$$LokokDAjXYBKjsQf!^#vzgYw{dD)kY zs*6Gkv!2O;>^FZbG$bNFwB6w#Ku=e!8x#azm!6YgKUY1c%M(X=Z?jJ2d_t zGOO^!d9ls3!&LclT0-h#hWmS6`v%kl+Hj*e;i_U}L~7){gm4u8Qwy2`BGehoP)(a7 z>9#)uHe3dlNt{Mz0ANF-IoMeq`}Or_OqRu(@P>zkpq04C#&bl@EFn#scJEG&Tf9^5 zfEP(fM_XHTh=Ba3%cB+8nY424V5z6g6g3s@|KM(rctYovmht}n0Xb!X-sr13lQPUlb+XbLSm~X!yB&4I0Pi!)x8(w}kNC*0n0uoz0z!Ld>b~rI# z*)MsAO{ZW@^mq6gfcpX<;v?SGQy?*S)K)Fp%UOC|NG=04-}sO=w$8tB9H#JbL>BvHQ@1u7;S*=mPqNWQ>$go^0A*dfRSoSyny-9cXgu5o~p?Kun zFY{_^!G>{FW+?xJ%l~TFYBWIrzV7CB{P_+^o_`P0rFnPyca)tRp*Uz4yKfcczu2UI z&vp>|9mz}luIkUNj{Y%0|L>n?l>=P`QKPTwVxkm|#xfZE)hh#2(?J*W8g!M9iE_tb ze*rk`zr+Fyn1Mo&?I?@W-+as4S0I!p=537sjavQRaBPWz;V}Ch{oQnQ0eY`zn6Hlh ze?J}oLErVzhhCW;E_Zg<)ztxqsw*!qk8y;9wqD6|EVtYAlG5}ml;DXG6!BE~0=#Dt zz}4lxXY&>Me8z;p+j=vRb>shtKS8kGADyFd}q@6**_E-4v z9VZm=)PUdV(t#KFQLL)ti&}?Nr)QSclQV_>skQz&>5er`4i&B1=KQ7gO(oT>wfudy zloqwqRW6Ow%@VCl60^47mHuHfGL;c@AjQocxKF|s+%92jw5odI)Z>ZKZh4{4tu620 z%zY3heTBseZnf97Z!yuJKoAgdr*{AdkK3;;l(1)v?k8^s&;R z7h~h*rdU~we@8(lFjrXo;2o>;{%B)>Xtpsp|2$oDu{J84NR*?29jH8a@pT^!S=;LO z3W*Z$AYeR`nEbC3_CH%ENT0>D3E#=^reV5a_vvM-V-sO{(Yr7Wyg;CrPK!72yFJ}n zV^|PhB;q0OggdRTnkhoZMTimmZ;k~1V>-LGNTnM)eoh$AZzkPB`!Vc4Ful@3II3xM zJ60-<6oJ4Trb;0R-st}Vp8xz#@d=z7E}wCG-4mYbH@#@2Y)W%L2j#D!DeKfx&jx-( z2Z`3zlf)Is?D}2oig?Ge*<~{cZ9*pru|)Ome+Ox{H5g!X$>@dJfKr5m+Y;^ zW46f!6Q$+8O0>VR&_efvly`n!Gz#e1wY4%8y;jBxth%y$6|LffR%bK$VaZ&1g0ayE5_@T}}u$%fy z0^)-^^>03V^qXOlo{{)3Ur{`VXt<4T$MX8+L!2r zih#jm9nkIX?GNY`r5zroM0w7!#%ZjR^;#KgO|l zFf{$oSCR%=gw2K~yt1dZ9v$~jCeC}80AWB$z;#OX4{XO38Y!XJq}NfqE8TBvX+ zv;-2Ims-dLPDwW;cb=6S`Pghu#MVelulo-CE!4w?_q5ffDqx&VPb9wnRE2w9rqTVp zPFG8-ujqQZ2e4pIPg|$o-qtw4&G_wS&GZHA`F9KiQYRx*m00BN{mpwM&_Pfn#;ISh zCoqAyff%C!aI1F75}g74s3@rEIl;4*?o21>=_3Q{dd(dl#IEfHV&C@SWZM?%xf918 zS>gfzRR^^1YU(X9tnMu_YGo_7m;Y9+ITqgEMc|FJo;l6!a8 zlAVD{5wzWWrhoR2j5Oe1Exd zLFlMt*6d_jffm%oAO;%H_Q_Kcu`3l`#z@>V%PVT@eGA5$l~VYy$%4G^poyeRq|r@S z2f{`9FV`SwpJ%aR_uI#-595=gyB^Qzu>!rkyf`@6*`KST@aL&O&eHT8Lq?B+Ic_h$ z$$F;#R&CU|c^suVt%g$&xcH~vF8E`s(^&_76jACit{o`_dI3YG?Qhh`%Ro;YhruLs zNW*%G4;R5xSN%`qJkM=f)8}YavAByX-YB;X2L2ZP%K-77i@!k4Sy0=bIc2D#(zI0g9qFsE2&N{ZX&p$Z8H+21_sI7kg6XxICC#Dz_N93_B z-tol-Jt&I+t4hPe!y`6iS$!Xz&K1bA9Vuvrc@<@LVL~C!a~sOY@{sk}-0E$cqqDS4 zW1{U&C5N-XSmkI>k1p|dZCxr*qqYY$Gj9uu4LVT8(?yfwWO*2j+>7o;eR5!) z-SHwMNy9w_29CrRde;HB=n4t?x9jy^gLkJ5;x{1Gs~h}Qm&7c%`3WQN;(dFo2%;NO{%6GdZ|4j`i8t<$slQyW*0W8Y?GqPzB4jy1pL^33pX!Z$ z_t=oa>WFJ6dZoEfXjZw2sE3;kG4wlmiU6a#|;rZ3We71#he6jh+h%h8NZ8oUaP*|UcFJFqYs6Ifi$+Jl zeMU%wVmIA1u6Y&rQm+HG?To%Y=IQm%-?OnVl%lXfIj9Az!aO{QWmj4Y6-EMI9_)#Y zOCv?}q#gWmQ4C~24f%K&fnNEHW7|z18yyir`Qe+TLmYl~AzVoltzvF>QaJ|C?W3fbJ z<;+JlOYfTI{m=!?k$`%Gf~>;MgBPRTkG2MjG5b~;hFV3rkTaoZy+k3)*4uhE318nP zbi08zo&3aZULQp?sbDN#k5z9iSC1JXo8BnhpMy5EA)xspUKjIJLJr@afmVGeJv*6~ z)yV#`Pmnt~iX4KhXvovCjj|EsJRb5^o`Q(~89w~e6;@#RAT3+4WL(qk{B_4oV7U_+ z%Hm3OXy3|||7#UHG;B~}e5ROSVxF>#Hg%c*F`-{$t@e3Ad^bPb$lVvUt-3pZIL*AB znZR->0&BDSz;?E)bBQ)IP|=|Jlu)F$PSb08g{H|3^somxy#jkOOZcZv(-skET%MDZ z^q?Nn{bpJjA-tiG0&JYHMm+h5J4Fgvlv4{KYa61oqCJo-(9AF9!c$}0iC zT_XK>0BRQ4JQ;ucQkt^v3=gD$9(W%mTDd)Mnn8GcV$anfcwm26Svt2ioh%9CT8LAr_`@;q--I6*ndh%b5DZjLMy0ub` zy1RD!1UNO3&D23{1v$8=ZBfkc{_I2!Phga_GREhBeOwl5tc6SvcqgSc4s*Oq;AScH@4)DFLt%nZg`hOp*J9drV`uVgs zA=WYb*CwlwzC%th?bprp`=pv&{$av)EQpBQr-C>M3}wj^0w0TZsIpCRnz>cGPYoA_ z3_xGvNjVOze*Tu$6TNDAc(8sYl$=;^XZOgh!Y|}pv?Y@C;LrXmw7N}3OgX=}b63VO z=_A>NWBrFZ(&uU>ZqFkh+;WM%6)(Bk4gE3j+;h#}*7~%S_WkZ~WIzo+HDmwe%o?>c zH;Ae_INOZ(d)GsIP!GANrsMsy3rix+6zR=xHKrG*4}ua$p?xHa(>nOy#L}kZ9wkk6 zPjldInG}F;Z+5%oji?K5v*`VR^Z6 z6HAUiY+TuNSfwYmmS9_t))7%&KQa1~34>Q$Gl0xIoVbZ_qlZxS8g?|hZk;oeOg5}T zW5?n8$pcZ&yP3Ce%8-FPD0P_DQ1vWl|Mnx1f2unJg-$gBhJ@NrZEUkd+@7MfoVF7o z434}C%-09APVTQ??mp3N{&RL?vkTSG^kkE3a5nfy>vTV|H<%g0HFwo?<36}Gh{`%Y z>ke4ovS^=t+5Xw=s!5f@r`~=0H(Dw21t9}y| zMJ5p*?ROWQ{=914S4rn zF-kY22(;=?)#WhjNT0FYKlZtWFXPBZ8r|uETRf{^R*U}cz%Tl~BPDxf+@9go;XJn% zKDlN&tRqIPm0uNQ5X`F2)(guOS8A@~ggw*}J5w^s4P3%^gzZQr=606-`S&XbZ;uWI zz0ApT=a|_E5($TZyT#nLqh`s;Q*X5ueemI&(mrG9iJ#6D>OvFLPtJzR9KY7-$wEG_ zr1zxOIsp&p#(UJA7^8KXLM9i;b<7+pHUW(nWwYEyB&9`Ifr|=u~MsbhCc(v^9`JuY^n%{=Kgww{xtTfJ}b8o|Y zohdR62C22dwgL;Rs&|*$EXAlyeK~bLf;r?qs1mP2<7JGpcyJ2p&w#D`p@kL2nHH@j zksD;l$#-E3S5UL)0>`o3>yj_){gE8o{@&MQDP6}T^FtXl93Fck{X;LjT3yN~aLqd(CX_CY}jnmh>ugg{Yx0Da@ z`UZg6Q#;zm^5`dw5o`U;V(Gm&6mnK*Z@BEUwM%`}nDo?c%g3ITqz73@6(RR0$5vdG z@ZBkFiTCs6YQRLzQDjK^{A&-(dtBuGaV`dQNo*^R>4yRx*LJYB@YEB@S@KSgN+h{O zm+LGY*!+HjbA1QBBr{m8iHR_|0!rWW+ZQs;qrHh@HKPE(ZhpC*B;#YDo_KL(*zjCc zll4gGePgz+{Uj-x#X6v`@%05}wKUwewMim_e--4s+!4mX&cPuykMY9mYV6yyi;T%f zKO-4H_hgH&e~F{!n4-4Ti-Wq>CSx?C(X+uIcd^{c zF}{^CgPsPDZeeBAB6jh zk3dDmXy3i3B?W4ebnC1&!!Tpgv%3S$Ct>r3rB~q%PN^R~XTARsi zL+uZ;rK|q347i9toLLXI#Nwy^1^WuY>ZN8>C&Qn-GDs7ibL?R8v0PYq3+vIn-!Bg$ zBN8TO(-{{04K*+PE=qmGyLYg>xz9az)*gQo=K2ucx!X2F!x5v@A;Q9r-{`_b%kwDD z(Gb!lvEpN*H9B_74#orBR+$ncYSlPN7QIqfFIip|h9^sDWUBTbml1)?a4UumoITYq zEy+X)#?Ri+1*tzlSqxDn2g}b)pezF30rZsKN<9Cb-#j8@Gdt7c9>~l1W*D z^v4EDbip|CWA9%6b7VgJ0Db*-jZw%;zS%Hp7se6+Sg-le#WM5$paH@+G(6|IWy4Jp z=7*AyJida#kn7Nt`|LSir4o%W?o4@8j2<|6QNUBx3DsLFVhYpSFx76 ze=UW%hAxO;Q2bdo!EZj})5~_FqyO zdPG(Kik!M#0fQzs#O6r@O9w38PV-7dJxc%$+w-^Pk5Pf5j1|=@2UoSCq*tO%(Zn-O z3su0^Mxv$3v1QGW@|T}CK4A%CeCd~I1lQuW6`GRvtz(Xz_b%+JCri`Nb&3 zmJ+E6>RCCQ?Fo5+v@qM|AL`v;%m~;zqe(c8`c)Z9zIS!)*+8bHAJ zTu^|hQTG)dEWo>N=a`_i&^7l~A5~oRO@a9&Joysq$nVI-`hT55P*4UVpP{kIVUfn!*=)+3Tlf#70Z_z_X>v!87Gw^oCh6n}XcDXLjZB2$k=XCwk zVUK0awRltf;_#`F7x|(_C{qttQOjI^X#}42k0grlx1e|M9!7oe)RS;B;mrbr#7^$f zcMOG=hkcEgWBUurO&wQ0D%)bdW;F(_WR){K$%|c`n`|?H5BV}WvwmYej}LSY{L|Ng z%datjZh?h1^v@Z%O&e4jvs+AKlK?YEUKyFj1?o`Oa)0OdFMetW0LMhbH{dd2zT**L zJ$q%+VxAG1_kJmFRXDB~cqJutEbk;%Dbgi~SoNKQjYH0mz!YKm{Q?p#i-@(JqzIc1 z{8$A;Cf_9TG{agx z9ni~D-co9=E;F9ZDeuw>InLzpQ0AJX03FpzQddvHf_yV!oWCFa)m_HeNy++yipvc> zUR`dD&tn-hY@mS^sQ7^fD==@fK;`mXMkt!NXokS`;&M*esQxxyq2r~YU>cBzz{#Ou zlp6h1k@ERr2TIZbBy{YT&PH^?)T)sYjnA}Ssjx}N$ZM3IRAFbrPKN>b>kG+m?J$GX zFIDi(%a|wraJg@jV?4dzGC$e$6+Y&2s;lc^Z%k3b{Y2jO(%hZ5H0{|>aHp3l>Bvl` zPS2E>n8*j3CWlWu&y1zx^Trg%OxaCfequ1)GgEk=wH-2hdhI=wc@K6=Df?-;KU zJAsuhBKo1MiB-z6zSKW6dZFQmr0S;x|9oAB;p+64FEaMO@W;4Hw>@I;f0WqO>*Hec ztfi*x^Q1$8=6q5#hji|SUibRZF&q?Meje3fF-wt;-0du_HkYJ+mZ_m+60pFMN&8nh zrK3h!6Hlazu7}3;pw|&Uu(bG@N*@!RzNuct<+lhSGGX!CzX3c~TN0+^dah|XMC4v> zGVHQCjk zDF=JU#3qLp=M}@XC}K(l~>y$4B(HxvI_S(f#p?|A)D^jH`O<+J*m%ZV)7-5fqeE zX(>TMNtKWWB?alug_MefAl;HmN;gYD8bOh6q`N!bxxDY^IeY8c=YGz6-Vg5=e_J=K zHDk;%#~jx+#$}yRllb2m(ierXc29Eli)Co_-^|0gD-Ky+^Oq@O6OJ&RBrGs2hrZ@p zN_b@IN!K1Evj*O~K{&~O=0=cM!U0KPRIR+?7w$G@kSK08Qp$+QH5UuGG%EYAEbrs& zmPdEE4`XAMmMG;HuQkJ8G)~I&dO19=^=-dyS>pAS{M5NxS}E`O`H$mUfoYL=_v323 zUpoH-d1X>I2?6t(tabu&L6PY>!eu$Sk*uA&6cVb|6c9xS8 zHhJ*^M5Lxf+nPoSEs+)@ z?`I#l-|0%>K=^l|1KY5*Mi^o|!KX5T-OsthFZJlenU;7LMiuG}e;u zcI=yTO#e7Z^_0U&t!G@WjeVTIa2t^?#K}LANXXTv7YP?EEqoFFbC z%PTp9I2fqTI`TMu#^asgzU;nxRipeR7F<~B@|C0$9_cS8Raoh>_dss({=KE~UU&|t zld#UK#d@tX`V{Uz{4hwE3qHX73!rr2E-y6mpoy?5AL#y4A|t4!O`z@fuT20Gn4KXSY1<7=!;c(UQH*tsxSAPv&#zS0x{&uoB2lnf#qJL6?*T{3wGF}FK%#MPhlSA<2=&kv(zo+ zWr2`0RA*$e2|$`>G@2d#juH!`FoSm=1ilc*-vj6p9ai=%p&l8}H9ciq+as>>+dS)g z+7pA4AX}Pym^CXe^A9*ZI1cFnwH?`gZY91l0H14mMHa2Ds;ZOXNGM@^H&fvOW(@iG zb%}w>FPV%tGTClQgQuYc-K8Dj@3M<>CsM+jz8d&5SI`qXu%7AOE(~sZqc_iBJ6_h$ zPkOErbTDOR&KzGGoLi>;tgI|tP4zq#wf~Zk$dTxUJvh}E{&W=DO>-YIc9uBb;?uJ2awUG0Y~szT~@QFvPw>E^RlROEEFb7`8-L%*4LWx^-Whg z4nPw_Wtf1%p^BEL{)|IMs_b=vs&$q4>O&YKac~xF+ri+^3+3ORfhdQRk7pO_>$IZr zp|mGQDx)dluRb82dIZz_gMXHo^rNu(VVT#3xsu`e{{S+~BOuqf6?K7OR?nEXM%-nv#4o6ey}oKvf0 zfe`Thhi+U`adUIC>k_qFnre&5n~2g8x0#v#?W>T{x{PIs#?5CDKO?3h z_RP&pb>&bDR>DV#^zre@^R|zs+=~4im1$GY1ZbhJ2}0Y+lz=Piks|}kFPCkUQIwZL z3|vXeWQZ82v~j2%O343hwSN6oVji!i=B6g!`A6Q9>dTtt&+dFUHDmcDvz;O8OAZCp z(h0e$_j9@&qS&3$nhi&VBS~t9_Ut=dG9zw{5X9dcl7ou zwaC?)nKYC;vC6)&^?K*btDM#1yZdRL>sb`UJosIO zPBqJ?Kg`U|Dzk9c@7yi2+MSNFEa<;qEez$BHntUB!2LW~_?9N)&ZJCR;f~mgQTaks z-%pFm!;XSo%->t4Ms0XJlf;NdCQIiF#4_gH%Ukj=WsJAvFusj!Qd^H2~AiGVadbhd z2&nL7)b{n?Jq29fpk`vjmP zfNLv3O-$%^vNSTw2)^&+2*{;7L4bh z2n`bMpW|bHJBI$@i`$VuB>1H1WeDAA`4OX?3OLG-M299&Ex<)K4g=_MOzti|6;w7p z$oWSA0Y{UPHfY5{iiInHuGL|0=x&!~aAIrZX+_q6j)-lbHN742iXkMZI_|ZWg<{{_ zeDZN2*$~=T`JAjQ)*&F`9Kl&OczNKYEAADE&Dv;X8|aH~muI)T)K@u2lO4-*d-^4F zc)WF;P~~Pb4feBQE7?D7O(i8A5rz+y51GUp?T> zp{2=&D)EonG|m9iS87$`2*$nG#rHkHX**LX(ap8{Gd9DCHwCC-(V+AEeax(6gMpqUS()wZ6mCy%hFA2m84Z;2j{_eigf))owK4x9tw-Cm*X^n4|+b z_d_ShzUF{Znd<>YqX=XG%2x(Ptg1PY3g->-jttn>A(6eorxDyz7BLZ57e(-`xJqW5NRo1CW^WJn?nu5RfxTLWe8|`7Rx9D-MtMr zLu92)k<5MG$8Kwt^F^C@!--#^LLu4gDTwDe({8YXLC}Ds7QRH4{X@{$xc-Va=ihtfJUILWqnq#$!gGwa;8K7%NVe%{U9xz*mFTj6TcOd z_OTy=?&pytDNYuPGZ0Vr=1Tw1Ij_H8HB!0;-J<&nWuWK&8=q!TAY8E`E$KWAn&4iI z-vj#JtUx){v|wOllM-A-w2?As2ws)C_bpK2ITvDz#L*3++IyNULJbi`GOv35{eB(0 z0xmb*mf~3Vr%=qJ;t?%q4Rm;JyMs;lF8HNF`8SpPis{!gNLh6+WDoQRAh*Il1oRyu z%4=ph4Ws;A=|OMom3_|g(VMB-j%-Mg`J!iiA7?fiiMz4BQ;B5J z!L-qEYtFNRP*`c|}xUp(lHjeccRoh!x`q<#f&T@+F`EKR4`t!3H zWExuby?!2K1DZeI`+lr< z6{&7e1hji*qO`5a#~_01@QpwS>^cmoB8q zjsxL@A34)Iqff<}8B;Eh8Uu%bTTc0N{tKnP0{^gCnxDmDkJQ^`&nnzUk6C>!Rii-z z_NyR~At&>O>TTCH=#gD8kQZYdK+KTT)nY%FTF5b?Q*NbO=9#%qF8RqDbQ)=QV+v>I z5l6S*8$b(t{!>b{GD@$^Qd34}=)jHFgUHI7d40(&AFC*O+m$-X7=RJo8 zhKYRP4$}A%P9YJOt)~!nVN%zMI9Q*st$xQm0L^(kw!rBWP|cb9`5`MQP6xE}Z=)IC z2$(?*sk6}&tuY(HnqVVo2TWUC?-*!hyzL>3bSG-^Cl0^$Rgf8ftnPSh{pzCJ&CQM> z`?WUEA<>KH*ygo<(;2q-!JS#D>t4b09x>mf4}k#1@-C^hM`p6quz4F6jb+br=>|T- z%jAP5)*`McLoG*0u6zO5)9sqk@Dl_J?q-cP5CrOE95@d*R~7a`MVcQS;fF< zLiWMuu>6=$`*{#_C{Dn%sG%r7$>CdPI6r7%u{wDqs_dwKCq+(0j**g5vJ?}af~9=I z%e?>*WYzM+NAhPfo%8685A?Z_DJ%Wj)_FgK^wvQut)$MF8_f6{4Gw5ItjQiXr|SH* zEk8-~SGtjqP#^XfWF5sN8{-O?ACN^C?WTuVa(@kcEY36!YTMrN@xLx_*?u3@*CDXH z4+1NsmMYESo%KO?h#$Xj!R_OO>TVS4k7vf$NU6wiA>5;n6E240>bZ~KUO9+=UZxpS zGS2+@GVCc^?lKUGXw^FNH!r2v+`q?~_|6l@e?WZqgYp%I(*@ba0!M~Q29`Yh#&Wto zn1TLr6U_qX!GF)|{CGm6UqAC}Fqig>i~9AY-#n~O*+oVJ;ic@fe*ACK?cp>%VFAmA zXuJ)DTK@gsKsY+N2nq|hS&COXngqQ5%9VWi-jTXI%Cj#WH@G|eNU<&a4E>x+@t7tF z1x9;vt}y0NEPm1`Xj%?JmvB2?1zvQQq9cx?PL_Y|P7`PmEGvaOYB%}4?XtL%X6c9(sGI*9~4DNq%@S8^JjYq2W zbjDgWze!gRcslNp+9MJZ9}6UT1>>8rnRMS>^DrnB_gKE8b-wR?zJJd{$IO*VvIbzL zvy1#5y@~?HoX3M!Cjs>{;qu`~Z`>IbdGlX(c+AO7ItOQ{=@x3v0fMHPZ-R?8>q z?C81}=?UgO^IbP2yJJv6RJS*5QOwn-L%iL%Y(yhVYkRk>wkb7QvK`^?^W$FS-4Wfaq0 z=G&=4isL#=@aIERB*dl%8@UfjXDW61MPg*uN_H@1yivas#>x7I5* ziDI5^>dIw`OhJgC?=OwZ4Din`6~P!;1JWQ?P3N&Q85q}hv@iim&P^QQYo%IKp1V2v zigiFQ#Hy1YIUp-fb7vX8-Hi9eeqermpz#&F7ZTq+E)yi3oquL%8&6xE&qY7JVCd8=Ct z&F<@Fel?CFjI_Nt`FnWWQ;CN0H1!+aK>DUx-KczW&l^b`^8ETk(KWo$RyG8N4v-OA zE=~z*7Ug~as$7wz`E;|AJ}Z?V*qhC^u-PGh1h++!sU-ad(QJP8T01q(WNQ zwFdpeb`4T7lFE90wo!?9?&N1n8ud%|2$H!1BIswoPt8}MPKeRcx1nysr|D^|aI_|W zj@*%Q($7nCyT4_`Qi?Gu=ri1rlJbe7-*3NlhXp+3hgc@l0x!*iST5I9`L^4Ut-iNa z^p^@4hP-W|j71GkgNl+hC+M$6+c6AM(w#V;8VL=p%~T} zA%0F5t7y43i&)&p%|t=9ek^9ukL|4v?rv%}V|I^KhNVku(Q<=wSQpmqFLb!nf|cWi z6tp$O-qFu@6muc4;Dn9 z(7~KQy^zp)&Gz-;tpLIcvZ;)fw`56Izl^%P zZ)TL+Oz$hAdMwqWGJ*y0(qNOPKKB9}za86#lOFEgv@B?5?7T&FcTOVj+qJ z|3Gv)anE`?D)l0S?C+%L1$yZ1zkh`;q4hPmfJ>FNtNh=nk9XH06cDH3Xa|U{I zCjtQ}+e}D$9Y%$fFxkXG3fW1u_GHzLXhZzBpp#ZvvG4>CAVk{JIoFXdbMc72MeMtjxMzgrMx~=$m=LK+DF8!QbY8yY)zMt{hVqu z77mOt@2nvuZKpYn-kiH{MbCR@E66?uI7~;Otybm;a0l{$;^Nszjpn|bqe1}r`u#oOAz_Ngqs68B)O@zNcBaCUTvtx&l7N+tG0Q|9 znuJx5vmYe0D+^IIWMqA=Gv>*R#?$P zn=tXQ#?ng}uYl7w$%NE7YRIm!or=;0Pghs|50_vDHFYj3ZwnQ-{CSSHKy((58HbEp zsXq}cTkbveg-w!=qW3_BK55_9V3XjTSIa_A9;3@)M~pBjgJ!xK0v}YABS3`p){%UU zCRF8sB*l?|0k2b*!3&FI3Z127&`3|qee1ad+Z(OB0^=%=uM+s{U4=Lv&EM<@IL#)4 zEaPbsZa)E?{k75oy~x531<(dEen&t;iYTUEk~Cy zV@$B9dw>@TUqty~mYN{`?0Wmdu<7tWI6UM+0lH z!9y71ZM_ow4P^Lu=?01PTP}p(118*ju^Y>&Ele7p8~<0uVPIV7nUxWCcG^qPUR8A9t%(g${Lp94GsaM;*04K*L7c3 z5;Jk)NgVdI11cZU5rQhrA|Aj1i!I!%h#%o(ERa)b{jjCs?7u_#lSg8Xt9m6o__?W(%TwU4ST?fa{<56fLl~oS{o-08W#CJN0;}AM&aQ+VUqT%eO?ckeB%jHkOZ4B< zHTjw_l=F4745t@ol8p(P(Mp~SJI3z6j$zNFYAFM?@;8SvBo77bs#{0HSAou){DLrD z^!upIqAm~M9Uk4XdNHC1WBhP%C0gg9c{{bepNb_9y2O(GsBO!Y`DAae0{6Wyy9C{r zr1wq5k2MeY4iVU5VLY651NyUH7I5>hl*LbXR^kb-Mn8wO3RCCV4;gRMDwi4lmfX9kx{FC8V9d# z@mSF9{=}~TMaTpDp{&9J3~!8QJ7;OLOd}>6UrCHUDQUs1YBrmPKq26(K;0` z&3{ddcdjoM&`INj%*(3I&yGz;J}UJss~MzJLB*b0Y~N2Kzd5_uZ(q%f9KDv65U%6c zr#4i(dA6&6Uiz?489aC*)qO{4CV>u*$!uw;=gQMIYwzO`kQPeq)0La8bpCt{UdVa{ zy|Xb~)fdNmcyneCn*8IvZrIwTQvfa57PbM}anQDIP zgNW~I9goc~hIV_cp4(`G^c_TvDRH-RG{{X7 zI7>Vt!z$t~amp<(*t}_++>00XyomEfd(8+fTZh)M#!iK!2T0{|5M5*yU@o5_9Bwax zSl(uO3;Xwc5+42NXt33v(_dtqxfw7ONS0PW48J+TR?MO3D==bNyduRt8pNn9dMGhT zWkY+&V<@<7S=97R?y? zz_tSSioks5qsLsz?4L!J?dboW=lS)4KB=5MEa(U)@fj@ms+V7GGK%!D5E>yi9Gk&o zqn-nRO@j^?ajQWqR^#e!(*12U(pnIO?!H8~H6++GZKeF@C>Qj6KpGASJPq|)!5F2k zm49SkmtgP;2&K=y@C@5+Vl?T`?@U1;kQwp{0B#VpBk1!4b>2`Um>Ny1TaGyXJ#F`| z6ud(;awSU6(#Q=2E^3{B!|VBTlfX|(Xd=NNpb~oC0c076=jh?1+F?+k+CCKrexkE0 z5f04Y8+wHE=~q;cA5RI!>p6uqnP4}w;SzI=y%KGx)o?lB7;-zWPu<0Gu>Lc7@1u?c zF9sL$py#IpOTA;e?0*7hQpzbgXc9#Fti)K;lMGVpgbVa2ekzY*p$Z}?R3d;8o@;r2 ztoHhIFAdD_9E_pXR2B>)qe&-*i+<<`&vP6IHI~7vonnD5k%DuMgXU^k&Pd|og>&|r z-p?c%BOk>cs-(DMzBW-_djdFf;fC zdqDTm-<}x%M%@rlk3Fh?m+;{N!1Btp?{fa%liUBElL53K^rx91t(OuYKu(*V9S45L z^?t#8W`Yn>(X6f%2r;Gs@Tb)CLUU45(&ggYsBve!cO*#8gs|h%x;qYpWMS;QCT9nL zCoM#&hHBs`k!aHB2%xMf!V9ob4RmBzF}h;A+4j}fsy!5N>5>EuRO{Au5->Wh&l zNj+buQupoa{hghQv9;H>i@KJQ3#ZiwSpP?mJ(W4^ zC!k3V2mbl+VVE7%pQjy7f}w@l1C&WC7g&f10+>R}$bV5`cia z^IUiGgcINwHEnPwTn~WXY4|Pm`^!*#OmKNgA*E!o)1@R3i&V}}Y)mzd)Qwoz`nG(2 zT#kbKJ0IwB|b`@pbVTIAU~{n>dbqJ(T(As zs0y0DVDUFp-#(?Ct25jsYLDZy_{e%(jq*(UV-i645v5+hXY|ulWB$1s2H7|SL%#}9 z+x&3J!hw8qS;;I?>pmPQP^npB_F&CNlmH5BAL%|tamuu~fzLof=6c`)e!;Bq%PODk zA+1t$zlK>hq?3<(Wa9rb=w5;uHd$ico4>gD1F`|Y%{^pC+i=TZ&N`#E@Rivzu9XTaN3Qt`+vpjKO$w|uOb_BU$1u_ zi8wz9J(mM~E486KB&M;2m8Y=t>d(FH36-FJueO!0ZC%Uf3bG8vSC$mlO&tmAMP|?t z0(G0gL!#$EdEI~JXt|)9P!{eC)H_YL#WxV>m1u~05)m?F@LU<8k+S z(q=;&pmnlh-N6@b^`%XJZV#r)rH?t+>$m+jLP>buZGXMZeF)?t>AhB~T9k;OZQAbq z+Xic4zYp*EbrtS~9D!Q3>Kowc@HY^?`u`Y&f8q)B`mP|;kfdlotT+>Cp*f+XF}KlC z?%%C>STRMfN5k4JXUQ78@15AN;X<#fO!(0e`9km3Uj9Bv-~Sq9Bp=jyZR9y@QtWso zg4Utu&d|$N2O7fJ*X;RnYar>qG5|!`1zq=sOd}Kp#&}&jw8u$J?#0XlB)rXQ!mfjp ztV%7=ZZRYJDhNRD69ImLC1WsXgUq@;*Cp=-m(4x5iY-Gs7$`>`xYr4n}*U@*VyvQp!*u~K=XjE(_bwXy4)z-O7)m{ptB>2 zv%`(mE||Xk2^oIcCobo+Z*!?G{nv%Z7h8{2-g4(^!ldVOsh@~p)NeOa{Tj$(#vQP zN-tGjb9CU6-LH0lA*Gv>Yk-abVc*9?7r-*PiWHOH3J|Da5&~mp-?m9c@Lb=(Wlab} z>IX*-fRkX&;vh8}OiC$JDfIKrt)iaQ>WNdUn;>X8m|YRtH#(Wb7LQS#I43z~0RI_j z^`j5}rnv6A0+1Hb|O10Pucl)(j!RSoO{BN(<+?v`4%!Iw+ z%fYW&6#yk@&_cMrCnhjJsBd7;PYcjpY@+yhCe*c`N3MXJt4J3$^Eb2XDjpSfLO(WM zRX1?1i;w({ZY;3-`jDcbZ^44xT_(3mmZe_ zmrBY|mr}>(PX89SLe6e$m9p?+`pn*lbwSO^2W8LehYPaeT8FjcWNX;>mK%63Iy*vx z17e$4!n5xlg(HPxJ9}?jea-Ga1o(A6HgxIOYp$- z9i#HWCqcQa#wTvOSjfQrK4Y83?u$CN-W*`36Y`jF^Xu-ac%{$Zw(t0>8j1F8^M6OP z`TPR2FXzMYZO*FcC=cnV*_43qTrh(LrD`BRex=x?3$ITenL%sEX(_2f3Z3DBWVUpT zD}WfqjTK!NO>}a4W~0}>AW33-&G_44HN9N|7iHMIy4}agyt>3N7EC(j+5@x3-Ygzb z<4sN9XrYbZK!W3UgCwii9wB3>(#s&bd>-Rzv4KR$hvIqMZ=4231u`||5J9nlb2Z4E zdVf*qYV-UiNLz+`0LBtQ&i(cu|1!7x(!Vck3If7ug3-jMb#UixS9oPzVdPwsRF-tp zv8(1nW2bJTb^P&QXfmBcwpEsyKJ(V(GaRhNO!q!DjT`d(aPwBf$Hbfml1w8^jOjhI z2S_Mp+`Bg-^b%MOgW+3LJ(j?YIJ9cq%~83lwy2HlnX}UJFUEpIv@jl6)8qv zJaBIdw@0#9Q%O!zl+;O*zn?4)v$r65lB?#9Ya=q32XOB^j#E|#?aX^t2|L@F;)gR4 zjg~{AFx(Nz!$oE9xD#NI?Ou6A5E$ta?b@Raq)yr4@IV~}MOPeo;4#}T6ido@ixvgk zfk)scL0bq^4Vr~)d1TY_0W@V4Y?V!1esCFQM%cB5&bjjipVp4Q3g?el8EGa#BORC) z(f4H=0Lpck7%IG|pxFR7etfVjBFI*bav*dgbkrx{u5Bue+%Ywb%+HpnL1a_dY@>;@ zh3%JFHXg;Dnt@x3SLxLyi5Fs1uJ|8zVA!-_UE^Gwkkr^VhKw{C0_5e{4uP@JsV5UM zO6D}ExS+2C@rT-RIq}0bnD8$UVZa$rcP}-s5uYaHIbMR3o@j+D0UI&rt2>-$b|gfd7HgRW6dAw6CM&Y zTS0Ypku;)Bk@9gj3n%f~x+NKl+ge1Voevg-Yd|!{!IA!!2>pesGdj_jH!f2_%~pHv zE`3MyNFCsY6)C(}w2c+AH=&rjkbXlCZ8@83<`RJib-7$FxSc^En|A_X0|L_%x&L< zO*;3UeV27uVnaB=ymoop$*9Q9VFyFqUi^oL-QMHNw88&FDB89094HXy67cC+*h+pW z{wmCFafwO~@D`*hDD~zyTg1<7?KVDRYh3jQG@;7QqSVW-A*L|{e>||TBpHbY%_<&^ zwFU?`!RXQ!zuN@TyMRzpn;*}{d-n~xL=|SQXbdTs@0fRGi?_(IjZQs4sPhQhWY{)q z(Tj1vi36O&JtIF=?3aC~_3`bRe}gtkAHWM{>ERQKpF&oC+>xm8Vb1%uMWNKhGl_v+ zEk`-I*qdc4b++^LL1BshjMnq=2>b)7uI+uR&&Cp0W!Uw-`T*(Sc2oRtUaN1 zZ;G9}ZqH8uHu4^qJ3|3_jO4O-KG#@5qhbObNSn`O` z?QIgi{x=dGXbGM#ZIYu%$s-y;7Avk!n(ao0Gn=xtn=pf4oRXA5v_Bu6JzQwEi00PH zauCfJyX z!{Wo@AN6vE*fzTikl0vmnRK@5g|6Rt{I5&t4*uDz8Mv;Hj}FdxOt~;*L>=sXRXM4%H#clv$NO}5YM}k;uhl6J zU`{94ON^Gj-3;>eV&&j^c6cZQvzilyKKuas6XEOL=f`cWZ<*cu-U?8so%f*eTpTyD zb{`oDM+Up@!2&upv<1CJG47Dx)h0vGi%+!l+CF6D31a4zB97#Fmz&AI=TLlnNME9t zspY5}r!Dpm^Y5Rswlb@x*(fH5+<80ZUeJF6N+sLeFt)Vvps;@5lFI}c>H<&nf|fP7 zA)~q_^+1Ind?uRx!ys*ee*B{)#n6F)&Uq}j5Z^twP_d&0ODn6pnkATwo?X{g`_aNm zPJpC%n@nHZb*fV`$xojxVRDXuUtQq`-Q>j#`8c?IEp6d!#Z){;;rJIIoL4_<#^(Z_ z;2KpF01B4F{5KTbjTff;dp?W`0uCt6kztB*N@p}X@U71}z@;tWp%wQ5fYYu8yII7& z-J9V&R^_N^A%TUSy3CoOKA@NXwo;6^gU1CMX5=^pYSxs)B=PTP;q|lg%Dm6v=EQG% zjnj{F**v>x;R~-|ki5uc+lq3gf`NE??vc)UDSl|iBpfl%X^bWj=Yu3{4`mK>Lg^13 z9%LS~3*;o+G``ROo-l7lNoe-nN^{gG&AR^iu0Ff!FXmhxmj3zC04um_1=tG!PRk(g zbv!bm?lq5#d)ssU+JK(>^DRI?;dZA#OYOL!>vXN;d)htD7FI5B;4Jwct^?hpOUhs8 z>Onz9u~lcuNe&mwscDj{NxyRPQ!2cPt0E^GjYBDyf$X7eOoFK0gvc71MCz*>y7h-P zuR8oG^ZO9s$!d3_TLc(JQ>n`_# z+M6&&-v>R`iKJPzo^+!%yGs^y!8Oe^uad(I1d2k`xf)3(-&9FG3H=tKEH<g)_f9qPLaRIQ+2UxjU3XY4I@(F-30J~O~3Rk)#sv79gRs`@Nk@nF#|BCFqI`)69ot_j}YY z+TdVj+c5opIof|!& z+H-x=TA$p!-?LkIY&~npG`Eu*yM*?6>G8;yqu=vA0L@Ee?NNgFH5wIIV z0Bx_tY@;4UFhJSHTvW$cQG6#16Lfljc2xgesK_{m)ek{}`pCwHe^2kH1c3y5^}%G7 z#h-=;5Gy2HQw|d2jT#`E^87-xI&sy5bgr*CsK6|Va(rGYNN)h-j%m>mR^qouQCPc# zPY5MIX%D0ph)~W-MIT_sb-@KF|7Xu8m@=I=&e-4Q@L!svo2X+DccJv8#JwM(KJHVm2-`+w!mP#;|ME8~4%0Dd^80IM`W8RaW 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 literal 0 HcmV?d00001 diff --git a/docs/images/quick-switcher-other-schemas.png b/docs/images/quick-switcher-other-schemas.png new file mode 100644 index 0000000000000000000000000000000000000000..535c9af8ab37ddf241fd5a42432f6db293205d42 GIT binary patch literal 72487 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 literal 0 HcmV?d00001 diff --git a/docs/images/sidebar-filter-other-schemas-dark.png b/docs/images/sidebar-filter-other-schemas-dark.png new file mode 100644 index 0000000000000000000000000000000000000000..4e2034701fe2be733652950ecf7cc521779c7f04 GIT binary patch literal 296571 zcmbTd1y~$Qw=N6>cM0wU_W*(5?hqijhu}_dw*-Q_ySvNa41oZ_-DMKo9R}wgviHvZ z&OOh)|2=n}?&+H9uBu+Emb`0KO{nraX*6UaWGE;oG+7ym_fSwM<4{oWt%&fDnryyL z+)z-+RhHu7%Ch3(6v~eFW|lUlP*5_ViOC4cstZK@V;#Gcxio4Fxjefp{t1{mP`mnS zV%QW31TeXwnZ3ArD2!Ak%sYAhflTjBSVHIllC}OmqIhto`ph9=gKb@yuHX?b`&AyN zt^2JZx6X5*`O&~V8nMzCXIj%9yl$^#Gm4RTfmFzef}iKT;Vt!JrFnY+U3w<{uNL!Ev~~nx@sz>Q2jS>-KWUvZ zcV7$%6bhP9Z?PC{BHsGb1a)6*yzdCGqnz3Ny23-UAG1$9woKTKw|HN@Nq94+2lxsS zIEPi}6QDckpnelL4do~Mq@a;fAk@R@oF!QR{|14Q;ow974OF9@@iu{*r(x*Z-@Y9yvU}}PEUQg^@dSUDds(4ZOlo!9I36nav+%N`?5T&uTw@f7?Ebhl z2%Y{&R8T)QHcdtaV4V`#HNPt<3>LhO(e2N#g(a!)iNWCZ7gI)c^%u+`Q419RN&go8U7&^oydG5Y zHx~z#h6VmmlR`zezD0rWqC-X5V^&7q0%D=)+;H(7c5WhwB?xrYk4_)>6P> zFS-$(!`lqxQP}MWl<&2lQk%t=g_d70do0^7vmd=OK&}pL>h}6&d;)VX<;~EE?uYJ2 z`~)K`8AG#!MS>In%SxGClj)E${;pY;fK~x(GX!43{3F5Z)aC#!DH{p{Dk0j=__(;q zB*z%!q&4}{n5AorHU5#hVY{Jo zCV8fMCT$tkkjf>W#?PY13dUbB02h=Rhd=Mu3Rs3S-l0zBcr{uy;wlAQ{*w`Uh;+#IV?}y=>6LS#e|*& z`2-`zBr6e9mH5)$>Gf%{z2?C7z(}z#Vo_p2-P%FWk_ma8RPwLYKeesN_6qfm$?eIZ z(qv8I6~Y%T$;A(bC#)oR3`!104uTVe%g5CO)ZeSQmNk?Ks7RI*mBW{tm6NG;6z~B; zT7Ot#nX63X#fOuXeY5JbqO>ZXK`&iVPFJ2&25aD#9jgLMgo<)Yeig-5)atHh^p(&` zPD#dBx9Fa?Z^@^@M2gB6CQh_ktm|0m22=w9NqdQQ@#>OiziBU;fS$Mp^$c|njf^-BO&@Iv ztsL!`$S870ia`n?!j7<~56~yuhug=a_yLC>r*i;0eziBH7d;#6hzgx9m25TCrL-V2>aeh%k(%J?6{D|z%)D4hSU$7YXr`{u=g?>F+Vv*(UhHA;A?t?tF8qEexm(^R z`AFyXtq7Y4<~R`|jCMd9Og1bbY$3t}b_5zaauuR4*+;@S@<~!TBz;01{9DRlK^w36 ze1{%~PwwVl6eMgUY`>cnNSnxRh$MJSrj7eR{Xv&#N$MFv?U#?8f7k zuszK5t3$@&9lb1ptn<6&#J6c1X=-U)edcFFH}-KpaZK@asxYci1q#JdMchTdrq(9k zp=`i01XigNl{;!&A}f9g>JD)3zYyGArxI3Cgiojy$Y+TUODQD&D1Pd;_Ki8YBCH~M z0c$~#*O50cgSe%yMc2`A!(;QIfv6*`zLnFE$xr<8CsAKoS>yQPbz|nf^DJ%!vB7c2 z;|}~Rvf4aw!P03HymNd50^8KC*4Ym= zQQ1v2ehgomTw~Ma)vbQ`a3j8eF|~vZxU^|n@^wIP{rW)~^lmOwT7E#;O4R4&UeGp+I~ZyC-4l-xj3K8AzwgU9O4np{VkOF+}74d|nQC4?1p zZnZK^JWb!n*r)Xe#^bUitB1Ww@p*CWuUX_#Z8RY7uU?FL>zHTE9}-af4rP7?m->r}|0b*TI$3cPF^*qOtAF>>W(k z2z{A$_UV?o^NHS)aJRO=Hc!?Y{Z_|?{j**>Dew)`sOG4iOS|VS(Sy#uOWQsRkBvRo zlhvKIQ?$O)km6msZ4-%IBbaqp&~54RDu|!VjTL0N(&5YY)4<-)9rW-x{}^z$eD@0D zJ$buF%B92J#BF~{zoe2$c7l+)m(D}_gni@-*B9mpg7EeNC_YyfA)FU`;0O>96<>f( zn9V2mCeQV|)y8ni+)ickkO4XnyEBc5>0bOO`k@-lF#C4uaEy3eWxdBZ0)>9n{o6WjQq^1_%+f zhEwK5r=o=RZ<27icyu7`nw`f3RU`}Z@? zJv@J6Am?+NzpgLhf}s!~zpx>vdk)M$Pos?Iy!fXK-wL@0C8{beD+{@*8atYr+BsR+ zJJXQhTtF(29AvbeprG(*o=<4m_tYnl{^u>#w4AjR75I$pZCQ;>>_3{ay4yND_X8#1 z&Ic*lnmQX%xZB#;Iq|s*QvH5{4^n=vW}~9`{fM)*AeEM)GKILkqbUV9D?2MYl@Kxo z1%-g4i5cH}38}xELw*TTSvWg8@UgMExw)~rakAPwnzOy;<>h5#=V0UDV1Ycr;^blH zY~;>j=k)5YPX6gf!qmyw(bB=$(%z2ZxnHA?_AbtXR8-Fc{rUX$o~G`W|Bhtm^fy@$ z0@fpF-){Xo8iec@CV{n;fhwDoQn8^ZgoQUVu z(<-l*>lom`t}gw6_LzP_b!#})V=IGKb@ir?=5kvP4h~M+mXk9*ncF&v?fnE_PvUH= zT$yfL+0Rnn`Glq=6;#$=5DQC(@^3oJI$)0&A#eKr|mF#N3KO)yC(jr zO-Iu?Lu_|CYzpY#M}P^1^5MH+Ep~Kj5t#q+F@Awq65OWtW_dI13_H;=ap#JA#yvTt zSx#?lbqlY)L$RqzqfLM5!aG*RC3dfyr?91*CzRhdpTEO1U#3117Z*2uaA+tTpUpt8 z=+{g*$8cf}v(urL@^~2^U9oiIP-Fg(dPkdD8^+7za&}R$am}AMR1ATFyHKRBPgVPe zlE3KrzxfX6Q|dZ2D9||{)30hcE?+(Z)yc`>Jp$ZM%@p02B`-hWj)M=En&dTt4|1^t zCk|cF?C*JdU&cWp#r!_FV4;zBhy(eKW&h_K6M?yu?RrQn7$8neJX=|Aank(0Kk9-v zjzP@L?6X>-Enc>wZeFtYH0drG@$0YQp1(!j!n_>+`l@IB4+H)Og>eF;W^(7YNkf9S z4nHGGRf{!dXo6g@$1%v3?Q7Z=1!p&1BP-;o-C6#o4>I6)F@Km_EsF`Zf2;m|nSc23 zzpLTGgE=yvT(0{1bbUT1Y?Yp;gS4aG0;1I~8*^w|!I-}4Ymb7J@&EgU z_u~JjdJ$wChXJ}OMzA{P_Gl)SJmW{K@iusj9jB6|OreoYNAo^MoLibd;uqkKo#QW* z#YKqs|H8onTIi0q1l(s`LdE~Ft-m^OKip~do!=p-ad(O1x#Z6+c$L_ zL?1#6hH7O0;p-m;|Nj>#8WEenyGXS~ks3an4Y4u3>J`ZICtJHgE7#24b#2KGeMvAD z|7X@kd@ytTJB8@a$^KtvEQSwOO+xs+evppe#Ah z`hTM19(K8Eug82W3#`(d5{&zo+^H2l6wGdO_UI4)ho+8W!qVs1Bkr}+{X1X(CsF&u z>E8uv;b&QxDl32Dbvjxm%>79GUPRd8XBRhXsb}wIlDL@ucjJEv7>{`#OXjwn=l^Le zUg%_Rs;UcBvyrq$O7fOJ?#GpckQ3}@kK=S`DUH@GmDN>P| z`$p0@x4(4}z$5J-U>xyil~EV8+;)YxDE(_w(L^DZAvkB$>yPFAzvo(vh!vKM(@>1? zpFLhbqwCP1wo)VK^p$5UqP`JXhQZ>!=7d*(TpYC~0o@P28e*OqjJ-7*AB3k3` z-p+CL=q>*<+eE_9z*cQlLeSQ=^LxSh-LlLd>Y4iJ4Xz6dNwY9S;Ss10#jVJPOma?z zx{Jsc_@c(YZWN~s@5^Uh$sbGEMK0kw4fB~C%9EfxU(DbnXlf7%23QUyCdq|9E|qx- z?jcbLV|$eO3=c{Pm6FkN4p|s+*sw$lyxP%cCPh8_Zpy_zTP^>F{Vn`gZ%6SLd5akJ zhc}XB&FaU{`iN&Ji_vn?SNRp~3UYF4cPcu0i-U1LVhf{dU~`N|hDI7MDqXY6`by1w z%A-39?N`j4tBvd@bLf`GPzks;0-qh^!o8eqee`dqm>lvW|Lu`tGd8C|pG<0DW zT|mt2P31*XVS~j)xA!nhK(_jLIy&#mdu0TjWWrzhzGTA`nDBwa2rtBBAG8umVmeDo zWB@h`RKz^CvmmNV^WNCcQg{fD5NBaQ1RJL=V(<4N24!K@O--t)?OA@^CcW?O0^LzVlVx>kp&$EDlp zVSV^liunqDhsXk*wM!S|L|xajNmj=5uJ?V5)YtO=>egSXyaT=f$UQ7}68spR2}oSd z(3`?DTS`_!fdGy{%o@IU1?NLwngdvSUFpO1i3`EpYD?V#?uDYy*E@a?(ZKeTz9va= z^Y{BB6=`?@4z~BS!kw92t(5)6;y~l8dc;?#m1^d5b?Qu(=&u@Yt3A%Qq`n`4=3q&K zr1_1W__%O7SD8Q$3V@Gu@xa+=RYR!A03~^UBx>F8@IrT{M_bj*RkMY5k8rGo^bh0o zHe#cruN16)%-vh&-b@Q%Jot|&`fB4~=LDQS;b$lzk4ymx7_KQEPV9F1x8cLQ`FBjaYGXi*wxNGk@LebCrN99dE7ut{T0Hr`>FrEa}T=94U@q`Ll zRLn}9go05=M2~!g-3o#Jo$5{U0Ne8&-EcKfE5q(ZrJd&DXg$RI+vT4MS-)j(_5&es zy-8lAyMb^SQxN*)OH6UIU4;x++a;NO?prot5bOut&dTvrEBXYc>023Qbd9u=Q_G_I zZ5x!{X0o8+J~U#Jm0Ps;MMjGsyR^ECAR-5iEh7mtK%L{J@u+M0iqdfCQKQm%P3;`7 zubYf9@meUw@ByA+f7c3&6!+b5MrBFKg=s)>9br}M&vOE+a#zhDWCq^o8+G0Muskrb zw0MbjJ*v_sDc;=!%i}tKm=t@(G(IkVYTq&K!>rw`RN~4>Hyi2y>NdFEz)&uA5)7-o zpdxIoqh0D$JPiHdDVy^eJEUW*-zz8|NT1eOET;p?Y?ehqQo!Db*Y&q#wVA3?h@16I_jUtz7De)E$cQKt0tGvA%t10b&F3R5Tb1p zSR&s7yM=XGm|bi@28%oWRMIRgsW83FxbKaU_99ptcDzmZz7hoqKj!{qQyHQmZiq4L zaIH)zgTwLu&TtYQMdK3-g;YQrV1hZmv?)Be2C!YSGR|!b+ty7-=AnHjN?=%;ICMrp zr>M=F_h!U@(5%bO%1jT&_^@(%5zLMd7`15L^Z0R>fh+L!d}CFj zk=OlbaBn}(zyAHVON)%~U%8UxFV$~zHOr|;tZEMBW?JfuWUfyoftW)gB-l%i-qK?v zvrF#%upWXRhD~;vyGk|+K1z{?&;Fus?hDaGFuxd`ohq>QBXK-EiX_5!>PcvH|01GaizaF< zDJgahHQ@1uM`G?1z`}RI_P8&}@EuVu;PC!Cavo{>?W~^9b_KXHPeAl`Rw26c4e9Ny z?Us*r{;fvE_*{$+dE(4bmDBd9KD5T_w$+cWPP*2Ws?uDjGXjXEWQTsqTtgKB)1=yu zep_q7roEtjds;Of{jueS9p2Ei!#T=coSsdz|0FNC4W7KLf;r?NO;+17)wQN7QN4UF zWkDoGMUv77^BoyP;VocciF8DwgNYdz4jVr%7!W&qw3-kQA#7%aswSpf9;B!naGp8P zc>h#K_lr`zMxIA&ubDXTVybctyGOr1oEH+im)cbVo)cybSfw-vBUx)@p+$lkb#j}s z12B1hQvMqa{gnW)cnLdx^i4$SD>`YzL%FS?epIS0NGi5b0Tx0T0gPyelrO@)Yxfub z9+g{^8F0bSaJ7EhyV(kDV^p5pr`L)4WxmpZj^oGvpm%5sIE6sk6Ow7D(BeNHVK3HS z5HN6hIG=+sv-kXl)0hqkk76@u#0%FAv=dq^(z?aQ{ZU0gq(B42&D=&N7M3?89p8uH zA0_fbPOd}y%Ae4ze(-0UEelgz9~{_38;oJYSL-(!Xjto_`^C4n&`)69A5$6E$A~d6V;R zf{=()U{&f|$}7~@LnA4Hko4f;;!UWt+oT(MJY`)%(B)`i(0G&7U_y@W7v7)4C=+gQ zw;JJosY2rH6g5_tRyfh{9)^?4JrKxz2Tx_+KV1lOtEny`ET9nPo&qb=B?^VN&BRpR zplr#M$>%by?JyEqXf*sTY;n?|VKed}iSLNq3Wu{udA#eRor+3rg-)XmO8TYFNpU)c zQ;D^E#B-SZK2by*X-Dy<8Ya+nQAXtR=y1)O$QET>c_qmqQ~c{#Want%r8cuDV@~z@ zGSRg|>BYA76+|4mbRZM8n|Tl!XS}Ahsc$BC8M`VWt|#Ar69Q(~`72vy-T`L_z@`rK zH)M-<>uGpSd*iWGX6kTi_IxQ6)oJ^X2rIKFowbjW_w2Ai{5(TX z&O9mpGNX(S1}N}ePyt0NLsPuF&}w|n5W{jiSn(U3*cIt12)VQS$-BWz=q$Gy(T5zQ zP79nC;XuVL_Vf*+{mE~2HdSta_)-c)l$OGl;BKq!fmva%KO=Ih0k*E+8YayxbxKcx zq?KX}6Vp3h8w{Afr5;Z~`T&oPJi)5Zm!7JjRYuV5agVawkWm}{s}+ye_t!i>G*2U( z@2=&pS zKqmfZETr;kqNYq@z2N zrKV6JG6ilVE?JmPgIvr3r4Jw+RBlK(8M!0TS0m2eOpv>|kqxvT%mhprk z0libed!x3(uD^s>lad+6$1V^)(f};2zvB5;=8A4DfP3+Wea%{)H6U? zTJ@Iu1<R}(0n z#I zUvAv1HH2jU6~c)4VAU*jYJljLIxl-O!IThCr2=!g3~o@k%Zl@fD3%n*)N#Zg@rp~zV`?xkrgc5U09+sjD>;vUP;47G_3j$kC( zep!kUH{F@(5=xEh2^(7<;eQ?gc8V@s1pIW?!_o5wL!_;FDYvZB49Brf| z>P;deUtn_r{y>8CXj2{5Rx+nYE?_?)J9Mz0{wz0l6+fBja5=T!T!~wSM4$$w%4f9E zuKd9x0yd2gx?Z6+jIK5V?)$lwm6n{me4$)&@;6sU{-y$R6B$=mfYg+&#D&%74lTfi7_i#eWu-+y49@TA}7qN--cFm*;QPb%5Kmt8VwT4ttI*2h0-Za}B?;pTuD zB5b>EuBqBO#JJwR=BjU|2<`uiEw#{rJpkAvNIwgk;y&RAD+q&#VniU2XqI4%h;&`H zsFTiDdhO(%D{z|v{Urg!$^Mn>5g|dmewH~>gn~ZT;)7S8I1gGZ1PLyTdFnIfy2ujgfDE~*H(no#f{!shW*)2wyN)kOub zUzAva-sd~8evVj8cN)bx2@;ni487jq;9vp7<<@0}(Uq5%M{M4d4VF=mY&Rh^q@dum+lU$T0=H+Xik6^c=clBHsF@d7o`aD)KmN;ncBw0bMwcxoP+% zv+A;zYgVqgal_L6YsvnWH&z&%J6cU&c5VnFEmh3vyv<6o1WlDu?|QAdQD3LphK-4` z!;wK$`EL+|2;;g^ksoDm-+y`-{39^OYgTiGeW9=T(EK%HWsuVeY1e_zHsEuG&*CR~ zqjb@mul&60o6EDRN0|83OC1)o*-l=q$jHcbx*KN65-=m@)Z^2L&Fbu$Iy$rv#2jFt zsXdUv7Ja^Je1*AoK5%SvsC>rwUnC5o+;m+4`v=Z#(r0WBWe8o1wy1b>Z}Z_%S621tm0fzM3A3++!jbmu zP{mr!3r#GR?NT+Kv z?T7f*@IB|fZf@#6BR`ab>y86NODZau8LH`%gTnFTTZ-PuPs#n3uTlvL6&TNiCwd$d zl*aoxL*N-XoaH=6%hAPwBN3(1&+Mur*o^Xu?& z?ScOY)IX_QZ1FC;;+J?9OFT@Swjda^^ZE7Y;K^Q2eh~Qa>J__(UkeqBoM*bZO6@(%90u?IrI;9j?v(#Li$?73y?Dn=n*$t>U0I;*I(2VA$+!t-7ZiV* zuSl2YAPwM&M#j-KfZf8P=zEoo`R;>3s_``rMzRUS7RZK zmHT&&2~RCs3QNI^LX3bK;s>bWx;i<}i+KYbF8f`&EN2dOHXkiY)2?DDwq^qohiO7R zwWVhBox5O$Kmjls>M|Y}7uP;E2qjrYN~-m72=SuN=eGmbfeFPNPd_tc`FTmtJT3aT z)p;hIbAqmqJ{K{FPPI5_I+A;8(~dMBS;1~Nb<%`#nK>iU4qC|jm{|dk;cz}90@nX} zeTMoEC;s*@4_Gp4OZbOnoTGfY!I{o+wYQJ!(ZWBR8)1O&S-R~P>Le$pCJQ{y@g_UP z5uSCa^Wj!5TgXRI7b$6X>Ox>q5#)Ow>3w&|Q}?qPIP5YrGc&0dbX|F_D-V2pFx?r? zt?P;6mx~R)8DwG`@;dI^f8+g8RYLFfYM<^asc$ohLsx*5jNjAuyNzOUUeu4AYmmi7 zkq2xGh<6OVjiQhy@*=k~_C((Uqphv{i66VMKCCd4q;3eW&hG_>y5q%{`d~Ww(&R=_ zV0nDuLAyz?;Un14R9K9r9O!$#s8ix*L) z@Q3Me-{;<)tt@w*{YEl8EgGO2f6nG`IM(DM>7t0=_e)PlnV@t2x}W+-K4DB?;%1`t z?2kIrp_xHdyC2#*-!#tOY%my&n5u|_pI^6%NZ8;?+4@rW;UZsv+cK^~uZ3gHC9};r7VFi! z*w5%fT3e%;OyFe~^ZET&*F(m2R-hilu23rpUnaC)ZV_Yk6eB##R|y+T=`1+m$FYph zYo)%sf<>p82vovq=S3;K&+wOoM`iEsfXX$`*o-J(a`OGa zz`%^Dua}IvX(N`hRDTzk?+%dH#$nKT&xHTz_3H@Q$k0 z2{X1Kc==y70J5qrMWJE~%8wG#>C2aB;nHM!Z+IB$I1o~9m&S{$_aPxg# z#n9Y~CJ{X&>>%7_ZZTsxPp{&hJ;sYsU>0>7n&#L93(f?EwDgyjcu2 ztQ82{AkyzHhqDS!C^?pi`>B*>L4D^G!<9pT^|uqZSc8qrwF69z@(;B(TAS`p7Agwx zU?<wHg88l>fvzw~Skd$_-`7@{$#?iV=oqp(gk1RT9O zz1bvR`Y9Nn-BMpuLV3Xr^wh`3N* z{VV?v7bYSAccHGXuCtXaHD2W0IDDoJdSV#umU(u;=aRvO4cx=6;FxlR513>%+ z3SOG10@s(_KYILkA*T~b%NE38dv_ILy~HDpU~S;NYnsYw4p??raZ#Z|2^J_40Jk&i zHON!}uhMkbE|($e1}&GfOD1=LFfF%(OeU-C9!BfzSCjIaH9hFbwfK<}(1SNd52wGO zG#6KZ$$^*Lv|B;0Hr@F{{3)-DnLz~c-*Ui312dq^)5GYj6^UNn3UZuMG&5}}NfC^a57^y5%coj; zOhQ}A73@|8xPJ{z^XgqIag#i&0~*;p*y>Z;Q50a0{?HS%oUTMCO}C=-^uc#e9aPX*n6`aYrDpaq48(Z>!oZo6gr7Dm?GSO37` zzrZmBG1A7A0FJSw$r$jXJ0$w_-s<3$;O1DYSQclq_9&52z8d4z)u=WgJv60!5dH2q z)`3&tb9d!9k%D6S(CR|@kn00K@p!Qd9DD%=kxyb^JTJ$JaA3(4brwtbNPpbS%#44P z$?p=!ZM!7rssS+BFUw<1mXFL!D2uJ&SZKG5uh6O$3kwf7M&q-5pqp}vX^0_s{f|O? zd{zk89iy)Uh3l-G8?~)>BRnhgz{fLroT1QLCA+#Aw5GDzJhVnUQ4Fz)n+8!ASP!I0 zEcWQYI=USZj!jMF4H)#4do>?xx0xmlE^HswhWqr=qb++~5K$AjS8(->#fPUQeLJ^{ zA|n`%pf+mAmJzj`2$>MtyQ`zZ`qnzF^-utZ*A?=;moIG z6Dy-B=2x%AQNX{^b}8a_d68(sQ&XKS@WdJU>@gJ!T@s_I-+NOHoDhX;wu(geVgKGi z?(^yH+{Q%|V7=nc+7HYq~2=!**@l#WK9KBr%vfq0)-4&}btyI{z&Hpfxj&}PnO4DPQJ zbN-3DzE2N4#Z9#JXqAK)@Z*L7kxPf%!MgI0n7g1rqO81peUOT9FW4O~_PE0fJUdVs z+u&Mz$-`^pvb(6>>UPX}xCr3Hv0$2}KY|Fi=}p~coyCM0=~p%vPo=WMowHH}O}T~( z&mGS2;__;NFq%;auvFgP6)ZF@Poh26sMKSSPiBpz3HfppDFoa~cN1KNfHWfwUkw5u zRTCfULr{y%sm%0^#kDvntP^8LcfAMX^40o>zb}U6*Xwx+nuuRLiZsi&`zHE#Jj!lHVXMQU)Z49*)?5A^l(d#ano?Xj- z9v`qy06tAq0Q>n)r6KzYThLrlC#9j!O`*WmPC?11V`RBFWhe&l{7V#DM%@H=cg>nG>z)}Jhi5=UH?YBa0VY2-*NcL@EQLKbKrfn%?% zh$m5V>VT%tv)roQh-a%K4<>4K)sQnjwC{#pe1Rb#<2uus<=yB&J__+d1IsObR)SAV zH)B9x3}ik2%lYDm{`^6@nSI;k9KOKz>nbz*GnpGg>&;I`I1#w?i>`Fh1eBiddB0Vh*CURz3dyGjI0^2D$DM=Hh)sI;dWHX>u-o(KpDwoxOxK{)BSu zGK==`$ah&uFMqz4V?R?MP=U8|Cv@o8CUv{QBI#BG%S3|QujWWdXi3|en0T6Ln`8mM zOS{TiTBg9V8lZR5o)fqrZT@|8Z!(%d0@+nV^aDP^w{6J}n-B&pB zD#=T0l|G}q^d7@aQ9nBW>?<;P(ogxuRz>|OgQfim*{OC9C(dwT15%9I?=;u@du^?$ z$UCvg_oKHd4&nbb7^FCTPI(<0bSPvS?sO_Kk<|ixCd_=!4=p)%W2F^?=2^Zv4apLR$G60G2>~w<2DQzzj5L-}+fUk6wugX^mu$#8FTOcsL-HClh|}}n z0%HM!{j{e!!%vXZ8N`;obk>?^Gg*GiQjT%L|4^(G|KtQwDEG_c3hjES+0rhUBmv6F zZZJx@keT^*N^R>E>7u-m5ytLPQ#C4)!2H-eF7qVFrJq#l;HTT?my4Dm+Y~`3>}7u| z*mw!jwA%_ZQ3^qJ$HwF*M~F`%JTBCcZo68vHo2^FzC6d{wViKRcR-Bkwm=)pkT{p5>BsG3{HSMan$kcl{0F>`b054GE>z zAY0}s_KX3`vqNH2r6MCon8azK*YO%lTB6-K^&NHdW>NYy)dL9Yfp$_{d_%L~V*X}9 z^Rki`vh=J$|E9yqRt@A?Hqms%lme>;vRmQX(FMixcdr8Nlb59((@cMiL;IM@jFC+if8gIOO)}QqvMg#{t}ATT!eiE^Jx{u4;lyK3 zcpAx~qoI_XxXkX$sNh;Kj*j9mDZZL)GPGtmDCL~cF|%yfuQPQjW!9<@-5Oh<06qZT zJ%U%P7#QTyReb6XoOjza-F9n@@po5?KRX{TsH8PXNOrOG>H-Gp;H*t{m*3Q#fN?p% z>A=D~E*FW*YsB0SyEFO9<~Qm=HA42dOmA>mI~p8X52M;fD!Om|%I=Rt(7#*v8{)c3 zB~{0OZ7E?9-*9qFZdM0{D~Ns`fOY;2zAIqYD0A2*;9n+T@6VJMt7)hO(?1EuGZRC> zF#2fi4Od-{X7F;F+!Ik)$@&Z#EXMSq`h{%2P6;M#M*DRStkFO{Sg1M2XJ!ZOkmz?u z|Fa9`hIaO{#saRy2dN z1;qGV_Doo{TRsNqdG6BGX;)qr*OiZLQzY`fKKe(tQxK=kSD5kaFeeNJuCS{`@T7XH zNc|c=V4D~_V#3%1AFd`_;lp<(ityplA0O}R7hV?gS^CVOQGV!!oi!+1ijelh`O=;e zQaiWmbw~N7aKASkuQayRqt0rRai-ojKH>t^II+_Ue8eFVN#E6#HD&vL=qHBoeT+Bw zuxYeMwpL$N=%J8kZt}f+4?*+~9gl=ckC#tE-?Y};Zg4dRMG?qtSOXC6ho0`GeXoCc zamG^f&}rUc?67?$b!~32og2MgX#VtBPrxif#A0QhY@2#ufju085%c*o6csE50YKf=JHuJJi9sO-24oB zj2S63y~NYpj?{TG7V`@Ih#BFjy#Am@9^sSvt|PM*B)M?PZK*tFsnaFz%K6FMYFYh< zz{7Uq*#c1W2SRpb!ieOlc4sePu?3)Bhbx{^8gDR09HkH}+$tN?HtF1+dtNDrpvT@E zh|Y`JE%GJh=son+*wAKlH2y#Y7+=;>#ofAdVi_oOZ!Zi2gr*a#1LO^t8~1i9R>T%5N4zX2M}$RHEzMI`(!;~{^O?cd z(ax*GrF74S+e_jG)sL04ru$@7V0hVv3Az0iEy1!D^t@_i6!IFKWE)mhmhD{M?CMXw zj;@g8F7kv%s8U5NxH(z3GOKG12^M+a=Q|=HJ%}y0w|!-lDx9o?>M>xG?Yg*2>-n}* zB#072`1%8fMDnM9qNV~Ge}KIkZeo+<63=(+UoMt+uKR#Y0Zxy)W$$&gvj;Fpx)r~gVRoDbZu_X{AEY31 zL`U?uCn7kH_=euBI7cmX?8ppFhK6IJg8@cg{thv6VzEocTD9rF5Gc(%jdhs(K<6i* z+|4Q}rUImWeo1VGWXTl! z^>)pc@m4H=V=^i0ZS`i!MAit8RnI%p$y{-SYQKmT#q=wH_vy{{n<}!PZQJ5ZSMGS8 zt9d7-#JL-K1)m3()cXTY7%X27UPDx$+PX_m`Dra@Ute!$*wf)xh6=_@i*BHYjkNtL zPJE+HxC_dUHf-ajWg1s?Lu|GTjdws z_NXjbbi+5cerWo!#PIlLQG!^jK&E6@%e;o~`0DBpI2$TUWIaCN+sEcz?sH{f?pyYL zLt{GU!xHJ;UVAs?9^POxrQ#fx(5yysJ_Fw0xCCnsHUayJZVQw3+7fc z3r%!OZ5S4*t!Jy^tV-3ypDe@Lbtbuv?C>XJiaujg9WJ>hCROU}MI`H`K3yWGKF*5W z-1TqZ6wISCs<9)XKsI%waecjKVb`{=TlWF5o!<#Qelg;BpZplKRAbb!?A+s0Cj#g7 zYq?AGvuXEtgyCH}azBOD)GLj*)hguDa6hkcz7Dj!l1{azAQHHXP_@p8++p3(e|?z|^m zpJDMBGB)p}aPf!JdFDbog`N)TbLe|KgESi=@uhoU==KXIWotZ#H@@=1)HZD{?_sQg zLvd)`qa+@`O`d6S+yBfFjVqd4I+gIaTC$(oEW|gAkT>UKJ|T4)u63M#Ep1&t)g(Z^ z7IloyM`Kj`hAh4*_^9@)kh!$Q52Dsfpn{iI+SW|;8yJt1+^-$-&Qu0&AeUsFmjlV? z($Rp4Au6AveuJ0H5#_HxWc~dgivU^)sLT7xECAac-l^T4>(Qj-b1rV#b)V(zkOw3o z31}nY@Yvfm-_XIW$wvh%KT!u*=@3TDb`t)~=^f>X+PK z1Sjkqhj1RvX9;Zb?&kTBv4?!>vn;lHIs}NYxh(d({ha70PbL%eEK><&c<)!gZi}ksey^tn9O0AaRA07ZzCA3dhyjn2A z`ui?5fUH4Q9-g^~U&a+YSm^N>NhP^c?#&J^J=%*>KO)76p+8lOKNewM@RZJ?gUjXp zRPAS^mMhDZH$5tT7<2S7u>q;=6*7q?F(niuJi$k{8e%(BP1SQt=Gne^Ocd`f_Q}t( zY`P+qZ@#?#mRdG9G~sQfAx#><7OjSn|1?7rZ557mSY4duAw@Uq%;Uj(mG|0AfM3tu z9eC6UHZYbT@MQ(sWDKYAa%O-%1%mNpNKF0}SnXZIdbAm%Ml|W!zY8 z#v9_Yn1F`ebKAN$?oP2{ zrC5u*Yq1tD6e;c$cXudOthhTAcXx;4?h>5f1cC<0m%Yz9@AnUKB~PBY<{0-FD>}b2 zP3YFm3lvIX&BAZw_p)|cohtV7gmTbB+03oyYAbgAci{Sxy&El(czWgHDf+w0@4p^U zi1J0}%iVAPQ*XSb`)P7sc^t8QJi;XIoJ2-(a<$gDQFyIm0!OLv_p!XUQR&s$76kE`yrM`%Ch^!RB_ z7qQZBnwPxjPIY10^+r2&)7OEMQO~9eRb9-NTC>2|v=E%TgXGD8>xTTBu~?33KP6$g zdCrcFM1R-3v$7>AS$)T#^GRRY*&W$`HPV09A-oK@weH&Ani0)4hJccQY%cI(eB9xW zo|Eq~Y^I6)|3OAx($wr*dXQl@ap*a2lt@CqV>quc_5~ z+tvEkpX)P0bk~AEfQ_Kn|L%1X2*g28)tNihq%FfMLto{n3F)%f*_jhHDzq^Db(?L= zP#kq2F)n-FS>$5RbVRx%9wv1C)$HM%&)rOao3X#rpL9poOH*IMn9aDzYG5Mz(%R4x zU_l0(TO@BdNykgm-mtiW4&XdKIqa!sCn$9j<}|n$E8a(rH25$r@{;5s{+;jB;!gf@ z!{ZWtj)AD+Zz`^4k#YqJ?_V(R0EQz=}X;V>HvLhtl&Mp5g|yc&GJ*wNko zqts$ic{7nJ%l9gPwu`2Vy)G@S0}3v)h{!{1rX1+;NCtNHP(ls_2GhbJJn`C06qS8m zHgGw2tH1PzkU8LP1@!nnJ54@mdSXpN9sCUQI!1Yo7cb&Y$(Of-Ui>w&``DT=^ZcuY z+EsAdfYieBm_)WD6~8Mx8@~;0cspp|=jHJixJVC0%s43`Z`J;));z8=V`hQEn_4J0 zH%>UP>Vh8%d!89CCv+n!2o7Uc`3;A2HojcDj1?FCD4Z%~p7$xcy|X5os&IR5v~H5E zNjbWW8^#azezqv3Zh9?saxXTwCYYx${NB8Oa4`Nfhvfx^YK}M75ZFX^FT+!srE+7? zv$lNVvo|PFSWA&l#=o=C0|{tq^%``0aj@=)q*(&RkibS&i3mK{>67(EO&G@&E#`mO z*;x{Ly0r_B62^@M!_ODgSW`IeCa3xa%)+4P&g$@*9*@_+tG;Hu7I?!Gt4uK@LbIcK@v z8s!NQIUbQzAejyDJ0G)k7sQ%3;%7^8@_Hu-sL|Ex{h$f|;t0s+(ETdh^!sc0HF*l3tepp6rfpXxDcIdS`*Oq@>?aNqVV%AF2m^GrWWn=rgGyJy1G*(pEebY^gGNdxar%|bXS`0Fl<8y9)N3B{B3an9( zwQPBh&+ij$xmthVcHvVVcNvj*G?MFY;cguCIx(-3Sf$${q_XTqZu@S#_r%|^aEkn6 zfSmC$VF*ae&?UyK$nr1D<$PPLL)FX_3&~Aj^oy17W+ISFyHZi=Kcf+Jemx{0P2%gE#vaau5xp6(ew8d zSAMAa9qyk_1J$itLn6Es_rV!W99OntTyI%U*V5%b8K?kNvn{SC{SaA1=pxUKJlI__ zWg}skv-Fx<(A$gT;hEnPWa9a|@P;?B5v-?wonOrIJ(GdZ@H->m1s|YHEBun}VM{NZ z+mvnAEean|X^!}>y@}%^DXJes5)Uv==gPOqCuU`D}m|)Eb>sUgRH&i~m zR(t5r=BoK_wyAPm6A>ga$Op?7m4t$E@og^uip|0_@z;SR0rZrX^5x- z;{nV;vq?=LS$Lbkv@fT6VVL8M##eu6b_p-Ryx%;}*Q`VpEx)bfjBA;G`qcS$)4g@} z`Kh}>hkmioegXRr^sYm5Uw3ibV~Jqq^3PWpyYCg#?b5s~V!b;Zah7;f_nlUL68E*x z=cJF{0L7CuxP5uMS{5kG-Z}4!^#$iQh0>QBa1P)d*P*No1Hf4^Ky_b){{v; zS`N2v5f&S4o)mRLri8nrTroAd7)0;VTrU=e_G@oeS?2nVLorFx=t+$8J2OoQFc9iq zwtS{VuWy$PA47dMZ~3*CHWvvq&;WiV#K6ne&1n^VcU5XpuR%0gjuE~&m}mPK$9fh{ zU~b6q^hxmgFYN?TN$lUR~NA11kzH}olnTqy&Qo%kc$@0bf z@jz>Z>RDi&v+o5z(qgSzf?~3ps-JFMT{i2ii*EsCtXz&k)IzgN;@utOK5E$M_1TL{ zB6V-QuVI&{T26?`O(XE@QFaNjrfFu8@8ScfetHXHO-juDv&HI$L0^9xkdTwZfJ)){ zn`c=AV5=zrjjz7AS}BY(;VuZtvuxGb7%_u06h_GZet?T0fl<}zO>67Ph)vB_lI!&6 z{#nb=|Kq(hHST;WE`!sz>ljoL8L=VWzsPQL0W)LA>*3P#%e zskuMO4frMRNybD$g{frJak1%!FhttteCnmc?$*vLRCXN>eVNvdsrXWfJsvJc?NUkM zKZrl4gL;FwnKGGquooxB#XJypO56KO>rMhvn8+}?oYO36r0urqQ1L>XY9(BlDi?jd zgG&APW?BiIj1GzUC`QPT<10}G?<&sj?s3oSdtA}0z-m`5TWUW4oOF?)Y1NQ>v$PoY z?gzab?}9^kg--FbnO~j)lxw0jK)PoSK>8t>rBhB!XLhNhlV#I~Mn!JcCK%|F z*lgk@c3DnkSq(ee_^3dHEVl+5>`7}ZL16Bw-|8yDo6;nNhwM}?`LXLV;)e%{x!H%k zhK)zCV?0-NpgXf>9@8A)Gux7H)Efh(qwM1dEwLfyIO|^?JV#j-0oj$ZYz4g0jsr^k z<5WHuAAu0T;b>4;kFMV#kx6{SGe)k^Y4oVdVhheUQ>XN`aO-2;Dwnz3{!b{WISL2`1nW^`Nn3z7m@&c8&0lEIy zksIQmZbwN7rN{7)w;_|+Qst_3Rx!-oOtopYafJFu@pxc9U!>3pvvOyS@Wu zDYGuu8RPdh%j4PNuWY(w8XHt{%UtYA_JS>4XS@PZ@(LPY!#1V8G9t8lSw99Qx=DRo z79g$8A35yVp@v|A?YPxmhw7ZEd7#unQekjd${J`@uRC3Xo?pDffRDt70Ux;P**ekb z`gjC9FFMCrt#?~T`MB)av1sC->{BsJLJ&ppqOsG1Nm=*ZyHk7Ug~{k^U(a}UA?WA9 zBZX)|0eA55tB(h(~ z{Yt6*uiHQ(DyhWXu4kkTq6eX=F>d6R9}?XJ)A#|N`p6vCL9hPf2rue!0|+nc$__Nm zRcV4MNYr&xCV@MnB~?Mi(;5;10Z9nndUm4jzZ;B3=((F*cy(no)1Rp3{+&wo|4gNB zy;DN-Vso9og=<5^`tffN{&=es@r4Z(x^B!`9GtJWck3j7 zBh+R8ibLBfyck)^D#o>+grr#g1%(F)C;>nE#U+J>qmjM$R_#*O?QMyHpbZm-*7WT> zvhcf4U!CGbT%m~91GoT)aWMVl%``RZ_tkXo4ezbg^5QT|Im7Lv%i!5U4MqPXkV%WU z>U01o^yr|=1F+bP$?&XW-y0ZYJ?T=}lo4|DDxlt2{F#wC`ucP~5ZPPAR5S7<0XpW zkU{`lJ76BI!zm~50r%=2a@mu*?$9wwuE|5LJqBL=I88QQqRA%BpS~TIX`is^K14^7 z$mIeZp$^a!^Mv|c+R@01pTlZ!0rKLn{?!O1EH)%nAsk0R;Z$7a1=-MA9j~fiC+Et{ z5uOZ+Y46hTY&)3jJPh-)qnWiTYjHzgnr_CFdp;V9dL_s531;Q+coh>P_X}zlhqg`$ z+(KJ*(4Hl#){roPB;|oy{(SwR!~bitnc+eI?{48on=T&ybsG zH|K4-OOPu0W#@gjnYHl8gn{0>bEXHVhf`nJC9B}Lcl_GD4g00RT_fVjyBx#A`s#uur%Rs1rlJCV#Icb{_+chgjbc0Y6l;GPR~Ud%tahk-#UnGPLYvQgn2{f^l>BL*$@Rp>a( zPD*~vbFCqMmZv2BDIJ&KF78)L8N9gl%XZxn%$W@#LW}66%fs!h8=D2+tD5cA=$2**E}wY zA)^5s8ga{;{ZwvmDV+)&F@R1K;|l}*$49yTZ$x^zoL6BGIQ!0ha2FQX}3?kq^ z9XE&I$AaK(`4F^T_CSI3C+Ppz^I%KmiJe-M-iSY34YWULs3dBmy?1B>p#-^s9qn7+ zN(!BxxlC9^2s4&){((M2q8zu>cLf+A0}|GDj775YX07csYwhC;*X|;Eo$F{3>LNKZ zr2U!C8#h~b2iVK{j4%S-bcJsH810m10v(Jjxf1o|$#H(mUm<4!)Uwv<_^6Rti%?TH zpE_nID2zST7_$so@w;CKPzXK$4srXzFZ63~VFeD0yq7XyVpdH}&7|4%k#IBH1by~s zS=pxZdYr@=SmoL2g0^b!Fs8#Z(rjJA=^7mzCxi^PEDfZ3HeRUFs@d|-F$_58 zZFv6?T%{s@Qz>}AYMDDGO_>?HwCWT^5)gB0(j)|oMZ7hTx1=VQ-Kf_*`I zur6QJ`OOfe1*4|o7Ns`O-hgSdMlC%=!EWZX8(+?-3P0!ugCB~)hn@06=ghYfv<@=i|hP4QitXXGc z-NMlQcc#X?1n3+`ipm3p?gi}&YriT&bxQ0$PS$6P4=(>YXqu)mi_1NAav2`E0L=nSOii{r%y1_(7%}hsJImftVP3AxrU@hM zhC5 z3}|21;xfg43}1dCB7MKr_LTFVRpsBI09#d1Vllc7dLF?HbdlZlyaJwBW0DiVH`Atp zfaYEjU*x!jFbNy|;quzrnQ}&NgkAzi;2HW6LQl=k^N{z32<{UjH@5;Yn~vGw@hvDj z6!~e>m5gN%{0ie1vN!ODg#=Oxw`^*g5}vVitiKsjQeLL*LaBu>u@pZ;NK z6K9F=O=Uw-Cxse!%nc4OhoM_8XSYu4A4KNDR0wRaBuSOW_azIp#-?vK+sqb(wp}Wplt_i+1i!>&@-bELUW*?*9R$1*ItL>N z#r+Y12A5cb6}9azY8fPG8ThZ_tXZqk7Gml5Tg+=VyqS7QQe*5&ov8+zDXnEA#=(Q< zEnC)?8HSB+m*48f-Vs%;;AjHFb9p8v7FyyK!9Lx}c>)-OA1Lh4R-(*}B}(pp(@5>( zbdh9HR%sdfX&Cq)%Zw!F^T%tEl*-5#QQPSxHQ|2HMa#c-yAwa`98l78S2HOJyD&6-bdQC8aPUustdS>XrK64ngkU}GTmdDKEnlSWaU-+CR=GQ)v zQyg`H+^X-fuH=5JsMGsVTcj7#x_;3y3PWLwGzlu}x9y0geai_G{}*j|M})qhwN8R) zybKInS+&fesnD#Bj=)I#OT9Gew8uuq9597mok|0zUAiW-{~xwSGaCz3|Y0(iky`P>8>sDGh+n@1!S*nLlW zK2^(^b!c69{zf!{wUcj1Eeh^)1CGt-w|f0d$dVLYI}5O>37Id{Ps8}M6fa)xG9A8g zbZA3LT#9>iR@aQfDZBdmbcid1geh5Q`@KEw?W^xOQXsFe$JTuF$;~>Zyea)bS5+G* zid&(T=2-jrG($P{1H33hZLY^Fvh!fPoREWMGpvn5_(VFe#8qN8X9hk5(=gz%xNeMJ zB0Vq0CQ8ua`L%;B(mxa(Gnl0EBoGvrq1R%+*_nv_dUF|25&E~|leZl8QWA*)4}yzl zFVaR?O%FruVVnTg65r2rBXcgDe8qzP&<{{ps}RCDSVAi?(7$EV72RoC+L~1C6Bz+J zyq}SXh*DwifZJBfx+>a__+}f<8H4rik|$V@tlGU({0Yo`mQlY5?n@IrotA$Yo|tzM zXf!qsH0!F~jubFSmbsD+aA=OT?8`$LI}S#uxGc@f>&5>Suo77-ap}>3CR}z!A^jOa z<^S3O7YKu%Dl?5WYGESeQW2Kl^IqfRn;%&d>1T;<2`A~6*>*UR>U^MX^y?u@&913q z_QmE|gHM?(1~|4HQ}CP|!?Nc@{pVNb?KH!r&>2olF#q7ds+-+Ujb%QB{)mx=h~&vw z7&?H&2zb8lv7Q+VP@Kq`5ua*ZA2E3u`eh&YL;TGX`3!2H20H(-{9==vyV&C0ljE}B zyw0-kFFC5vD9ddp%TB~;{eZog`jQizZ5-i;yxw`^dv-F9bPDek1IF>!qAb85$HTL{=8nVE=bILO^#@%kws`B$sP z?}9Nw68}xB_A+OCR^YcX6Z9E3@_H}P(&bWL1K#(GOZZ=9TBzm_nJ7jlMiT{PbPqD9 z{ZrMj`Kj0#$LVqPHq^qvr3t^rl$dq_<)5yTBQo$YSJ)X$P(alFF$|lwKN>4P_{hAA zAWSg+d0XAwzA4YewLVIXId8TxkXc+bfrBq*b2-Pm1#SI?EGjA^KelMyon*by@;P*v z(xY@i+&(5kfmXMwF04sTda>vowpV`U6RtOfZOQ4E{V!pzYS&&&3#0KH6U}OkGpyp` zwX)^AZyX3ibzWBskZsA&dBS`9rMDpb&2X@P11q1qz^hLRvUgmd7!%BB5eVuDv={WL z$i$e=@wWIS_}~={TdDS=$`mxqBV0moM4GkI69Y9eh6M6MU->}F~S8|qIm>k4n5#yFH(w>ZLE)!V1E!oh012~uE7h%HSI-hZUtXmBJBSAe1_-J#W$3yN9)ie)%UAs%07kXor$J zbmqT*93AGChSZeOyFlLB_7XhHki;dsHnNN09K{JfeQ?Nt9o-Du_U9BtO;CkHQ!Irm zC)d8X9A$eTMfzf5V4BYr$(`pZIWvl0*ZN+AMz&0+utkn)i|mi!G}qD&wU5!bZ`rAQ zBJT+{ps9xb@tKRe1)^V;eCF!vPOCdGQpQ3W_OS5BWk{X|5AK*y?;bsM^IDL=g_AEm zuTM5!-&iH=7rzj)cY}Z7n`iz#&ix2qaHhWy{K#rOy5Y^RX>l8$=o%?;goFyw(QXyj zW8GYzre;_}(z$AR3403teDpp0+iYiB%>`Eelzv7Fub|@lHl3k^yZIo9VGTkfK;xMJ zcsCOpW>c-sT*>$2*0E5>JcbUgVZiG-vZQF;eRF~>I8D&zPjt@-6QmJvNq4Tu^5Mf3 zRc7ICGjmPrMhCV1z!Y;9RQAR?fxpIJsnhzr%XZ8RI*PMJ*go6Uq3o-Q`7VN%LMTjm zDH7o?KVi2r(v?{`3oJEL71YgW%HB2@IizRFVI_Foi+DfY)AP_z(E!bJAvRvUe~=ye zo;K4Anc2Ket9ka(my!Gs@^AF=AIy^o{o&rvTRhiE38TB1RMG!pC^h>I2pPRB`*zH+zLKDfAvq)xa{@_KC3NMF@v7XtDOF-RS#Jc4!7=t zCMb+}HQ2m%ddW&(+A`98lEAHd7(}H?x)7ROcCV#yxC|$lq0V>HY!u#^8Sc8s0IBJn zaaT4%dvIn(%e6A=NE^FU=7P+%&tix3Um@UzM7M)rwqaN}Z41wx7g=$oS#ywp8~(Y| zW$NxNL$AP$k`O%Uu8RO^7^&NZAkDh|aLAs@`+npGP7;0Fv~A5aAP!%e1Uzh%y>8r0 zB@%{bn>}ylTlGu7NTUNMmB4X}22J<7H#RLUCql#Oh5&raay!`2mF$9L;DbHzWy^MV zRGaexFcZ(?g!^=Oi}R7e?(GSWg0*{p|1ApqmnaRRS2c9wjy5!%6Fzy=&VKsklsaZ8 z6eO5M?le~B4AVi==Sgk6jduO6)2peHPH>LH>+*ZQWV?MKafNFJaYo2VDLu$Ml#}(;ACsJSzv9A9 zI0!p!?^s4xH19C9#S9!x&sD#t%*MKmGB zeK}mSCN<)u7WQE; z*Lt#8r_e%oi`!7_>{Op7f&YukFdS&fuSki1F;2%_#i7v2fqq%+JA?3RVSDrL>zYPU1X zLETa&z$ppYOKKJ(Z8A%W>_ZyZC;vE3>u#sk(%?MXxvx>AFvVHByY(CE3@y9gQ~>VC z3+s%yJ zICnb>YHGNmv`*J2W^}c8y^pcx8GMz&(p_B=(mnQ$RtN3zJfGO%eve|eJ$-U z!JcCADH(&4Ks;}oHJ)?4F`jOxNpkg)F_&qjSyoQXYgs9Q^T1#wVcWe?5MvU(U1gff zSM2-IbNNytR~}zk1bzE%M`WeUv_DPQj9n zxzvU$u|}?{ehuBZRTI3QXEPl-?JFntB%+9!@}S~GGka}g~UDCew~IO2WxHIv|P%r2m?)^>7g|d|X1N@EjjZR+C71w_yXr5aQ;{r_N)=AY=^#j{s%UBM3wA<%G8Co0Ts_n24X=4wrHQ6U2YURLAFwOA0-R!(B7a zLA%12F!4JD?!`Ah@!b2)+@RNNNNw+ZC&qf#Bd)Ok(r*3+Oyrb!z`UM7^`4*L#3};%QCClBeJau<*dQX~jxd zvFPv8;=vqGjg;WeuVp6b>-JqT{*RBAHK~~2eg?qK`Cj)5w|-&8pT-}z;+Gc)UZadP ze_R<%VE@+;|Ez}a1LA&j=l7&Rb3$S2%bJbDOz8)Gx#v3G3C{|bvd4YPqs_1p(4*(s z_b92^bB-A+c1YSL!MfF#;7#Wd*UZY*mJ zJ3w%sW9ah20~9GdcaJR<^^yGc2UJ98N~^6fT6i!#L zjm5a%DPI`{hCnSxhD0r#TpLQ>dQ|p?XiQblM8>Cm!}Qp@T~2pGS#YwLdLE!~fzh@H zeox?J7%E;)4^pa^s1k&7nub}0^s0%U*akqmq?bNO2{bC5?I{qmC%9SPw$;|EhLvh} zB{%2$zuc0zbb-zu=d1O7R*g$2u^AmDwA1LU!;isH=Zwk4taLpJT8faTiW-EjG(W|k z0uoxdAyT5}$*HO%M5ePRI8DCx9dY7MpQ+{|lXkMyKVXY{oQ&B(7t!;Y6@CU%eR5;@ zii=8vvBtk`T=V)yULtOE!so25r0p=HqGpZ=|4*jf5w-T_W&VqzW6PFrqScM?bojb# zCXwdmHbvX-oX=+ z*Jj9;Mq<`=3ddUHq^j8QpK-lKNk};+Rk4HQoZJYTlq|v)j4$?Ajffy$?8SRH1P0Pl zjK&2kL-GgRuV1SlxmB(xo*(vbw=`5_W8W5^ZyFDG;GY7eQ$FMD{vk2&hxtUmXj@7- z5t2?r!m(0JPDna{ zal~=Qc{D9PkRAKz*|~<+>ZG45Q;Fw$YS)sM*qvwZFa)|Hho@8 zuHd?gUBG1kkmeW=5Xjl=I9yip6MOjZ^36;@HFL@a|ISwJ@=syokuKP><=-Q39JCdy z+X~_R3v%&xOWo^mPdFJPP(U)Qdhe|Vhe}j1fYC0C4PDr1D^6d&v5wzTE8F`y z;+{p5VvpXlDBVu}{s~L8gu0N2Xs)Nrw@NXmhmP&I^QzT?YgYp8HP!0*SEVP7Sxjss zzJFCIS#euB>UJAfgI8=2u&L>I)kNR%v#!&JESEb{{JxB;wlp*n3`?&e!Q*g)yCOE;=slPpmzGHU#{p z43G+@H!Zfc%=muaa+h)HVX}rj!-**Pif(kw_Ro>17}z(NttIrJq2oj?jC2qzx~WNY zT_?vlDu-k9yEe9^M#mz&VIaL4VKsg2%bW(XnDBXL!@iI7EE-n-rpvUL?$R+=JW#dI z=VvT)gs3CcB5OqKx`cLR2~f$16PH5hrU7&0=lEi)#2ZlMYdZbWKoWwuaSWkQw=jrg92g& zu0Qvgk=+2ja>UUv&%O`_y`H}~dfgUaU|(JI@4O}=YGQIQiUbVnyQlwCS2Rp(|5C1; z*W*&l2tR zKN%ee8Qi{W8ad(GqMatEm!ono_4{xJ170uLwQTfpb`2u}cd9k&Y)|>B4&PvWE;!ay3U+eEdhSnscCkKXrZ2Dx3spV!3T}^Te#OpBHI*s(tfvpbnW9Q z-LJk|wY+>fd*14}9P`x2M!!I8dX6Tl-A2KsV!2mt90b;a0qVKTXc2bz?aee_Nm@1^ z3)y)pUL@XZyGGogUiPrZ9W%)U;Z&fw!lHD7zOeEg(mtC!>a&(bKAu6SVCgsVM;(>{*!i_2U}h2C}!HAYNEooR=gQg-jGxSUr7U> zTa9yW$0$2=Y!EtQ-be@kZB>g>F8;N}!e199a5n5ixH&_CoTiE zdoS3^z71XNz<^^OyY%rmCjLf;B#HFq%pPAD|1sV5Gc$d`=hPxs5A=d}Mjrfp#)0o5 zjMV08A>v0? ztVkiacfT`u?e_&yIWe}yK0$sT?Qs^$nv>#Yy2|a4_yEvK?P;@@aVT}f94(mdU; zQtz$Q7^BGt=b51|yAWj4*0M&5MS=13NKVDxc;o1y#2vn=xn+p?+)rH%&!W>Q{r$3y zPx8`^M=e6@GeK{cwD;J1&H~+yhFAsmE-at0&;{Z8<*dPMfLC@jBnc?Wbv}w)==4^^ z@zosbuuQ=+SAfLjtkOzzm|MSUttt6ia8R84c{yZls`C%keSDGiJ^zn)8}}WUaNfI2 zT(olQFTWOB%r>Vv0$)*&AB-T{ixx~sed9)04qLe0KHMcL>T_5GY|7~tRrD6g zK{?op!;pf5eN8w&0C&ac_n|1bP-nbSG9Ds0?*db`)|H?DjKCn`Ij4d=l3^AW(|n0G&NP83jOysa^Uz>oVClu-HHOaB5ff|Q-}o4=tY!INTk z%$Zi4lMU86g|5ET;69_Q;A#BfZjM;|2g7;1rVA`fgh_HCd26r7Gsy1smB8U=J?m!n zcQWPYNg>za6!NHnRJZEqwv4BI=b`RZaKJ>nC9&&LtID6=)lSA&a zhQrM*AW03+;CY&l6`>pDp+=dh(dj<~rN2R#=>a|280AfOhT>%Q`*cuG$O0<$=*{6J z(CPm3G_@%qM#2GGt|0-kO6ETlrfN!WH=~Pbm47m8RaYh=C*F~8P{g+>g;E0~>QxZ) zGnMez_@A=hd2-`$3}JRnJn68R~!RgnzVSS zp&PC@ljSP&{@J(!CnZjt5XqE=nw}?}?gx|5%iw8lZPMN0`esV=8aQ$fYK}icv`B8? z^JVb@XrWwO{ib7v@JJn19t04JX~iYysRh~I5BUuE`okA|L{`2>h!d@B(JBO)48KF>O;BrTEGV=dBLKf~!pF zE&Q3Pn9ipJOIenDRRkbnm4{g+V%=BOwT^`y>k)y%jU>1|uL!kUpY=#)l|^rPygDsa z{CboiZ7Y{Nq{d_|c`WmiiS{24EvS93y5Ay$?t?Mc()H7BPSo*;|M%7kLW%u}B5*HC z=mJ16V&v~Rifj()NjK>Ck~j+Qkl#bOHGLZaz=-3rtBtU1%6I9I_Uy>vRqB)b)I@Eit%*PUCVqrfNPQ0fKwgr}q>&Jr zSYoa7_UpaphEI3FFiV{KvTIbXpX?u{?A=8(VU~`u1Mb($>Hzb}j74{Sj677rx5YGR zGtoPt*>H?gKA_zw_7y7LtV==owaz$$eqP+S#sZ>b0zvaRm$BmyKMxpge7c~${*QMZ z8s80k#zq17h4UPNViOV$yJv-fxcKaMPmu^fY(&3t;(E^5whpeD=>}3@p(tu)x&iu+ zL6_}bc)P!|uN2bD7I^ z`=g-oj_Y;&eG)5po6zl*ZwrK|e|_j^@?Tc5tBF8T~)h3kcgVS&O@kS^%Dm#AT z#hSnP^k@~OOJjrlGh{yrfUI6e3`qEyLs_9l&a11a{VQh z1o_xucW37W+s)PGp}iCNN

>&^TmbI>O6VS%asN97HwaQ1nIa=?y%&NFaR%DkxBB*DP+*s{Z=@l(u(a}lCBd#wGBaF!&5Sv%&bDjlx*EOm z4`-Lf?kpN&eA=kzvx}v9*}W$`Vdf0z%%6kjL!HL=n^BekJm`wD<`)f6)_G&>LIrYO zYEtK4Q@@q8xMQM)znvLmk30dt_N64f)S`Z!ePB1dTQHzoIF#mwKCKhCU3I#E(6+zJ z=W&orKoQ}tJ4iIRo~n$|ogo%n^2G2`T{5QNhUcNh9@CkGBw_+ZQD5)rOAAH^zwGKS}ce+P1RuB9p* zv_B=rl(^Lp)r6yd*KoxoaTOr)Nq;JcO-WSbpAJYC?=_PNo@vrc-pu>>5pH4?(R3v# zIKMBR%pB(#oPH=0tHx4M+6Q%pQsLOB+yP`2SY}4wrQn8Nw_ol}&6hpj8Y@b5A!8CP zSZ2Qjz=TNEFy!D!jlbUl^;- z9;lEB{{MJ-Wq!N8aUXm$-9T1AaGpv==$Sm=wCGEk#q@4t$8U`4vjErP0E5ZEu+o0) zx`W$K*&Lj=BGPlUe8;E@F^a4h@)t98iNS$wZA)kegezOyuReXQu5I8zW7uo%g>%?v zI(zX($N=u;0X^}j;!Tpfo$k7US)?|7HTy6(S|tD?gFvU7y`WrXD^b9vz+_v&}K z(l|s}C~@G(k7RA ztIhZYvLKaN_zSCqr!#LBef9Zcm$w*|TULz$?e=PHKjeZZaJhGey8YxZ?Bl__ig>(O zmv@*+C+@07wU(U)ZK{($+|#g9#@giy-fx<&o4a+LBtnU4IBz^p?;V8Oz+R7b`e>In zcB$`=n;zOOwIYUBYgWGfHhv!4p?xnG98({&a_OWVVjg{mNd7yr<^fo6Pd~)P7}Oc! zrY?;uP%}#ar$aYKAByp|iH-HyJC zh>i3XjR)^Pk5SgFgmUzxH~1v9ZJlT>zxfKOgUS?uHX2siK-IcYP}2y`3fZrxGjg6M3v z^>PVncDfkCuHBTs4{(kBf%j+k9KS}`o;OXOS6}?gnEPhxmYdniDx5PF!qwNNw{(fW z4k3N=T-0ddS_h{ck3>_E?X-zmgiSCAU|ecdvN1eOrC-~@iC$Gv1|3B(r9W?p3tC5a zhwzkIFVu=LOny~JC9I3(a%=Bv>846;aqA%<^fT19uST9>?|g8jiIaMwsUJf`Qqgh2 zz&Q?dEsuVO z+Wt>+7Q^CHcT`Lt`Ca8>i>Cz#Jih33Pdfj$efdFmju&xqq!U+;k?PfG!1bCsd-Vor zDE#xMEp!JAxD^9ol&22lt*8`&f)~v+JPdx8P%*I@dc;h1hp?=&W%iPKkA{+Hk16Ky zkxSHIfjPxEN=s1qK81zyeM$=QKX#e5Sw?;5O+cudk3b59@6V@0$XiBGy&TE)V^7fS$yM(8!ey_trw3gX!#1f;%wS4^R&7l&$pncpq zIzz-py=sFl?=(SNTtxUS|E04jV!Ee|{ZM#In!pEu=Z%u0Zv)ih4n)-jm)D~`Vn(4h ze|_KK&?A+~p*&y|R~bRHGX%ThmHoo&vWvZ{toEH-Vwg+jF~)4#^4xLEoFX3Ad&kX7RXHE z)1Gh{OZU7)!SP0rv<+X(2!gYk3G8L{r6Lx+u|;bAkPy@@Knf(W=9{lrZLk>Qo)+0- zlV{QrBg1+!rF|0LkCY_ShI^#YcN!v^L&^ldF}Pgm9!NA#R0Ovymlak9|M5>8;j(KI zaZI;#AtDKTx@(dgk%=Ns4pm`StNFV0AUfo1Nqs^%{)@rP#nU@}QA-{A{CH#5r%nu6 z+Y|LhKyr<|3p$X#amK64nHc^K_oP<3d=kK;>Ef|!hC?ReTAGD~>4D)k(hU-%5VIu> z*-b#D`th*^@D`AGmWrq$kX>}?e!-ac+D8CC}i znixPn3oodZ$p{9D79e(hPJ>K4a@GGovfhF%so}s&?Qv^i18%9JzN4u@}UFUV)*Ly$D_IvH{e70b1y4?WP<+36s#fqi(Ylf)&J zcjTi1V_u8;w6_VvDXUmW*Un_f9n9Wng8UZuzb~MN2rSVD%VB?a7O_s*OaYUhX6zd9 ze8pmPY*cibTIT_=`_@y>Md#*(-%~vF&9b#li97e-7bRb#Bmtz5*g$WZ_~+b`#{+H6ncLD z2&-LD9Ged2J?9qC30Y_4zM1#fU)mE?&*%$dohNnnT;M zk3BvjR-9%Q_gc88i~T-7nlEk9f4M4x4lThNblq8cV;GaQAn0+6;idZRTPHr1G+VZi z#P9xVwSpjcyk~uZ9v{u9W0=u`d|s!f++C@O&*Uy+HyMtsW1B^2|FOY>Wc^FKj^;t3 zsj|}e^17G~VmMwF$hL?W*w$Kzi96J#*MUdoPnj&JDX?&JEtAiLQGlXet+XGb#%L{keY&l4;IA2S=Ea?K8#Q5K*MX8;}+A}z@46~E0h=?5ZI{qqsn#VW`8EJVEJkFzpIq=%(_6EP> z>V^16&i4=AuFO|66X?I!=ai~}-DQsyuaXHsG9qWI-yN-aXhUeG)!Z_^QC5FGl`i+#6|wB)-ed0M0Se63aabOEnByMDoMkn)d>IGmd_h+FZp*gRX6o$lwsKM$j`5nkAMHDUts@H zrN=~D8$L+zXylk|hGq$!-wboU+qcnK8{}VO`QGaFCn|J*fMHyyI;HdzT)e>ZStM51 z&ZRELM1SoZ9{Yg+(h5$c;IagMe~FrsxYe6YLX$_k)u7GuU^02 z)3ed;NV<2J=iV0Sj1chJs&vwSb03-zEi$#{KEt?w_x$ z^Gx^FNec7`i3Iy)TNM*&%#kp7}=mD>OUABS8?{)rH~aNa>pt{11wFC$B+|VCgJ}TGBQtsR zw`!lfSLiC%F4HuD<9z8C#Ra_z_<0T$)V<^lH@Nv2r`0j>E8OKYR?LLAD>0XivT{Zc zXEEwnyQWzE@v6Ec{!_mYqYoh9^go6c7>9JCjjH>21?x9s>L03yZVQTNJ)qlZt0OtA z=rR)S3~%SPF#TK?Jr5TsVG|Txm%htE(R3s9w!XN7w?Hm3H8Uy7p%X1C1O(J(<2lV7_q+L+d zz~kW;F5xB?GqoV;xv?Tab7MIIM}Of%T`%tw{AOfVX1ouXTem;^o#Uy|p9DBvmQmNu z#p+H5rmZ=#Y^hE=cld)`+`d(cr>tycYRvHMFZb;J$0rH~%l`d@ zplh!{CGqFJR})jU_*|e{V8?~8f@ifyVwJ~W#%ACL`gW^h>JFyBTW3Kl_{+x~OAS8m zyHH&zaVA@lJ8YsqE=y=OJ(XW3XFC905UPIoy!?M3EZ~wgL)#ZAaZk3#>TG{ErJhxJ z5GT`67%d`NP}0z&o@M56{7pKf(b*xzwMwZ=BCcMS)t#0o88@fH>p-gU6MS}vk)R(< zd2fS@F(fdp9k4hfxEcE&ubLY@5mz#~0&Fn8){}3v98W=vu8yqpHFRR8`HkZRB231` zn?HaZfRdh};EVY=4v7$!-h!Z(Q&|8tD%HdY-6xAAORcq;(-@4hq-Puj^%4^o?~R~7MqUt z|EaGN|MuX5r>f-6y2+SvAOh!A&t0KMY-dvvr>0s@TDnkHyZ5e@SX{%WFzXJ>y@T)YLIz-vy>PxKA~ zsCYgNjFlJnUgNoUAlmlAiLK)@C^dyfPtfTHy-u*Zt~`n4%>0?BND+ocC4c4zP~xZ2 zAwSA7U!Qe!W=QPHPwe#?>*tHc;EQ>eLc<)``$%Hp0>_Y-*|QdHFs+? z3NN4kFr14DPd5of+d9o#@Ls3x&(gxVdm8HclP*%L6H?KGi}a>-^Aq1^p6wO%cs`-u zVHs~*Mt~Fx3(sS8$x?GKc(0Y$y_(lM9%|uUts;Np) ztmoIr#7yWDiiX#LP~AK_E!ymwDHaGGXZC3S5vxumKm!m&#$&)_U%BLJm6;)}iJyM47Q$1p{(%m5+@5SVFK+^+9|X_MQhPm2o!ei_Kscw&u_2 z1mUVpI}@4{rV`QqbZTew)?)G(zV!G2x)?)Mq3U_F)U8%j=$@P++d8Y*BK7v zy3_!q@9WeCLd0bLVEk)MjlPRctCWl$Z{}uX=Zo=HNrc|Rs#Ol?+RUWWPcr`jSQ>FW z4{g2vxV5tqt{1Zq*ot!(S@dvo(8|$OlqXbinjLMAq2(HK{_TT~N>x6;E(C4!hu!Ok zfXZ3NDLWx61QyP^S2HoR+-Y}6ukAD&M9HfrF(*rc=mq$uW&M{ihA~z{1EU9Nn=->(7j*=Q zS^y0yMvDdTI7rZC&?hV6p{4a&k!Xu)K8k1qk2T;bXESOpzz$o#) zCxmhT9hW55%W_|WpbZxjRa)Hkp=2~B(uUB$+hZlh#;&5oAMmwtrDi>>Ty_Dml9Hg~ zI3o|NP~91I18F5%j*a1Dod(5gdQmQ1m!)t*^(J^cCbvhLBM3FZ-|ia6>U-`5a1_p& z#9#MrscBjsGIi|yW!tm5I$0OlVdQ5yoNq+m+b_WZFDOo1(((rY%vMQ`d|xLA5?>Wz zkWA|>il}O}{pLVQp3;u5aixc@h;`#Ng&gSaAIxR}SkVK&cgkGeXz>1em+xw;n|MJ5 z)igPwGe=-K|N4fU@y~qMCd@8S$LO6ZO=mxB3yZfbM8NZ+m+@UC8qMv7i33E!>xh|p z%Q1eg1}PMsjP)UKYJTmuuy!=?;{w&QP4IeXQdKEua4JS?C(WIgVaRCpKmgMHVSU| zzXsN(a00n`4b_W|joPEX*Csc00+Q)xRWp5W3fu#uZv?X2*A*ph_G(x&kgc*>Zj zA6@{omsGWQ#S2AoParT|8{90B`{T`;@E5VYjMWT~T`&te;rPO;@@ia^cg_}l(4(!I zQe7z!RSmOn83!^a>}y>Kdddr#I2t)48UGqx+TnVKGuUmc2o_#!e&a(nUOqHRWaFS> z^LDKKF631<6b;AW;V-!@Q?lvBqG#^Dq5W#;akXD2=8)L75Tnq?&o>6>xs}rOLNYgy z5D&6Z8okSu^+Y~%hvdiS0)*64h@dI1+?Opz`4npPy z9{bIY)C8l;(CF1Xc{<1Q=ou_1VAhQ=fSf6VBb<2DHNNnmjHaA;PmcLNArQ^VjA+3p zIB5T#+nq2(5^!JvTx}0l@Hg6cFm+z8rQRb)2nD9slhwjZW}oU0dg$nH(h+j#)Crlf zw@+)a-Z)$5sbva^DhHvzj3e&PKWH4K??oq5N+S627+oe-T<-p_HfJ(=d(C`bD+Ubr zk#v@%;&05}ryJQm({=kype`}I8S-t};r=fF{-X3(fPlS~kmhf>NC~QJ&Ll2-wLCzZ zwPP`uG9kcaEbKrL&m=aYu$!pnJ7wVdgJfvM;O**efqQ5i1_TA_7Nz$Q;u+1L7+L_Z9&X-LrwidnJx|_p39yN z&ki3{PNh0ily1ZxAM{)EhIA(;cv_uR7sN(UvaZL1cW#aDq-hD69~$^n9Nz4addk

;7;=%AOV1vMgA@&WK;>GhN61sB*qc84@rO*~g%* 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%0As%#Z*d2BRTl2 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 literal 0 HcmV?d00001 diff --git a/docs/images/sidebar-filter-other-schemas.png b/docs/images/sidebar-filter-other-schemas.png new file mode 100644 index 0000000000000000000000000000000000000000..1ae710acdbc7de6981af1016fb22a51234fcf7a6 GIT binary patch literal 293623 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%0At>#>u9jJX5S!h4Q3_CC%8VdnL&|-B(;R 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

3da2r;wwEIiz98>d?Ou& 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 z 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%0A$*rvzBv@gN zu7KS-JD)IZ57nbLdf1f{hKp+GGvXrH|Im7Wi4^pD=tO5ugOasMzzig&vZW`X^Qkoe zGmKP#k|rcn*>ei%1di|&pDF-Gth4S@G$&_RgMqTA5&;iQ$msYqKk+piZH$d#$qqCs z_+SjNd}>UK!}s`Hr*!gp$8(oDMukr{C`!1&@tj=ByyGs~8iZ+Ch_FhI;-iF^SEq~= zwy*S~PTki-DQX{}l_ADQ$wR9pK4}*&>C}+DnlRRTTnc@6G~~Lj7=2Jl(73?!!`pwu z|LyQF;p+enb>8-SgTHJcdIW&m=l`{K%aXHj zkdW^WPX;bUNKclMj>0}q_#)gcyhhDufTOrC0XSWf_7@PhI{?|ntdhOfk^2j6pqPZW z_so2jpg<30bpeBo2?F5D00`jugOh%pveb<{%B22)q?w3|T@SU}0w_N3MOu&KT>}Vi zx|%|fL&k%;B2G&bxl?=`vR0R=j+9+jn!Mi%k^QW9Ow#hqm}sP`Nd9R)e3LTtq2SYY zv!*<#)iQJHN@CQL!-@k1pg^lzt5zogfRqgIcg`#*`pBNnC>rH4Y&4gMzEEPXE)3YW z6H=bT)KMz@`A{)ZN>XQYn5%v}CHX7%n54c$=tk2TN>zv%Wk>MP>ZQzCZsy`c*US#? z%(TZY^t}Zg)1lGwxck;Rh%`2se16QiT&{Fq;)zr-bb*)q2!0r$sA+jso#(5GjfE7F zHpjRXumB(7G1AvjFiTc`8(AaArRXRVLB~^pw6Z zM>kOcW_HX_4ZCy4R|w|c119B28VQq&#|lgw0jhhmrD6Nw+)U@|AGJ*mc{WDy zh!}^H(H~{+XU!E`D1f{Y1Rni6e3C9Nj4L$9CvC;Oe@ zl7T7LrMyoJRx8HedykVUzSjdV_T=M5VDc!cZfTGcn=oA+b&et4fK;>0Ar|?Xz~Ig; z_fz;CV$dFbG)L6Nh`Y(vvEs>WI@l-&(dqbe`9(kDToa>Apc-N%ih58f(nhJR856gc zX}4Tnz^hgN8}3?pw<7J7XjK|+ACy;~7DMwD*Q=;_35z1(KoAQkl;*u>p{w&}$$?U6Xo9 zsX$w1o4wMM3bnJy>u@7Uh@6k`p#W{3-52B$XizCgqm-`V?}wH=Frm@`v0+S-#RFl> z`h^d8De~m_k&u_~&C18+sE2TPeR-J5N^At{8zU@pXS-Ttg7d0Ix_f>9D(^{WEzWmx0Qwk1deBEI!I>9s#3ytU&eEl_Vyba25G>6`!UNiZ`{WE1NE8 zS2W3rEGVj^XgAam&xa)Qf|W%ZZU%{~)3+Io$;*K$lg1>6cxY4|agCBxD0U1hi4*`{ z!n6?IR~j)oO0Henuzy!=d`tk-ae1h{a2WQfb=)hiqb#m**PPkC#WC)c7zFWUa>-~8 zPAy z10VQAVn$@h$ScM$iYM?_IXPOkAIvqicG-Fdf#*6)TQ*FD!`K*UMn27_oAJW6CMXk$WXqpj^Z;Wh6YosGUYdXh|H=q1N9RBs`TKuGI!)WOSP znS&6Ce)sSC?Lj3P7=F~Y$^+(}&eZ%?Q(kJS zrXCe_Uj9U39nY+NQz-q`{sW{yQP&k4^D3@*3>Ej(3<@YnUuS6C9Yo;wN=7JQht&A# ziTFG-C?5sd_aAHp>?Da^BZ8UW{p5J{#?d6l&2Xrto8wnq{rA*j*TCNDD;dOAOaXX7 z>243I^an2+R|e>PzCpl}AIm;9Xnk~>qox=F0CAB}dk_^kMqekUDVDo9U!%jhEsjMkC>|UrYK)nr9hGR=lyp!#!a7$rXJD|j6?xHpG zuoh4}0_IO8NeyWlU<_qmlP0CC@9aN}w7RtB0un~Kz|p41=LADILZo(jIP5C5-9)2b z9u&GZgPB*$zk1~^*>DzcIs2+&74EyK#-4rwVIpaj*q*AVGo?=0Z!18o8HGsjtn&(P zRDtTrsgFrIwJ9+t(!@-%z!hG?ADzXkfkEDhKd>;>bM!~e%S`X+kt4okdtHS)QYg20 zD=aTehz~J`s{|}V*TrK4Lks?XVwQZ_uFhXPCFsLj*x7B;RQWWNex6W^eD;7W-jLC8 zPqY?ktjZ%Ai3THi#5*%RF6qP*Z+c-=FB(0f4i3p1rSlLl{dP!)8MFjAxDWuctfoG; zC0y#!yAKu~?Yv^yk!=w{F**9Ku&98%DV{AeB#QbeVkRra-uk9wsxqws40T?Q06l7+ z44y-WEZQLEUS0_KLFx-c+O-p1;`df(ju?m>4wvr6D9#C6m-2AB5MNf)OIgc)Jell3qpaY_@g;MQD3wIDfi(lQ zmRD?JV|K~V-67Y_QT!tM$O-z5#V>@`F_Z82`mm>tyx*xgmHRjpcm`=$)6jR&agxb+ z1xJb^DBPb|^D}UO5L{T0@ORf5*Td&!&0u)Ac(eo~Rn{FWQbf#TqG0HHa3 zAdQ=&k27T&S@4`mZ?_rEZE8+dAB#IPyhAZA)O0V>4TT)aG8pbpwA-0~Wm@=rRR}Vg zCd0Mwd8fQr?mn^X%Gf>uG`N2BA6wX!rJmE>Mc4r*+6!3IH9cpgw2xu>{pE5)U#W$w z_`GYzTW3`#C*?ImBw!%w7(Rv*FJ9E6%n2wb4XRREIV9o?E znqXsqmW%*2H3$_LORE)@X^d0-%Gd{t^Ir$YD1f-)>Kg=^w!w}iiaRX4MfQr1AfEEl z%5xqMaMkaLTp)tm8D|-ckit&3rA1R*h_BC2Xq;yV%%2wuyfo=Z zcd==Ox(skj+vi<1;-r&m0bYEbNdU@cwE7?6za0t>dX_}x6AQ6f+wZ5N|9CvXtSJ9L zOR49Pj8YfS0`@YMfy|!`zI$G5mv$^2N_m4hO~(z_-EB~@GqVB zaAI|jNFB{3e!AogCsM9?1U_&%N3|v32e*T($5E)0zaq7FjrL>V3kS^BdxJ%3>Z$g8T@#Fing}{ofvjRZX9Tk z$<>ou#7231;#&^8bUkP-nksCJS1%P^{_#jYa(CCX@^FEk&*)@Ra9!rjJFb}L!KQU8 z+DUdw=N{^a^v$m=qU2crFrnXFi`+pNl&fUxY#C=(k8M2kV>)9Dg}CP^3lSGf6`{%+ zitY~l*3yx zM^%nEdb%rxUvLGo5svsbkPhV zZ^n`xU(ICu9%&@r2N!S-s_Iuh>%Ux7CSnPua5NB#SUvIg$0ondyC}$l+KYn@4-*t! ziZ&f@_8j6W?#iz0dvm6Ncz*3R^=oKD=$!~)kVT{)C=_3qc4SVOdrSFd_as5P7Id5s z^t7AA_TeV6*H{<1lx$jL6uNYsfFtA5ktO!C=*q-+YNWP4g85Ki=E@J;l5Z^LeQ02! zT9!q{Bd|2xyE!Ux+`}p@IiW$h!O;w5;C+6|FltdliMkk1WnnuFTPX8OpiiZ+ist}A zfCIN&QDIwd6$isy*@Haj4&0f(wl|#W=DCgH6LyHISNtZ2Q>Olz%ymv{3>yg%MsiPo zTqoG>*-p!Ad2G7uMB|~vBY+aHHDmNu^5{;EpGYqVapeXie}?w!T7BJ9BJX^tZ!0TV z@pz&#%#^&qfFvD4Xj34{X>&w3F=7D2akBN`XO+D@S%5_Pqd-8_4AYhGkfwc@=SP@| zyOx=Vvc++wV3i*l7oC}3D^pvN)W0rHKViGTYXhqqrwl~6^#mNWq|xR4QgCe5f3$CmD6?HCYw*+#IU?yqUuOx?h zP7NueS{!Y!cwm!we|+#R@?-g)bz^re*`vv|7dB}LW@rVRN=LpyL|$9`A-*na|B;dy z({NG9qfaipah2#QR#fu)DrK3V+R%47K=`2fRCB=-^@&^~vfSF-9!b>bP-e%JdD_~- z;&QFgB|!R^4ZYLuYV|gTAbhG@;o9R+m!VHRzPDq9;noY<=v_#&MW|un zSG%Z_0Yyjc%4qeN+kPQ&2~vwwH2rf(ATf6p3ZgW`+sN{G3TYQ z7Ad{glKFyFkQ3oK*x8(ar%d(dpueo(wY0BlT3~HNgJr{FS1kvibcTXKlmLn~I^3y|u9~W$VMtr^%ma7ekmwvGNFeO+G+fO_JwJj7v z+E58=ab#5&3+CiPXh=!a$(kQF@2!BfvF6j*(cr$?%ljQeJ(8=FaWTCGOzzWIZ(&m( z*4b^oWiyERBT~yE_S>k|8lo~JkZ1qzVF$iST6iB&=_j($Nd2cvQZY5>JrAX>h5O%vXM&2$V%5cu{0n4(uIFOwr0`cS|-+86f7ImVdJ&NHv z+F*P-8M$L9VfRJqT&Xosz)j7|Bl0O6H!8DB^heSPpyMLLopi5TyR~ak5f8U6uy~2J z2$DgHD-(jfPYM=}WTU~=$+2Qim`;AONAbe-7L5=1pocEpTjTOObwkBdNQOO~FR+MJ zJH+!!E_H^+7D7aMG42*h-LacvDiDh)v1hBv3$ViLs=2SdWqxOpoImR&mj6jkseQT5 zkJEgPi2)m<>AEs-w_-tpnq9F=lkXBPo?F{#f+v*ACPba@cFr2qPo%%k>Kq+(n_hE@ z3QaSN+u0Cj!@%b<_u`A~QkT@_$&h^z4TwLJY-7#+>25?xNcw}O`L2hZVsW`MU#+Tb zv`a+=OOmpC$@yg5yD4VY3z1n6*&zF^Y)CMM*En5>RabjKRKV=%%6Idr)=v{pUnNc9 zFg81O#l+99=|$48!+8sN-j`Y+aU~d4lqXjGYC84_oAnv;Zr1%oEdsCoiTfR&vZS8q zNXEP@c(^dC{eI>4(2?vK-KC+Wh&j3m{)gD<20>eq8%H=bvvMhaOHuS}*Fkl6t*>vP zYR3gSslVT6H`WdNZen{uSetE0PsKE~TPYfCF8(0Q{v@0_H{g?KhYrynm~!JHFBo+f zapaADXTL!`;^H(EW@kL!nzFd^Hpf-Du?A|tA-ZPkJSiZbhxD_W&5J^s80IZxcJLUa ziG|+hP&?ceT?mo9CH#zN-p|Jj7laZJj`(VUC1Jj)_heFS&>@*2v(v3^5Bg*&pN%#r zdi)jwMDM(?&5^Ts-R^LQAcPg;f0`bfsYnL|pV#pua_j0N4*2zf1*U7=>37{vCDuuRp1> zy`b6V*yhKKU#tVB8?Qq3mLy)5^67lccfc4YhVU4dzdC_%)iP?`cABq~n($llGoL%@ zjA2H4zl;NoO=f&jVM$fq(4<%^^eHdOtP6tP_8qIF6kV$@KWKD@)VXCk)o39S+6)x` zc>~QIow@PKNuL0>nQee)eMeN#jF5&UYNa)|XPD@~6*w3A#AR)z#x3)wTXsiPsIb9@ zj;um34R!wh@^1xO4NyA#s0``mUT6S}wBWkl9Dayniz~S<(jUXb+ewB`M6k^x{bLnm z1tP`egK5HPOO#Z!?gF@Xmz636Xck5~I4{(Y{Veri&~MqD-&}=;p6=sd%I;2#cvkMu z+TppqFnMw+iz4Zx$=XnPbOLxv&CpjNl-K1k4j~!@T>hS(1!5Hl(xD{N+X%L$U_Os@}(~kPKfwb7TGU`T?>y#PzT2>%V=bS(;_Y^iKe# zhC{MqQD9uHJR}IDTVoEL{fl{qimQpFvXH3hOrBqiP`x;lLsQ3~Usi5;E2PE$D@JE)k(qaX)mP^F%3 z-4J;_81gyat3{SHItpF#Tp&ho3lv3#*Ov})K&OeN0_^-A^{FX0r*c@a{7(*;{fEbJ zZuvE)**_oaG}k@(P1-X-E~8_%N;%88@>s+~Tzryc1Lm^3=#?+) zWt`$kMB5zCZr>vD;w)w!h?Dn0!Xa5HH4w^N>i~A4l)9tp!Iliqy7kC1K>}F_ph&Y* zPqPgRvv72Cf<~6N)&y(bzCEm-V;Q;UFn_IbqLvP=*0hcj7&Z!ymXF@gqgLH$JD_-z zIt}m5Nq?sXD4SYm5l&BUP8^4^)^tTI4%7azT%j`oYF;>MLx}>X>buQz9Vt-2`(*Ers3iIJ99Zh-RG8S zUY}Hlt`zNt%?Sq7Y>HR?_nqIpRX~tkKNX8)cw5TtffQ<;8?ec!nWjC*pgSS93pihG zzmU>?bY_0J4GwDdmkEFxFlGWvQG=1RdisNXEk3b1qi?i&dHQ+=m5XCe89~T zHWDR=^iQ=gW2o^$pmop;5n+TL&+hY0d%TAM3AFaMy|!6D%BdQloddOr4vTI%wZ$jG zvC{zmduG&StsM)%6^H{bSTmpO+k{&DDI(;tpXEgg;Lh%#hW0|-Yp(MYv?R}+YFr^{ z(WznTnt=YBH||bZZ_t{Ge?btsm41m^4g`x3iQ;EHkgG*d?daId<4if-(&~`hX9ut4 z+F?BDA|tjm0=atWLVI_0X9u>$RcH zli?z~Aj0>JI^3-F)B6cA^K&1$rbFTR}B4MiiyK$N4Qrjrg_w{N_L0 zCx9Uf{D=n-?Kn?5)^sqAbMj8X!&yvpRJijxYnXp8VB#!F;G!y= z2<}BNFFHtz&w{mHTJ$HVi;uRas>@?IcgKCAJ);8Q-5Pr5l!WVN6?;~A)M{f-PDz4g z`|W8>(v~gS>hb=%6+HGs^+6#CO8D^xL%et<+#WT}+%*;(fcO8p`M2nlU;j%ATd93c zEb~_##64Io?cKxU`~S4(|Ld=1MDX>8%=ZhBY%ESHl99~}v+&)Tk^S}YTVHq82R5^j zzkZ#S5v-hp@8R!9i}h6g^3%8ehxiV_!q$ZQm%rcG>lYkI++g5_)!VJlZkn}Q|3lmm z!811dcW-`c_)g^bY~#xN&At4W)A(jvVGB&Vo%T z6F-80-ANR4{|R(IRUBqR^H!H~-}-DlZXgQ9K>u~$KPe*cl7yGk@u&T&ak+{}%)xv0 z|Ae9Yg#;oY!@5>68-k$g1@E{a;D7j6oy8WV@f*33PluOyH-{Gd0(g;w#6%OlJo}g8 zvGqSZ&LHFso~&V)H^J^75wQD+{)?G^a+<##1C?Ok+4e6fLDqTObnC(23)R-ofal5( zrhHZBSpn+}sgOp>DqcAb()|<0W%+z$Nm@|+8xns4 zDH(Ytbbt3hs+ysIxfoc`)BU0XIerxK5&Jlrx1<{X*8)w$w-=E7g0#rrgWU~!qwr1q zua)&OzAbNRIc_wM>W8-S{W4pw;<%??M?v=|j-}WrN}#;dsJ&VP2Tu9cf5?_lm%3Sd zsZ0Iy;=XUvPqusJwneff?!Ndq{KF-A7GZ%W-5n(RckOx++V7%W_{z$4Y_%H8fX8++ zlk5al?GCDU;}7DpyP(I1qJZ(^jek1j1M6k*`Z+MU{p*?k^#>0dQmEahwt(U!<|AkQsy4^_28%%({Q>Tj&E@%YJ^SR0M`CG`+aCtgnYmYZe%SL$QcOS zJMqZdS(bf!!FOK~BvczJi{gC!*v~On|U%C5cZ&Ux6q{1c0ZYrJ++o zPps$qRw!PEBVu^lIvLtW5%PH+GAv*UQWgX3qy+NC^w3D+bSYaT3e)wq@Bnbi`9c0V z(Dl{J^^FTBN2K7(2gefxZ92(L<8AOYmMjQO1e4o6``n`Li6t*c1KB=`2O>B&twVgG zjCPGLrHsv;xqg5<^W3f{^rf!|T5c+PvEAr852p$lMDGQFf`k^}#ZMu5cLjdOYZyNe zhQ3L~{RWw$XIF~bqw=>da- zK#6U$is9pnzAW~JTZsO`1Njhxw(|pFD9tibWG58WU|eZ+L55A`_e-n%)n|(%M>OaW zT6NB(z6~ETqjdr5KNQ&mc*OBgkNxe-lf(2jhAm#66tsb(s*#MZ9sKHjYo0?`d7DL@ z1nqs(>$tr9ZOgOOoC}hBj>9qYcuNgtb6b5Y9U*doEUX%+yTb$JBsD{>=U7J}6BZZn zojx4JtuJfcX@-wcJ$7%Vw;rXT9U=p{tHM`?Sg^-)hl94d-3H|Tj@|kQZ_Wiq+*xXY2LvU^?ZbruK59jm^H?PI( zi{Y+yS~tji+rzG)?y!A&AWRz|tXB}h7dQcSmcqcNLj(${BK^8hupJ0@1FEM80AfX| z89@2jOrPmcl#Y}yomQMcc{sFHlR(XJww__FrOkSlN-`{l9Zy4=A42sFmu>6aC%u6( z9n$2Vff02e&8d-nE-Vk& zU8KOB^k$5JmYu{TY;dm@_Ku4L|E)A{D9`}aaA~q(F`Tu*1%rC~h|xI!!d-!w>vbO1 z1L2%aKV&Y%==nT_Y?;}ICTXoGXyOcMrII~-oqK`M#?5){Tk7~jb(aX)!!U{S*2A?A z0GygBl5^^CI7-AwPZ*Gs764}}_2NW-_wBHFGNA)pSaq=q(Z=e7AEsBS1}lAmp+`5j zz6XGE(nClDNI9{(X7PkARB7EnDFJ@R*lFlKAXlLWIW63C)B9TqoI43yqlqPrO7AErbJVt*gNS}frD~eh zC<*4c`MW>*^{d_~^fqU8MLDcOLxE=iNzg4lNckC`Z4_h=Z3@y{#qaCXm{01)MYuF`PoS{R9E zwEnSeQs+o!LocO@3SbYzBdrWD=sSMwyx zWK7Pd7`5Vmv@RoEUW$pBEng@Ir0|bCd~A){@!EB zXi-z_M0+g`|ISgm6C#LhYejPuWW%&)HRzlsn?xB~a+NCR_)Ik}0L_??8AP5eATV75 zxs`^@73OO1#LRZKf^HbG!GB(TJp1yEP+krp)|{)&&zM9WHCo-cnBjdEpcPKZ@Kry~<9 z8((vClL-xSr{~P*Z3Ki=3}CJKYgXFs4mwK#?3d>O>|CL6Ny@g+^RJ|E(n>e42Ilejtpxtf6Iqaav^DPlRuc@GFKhywu}KuDLMY#x42Wnae~q`;IGgnbj{? z@!US&qG2V|>00{3x)M4HDfC}itxTO8tnvnC(K7{%_ForX3Ljh1ux-03`*OHlsD07d_y>LzY2)3>p4Fs5oY@y--RJE+64iNRe2Z>~(N3)~` zD=rk5<{>d-B`jj7*dF+N1Ufr>8JQ1zRdLIWYa5349bUZ=`0N$u5X^k3^Ar>ksNh8l z6|G)fgx(N-c-&8en`tZ~X#1JoTQ%%spKHYM!tLX$Ro0jqSB!u5NK~korXetuoqtdp z{^p#;trT2v$t&V{h3Ff;uVkH=xpc2;I5ahl?B^_4z6AHlk%F^_KXV=q7XxUjPUkXO zpDE`{PqdvV$74#y5Z{W5itA(e=8gl+p)D3Yl!!Gp3@Gl{vHb3%^oVhA#~(}~vs<#> zgc|JaI~Bc&Ty9lGzjI_eN&82Jzrrv@^#@LVOHl#4!XFCL@n?Rn=o+3BM`@VF%AF-0 z20GS~?3F-u?|jF!D47p{r>lb|3|D2Hv_F~OY}dZE&c_bL0p3TAbWJDo=c?(<2b4x8 zyg7wYYZTkcWv*?*0QOE)%dM}BDU(BKY z<9y@FaR$w_AEkv@lhyLM;1Bx5^9y55$klpjC35-rk%@e2?Wki6jhtPv3*|q+0R9%F zomd%sV3-0WkG6S)nQ7JW`v(2f=pnyR$);iPjoPARs`=ft)-Ct76e;FsNQt;m^t1#3 z6m*KqSR0}|DF&s&1a0caVDCLqOF#2-ZUSbfsKTUi0ZMxBVdh6>mizol0r+rl!L5E? zGw-ecyKMAL??da}NvMXnyQ{xHfH?@WNSiK&L%!4B%a>lsd_S(g{3XdpA=^$dK^wuG zO3!MN;eVN_HsoYAVp^%$h&WpfRzCB^PN2BAVc>WR=7x2Mbm5y+G!H>Dt)Grlmc{#| ziW?2^S39ng*P=isH2@qrRwXlzljZLu~t-twmiR|H>2_Apc&CU}5F?IEEPln-x*3DN^U zWX_L+%lVdM3Gr6$h32<$ue`A(V4Z07yP+)lO1_nc$(CmZ!1wHU?l385QG1c>e(6bC zC{%y0Zd$-$g6&a|dj7LL5{o~6oY&PM39{J- zeWU!KT=K&YZDu;^ES#;pZCLOWUWlI0^zh2cN?oQ&$8vu|q=7bG8^^V$8MwET&Vz47 zckYh(>PXIcgPx2Q4Mu3c<7&Hyc0Jy39-SiT; zzy|&=@3Q4z&Sk;MV5r5oMX40d(dL+dfs2(J`P3ZZ($K%qUJ6F?uYK>IFso(>IN=dr zJoz~TsypalxL7ha2f0A>hZ3A-p0G-l+>~Ne`nUo;yvAAs_K#b1&)hPAtU>~b-=V>p_vYhQN%l#=rL*0>|N|I^MiwW#I#@{ z%K$6oO(O~ZfBl%cY0ilq-S!HOxG!(pX3CEF6+xS80lS<_b7Tr}dz4f(sqK1P>=LTA6+TYA!3zjZ81)poyj<+pYfm?@fGlxw z|7iv9d6R~GRUm;maTdKg8>5=0_fnMa|AjRCxJ)H-P;AP{LO{87IhIOfSsc0g8N@8O zYu<>txgxG1M2@M!;GB>Y;}8&Vg)Ux*f!*qgornPAe~jDG(f_cKCA*Fr|e?;_fa zImp3ZXPYX0H=^NxJA)S#FkFs2sne#&@k+zx7?Hi3K$#@+z{7=uRoMJBTNnh7BH4rY z5E#H_VTIt4)rZ}@7dLj=_&Mmjk_U&@?`cBT?+~or^FMkv9u<#7P-SwX8&vW zT-kuHdYf`r4|55UET<#z=X-Cfz+!3cTiP7H8sgzY&d-bqwVVV_gB#_4Kjrksct6Hq zG0?J7z)48R)Jb-}hQx{XtLL^GkF)4Q{M;(@0xzM5_ARKBnvvPo&CG}VTUZPWw)Ty+ z`1^0Ta~ULuVLw8dh&zTOvFk$r0wWp)p1gjp1T6RYl;Lm1ly{XNNbeSs48(GWsW{ zQv@y@TLCgU=X-!cAWPYVXbenKCj)_J_KpIa5;JlMqfIYZT@em}x1|%I0qi(9<1PWG zBWX7>Y)w+g@Qv-E1X`?j6cDddTE=K|jK-=6JT;#L;E?l0CuMAi ziboZ4Q>xzPAk;Z!=o5;9)e8EV(3|St(giXy%g$1DnkZ>F z_XgdJUZin&yOCA(;DQ@6D7c#7u&5Czy2EGjB5qj8=fR4sh7dS(O0V=QS!gjf&x)s@ zeCal)ozWoBW18pqsLy{Jv)j#M-B@#ztN8TGg=)TMvVqxnVm5vcwobFNohq>}O-@G;M+w04~4Bpj1p7-?wV6 z8s9EhUY-l78_MSFiz!f{7Sih~$xk-C5+pP#RTW}%ulQR<%f#6k*Tztr-k&KwPs6e* z{M2&?1Nco9>;RoBn7fv(o@@NXWziSUVM|51LVhIs$JC*R>sY0x& zF(i@evdntoZjn!2bQh;a?6ISs^YjGXtE~ujL!Hi9hsmy;V^950KdtmLnQ;oa!T0yn za;_yv&ab-Q9^5vQ>Fm*OARR9CV}@v6=jpE1A3~;n5Yf&n^X?xSDuv>RUg#a=O>s7x z1)MOIUmv+txKv>8R8;(+JHepx&H0G9*F{cnl}msf5`Xnb!6pphZ%v2HPl#W>qvuVj z(i1RN?G*>1?MOh52PdUewJ|t@35-_Ui;gLpjEqS zB>(6qx@g~+tilJKoWuB`=(TT!R;w~8M`ljXVyVlnbf47WeLyHAJyf_{-)ihukgNU; z9;9v2ax%$GoR-*M!pv`eXZL2()Aoe6=rEM@XaE7o&AdfSkH+mnX9o?(k;oZn;a8kG z;Lzsa!@%=gx8_&Y^Yr}b!{Kt>LJlr%h@j&Nh=NBm9Loo_Z5oHQ~X?>t_M zFOR-XAtvh7b+44Mp7We8g9dUmA0nph&Tbt-?YVNqa?f@TCUWUuREcK&9;6q)Vsuom zQrpSVF^?wxI`;|2wA4GpSPCPP)C0rN1G_tWoE9hTy!PUYU9qZu7&RooyqkqGu9Yre zzum7(?r|GBeq?dqG1QG79OQPqgR~E+j61s7Tk2W^4*Kewg6Yp%B2LASX_n7ET`&o; zi`~rUEejTJTpnt0rGt!jMQ0Rxs0PIhEl@R_&)I3cTrA>y!enU<3M$uJL6>-5ipj$M zIkT9kauQo1FQ0~+=5egrl0smCUUO?}PI)=b6HWI*m31Y|+2AL9E&E1Bl^To{?IYt% zgc>W->!;&HCCM;z!2?xerD$u0Dr}sjbxwq9V?xeJNevB*e?P68@-fG?!nKnWwX9#3 zj~lN+a7rq<+X$*|dS}-xfP5yJvmSB;F~DyZ3y@nrv7zy_dWB*ChAt$;Xg^EkR%soH zmRtR@3zE@(NMJ_?w1dTfl8Qc-mP13n|H8_zylFdnh-u=ezzXiK(x%)LaC~fLIxc2K zL*v&@o;|C42KC3aAb6cU`<-29G~Ml^i=6M_eNxOW)_Q8ZfV;hV1_=g2zUJa{dLFjC zppR~g3Bky*tgJmXrsYrioofls%TrGDDwpeOA9FON54|ZP+*CdFxW+_vJ~-6@U7-|k zO(`P2tVFrfSwgRaEO?%>C7BD7i3#NfV~8d#V012>uz)DAK7a-y1w2F#**E)DKRcD3k>s%Y9M?Pjvncf=OWxp_kq?x+^fF3&}l3{hHH zrcGP`5>h$-sSqM|{PVS!b=Dqwj=cG=jH*uaxIi78o_i4GGf*FtN;QR=h-0A7WQ8Wu zhk;EZD*mebng@2O!u2H!_YY{f^*q!pho=CC7F#>w%isHSK3CX@qo%X}XAib}sdr-6 zfe44RsPj-zW-aClhml1E4x?4%{>9A@!=~5rmpaVjI|5Sqy0AZd>d-Ms(O~7_CbXX) z5WiB#HgjZk?%!^ff7-;U|L2q5KMu&Asz<#Iam5_ck21OJW~cJj6*Drj@GG}k;Of|@ zU;+3O>foTxU%6ES>|f+oA>|h}!GNhtSm7Oc!I;@|782cs-P3>s5u@av4o?>m2wQ`q zBH3h6%CnU+OlQSWfuE@W4+QR)s1yazSP|wzlv%9XR4<5dZrkUXIaTwuA|c)NZdn4Y z9W`-)HJ=e;m#4W-?uuhx?E2b}38i!U_21?2-f*kpX(^tt+b!EMmACW`IZZDe%B%7n z=6YXU=e*uQ)@|-G5Bb-E!tvCK-frxqT(UoNdHFIhPuz37hY&8MPK;@R=3ot5euQw# zwM_UTVc$ie@i&=ElTF+}jDh*rRswK%*DCCt6rvc@&t(D9NCmUv! zdAk=xRUwKUrwJK3;O+6X=)-I2j<Vktk#iV_tnfg zLx`vQKVnOn-GrgOizXh(5vKqHgCr+xomIEb540IM44!154X+8TfkeFkvSyDYQV7LG zDiW_Bja!f*8kVTI7cUsu@t|9U=R*bKLWEuw&-vcofyhwBbA~heJRgRp#>|?Da3)#Z z`(Z2DQ=_4=tHfAX`$v<12}=)b7O z8${nw!3gcjTt91L8)wZy&k+ZWUL=<0TwiJ7N80Kv;Iu@y4B(Kw!-G7hJnLXyp$uQ> zT&@=cR(s*P_S5YH;{gHpLHnoFsa_4p=uvWtnH1gPYPqoGtd=N3Jx}xy0n|$X4X=x=P$FCUX|BO|D3gK zTT9(BT#?(-|78Hg9{+{Pb#HRvqNC*@{2N{#+fIwp`F2ooJNqAk?3`8n!bF&gW07A$ zbbhv;(h+fdofNY~p2*^j0HdaaeK_orUxcq9n=P=Ov^tI@M!=lP^rs7Se`)0so)MVNeZiG{0Gvq9vm^EC$@pZ~;2mRd;kV5H zvAAvfj$+h12LDA(r>Z6ks9i;{BrrSwocnD?T%0Sf^-U4L)eP(7=&{2V%XSJ8{hI#m zD~P%H0kj-@F7dm~Nb29;P)OYPs|~g;9Ft@FzzTfQEai^}t*x}nfVo2kHYsl1!kF2(GLORt~Xs?G&q@b1ujN93Zq6e652Y^4oLw*1o| zEN$wAhB4&m@_{c&qP-KD-%-RIzSPA{s5!i{ZVo>V5>e#TI~#WhynD9X!!t@3lF&b^ z23@FU(%u_wpQn1Koy)RXs@?e1=^bA3MwlkMV7e-!img`4PcmrIi8!wJgEVQ})+)5q z(k2gc@w?7PFiU7@X{8%C37W{sTBD&QcbX0tYq;5hkKlQ?wN(H^_9B#Q>&T!m!TXj7 zezYNA%@w?jz89C#{#sNFm^{G1JfL$1nr4e8C6#Yoc0G*obKb5OfBrjT$>SdiP?c|p z3*#SsgQGs^kBU6&k^PY4clbg}XGk+rK{D*N*nldQ;plwMu&fk(4C5nI zhoSf6vZLVrT29}SG9g!h_UQwd zJ`5Ts#l*ybf%j0k(8OjEb5Hf@DfiS#9tTrUxkpwJD3VJl;N()>{0DfrQA8ebAf?(o zW21=#9@uYeQ5BXhp%XUIb^&E9s$_) zHjGal7oiwY5-!+|L%YzM;ah1WZ)zZYKZ3yBEISRuy=8k+wW%YJgcqmJtMdf@oaIvz z#4d7=PHqnW7BQDr_P4PRc!&Q9)c?5!N+8_Ae4$kpVS9Y)8VK+4LlYa1i&rDj5@Q2n z=r~2t8w5B&?==jh2y8qZ&JT;xtC&t8{LKCHW6(o<$3LPrhAR_5){_0%9s++Kehao< z#fz)$_{P`DBjJ!wkBtcWbeQoeB>k9Azg=~xx2WR(BTm|WmCDu zxn4p+5{DS}P01;I2!w=ybMtu+nf>9o=FR7M<6(Hcfeb=(m2n9$UI0fT?S|YcAzMG% z+#E{askvi?r0ZlgjW$IkR07GDeNuZ($hX5YN(j8+dr&LIdcMsg4ncY>7>@e<-KuZC z{?iFK^I3nS>TfE{P$XIDZ>dJ8%4vdATG;-&-FtI*L|@w&j>r%^JlsuLA2angS1S}r zR{Eb)`-8yQHz5@#?E#$>8;RoYNcL{UXm}5S!^`i3b4UGtGI&$r=D=c9eADM5Kx~i? zj6*b521fzyMr~98vh}mg)zyUBaW9e4W2f3SM-N6uFV-W}VT?o4)EW2#L>qF>hMf9= z_+Ul?bq)(H3}^M8d~x%b7(;vvmuc7+_=^ib(qaSeN{If&!#%qcz4@m9Ycu?R%w|CE z`pykqgx-j{I40aq`A``TgC?O%y0y9`}=N> zQBFW!MtH4wI^AJv(dir5-+7ZSZuPK6x1bl>$5Nv1NQSj%+ym+p1m%6JhR=MCVih;# z<_8giDEuXH2&eMlw~KfnCt4b=BF>kRWCSXJoz6aRXj*<4$Hf1sE_2VGo;&y=PYRvn zg7)Ym7%^c1E?>dXm_5~Pt=o_cOl1g9e5(P_(muURDR7)pY<2o-cU5%EXHQx!IzM5| z?e^uFSKlOrx)8ninFdNAdp>kB5ei&lJ0_nY z)j=Kb0;Zxvo?qN;I*aQ2*(~7MdLv+^cV=bT-&h?0)+H$X>d=G6n46i2g4$rF4vjk5 zfsH8xHf9UkJuyOb96S?qn7D~eT+DX7l@8l`J>{g~$0HaQp-F~lYr)9M0JhWOX!D;% ztyam4Z8rGn{;~__P!}NDdv<1|zNWsAAqjmJyvG2>APwVKBHTNtbZ_AEqjj*goSSmP z3jt1iAE1q;v98vGhb(|zF^MlpkQY9+G|ovMJ{52@qAKh<+5~=TnTdxXb-0`~(i8bx zf4P5}(luG#sm562|HIjP2U6Yl|KnG6wXde6%!a6hRQBv@*i=Gg6-BbL=W)_TsAOdv zB~(cEKBr+MB9zU^%67sr4#zp)=j)u){kcE)?|0wM=l<^+c(2!ZzMhXITnBV)0%#(- zhiu*ih3d*lpw2SVc20XjkK#lzsHTv}sSXrhyS&v`=)2rdYWWBaP<}9@az~=eX5S*a z9(bQt^~T*+0H{iU{TfIx6rTgfe>h09Q&#qoGW2tE5V89C$)KC!5>L8At78?t-4Oa5 z=RLL^Y}UleQq?Miy)V4Ic+?gc*@MnDa0jmoDwRSTW<&KTz;vE@X_RL#=b#DD>l@=J zn#gkSJJlq5c4!N4y@JW>t>UX}?=9h$vdtf>N9VOu*07(6Xuq;$w{nu*b82)c*`M|@ zS+(p%@9inc<#f*8eEBgWP-*Pr!EVNYJVsNzC^Mbz*up%l4qcV|Z#roHo_FwjC)r7N$Q)evo(PU+<8|G8tlQG^ z+IgYHY3~(F^_cu3ZSn5Ll5qfyuCzT4Ow#7As0Hz7KFE#(vbpe{^P_nU1?eTUlU+ZN z=mtSOfD$FDdH)nzU9y2!=HT7Gwr@@`=(l>BV0kna{JFLpnqgf1cTz#v@q)DQ?PYS- z+DLObl39n{^e&LRO3fjg($)>OHmzJhDU%Njp2U@GFyFd5t?4 zmYzsbl<**DR3!M86b?r0D|8#>MxDpjj_boK1|wD;vZ$J~ha9btUWbV&t2qBFRg;IR zPV}5y*T78%9p*Q)tDkh-U?ulk10>4yA4@$L+UdnQcd+d4f2ET1*H_^jFK8}CD!kfp z+|0r*0DpinYIT=ZZcrj$SD5&9%<;o&;VtvY86Vfnml}!~_SxQ0at`p#q@31WF!Pxy zB5Lb86H^vC2j_WRdpC`DYgz;r8-c73L~lK?>Flp3jD1OrFy@7Rr&*pXl1$#i%>0^a zT`TP}@7SdFVIHJJ2ikdm%VMoXd>Sa(0_6ZZu8~e`QkPknC(?bjo+?}^!M}KB+L6{R zPo(HjM=4zOG=L_M;Ar9TJJ^OcI~1Qj@(Xu<1V)5TlRcp+Zv3-I`sJq$r@)m^_vBH$ z@^o9eg_at=c^p>@0@TdnHY#OucMEZ)bN`ia6VePza%-AyvJ761(|K3~B2p|I*j)rn z{H}p)Qe&cDnJ#OJnVP!UkQcfU^Io02e92FpSh=vm3wxFi)Pf(tY=g4}v@Jaj1w-f4 zyr~U_baz7{u56{Vr7E(+ws7kEbFR8_pt9Vu_UU$Hq`x`7);7PQ*7xa(D(Hf77mXF# z2%7yB2{LTx57QA(w33c_X%;v{H;7Rc-s1g zQi1Y|A4kSuA877%x`lIHMn(abD6qzqd)^7Pi?zT|VhD%`BXYkHsOenRRl;C>Pa`#8Ne$Hl_N4Bwq*TmL zcx53O7EN(Ce{Xk#ZyVDtl!L!+{a37IClq^nJ(RUu!8}zthRet`ZpTQS)( z9knO8OgE}GD^s?t|0)1jMh~4vqSsHmVts~oLvA1dq^Tmb&q_GNF3 zi^lQ|O@m9OTSe?@|HOyt{RsWx3nIwIXgb=$!DBc9I?XLNFivuqh&ReQ72#V(u;AgG z&{ojVAc5tdH0JgA(Rv|>SN4z>c_b`XnYBu$&Q$9vQ3TyO((H0E&VLS=`E*g5-HAD7 z#-Eg4{&=oH3XggB4+*m%4Jm6)TM^6rf0MA`KP+;nj{kf4Ys?K_sIeq60HoB?DuSSy zx(thoGn`jC{=givF1^2rK`#XL<^yZJLaw|PgT-K+!RmP>p1nys+HG0#TL0uE}8@|3K{LS%^K&%OW&% zO1yxanT`3eu1VFY6*Do&lIfA>i1eqA(oVFV8c>~Zm*~G$U|scd)mQQJ)YBPe+xFHL znXn|%R>ba9f!L_HB%F_D!s!Hhqq6)vB#Pee4@ajx`<~b_Iwgz0&K(thzIMH#w7OPz z|EgLmrQ{eVjSS%%R&z}YCdN0Ewj*2n3X2fsO(DwDS9yVaGOVLX3JrZXY2dT{&aGzk zitxX_ausFJj|d$d7JL`Cx>ooL(t4Y@+mXjQyi4{x*6RsT9GlHvkS5^w`A&r5Ql*8g z5$7xWT8Un3Q(sJ04^pu~5|CoBa@R`hwl4&VYYdd`gRa)Tm+=ozJ>xo1uGxz zd&0ssgy}h+(*)BFa160i!RNa^en=m%qCauteA9+JBpiw<1|zw{V&gzi*&;0&tTZ$AMaP1cYV0C3H(;AEOg>(pJcuG0|T169*Fe|R^|8I z`}n$>BaY9lc_;ot!Rrr8$-pftG5y0Aq630^FHb-$?3UFvR?~z6piMRW1c#K-+0L0J z->x6!e$vMwWcg4?=MU096xPO@FB8A^zX;U{04VguM<+!Uvp9E6(}RE<#bId_vKhy= z!=&-yY zqlV{}M<04<2dU`}j5TLKs@=;Me=LADm!H5Rcfi-ZDb^7p0#ftFKmh%mBGpzdJ@idS z*Hv8MqGqfLVs)8QXUFddl)N9V2MrE&qN+LLM3qb089B&B4usdqIBZLYl}ELk2%FsN40TEir~#WzD>&ZTq;fX zDQ);#&KNg34*aWbYq1xm(#P@AUPS0J)RMlE$k zwUmsW^=+!qGH3|>1`N5-+QYR948tj9MQI^?4&8Sg43#A9YN;GYHP`)s1%TZG zHbHAOnw9eWc{vi;Tm>KzcL}W_E1?HIs!qD*qy<7 z^M8pz0du&!ZKc3tJ0oh{bK6ri>SS$51wVGz=x{@kp)m}?7RSmmIKXnP6mYuQn%flT zU5d(;VSvF;-orG}M3z>n{{j-B(~)c6_KsFj(Nsj+c}WQ@SUpelbkx)7AOS8rN;Kuk zcldUFSWTw_5|KPDFU(yDL}A9Jn9(U)bi_!f+NQW~zQmH5%g26I z{s2?{im#Uly8U~Sp+{GQT07S39*gU?Pq!VlHk+{cIZp?RB_1o%+LbfzZLSdmQ1$XU zmTr=O7Ntk;Bh~IZTxOqxwGp+9j%4>y%5oy34p1r}F7tXg5Ri{kdd+s{54#`Ba<1AO zuPYSM*D*0UnE+Po<3LAl=$`=(AH8%$I)If%K{)1`3w{=LWrB=WVj2Ax#rWPd!mU{%Yr7&tuiBTKbp@e6a6n8 z!*W41RHvZLR?`>ou~9vd@q3jmlJbbX-8OTL;4U{dH~c0DEOa7dtY9s0EPbRJ){Jv8 zc5)=hL)M6!hlSuSy5#DtJ(~jF3U5kb=j6)j_t}V8 z)9v71m(k(Y7Dn0R>FN0>=5Z$}f}qjl;W?t2G1F=Dap;O^cBDUXt})O2XKG7^`+P|^ zY-3`U$1Al3FyzzOZ5FjI?}C;&Altns3ib;qY~Ykaw{ zQ5ApN_H^BZeAAUN@0wSkI{oeaE;R+XnV!=#u9)26Nl)J~WwWM!7mZ=WShhCpod=d| zARaSc9;zF3;7q3@5!0O%Z6DybY-RaFLc7_onYFu==+vxTc6f07Am6zO@fPLXBZN#YalA9Sfu59OlVDFnL{4iP-> zTlJ4Y36R77${FhGK<^iapx|f1+C`E=>~@|tfPr9kca&0PM%!$KbGF}paxdOyb0NRv z>)D3tK+@>~P3ScaM@rfl2qqUhvB2}+Q^V-I0Mr@ur?Bj?69c)g>6$l4K3 z?c3D%`hHv|twkSF0cyVHw;4D*25nH9-SOB8jLnWT8ab3~o~k{7f z^Mn=8i(tSd-ybe^-ePS9pOyjqt#7tM5ivZ?)BAg8kpo!dW=-!jWDq`N8Lttua0a(71~`i znM?rCqcFtYcP0i(~%!swc>&cgxj6HecNh74Q|<#QI@;Sp;rUITsoSEGmi z*%DfQ@sG}0BbX)>+5)VRn+6M3y1wrQCI@5DH=q&*vo1Z;$f}$1qdTxLbSB+NY3%CL znTFJHc;#>PnF#xmEvCLa@9R>=!>G{UP4pAvjM%k=b^^#7xAueu>rHc_t>zi~ zz%bK>Cb#}?*45E!TWe~>t|PP)FjjGz+7_(u&XlWF^Z(ymXmY>ZWL|v=r~&CTZ`(VI zelzAqxpxCB_7kThg;M#;vw^;RraTbyM zCWE;-_&FhFDVM=5c2~Ssq(+_>%~fFxTc#H{G48@9c2_L4IqZ6(c#HWiKD~mw*O6Vv zZe3OkcUv2smdj)mo?=*m*P32f&FP7hC5N5a zyZEY9Z5TH>|HIOH1xvqXSrP}EH$MUVJS7r#=^xBN&oq?qwk&6J(7*f(Z7r9$su}c@ zRU6NtdP}mqp5Y;^5@o!g88e-(>DBnRC0BS-2+8YRgS`}cw&V#HTr>zl61Zkud zek=L6AvIdAk1H1dEWyCOKY~oezDw%kj`@L)c;b8u6zAZvci2fL^BKB${1Ldj#M2Ed z*6hE%iGSQERJL8xzaRps9Jm2n*Kb33T+DfAx@KGhC#xx_K@x0ykmEJl4T4Z!1 zs=SWJANbPlM3&TdFrFo)2_{%CfjqtH&tcWCby6toGUeB&BATMbqhf@=8#De%K(OO9SxK^x` zqA0zsVRr+Upux2ljLEWJ3+Cg8mx}C0Kz!HOk-n6SSTzU(eO^8R7T?+~N~z8@($3@E zWf_#MMoB$!SW{v?H&orC~Fi&pZ6?%+0uKqLoB6Ob@Jo_%1|v;(jRL~>9|x&AG6 z=RMxXjp#ndn|pLiw&%XWCJt-1~wTO=Fe!tOjn;lo1cC4zHiXDyiQt>CE4dV<8K87}(SM=lc$+;1t|}P?rI8r>hWKY+E>( z1WteN+cw+$QZHAdo%wqr^Eh;SHNH*45nhe1aTMAQ$e-4RTD@8E_-|7OB~h3C=Sf~lJ2!gcQZ7Szdyt!f@1d+f&z-O3Pe zaIP@*;*XoPwRzVb`;v-Cc*iQyycbQ#B;2||`Mz?yj~=ozv_3yU1bS4D;rvK+rx~{6 z#sIY26uNZ|OJ~f=2kH{Cv{8!%i@A6;btcQz0(9JU0IwrfUH7~| z_~o{dnPDAAz?8OTd@|T-jDj$cU!ezPgy&9RLYdnaSa56ZzcDGYthxt`pZ=IOX>USz zS*&|IKLPx^8@e^c3IxZBhby@Fe`0AZ0ooSr`Hq9m#BDQ{j|zjNY&TlrFm8f2M&px% z$+(k&;cdxfm2tv;^N7l@fVtc%v=yS$^>|&sosN3Gi|9{;bYxz=WNq;?c+H|*gvO|X zi$uVaBCw-UafLb}T}0Wu6EgY4S7`{r74jjFfWX>QF*reJ2F z<;We0oqeR5VEJBi9iP101MCA|B_qRG^PV872SC2UF^quA#-WKXGTl0Fc;d4`vFun9BTJ%HjV2k1DH@n^ypq)9Bx1N6sWSH1`0eIJ6QG%Uw_9`*I;S19tqZZGXwGdDw zlTIplbo`(9+k4 z%A^j5!tuM!FxS_XzuAN|o6vEDZ|<|HP0A*&ks#gIarN6k#X(G0{}r9^+9$D?#wbU~ zLbkHcBGPBDbS|qn*J<4q-?M@=9W$hsk)sCr-_m^@hh8O@BYs9XYZqN z@M9^Dk#(-u8`f1$FudU2k{Iz~;c>KRZu2hG@XPkmhn1jq21tjq_Fd1jP4d7v7+fG^ zq<~ejP4e1VL^M*u(NA1(pVXEv2PO9tQ(-!4ZqHN(E<^o(v+#3}B#bQb9V=qp_voK4 zGWeoKt3PU~gv=R4qiw?)?V2y%QZrq_0O+O^0930ZO^DPN@)?b81o*_TJyQZguN> zm7$&L%bM?a*G5Y0ZXM0Exj?RLmpz@V6Z_%&;1sOU&-Y zm^Iy=a7^&%cy+Q>ZQP?6Q=CtY?0o6~#HS?fUxMOS&0U~eizt8L3stjAY*RHvMTY|~o@~#$OE+}AHzcpV?2r{tUeCO5=^}cw&yi#Bw z6V4PNTlAWN@AA1cih+bLbvA6M>cYd-U(@Yl=BB_RsAswybV_=&ZNtfNDEcg`Kq<|0*y>Ag5}{cLAg_oO6&;SU6Aec+(~ocalX9mk4tLcl59E0G2aui)LmRJ#kl z6{C4&;IkZNYGoR)X0JnP**!Ny!iCR=z?p#pUNbmxdAnFPSMpD3==~v~bI)3xXX)bt zO~{>LGr#zkey9e6GaMcSVtjMlz2;^DEDo3y9^tktJb!^&-rSS`9>gb}qA-@a(d;qn z7Gz=`Vdi+nOL2Ot={ZpSPPAJ7-D2049Sju&=c}qRZS`f~C6UeryUu5&LxxM{3Y?XK zT^r8}%iI6lCCf*1s8!$@Ua;+$1;6ZuZWMs9)ksP`Jw$n|85tcUdHUludE(8AJsfTE zW#NN|bq2hA+M#h@rbPN8O?#XH6(kyWS){T+1f3}p1!QtZ6IyhXUycfE#l+Dv% z<4qOQl>?!_sJCza^7#pI)e+55YaY(Cp_Wt%MT5=KrhZ(Lv>1N2+k9TQ>!&Bq7l_5q z?!17Jwn(XO^XZQ@;)?MTcqD60&2G>MLryzvR}&oHcv;&cp2?F8|Y? z1JTlLQmEk5&(+d#hKj;BR|#_IQS}OIN2bMAyiDH{J@e*Yn@%hx0|ps%3+t@bI&zmt z7enCf2NMHtlh!{lPW20ZEBRuA&1Bl~-OC6N`Exb%du>Dan+gGB-L91mF(K(CKZnq{ z&|u_g+!(P?yDi(N%<2I!(F)_PcWYo8U+KvQD^547r6O1~Y={#b9p#|;WO&acdj-1_ zxLCy$+yXeNNIXtvK44q)NT_jbdzI6KPo^Eim#d8wKK5hx2IVaT+EjYOFekn0cDJr# zUoS*^^VAQ4{Y0YhJ>93&TA5zyl@)-3+0D)?Th(iVC}0}^+5WlZ z&k&ofyfgUXlPw=7D-G81$sO^U8Ven3eXt=3adZPZ-f!A{vQ%9dw|Sj(=iVfp*r&Pb zIvQgw^t4=E2YGk_!l9mFei$>$7W2L4RnxSM0#2B1kQ^g%m zrx<7l#EhAFh#|=BW9RSc$yWd8*#${OKQI9xgaB>*QLr=lG$9BOIYoI(buo>9nsvMX zXV$&B{*E55+|DZ;bN%mDF&Kd#Hc-J+&>V6&2Iq)g-afh4hUQ5pz*Q@2hB2x5(4_h( zb^(#Q{?R%35C5>=6rFCPLi_tUV-yHJo=3fuu5FD`z@8JlG@j|J1B94uO5K&sPJv%6 zpg2q66_d5|1%Hd6bTGw=^PpxlLxEhcSGw}AZ5tUZJ7-TIMDzeF(?2C0F9!kM+mX{? zyJNq}IDI{7GuXb=?#Jne2h^_^2mu<~?7VZrbAvD3<4|6|IdTWs_oYeEk~&q+Air3F zEZViAX-93pU#>zY%%SY=k2ok8T^t&Le}K*!xrNtn(0)eSKM2*4+h-I}AVa54_H-&Q z$d<&?DOOS4$WEg=MpFKQZIc2r%ChzB3PgTeb0)qgE|4cQ#TjLnX}_F`*=!V-iOXr~ z_?Q5e2U|E3HvmlBu4_%Gn4ExOQr~y2=wiLL->=!`1bU~H>ZG0u-3Ls*j-uJdIFhmL zMU1waIp`1&J*_OGf)D35>{>qP2<}JJ-i?UuW$aU#m;pzJ@fkQI3%9*FC(Bw$vuD2p z!4(LmZ<+;#XA;+arH{E20*MQ>yDsZ>gSYWR^n=wS3aZ`S?X zRfyVeK=DG&B_H{%7uL7sJwS;N^64m50 zq$&ss*?)$STJ&GQi>Q@!?&u9#tbfni=aZ7pCof&uP%GT^%RRX`qN6}A#|BArfF*je zC9_-XaRUjuM8wD=6r2Rvk5CQ`xpT%@=2eKWfW? z=Mhy%8A<^ZV<@+h4nRVDA=(EbVzbw?H`!O6O;s^nKENe<0Ssxpo1g5{TccAaW6tKEYmk=e%CvgMx1DF3Hq${c%u{>4Uffzn>IWz-FiN;^=BLyhbGqON8@4P-R&i z!zrKJy3-VlW+X4X17kD+s~E?VXdB*&r60?6Xp>57;24CGo6jKx2bNsT`++tWnx?Cx zEim`v*lG7zISEKtL+cA7*7JK){m&76OHli#>os`}&SW~bhAfEN3}4u%2pN@w>Suf9 z+O=gE6d8C#kUm1hRT&W7hJVQXjI^kq4-_lhOY@jf9Gn8{ld9ZG;|F~5Qb^C|fS+

{O}4gaAv(yn+0J}O=upBkWcQD?(jGk1Dkz|lxBoj z5V8=0smwtP1f)5Cxf^dy)ZZx_~S~T7p7*qR88lzS%dD+0?qIP{$Hfp4lHP{ ztmOSXAF3do(RuOKI`e3|T>k(MOV9MmS-AczG9;2$OXqK2;b(w|I zft^4niQQNKC&O)qTM}t{P!~D}&{cu~MUh=-m}y;ZAM4L}d45!AV%HK&@>rj8(Yttp zxHAX5=2(cL4g9Nb8vCyGuZ!VThY|l?%Y4xk`0zNaw|yC#ul^H+4P(T%1hLfD;MlLN zzpeha7XbL@{~rwOK@^S2Y0+5AEORL+c|h6QE|J|kLF5cE$sm@eA=AD8|KMMbA~tf` z&a7o}JH8|T`Z-btC%Ztc0#u(>$G%50?^dM%!M-Bt@0kN?(K&p|4uPAajTe}1|IEZ` zcZW1~sU3X)v75yema{N}&uB~-pIgVSBkVO~fH9iayp(afDpQCU;_H3w1e>p(74$OA zvWnV~3=5=e-w}3`3nqXFqU4a<`Zw$9s9CJ!ZM}!xt22XMrVlXJjvd12>X(kN8(c5} zYn2iyxBVvb>faH)V9xvMayGAijt4GhbL_VZo8KX5Fh%(5g7liLwW}9-fpprJ++j|B zW^TbuO*Nb2=B*Tro2DeZ6>H%|sp;aJ(K_s1eB&o?ST~FR5ptuCA}fYQqqejD+G2kt z{t#NW@0uKBc_Cg5LZIn=O$#<3e&Z~7{*>TYU650K=m6Iq9(8ch>B4jj*^kzq#O4*D ztUaO;xxi>=XYXPD??vCgA4<$P`2k!&(Sx44f-YZe5XE-hM;N+%>-tdEv0MYy5u5ke zEqYzn<6S%fFQ4;7JL_eKAxEBihexZ~U2)DJM#5)1iQh3d$#DNz4OKoi-`=WJ6iK9i z=rePu`Dp-#YG$2RUdrbEpLzvDPh@I3@_*;td}j04RW7>1#7W^eqs!dknC>rmdxV&F zOpE>%zx}{zGTW0|Dag8i<;|BXs@&WrqN;rz7>wpH&BHpb`KnlMf>&^vWljqWZz|r&A{K)!6}sJ zUH>xdc`c9&%+YZRsYRQ5LIQ#L9d5qGg!w-G{+q%k=L}gEor3%?eQb!UrH&3>h33S* zlXZ8PuUQR--2(fDX-w*e(MKidhv*t#?>b?fE}GY@0IrDHcXwZ9aay;aM7Go}MqKow zBLT*{1|qbbd37e&o7HHmo*o1A2OShHlTs$iz;W38*N^u|3L*o63(ujer|&8IlW{eD z6i2?$&EjY+TJTbYA2Pbz{Yg7X zTbBzb=2>?X8oSHO#x5X1JnE>M*=D&`N6L!GjTPxCOgCHf&9#5H<=cfRmyuw)5#HnvfBjn*$@+dINhFJ0Z;j#)J%f*D-; zmbQzV*?ey=otAn+pU=&z`Ryg7+#5NW1EB8l=;;r?XpFb|Ji z_Gx3M!7FtM^VW{wikp_?PBDzw!|>oOLs|z>qudA3OnKswiD1amE5OZp1Od}oxP{bG zOz7P!qqtO0II|#JBh)qA#H+Fl1*Gg6j+S;Xje$<-c(2~>z$flQ`3^`KBys)6yV*(1vFC1S zPakEQjO#VhfE{Crf+{4&zT^e`)#24|mLz@{MM<9c%ou#75U0wG03-5=Kn@+5ou=Lx z+gAI9xhZo{Hnk`rxC}&uGD$koaiW@HZq`jw_R!b?$Jg_ZoEXuW59MKAx1Z-`H?)Kz z_z+r`mv7x$C&14kyyfG^$o>(pu7NeHG@RAx96J^dM20ONy)OxMGf*ZH$DBU*}i8YrzTGAqM+C zWXZ&)kN3);$<4_p=W>6h6Ia+e{*-1Ot)`=ye!uqVih;wddX7v?!t20zX&Z%1%)A0# z09QtdMeZbzivza?o3Z(nBpFaRXVt2Uq1>DNU(W*@GL=fa%OG|(EDbWyN#7ia$f_T> z1;R!+;|JR$cIn7bo@9@NxOZ$vEX_xA?{BTF04eP0U*;!+vh9%I>>DBt{o$91Qms0^ zu3~q@sQMK{G<>wu8taYEU!!O4%tlK3fO2M!bE(grljjG&2)5wFk0hQ zgRura%0u_cyO;m1E+-3!hcpstj_ z122S|-qMV~_2I@e&EhX6g)aVFW?r&(h|BRD#P(&=ppLZbK~CJ1$^PUX@!9DjnTzy= z?)NLP3j0c$b^1=_Cn4*q0vSLKj7GEo4-xkXn2!lj4gmh{);26kK+dbsRT~BgZB@Op zEQK)s)98hTTe~|B=xVbOJCP$;L|O#xM3GL`3-PwwW109`33-ANnn_h z&}^LsQrudl`O+7a^apprZ338#qPY%dn!zq;c6iybhB*+%XOgkNY_lLNY&h36twQk^HYmoqLclXoeE0wRNOmt-&6XygUVv#@AzT}wA^57q$F|`Jjvpb~W ztWw~3WDT1~wF&JV;>*a$_hkNVI~UGpLcMfCAkRk|)Y;Tik2g}Ff{QBig&fK^|GyT&hlRDF>`xjYtw_?j6a^0Pl~ zS&Z=X)E6?IQ9$0!mX{iRtX_i0_N_0}0xz4bxWsrR%uBg}g+QyUoT@bARHFsF1A@t# z4N;~W_>UX}hHQS=X9UsTP-%gqRh9kKKiNDD^(LrvLJ<5fDkO}V>l~deusrJF>v=T4 zB)g09ec_@#utW!xe-sXYB%k;CyCseTmtq^lev`gZhE2t$I5#n^>FTTI5+?pKq0FrGJ&>1E9jfCL<;(FBVs5rM$GkK=fdLRIWYed&3G6IfD2OcF$*;WAq{n{L zJxDMT51UXqWT12dr9b!{zwe7rb3g~FY9#<-GCs@kv3{I>eNx*IxLaF28z1k{?7qJ{ z7&dlq@myf!Af{d}UU13WWUaC?W?wuUx5nQs+fWMLRdJ&@V?k`!j~M6qq$`LM35Ty& zY9%~qAnq-Ky|ras(0|@i|1l%|e72zD!rPmFEXZ?Ia2@ZrIo|(KE~2e+vU0;K7XOS( zq5mu52)r!PiM{!YHhZ-_fBeEitp4#EO6PwdcPD@aRjU^+n`R7acV23SLanVxJ-6BQT2la`rGtrO7#|Ut2d(NwtySsZlk74_ z@C`#7R0@Wnqsj9ddOBu@zsJZ7B8M=B%y-a5}t^i$o!B#)27VltxtDt#^eE! zTG%|+wXsrapZX0Y3ZE-5r8>Q_*K*AqxqkCx9rYP4rT7Q1W?uR8TP!=x9rzi~{b=$9 zwDu6Fed3POvi+6u!Ev?P#6pH;YsObG7IXPVh2b|y|7XZo@ z#oI$tO}D#3ai!$Jh8{S3-G`jO%eq~Q+rTeGR}1J%F1-uB9sBqJ z!*}w~=;NC}#{uN18vDb*$c_`-Qun!K0^8lYSlRVLb|)nQd8gP$XHM6yC*uOs@pJpZ z^CGNs&twaO)p#apKAk|5QxwJCS|@eiF1JMpHi^?o<1Pq*@cRyhTY9G&ice!}H$Mju zw(phDLt$FcQlhP-TyME@%V?Cy^H$XnOZ{Ogm^GYiu!~M?FwGm2d-Xot$o~B0 z?Ro7^n#PzfIo2)Uoc1to70&upBQ462SxrqLH3;6@<_ep4u~!$Cciv%B@U{ca4pvJQ z1IHb6*zRk`IbN4vhb7CtUAkAirE;v%w+WF>4?sn43ay+-iOC9%F62!N@5Bq8p4+4f z_S(>Q-6~+zvDXloI{I6{xcK-zwG%#_tYs(2V!F*pI{xycd_`Y~ru*qZeto$8=JK`m zdVK;u16}$$UIh`;5e;Pjn$3=L!;nv@}STqJn0BKkFu-$H5fV4?UN)?Vd;x0%!Q%J=%HfA%jj z*~O1B=ThKCZNi8jSzX-!tzcg*$J%!#^x_@{s zo8x82L!^#Wn`K>&nZMn#pMy>KK?Pwo>1W$69b#TjMI9Qcn$KS#Pr}7+oiT<|A%=_a z{JuBy$K&gfQglxA&`~yj{j3HIcZ~v3Ar@dtMMmzrgD=?>PyOMi52uxMjgzv>`#oii z;DFJ_NOn=b{W-87CwB6OvMv~a`U5&AwzK{CfZO@H{yp>?zCe>~Ft_wJTkj6w9+Y5^ zQYsbo-^Pw0DXn^9HtX*9qlSKB%Nh=LciJ%Y_0P0j$z*+fIQ@{^*{n^LEM*4NJY`4~ z!Rh+~EOllnRDO0_bo&w3b0x2)l-a$c0g}{D>NH|~%0=(uGeWwyDq>i#J_r7lV9>0{ zu7ff&d&1$_a>nN1M@1VOK{3yq&4Jqsnr0=gfO6Kf-;Z1c{w`2t7b^b_B@w>WHt`PY z>Sz+D@8mlXIVh(2Sf$`cckL~EqTK3)p7>N<2QtW_l23}HOyDJ=-5BS zk9PHE*R)uZ-WZ*cQQ|IB~Q4;XM(d zMB2#i8SCl@yT+AdZ)W%EprOT_xaPf;`H>!SpsOF`X7|H;B4UlZk^Ot-)rZh(y`Y%Q z*sT{mN&dMibsbzT=YJwcn4urZhZh|&%*i}q0Hf9+uk!k+e9GamV{LHW} zx?ilKs=_2)>bnM!0U>m^6qzp?*=C#oOH+9;t~6MpJH3kWD5n%*KBe^IFL1K?UOyYb zUyiw>8pO?s5`&y2B3uygPd7KVbd+4$JZ*Axc#VklLq zUJ1r<-QX`4h}wC44oF)Hy-RL5is%%RCq%4UAmBiiPFv_fmbmaZKYI&SFn1veimKdD zWE;fhXJ)jYgSAmiW&U)lP0yJ3*q7k;EY+EOMC^s*jCIRe@#2jr*N{5@F{FMT0gZow zr9Av_x~%}CNdmjkYjopw3G9}he;R=M7vWm8ZDTnAlt>r*sPxV`{5s^8GDCrJ7v zNDd6SZJ?WjeAQG5z6<7qnSIs^OXf*jKo%$UfKNF^W0cW+g3^c%qnn<7M}*DMxp8j+ z4A06mgO&+6WCVkOn!Hk^#9_OJ%T=P?aL(`t$MdvI-K6d+al(U?H--D}Qu}CHr^$mI zB4UtwaL%D*D)S0bAfTfU9kx<>(+76P&#EWJFo1duL~^LmtWN+9oy5c-A<jv`d?%%M-s0rOjl`PU7gia6TdGx{BzVfKm^+(%Q7o%=Uzc z*J&=XQFyza@!>D7gAdZQQHx#cij8W^Cm^l@;u#Q5{rp5#cwLg~@FDu2s0|#VEOCG@ zd3d~{EX>e!JAx*o%K2oSF2?{3e;nC3_B;UZLex5_I`T6hR@y$lGT_9XLI@4_bp*Y9 z*vqt&%oR`pZmLSJshQ2O36wbKLtzJ=-P73XQmIQPb+q!%9I%hS5`<}0{%);x-dGn>rA{_~Cz%Qc>Eiv9J6aQ{|SmsC62cPjiLukb#Y4LO)Kw~dnp@9 zTUJMIf>X3Jb!5!A#rGr^~&YLDY{@ z>=`!g6Cb!>%IoM(;Nmxt_|s|O$z_#d5K!-?K8F)w{#qL(`-&>nS6YKr0a)+kI?pMzz-J` zJvmL~TOo0rk!WFeLAAdoRWBC81WHR6N^&BWaR|Q8GK99jZ7{k>-p#z|OTM$)$5P^BdGic@8bRz}}d% zXe3j!7)F4E$FCnA?w`G_O(rt`K6I}-`B#jz?c1a6&{NJpx)s2ayP+-lz&FC|kyJ;< z_x0nz6R<3#F#2&CVo;}7N`E5%n^of--HL?o8QDKf^}`CU-g)Q9W-s-nOLoP_uS)r} zYsa%$qkV3tRa8_QIbWRHvBmH9`kQZ_-xj+0(&gyV{TeE6iF*x>Yp)V~qH<_(uAC_A32j*2M6125(E|lY_ zM^>!k-H1A(BcSn3Y!mhEmsFu6V1x#AfG-r}ssOBpY)9G#W$N{jEYixXNlk*QI+9}r z%{(1b!6IHr*S+*LInq*U>rtQs;<)ssr{7luQy7H8jZDML$G6hG)Z z=-3cXRn#K|^SQT6*gPJ4jQ#Ws_a&I{i;{q3lPwvHkgQX-aC|XusvTjoTnm8noWGo{tjfZum+rE@o-=JXy=1gpJz8fS~JjIZ}on!n{LP**D zE^t{U54Myz_)bPU4qhSF1g94|X#kG#vgPn#B@~7{!Z99a+%OX_va~_=FV`R|t;jP`?DC48_MB>1GIvCQ?y)&e z9D|&xQ6iQ`@~Cf<`3SE+$z*V%MO1Dj1kG{Fz45TGu||JiC| zUK1m`XK$G=r4M|WuI z;xR3WU93=Uhvjgjl--4BI~1rk`h(U_ zpi1h#S9lKi7lta+V9xupr8Yj1xyu$b+#+V<%sl^PPJr&7N>7^DZgmkgU^ zT6ayfv-oEX8k&G!J5ThrPObQQkFY=!a(lgweC%o(2u_c-zI%Il1Dy??wPae=ws^J#a;1Mt)ix0jwDyLy8L z$wT+Wv6QMH`2-@pjab@7q)l65!g^k0En#pQBQv6}=uyZ=aRI{)vyN`muO$8lP)8B2 z1ZXcK@1uhnmKzQV){SCQMU-%(ESm~!U%qWWg?t&TcE*E84N7|74hr#DiSPJ}PcFM9 z>lMimKM^+43T0Tsw%f{sFG9N!i3ic9)=9T-1d7Jdtp0jz&<~Lc+(VP1K`Z4irp8wr z-!WVodl~J@E5AhoivlXWrtwKj$$5L0%qi0cL)2aHV$(zix)@2p?DY_uWh?nTE-FxJ zu~#CbT09bF8}sm-2sM1A-sA4QWDbF<+pS_YDHo5a2Gts0r+I=Ai|UcMh{tHE6>r|3&?jqgo1Q z2VRK%ygGui^n$Ah^jjl7DWZAzvk9;tNroRdzj-il6PMXUT6wPSmq>m%j#Sk|ujtKd zH#gP-V6$_+bHv6wWKMgNBzM**)2YpuL$$ea;xk7L!5vXD?5A5}6tQ~g zVB%yFF%bf0lw8kW#asWvTNjaM->*z6152Zh5vL)aPdo3Gnh^4fTBg41`p$*&Sb&p~ zZE;Ma0_NE>^5bJYLEqQoCr7I?xt1CfjWBxjPC%E(HGGIdwBEnN`J7A-1A zrcb}RovrAp0tiq{1h|2Q99V*nI3n!TEw6L z;kEhr&hyp9iTzI{T^O3s0zhAC^<}l#?NQxhYm49bnsk?Fb}IsNX| z`PyYGQ@0~j_yM=%ex-$|Tf5hNWt=yG)KH#In%8bjqH`}~zMH#rk8dk97Y4hwhou)G z@-tc>mW@o)OnRWbWbOJEXm?3S6^64Aq{ znz7rPZ9(=*4MJ)B$@!S3}a_tw&HEU&$qa_4tRWgD(c=$ZB) z&UZEqJuq7HHLtaK9i!{^H5m3Kc@=vWP_XFkq!I}I7ST*{b(u>t8TxDrI`X6BtLM_H zOgi(NjX{|%0d%PEW4-f7IwWXle3{Ybn#Kc*k}X3q{nKq%`t80L-@uFV&7h}>M}ZQt zoDE1Fzvz|G&mi^i8tVF?;o%8iw98$Y zKfNOlUQ&T*kUyIe?Hx_%=f(cvJuV6mK;DaPZZ+*ex}UMCJU(a%lU_by^-NUk(be_X2Wy|9 ztLy(m>jmTG|Dg362!Od@`2ULg?yx4du3s#u=s^%flxhQ1#HfHsk0L4^rAb$50z#zM zQ1l=w3X0OD2+~XFNJ~_jbVQ2OC`EcrXbF&Sj|txIJ?FjG@vnRS@Og$aGug9OUwf_J zYLfz31JGs>A-sRgJSW`ta6hng#N9Dv>iun5;OVK3ep=VwZ+E|i8*t?Gs9PwNOGeqi zrO_=hxUtAi=zMaSMUVP)iZpn-JH404C;gwE94 zUv0pSLsJ(zRWmc;9y3dWo@o5bNYchhEp%A9#~f~baojjqdwSN}ebj!$w4eRp)_472 zi5jRjgob~JYc42IiT(=ep~)zdfQvTY4)|Ng#&YAF7V`2JIy&I?R;sH4I@ynpM^VXk zEC4*Nd&3ECH+b657HAgzgFm?|MFzZVJUx{SrlN?0rUZnjpMy?mv&QU(Hn0F7^_T$u zmvmjKFiZw$gBo-jU;SzfhfZwOgfihCxrTt#YRuch9IA5h<$-MYp3BiRmGC=4#{B>c zV4XFzkE&#zK$5V^0ULeXT@FxOtnC?%0UVXUrM@Q*+}fl@zyO_h$AqX-zgGu5{jLBu z_&6~MY#eHwlg0p}!Qe9Ns}$VU+DM22R$}Sse$q)@3NXMxJM81y=i9;kQkoyQX#1`T zEQQMx_)X!iVCVYPXu##iUW287SA=~wK*gh|+i1i?S^y$SCL{{|R#DQd&MR=g5(}1g z&ixT^9D9-`KU~Q%0G~RN#>G!l^^Q<+$PvYEm>lQxejLb0dcb*_maqpb7fWV=J)Y#} zoQ3+_@V(TJZ3zWir!O%LQ*M2b*5KDOYv0j|h=!n&fucm%5HdqxIEhT>@ELKcaL4fh zE(p~$fSD+ZTT)rZf-W7*rc_sLnK)W@@0?kR*;knCV7j z9Hg1JLt1H$+b78K*ec#S4ENWeX7D$4zlym)eDw##T!xThdJ<_tlNTe%SJCo%0N2Q7 zgQfckZNSGs(}6I3-LPx9NwYc=RuV5b3A?1{J22_Hj5p9@3ZNo94^h~q zTttX!YRATDtw46l{S?U6=}s*Op?%8lXcs2{*6wj#! z_AaV3-VPBREegMk3)JsnS?V_G_uQfSy({8QaBI*aA)-fI*QdI$DLh~!##0kRVCvYo zV6gU(wsW-9N6Qg#Dg7~p6(-T!Aam3hvH=z|2RJCeSnlWa0T>nri30Xy>0!wknt8E> zEMq`(#eXI7zd0yH7kq1^&<0k_0ALyRB4=~BMW6k^9hy-=Zxrttf)vOMOO!uV>-={0 z>IAS;q7+s-s-b)W5xp!j0&We~JXDJ0e`2GAs|CV0Q?;{%9l$|5M?Ov?vL93`Y*4EV zcbZ8t)bb>MK>25%;ST0e$gQ;a1DqJheNy;^6SE&I{o|{;OE9J7xgfaTAf&>Srrra= zm$+O~_}P>6ZyNvmFE{y%kROAOd~kBieZ zJ@vB%#!x{S?)(xzNXK4^*qB##2bg8NW(8c9-Qfsnri5Sf%8G&FX;wL|3^)An16z&I zELNt4-d6!3{s1RM5Qv-MHNsysUk+-MD6d1oom#aQIB(eOL}9z1bXG3~PZ#KW2*M3N zU4SVpO&FmKT8q;GmmYq7aWM7NF$hxbyV9LaKktu&96M{w4{eyT?i&NBHp3u~rU^S6 zWZRAvefS-x(|AW+6nv|e#s-R90d)8(Spd7doA?&2UCnBoHnJ+^5xA5Ohdr_?4Ju_S z3D#r&NwyR(Ao}AN_#kpzVC}=|?E+Myt80VDbLYq5W{R|+s{Vq+0&0Fmy&Sx(T_66W zGI7A5^{MG7s%nTk2_84Q)ed*aTN(skHLmolwi^&V9h0ODH{|>Y0C}-%Kb6IhK|s$e z9ZPP4OLSqdSWykDUDQhSc8KWG1@KF|p*dy2-5WLi?oilvWxo?#^vFnv=*7YMRNS&- zSimxK*02HOMxn~?eswY0e7Y7PaA`Z|2G_QULPXC?ETU=#bp!D9KnHC6xE83eyF3+j zmqv6YaA|m(KxN;5+oFH|#R?+&k6%;D<^a(HbcBWBCOLS({RDM-2ij{T_<(*se(D)a z!;1U{cFtXvp0@ORVCjB>ut%95WC!;bAA6ucQ!~*}5cU*)^OriL-4!;Pzy7?&1Gq!! z_Td}qeGed8;4w>D-r)DXY&x*3m{S8Z%|L|>Q8K*`Q$c@91T1>0{`Pg6wCRJbuo-&? z8*DZc%Kh^XN>J6*b7(?hZ)kNTOksU)4emDxs~Mu+?;8rZK>xZO+?uGZ-OxFP+9x!X z?gw2UIts#vnq`LgoIeOlFB+Ouz{IALIFdeBR@4@u!3@m&eo`5m`pPo z2$;r&D5XR@#(+*WFxi}Nv+;f)r-<-m5TZWa203<9?Y&Q6%6bbc*f;4nDNHnBj|Z1* z!{^}k8m3(a-)g03dFbc2#yJCyvrg{NhMU%lfg&db6*MiA#s)>8JM!SxV5>twhgv$n zkY#_ie2Erbq<+e8^9-+`L^4+ziRSRv0Vmd2+b9}tcE}3wcY0y|KB~u_1`*xe+8TCG zbTXimxYNSV>cy=)s93`p5^x*7phj>V^kX4vQbaQrylkPp?Fmdpq0Rslh2k+zT6Spk z8o1;cZiAcTu!4wgu4qH+_i_hBPfrfjhHKRofwbsc@3}!04`dJ&y6;F(g}ZhKKy*T$9-r_nn6gG~Ej8O1ZypD^mC>JDX%XB%y`O)xf+Dz| zj{#3(nOk7#yENc8glB>K9khPo$x1+}*gb!MC+h^{qh0>>Mz9Q6t{MGU8E!(d7$~`B zGhJm`@!TEgz=~E-0f%ejM8U6jm>O)HT>zeo?P-PG4Q>xAAz~-yH^5|Dpp=W!i7eP> z7am~erx=RWs7oD!Fr8ia&K!bC_q|X`lG*GR{5&wrXbr|1n3nNi3#6F>f5FcW0mUOD zmUwy(++PPkyjb<&Uvtetz`F#0u6Y)ePm*sGrZF7`ikwd1U;~fe089TEy3q+f1)lD- zoq|2qybto417j>`=^-QNlFb?Rbn96_H9y2gBRJ&PVag+6Pc?Uks3x#?VFP;}O4r2q zZi9K^glq>Jr=xOQh?>u7gWQ{`wr)kZ9?46vcInhq1eM5fhruP=t#j0)h~I09G)Oaz zD_ULnNwzo=WTkP{+HisY?7`Z@xzJktw31;;ONu+-xHLo#{ZALzcN`)*HWL0sa|rgC!E9rcy)=~5 zOL#2-m*|aPv7O4PLR7a^GYD+NLR+iizg78v{foK+Si7PXCoMZP3WaSvx7y&&L$`v6 z{zK9B1C{8@fMu#MZ#LRif46^eV!%Fl$n}NOh+YIPORGlU+P1a~@U4xZ8!g~=fMo*o zC57Rp1W}M)Ny2W-u|EYJT|91-``w~xrX$4->{R40p!q65bc9i31KcEs8uoa09a-u{x5!-nsJ2ON@2ZjS_Jpo zUq?dj)6wr6wK&k(!!1R#_}@N9b)P;#AoE#uw>Cgxu7EF*{1cEE(E5cdc|_9;2bTcL z6(e9{%pVMc?mrozK(oU(P~e|9$U_bMf1kn62dF~$$fpz3k44%7o^#OWV1+BJSdptB2wDp8nbmH7@d&OrLm63saEg2j(y9p#6clDr7$&K|GKPpjY&0cIJM_8l(E zZk2#E)3xJMG_LD~xF~5a?2$AVAudfb;HQP#Zvi2^w!>tagDp^*Usj46t-N_u3tSov zi=Br_x1CVH@U=C9dVh)`c)B~YJOpm^Aqm#n_nB~#`fDxFNk;icTXmRZ+Y99sXZiB! ze%`MRId%m)4uUXc9jONPdFk(X8QQi#fo$8Wo|`atE(OBTPdmN=4$}=q`q6s&aFgKf zP$F4Cbb;1lqzNUG4>!=z7=F71WILd_j-i4O^?XYc2Sk6N^DAs@nB8FQ_9^2pX@OTd zcwE=bi5dg`S9A8i1=u$YI%nx_-IzdQ1YS0tnHd7p1CM(R=rr8czA;Q=A9y@BdmL_d zNDE4eEbtW~sYFMEm$mC?2*M3HAuK1sH+O0CXX35^z2Wgn!{WC)PTi@L17NX{#|!*u z9tlMB7(G3>R{aE2Orc<7Lfa{6C~Q0OR01v#R3jjIr$Ma{Rk7@a>P(kKVdKIO9|9_) zQaEWuABAeZik79|+O|lD=v}S)R7pRU1)jFEh7Aidssc8yzfJ5MP12!~uTwd0aF1t2 zA)*sxH_`p1Q=BUxdR02?;WG!B!2ND1_r*67_`o{M>U4l?fRfa1q|L9&Bg$^mN zyvm2kaR8r@etdmpNR~qzH@b1Q_}s!*sId1$^A}+;xZm&zijq}#ndnh>9615#k=gSO z_8CUzuD15(DC_N{4sGsD?-=2CQ{yOA1Otk~L`hlzyj1CcKK1Dx}KFU58_TTC| znkkIi0#?n9Y^5FQe+mQNgdM+i4ki~JgR<7}$A_{_Wz)(>;{NoklxcHNdwa9T znD3(!!}-&k4jWtW#|6$-o0<5*WcH<_>`Qu64>f42=8pq|82ahVbWE&=zDVV|TTEi{ zhPL?QwxGT5q`Q2*`Wg2y#*Tm661njncTjVM?Nqu6R}~(Me;+gf_{T+FPQ)|oQJxre z{F}O^Z*r`c#QI#2Ktfj5DVbSc>39?#8y$Jkx>*)Xw>`5E<8ixT^bA1oV3laM5IVOn z4pWt;4;R#}MCf#)ZGUfZ82^Fy2$xbp?!89e3WjUb_tu{1Fi6Ofv(_y>dwXSq@iWHw z5?+SeBT0_i8U#PST)V(Hb?&)APE>=r>q5IujgM&OWZPYRkM*Z0FX0$4H#GzEMNLwu zI*1pa>SdjoLx;}P>UD={8bL{A7+{uY59hY34`qS5Tp3uKoRo9;WYtVuN!3dh#7 z2J1n)bbJU*sUW1#$p1Yr<7Q_)6wVl7hisD_tiaT<#KdSl}mx`PB-^q z!-X7T2%FugjCDd1^kj|VaKpbl>Di);mwU$5!Z;kE zEayy|HyI&f;61bYjx`{q&?K0hu1Vbe!3~Rd2hr(Q zZ9yOWHQ$cSv)s{_tecx7MFpqJm%?(!lAZekh8yo3<&{^u`CmM&>LK?oeGPWC?VqnUcVNfzxX9!m z+r~7?%BysLQbl&A%U%6x&$~ecAJN>$Yw((Nr3~fF(Wv#@PL9Lq?*qoo*vM$q^T~_e zU3Q!`j}A@YZnikCK?VQnyMKN?cY0~Fi{oo6lmGx`dOu>~X3^0K*%!??`U zIU{Pa#j9d0K?m12StcD63JNl$zr5fc?QxfhHn7}I;x6LYJL2i}z?`6BT((?i)?9sm zi2i|zY>BGpC|WM659OX)V*SNqs_~7bJ~+47tN#tavpoj*R)@e~sQn3-pFQzfb6+>c z+!3NPHa6y6AdJ+cyf|XAJo^J7BC2IGwUT7hEn!q_Z+7xV_CZeTKBtbyZ{+kTlxH>z z8bpuHM0rfy3f%Z#XRA!aw$UZU&BUcw4$FC%XjUBBQ^C`<^OjwMZ$kgsHp-ffrPRWz zbxz+q-<*Z;OO^>1ot%FKScL z-$cr9bXsZ%0u>B3(=!Hws^X^QlR1S3_~POB8I7!Jh=5c|(Rm(<3rmuU*Y+rzud-w` z_iSv%?FU0*-{pLeIrIRtey{QJ$1`1rcgwD3?+1W62ILCfYA}T7^Sf*?ExS6#!|R~T z+*}Zj@2dAYJ$q#=4@Ki?&us%w!c$?6SWEYN0Ee&|YQf$w>*e{{eY~<-UuDazj-i{G z6c`0(_eDjl=Dy!9j-I>upD)kVs(Bvn2M8u&MuOZT==Je*OyDN#EYi%^AOMCpy}A

Gg? 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