From 3d1baa837e1353218da4430eee423c6f7dedc202 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Thu, 12 Nov 2026 02:28:24 +0700 Subject: [PATCH 1/5] perf(macos): fewer PostgreSQL connect round trips and no per-table column preload --- .../BigQueryPluginDriver.swift | 2 + .../CassandraPlugin.swift | 2 + .../ClickHousePluginDriver+Schema.swift | 2 + .../CloudflareD1PluginDriver.swift | 2 + .../DamengPluginDriver+Schema.swift | 2 + .../DuckDBDriverPlugin/DuckDBPlugin.swift | 2 + .../DynamoDBPluginDriver+Schema.swift | 2 + .../LibSQLPluginDriver.swift | 2 + .../MSSQLPluginDriver+Schema.swift | 2 + .../MemcachedPluginDriver.swift | 2 + .../OracleDriverPlugin/OraclePlugin.swift | 2 + .../CockroachPluginDriver.swift | 2 + .../LibPQDriverCore.swift | 57 ++++++++++ .../LibPQPluginConnection.swift | 100 ++++++++++++++---- .../PostgreSQLPluginDriver+EnumTypes.swift | 4 +- ...PostgreSQLPluginDriver+ServerSupport.swift | 4 +- .../PostgreSQLPluginDriver.swift | 28 +++-- .../RedshiftPluginDriver.swift | 2 + .../LibPQScriptedServer.swift | 56 +++++++++- .../PostgreSQLConnectRoundTripTests.swift | 69 ++++++++++++ .../RedisDriverPlugin/RedisPluginDriver.swift | 2 + .../SnowflakePluginDriver.swift | 2 + .../PluginDatabaseDriver.swift | 4 + .../Core/Autocomplete/SQLSchemaProvider.swift | 11 ++ .../Core/Database/DatabaseDriver.swift | 7 +- .../Core/Plugins/PluginDriverAdapter.swift | 2 + .../SQLSchemaProviderFallbackTests.swift | 2 + .../Autocomplete/SQLSchemaProviderTests.swift | 51 +++++++++ 28 files changed, 386 insertions(+), 39 deletions(-) create mode 100644 apple/Plugins/PostgreSQLDriverTests/PostgreSQLConnectRoundTripTests.swift diff --git a/apple/Plugins/BigQueryDriverPlugin/BigQueryPluginDriver.swift b/apple/Plugins/BigQueryDriverPlugin/BigQueryPluginDriver.swift index 103e191ecc..a67fb55d13 100644 --- a/apple/Plugins/BigQueryDriverPlugin/BigQueryPluginDriver.swift +++ b/apple/Plugins/BigQueryDriverPlugin/BigQueryPluginDriver.swift @@ -415,6 +415,8 @@ internal final class BigQueryPluginDriver: PluginDatabaseDriver, @unchecked Send ) } + var fetchesAllColumnsInOneRequest: Bool { true } + func fetchAllColumns(schema: String?) async throws -> [String: [PluginColumnInfo]] { let datasetId = dataset(for: schema) guard !datasetId.isEmpty else { return [:] } diff --git a/apple/Plugins/CassandraDriverPlugin/CassandraPlugin.swift b/apple/Plugins/CassandraDriverPlugin/CassandraPlugin.swift index 64b527cbf6..e5bbf43f02 100644 --- a/apple/Plugins/CassandraDriverPlugin/CassandraPlugin.swift +++ b/apple/Plugins/CassandraDriverPlugin/CassandraPlugin.swift @@ -559,6 +559,8 @@ internal final class CassandraPluginDriver: PluginDatabaseDriver, @unchecked Sen } } + var fetchesAllColumnsInOneRequest: Bool { true } + func fetchAllColumns(schema: String?) async throws -> [String: [PluginColumnInfo]] { let ks = resolveKeyspace(schema) let query = """ diff --git a/apple/Plugins/ClickHouseDriverPlugin/ClickHousePluginDriver+Schema.swift b/apple/Plugins/ClickHouseDriverPlugin/ClickHousePluginDriver+Schema.swift index c9b04b9c9b..91ee397d3d 100644 --- a/apple/Plugins/ClickHouseDriverPlugin/ClickHousePluginDriver+Schema.swift +++ b/apple/Plugins/ClickHouseDriverPlugin/ClickHousePluginDriver+Schema.swift @@ -118,6 +118,8 @@ nonisolated extension ClickHousePluginDriver { """ } + var fetchesAllColumnsInOneRequest: Bool { true } + func fetchAllColumns(schema: String?) async throws -> [String: [PluginColumnInfo]] { // Pre-fetch PK columns for all tables. Falls back to sorting_key when // primary_key is empty (MergeTree without explicit PRIMARY KEY clause). diff --git a/apple/Plugins/CloudflareD1DriverPlugin/CloudflareD1PluginDriver.swift b/apple/Plugins/CloudflareD1DriverPlugin/CloudflareD1PluginDriver.swift index 3ef3e11102..cb3e9b4506 100644 --- a/apple/Plugins/CloudflareD1DriverPlugin/CloudflareD1PluginDriver.swift +++ b/apple/Plugins/CloudflareD1DriverPlugin/CloudflareD1PluginDriver.swift @@ -361,6 +361,8 @@ nonisolated final class CloudflareD1PluginDriver: PluginDatabaseDriver, @uncheck } } + var fetchesAllColumnsInOneRequest: Bool { true } + func fetchAllColumns(schema: String?) async throws -> [String: [PluginColumnInfo]] { let query = """ SELECT m.name AS tbl, p.cid, p.name, p.type, p."notnull", p.dflt_value, p.pk diff --git a/apple/Plugins/DamengDriverPlugin/DamengPluginDriver+Schema.swift b/apple/Plugins/DamengDriverPlugin/DamengPluginDriver+Schema.swift index 8b49aa22e7..50aae42be1 100644 --- a/apple/Plugins/DamengDriverPlugin/DamengPluginDriver+Schema.swift +++ b/apple/Plugins/DamengDriverPlugin/DamengPluginDriver+Schema.swift @@ -103,6 +103,8 @@ extension DamengPluginDriver { } } + var fetchesAllColumnsInOneRequest: Bool { true } + func fetchAllColumns(schema: String?) async throws -> [String: [PluginColumnInfo]] { let owner = effectiveSchema(schema) let result = try await executeParameterized( diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBPlugin.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBPlugin.swift index 19da1b5586..88d68c71c3 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBPlugin.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBPlugin.swift @@ -859,6 +859,8 @@ final class DuckDBPluginDriver: PluginDatabaseDriver, @unchecked Sendable { } } + var fetchesAllColumnsInOneRequest: Bool { true } + func fetchAllColumns(schema: String?) async throws -> [String: [PluginColumnInfo]] { let schemaName = resolveSchema(schema) let catalog = try requireCatalog() diff --git a/apple/Plugins/DynamoDBDriverPlugin/DynamoDBPluginDriver+Schema.swift b/apple/Plugins/DynamoDBDriverPlugin/DynamoDBPluginDriver+Schema.swift index b7a62af00f..435ad7aaca 100644 --- a/apple/Plugins/DynamoDBDriverPlugin/DynamoDBPluginDriver+Schema.swift +++ b/apple/Plugins/DynamoDBDriverPlugin/DynamoDBPluginDriver+Schema.swift @@ -73,6 +73,8 @@ extension DynamoDBPluginDriver { ) } + var fetchesAllColumnsInOneRequest: Bool { true } + /// Columns for autocomplete, from the tables already described, with no request at all. The /// app asks for every table on connect, and answering by sampling each one read up to 300 /// tables in the background. diff --git a/apple/Plugins/LibSQLDriverPlugin/LibSQLPluginDriver.swift b/apple/Plugins/LibSQLDriverPlugin/LibSQLPluginDriver.swift index c60cbb0d99..5c9478a233 100644 --- a/apple/Plugins/LibSQLDriverPlugin/LibSQLPluginDriver.swift +++ b/apple/Plugins/LibSQLDriverPlugin/LibSQLPluginDriver.swift @@ -383,6 +383,8 @@ final class LibSQLPluginDriver: PluginDatabaseDriver, @unchecked Sendable { } } + var fetchesAllColumnsInOneRequest: Bool { true } + func fetchAllColumns(schema: String?) async throws -> [String: [PluginColumnInfo]] { let query = """ SELECT m.name AS tbl, p.cid, p.name, p.type, p."notnull", p.dflt_value, p.pk diff --git a/apple/Plugins/MSSQLDriverPlugin/MSSQLPluginDriver+Schema.swift b/apple/Plugins/MSSQLDriverPlugin/MSSQLPluginDriver+Schema.swift index 9bf02abdf9..034fe2b2ff 100644 --- a/apple/Plugins/MSSQLDriverPlugin/MSSQLPluginDriver+Schema.swift +++ b/apple/Plugins/MSSQLDriverPlugin/MSSQLPluginDriver+Schema.swift @@ -266,6 +266,8 @@ extension MSSQLPluginDriver { return "DROP TRIGGER \(quoteIdentifier(resolved)).\(quoteIdentifier(name))" } + var fetchesAllColumnsInOneRequest: Bool { true } + func fetchAllColumns(schema: String?) async throws -> [String: [PluginColumnInfo]] { let result = try await execute(query: MSSQLSchemaQueries.allColumns(schema: effectiveSchema(schema))) var columnsByTable: [String: [PluginColumnInfo]] = [:] diff --git a/apple/Plugins/MemcachedDriverPlugin/MemcachedPluginDriver.swift b/apple/Plugins/MemcachedDriverPlugin/MemcachedPluginDriver.swift index 93d1cda577..82ae7dfff6 100644 --- a/apple/Plugins/MemcachedDriverPlugin/MemcachedPluginDriver.swift +++ b/apple/Plugins/MemcachedDriverPlugin/MemcachedPluginDriver.swift @@ -417,6 +417,8 @@ final class MemcachedPluginDriver: PluginDatabaseDriver, @unchecked Sendable { ] } + var fetchesAllColumnsInOneRequest: Bool { true } + func fetchAllColumns(schema: String?) async throws -> [String: [PluginColumnInfo]] { [MemcachedPlugin.keysTable: try await fetchColumns(table: MemcachedPlugin.keysTable, schema: schema)] } diff --git a/apple/Plugins/OracleDriverPlugin/OraclePlugin.swift b/apple/Plugins/OracleDriverPlugin/OraclePlugin.swift index f71b06fe00..9f364ae3d4 100644 --- a/apple/Plugins/OracleDriverPlugin/OraclePlugin.swift +++ b/apple/Plugins/OracleDriverPlugin/OraclePlugin.swift @@ -635,6 +635,8 @@ final class OraclePluginDriver: PluginDatabaseDriver, @unchecked Sendable { OracleObjectQueries.dropTrigger(name: name, schema: schema, currentSchema: _currentSchema) } + var fetchesAllColumnsInOneRequest: Bool { true } + func fetchAllColumns(schema: String?) async throws -> [String: [PluginColumnInfo]] { let result = try await rawQuery( OracleSchemaQueries.allColumns(schema: effectiveSchema(schema), release: serverRelease()) diff --git a/apple/Plugins/PostgreSQLDriverPlugin/CockroachPluginDriver.swift b/apple/Plugins/PostgreSQLDriverPlugin/CockroachPluginDriver.swift index 0ea3e26c4a..5868464d42 100644 --- a/apple/Plugins/PostgreSQLDriverPlugin/CockroachPluginDriver.swift +++ b/apple/Plugins/PostgreSQLDriverPlugin/CockroachPluginDriver.swift @@ -79,6 +79,8 @@ final class CockroachPluginDriver: LibPQBackedDriver, @unchecked Sendable { return result.rows.compactMap { Self.mapColumnRow($0, includesTableName: false) } } + var fetchesAllColumnsInOneRequest: Bool { true } + func fetchAllColumns(schema: String?) async throws -> [String: [PluginColumnInfo]] { let resolvedSchema = schema ?? core.currentSchema let query = CockroachRelationSQL.columnsQuery(schema: resolvedSchema, table: nil) diff --git a/apple/Plugins/PostgreSQLDriverPlugin/LibPQDriverCore.swift b/apple/Plugins/PostgreSQLDriverPlugin/LibPQDriverCore.swift index 9b6c67a479..f13731cc1c 100644 --- a/apple/Plugins/PostgreSQLDriverPlugin/LibPQDriverCore.swift +++ b/apple/Plugins/PostgreSQLDriverPlugin/LibPQDriverCore.swift @@ -246,6 +246,63 @@ final class LibPQDriverCore: @unchecked Sendable { return try await executeTransactionScopedRead(path + statement) } + // The server runs one Query's statements as one implicit transaction, so one `SET LOCAL` covers every read. + func executeCatalogReads(_ statements: [String]) async -> [Result] { + guard pinsCatalogSearchPath, statements.count > 1, let pqConn = libpqConnection else { + return await catalogReadsOneByOne(statements) + } + let startTime = Date() + let answered: [Result] + do { + let text = PostgreSQLCatalogSearchPath.pinned + statements.joined(separator: ";\n") + guard let batch = try await pqConn.executeConnectStatements(text) else { + return await catalogReadsOneByOne(statements) + } + // The first result is the pinned path's own. + answered = Array(batch.dropFirst()) + } catch { + // A round trip that failed fails the connect in `finishConnecting`, so no read is sent again. + return statements.map { _ in .failure(error) } + } + let executionTime = Date().timeIntervalSince(startTime) + var reads: [Result] = [] + for (index, statement) in statements.enumerated() { + guard index < answered.count else { + reads.append(await catalogReadResult(statement)) + continue + } + reads.append(answered[index].map { Self.pluginResult($0, executionTime: executionTime) }) + } + return reads + } + + private func catalogReadsOneByOne(_ statements: [String]) async -> [Result] { + var reads: [Result] = [] + for statement in statements { + reads.append(await catalogReadResult(statement)) + } + return reads + } + + private func catalogReadResult(_ statement: String) async -> Result { + do { + return .success(try await executeCatalogRead(statement)) + } catch { + return .failure(error) + } + } + + private static func pluginResult(_ result: LibPQPluginQueryResult, executionTime: TimeInterval) -> PluginQueryResult { + PluginQueryResult( + columns: result.columns, + columnTypeNames: result.columnTypeNames, + rows: result.rows, + rowsAffected: result.affectedRows, + executionTime: executionTime, + isTruncated: result.isTruncated + ) + } + private func executeTransactionScopedRead(_ statement: String) async throws -> PluginQueryResult { let pqConn = try connection() let startTime = Date() diff --git a/apple/Plugins/PostgreSQLDriverPlugin/LibPQPluginConnection.swift b/apple/Plugins/PostgreSQLDriverPlugin/LibPQPluginConnection.swift index a57fb8a048..88679f7f66 100644 --- a/apple/Plugins/PostgreSQLDriverPlugin/LibPQPluginConnection.swift +++ b/apple/Plugins/PostgreSQLDriverPlugin/LibPQPluginConnection.swift @@ -390,11 +390,14 @@ final class LibPQPluginConnection: @unchecked Sendable { deadline: LibPQConnectDeadline ) throws { logUnexpectedClientEncoding(of: connection) - try runSessionSetupStatement( - LibPQStringConformance.enableStatement, - on: connection, - deadline: deadline - ) + // Every server since 8.2 reports the setting and PgBouncer tracks it, so a reported `on` needs no round trip. + if reportedStandardConformingStrings(on: connection) != true { + try runSessionSetupStatement( + LibPQStringConformance.enableStatement, + on: connection, + deadline: deadline + ) + } let standardConformingStrings = try ( reportedStandardConformingStrings(on: connection) ?? queriedStandardConformingStrings(on: connection, deadline: deadline) @@ -476,21 +479,37 @@ final class LibPQPluginConnection: @unchecked Sendable { on connection: OpaquePointer, deadline: LibPQConnectDeadline ) throws -> OpaquePointer { + // One element: only the last result is kept, and no result at all throws. + try bootstrapResults(for: statement, on: connection, deadline: deadline, keepsOnlyLast: true)[0] + } + + private func bootstrapResults( + for statements: String, + on connection: OpaquePointer, + deadline: LibPQConnectDeadline, + keepsOnlyLast: Bool + ) throws -> [OpaquePointer] { do { - return try uncheckedBootstrapResult(for: statement, on: connection, deadline: deadline) + return try uncheckedBootstrapResults( + for: statements, + on: connection, + deadline: deadline, + keepsOnlyLast: keepsOnlyLast + ) } catch { bootstrapTransportFailed = true throw error } } - private func uncheckedBootstrapResult( - for statement: String, + private func uncheckedBootstrapResults( + for statements: String, on connection: OpaquePointer, - deadline: LibPQConnectDeadline - ) throws -> OpaquePointer { + deadline: LibPQConnectDeadline, + keepsOnlyLast: Bool + ) throws -> [OpaquePointer] { try checkBootstrapState(connection, deadline: deadline) - let sent = statement.withCString { PQsendQuery(connection, $0) } + let sent = statements.withCString { PQsendQuery(connection, $0) } guard sent != 0 else { throw connectionError(from: connection) } while true { @@ -501,10 +520,10 @@ final class LibPQPluginConnection: @unchecked Sendable { try pollBootstrapSocket(connection, reads: false, writes: true, deadline: deadline) } - var finalResult: OpaquePointer? - var returnsFinalResult = false + var results: [OpaquePointer] = [] + var returnsResults = false defer { - if !returnsFinalResult, let finalResult { PQclear(finalResult) } + if !returnsResults { results.forEach { PQclear($0) } } } while true { while PQisBusy(connection) != 0 { @@ -515,13 +534,13 @@ final class LibPQPluginConnection: @unchecked Sendable { } guard let result = PQgetResult(connection) else { break } - if let finalResult { PQclear(finalResult) } - finalResult = result + if keepsOnlyLast, let earlier = results.popLast() { PQclear(earlier) } + results.append(result) } - guard let finalResult else { throw connectionError(from: connection) } - returnsFinalResult = true - return finalResult + guard !results.isEmpty else { throw connectionError(from: connection) } + returnsResults = true + return results } private func pollBootstrapSocket( @@ -757,6 +776,17 @@ final class LibPQPluginConnection: @unchecked Sendable { } } + // Nil once the connect has finished, when a block of the user's may be open: the caller then scopes each read alone. + func executeConnectStatements(_ statements: String) async throws -> [Result]? { + let statementsToRun = String(statements) + + return try await pluginDispatchAsync(on: queue) { [self] () throws -> [Result]? in + guard !isShuttingDown else { throw LibPQPluginError.notConnected } + guard let deadline = activeConnectDeadline else { return nil } + return try executeConnectStatementsSync(statementsToRun, deadline: deadline) + } + } + // A catalog query the driver sends on its own while reading a result, on the connection's queue, scoped the way // `executeTransactionScopedRead` scopes one. The caller clears the result. Inside an aborted block it hands back // the savepoint's own `25P02` failure. @@ -962,6 +992,38 @@ final class LibPQPluginConnection: @unchecked Sendable { return decoded } + // One simple Query: the server answers each statement in order and runs none after the first that fails. + private func executeConnectStatementsSync( + _ statements: String, + deadline: LibPQConnectDeadline + ) throws -> [Result] { + guard !isShuttingDown, let connection = connectionHandle else { + throw LibPQPluginError.notConnected + } + + let generation = cancellationGate.beginQuery() + defer { cancellationGate.endQuery(generation) } + defer { refreshStandardConformingStrings(from: connection) } + + let cancelsOutput = cancelsAbandonedOutput(connection) + if let ended = sessionEndedBeforeSending(connection) { throw ended } + let results = try bootstrapResults(for: statements, on: connection, deadline: deadline, keepsOnlyLast: false) + recordTransactionState(of: connection) + let decoded = results.map { result in + Result { + try queryResult( + from: result, + connection: connection, + generation: generation, + cancelsOutput: cancelsOutput, + allowsSideQueries: false + ) + } + } + try checkBootstrapState(connection, deadline: deadline) + return decoded + } + private func executeQuerySync(_ query: String, singleStatement: Bool = false) throws -> LibPQPluginQueryResult { let conn = connectionHandle diff --git a/apple/Plugins/PostgreSQLDriverPlugin/PostgreSQLPluginDriver+EnumTypes.swift b/apple/Plugins/PostgreSQLDriverPlugin/PostgreSQLPluginDriver+EnumTypes.swift index 9eb8f64f03..d9209bf74e 100644 --- a/apple/Plugins/PostgreSQLDriverPlugin/PostgreSQLPluginDriver+EnumTypes.swift +++ b/apple/Plugins/PostgreSQLDriverPlugin/PostgreSQLPluginDriver+EnumTypes.swift @@ -15,9 +15,9 @@ private let enumProbeLogger = Logger( ) extension PostgreSQLPluginDriver { - func probeEnumOids() async { + func applyEnumProbe(_ read: Result) { do { - let result = try await core.executeCatalogRead(PostgreSQLSchemaQueries.enumTypeOidQuery) + let result = try read.get() let rows = result.rows.map { row in row.map(\.asText) } core.mergeCatalogTypeNames(PostgreSQLCatalogTypeNames.enumProbeNames(rows: rows)) } catch { diff --git a/apple/Plugins/PostgreSQLDriverPlugin/PostgreSQLPluginDriver+ServerSupport.swift b/apple/Plugins/PostgreSQLDriverPlugin/PostgreSQLPluginDriver+ServerSupport.swift index b8f8db1e45..3a32db50c5 100644 --- a/apple/Plugins/PostgreSQLDriverPlugin/PostgreSQLPluginDriver+ServerSupport.swift +++ b/apple/Plugins/PostgreSQLDriverPlugin/PostgreSQLPluginDriver+ServerSupport.swift @@ -27,9 +27,9 @@ internal extension PostgreSQLPluginDriver { PostgreSQLVersionedStatements.refusal(for: operation, capabilities: versionedCapabilities) } - func probeSessionFacts() async { + func applySessionFactsProbe(_ read: Result) { do { - let result = try await core.executeCatalogRead(PostgreSQLSessionFacts.probeQuery) + let result = try read.get() let row = result.rows.first?.map(\.asText) ?? [] let facts = PostgreSQLSessionFacts(probeRow: row) sessionFacts.withLock { $0 = facts } diff --git a/apple/Plugins/PostgreSQLDriverPlugin/PostgreSQLPluginDriver.swift b/apple/Plugins/PostgreSQLDriverPlugin/PostgreSQLPluginDriver.swift index 332e0df495..41d4b5ef1e 100644 --- a/apple/Plugins/PostgreSQLDriverPlugin/PostgreSQLPluginDriver.swift +++ b/apple/Plugins/PostgreSQLDriverPlugin/PostgreSQLPluginDriver.swift @@ -74,16 +74,22 @@ class PostgreSQLPluginDriver: LibPQBackedDriver, @unchecked Sendable { /// Runs inside the connect's deadline and cancellation, before the connection is handed out. func probeAfterConnect() async throws { - await probeSessionFacts() - await probeCatalogPresence() - await probePostgisOids() - await probeEnumOids() - await probeVectorTypes() + let probes: [(statement: String, apply: (Result) -> Void)] = [ + (PostgreSQLSessionFacts.probeQuery, applySessionFactsProbe), + (PostgreSQLCatalogPresence.probeQuery, applyCatalogPresenceProbe), + (PostGISTypes.probeQuery, applyPostgisProbe), + (PostgreSQLSchemaQueries.enumTypeOidQuery, applyEnumProbe), + (PgvectorTypes.probeQuery, applyVectorTypesProbe) + ] + let reads = await core.executeCatalogReads(probes.map { $0.statement }) + for (probe, read) in zip(probes, reads) { + probe.apply(read) + } } - private func probeCatalogPresence() async { + private func applyCatalogPresenceProbe(_ read: Result) { do { - let result = try await core.executeCatalogRead(PostgreSQLCatalogPresence.probeQuery) + let result = try read.get() let relationNames = result.rows.compactMap { $0.first?.asText } catalogPresence = PostgreSQLCatalogPresence(relationNames: relationNames) } catch { @@ -91,18 +97,18 @@ class PostgreSQLPluginDriver: LibPQBackedDriver, @unchecked Sendable { } } - private func probePostgisOids() async { + private func applyPostgisProbe(_ read: Result) { do { - let result = try await core.executeCatalogRead(PostGISTypes.probeQuery) + let result = try read.get() core.setPostgisOidMap(PostGISTypes.names(fromProbeRows: result.rows.map { row in row.map(\.asText) })) } catch { Self.logger.debug("PostGIS type probe failed; spatial values stay as hex: \(error.localizedDescription)") } } - private func probeVectorTypes() async { + private func applyVectorTypesProbe(_ read: Result) { do { - let result = try await core.executeCatalogRead(PgvectorTypes.probeQuery) + let result = try read.get() let rows = result.rows.map { row in row.map(\.asText) } core.mergeCatalogTypeNames(PgvectorTypes.names(fromProbeRows: rows)) } catch { diff --git a/apple/Plugins/PostgreSQLDriverPlugin/RedshiftPluginDriver.swift b/apple/Plugins/PostgreSQLDriverPlugin/RedshiftPluginDriver.swift index 55db6d0359..8b7c359b62 100644 --- a/apple/Plugins/PostgreSQLDriverPlugin/RedshiftPluginDriver.swift +++ b/apple/Plugins/PostgreSQLDriverPlugin/RedshiftPluginDriver.swift @@ -224,6 +224,8 @@ final class RedshiftPluginDriver: LibPQBackedDriver, @unchecked Sendable { } } + var fetchesAllColumnsInOneRequest: Bool { true } + func fetchAllColumns(schema: String?) async throws -> [String: [PluginColumnInfo]] { let resolvedSchema = schema ?? core.currentSchema if isExternalSchema(resolvedSchema) { diff --git a/apple/Plugins/PostgreSQLDriverTests/LibPQScriptedServer.swift b/apple/Plugins/PostgreSQLDriverTests/LibPQScriptedServer.swift index 4b5eaf6ecd..5445661b83 100644 --- a/apple/Plugins/PostgreSQLDriverTests/LibPQScriptedServer.swift +++ b/apple/Plugins/PostgreSQLDriverTests/LibPQScriptedServer.swift @@ -7,8 +7,9 @@ import Darwin import Foundation // A loopback PostgreSQL server for one plaintext session. It refuses SSL and GSS encryption, accepts any startup -// without a password, records each simple query, runs `onQuery` before it answers, and answers with an empty -// completion and the transaction status `status` picks from the query and the ones before it. +// without a password, records each simple query, runs `onQuery` before it answers, and answers each statement in it +// with an empty completion, then the transaction status `status` picks from the query and the ones before it. A +// statement holding `failingStatement` gets an error instead, and the statements after it in that query get nothing. final class LibPQScriptedServer: @unchecked Sendable { struct SetupFailure: Error {} @@ -33,6 +34,7 @@ final class LibPQScriptedServer: @unchecked Sendable { private let listener: Int32 private let status: @Sendable (_ query: String, _ earlier: [String]) -> UInt8 private let onQuery: @Sendable (String) -> Void + private let failingStatement: String? private let lock = NSLock() private var received: [String] = [] @@ -42,10 +44,12 @@ final class LibPQScriptedServer: @unchecked Sendable { init( status: @escaping @Sendable (_ query: String, _ earlier: [String]) -> UInt8 = { _, _ in LibPQScriptedServer.idle }, - onQuery: @escaping @Sendable (String) -> Void = { _ in } + onQuery: @escaping @Sendable (String) -> Void = { _ in }, + failingStatement: String? = nil ) throws { self.status = status self.onQuery = onQuery + self.failingStatement = failingStatement let socketFD = socket(AF_INET, SOCK_STREAM, 0) guard socketFD >= 0 else { throw SetupFailure() } var option: Int32 = 1 @@ -91,11 +95,47 @@ final class LibPQScriptedServer: @unchecked Sendable { return received } onQuery(query) - let reply = Self.message("C", Array("SELECT 0".utf8) + [0]) + Self.message("Z", [status(query, earlier)]) + let reply = answers(to: query) + Self.message("Z", [status(query, earlier)]) guard send(client, reply) else { return } } } + private func answers(to query: String) -> [UInt8] { + let statements = Self.statements(in: query) + var reply: [UInt8] = [] + for statement in statements.isEmpty ? [query] : statements { + if let failingStatement, statement.contains(failingStatement) { + return reply + Self.errorResponse(sqlState: "42501", text: "permission denied") + } + reply += Self.message("C", Array("SELECT 0".utf8) + [0]) + } + return reply + } + + // Splits on each `;` outside a quoted literal or identifier, which is enough for the statements the driver sends. + private static func statements(in query: String) -> [String] { + var statements: [String] = [] + var current = "" + var quote: Character? + for character in query { + if character == ";", quote == nil { + statements.append(current) + current = "" + continue + } + if character == quote { + quote = nil + } else if quote == nil, character == "'" || character == "\"" { + quote = character + } + current.append(character) + } + statements.append(current) + return statements + .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) } + .filter { !$0.isEmpty } + } + private func startUp(_ client: Int32) -> Bool { while let packet = receiveBody(client), packet.count >= 4 { let code = Self.uint32(packet.prefix(4)) @@ -119,6 +159,14 @@ final class LibPQScriptedServer: @unchecked Sendable { [type.asciiValue ?? 0] + bytes(UInt32(body.count + 4)) + body } + private static func errorResponse(sqlState: String, text: String) -> [UInt8] { + var body: [UInt8] = [] + for (field, value) in [("S", "ERROR"), ("V", "ERROR"), ("C", sqlState), ("M", text)] { + body += Array(field.utf8) + Array(value.utf8) + [0] + } + return message("E", body + [0]) + } + private static func bytes(_ value: UInt32) -> [UInt8] { [UInt8((value >> 24) & 0xFF), UInt8((value >> 16) & 0xFF), UInt8((value >> 8) & 0xFF), UInt8(value & 0xFF)] } diff --git a/apple/Plugins/PostgreSQLDriverTests/PostgreSQLConnectRoundTripTests.swift b/apple/Plugins/PostgreSQLDriverTests/PostgreSQLConnectRoundTripTests.swift new file mode 100644 index 0000000000..a0a4981176 --- /dev/null +++ b/apple/Plugins/PostgreSQLDriverTests/PostgreSQLConnectRoundTripTests.swift @@ -0,0 +1,69 @@ +// +// PostgreSQLConnectRoundTripTests.swift +// PostgreSQLDriverTests +// + +import Foundation +import TableProPluginKit +import TableProPostgreSQLCore +import Testing + +@Suite(.timeLimit(.minutes(1))) +struct PostgreSQLConnectRoundTripTests { + private static let probes = [ + PostgreSQLSessionFacts.probeQuery, + PostgreSQLCatalogPresence.probeQuery, + PostGISTypes.probeQuery, + PostgreSQLSchemaQueries.enumTypeOidQuery, + PgvectorTypes.probeQuery + ] + + private static func connectedDriver(to server: LibPQScriptedServer) async throws -> PostgreSQLPluginDriver { + let driver = PostgreSQLPluginDriver(config: DriverConnectionConfig( + host: "127.0.0.1", port: server.port, username: "postgres", password: "", database: "postgres" + )) + try await driver.connect() + return driver + } + + private static func probeCount(in query: String) -> Int { + probes.filter { query.contains($0) }.count + } + + @Test("Connect sends the five catalog probes in one Query and no string setting the server reports on") + func probesShareOneQuery() async throws { + let server = try LibPQScriptedServer() + defer { server.close() } + server.start() + let driver = try await Self.connectedDriver(to: server) + defer { driver.disconnect() } + + let sent = server.queries + let carriers = sent.filter { Self.probeCount(in: $0) > 0 } + let batch = try #require(carriers.first) + let settingSent = sent.contains { $0.contains(LibPQStringConformance.parameterName) } + #expect(carriers.count == 1) + #expect(Self.probeCount(in: batch) == Self.probes.count) + #expect(batch.hasPrefix(PostgreSQLCatalogSearchPath.pinned)) + #expect(!settingSent) + } + + @Test("A probe the server refuses costs no other: each probe after it goes again in its own Query") + func failedProbeLeavesTheRestSent() async throws { + let server = try LibPQScriptedServer(failingStatement: PostGISTypes.probeQuery) + defer { server.close() } + server.start() + let driver = try await Self.connectedDriver(to: server) + defer { driver.disconnect() } + + let sent = server.queries + let found = sent.firstIndex { Self.probeCount(in: $0) == Self.probes.count } + let batchIndex = try #require(found) + let resent = sent[(batchIndex + 1)...].filter { Self.probeCount(in: $0) > 0 } + let eachAlone = resent.allSatisfy { Self.probeCount(in: $0) == 1 } + #expect(resent.count == 2) + #expect(eachAlone) + #expect(resent.first?.contains(PostgreSQLSchemaQueries.enumTypeOidQuery) == true) + #expect(resent.last?.contains(PgvectorTypes.probeQuery) == true) + } +} diff --git a/apple/Plugins/RedisDriverPlugin/RedisPluginDriver.swift b/apple/Plugins/RedisDriverPlugin/RedisPluginDriver.swift index 75ff9f44ec..07ffe24086 100644 --- a/apple/Plugins/RedisDriverPlugin/RedisPluginDriver.swift +++ b/apple/Plugins/RedisDriverPlugin/RedisPluginDriver.swift @@ -307,6 +307,8 @@ final class RedisPluginDriver: PluginDatabaseDriver, @unchecked Sendable { ] } + var fetchesAllColumnsInOneRequest: Bool { true } + func fetchAllColumns(schema: String?) async throws -> [String: [PluginColumnInfo]] { let tables = try await fetchTables(schema: schema) let columns = try await fetchColumns(table: "", schema: schema) diff --git a/apple/Plugins/SnowflakeDriverPlugin/SnowflakePluginDriver.swift b/apple/Plugins/SnowflakeDriverPlugin/SnowflakePluginDriver.swift index 13c8010726..a2e8ec8c9d 100644 --- a/apple/Plugins/SnowflakeDriverPlugin/SnowflakePluginDriver.swift +++ b/apple/Plugins/SnowflakeDriverPlugin/SnowflakePluginDriver.swift @@ -312,6 +312,8 @@ final class SnowflakePluginDriver: PluginDatabaseDriver, @unchecked Sendable { }.sorted { $0.name < $1.name } } + var fetchesAllColumnsInOneRequest: Bool { true } + func fetchAllColumns(schema: String?) async throws -> [String: [PluginColumnInfo]] { let database = connection?.currentDatabase let targetSchema = schema ?? connection?.currentSchema diff --git a/apple/Plugins/TableProPluginKit/PluginDatabaseDriver.swift b/apple/Plugins/TableProPluginKit/PluginDatabaseDriver.swift index b1f03c7154..1453ffef39 100644 --- a/apple/Plugins/TableProPluginKit/PluginDatabaseDriver.swift +++ b/apple/Plugins/TableProPluginKit/PluginDatabaseDriver.swift @@ -316,6 +316,7 @@ public protocol PluginDatabaseDriver: AnyObject, Sendable { func fetchApproximateRowCount(table: String, schema: String?) async throws -> Int? func fetchAllColumns(schema: String?) async throws -> [String: [PluginColumnInfo]] var providesBulkColumnFetch: Bool { get } + var fetchesAllColumnsInOneRequest: Bool { get } func sampleFieldPaths(table: String, schema: String?, limit: Int) async throws -> [PluginFieldPath] func fetchAllForeignKeys(schema: String?) async throws -> [String: [PluginForeignKeyInfo]] var providesBulkForeignKeyFetch: Bool { get } @@ -1031,6 +1032,9 @@ public extension PluginDatabaseDriver { /// difference at all. var providesBulkColumnFetch: Bool { false } + // Whether `fetchAllColumns` reads every table in one request or a fixed few, whatever its completeness. + var fetchesAllColumnsInOneRequest: Bool { providesBulkColumnFetch } + /// Default: fetches columns per-table sequentially (N+1 round-trips). /// SQL drivers should override with a single bulk query (e.g. INFORMATION_SCHEMA.COLUMNS). func fetchAllColumns(schema: String?) async throws -> [String: [PluginColumnInfo]] { diff --git a/apple/TablePro/Core/Autocomplete/SQLSchemaProvider.swift b/apple/TablePro/Core/Autocomplete/SQLSchemaProvider.swift index a256b5de58..b81fdc01d8 100644 --- a/apple/TablePro/Core/Autocomplete/SQLSchemaProvider.swift +++ b/apple/TablePro/Core/Autocomplete/SQLSchemaProvider.swift @@ -103,6 +103,8 @@ actor SQLSchemaProvider { private(set) var tableColumnItemsBuildCount = 0 private weak var cachedDriver: (any DatabaseDriver)? + // Read from the driver that filled the table list, so learning it opens no connection. + private var fetchesAllColumnsInOneRequest = false private let metadataSource: ColumnMetadataSource? private var connectionInfo: DatabaseConnection? @@ -131,6 +133,7 @@ actor SQLSchemaProvider { Self.logger.info("[schema] loadSchema starting new fetch") let t0 = Date() self.cachedDriver = driver + self.fetchesAllColumnsInOneRequest = driver.fetchesAllColumnsInOneRequest self.eagerLoadSchema = (driver as? SchemaSwitchable)?.currentSchema if let connection { self.connectionInfo = connection } @@ -260,6 +263,7 @@ actor SQLSchemaProvider { self.onDemandSchemaTables.removeAll() self.onDemandSchemaTableTasks.removeAll() self.cachedDriver = driver + self.fetchesAllColumnsInOneRequest = driver.fetchesAllColumnsInOneRequest self.eagerLoadSchema = (driver as? SchemaSwitchable)?.currentSchema if let connection { self.connectionInfo = connection } noteTableListWritten() @@ -318,6 +322,13 @@ actor SQLSchemaProvider { columnPreload = .awaitingTables(generation: generation) return } + guard fetchesAllColumnsInOneRequest else { + Self.logger.info( + "[schema] column preload skipped tableCount=\(tableCount) fetchesAllColumnsInOneRequest=false" + ) + columnPreload = .settled(generation: generation, outcome: .skipped) + return + } guard tableCount <= Self.maxCachedTables else { Self.logger.info( "[schema] column preload skipped tableCount=\(tableCount) limit=\(Self.maxCachedTables)" diff --git a/apple/TablePro/Core/Database/DatabaseDriver.swift b/apple/TablePro/Core/Database/DatabaseDriver.swift index 5bae9e93a9..55f235c4d0 100644 --- a/apple/TablePro/Core/Database/DatabaseDriver.swift +++ b/apple/TablePro/Core/Database/DatabaseDriver.swift @@ -174,9 +174,12 @@ protocol DatabaseDriver: AnyObject, Sendable { /// Default implementation falls back to per-table fetchColumns. func fetchAllColumns() async throws -> [String: [ColumnInfo]] - // False when `fetchAllColumns` degrades to one round trip per table. + // One query that also reports every column `fetchColumns` does, so Compare can trust it. var providesBulkColumnFetch: Bool { get } + // Only whether `fetchAllColumns` reads every table in one request, whatever its completeness. + var fetchesAllColumnsInOneRequest: Bool { get } + /// Dotted field paths a document store exposes for a collection, for query authoring. /// Default implementation returns nothing, which is correct for every SQL driver. func sampleFieldPaths(table: String, limit: Int) async throws -> [PluginFieldPath] @@ -832,6 +835,8 @@ extension DatabaseDriver { var providesBulkColumnFetch: Bool { false } + var fetchesAllColumnsInOneRequest: Bool { false } + var providesBulkForeignKeyFetch: Bool { false } func fetchAllForeignKeys(schema: String?) async throws -> [String: [ForeignKeyInfo]] { diff --git a/apple/TablePro/Core/Plugins/PluginDriverAdapter.swift b/apple/TablePro/Core/Plugins/PluginDriverAdapter.swift index 4b4ec3ab6d..7360b71037 100644 --- a/apple/TablePro/Core/Plugins/PluginDriverAdapter.swift +++ b/apple/TablePro/Core/Plugins/PluginDriverAdapter.swift @@ -929,6 +929,8 @@ final class PluginDriverAdapter: DatabaseDriver, SchemaSwitchable, DatabaseRepor var providesBulkColumnFetch: Bool { pluginDriver.providesBulkColumnFetch } + var fetchesAllColumnsInOneRequest: Bool { pluginDriver.fetchesAllColumnsInOneRequest } + func fetchAllColumns() async throws -> [String: [ColumnInfo]] { let pluginResult = try await pluginDriver.fetchAllColumns(schema: pluginDriver.currentSchema) return pluginResult.mapValues { $0.map(ColumnInfo.init) } diff --git a/apple/TableProTests/Core/Autocomplete/SQLSchemaProviderFallbackTests.swift b/apple/TableProTests/Core/Autocomplete/SQLSchemaProviderFallbackTests.swift index ec3b9f7aab..c7b1794182 100644 --- a/apple/TableProTests/Core/Autocomplete/SQLSchemaProviderFallbackTests.swift +++ b/apple/TableProTests/Core/Autocomplete/SQLSchemaProviderFallbackTests.swift @@ -59,6 +59,8 @@ private final class MockFallbackDriver: DatabaseDriver, @unchecked Sendable { return columnsPerTable } + var fetchesAllColumnsInOneRequest: Bool { true } + func fetchIndexes(table: String) async throws -> [IndexInfo] { [] } func fetchForeignKeys(table: String) async throws -> [ForeignKeyInfo] { [] } func fetchApproximateRowCount(table: String) async throws -> Int? { nil } diff --git a/apple/TableProTests/Core/Autocomplete/SQLSchemaProviderTests.swift b/apple/TableProTests/Core/Autocomplete/SQLSchemaProviderTests.swift index f7bd3cfbb5..ca15845d37 100644 --- a/apple/TableProTests/Core/Autocomplete/SQLSchemaProviderTests.swift +++ b/apple/TableProTests/Core/Autocomplete/SQLSchemaProviderTests.swift @@ -308,6 +308,9 @@ final class MockDatabaseDriver: DatabaseDriver, SchemaSwitchable, @unchecked Sen return allColumnsToReturn } + var oneRequestColumnRead = true + var fetchesAllColumnsInOneRequest: Bool { oneRequestColumnRead } + func fetchIndexes(table: String) async throws -> [IndexInfo] { [] } func fetchForeignKeys(table: String) async throws -> [ForeignKeyInfo] { [] } func fetchApproximateRowCount(table: String) async throws -> Int? { nil } @@ -892,6 +895,54 @@ struct SQLSchemaProviderTests { #expect(driver.fetchColumnsCallCount == 0) } + @Test("Only a driver that reads every table's columns in one request preloads them", arguments: [true, false]) + func preloadNeedsAOneRequestColumnRead(oneRequest: Bool) async { + let driver = MockDatabaseDriver() + driver.oneRequestColumnRead = oneRequest + driver.allColumnsToReturn = ["users": [TestFixtures.makeColumnInfo(name: "id")]] + driver.columnsToReturn = ["users": [TestFixtures.makeColumnInfo(name: "id")]] + let provider = SQLSchemaProvider() + await provider.resetForDatabase("db", tables: [TestFixtures.makeTableInfo(name: "users")], driver: driver) + + await provider.requestColumnPreload() + await provider.waitForEagerColumnLoad() + await provider.requestColumnPreload() + _ = await provider.allColumnsFromCachedTables() + await provider.waitForEagerColumnLoad() + + #expect(driver.fetchAllColumnsCallCount == (oneRequest ? 1 : 0)) + let columns = await provider.getColumns(for: "users") + #expect(columns.map { $0.name } == ["id"]) + #expect(driver.fetchColumnsCallCount == (oneRequest ? 0 : 1)) + } + + @Test("A source asks for every column only when the driver that filled the scope reads them in one request", arguments: [true, false]) + func sourcePreloadFollowsTheFillingDriver(oneRequest: Bool) async { + let recorder = CallRecorder() + let source = SQLSchemaProvider.ColumnMetadataSource( + fetchColumns: { table, _ in + recorder.record("columns.\(table)") + return [TestFixtures.makeColumnInfo(name: "id")] + }, + fetchAllColumns: { + recorder.record("allColumns") + return ["users": [TestFixtures.makeColumnInfo(name: "id")]] + } + ) + let driver = MockDatabaseDriver() + driver.oneRequestColumnRead = oneRequest + let provider = SQLSchemaProvider(metadataSource: source) + await provider.resetForDatabase("db", tables: [TestFixtures.makeTableInfo(name: "users")], driver: driver) + + await provider.requestColumnPreload() + await provider.waitForEagerColumnLoad() + let columns = await provider.getColumns(for: "users") + + #expect(recorder.calls == (oneRequest ? ["allColumns"] : ["columns.users"])) + #expect(columns.map { $0.name } == ["id"]) + #expect(driver.fetchAllColumnsCallCount == 0) + } + @Test("A table-list write after a preload sends nothing until the next request") func tableListWriteAfterPreloadWaitsForTheNextRequest() async { let driver = MockDatabaseDriver() From 9bc8715e5ebe0e6ebef61beed2987e12b1b0c799 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Thu, 12 Nov 2026 02:28:41 +0700 Subject: [PATCH 2/5] docs(macos): changelog for faster PostgreSQL connects and skipped column preload --- apple/changelog.d/4209.changed.1.md | 1 + apple/changelog.d/4209.changed.md | 1 + 2 files changed, 2 insertions(+) create mode 100644 apple/changelog.d/4209.changed.1.md create mode 100644 apple/changelog.d/4209.changed.md diff --git a/apple/changelog.d/4209.changed.1.md b/apple/changelog.d/4209.changed.1.md new file mode 100644 index 0000000000..f45f16d5bd --- /dev/null +++ b/apple/changelog.d/4209.changed.1.md @@ -0,0 +1 @@ +Query tabs on drivers without a bulk column read, such as Trino and Neo4j, no longer read every table's columns up front. diff --git a/apple/changelog.d/4209.changed.md b/apple/changelog.d/4209.changed.md new file mode 100644 index 0000000000..0f0cdf1620 --- /dev/null +++ b/apple/changelog.d/4209.changed.md @@ -0,0 +1 @@ +PostgreSQL connections open with five fewer round trips, so the sidebar lists tables sooner after a connect. From ada06e1f56143cd6afb1b0b1b5cd21dee3b9d68b Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Thu, 12 Nov 2026 02:28:50 +0700 Subject: [PATCH 3/5] docs(macos): shorten the column preload changelog entry --- apple/changelog.d/4209.changed.1.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/apple/changelog.d/4209.changed.1.md b/apple/changelog.d/4209.changed.1.md index f45f16d5bd..e2e6336f77 100644 --- a/apple/changelog.d/4209.changed.1.md +++ b/apple/changelog.d/4209.changed.1.md @@ -1 +1 @@ -Query tabs on drivers without a bulk column read, such as Trino and Neo4j, no longer read every table's columns up front. +Query tabs on Trino, Neo4j and similar drivers no longer read every table's columns up front. From bd735dab380da943a0dfb1c6c7e98b13aad48bd0 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Thu, 12 Nov 2026 06:29:38 +0700 Subject: [PATCH 4/5] fix(macos): carry #4217's fix for the Unit suites #4200 left red Same change as #4217, so either PR merges cleanly after the other. --- .../QueryExecutionCoordinator+Batches.swift | 15 ++++++++--- .../Models/Query/QueryBatchResult.swift | 26 +++++++++++++++++++ .../Execution/QueryBatchResultTests.swift | 17 ++++++++++-- .../Helpers/FakeMSSQLPlugin.swift | 3 +++ .../ConnectionFormPortTLSTests.swift | 7 +++-- 5 files changed, 61 insertions(+), 7 deletions(-) diff --git a/apple/TablePro/Core/Coordinators/QueryExecutionCoordinator+Batches.swift b/apple/TablePro/Core/Coordinators/QueryExecutionCoordinator+Batches.swift index 3072505f7c..b15c7901a0 100644 --- a/apple/TablePro/Core/Coordinators/QueryExecutionCoordinator+Batches.swift +++ b/apple/TablePro/Core/Coordinators/QueryExecutionCoordinator+Batches.swift @@ -26,6 +26,7 @@ private struct BatchOutput: Sendable { let rowsAffected: Int let errors: [PluginBatchError] let discardedResultSetCount: Int + let supersededResultSetCount: Int let executionTime: TimeInterval let errorDescription: String? var serverOutput: PluginServerOutput = .none @@ -308,7 +309,8 @@ extension QueryExecutionCoordinator { driver: DatabaseDriver, failureOutput: ServerOutputBox ) async throws -> BatchOutput { - var combined = QueryBatchResult.empty + var earliest = QueryBatchResult.empty + var latest = QueryBatchResult.empty var printed = BatchPrintedOutput() for _ in 0.. QueryBatchResult { + let combined = resultSets + next.resultSets + let superseded = max(combined.count - Self.keptResultSetLimit, 0) + let shifted = { (error: PluginBatchError, preceding: Int) in + PluginBatchError( + message: error.message, + code: error.code, + line: error.line, + procedure: error.procedure, + precedingResultSetCount: max(preceding - superseded, 0) + ) + } + return QueryBatchResult( + resultSets: Array(combined.suffix(Self.keptResultSetLimit)), + rowsAffected: rowsAffected + next.rowsAffected, + errors: errors.map { shifted($0, $0.precedingResultSetCount) } + + next.errors.map { shifted($0, resultSets.count + $0.precedingResultSetCount) }, + discardedResultSetCount: discardedResultSetCount + next.discardedResultSetCount, + executionTime: executionTime + next.executionTime, + supersededResultSetCount: supersededResultSetCount + next.supersededResultSetCount + superseded + ) + } } diff --git a/apple/TableProTests/Core/Services/Execution/QueryBatchResultTests.swift b/apple/TableProTests/Core/Services/Execution/QueryBatchResultTests.swift index f52a2d2e5d..4722b88946 100644 --- a/apple/TableProTests/Core/Services/Execution/QueryBatchResultTests.swift +++ b/apple/TableProTests/Core/Services/Execution/QueryBatchResultTests.swift @@ -2,8 +2,8 @@ // QueryBatchResultTests.swift // TableProTests // -// `GO n` sends a batch n times, and the editor and every external caller fold the answers into one with -// `followed(by:)`, so the ceiling, the counts and the place of each error are decided in one place. +// `GO n` sends a batch n times, and every caller folds the answers into one here, so the ceiling, the counts and +// the place of each error are decided in one place. The editor keeps the newest result sets past the ceiling. // import Foundation @@ -51,4 +51,17 @@ struct QueryBatchResultTests { #expect(combined.errors.map(\.precedingResultSetCount) == [3]) } + + @Test("Keeping the latest, result sets past the ceiling push out the oldest and are counted as superseded") + func latestPastTheCeiling() { + let limit = QueryBatchResult.keptResultSetLimit + let combined = answer(resultSets: limit - 1).followedKeepingLatest(by: answer(resultSets: 3, errorAfter: 3)) + + #expect(combined.resultSets.count == limit) + #expect(combined.resultSets.last?.columns == ["c2"]) + #expect(combined.resultSets.dropLast(3).last?.columns == ["c\(limit - 2)"]) + #expect(combined.supersededResultSetCount == 2) + #expect(combined.discardedResultSetCount == 0) + #expect(combined.errors.map(\.precedingResultSetCount) == [limit]) + } } diff --git a/apple/TableProTests/Helpers/FakeMSSQLPlugin.swift b/apple/TableProTests/Helpers/FakeMSSQLPlugin.swift index 9a3a6f9a6c..a21c207a64 100644 --- a/apple/TableProTests/Helpers/FakeMSSQLPlugin.swift +++ b/apple/TableProTests/Helpers/FakeMSSQLPlugin.swift @@ -193,6 +193,9 @@ final class FakeMSSQLPluginDriver: PluginDriverStub, @unchecked Sendable { } func disconnect() { disconnectCallCount += 1 } + // SQL Server moves a live session with USE, so a statement pinned to a database after a reconnect lands. + func switchDatabase(to database: String) async throws {} + func applyQueryTimeout(_ seconds: Int) async throws { queryTimeoutValues.withLock { $0.append(seconds) } } diff --git a/apple/TableProTests/ViewModels/ConnectionFormPortTLSTests.swift b/apple/TableProTests/ViewModels/ConnectionFormPortTLSTests.swift index f4865d2306..a1fbcb95d6 100644 --- a/apple/TableProTests/ViewModels/ConnectionFormPortTLSTests.swift +++ b/apple/TableProTests/ViewModels/ConnectionFormPortTLSTests.swift @@ -118,10 +118,13 @@ struct ConnectionFormPortTLSTests { #expect(coordinator.ssl.validationIssues.isEmpty) } - @Test("PostgreSQL Verify Identity still asks for a CA certificate") - func postgresStillRequiresCA() { + @Test("PostgreSQL Verify Identity saves without a CA certificate, and Verify CA still asks for one") + func postgresNeedsACAOnlyForVerifyCA() { let coordinator = newConnection(.postgresql) coordinator.ssl.select(.verifyIdentity) + #expect(coordinator.ssl.validationIssues.isEmpty) + + coordinator.ssl.select(.verifyCa) #expect(!coordinator.ssl.validationIssues.isEmpty) } } From 45895d995a68039100334ce777f2a5453fbdccf6 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Thu, 12 Nov 2026 06:58:09 +0700 Subject: [PATCH 5/5] revert(macos): drop the carried #4217 fix, main brings it in --- .../QueryExecutionCoordinator+Batches.swift | 15 +++-------- .../Models/Query/QueryBatchResult.swift | 26 ------------------- .../Execution/QueryBatchResultTests.swift | 17 ++---------- .../Helpers/FakeMSSQLPlugin.swift | 3 --- .../ConnectionFormPortTLSTests.swift | 7 ++--- 5 files changed, 7 insertions(+), 61 deletions(-) diff --git a/apple/TablePro/Core/Coordinators/QueryExecutionCoordinator+Batches.swift b/apple/TablePro/Core/Coordinators/QueryExecutionCoordinator+Batches.swift index b15c7901a0..3072505f7c 100644 --- a/apple/TablePro/Core/Coordinators/QueryExecutionCoordinator+Batches.swift +++ b/apple/TablePro/Core/Coordinators/QueryExecutionCoordinator+Batches.swift @@ -26,7 +26,6 @@ private struct BatchOutput: Sendable { let rowsAffected: Int let errors: [PluginBatchError] let discardedResultSetCount: Int - let supersededResultSetCount: Int let executionTime: TimeInterval let errorDescription: String? var serverOutput: PluginServerOutput = .none @@ -309,8 +308,7 @@ extension QueryExecutionCoordinator { driver: DatabaseDriver, failureOutput: ServerOutputBox ) async throws -> BatchOutput { - var earliest = QueryBatchResult.empty - var latest = QueryBatchResult.empty + var combined = QueryBatchResult.empty var printed = BatchPrintedOutput() for _ in 0.. QueryBatchResult { - let combined = resultSets + next.resultSets - let superseded = max(combined.count - Self.keptResultSetLimit, 0) - let shifted = { (error: PluginBatchError, preceding: Int) in - PluginBatchError( - message: error.message, - code: error.code, - line: error.line, - procedure: error.procedure, - precedingResultSetCount: max(preceding - superseded, 0) - ) - } - return QueryBatchResult( - resultSets: Array(combined.suffix(Self.keptResultSetLimit)), - rowsAffected: rowsAffected + next.rowsAffected, - errors: errors.map { shifted($0, $0.precedingResultSetCount) } - + next.errors.map { shifted($0, resultSets.count + $0.precedingResultSetCount) }, - discardedResultSetCount: discardedResultSetCount + next.discardedResultSetCount, - executionTime: executionTime + next.executionTime, - supersededResultSetCount: supersededResultSetCount + next.supersededResultSetCount + superseded - ) - } } diff --git a/apple/TableProTests/Core/Services/Execution/QueryBatchResultTests.swift b/apple/TableProTests/Core/Services/Execution/QueryBatchResultTests.swift index 4722b88946..f52a2d2e5d 100644 --- a/apple/TableProTests/Core/Services/Execution/QueryBatchResultTests.swift +++ b/apple/TableProTests/Core/Services/Execution/QueryBatchResultTests.swift @@ -2,8 +2,8 @@ // QueryBatchResultTests.swift // TableProTests // -// `GO n` sends a batch n times, and every caller folds the answers into one here, so the ceiling, the counts and -// the place of each error are decided in one place. The editor keeps the newest result sets past the ceiling. +// `GO n` sends a batch n times, and the editor and every external caller fold the answers into one with +// `followed(by:)`, so the ceiling, the counts and the place of each error are decided in one place. // import Foundation @@ -51,17 +51,4 @@ struct QueryBatchResultTests { #expect(combined.errors.map(\.precedingResultSetCount) == [3]) } - - @Test("Keeping the latest, result sets past the ceiling push out the oldest and are counted as superseded") - func latestPastTheCeiling() { - let limit = QueryBatchResult.keptResultSetLimit - let combined = answer(resultSets: limit - 1).followedKeepingLatest(by: answer(resultSets: 3, errorAfter: 3)) - - #expect(combined.resultSets.count == limit) - #expect(combined.resultSets.last?.columns == ["c2"]) - #expect(combined.resultSets.dropLast(3).last?.columns == ["c\(limit - 2)"]) - #expect(combined.supersededResultSetCount == 2) - #expect(combined.discardedResultSetCount == 0) - #expect(combined.errors.map(\.precedingResultSetCount) == [limit]) - } } diff --git a/apple/TableProTests/Helpers/FakeMSSQLPlugin.swift b/apple/TableProTests/Helpers/FakeMSSQLPlugin.swift index a21c207a64..9a3a6f9a6c 100644 --- a/apple/TableProTests/Helpers/FakeMSSQLPlugin.swift +++ b/apple/TableProTests/Helpers/FakeMSSQLPlugin.swift @@ -193,9 +193,6 @@ final class FakeMSSQLPluginDriver: PluginDriverStub, @unchecked Sendable { } func disconnect() { disconnectCallCount += 1 } - // SQL Server moves a live session with USE, so a statement pinned to a database after a reconnect lands. - func switchDatabase(to database: String) async throws {} - func applyQueryTimeout(_ seconds: Int) async throws { queryTimeoutValues.withLock { $0.append(seconds) } } diff --git a/apple/TableProTests/ViewModels/ConnectionFormPortTLSTests.swift b/apple/TableProTests/ViewModels/ConnectionFormPortTLSTests.swift index a1fbcb95d6..f4865d2306 100644 --- a/apple/TableProTests/ViewModels/ConnectionFormPortTLSTests.swift +++ b/apple/TableProTests/ViewModels/ConnectionFormPortTLSTests.swift @@ -118,13 +118,10 @@ struct ConnectionFormPortTLSTests { #expect(coordinator.ssl.validationIssues.isEmpty) } - @Test("PostgreSQL Verify Identity saves without a CA certificate, and Verify CA still asks for one") - func postgresNeedsACAOnlyForVerifyCA() { + @Test("PostgreSQL Verify Identity still asks for a CA certificate") + func postgresStillRequiresCA() { let coordinator = newConnection(.postgresql) coordinator.ssl.select(.verifyIdentity) - #expect(coordinator.ssl.validationIssues.isEmpty) - - coordinator.ssl.select(.verifyCa) #expect(!coordinator.ssl.validationIssues.isEmpty) } }