diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBAccessMode.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBAccessMode.swift index 5bbdd843dd..33cb46cab3 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBAccessMode.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBAccessMode.swift @@ -14,14 +14,14 @@ import Foundation /// `DuckDBError` -- and a rejected value leaves the config untouched, so the open then **succeeds /// read-write with writes allowed**. A caller that ignores `duckdb_set_config`'s return therefore /// ships a read-only toggle that silently does nothing. -enum DuckDBAccessMode: String { +nonisolated enum DuckDBAccessMode: String { case readWrite = "READ_WRITE" case readOnly = "READ_ONLY" static let configurationOption = "access_mode" } -extension DuckDBAccessMode { +nonisolated extension DuckDBAccessMode { static let fieldId = "duckdbReadOnly" /// Read-only applies to a database file, whatever it is called. Measured: `access_mode` of diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBConnectAttempt.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBConnectAttempt.swift index 4c27e88e13..a890ab26a6 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBConnectAttempt.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBConnectAttempt.swift @@ -5,11 +5,11 @@ import Foundation -internal enum DuckDBConnectAttemptError: Error, Equatable, Sendable { +nonisolated internal enum DuckDBConnectAttemptError: Error, Equatable, Sendable { case timedOut } -internal final class DuckDBConnectAttempt: @unchecked Sendable { +nonisolated internal final class DuckDBConnectAttempt: @unchecked Sendable { internal static let defaultTimeoutMilliseconds = 30_000 private enum State: Equatable { diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBConnection.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBConnection.swift index 26b3de538b..525c51e330 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBConnection.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBConnection.swift @@ -12,7 +12,7 @@ import TableProPluginKit /// Everything a reopen needs to put the connection back where it was. Held from the first open, /// because a released handle has to be re-acquired from inside the actor with nothing handed down /// to it. -struct DuckDBOpenSpec: Sendable, Equatable { +nonisolated struct DuckDBOpenSpec: Sendable, Equatable { let path: String let accessMode: DuckDBAccessMode /// False for Remote mode, whose token and trust come from the connection form alone. Loaded, a secret @@ -23,7 +23,7 @@ struct DuckDBOpenSpec: Sendable, Equatable { /// Why a release did not happen, for the log line that tells a user whose lock never comes back /// whether the timer is broken or the session is holding something. -enum DuckDBReleaseOutcome: Equatable { +nonisolated enum DuckDBReleaseOutcome: Equatable { case released case alreadyReleased case notOpen @@ -35,19 +35,112 @@ enum DuckDBReleaseOutcome: Equatable { case stateUnreadable } +// The open database and the task threads its connections share, with the transfer connections opened on it. Used only +// on the executor of the session that opened it, which those connections run on too. +nonisolated final class DuckDBOpenDatabase: @unchecked Sendable { + var database: duckdb_database? + var taskThreads: DuckDBTaskThreads? + var transferConnections: [ObjectIdentifier: DuckDBConnectionHandles] = [:] + // Keyed as `transferConnections`, so a close can end each one's read before its connection. + var transferActors: [ObjectIdentifier: DuckDBTransferReference] = [:] +} + +nonisolated final class DuckDBTransferReference: @unchecked Sendable { + weak var actor: DuckDBConnectionActor? + + init(_ actor: DuckDBConnectionActor) { + self.actor = actor + } +} + +// A connection, with the second one that renders the rows of a result the first is still producing. +nonisolated final class DuckDBConnectionHandles: @unchecked Sendable { + let live: DuckDBLiveConnectionBox + var connection: duckdb_connection? + var renderConnection: duckdb_connection? + var renderSettings: [String: String] = [:] + var resultReader: DuckDBResultReader? + + init(live: DuckDBLiveConnectionBox) { + self.live = live + } + + // The box is cleared before the disconnect, so a cancel never reaches a freed connection. + func close() { + live.set(nil) + resultReader = nil + if renderConnection != nil { + duckdb_disconnect(&renderConnection) + renderConnection = nil + } + if connection != nil { + duckdb_disconnect(&connection) + connection = nil + } + renderSettings = [:] + } +} + +// One value of a fetched chunk, read in place: text and bytes point into the chunk and live only for the call, so a +// reader that cuts a value for display copies only what it keeps. +nonisolated enum DuckDBChunkValue { + case null + case text(UnsafeRawBufferPointer) + case bytes(UnsafeRawBufferPointer) + case spelled(String) + + var pluginValue: PluginCellValue { + switch self { + case .null: .null + case .text(let utf8): .text(String(decoding: utf8, as: UTF8.self)) + case .bytes(let bytes): .bytes(Data(bytes)) + case .spelled(let text): .text(text) + } + } +} + +// What a read hands out for a value of the named column. +typealias DuckDBValueReader = @Sendable (_ column: String, _ value: DuckDBChunkValue) -> Value + +nonisolated enum DuckDBPulledElement: Sendable { + case header(PluginStreamHeader) + case rows([[Value]]) +} + actor DuckDBConnectionActor { private static let logger = Logger(subsystem: "com.TablePro", category: "DuckDBConnectionActor") - private let executor = DuckDBStackExecutor(name: "com.TablePro.duckdb") + private let executor: DuckDBStackExecutor nonisolated var unownedExecutor: UnownedSerialExecutor { executor.asUnownedSerialExecutor() } - private var database: duckdb_database? - private var taskThreads: DuckDBTaskThreads? - private var connection: duckdb_connection? - // Renders the rows of a result the session's own connection is still producing. - private var renderConnection: duckdb_connection? - private var renderSettings: [String: String] = [:] - private var resultReader: DuckDBResultReader? + private let openDatabase: DuckDBOpenDatabase + private let handles: DuckDBConnectionHandles + // False for a transfer connection, which reads the database its session opened and closes. + private let ownsDatabase: Bool + + private var database: duckdb_database? { + get { openDatabase.database } + set { openDatabase.database = newValue } + } + + private var taskThreads: DuckDBTaskThreads? { + get { openDatabase.taskThreads } + set { openDatabase.taskThreads = newValue } + } + + private var connection: duckdb_connection? { + get { handles.connection } + set { handles.connection = newValue } + } + + private var renderSettings: [String: String] { + get { handles.renderSettings } + set { handles.renderSettings = newValue } + } + + private var resultReader: DuckDBResultReader? { handles.resultReader } + + private var liveConnection: DuckDBLiveConnectionBox { handles.live } private var openSpec: DuckDBOpenSpec? @@ -69,16 +162,28 @@ actor DuckDBConnectionActor { private var lastActivity = ContinuousClock.now private var isReleased = false - private let liveConnection: DuckDBLiveConnectionBox + private var pulledRead: PulledRead? + private var lastPulledRead: UInt64 = 0 init(liveConnection: DuckDBLiveConnectionBox) { - self.liveConnection = liveConnection + executor = DuckDBStackExecutor(name: "com.TablePro.duckdb") + openDatabase = DuckDBOpenDatabase() + handles = DuckDBConnectionHandles(live: liveConnection) + ownsDatabase = true + } + + private init(transferOn executor: DuckDBStackExecutor, of openDatabase: DuckDBOpenDatabase, handles: DuckDBConnectionHandles) { + self.executor = executor + self.openDatabase = openDatabase + self.handles = handles + ownsDatabase = false } /// True while the handle is closed but the connection is still live and will reopen on demand. var hasReleasedFile: Bool { isReleased } func open(spec: DuckDBOpenSpec) throws { + guard ownsDatabase else { throw DuckDBPluginError.unsupportedOperation } try openHandle(spec: spec) openSpec = spec isReleased = false @@ -103,7 +208,34 @@ actor DuckDBConnectionActor { baselineSettings = (try? readSettings()) ?? [:] } - func close() { + // A connection on this database for a transfer. DuckDB gives it a transaction of its own, so it reads one snapshot + // while the session writes. It runs on this executor, and every close of the database closes it first. + func openTransferConnection(liveConnection: DuckDBLiveConnectionBox) throws -> DuckDBConnectionActor { + guard ownsDatabase else { throw DuckDBPluginError.unsupportedOperation } + try ensureOpen() + guard let database else { throw DuckDBPluginError.notConnected } + let transfer = DuckDBConnectionHandles(live: liveConnection) + try Self.connect(transfer, to: database) + let actor = DuckDBConnectionActor(transferOn: executor, of: openDatabase, handles: transfer) + openDatabase.transferConnections[ObjectIdentifier(transfer)] = transfer + openDatabase.transferActors[ObjectIdentifier(transfer)] = DuckDBTransferReference(actor) + lastActivity = ContinuousClock.now + return actor + } + + func close() async { + closePulledRead() + guard ownsDatabase else { + openDatabase.transferConnections[ObjectIdentifier(handles)] = nil + openDatabase.transferActors[ObjectIdentifier(handles)] = nil + handles.close() + hasOpenTransaction = false + return + } + // Each transfer connection ends the read it holds, which keeps the database open, before it closes. + for transfer in openDatabase.transferActors.values.compactMap(\.actor) { + await transfer.close() + } closeHandle() openSpec = nil sessionSetup = [] @@ -126,6 +258,8 @@ actor DuckDBConnectionActor { guard !isReleased else { return .alreadyReleased } guard connection != nil, let spec = openSpec else { return .notOpen } if let minimumIdle, ContinuousClock.now - lastActivity < minimumIdle { return .notIdleYet } + // A transfer connection reading the file is use of it. + guard openDatabase.transferConnections.isEmpty else { return .notIdleYet } if let blocked = heldSessionState() { return blocked } @@ -175,10 +309,17 @@ actor DuckDBConnectionActor { /// Checks the handle without counting as use. `executeQuery` would refresh `lastActivity`, and /// a health check every thirty seconds would then hold the idle clock at zero forever. - @discardableResult - func pingQuery() throws -> DuckDBRawResult { + func pingQuery() throws { try ensureOpen() - return try runInternalQuery("SELECT 1") + guard let conn = connection else { throw DuckDBPluginError.notConnected } + // A statement would end the read being handed out, which is itself a live session. + guard pulledRead == nil else { return } + var result = duckdb_result() + defer { duckdb_destroy_result(&result) } + guard duckdb_query(conn, "SELECT 1", &result) == DuckDBError else { return } + // An aborted transaction refuses every statement until its ROLLBACK, on a session that is still alive. + guard duckdb_result_error_type(&result) != DUCKDB_ERROR_TRANSACTION else { return } + throw DuckDBPluginError.queryFailed(Self.errorMessage(from: &result)) } func executeQuery(_ query: String) throws -> DuckDBRawResult { @@ -200,6 +341,7 @@ actor DuckDBConnectionActor { guard let conn = connection else { throw DuckDBPluginError.notConnected } + closePulledRead() let startTime = Date() noteActivity(query) @@ -218,6 +360,7 @@ actor DuckDBConnectionActor { guard let conn = connection else { throw DuckDBPluginError.notConnected } + closePulledRead() noteActivity(query) var opened = try openResult(query: query, parameters: [], connection: conn, unread: .abandonWhenIdle) @@ -272,13 +415,114 @@ actor DuckDBConnectionActor { private func readOnlyConnection() throws -> duckdb_connection { try ensureOpen() guard let conn = connection else { throw DuckDBPluginError.notConnected } + closePulledRead() lastActivity = ContinuousClock.now return conn } + // MARK: - Read handed out a batch at a time + + // A read handed out one batch per call, so other work on this executor runs between batches. Any other statement on + // the connection ends it first, and the next call then throws CancellationError. + private nonisolated struct PulledRead { + var opened: OpenedResult + var projection: duckdb_prepared_statement? + let generation: UInt64 + // The read-only transaction DuckDBReadOnlyStatement opened for it, rolled back when it ends. + let endsReadOnlyTransaction: Bool + } + + func beginPulledRead( + _ query: String, + reason: DuckDBReadOnlyStatement.Reason? + ) throws -> (header: PluginStreamHeader, generation: UInt64) { + // A Stop that came while this waited for the executor interrupted nothing, and DuckDB clears it at the start. + try Task.checkCancellation() + let conn: duckdb_connection + if let reason { + conn = try readOnlyConnection() + try DuckDBReadOnlyStatement.begin(on: conn, session: sessionTransactionState(), reason: reason) + } else { + try ensureOpen() + guard let open = connection else { throw DuckDBPluginError.notConnected } + closePulledRead() + noteActivity(query) + conn = open + } + let opened: OpenedResult + do { + opened = try openResult( + query: query, parameters: [], connection: conn, + unread: reason == nil ? .abandonWhenIdle : .abandon, session: reason == nil ? nil : .inTransaction + ) + } catch { + if reason != nil { DuckDBReadOnlyStatement.end(on: conn) } + throw error + } + lastPulledRead &+= 1 + pulledRead = PulledRead( + opened: opened, projection: nil, generation: lastPulledRead, endsReadOnlyTransaction: reason != nil + ) + let header = PluginStreamHeader( + columns: opened.schema.names, + columnTypeNames: opened.schema.typeNames, + estimatedRowCount: opened.rowCount.map { Int($0) } + ) + return (header, lastPulledRead) + } + + // Nil once the read has ended, which ends what it opened. + func nextPulledBatch( + _ generation: UInt64, + reading read: DuckDBValueReader + ) throws -> [[Value]]? { + guard var pulled = pulledRead, pulled.generation == generation, let conn = connection else { + throw CancellationError() + } + let batch: [[Value]]? + do { + batch = try nextBatch(of: pulled.opened, projection: &pulled.projection, reading: read) + } catch { + pulledRead = pulled + closePulledRead() + throw error + } + if let batch { + pulledRead = pulled + return batch + } + pulledRead = nil + duckdb_destroy_prepare(&pulled.projection) + defer { + if pulled.endsReadOnlyTransaction { DuckDBReadOnlyStatement.end(on: conn) } + } + try finish(&pulled.opened, on: conn) + return nil + } + + func endPulledRead(_ generation: UInt64? = nil) { + guard generation == nil || pulledRead?.generation == generation else { return } + closePulledRead() + } + + // What a read given up leaves: its rows unread, and any transaction it opened rolled back. + private func closePulledRead() { + guard var read = pulledRead else { return } + pulledRead = nil + duckdb_destroy_prepare(&read.projection) + guard let conn = connection else { + duckdb_destroy_result(&read.opened.result) + return + } + try? finishUnreadRows(of: read.opened) + close(&read.opened, on: conn) + if read.endsReadOnlyTransaction { DuckDBReadOnlyStatement.end(on: conn) } + } + // MARK: - Handle lifecycle private func openHandle(spec: DuckDBOpenSpec) throws { + DuckDBExtensionPolicy.registerLinkedExtensions() var config: duckdb_config? guard duckdb_create_config(&config) != DuckDBError else { throw DuckDBPluginError.connectionFailed( @@ -310,6 +554,10 @@ actor DuckDBConnectionActor { String(localized: "This build of DuckDB does not accept running its tasks on threads TablePro starts") ) } + for option in DuckDBExtensionPolicy.openOptions + where duckdb_set_config(config, option.name, option.value) == DuckDBError { + throw DuckDBPluginError.connectionFailed("DuckDB rejected \(option.name) = \(option.value)") + } if !spec.allowsPersistentSecrets { guard duckdb_set_config(config, "allow_persistent_secrets", "false") != DuckDBError else { throw DuckDBPluginError.connectionFailed( @@ -358,50 +606,48 @@ actor DuckDBConnectionActor { ) } - var conn: duckdb_connection? - let connState = duckdb_connect(openedDB, &conn) - - if connState == DuckDBError { + do { + try Self.connect(handles, to: openedDB) + } catch { duckdb_close(&db) - throw DuckDBPluginError.connectionFailed("Failed to create DuckDB connection") + throw error } + database = db + taskThreads = DuckDBTaskThreads(database: openedDB) + } - guard let conn else { - duckdb_close(&db) + // Both connections of `handles`, or neither. + private static func connect(_ handles: DuckDBConnectionHandles, to database: duckdb_database) throws { + var conn: duckdb_connection? + guard duckdb_connect(database, &conn) != DuckDBError, let conn else { throw DuckDBPluginError.connectionFailed("Failed to create DuckDB connection") } var renderConn: duckdb_connection? do { - guard duckdb_connect(openedDB, &renderConn) != DuckDBError, let renderConn else { + guard duckdb_connect(database, &renderConn) != DuckDBError, let renderConn else { throw DuckDBPluginError.connectionFailed("Failed to create DuckDB connection") } - resultReader = try DuckDBResultReader(renderConnection: renderConn) + handles.resultReader = try DuckDBResultReader(renderConnection: renderConn) } catch { if renderConn != nil { duckdb_disconnect(&renderConn) } var failedConnection: duckdb_connection? = conn duckdb_disconnect(&failedConnection) - duckdb_close(&db) throw error } - database = db - taskThreads = DuckDBTaskThreads(database: openedDB) - connection = conn - renderConnection = renderConn - renderSettings = [:] - liveConnection.set(conn) + handles.connection = conn + handles.renderConnection = renderConn + handles.renderSettings = [:] + handles.live.set(conn) } + // A transfer connection left open would keep the file after the close. private func closeHandle() { - liveConnection.set(nil) - resultReader = nil - if renderConnection != nil { - duckdb_disconnect(&renderConnection) - renderConnection = nil - } - if connection != nil { - duckdb_disconnect(&connection) - connection = nil + for transfer in openDatabase.transferConnections.values { + transfer.close() } + openDatabase.transferConnections = [:] + openDatabase.transferActors = [:] + handles.close() taskThreads?.close() taskThreads = nil if database != nil { @@ -438,6 +684,8 @@ actor DuckDBConnectionActor { func sessionTransactionState() -> PluginSessionTransactionState { guard !isReleased else { return .idle } guard connection != nil else { return .unknown } + // A probe statement would end the read being handed out. + guard pulledRead == nil else { return .unknown } if let decided = DuckDBTransactionProbe.state( catalogType: probeReading(DuckDBTransactionProbe.catalogTypeQuery), tracksOpenTransaction: hasOpenTransaction @@ -532,7 +780,7 @@ actor DuckDBConnectionActor { // MARK: - Execution - private struct OpenedResult { + private nonisolated struct OpenedResult { var result: duckdb_result let schema: ColumnSchema let rowsChanged: idx_t @@ -746,11 +994,10 @@ actor DuckDBConnectionActor { case .text(let value): state = duckdb_bind_varchar_length(stmt, position, value, idx_t(value.utf8.count)) case .bytes(let data): - state = data.withUnsafeBytes { buffer -> duckdb_state in - guard let baseAddress = buffer.baseAddress else { - return duckdb_bind_null(stmt, position) - } - return duckdb_bind_blob(stmt, position, baseAddress, idx_t(data.count)) + // An empty Data has no base address, and a null pointer binds NULL rather than an empty blob. + let bytes = data.isEmpty ? Data([0]) : data + state = bytes.withUnsafeBytes { buffer in + duckdb_bind_blob(stmt, position, buffer.baseAddress, idx_t(data.count)) } } if state == DuckDBError { @@ -766,7 +1013,7 @@ actor DuckDBConnectionActor { // MARK: - Extraction - private struct ColumnSchema { + private nonisolated struct ColumnSchema { let names: [String] let logicalTypes: [DuckDBLogicalType?] @@ -895,12 +1142,21 @@ actor DuckDBConnectionActor { // Returns false when `body` stopped the read before the result ended. @discardableResult private func readRows(of opened: OpenedResult, body: ([[PluginCellValue]]) -> Bool) throws -> Bool { - var source = opened.result - let types = Self.storageTypes(of: &source) - let needsText = DuckDBLogicalType.requiresTextProjection(anyOf: opened.schema.logicalTypes) var projection: duckdb_prepared_statement? defer { duckdb_destroy_prepare(&projection) } + while let batch = try nextBatch(of: opened, projection: &projection, reading: { _, value in value.pluginValue }) { + guard body(batch) else { return false } + } + return true + } + // The next chunk that holds rows, nil at the end of the result. `projection` renders it, prepared on first use. + private func nextBatch( + of opened: OpenedResult, + projection: inout duckdb_prepared_statement?, + reading read: DuckDBValueReader + ) throws -> [[Value]]? { + var source = opened.result while true { // A statement that ran whole has already taken effect, so its rows are still handed back. if opened.isStreaming { try Task.checkCancellation() } @@ -909,25 +1165,22 @@ actor DuckDBConnectionActor { if let message = duckdb_result_error(&source) { throw DuckDBPluginError.queryFailed(String(cString: message)) } - return true + return nil } defer { duckdb_destroy_data_chunk(&chunk) } guard duckdb_data_chunk_get_size(fetched) > 0 else { continue } - let batch: [[PluginCellValue]] - if needsText { - guard let resultReader else { throw DuckDBPluginError.notConnected } - if projection == nil { - projection = try resultReader.prepareProjection(of: source, columns: opened.schema.projectionColumns) - } - guard let projection else { throw DuckDBPluginError.notConnected } - var rendered = try resultReader.render(fetched, of: source, with: projection) - defer { duckdb_destroy_result(&rendered) } - batch = try Self.renderedRows(of: &rendered) - } else { - batch = Self.rows(of: fetched, types: types) + guard DuckDBLogicalType.requiresTextProjection(anyOf: opened.schema.logicalTypes) else { + return Self.rows(of: fetched, types: Self.storageTypes(of: &source), names: opened.schema.names, reading: read) } - guard body(batch) else { return false } + guard let resultReader else { throw DuckDBPluginError.notConnected } + if projection == nil { + projection = try resultReader.prepareProjection(of: source, columns: opened.schema.projectionColumns) + } + guard let projection else { throw DuckDBPluginError.notConnected } + var rendered = try resultReader.render(fetched, of: source, with: projection) + defer { duckdb_destroy_result(&rendered) } + return try Self.renderedRows(of: &rendered, names: opened.schema.names, reading: read) } } @@ -953,9 +1206,13 @@ actor DuckDBConnectionActor { } } - private static func renderedRows(of rendered: inout duckdb_result) throws -> [[PluginCellValue]] { + private static func renderedRows( + of rendered: inout duckdb_result, + names: [String], + reading read: DuckDBValueReader + ) throws -> [[Value]] { let types = storageTypes(of: &rendered) - var batch: [[PluginCellValue]] = [] + var batch: [[Value]] = [] while true { var chunk = duckdb_fetch_chunk(rendered) guard let fetched = chunk else { @@ -965,7 +1222,7 @@ actor DuckDBConnectionActor { return batch } defer { duckdb_destroy_data_chunk(&chunk) } - batch.append(contentsOf: rows(of: fetched, types: types)) + batch.append(contentsOf: rows(of: fetched, types: types, names: names, reading: read)) } } @@ -973,18 +1230,25 @@ actor DuckDBConnectionActor { (0.. [[PluginCellValue]] { + private static func rows( + of chunk: duckdb_data_chunk, + types: [duckdb_type], + names: [String], + reading read: DuckDBValueReader + ) -> [[Value]] { let size = duckdb_data_chunk_get_size(chunk) let vectors = types.indices.map { duckdb_data_chunk_get_vector(chunk, idx_t($0)) } - var batch: [[PluginCellValue]] = [] + var batch: [[Value]] = [] batch.reserveCapacity(Int(size)) for row in 0.. PluginCellValue { + private static func chunkValue(_ vector: duckdb_vector?, type: duckdb_type, row: idx_t) -> DuckDBChunkValue { guard let vector, let data = duckdb_vector_get_data(vector) else { return .null } if let validity = duckdb_vector_get_validity(vector), !duckdb_validity_row_is_valid(validity, row) { return .null @@ -996,25 +1260,25 @@ actor DuckDBConnectionActor { let bytes = UnsafeRawBufferPointer( start: duckdb_string_t_data(element), count: Int(duckdb_string_t_length(element.pointee)) ) - return type == DUCKDB_TYPE_BLOB ? .bytes(Data(bytes)) : .text(String(decoding: bytes, as: UTF8.self)) + return type == DUCKDB_TYPE_BLOB ? .bytes(bytes) : .text(bytes) case DUCKDB_TYPE_BOOLEAN: - return .text(data.assumingMemoryBound(to: UInt8.self)[index] != 0 ? "true" : "false") + return .spelled(data.assumingMemoryBound(to: UInt8.self)[index] != 0 ? "true" : "false") case DUCKDB_TYPE_TINYINT: - return .text(String(data.assumingMemoryBound(to: Int8.self)[index])) + return .spelled(String(data.assumingMemoryBound(to: Int8.self)[index])) case DUCKDB_TYPE_SMALLINT: - return .text(String(data.assumingMemoryBound(to: Int16.self)[index])) + return .spelled(String(data.assumingMemoryBound(to: Int16.self)[index])) case DUCKDB_TYPE_INTEGER: - return .text(String(data.assumingMemoryBound(to: Int32.self)[index])) + return .spelled(String(data.assumingMemoryBound(to: Int32.self)[index])) case DUCKDB_TYPE_BIGINT: - return .text(String(data.assumingMemoryBound(to: Int64.self)[index])) + return .spelled(String(data.assumingMemoryBound(to: Int64.self)[index])) case DUCKDB_TYPE_UTINYINT: - return .text(String(data.assumingMemoryBound(to: UInt8.self)[index])) + return .spelled(String(data.assumingMemoryBound(to: UInt8.self)[index])) case DUCKDB_TYPE_USMALLINT: - return .text(String(data.assumingMemoryBound(to: UInt16.self)[index])) + return .spelled(String(data.assumingMemoryBound(to: UInt16.self)[index])) case DUCKDB_TYPE_UINTEGER: - return .text(String(data.assumingMemoryBound(to: UInt32.self)[index])) + return .spelled(String(data.assumingMemoryBound(to: UInt32.self)[index])) case DUCKDB_TYPE_UBIGINT: - return .text(String(data.assumingMemoryBound(to: UInt64.self)[index])) + return .spelled(String(data.assumingMemoryBound(to: UInt64.self)[index])) default: return .null } @@ -1063,7 +1327,7 @@ actor DuckDBConnectionActor { } } -struct DuckDBRawResult: @unchecked Sendable { +nonisolated struct DuckDBRawResult: @unchecked Sendable { let columns: [String] let columnTypeNames: [String] var rows: [[PluginCellValue]] diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBExtensionPolicy.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBExtensionPolicy.swift new file mode 100644 index 0000000000..1df79ea0a0 --- /dev/null +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBExtensionPolicy.swift @@ -0,0 +1,31 @@ +// +// DuckDBExtensionPolicy.swift +// DuckDBDriverPlugin +// + +import CDuckDB +import Foundation + +// iOS may not run code it downloads (App Store Review Guideline 2.5.2): its DuckDB links its extensions in +// (scripts/build-duckdb-ios.sh) and installs none. macOS installs and loads a known extension when a statement needs it. +nonisolated enum DuckDBExtensionPolicy { + #if os(iOS) + static let openOptions: [(name: String, value: String)] = [ + (name: "autoinstall_known_extensions", value: "false"), + (name: "autoload_known_extensions", value: "false"), + ] + static let sessionStatements: [String] = [] + + // DuckDB's generated loader registers them once per process, before the first open. + private static let registration: Int32 = duckdb_register_static_extensions() + + static func registerLinkedExtensions() { + _ = registration + } + #else + static let openOptions: [(name: String, value: String)] = [] + static let sessionStatements = ["SET autoinstall_known_extensions=1", "SET autoload_known_extensions=1"] + + static func registerLinkedExtensions() {} + #endif +} diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBFileKinds.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBFileKinds.swift index bd6f3cdf5a..7c56173153 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBFileKinds.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBFileKinds.swift @@ -9,7 +9,7 @@ import Foundation -enum DuckDBFileKinds { +nonisolated enum DuckDBFileKinds { /// DuckDB's own storage format. Opening a path that does not exist creates the /// database there, which is what the connection form's file field offers. static let database = ["duckdb", "ddb"] diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBIdleRelease.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBIdleRelease.swift index e932faad78..fafc6fb358 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBIdleRelease.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBIdleRelease.swift @@ -16,7 +16,7 @@ import Foundation /// rolled back with nothing raised. The driver refuses to release while it holds any of those, /// so the feature is safe once it is on, but a connection that never releases is what a user /// who has not asked for this should get. -enum DuckDBIdleRelease { +nonisolated enum DuckDBIdleRelease { static let fieldId = "duckdbIdleReleaseMinutes" /// Four hours. Past this the setting is indistinguishable from never, and a stepper with a diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBIsolatedImport.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBIsolatedImport.swift index 90738ac403..001af86375 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBIsolatedImport.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBIsolatedImport.swift @@ -8,7 +8,7 @@ import Foundation // DuckDB's settings for running untrusted SQL ("Securing DuckDB" in its operations manual), on an instance of its own, // since `enable_external_access` cannot be turned back on once a session turns it off. -enum DuckDBIsolatedImport { +nonisolated enum DuckDBIsolatedImport { static let openOptions: [(name: String, value: String)] = [ ("autoinstall_known_extensions", "false"), ("autoload_known_extensions", "false"), @@ -39,6 +39,7 @@ enum DuckDBIsolatedImport { } private static func importFolder(_ folder: String, into file: String, live: DuckDBLiveConnectionBox) throws { + DuckDBExtensionPolicy.registerLinkedExtensions() var config: duckdb_config? guard duckdb_create_config(&config) != DuckDBError else { throw DuckDBPluginError.connectionFailed("DuckDB could not allocate a configuration") diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBLiveConnectionBox.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBLiveConnectionBox.swift index a589d852df..75fdba9266 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBLiveConnectionBox.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBLiveConnectionBox.swift @@ -19,7 +19,7 @@ import Foundation /// So the actor owns the writes and makes them either side of the C calls: cleared **before** /// `duckdb_disconnect`, set **after** `duckdb_connect`. A cancel that lands in the gap reads nil /// and does nothing, which is the right answer, because there is no query running to interrupt. -final class DuckDBLiveConnectionBox: @unchecked Sendable { +nonisolated final class DuckDBLiveConnectionBox: @unchecked Sendable { private let lock = NSLock() nonisolated(unsafe) private var handle: duckdb_connection? diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBLockConflict.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBLockConflict.swift index a8a3aa02dc..0e9118544b 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBLockConflict.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBLockConflict.swift @@ -20,7 +20,7 @@ import Foundation /// database in read-only mode" before that URL, which is DuckDB's own signal that a read-only /// retry would succeed. Everything past the anchor is optional so a reworded DuckDB release /// degrades to "another process has the file" instead of failing to classify at all. -struct DuckDBLockConflict: Equatable { +nonisolated struct DuckDBLockConflict: Equatable { let filePath: String? let holderExecutablePath: String? let holderProcessId: Int? @@ -92,7 +92,7 @@ struct DuckDBLockConflict: Equatable { } } -extension DuckDBLockConflict { +nonisolated extension DuckDBLockConflict { /// What the user is told. DuckDB's own sentence names the holder, a path and a /// documentation URL, which is more than a person needs and less than they can act on, so /// the holder's name is promoted to the front and the rest is dropped. diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBPlugin.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBPlugin.swift index c70e15342a..65d2bb6418 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBPlugin.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBPlugin.swift @@ -12,7 +12,7 @@ import TableProSQLGrammar import TableProSQLQuoting import TableProSQLVocabulary -final class DuckDBPlugin: NSObject, TableProPlugin, DriverPlugin { +nonisolated final class DuckDBPlugin: NSObject, TableProPlugin, DriverPlugin { static let pluginName = "DuckDB Driver" static let pluginVersion = "1.1.0" static let pluginDescription = "DuckDB analytical database support" @@ -215,7 +215,7 @@ final class DuckDBPlugin: NSObject, TableProPlugin, DriverPlugin { } } -private extension SQLOperatorDescriptor { +nonisolated private extension SQLOperatorDescriptor { init?(vocabulary entry: SQLEngineVocabulary.Operator) { guard let category = Category(rawValue: entry.category), let placement = Placement(rawValue: entry.placement) else { return nil } @@ -231,10 +231,12 @@ private extension SQLOperatorDescriptor { // MARK: - DuckDB Plugin Driver -final class DuckDBPluginDriver: PluginDatabaseDriver, @unchecked Sendable { +nonisolated final class DuckDBPluginDriver: PluginDatabaseDriver, @unchecked Sendable { private let config: DriverConnectionConfig - private let liveConnection = DuckDBLiveConnectionBox() + private let liveConnection: DuckDBLiveConnectionBox private let connectionActor: DuckDBConnectionActor + // A transfer connection's reads are handed out a batch per pull, so the session sharing its executor runs between. + private let pullsReads: Bool private let idleReleaseTimer = DuckDBIdleReleaseTimer() private let trustBundleFile = DuckDBTrustBundleFile() private let stateLock = NSLock() @@ -283,7 +285,44 @@ final class DuckDBPluginDriver: PluginDatabaseDriver, @unchecked Sendable { init(config: DriverConnectionConfig) { self.config = config + let liveConnection = DuckDBLiveConnectionBox() + self.liveConnection = liveConnection self.connectionActor = DuckDBConnectionActor(liveConnection: liveConnection) + pullsReads = false + } + + private init( + config: DriverConnectionConfig, + transferOn connectionActor: DuckDBConnectionActor, + liveConnection: DuckDBLiveConnectionBox, + database: String?, + schema: String + ) { + self.config = config + self.liveConnection = liveConnection + self.connectionActor = connectionActor + pullsReads = true + _currentDatabase = database + _currentSchema = schema + } + + // A driver on a connection of its own to this session's database, for a transfer: open already, on the session's + // catalog and schema, and its disconnect ends only that connection. + func openTransferDriver() async throws -> DuckDBPluginDriver { + let live = DuckDBLiveConnectionBox() + let transfer = try await connectionActor.openTransferConnection(liveConnection: live) + let (database, schema) = stateLock.withLock { (_currentDatabase, _currentSchema) } + if let database, !database.isEmpty { + do { + _ = try await transfer.executeQuery(DuckDBSchemaQueries.useSchema(schema, in: database)) + } catch { + await transfer.close() + throw error + } + } + return DuckDBPluginDriver( + config: config, transferOn: transfer, liveConnection: live, database: database, schema: schema + ) } /// The timer's task holds the connection actor, not the driver, so a driver dropped without @@ -551,15 +590,16 @@ final class DuckDBPluginDriver: PluginDatabaseDriver, @unchecked Sendable { private func enableExtensionAutoloading() async { do { - try await connectionActor.executeQuery("SET autoinstall_known_extensions=1") - try await connectionActor.executeQuery("SET autoload_known_extensions=1") + for statement in DuckDBExtensionPolicy.sessionStatements { + try await connectionActor.executeQuery(statement) + } } catch { Self.logger.warning("Failed to enable DuckDB extension autoloading: \(error.localizedDescription)") } } private func enableExtensionAutoloading(during attempt: DuckDBConnectAttempt) async throws { - for statement in ["SET autoinstall_known_extensions=1", "SET autoload_known_extensions=1"] { + for statement in DuckDBExtensionPolicy.sessionStatements { do { try await executeRemoteConnectStatement(statement, during: attempt) } catch { @@ -609,7 +649,7 @@ final class DuckDBPluginDriver: PluginDatabaseDriver, @unchecked Sendable { /// The statements that put a reopened session back where it was. Recomputed rather than /// appended to, so a session that has switched database a dozen times replays one `USE`. private func refreshSessionSetup() async { - var statements = ["SET autoinstall_known_extensions=1", "SET autoload_known_extensions=1"] + var statements = DuckDBExtensionPolicy.sessionStatements let (database, schema, attachSetup) = stateLock.withLock { (_currentDatabase, _currentSchema, _attachSetup) } statements += attachSetup if let database, !database.isEmpty { @@ -663,12 +703,22 @@ final class DuckDBPluginDriver: PluginDatabaseDriver, @unchecked Sendable { } func disconnect() { + let closing = beginClose() + Task { await closing() } + } + + // The disconnect that returns once the file is closed, for a caller that hands the file on next. + func close() async { + await beginClose()() + } + + private func beginClose() -> @Sendable () async -> Void { liveConnection.interrupt() resetCurrentPosition() let actor = connectionActor let timer = idleReleaseTimer let trustBundle = trustBundleFile.take() - Task { + return { await timer.stop() await actor.close() // Only once the instance is closed, so no request of it reads a bundle that is gone. @@ -682,7 +732,7 @@ final class DuckDBPluginDriver: PluginDatabaseDriver, @unchecked Sendable { /// prove that would take the lock straight back off whatever the release handed it to. func ping() async throws { guard !(await connectionActor.hasReleasedFile) else { return } - _ = try await connectionActor.pingQuery() + try await connectionActor.pingQuery() } func applyQueryTimeout(_ seconds: Int) async throws { @@ -785,6 +835,7 @@ final class DuckDBPluginDriver: PluginDatabaseDriver, @unchecked Sendable { // MARK: - Streaming func streamRows(query: String) -> AsyncThrowingStream { + guard !pullsReads else { return pulledRows(query: query, context: PluginStatementContext()) } let actor = connectionActor return AsyncThrowingStream(bufferingPolicy: .bufferingOldest(DuckDBBoundedStream.bufferedBatches)) { continuation in @@ -799,6 +850,7 @@ final class DuckDBPluginDriver: PluginDatabaseDriver, @unchecked Sendable { } func streamRows(query: String, context: PluginStatementContext) -> AsyncThrowingStream { + guard !pullsReads else { return pulledRows(query: query, context: context) } guard let reason = DuckDBReadOnlyStatement.reason(for: context) else { return streamRows(query: query) } let actor = connectionActor return AsyncThrowingStream(bufferingPolicy: .bufferingOldest(DuckDBBoundedStream.bufferedBatches)) { continuation in @@ -812,6 +864,49 @@ final class DuckDBPluginDriver: PluginDatabaseDriver, @unchecked Sendable { } } + // The rows a batch per pull, so the connection's executor runs other work between batches. Any other statement on + // the connection ends the read. + func pulledRows(query: String, context: PluginStatementContext) -> AsyncThrowingStream { + let cursor = pulledCursor(query: query, context: context) { _, value in value.pluginValue } + return AsyncThrowingStream(unfolding: { + switch try await cursor.next() { + case .header(let header): return .header(header) + case .rows(let rows): return .rows(rows) + case nil: return nil + } + }) + } + + // The same read with each value made by `read` from the chunk in place, so a host that cuts a value for display + // never copies the rest of it. + func pulledValues( + query: String, + context: PluginStatementContext, + reading read: @escaping DuckDBValueReader + ) -> AsyncThrowingStream, Error> { + let cursor = pulledCursor(query: query, context: context, reading: read) + return AsyncThrowingStream(unfolding: { try await cursor.next() }) + } + + private func pulledCursor( + query: String, + context: PluginStatementContext, + reading read: @escaping DuckDBValueReader + ) -> DuckDBPulledRows { + DuckDBPulledRows( + actor: connectionActor, + query: query, + reason: DuckDBReadOnlyStatement.reason(for: context), + live: liveConnection, + read: read + ) + } + + // Gives up the read `pulledRows` handed out, for a consumer that stopped before its end. + func endPulledRows() async { + await connectionActor.endPulledRead() + } + // MARK: - Schema Operations func fetchTables(schema: String?) async throws -> [PluginTableInfo] { @@ -980,8 +1075,11 @@ final class DuckDBPluginDriver: PluginDatabaseDriver, @unchecked Sendable { DuckDBSchemaQueries.quoteIdentifier(name) } + // DuckDB reads statement text as a C string, which ends at a NUL, so each one is joined in with chr(0). func escapeStringLiteral(_ value: String) -> String { - SQLQuoting.stringLiteralBody(value) + value.unicodeScalars.split(separator: "\0", omittingEmptySubsequences: false) + .map { SQLQuoting.stringLiteralBody(String(Substring($0))) } + .joined(separator: "'||chr(0)||'") } func objectCommentStatement(name: String, objectType: String, schema: String?, comment: String?) -> String? { @@ -1211,3 +1309,65 @@ final class DuckDBPluginDriver: PluginDatabaseDriver, @unchecked Sendable { return stmts.isEmpty ? nil : stmts } } + +// The pull side of a read handed out a batch at a time. A stream dropped before its end gives the read up. +nonisolated private final class DuckDBPulledRows: @unchecked Sendable { + private let actor: DuckDBConnectionActor + private let query: String + private let reason: DuckDBReadOnlyStatement.Reason? + private let live: DuckDBLiveConnectionBox + private let read: DuckDBValueReader + private let lock = NSLock() + private var generation: UInt64? + private var ended = false + + init( + actor: DuckDBConnectionActor, + query: String, + reason: DuckDBReadOnlyStatement.Reason?, + live: DuckDBLiveConnectionBox, + read: @escaping DuckDBValueReader + ) { + self.actor = actor + self.query = query + self.reason = reason + self.live = live + self.read = read + } + + deinit { + let open = lock.withLock { ended ? nil : generation } + guard let open else { return } + let actor = actor + Task { await actor.endPulledRead(open) } + } + + func next() async throws -> DuckDBPulledElement? { + let actor = actor + let live = live + let read = read + do { + return try await withTaskCancellationHandler { + if let current = lock.withLock({ generation }) { + guard let rows = try await actor.nextPulledBatch(current, reading: read) else { + markEnded() + return nil + } + return .rows(rows) + } + let begun = try await actor.beginPulledRead(query, reason: reason) + lock.withLock { generation = begun.generation } + return .header(begun.header) + } onCancel: { + live.interrupt() + } + } catch { + markEnded() + throw error + } + } + + private func markEnded() { + lock.withLock { ended = true } + } +} diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBPluginDriver+Rename.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBPluginDriver+Rename.swift index 346d0a8f10..ee3652cb26 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBPluginDriver+Rename.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBPluginDriver+Rename.swift @@ -6,7 +6,7 @@ import Foundation import TableProPluginKit -extension DuckDBPluginDriver { +nonisolated extension DuckDBPluginDriver { /// The new name is bare and the object stays in its schema. DuckDB has no `ALTER SCHEMA /// RENAME` and no database rename at all, so those stay unimplemented. func renameTable(name: String, schema: String?, to newName: String, objectType: String) async throws { diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBPluginDriver+Routines.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBPluginDriver+Routines.swift index 03b6099611..40f4f7dab8 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBPluginDriver+Routines.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBPluginDriver+Routines.swift @@ -7,7 +7,7 @@ import Foundation import TableProDuckDBCore import TableProPluginKit -extension DuckDBPluginDriver { +nonisolated extension DuckDBPluginDriver { func fetchRoutines(schema: String?) async throws -> [PluginRoutineInfo] { try await DuckDBExportCatalog.routines(catalog: try requireCatalog(), schema: schema, run: catalogRun) } diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBPluginError.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBPluginError.swift index e7710a34e1..79a8f38500 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBPluginError.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBPluginError.swift @@ -6,7 +6,7 @@ import Foundation import TableProPluginKit -enum DuckDBPluginError: Error { +nonisolated enum DuckDBPluginError: Error { case connectionFailed(String) case notConnected case catalogUnresolved @@ -16,7 +16,7 @@ enum DuckDBPluginError: Error { case fileMissing(String) } -extension DuckDBPluginError: PluginDriverError { +nonisolated extension DuckDBPluginError: PluginDriverError { var pluginErrorMessage: String { switch self { case .connectionFailed(let msg): return msg diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBPositionParser.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBPositionParser.swift index 29877b0e3b..2729826343 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBPositionParser.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBPositionParser.swift @@ -8,7 +8,7 @@ import Foundation -enum DuckDBPositionParser { +nonisolated enum DuckDBPositionParser { struct Position: Equatable { let catalog: String? let schema: String? @@ -39,6 +39,6 @@ enum DuckDBPositionParser { } } -private extension String { +nonisolated private extension String { var nilIfEmptyPosition: String? { isEmpty ? nil : self } } diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBReadOnlyStatement.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBReadOnlyStatement.swift index e0e502323e..04ca54f646 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBReadOnlyStatement.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBReadOnlyStatement.swift @@ -7,7 +7,6 @@ import CDuckDB import Foundation import TableProPluginKit -// Depends on nothing else in the plugin, so TableProMobileTests compiles it against a DuckDB connection of its own. nonisolated enum DuckDBReadOnlyStatement { // Who asked for the read-only mode, which is what a refusal names. nonisolated enum Reason: Sendable, Equatable { @@ -51,15 +50,23 @@ nonisolated enum DuckDBReadOnlyStatement { reason: Reason = .externalClients, _ statement: () throws -> T ) throws -> T { + try begin(on: connection, session: session, reason: reason) + defer { end(on: connection) } + return try statement() + } + + static func begin(on connection: duckdb_connection, session: PluginSessionTransactionState, reason: Reason) throws { guard session == .idle else { throw reason == .safeMode ? Refusal.safeModeTransactionOpen : Refusal.transactionOpen } if let failure = send("BEGIN TRANSACTION READ ONLY", on: connection) { throw Refusal.beginFailed(failure) } - // Fails without harm when the statement itself ended the transaction. - defer { _ = send("ROLLBACK", on: connection) } - return try statement() + } + + // Fails without harm when the statement itself ended the transaction. + static func end(on connection: duckdb_connection) { + _ = send("ROLLBACK", on: connection) } private static func send(_ sql: String, on connection: duckdb_connection) -> String? { diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBResultReader.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBResultReader.swift index fa1e894823..2f4dfa7cd5 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBResultReader.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBResultReader.swift @@ -3,7 +3,7 @@ import Foundation // DuckDB spells a value as text only through a query. A streaming result keeps its own connection busy until it ends // (DUCKDB_ERROR_RESOURCE_IN_USE), so a second connection renders each fetched chunk through a table function. -final class DuckDBResultReader: @unchecked Sendable { +nonisolated final class DuckDBResultReader: @unchecked Sendable { private let name = "_tablepro_result_" + UUID().uuidString.replacingOccurrences(of: "-", with: "") private let connection: duckdb_connection private let connectionID: idx_t diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBStorageCompatibility.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBStorageCompatibility.swift index 6de1594948..e83260cee2 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBStorageCompatibility.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBStorageCompatibility.swift @@ -7,7 +7,7 @@ import Foundation // DuckDB 2.0 creates files that 1.x cannot open. 1.x's own default keeps every file a connection creates or // attaches, a .duckdb backup included, readable by DuckDB 1.x. An existing file keeps its version either way. -enum DuckDBStorageCompatibility { +nonisolated enum DuckDBStorageCompatibility { static let configurationOption = "storage_compatibility_version" static let version = "v0.10.2" } diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBTransactionProbe.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBTransactionProbe.swift index 40cb33ab24..ee19a0e6b3 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBTransactionProbe.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBTransactionProbe.swift @@ -24,7 +24,7 @@ import TableProPluginKit /// non-DuckDB transaction` and **took the transaction with it**, so the row the user had inserted /// was gone after their own `COMMIT` reported success. `duckdb_databases()` is safe in the same /// place, measured: it answered `sqlite`, and the transaction went on to commit both rows. -enum DuckDBTransactionProbe { +nonisolated enum DuckDBTransactionProbe { /// One answer read back from the connection. enum Reading: Equatable { case value(String) diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBTrustBundleFile.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBTrustBundleFile.swift index bd06cfd51b..75485d0e27 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBTrustBundleFile.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBTrustBundleFile.swift @@ -13,7 +13,7 @@ import TableProDuckDBCore /// its HTTP client setting changes, which the editor can do, and then reads the file again. It goes in the /// temporary directory because it holds certificates only, never a key: a copy a crash leaves behind /// exposes nothing, and the system clears it. -final class DuckDBTrustBundleFile: @unchecked Sendable { +nonisolated final class DuckDBTrustBundleFile: @unchecked Sendable { private let lock = NSLock() private var url: URL? diff --git a/apple/Plugins/DuckDBDriverPlugin/DuckDBTypeRendering.swift b/apple/Plugins/DuckDBDriverPlugin/DuckDBTypeRendering.swift index 637a290293..966c417c3e 100644 --- a/apple/Plugins/DuckDBDriverPlugin/DuckDBTypeRendering.swift +++ b/apple/Plugins/DuckDBDriverPlugin/DuckDBTypeRendering.swift @@ -6,7 +6,7 @@ import Foundation import TableProSQLQuoting -enum DuckDBLogicalType: String, CaseIterable, Sendable { +nonisolated enum DuckDBLogicalType: String, CaseIterable, Sendable { case boolean = "BOOLEAN" case tinyint = "TINYINT" case smallint = "SMALLINT" @@ -47,7 +47,7 @@ enum DuckDBLogicalType: String, CaseIterable, Sendable { var displayName: String { rawValue } } -extension DuckDBLogicalType { +nonisolated extension DuckDBLogicalType { static let typesTheValueAPICannotRender: Set = [ .timestampSeconds, .timestampMilliseconds, @@ -87,7 +87,7 @@ extension DuckDBLogicalType { } } -enum DuckDBProjectedQuery { +nonisolated enum DuckDBProjectedQuery { static func sourceAlias(at index: Int) -> String { "c\(index + 1)" } diff --git a/apple/TableProMobile/TableProMobile/Drivers/DuckDBBackedDriver.swift b/apple/TableProMobile/TableProMobile/Drivers/DuckDBBackedDriver.swift new file mode 100644 index 0000000000..9fa9519058 --- /dev/null +++ b/apple/TableProMobile/TableProMobile/Drivers/DuckDBBackedDriver.swift @@ -0,0 +1,260 @@ +import Foundation +import TableProDatabase +import TableProModels +import TableProPluginKit +import TableProQuery + +// The Mac's DuckDB plugin driver over a file this app holds access to: one in its own container, one the user picked +// (security-scoped) or an in-memory database. A transfer reads on a connection of its own to the session's database, +// since DuckDB opens a file once per process. The plugin writes no rows of its own, so edits take SQLBuilder's SQL. +nonisolated final class DuckDBBackedDriver: PluginBackedDriver, DedicatedTransferConnection, @unchecked Sendable { + private let duck: DuckDBPluginDriver + // Nil for a transfer connection, which lives and ends inside its session's database. + private let source: LocalDatabaseFileSource? + private let openMode: LocalDatabaseOpenMode + private let fileAccess = LocalDatabaseFileAccess() + + convenience init(source: LocalDatabaseFileSource, openMode: LocalDatabaseOpenMode = .existingOnly) { + self.init( + duck: DuckDBPluginDriver(config: DuckDBBackedDriver.config(opening: source)), source: source, openMode: openMode + ) + } + + private init(duck: DuckDBPluginDriver, source: LocalDatabaseFileSource?, openMode: LocalDatabaseOpenMode) { + self.duck = duck + self.source = source + self.openMode = openMode + super.init( + plugin: duck, + dialedHosts: [], + readsOnly: { !SQLWriteClassifier.isWriteQuery($0, databaseType: .duckdb) }, + cancelsRunningRequest: { try? duck.cancelQuery() } + ) + } + + // Only the file the app resolved: a connection from the Mac can carry a Mac path, Remote mode, attached databases + // or an idle release, none of which this app opens. + private static func config(opening source: LocalDatabaseFileSource) -> DriverConnectionConfig { + let path: String + switch source { + case .inMemory: path = LocalDatabaseLocation.inMemoryPath + case .file(let url), .securityScoped(let url): path = url.path + } + return DriverConnectionConfig( + host: "", + port: 0, + username: "", + password: "", + database: path, + additionalFields: ["duckdbMode": "local", "duckdbFilePath": path] + ) + } + + // The session holds the file; a transfer connection and an in-memory database hold none of their own. + override var holdsSuspensionBlockingResource: Bool { + guard let source else { return false } + return source != .inMemory + } + + override func connect() async throws { + guard let source else { return } + _ = try fileAccess.begin(source, openMode: openMode) + do { + try await super.connect() + } catch { + await duck.close() + fileAccess.end() + throw error + } + } + + // Access to a picked file ends only once DuckDB has closed it. + override func disconnect() async throws { + await duck.close() + fileAccess.end() + } + + // A transfer connection runs only its own transfer, so its Stop interrupts whatever it is reading. + override func cancelCurrentQuery() async throws { + guard source == nil else { return } + try duck.cancelQuery() + } + + // A read takes each batch as the plugin hands it out and cuts each value while it is decoded: long text is copied + // only up to its preview and a BLOB only counted, so no value is held whole that the grid shows cut. + override func stream( + query: String, + options: StreamOptions, + bindsToSession: Bool + ) -> AsyncThrowingStream { + guard !SQLWriteClassifier.isWriteQuery(query, databaseType: .duckdb) else { + return super.stream(query: query, options: options, bindsToSession: bindsToSession) + } + let duck = duck + let context = statementContext(query) + let read = Self.gridReader(options: options) + return AsyncThrowingStream { continuation in + let task = Task { + do { + try await self.exclusively { + var rows = PluginRowEmitter(options: options) + batches: for try await element in duck.pulledValues(query: query, context: context, reading: read) { + switch element { + case .header(let header): + rows.begin(columns: header.columns, typeNames: header.columnTypeNames, into: continuation) + case .rows(let batch): + for row in batch { + let cells = Self.cells(of: row, rows: rows) + guard rows.emit(cells: cells, locator: nil, into: continuation) else { break batches } + } + } + } + await duck.endPulledRows() + } + continuation.finish() + } catch { + // A Stop interrupts the query, so its error is the Stop itself. + if error is CancellationError || Task.isCancelled { + continuation.yield(.truncated(reason: .cancelled)) + continuation.finish() + } else { + continuation.finish(throwing: error) + } + } + } + continuation.onTermination = { _ in task.cancel() } + } + } + + // A key column stays whole, since a long value is read back by it. Without a key a long value the budget admits + // stays whole too, as `Cell.from(text:options:ref:)` keeps it. + static func gridReader(options: StreamOptions) -> DuckDBValueReader { + let keys = Set(options.lazyContext?.primaryKeyColumns ?? []) + let limit = options.textTruncationBytes + let budget = options.lazyContext == nil ? options.textBudget : nil + return { column, value in + switch value { + case .null: + return .null + case .spelled(let text): + return .text(text) + case .bytes(let bytes): + return .bytes(count: bytes.count) + case .text(let utf8): + guard utf8.count > limit, !keys.contains(column) else { return .text(String(decoding: utf8, as: UTF8.self)) } + if let budget, budget.admit(utf8.count) { return .admitted(String(decoding: utf8, as: UTF8.self)) } + return .cut(prefix: preview(of: utf8, maxBytes: limit), totalBytes: utf8.count) + } + } + } + + // Decodes a little past the limit, at a scalar boundary, so the last Character the preview keeps is whole. + static func preview(of utf8: UnsafeRawBufferPointer, maxBytes: Int) -> String { + var end = min(utf8.count, maxBytes + 64) + while end > 0, end < utf8.count, utf8[end] & 0xC0 == 0x80 { + end -= 1 + } + return Cell.preview(of: String(decoding: UnsafeRawBufferPointer(rebasing: utf8[.. [Cell] { + let keyText: (Int) -> String? = { index in + guard index < row.count, case .text(let value) = row[index] else { return nil } + return value + } + return row.enumerated().map { index, value -> Cell in + let ref = rows.ref(column: rows.column(at: index), keyText: keyText, locator: nil) + switch value { + case .null: + return .null + case .text(let text): + return Cell.from(text: text, options: rows.options, ref: ref) + case .admitted(let text): + return .text(text) + case .cut(let prefix, let totalBytes): + return .truncatedText(prefix: prefix, totalBytes: totalBytes, ref: ref) + case .bytes(let count): + return .binary(byteCount: count, ref: ref) + } + } + } + + // A session export reads on a connection of its own, a batch per pull: one that streamed on the session would hold + // the executor the session's next statement waits on, and a grid statement would end its result. + override func exportRows(query: String, readOnly: Bool) -> AsyncThrowingStream { + guard source != nil else { return super.exportRows(query: query, readOnly: readOnly) } + var context = statementContext(query) + context.readOnly = true + context.enforcesReadOnly = readOnly + let pull = DuckDBOwnedTransferRead(duck: duck, query: query, context: context) + return AsyncThrowingStream(unfolding: { try await pull.next() }) + } + + func openTransferDriver() async throws -> any DatabaseDriver { + guard source != nil else { return self } + return DuckDBBackedDriver(duck: try await duck.openTransferDriver(), source: nil, openMode: .existingOnly) + } +} + +// A DuckDB value as the grid reads it. +nonisolated enum DuckDBGridValue: Sendable, Equatable { + case null + case text(String) + // Long text the text budget took whole. + case admitted(String) + case cut(prefix: String, totalBytes: Int) + case bytes(count: Int) +} + +// The pull side of a session export: a transfer connection opened on the first pull and closed at the read's end, or +// by the stream's release. +nonisolated private final class DuckDBOwnedTransferRead: @unchecked Sendable { + private let duck: DuckDBPluginDriver + private let query: String + private let context: PluginStatementContext + private let lock = NSLock() + private var transfer: DuckDBPluginDriver? + private var rows: AsyncThrowingStream.AsyncIterator? + + init(duck: DuckDBPluginDriver, query: String, context: PluginStatementContext) { + self.duck = duck + self.query = query + self.context = context + } + + deinit { + guard let transfer = lock.withLock({ self.transfer }) else { return } + Task { await transfer.close() } + } + + func next() async throws -> PluginStreamElement? { + do { + var iterator = try await openedRows() + let element = try await iterator.next() + lock.withLock { rows = iterator } + if element == nil { await end() } + return element + } catch { + await end() + throw error + } + } + + private func openedRows() async throws -> AsyncThrowingStream.AsyncIterator { + if let rows = lock.withLock({ self.rows }) { return rows } + let opened = try await duck.openTransferDriver() + lock.withLock { transfer = opened } + return opened.pulledRows(query: query, context: context).makeAsyncIterator() + } + + private func end() async { + let ending = lock.withLock { () -> DuckDBPluginDriver? in + defer { + transfer = nil + rows = nil + } + return transfer + } + await ending?.close() + } +} diff --git a/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver+Decode.swift b/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver+Decode.swift deleted file mode 100644 index 0cd74fc0b7..0000000000 --- a/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver+Decode.swift +++ /dev/null @@ -1,239 +0,0 @@ -import CDuckDB -import Foundation -import TableProModels - -extension DuckDBActor { - // A streamed BLOB is its bytes, as on every other engine. `decodeCell` keeps the base64 text `execute` returns. - static func streamedCell( - vector: duckdb_vector, - row: idx_t, - column: DuckDBStreamColumn, - options: StreamOptions, - ref: CellRef? - ) -> Cell { - guard !column.castToText, column.type == DUCKDB_TYPE_BLOB else { - return decodeCell(vector: vector, row: row, column: column, options: options, ref: ref) - } - if let validity = duckdb_vector_get_validity(vector), !duckdb_validity_row_is_valid(validity, row) { - return .null - } - guard let data = duckdb_vector_get_data(vector) else { return .null } - let value = data.assumingMemoryBound(to: duckdb_string_t.self)[Int(row)] - return .binary(byteCount: Int(duckdb_string_t_length(value)), ref: ref) - } - - static func decodeCell( - vector: duckdb_vector, - row: idx_t, - column: DuckDBStreamColumn, - options: StreamOptions, - ref: CellRef? = nil - ) -> Cell { - if let validity = duckdb_vector_get_validity(vector), !duckdb_validity_row_is_valid(validity, row) { - return .null - } - guard let data = duckdb_vector_get_data(vector) else { return .null } - - if column.castToText { - return decodeVarchar(data, row: row, options: options, ref: ref) - } - - switch column.type { - case DUCKDB_TYPE_VARCHAR: - return decodeVarchar(data, row: row, options: options, ref: ref) - case DUCKDB_TYPE_BLOB: - return decodeBlob(data, row: row) - case DUCKDB_TYPE_BOOLEAN: - return .text(data.load(fromByteOffset: Int(row) * MemoryLayout.stride, as: Bool.self) ? "true" : "false") - case DUCKDB_TYPE_TINYINT: - return .text(String(element(data, row, Int8.self))) - case DUCKDB_TYPE_SMALLINT: - return .text(String(element(data, row, Int16.self))) - case DUCKDB_TYPE_INTEGER: - return .text(String(element(data, row, Int32.self))) - case DUCKDB_TYPE_BIGINT: - return .text(String(element(data, row, Int64.self))) - case DUCKDB_TYPE_UTINYINT: - return .text(String(element(data, row, UInt8.self))) - case DUCKDB_TYPE_USMALLINT: - return .text(String(element(data, row, UInt16.self))) - case DUCKDB_TYPE_UINTEGER: - return .text(String(element(data, row, UInt32.self))) - case DUCKDB_TYPE_UBIGINT: - return .text(String(element(data, row, UInt64.self))) - case DUCKDB_TYPE_FLOAT: - return .text(String(element(data, row, Float.self))) - case DUCKDB_TYPE_DOUBLE: - return .text(String(element(data, row, Double.self))) - case DUCKDB_TYPE_HUGEINT: - let value = element(data, row, duckdb_hugeint.self) - return .text(HugeIntFormatter.format(upper: value.upper, lower: value.lower)) - case DUCKDB_TYPE_UHUGEINT: - let value = element(data, row, duckdb_uhugeint.self) - return .text(HugeIntFormatter.formatUnsigned(upper: value.upper, lower: value.lower)) - case DUCKDB_TYPE_UUID: - let value = element(data, row, duckdb_hugeint.self) - return .text(formatUUID(value)) - case DUCKDB_TYPE_DATE: - let value = element(data, row, duckdb_date.self) - return .text(formatDate(duckdb_from_date(value))) - case DUCKDB_TYPE_TIME: - let value = element(data, row, duckdb_time.self) - return .text(formatTime(duckdb_from_time(value))) - case DUCKDB_TYPE_TIMESTAMP, DUCKDB_TYPE_TIMESTAMP_S, DUCKDB_TYPE_TIMESTAMP_MS, DUCKDB_TYPE_TIMESTAMP_NS: - return .text(formatTimestamp(normalizedTimestamp(data, row: row, type: column.type))) - default: - return decodeVarchar(data, row: row, options: options, ref: ref) - } - } - - private static func element(_ data: UnsafeMutableRawPointer, _ row: idx_t, _ type: T.Type) -> T { - data.load(fromByteOffset: Int(row) * MemoryLayout.stride, as: T.self) - } - - private static func decodeVarchar( - _ data: UnsafeMutableRawPointer, - row: idx_t, - options: StreamOptions, - ref: CellRef? - ) -> Cell { - let strings = data.assumingMemoryBound(to: duckdb_string_t.self) - var value = strings[Int(row)] - let length = Int(duckdb_string_t_length(value)) - guard length > 0, let pointer = duckdb_string_t_data(&value) else { return .text("") } - let text = String(bytes: UnsafeRawBufferPointer(start: pointer, count: length), encoding: .utf8) ?? "" - return Cell.from(text: text, options: options, ref: ref) - } - - private static func decodeBlob(_ data: UnsafeMutableRawPointer, row: idx_t) -> Cell { - let strings = data.assumingMemoryBound(to: duckdb_string_t.self) - var value = strings[Int(row)] - let length = Int(duckdb_string_t_length(value)) - guard length > 0, let pointer = duckdb_string_t_data(&value) else { return .text("") } - let bytes = UnsafeRawBufferPointer(start: pointer, count: length) - return .text(Data(bytes).base64EncodedString()) - } - - private static func normalizedTimestamp(_ data: UnsafeMutableRawPointer, row: idx_t, type: duckdb_type) -> duckdb_timestamp { - let raw = element(data, row, duckdb_timestamp.self).micros - switch type { - case DUCKDB_TYPE_TIMESTAMP_S: - return duckdb_timestamp(micros: raw * 1_000_000) - case DUCKDB_TYPE_TIMESTAMP_MS: - return duckdb_timestamp(micros: raw * 1_000) - case DUCKDB_TYPE_TIMESTAMP_NS: - return duckdb_timestamp(micros: raw / 1_000) - default: - return duckdb_timestamp(micros: raw) - } - } - - // MARK: - Formatting (matches duckdb_value_varchar output) - - static func formatTimestamp(_ ts: duckdb_timestamp) -> String { - let parts = duckdb_from_timestamp(ts) - let date = parts.date - let time = parts.time - let micros = time.micros % 1_000_000 - let year = formatYearISO(date.year) - if micros == 0 { - return String(format: "\(year)-%02d-%02d %02d:%02d:%02d", date.month, date.day, time.hour, time.min, time.sec) - } - return String(format: "\(year)-%02d-%02d %02d:%02d:%02d.%06d", date.month, date.day, time.hour, time.min, time.sec, micros) - } - - static func formatDate(_ date: duckdb_date_struct) -> String { - String(format: "\(formatYearISO(date.year))-%02d-%02d", date.month, date.day) - } - - static func formatTime(_ time: duckdb_time_struct) -> String { - let micros = time.micros % 1_000_000 - if micros == 0 { - return String(format: "%02d:%02d:%02d", time.hour, time.min, time.sec) - } - return String(format: "%02d:%02d:%02d.%06d", time.hour, time.min, time.sec, micros) - } - - static func formatYearISO(_ year: Int32) -> String { - year < 0 ? String(format: "-%04d", -Int(year)) : String(format: "%04d", year) - } - - static func formatUUID(_ value: duckdb_hugeint) -> String { - let high = UInt64(bitPattern: value.upper) ^ 0x8000_0000_0000_0000 - let low = value.lower - let hex = String(format: "%016llx%016llx", high, low) - let s = Array(hex) - return "\(String(s[0..<8]))-\(String(s[8..<12]))-\(String(s[12..<16]))-\(String(s[16..<20]))-\(String(s[20..<32]))" - } - - // Single source of truth for which types decodeCell handles directly from - // vector data. Anything not in this allowlist is cast to VARCHAR in the - // query (requiresTextCast), so an unhandled or future type can never reach - // the native decode path and reinterpret non-string bytes as a string. - static func isNativelyDecodable(_ type: duckdb_type) -> Bool { - switch type { - case DUCKDB_TYPE_VARCHAR, DUCKDB_TYPE_BLOB, DUCKDB_TYPE_BOOLEAN, - DUCKDB_TYPE_TINYINT, DUCKDB_TYPE_SMALLINT, DUCKDB_TYPE_INTEGER, DUCKDB_TYPE_BIGINT, - DUCKDB_TYPE_UTINYINT, DUCKDB_TYPE_USMALLINT, DUCKDB_TYPE_UINTEGER, DUCKDB_TYPE_UBIGINT, - DUCKDB_TYPE_FLOAT, DUCKDB_TYPE_DOUBLE, DUCKDB_TYPE_HUGEINT, DUCKDB_TYPE_UHUGEINT, - DUCKDB_TYPE_UUID, DUCKDB_TYPE_DATE, DUCKDB_TYPE_TIME, - DUCKDB_TYPE_TIMESTAMP, DUCKDB_TYPE_TIMESTAMP_S, DUCKDB_TYPE_TIMESTAMP_MS, DUCKDB_TYPE_TIMESTAMP_NS: - return true - default: - return false - } - } - - static func requiresTextCast(_ type: duckdb_type) -> Bool { - !isNativelyDecodable(type) - } -} - -nonisolated enum HugeIntFormatter { - static func format(upper: Int64, lower: UInt64) -> String { - if upper == 0 { - return String(lower) - } - let negative = upper < 0 - var magHigh: UInt64 - var magLow: UInt64 - if negative { - let low = ~lower &+ 1 - let carry: UInt64 = low == 0 ? 1 : 0 - magHigh = ~UInt64(bitPattern: upper) &+ carry - magLow = low - } else { - magHigh = UInt64(bitPattern: upper) - magLow = lower - } - let digits = decimalString(high: magHigh, low: magLow) - return negative ? "-\(digits)" : digits - } - - static func formatUnsigned(upper: UInt64, lower: UInt64) -> String { - if upper == 0 { - return String(lower) - } - return decimalString(high: upper, low: lower) - } - - private static func decimalString(high: UInt64, low: UInt64) -> String { - var parts: [UInt32] = [ - UInt32(low & 0xFFFF_FFFF), - UInt32((low >> 32) & 0xFFFF_FFFF), - UInt32(high & 0xFFFF_FFFF), - UInt32((high >> 32) & 0xFFFF_FFFF), - ] - var digits = "" - repeat { - var remainder: UInt64 = 0 - for index in stride(from: parts.count - 1, through: 0, by: -1) { - let acc = (remainder << 32) | UInt64(parts[index]) - parts[index] = UInt32(acc / 10) - remainder = acc % 10 - } - digits = "\(remainder)\(digits)" - } while parts.contains(where: { $0 != 0 }) - return digits.isEmpty ? "0" : digits - } -} diff --git a/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver+Schema.swift b/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver+Schema.swift deleted file mode 100644 index dc62281163..0000000000 --- a/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver+Schema.swift +++ /dev/null @@ -1,173 +0,0 @@ -import Foundation -import TableProDatabase -import TableProModels -import TableProPluginKit -import TableProSQLQuoting - -nonisolated extension DuckDBDriver { - func fetchTables(schema: String?) async throws -> [TableInfo] { - let schemaName = resolveSchema(schema) - let query = """ - SELECT table_name, table_type - FROM information_schema.tables - WHERE table_schema = '\(escapeLiteral(schemaName))' - ORDER BY table_name - """ - let result = try await actor.query(query, lane: transferLane) - return result.rows.compactMap { row in - guard row.count > 0, let name = row[0] else { return nil } - let typeString = (row.count > 1 ? row[1] : nil) ?? "BASE TABLE" - let kind: TableInfo.TableKind = typeString.uppercased().contains("VIEW") ? .view : .table - return TableInfo(name: name, type: kind) - } - } - - func fetchColumns(table: String, schema: String?) async throws -> [ColumnInfo] { - let schemaName = resolveSchema(schema) - let query = """ - SELECT column_name, data_type, is_nullable, column_default, ordinal_position - FROM information_schema.columns - WHERE table_schema = '\(escapeLiteral(schemaName))' - AND table_name = '\(escapeLiteral(table))' - ORDER BY ordinal_position - """ - let result = try await actor.query(query, lane: transferLane) - let primaryKeys = try await fetchPrimaryKeyColumns(table: table, schema: schemaName) - - return result.rows.enumerated().compactMap { index, row in - guard row.count >= 2, let name = row[0], let dataType = row[1] else { return nil } - return ColumnInfo( - name: name, - typeName: dataType, - isPrimaryKey: primaryKeys.contains(name), - isNullable: (row.count > 2 ? row[2] : nil) == "YES", - defaultValue: row.count > 3 ? row[3] : nil, - ordinalPosition: index - ) - } - } - - func fetchIndexes(table: String, schema: String?) async throws -> [IndexInfo] { - let schemaName = resolveSchema(schema) - let query = """ - SELECT index_name, is_unique, sql - FROM duckdb_indexes() - WHERE schema_name = '\(escapeLiteral(schemaName))' - AND table_name = '\(escapeLiteral(table))' - """ - let result = try await actor.query(query, lane: transferLane) - return result.rows.compactMap { row in - guard row.count > 0, let name = row[0] else { return nil } - let sql = row.count > 2 ? row[2] : nil - let isUnique = (row.count > 1 ? row[1] : nil) == "true" - let isPrimary = name.lowercased().contains("primary") - || (sql?.uppercased().contains("PRIMARY KEY") ?? false) - return IndexInfo( - name: name, - columns: Self.extractIndexColumns(from: sql), - isUnique: isUnique || isPrimary, - isPrimary: isPrimary, - type: "ART" - ) - } - } - - func fetchForeignKeys(table: String, schema: String?) async throws -> [ForeignKeyInfo] { - let schemaName = resolveSchema(schema) - let query = """ - SELECT - rc.constraint_name, - kcu.column_name, - kcu2.table_name AS referenced_table, - kcu2.column_name AS referenced_column, - rc.delete_rule, - rc.update_rule - FROM information_schema.referential_constraints rc - JOIN information_schema.key_column_usage kcu - ON rc.constraint_name = kcu.constraint_name - AND rc.constraint_schema = kcu.constraint_schema - JOIN information_schema.key_column_usage kcu2 - ON rc.unique_constraint_name = kcu2.constraint_name - AND rc.unique_constraint_schema = kcu2.constraint_schema - AND kcu.ordinal_position = kcu2.ordinal_position - WHERE kcu.table_schema = '\(escapeLiteral(schemaName))' - AND kcu.table_name = '\(escapeLiteral(table))' - """ - do { - let result = try await actor.query(query, lane: transferLane) - return result.rows.compactMap { row in - guard row.count >= 4, - let name = row[0], - let column = row[1], - let referencedTable = row[2], - let referencedColumn = row[3] else { - return nil - } - return ForeignKeyInfo( - name: name, - column: column, - referencedTable: referencedTable, - referencedColumn: referencedColumn, - onDelete: (row.count > 4 ? row[4] : nil) ?? "NO ACTION", - onUpdate: (row.count > 5 ? row[5] : nil) ?? "NO ACTION" - ) - } - } catch { - return [] - } - } - - func fetchDatabases() async throws -> [String] { [] } - - func fetchSchemas() async throws -> [String] { - let query = "SELECT schema_name FROM information_schema.schemata ORDER BY schema_name" - let result = try await actor.query(query, lane: transferLane) - return result.rows.compactMap { $0.first ?? nil } - } - - func switchDatabase(to name: String) async throws { - throw DuckDBDriverError.unsupported("DuckDB does not support switching databases on this platform") - } - - func switchSchema(to name: String) async throws { - _ = try await actor.query("SET schema = \(SQLQuoting.identifier(name))", lane: transferLane) - setCurrentSchema(name) - } - - // MARK: - Helpers - - private func fetchPrimaryKeyColumns(table: String, schema: String) async throws -> Set { - let query = """ - SELECT kcu.column_name - FROM information_schema.table_constraints tc - JOIN information_schema.key_column_usage kcu - ON tc.constraint_name = kcu.constraint_name - AND tc.table_schema = kcu.table_schema - WHERE tc.constraint_type = 'PRIMARY KEY' - AND tc.table_schema = '\(escapeLiteral(schema))' - AND tc.table_name = '\(escapeLiteral(table))' - """ - let result = try await actor.query(query, lane: transferLane) - return Set(result.rows.compactMap { $0.first ?? nil }) - } - - private func escapeLiteral(_ value: String) -> String { - SQLQuoting.stringLiteralBody(value) - } - - // DuckDBLexicalFeatures in the DuckDB plugin, which this app does not compile. - private static let lexicalFeatures: SQLLexicalFeatures = [ - .taggedDollarQuotes, .nestedBlockComments, .escapeStringPrefix, .backtickQuotes, - .carriageReturnEndsLineComments, - ] - - // The key list as the plugin reads it: a quoted name unquoted, an expression as written. - static func extractIndexColumns(from sql: String?) -> [String] { - guard let sql, let statement = SQLIndexKeyList.statement(sql, lexicalFeatures: lexicalFeatures) else { return [] } - return statement.keyParts.map { part in - SQLIndexKeyList.unwrapped(part, lexicalFeatures: lexicalFeatures) - ?? SQLIndexKeyList.quotedIdentifier(part, lexicalFeatures: lexicalFeatures) - ?? part - } - } -} diff --git a/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver+Streaming.swift b/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver+Streaming.swift deleted file mode 100644 index cb248caf3b..0000000000 --- a/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver+Streaming.swift +++ /dev/null @@ -1,345 +0,0 @@ -import CDuckDB -import Foundation -import os -import TableProDatabase -import TableProModels - -nonisolated struct DuckDBStreamColumn: Sendable { - let name: String - let typeName: String - let type: duckdb_type - let castToText: Bool -} - -nonisolated enum DuckDBBeginStreamResult: Sendable { - case rowSet([DuckDBStreamColumn], stream: UInt64) - /// The statement cannot be read as a subquery (DDL, DML, PRAGMA), so it has no columns to plan and runs whole. - case materialize -} - -/// Carries a stream's generation from its producer, which learns it on the actor, to its consumer's termination -/// handler, which runs on whatever thread cancels the stream. -nonisolated struct DuckDBStreamToken: Sendable { - private let generation = OSAllocatedUnfairLock(initialState: nil) - - var stream: UInt64? { - generation.withLock { $0 } - } - - func assign(_ stream: UInt64) { - generation.withLock { $0 = stream } - } -} - -nonisolated extension DuckDBDriver { - private static func yieldMaterialized( - query: String, - options: StreamOptions, - actor: DuckDBActor, - continuation: AsyncThrowingStream.Continuation - ) async throws { - let raw = try await actor.query(query) - let columns = raw.columnNames.enumerated().map { index, name in - ColumnInfo(name: name, typeName: index < raw.columnTypeNames.count ? raw.columnTypeNames[index] : "", ordinalPosition: index) - } - continuation.yield(.columns(columns)) - var emitted = 0 - for legacyRow in raw.rows { - if emitted >= options.maxRows { - continuation.yield(.truncated(reason: .rowCap(options.maxRows))) - break - } - let cells = legacyRow.enumerated().map { index, value -> Cell in - let typeName = index < columns.count ? columns[index].typeName : nil - // `execute` carries a BLOB as base64, so the cell counts the bytes it decodes to. - if let value, typeName == DuckDBActor.typeName(for: DUCKDB_TYPE_BLOB) { - return .binary(byteCount: Self.base64ByteCount(value), ref: nil) - } - return Cell.from(legacyValue: value, columnTypeName: typeName, options: options) - } - continuation.yield(.row(Row(cells: cells))) - emitted += 1 - } - if raw.rowsAffected != 0 { - continuation.yield(.rowsAffected(raw.rowsAffected)) - } - } - - private static func base64ByteCount(_ text: String) -> Int { - let utf8 = text.utf8 - let padding = utf8.reversed().prefix(2).prefix { $0 == UInt8(ascii: "=") }.count - return utf8.count / 4 * 3 - padding - } - - func executeStreaming(query: String, options: StreamOptions) -> AsyncThrowingStream { - // A transfer connection reads with `exportRows`; anything else it runs is read whole. - guard transferLane == nil else { - return QueryResultStreaming.stream(options: options) { try await self.execute(query: query) } - } - let actor = self.actor - let interruptHandle = actor.interruptHandle - let token = DuckDBStreamToken() - return AsyncThrowingStream(bufferingPolicy: .unbounded) { continuation in - let task = Task { - var stream: UInt64? - do { - switch try await actor.beginStream(query: query, token: token) { - case .materialize: - try Task.checkCancellation() - try await Self.yieldMaterialized(query: query, options: options, actor: actor, continuation: continuation) - case .rowSet(let columns, let id): - stream = id - continuation.yield(.columns(columns.map { - ColumnInfo(name: $0.name, typeName: $0.typeName, ordinalPosition: 0) - })) - try await Self.yieldRows(stream: id, options: options, actor: actor, continuation: continuation) - try await actor.endStream(id) - } - continuation.finish() - } catch { - if let stream { - await actor.abandonStream(stream) - } - // A cancelled consumer interrupts the query, so the interrupt error is the cancel itself. - if error is CancellationError || Task.isCancelled { - continuation.yield(.truncated(reason: .cancelled)) - continuation.finish() - } else { - continuation.finish(throwing: error) - } - } - } - continuation.onTermination = { reason in - task.cancel() - if case .cancelled = reason, let stream = token.stream { - interruptHandle.interrupt(stream: stream) - } - } - } - } - - private static func yieldRows( - stream: UInt64, - options: StreamOptions, - actor: DuckDBActor, - continuation: AsyncThrowingStream.Continuation - ) async throws { - var emitted = 0 - // The cap is checked against the next row rather than the count, so a result that fills the cap at a chunk - // boundary still reads one more chunk to learn whether rows were left out. - rows: while !Task.isCancelled { - guard let chunk = try await actor.fetchStreamChunk(stream: stream, options: options) else { break } - for cells in chunk { - if emitted >= options.maxRows { - continuation.yield(.truncated(reason: .rowCap(options.maxRows))) - break rows - } - continuation.yield(.row(Row(cells: cells))) - emitted += 1 - } - } - if Task.isCancelled { - continuation.yield(.truncated(reason: .cancelled)) - } - } -} - -extension DuckDBActor { - /// A failure before the query runs falls back to the materialized path, which reports the statement's own error. - /// A failure while it runs is thrown: running it again materialized would repeat the work, an interrupted query - /// included. - func beginStream(query: String, token: DuckDBStreamToken) throws -> DuckDBBeginStreamResult { - guard let connection else { throw DuckDBDriverError.notConnected } - // Stop can land while the stream waits for the actor, and an interrupt then reaches nothing. - try Task.checkCancellation() - closeStreamResult() - - guard let plan = try? planColumns(connection: connection, query: query) else { return .materialize } - let streamQuery = plan.contains(where: { $0.castToText }) - ? Self.castedQuery(originalQuery: query, columns: plan) - : query - - // A prepare commits nothing on its own (DuckDBPreparedRun), so it runs only inside a transaction it then runs in. - guard let ownsTransaction = Self.prepareTransaction(on: connection, session: transactionState()) else { - return .materialize - } - var streaming = false - defer { - if ownsTransaction, !streaming { DuckDBPreparedRun.rollback(on: connection) } - } - - var stmt: duckdb_prepared_statement? - guard duckdb_prepare(connection, streamQuery, &stmt) != DuckDBError, let preparedStmt = stmt else { - duckdb_destroy_prepare(&stmt) - return .materialize - } - defer { duckdb_destroy_prepare(&stmt) } - - var pending: duckdb_pending_result? - guard duckdb_pending_prepared_streaming(preparedStmt, &pending) != DuckDBError, pending != nil else { - duckdb_destroy_pending(&pending) - return .materialize - } - defer { duckdb_destroy_pending(&pending) } - - streamGeneration &+= 1 - let stream = streamGeneration - token.assign(stream) - - var result = duckdb_result() - let state = try running(stream) { duckdb_execute_pending(pending, &result) } - guard state != DuckDBError else { - let message = duckdb_result_error(&result).map { String(cString: $0) } ?? "Failed to execute query" - duckdb_destroy_result(&result) - throw DuckDBDriverError.queryFailed(message) - } - - streamResult = result - streamColumns = plan - streamOwnsTransaction = ownsTransaction - streaming = true - return .rowSet(plan, stream: stream) - } - - /// A stream whose result is gone, replaced by a later `beginStream`, closed by another statement or destroyed by - /// a close, ends as cancelled rather than reading rows that belong to another statement. - func fetchStreamChunk(stream: UInt64, options: StreamOptions) throws -> [[Cell]]? { - guard stream == streamGeneration, var result = streamResult else { throw CancellationError() } - var chunk = try running(stream) { duckdb_stream_fetch_chunk(result) } - guard chunk != nil else { - // A failed fetch returns no chunk either; only the result's error tells it from the last chunk. - if let message = duckdb_result_error(&result) { - throw DuckDBDriverError.queryFailed(String(cString: message)) - } - return nil - } - defer { duckdb_destroy_data_chunk(&chunk) } - - let rowCount = duckdb_data_chunk_get_size(chunk) - guard rowCount > 0 else { return [] } - - var rows: [[Cell]] = [] - rows.reserveCapacity(Int(rowCount)) - let columns = streamColumns - - var vectors: [duckdb_vector?] = [] - for index in 0.. String? { - guard let vector, column.castToText || column.type != DUCKDB_TYPE_BLOB, - case .text(let value) = decodeCell(vector: vector, row: row, column: column, options: wholeText) - else { return nil } - return value - } - - // True when the prepare runs in a transaction the actor opens for it, false in the session's own, nil when there is - // none it may prepare in: a BEGIN inside a transaction aborts it, so only a session DuckDB says holds none gets one. - static func prepareTransaction(on connection: duckdb_connection, session: DriverTransactionState) -> Bool? { - switch session { - case .idle: - return DuckDBPreparedRun.begin(on: connection) == nil ? true : nil - case .explicitTransaction, .abortedTransaction: - return false - case .implicitTransaction, .unknown: - return nil - } - } - - // A read that ran to its end commits the transaction opened for it, and a failed COMMIT fails the read. - func endStream(_ stream: UInt64) throws { - guard stream == streamGeneration else { return } - let owned = streamOwnsTransaction - streamOwnsTransaction = false - closeStreamResult() - if owned, let connection, let failure = DuckDBPreparedRun.commit(on: connection) { - throw DuckDBDriverError.queryFailed(failure) - } - } - - func abandonStream(_ stream: UInt64) { - guard stream == streamGeneration else { return } - closeStreamResult() - } - - // A read given up, replaced or closed with the session rolls back the transaction opened for it. - func closeStreamResult() { - if var result = streamResult { - duckdb_destroy_result(&result) - streamResult = nil - } - streamColumns = [] - if streamOwnsTransaction, let connection { - streamOwnsTransaction = false - DuckDBPreparedRun.rollback(on: connection) - } - } - - /// Marks `stream` as the running query for the length of `body`, so its consumer's cancel can interrupt it. The - /// cancel check follows the mark, so a cancel either finds the mark or is caught here. - private func running(_ stream: UInt64, _ body: () -> T) throws -> T { - interruptHandle.enter(stream) - defer { interruptHandle.leave(stream) } - try Task.checkCancellation() - return body() - } - - // MARK: - Column Planning - - func planColumns(connection: duckdb_connection, query: String) throws -> [DuckDBStreamColumn] { - var probe = duckdb_result() - guard duckdb_query(connection, Self.zeroRowQuery(for: query), &probe) != DuckDBError else { - let message = duckdb_result_error(&probe).map { String(cString: $0) } ?? "Unknown DuckDB error" - duckdb_destroy_result(&probe) - throw DuckDBDriverError.queryFailed(message) - } - defer { duckdb_destroy_result(&probe) } - - let columnCount = duckdb_column_count(&probe) - var columns: [DuckDBStreamColumn] = [] - for index in 0.. String { - "SELECT * FROM (\(stripTrailingSemicolon(query))) AS _tp_probe LIMIT 0" - } -} diff --git a/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver+Transaction.swift b/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver+Transaction.swift deleted file mode 100644 index 2d2b8dc614..0000000000 --- a/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver+Transaction.swift +++ /dev/null @@ -1,87 +0,0 @@ -import CDuckDB -import Foundation -import TableProDatabase -import TableProModels - -// No C API call answers this. A BEGIN inside a transaction aborts it, and txid_current() on a catalog DuckDB does not -// own destroys it, so the probe reads the catalog type, then txid_current() twice: the ids match only inside a -// transaction. Measured for the Mac driver: Plugins/DuckDBDriverPlugin/DuckDBTransactionProbe.swift. -nonisolated enum DuckDBTransactionProbe { - nonisolated enum Reading: Equatable, Sendable { - case value(String) - // Refused with DUCKDB_ERROR_TRANSACTION, "Current transaction is aborted (please ROLLBACK)". - case abortedTransaction - case unreadable - } - - static let catalogTypeQuery = - "SELECT type::VARCHAR FROM duckdb_databases() WHERE database_name = current_database()" - - static let transactionIdQuery = "SELECT txid_current()::VARCHAR" - - // Nil when the catalog is DuckDB's own and the transaction id has to be asked. - static func state(catalogType: Reading) -> DriverTransactionState? { - switch catalogType { - case .abortedTransaction: - return .abortedTransaction - case .unreadable: - return .unknown - case .value(let type): - // The Mac driver falls back to the statements it saw open a transaction; this one tracks none. - return type.lowercased() == nativeCatalogType ? nil : .unknown - } - } - - static func state(first: Reading, second: Reading) -> DriverTransactionState { - if first == .abortedTransaction || second == .abortedTransaction { return .abortedTransaction } - guard case .value(let firstId) = first, case .value(let secondId) = second else { return .unknown } - return firstId == secondId ? .explicitTransaction : .idle - } - - private static let nativeCatalogType = "duckdb" -} - -nonisolated extension DuckDBDriver { - func sessionTransactionState() async -> DriverTransactionState { - await actor.transactionState(lane: transferLane) - } -} - -extension DuckDBActor { - // One actor turn for every reading, so no other statement lands between the two transaction ids. - func transactionState(lane: UInt64? = nil) -> DriverTransactionState { - guard let connection = connection(for: lane) else { return .unknown } - // A statement would end the open stream inside DuckDB. Its consumer's own work reads the state once it ends. - guard lane == nil ? streamResult == nil : !holdsExportResult(lane: lane) else { return .unknown } - let catalogType = probeReading(DuckDBTransactionProbe.catalogTypeQuery, on: connection) - if let decided = DuckDBTransactionProbe.state(catalogType: catalogType) { - return decided - } - return DuckDBTransactionProbe.state( - first: probeReading(DuckDBTransactionProbe.transactionIdQuery, on: connection), - second: probeReading(DuckDBTransactionProbe.transactionIdQuery, on: connection) - ) - } - - // duckdb_query is the one path that reports the error type; the message text is no contract. - private func probeReading(_ sql: String, on connection: duckdb_connection) -> DuckDBTransactionProbe.Reading { - var result = duckdb_result() - defer { duckdb_destroy_result(&result) } - guard duckdb_query(connection, sql, &result) != DuckDBError else { - return duckdb_result_error_type(&result) == DUCKDB_ERROR_TRANSACTION ? .abortedTransaction : .unreadable - } - guard duckdb_column_count(&result) > 0 else { return .unreadable } - var chunk = duckdb_fetch_chunk(result) - guard chunk != nil else { return .unreadable } - defer { duckdb_destroy_data_chunk(&chunk) } - guard duckdb_data_chunk_get_size(chunk) > 0, let vector = duckdb_data_chunk_get_vector(chunk, 0) else { - return .unreadable - } - let type = duckdb_column_type(&result, 0) - let column = DuckDBStreamColumn(name: "", typeName: Self.typeName(for: type), type: type, castToText: false) - guard case .text(let value) = Self.decodeCell(vector: vector, row: 0, column: column, options: .default) else { - return .unreadable - } - return .value(value) - } -} diff --git a/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver+Transfer.swift b/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver+Transfer.swift deleted file mode 100644 index 2e333e3792..0000000000 --- a/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver+Transfer.swift +++ /dev/null @@ -1,442 +0,0 @@ -import CDuckDB -import Foundation -import os -import TableProDatabase -import TableProModels -import TableProPluginKit -import TableProSQLQuoting - -// One extra `duckdb_connection` on the session's database. DuckDB gives it its own transaction, so an export reads one -// snapshot while the session writes, and the grid's next statement never ends its streamed result. -nonisolated struct DuckDBTransferLane { - let connection: duckdb_connection - let interruptHandle: DuckDBInterruptHandle - var exportResult: duckdb_result? - var exportColumns: [DuckDBStreamColumn] = [] - var exportGeneration: UInt64 = 0 - // The export's prepare ran in a transaction opened for it, which ends with the export. - var exportOwnsTransaction = false -} - -nonisolated extension DuckDBDriver { - func catalogQuery(_ sql: String, parameters: [PluginCellValue]) async throws -> PluginQueryResult { - try await actor.catalogRows(sql, parameters: parameters, lane: transferLane) - } - - // Bound as the Mac plugin binds: text as VARCHAR, bytes as a BLOB. - func executeParameterized(query: String, parameters: [PluginCellValue], typeNames: [String?]?) async throws - -> QueryResult { - let raw = try await actor.executeBound(query, parameters: parameters, lane: transferLane) - return QueryResult( - columns: raw.columnNames.enumerated().map { index, name in - ColumnInfo(name: name, typeName: raw.columnTypeNames[safe: index] ?? "", ordinalPosition: index) - }, - rows: raw.rows, - rowsAffected: raw.rowsAffected, - executionTime: raw.executionTime - ) - } - - // The session reads through a connection of the stream's own, so a grid statement cannot end the read. - func exportRows(query: String, readOnly: Bool) -> AsyncThrowingStream { - let cursor = DuckDBExportCursor( - actor: actor, - query: query, - lane: transferLane.map { ($0, laneInterrupt) }, - schema: transferLane == nil ? currentSchema : nil - ) - return AsyncThrowingStream(unfolding: { try await cursor.next() }) - } - - // Every close path of the session ends this connection before the database (`DuckDBActor.close`). - func openTransferDriver() async throws -> any DatabaseDriver { - guard transferLane == nil else { return self } - let lane = try await actor.openTransferLane(schema: currentSchema) - let driver = DuckDBDriver(transferOn: actor, lane: lane.id, interrupt: lane.interruptHandle, source: .inMemory) - driver.setCurrentSchema(currentSchema ?? "main") - return driver - } -} - -extension DuckDBActor { - private static let wholeText = StreamOptions(textTruncationBytes: .max) - - func connection(for lane: UInt64?) -> duckdb_connection? { - guard let lane else { return connection } - return transferLanes[lane]?.connection - } - - // Opened on the session's schema, so an unqualified name reads the table the session would. - func openTransferLane(schema: String?) throws -> (id: UInt64, interruptHandle: DuckDBInterruptHandle) { - guard let database else { throw DuckDBDriverError.notConnected } - var opened: duckdb_connection? - guard duckdb_connect(database, &opened) != DuckDBError, let opened else { - throw DuckDBDriverError.connectionFailed("Failed to create a DuckDB connection") - } - let handle = DuckDBInterruptHandle() - handle.attach(opened) - lastTransferLane &+= 1 - let id = lastTransferLane - transferLanes[id] = DuckDBTransferLane(connection: opened, interruptHandle: handle) - if let schema, schema != "main" { - do { - _ = try query("SET schema = \(SQLQuoting.identifier(schema))", lane: id) - } catch { - closeTransferLane(id) - throw error - } - } - return (id, handle) - } - - func closeTransferLane(_ id: UInt64) { - guard var lane = transferLanes.removeValue(forKey: id) else { return } - lane.interruptHandle.interrupt() - lane.interruptHandle.detach() - if var result = lane.exportResult { - duckdb_destroy_result(&result) - lane.exportResult = nil - } - var connection: duckdb_connection? = lane.connection - duckdb_disconnect(&connection) - } - - func closeTransferLanes() { - for id in Array(transferLanes.keys) { - closeTransferLane(id) - } - } - - func closeExportResult(lane id: UInt64) { - guard let lane = transferLanes[id], var result = lane.exportResult else { return } - duckdb_destroy_result(&result) - transferLanes[id]?.exportResult = nil - transferLanes[id]?.exportColumns = [] - if lane.exportOwnsTransaction { - transferLanes[id]?.exportOwnsTransaction = false - DuckDBPreparedRun.rollback(on: lane.connection) - } - } - - func holdsExportResult(lane id: UInt64?) -> Bool { - guard let id else { return false } - return transferLanes[id]?.exportResult != nil - } - - // MARK: - Bound statements - - // Every row, bytes kept. A column of a type read only as text is read again cast to VARCHAR, as `query` does. - func catalogRows(_ sql: String, parameters: [PluginCellValue], lane: UInt64?) throws -> PluginQueryResult { - let start = Date() - var result = try run(sql, parameters: parameters, lane: lane) - let plan = Self.plan(of: &result) - if plan.contains(where: { $0.castToText }) { - duckdb_destroy_result(&result) - result = try run(Self.castedQuery(originalQuery: sql, columns: plan), parameters: parameters, lane: lane) - } - defer { duckdb_destroy_result(&result) } - let rowsChanged = Int(duckdb_rows_changed(&result)) - var rows: [[PluginCellValue]] = [] - while true { - var chunk = duckdb_fetch_chunk(result) - guard chunk != nil else { break } - defer { duckdb_destroy_data_chunk(&chunk) } - rows += Self.exportValues(chunk: chunk, plan: plan) - } - return PluginQueryResult( - columns: plan.map(\.name), - columnTypeNames: plan.map(\.typeName), - rows: rows, - rowsAffected: plan.isEmpty ? rowsChanged : 0, - executionTime: Date().timeIntervalSince(start) - ) - } - - // Run once: an import's statement writes, so it is never run again cast. A value of a type read only as text comes - // back nil. - func executeBound(_ sql: String, parameters: [PluginCellValue], lane: UInt64?) throws -> DuckDBRawResult { - let start = Date() - var result = try run(sql, parameters: parameters, lane: lane) - defer { duckdb_destroy_result(&result) } - let plan = Self.plan(of: &result) - var rows: [[String?]] = [] - while true { - var chunk = duckdb_fetch_chunk(result) - guard chunk != nil else { break } - defer { duckdb_destroy_data_chunk(&chunk) } - rows += Self.exportValues(chunk: chunk, plan: plan).map { row in - zip(row, plan).map { value, column in - guard !column.castToText else { return nil } - switch value { - case .null: return nil - case .text(let text): return text - case .bytes(let data): return data.base64EncodedString() - } - } - } - } - return DuckDBRawResult( - columnNames: plan.map(\.name), - columnTypeNames: plan.map(\.typeName), - rows: rows, - rowsAffected: Int(duckdb_rows_changed(&result)), - executionTime: Date().timeIntervalSince(start), - isTruncated: false - ) - } - - // With no values the text runs unprepared, as the Mac plugin's catalog reads do. - private func run(_ sql: String, parameters: [PluginCellValue], lane: UInt64?) throws -> duckdb_result { - guard let connection = connection(for: lane) else { throw DuckDBDriverError.notConnected } - if let lane { - closeExportResult(lane: lane) - } else { - closeStreamResult() - } - var result = duckdb_result() - guard !parameters.isEmpty else { - if let message = run(sql, on: connection, into: &result) { - duckdb_destroy_result(&result) - throw DuckDBDriverError.queryFailed(message) - } - return result - } - var statement: duckdb_prepared_statement? - guard duckdb_prepare(connection, sql, &statement) != DuckDBError, let prepared = statement else { - let message = duckdb_prepare_error(statement).map { String(cString: $0) } ?? "Failed to prepare statement" - duckdb_destroy_prepare(&statement) - throw DuckDBDriverError.queryFailed(message) - } - defer { duckdb_destroy_prepare(&statement) } - try Self.bind(parameters, to: prepared) - let state = duckdb_execute_prepared(prepared, &result) - followThreadCount(after: duckdb_prepared_statement_type(prepared)) - if state == DuckDBError { - let message = duckdb_result_error(&result).map { String(cString: $0) } ?? "Unknown DuckDB error" - duckdb_destroy_result(&result) - throw DuckDBDriverError.queryFailed(message) - } - return result - } - - private static func bind(_ parameters: [PluginCellValue], to statement: duckdb_prepared_statement) throws { - guard Int(duckdb_nparams(statement)) == parameters.count else { - throw DuckDBDriverError.queryFailed("The statement does not take the values it was given") - } - for (index, parameter) in parameters.enumerated() { - let position = idx_t(index + 1) - let state: duckdb_state - switch parameter { - case .null: - state = duckdb_bind_null(statement, position) - case .text(let value): - state = duckdb_bind_varchar_length(statement, position, value, idx_t(value.utf8.count)) - case .bytes(let data): - // An empty Data has no base address, and a null pointer would bind NULL rather than an empty blob. - let bytes = data.isEmpty ? Data([0]) : data - state = bytes.withUnsafeBytes { buffer in - duckdb_bind_blob(statement, position, buffer.baseAddress, idx_t(data.count)) - } - } - if state == DuckDBError { - throw DuckDBDriverError.queryFailed("Failed to bind parameter at index \(index)") - } - } - } - - private static func plan(of result: inout duckdb_result) -> [DuckDBStreamColumn] { - (0.. [[PluginCellValue]] { - let size = duckdb_data_chunk_get_size(chunk) - guard size > 0 else { return [] } - let vectors = plan.indices.map { duckdb_data_chunk_get_vector(chunk, idx_t($0)) } - return (0.. PluginCellValue { - if let validity = duckdb_vector_get_validity(vector), !duckdb_validity_row_is_valid(validity, row) { - return .null - } - if !column.castToText, column.type == DUCKDB_TYPE_BLOB { - guard let data = duckdb_vector_get_data(vector) else { return .null } - var value = data.assumingMemoryBound(to: duckdb_string_t.self)[Int(row)] - let length = Int(duckdb_string_t_length(value)) - guard length > 0, let pointer = duckdb_string_t_data(&value) else { return .bytes(Data()) } - return .bytes(Data(bytes: pointer, count: length)) - } - switch decodeCell(vector: vector, row: row, column: column, options: wholeText) { - case .null, .binary: - return .null - case .text(let text): - return .text(text) - case .truncatedText(let prefix, _, _): - return .text(prefix) - } - } - - // MARK: - Export stream - - func beginExport(query: String, lane id: UInt64) throws -> (header: PluginStreamHeader, generation: UInt64) { - guard let lane = transferLanes[id] else { throw DuckDBDriverError.notConnected } - try Task.checkCancellation() - closeExportResult(lane: id) - let plan = try planColumns(connection: lane.connection, query: query) - let streamQuery = plan.contains(where: { $0.castToText }) ? Self.castedQuery(originalQuery: query, columns: plan) : query - - // A prepare commits nothing on its own (DuckDBPreparedRun). A lane with no transaction to prepare in reads the - // whole result unprepared. - let ownsTransaction = Self.prepareTransaction(on: lane.connection, session: transactionState(lane: id)) - var exporting = false - defer { - if ownsTransaction == true, !exporting { DuckDBPreparedRun.rollback(on: lane.connection) } - } - let result = try ownsTransaction == nil - ? Self.wholeResult(streamQuery, on: lane.connection) - : Self.streamedResult(streamQuery, on: lane.connection) - let generation = lane.exportGeneration &+ 1 - transferLanes[id]?.exportGeneration = generation - transferLanes[id]?.exportResult = result - transferLanes[id]?.exportColumns = plan - transferLanes[id]?.exportOwnsTransaction = ownsTransaction == true - exporting = true - return (PluginStreamHeader(columns: plan.map(\.name), columnTypeNames: plan.map(\.typeName)), generation) - } - - private static func wholeResult(_ sql: String, on connection: duckdb_connection) throws -> duckdb_result { - var result = duckdb_result() - guard duckdb_query(connection, sql, &result) != DuckDBError else { - let message = duckdb_result_error(&result).map { String(cString: $0) } ?? "Failed to execute query" - duckdb_destroy_result(&result) - throw DuckDBDriverError.queryFailed(message) - } - return result - } - - private static func streamedResult(_ sql: String, on connection: duckdb_connection) throws -> duckdb_result { - var statement: duckdb_prepared_statement? - guard duckdb_prepare(connection, sql, &statement) != DuckDBError, let prepared = statement else { - let message = duckdb_prepare_error(statement).map { String(cString: $0) } ?? "Failed to prepare statement" - duckdb_destroy_prepare(&statement) - throw DuckDBDriverError.queryFailed(message) - } - defer { duckdb_destroy_prepare(&statement) } - var pending: duckdb_pending_result? - guard duckdb_pending_prepared_streaming(prepared, &pending) != DuckDBError, pending != nil else { - let message = duckdb_pending_error(pending).map { String(cString: $0) } ?? "Failed to execute query" - duckdb_destroy_pending(&pending) - throw DuckDBDriverError.queryFailed(message) - } - defer { duckdb_destroy_pending(&pending) } - - var result = duckdb_result() - guard duckdb_execute_pending(pending, &result) != DuckDBError else { - let message = duckdb_result_error(&result).map { String(cString: $0) } ?? "Failed to execute query" - duckdb_destroy_result(&result) - throw DuckDBDriverError.queryFailed(message) - } - return result - } - - // Nil at the end, which releases the result. - func nextExportChunk(lane id: UInt64, generation: UInt64) throws -> [[PluginCellValue]]? { - guard let lane = transferLanes[id], lane.exportGeneration == generation, var result = lane.exportResult else { - throw CancellationError() - } - try Task.checkCancellation() - var chunk = duckdb_stream_fetch_chunk(result) - guard chunk != nil else { - let failure = duckdb_result_error(&result).map { String(cString: $0) } - // A read that ran to its end commits the transaction opened for it; closing rolls one back. - let commits = failure == nil && lane.exportOwnsTransaction - if commits { transferLanes[id]?.exportOwnsTransaction = false } - closeExportResult(lane: id) - if let failure { throw DuckDBDriverError.queryFailed(failure) } - if commits, let failure = DuckDBPreparedRun.commit(on: lane.connection) { - throw DuckDBDriverError.queryFailed(failure) - } - return nil - } - defer { duckdb_destroy_data_chunk(&chunk) } - return Self.exportValues(chunk: chunk, plan: lane.exportColumns) - } - - func endExport(lane id: UInt64, generation: UInt64) { - guard transferLanes[id]?.exportGeneration == generation else { return } - closeExportResult(lane: id) - } -} - -// The pull side of one export read. A stream read through the session opens a connection of its own and ends it with -// the read. -nonisolated private final class DuckDBExportCursor: @unchecked Sendable { - private let actor: DuckDBActor - private let query: String - private let schema: String? - private let lock = NSLock() - private var lane: UInt64? - private var interruptHandle: DuckDBInterruptHandle? - private let ownsLane: Bool - private var generation: UInt64? - - init(actor: DuckDBActor, query: String, lane: (id: UInt64, interruptHandle: DuckDBInterruptHandle?)?, schema: String?) { - self.actor = actor - self.query = query - self.schema = schema - self.lane = lane?.id - self.interruptHandle = lane?.interruptHandle - self.ownsLane = lane == nil - } - - deinit { - let actor = actor - let state = lock.withLock { (lane, generation) } - let ownsLane = ownsLane - guard let lane = state.0 else { return } - Task { - if let generation = state.1 { - await actor.endExport(lane: lane, generation: generation) - } - if ownsLane { - await actor.closeTransferLane(lane) - } - } - } - - func next() async throws -> PluginStreamElement? { - let actor = actor - return try await withTaskCancellationHandler { - let lane = try await resolvedLane() - if let generation = lock.withLock({ self.generation }) { - guard let rows = try await actor.nextExportChunk(lane: lane, generation: generation) else { return nil } - return .rows(rows) - } - let begun = try await actor.beginExport(query: query, lane: lane) - lock.withLock { generation = begun.generation } - return .header(begun.header) - } onCancel: { - lock.withLock { interruptHandle }?.interrupt() - } - } - - private func resolvedLane() async throws -> UInt64 { - if let lane = lock.withLock({ lane }) { return lane } - let opened = try await actor.openTransferLane(schema: schema) - lock.withLock { - lane = opened.id - interruptHandle = opened.interruptHandle - } - return opened.id - } -} diff --git a/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver.swift b/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver.swift deleted file mode 100644 index a41b0a9275..0000000000 --- a/apple/TableProMobile/TableProMobile/Drivers/DuckDBDriver.swift +++ /dev/null @@ -1,569 +0,0 @@ -import CDuckDB -import Dispatch -import Foundation -import TableProDatabase -import TableProModels -import TableProSQLGrammar -import TableProSQLQuoting - -nonisolated final class DuckDBDriver: DatabaseDriver, CatalogQuerying, ExportRowStreaming, - DedicatedTransferConnection, @unchecked Sendable { - let actor: DuckDBActor - // A second connection on the session's database, which a transfer reads through; nil for the session itself. - let transferLane: UInt64? - let laneInterrupt: DuckDBInterruptHandle? - private let source: LocalDatabaseFileSource - private let openMode: LocalDatabaseOpenMode - private let fileAccess = LocalDatabaseFileAccess() - private let stateLock = NSLock() - private var currentSchemaName = "main" - - var supportsSchemas: Bool { true } - var supportsTransactions: Bool { true } - var serverVersion: String? { String(cString: duckdb_library_version()) } - // The session holds the file; a transfer connection lives and ends inside it. - var holdsSuspensionBlockingResource: Bool { transferLane == nil && source != .inMemory } - - // DuckDB ends statement text at a NUL, so a NUL in a value goes in as chr(0) between two literals. - func escapeStringLiteral(_ value: String) -> String { - value.split(separator: "\0", omittingEmptySubsequences: false) - .map { SQLQuoting.stringLiteralBody(String($0)) } - .joined(separator: "'||chr(0)||'") - } - - var currentSchema: String? { - stateLock.lock() - defer { stateLock.unlock() } - return currentSchemaName - } - - init(source: LocalDatabaseFileSource, openMode: LocalDatabaseOpenMode = .existingOnly) { - self.actor = DuckDBActor() - self.transferLane = nil - self.laneInterrupt = nil - self.source = source - self.openMode = openMode - } - - init(transferOn actor: DuckDBActor, lane: UInt64, interrupt: DuckDBInterruptHandle, source: LocalDatabaseFileSource) { - self.actor = actor - self.transferLane = lane - self.laneInterrupt = interrupt - self.source = source - self.openMode = .existingOnly - } - - // MARK: - Connection - - func connect() async throws { - guard transferLane == nil else { return } - let path = try fileAccess.begin(source, openMode: openMode) - do { - try await actor.open(path: path) - } catch { - fileAccess.end() - throw error - } - } - - func disconnect() async throws { - if let transferLane { - await actor.closeTransferLane(transferLane) - return - } - await actor.close() - fileAccess.end() - } - - // In-process, so an open handle is a live session; an aborted transaction refuses every statement until ROLLBACK. - func ping() async throws -> Bool { - guard await actor.isOpen(lane: transferLane) else { throw DuckDBDriverError.notConnected } - return true - } - - // MARK: - Query Execution - - func execute(query: String) async throws -> QueryResult { - let raw = try await actor.query(query, lane: transferLane) - let columns = raw.columnNames.enumerated().map { index, name in - ColumnInfo( - name: name, - typeName: index < raw.columnTypeNames.count ? raw.columnTypeNames[index] : "", - ordinalPosition: index - ) - } - return QueryResult( - columns: columns, - rows: raw.rows, - rowsAffected: raw.rowsAffected, - executionTime: raw.executionTime, - isTruncated: raw.isTruncated - ) - } - - /// Runs off the actor: the actor is busy inside the query for as long as it runs. - func cancelCurrentQuery() async throws { - (laneInterrupt ?? actor.interruptHandle).interrupt() - } - - // MARK: - Transactions - - func beginTransaction() async throws { - _ = try await actor.query("BEGIN TRANSACTION", lane: transferLane) - } - - func commitTransaction() async throws { - _ = try await actor.query("COMMIT", lane: transferLane) - } - - func rollbackTransaction() async throws { - _ = try await actor.query("ROLLBACK", lane: transferLane) - } - - // MARK: - State - - func resolveSchema(_ schema: String?) -> String { - if let schema { return schema } - stateLock.lock() - defer { stateLock.unlock() } - return currentSchemaName - } - - func setCurrentSchema(_ schema: String) { - stateLock.lock() - currentSchemaName = schema - stateLock.unlock() - } -} - -// MARK: - Interrupt Handle - -/// The open connection, reachable without the actor so a cancel can interrupt the query the actor is running. -/// `duckdb_interrupt` on a disconnected connection reads freed memory, so the interrupt and the detach that precedes -/// `duckdb_disconnect` share one lock. -nonisolated final class DuckDBInterruptHandle: @unchecked Sendable { - private let lock = NSLock() - private var connection: duckdb_connection? - private var runningStream: UInt64? - - func attach(_ connection: duckdb_connection) { - lock.withLock { self.connection = connection } - } - - func detach() { - lock.withLock { - connection = nil - runningStream = nil - } - } - - /// The user's Stop, which ends whatever the connection is running. - func interrupt() { - lock.withLock { - guard let connection else { return } - duckdb_interrupt(connection) - } - } - - /// The editor and the data browser share this connection, so a stream's consumer interrupts only while that - /// stream's own query is the one running. - func interrupt(stream: UInt64) { - lock.withLock { - guard runningStream == stream, let connection else { return } - duckdb_interrupt(connection) - } - } - - func enter(_ stream: UInt64) { - lock.withLock { runningStream = stream } - } - - func leave(_ stream: UInt64) { - lock.withLock { - if runningStream == stream { runningStream = nil } - } - } -} - -// MARK: - DuckDB Actor (thread-safe C API access) - -actor DuckDBActor { - static let maxRows = 100_000 - - private let executor = DuckDBStackExecutor(name: "com.TablePro.duckdb") - - nonisolated var unownedExecutor: UnownedSerialExecutor { executor.asUnownedSerialExecutor() } - - nonisolated let interruptHandle = DuckDBInterruptHandle() - private(set) var database: duckdb_database? - var connection: duckdb_connection? - private var taskThreads: DuckDBTaskThreads? - // The transfer connections on `database`, which `close()` ends before the database. - var transferLanes: [UInt64: DuckDBTransferLane] = [:] - var lastTransferLane: UInt64 = 0 - - /// One result streams at a time. Each `beginStream` gets a new generation, so the producer of a stream that a - /// later one replaced cannot fetch from or destroy the later result. - var streamResult: duckdb_result? - var streamColumns: [DuckDBStreamColumn] = [] - var streamGeneration: UInt64 = 0 - // The stream's prepare ran in a transaction opened for it, which ends with the stream. - var streamOwnsTransaction = false - - // The linked extensions, core_functions among them, exist only once DuckDB's generated loader has registered them. - private nonisolated static let registeredExtensions: Int32 = duckdb_register_static_extensions() - - // v0.10.2 is DuckDB 1.x's default, so a file this creates stays readable by DuckDB 1.x (macOS: - // DuckDBStorageCompatibility). Automatic installs stay off: iOS may not load downloaded code. - private nonisolated static let openOptions = [ - ("storage_compatibility_version", "v0.10.2"), - ("autoinstall_known_extensions", "false"), - ("autoload_known_extensions", "false"), - (DuckDBExpressionDepth.configurationOption, DuckDBExpressionDepth.limit), - ] + DuckDBTaskThreads.sessionOptions - - func open(path: String) throws { - _ = Self.registeredExtensions - var config: duckdb_config? - guard duckdb_create_config(&config) != DuckDBError else { - throw DuckDBDriverError.connectionFailed("Failed to allocate a DuckDB configuration") - } - defer { duckdb_destroy_config(&config) } - for (option, value) in Self.openOptions where duckdb_set_config(config, option, value) == DuckDBError { - throw DuckDBDriverError.connectionFailed("DuckDB refused \(option) = \(value)") - } - - var db: duckdb_database? - var errorPtr: UnsafeMutablePointer? - let state = duckdb_open_ext(path, &db, config, &errorPtr) - - if state == DuckDBError { - let detail: String - if let errorPtr { - detail = String(cString: errorPtr) - duckdb_free(errorPtr) - } else { - detail = "unknown error" - } - throw DuckDBDriverError.connectionFailed(detail) - } - - guard db != nil else { - throw DuckDBDriverError.connectionFailed("Failed to open the DuckDB database") - } - - var conn: duckdb_connection? - if duckdb_connect(db, &conn) == DuckDBError { - duckdb_close(&db) - throw DuckDBDriverError.connectionFailed("Failed to create a DuckDB connection") - } - - database = db - connection = conn - if let db { taskThreads = DuckDBTaskThreads(database: db) } - if let conn { interruptHandle.attach(conn) } - } - - var isOpen: Bool { database != nil && connection != nil } - - func isOpen(lane: UInt64?) -> Bool { - guard let lane else { return isOpen } - return database != nil && transferLanes[lane] != nil - } - - // A connection left open after `duckdb_close` keeps reading the file, so each transfer connection goes first. - func close() { - closeTransferLanes() - interruptHandle.detach() - closeStreamResult() - if connection != nil { - duckdb_disconnect(&connection) - connection = nil - } - taskThreads?.close() - taskThreads = nil - if database != nil { - duckdb_close(&database) - database = nil - } - } - - func query(_ sql: String, lane: UInt64? = nil) throws -> DuckDBRawResult { - guard let connection = connection(for: lane) else { throw DuckDBDriverError.notConnected } - // Another statement closes an open streaming result inside DuckDB, and its next fetch would fail with an - // internal error. Closing it here ends that stream as cancelled. - if let lane { - closeExportResult(lane: lane) - } else { - closeStreamResult() - } - - let startTime = Date() - var result = duckdb_result() - - if let message = run(sql, on: connection, into: &result) { - duckdb_destroy_result(&result) - throw DuckDBDriverError.queryFailed(message) - } - - let columnCount = duckdb_column_count(&result) - let rowsChanged = Int(duckdb_rows_changed(&result)) - var plan: [DuckDBStreamColumn] = [] - for index in 0.. String? { - guard let taskThreads else { - return duckdb_query(connection, sql, &result) == DuckDBError ? Self.error(of: &result) : nil - } - var extracted: duckdb_extracted_statements? - defer { duckdb_destroy_extracted(&extracted) } - let count = duckdb_extract_statements(connection, sql, &extracted) - if let error = duckdb_extract_statements_error(extracted) { - return String(cString: error) - } - guard count > 1 else { return Self.run(sql, on: connection, taskThreads, into: &result) } - let statements = SQLStatementScanner.executableStatements(in: sql, grammar: Self.grammar) - guard statements.count == count else { - return "DuckDB reads \(count) statements here where TablePro splits \(statements.count); run them one at a time" - } - var kept: duckdb_result? - var keptHasRows = false - for statement in statements { - var current = duckdb_result() - if let failure = Self.run(statement.sql, on: connection, taskThreads, into: ¤t) { - duckdb_destroy_result(¤t) - if var kept { duckdb_destroy_result(&kept) } - return failure - } - if kept != nil, keptHasRows { - duckdb_destroy_result(¤t) - continue - } - if var earlier = kept { duckdb_destroy_result(&earlier) } - keptHasRows = duckdb_result_return_type(current) == DUCKDB_RESULT_TYPE_QUERY_RESULT - kept = current - } - if let kept { result = kept } - return nil - } - - func followThreadCount(after type: duckdb_statement_type) { - guard !DuckDBTaskThreads.keepsCount(type) else { return } - taskThreads?.followCount() - } - - private static let grammar = SQLLexicalReadings.resolve( - databaseTypeId: DatabaseType.duckdb.rawValue, declared: nil, session: nil - ).execution - - private static func run( - _ sql: String, - on connection: duckdb_connection, - _ taskThreads: DuckDBTaskThreads, - into result: inout duckdb_result - ) -> String? { - let state = duckdb_query(connection, sql, &result) - if !DuckDBTaskThreads.keepsCount(duckdb_result_statement_type(result)) { - taskThreads.followCount() - } - return state == DuckDBError ? error(of: &result) : nil - } - - private static func error(of result: inout duckdb_result) -> String { - duckdb_result_error(&result).map { String(cString: $0) } ?? "Unknown DuckDB error" - } - - private static func decodeMaterialized( - _ result: inout duckdb_result, - plan: [DuckDBStreamColumn], - rowsChanged: Int, - startTime: Date - ) -> DuckDBRawResult { - let options = StreamOptions(textTruncationBytes: Int.max, maxRows: maxRows) - var rows: [[String?]] = [] - var truncated = false - - chunks: while true { - var chunk = duckdb_fetch_chunk(result) - guard chunk != nil else { break } - defer { duckdb_destroy_data_chunk(&chunk) } - - let size = duckdb_data_chunk_get_size(chunk) - var vectors: [duckdb_vector?] = [] - for index in 0..= maxRows { - truncated = true - break chunks - } - var values: [String?] = [] - values.reserveCapacity(plan.count) - for index in 0.. String? { - switch cell { - case .null: return nil - case .text(let value): return value - case .truncatedText(let prefix, _, _): return prefix - case .binary: return nil - } - } - - // MARK: - Type Rendering - - static func castedQuery(originalQuery: String, columns: [DuckDBStreamColumn]) -> String { - let projection = columns.map { column in - column.castToText ? castExpression(for: column.type, column: column.name) : quoteIdentifier(column.name) - } - return "SELECT \(projection.joined(separator: ", ")) FROM (\(stripTrailingSemicolon(originalQuery))) AS _tp_cast" - } - - private static func castExpression(for type: duckdb_type, column: String) -> String { - let quoted = quoteIdentifier(column) - if type == DUCKDB_TYPE_GEOMETRY { - return "CASE WHEN \(quoted) IS NULL THEN NULL ELSE ST_AsText(\(quoted)) END AS \(quoted)" - } - return "CASE WHEN \(quoted) IS NULL THEN NULL ELSE CAST(\(quoted) AS VARCHAR) END AS \(quoted)" - } - - static func quoteIdentifier(_ identifier: String) -> String { - SQLQuoting.identifier(identifier) - } - - static func stripTrailingSemicolon(_ query: String) -> String { - var trimmed = query.trimmingCharacters(in: .whitespacesAndNewlines) - if trimmed.hasSuffix(";") { - trimmed = String(trimmed.dropLast()) - } - return trimmed - } - - static func typeName(for type: duckdb_type) -> String { - switch type { - case DUCKDB_TYPE_BOOLEAN: return "BOOLEAN" - case DUCKDB_TYPE_TINYINT: return "TINYINT" - case DUCKDB_TYPE_SMALLINT: return "SMALLINT" - case DUCKDB_TYPE_INTEGER: return "INTEGER" - case DUCKDB_TYPE_BIGINT: return "BIGINT" - case DUCKDB_TYPE_UTINYINT: return "UTINYINT" - case DUCKDB_TYPE_USMALLINT: return "USMALLINT" - case DUCKDB_TYPE_UINTEGER: return "UINTEGER" - case DUCKDB_TYPE_UBIGINT: return "UBIGINT" - case DUCKDB_TYPE_FLOAT: return "FLOAT" - case DUCKDB_TYPE_DOUBLE: return "DOUBLE" - case DUCKDB_TYPE_TIMESTAMP: return "TIMESTAMP" - case DUCKDB_TYPE_DATE: return "DATE" - case DUCKDB_TYPE_TIME: return "TIME" - case DUCKDB_TYPE_INTERVAL: return "INTERVAL" - case DUCKDB_TYPE_HUGEINT: return "HUGEINT" - case DUCKDB_TYPE_UHUGEINT: return "UHUGEINT" - case DUCKDB_TYPE_VARCHAR: return "VARCHAR" - case DUCKDB_TYPE_BLOB: return "BLOB" - case DUCKDB_TYPE_DECIMAL: return "DECIMAL" - case DUCKDB_TYPE_TIMESTAMP_S: return "TIMESTAMP_S" - case DUCKDB_TYPE_TIMESTAMP_MS: return "TIMESTAMP_MS" - case DUCKDB_TYPE_TIMESTAMP_NS: return "TIMESTAMP_NS" - case DUCKDB_TYPE_ENUM: return "ENUM" - case DUCKDB_TYPE_LIST: return "LIST" - case DUCKDB_TYPE_STRUCT: return "STRUCT" - case DUCKDB_TYPE_MAP: return "MAP" - case DUCKDB_TYPE_ARRAY: return "ARRAY" - case DUCKDB_TYPE_UUID: return "UUID" - case DUCKDB_TYPE_UNION: return "UNION" - case DUCKDB_TYPE_BIT: return "BIT" - case DUCKDB_TYPE_TIMESTAMP_TZ: return "TIMESTAMPTZ" - case DUCKDB_TYPE_TIME_TZ: return "TIMETZ" - case DUCKDB_TYPE_TIME_NS: return "TIME_NS" - case DUCKDB_TYPE_GEOMETRY: return "GEOMETRY" - default: return "VARCHAR" - } - } -} - -nonisolated struct DuckDBRawResult: @unchecked Sendable { - let columnNames: [String] - let columnTypeNames: [String] - let rows: [[String?]] - let rowsAffected: Int - let executionTime: TimeInterval - let isTruncated: Bool -} - -// MARK: - Errors - -nonisolated enum DuckDBDriverError: Error, LocalizedError { - case connectionFailed(String) - case notConnected - case queryFailed(String) - case unsupported(String) - - var errorDescription: String? { - switch self { - case .connectionFailed(let message): return "DuckDB connection failed: \(message)" - case .notConnected: return "Not connected to DuckDB database" - case .queryFailed(let message): return "DuckDB query failed: \(message)" - case .unsupported(let message): return message - } - } -} diff --git a/apple/TableProMobile/TableProMobile/Drivers/PluginBackedDriver.swift b/apple/TableProMobile/TableProMobile/Drivers/PluginBackedDriver.swift index d4224570a0..f34f6eefa8 100644 --- a/apple/TableProMobile/TableProMobile/Drivers/PluginBackedDriver.swift +++ b/apple/TableProMobile/TableProMobile/Drivers/PluginBackedDriver.swift @@ -125,6 +125,9 @@ nonisolated class PluginBackedDriver: DatabaseDriver, CatalogQuerying, ExportRow plugin.disconnect() } + // Declared here so a driver over a file it holds open can say so. + var holdsSuspensionBlockingResource: Bool { false } + func ping() async throws -> Bool { try await plugin.ping() return true @@ -190,46 +193,17 @@ nonisolated class PluginBackedDriver: DatabaseDriver, CatalogQuerying, ExportRow options: StreamOptions, into continuation: AsyncThrowingStream.Continuation ) { - let columns = zip(result.columns, result.columnTypeNames).enumerated().map { index, pair in - ColumnInfo(name: pair.0, typeName: pair.1, ordinalPosition: index) - } - continuation.yield(.columns(columns)) - let keyIndices = options.lazyContext.map { context in - context.primaryKeyColumns.map { key in result.columns.firstIndex(of: key) } - } + var rows = PluginRowEmitter(options: options) + rows.begin(columns: result.columns, typeNames: result.columnTypeNames, into: continuation) let locators = result.rowLocators.flatMap { $0.count == result.rows.count ? $0 : nil } ?? [] - var emitted = 0 for (rowIndex, row) in result.rows.enumerated() { if Task.isCancelled { continuation.yield(.truncated(reason: .cancelled)) return } - if emitted >= options.maxRows { - continuation.yield(.truncated(reason: .rowCap(options.maxRows))) - return - } let locator = locators.indices.contains(rowIndex) ? locators[rowIndex] : nil - let cells = row.enumerated().map { index, value -> Cell in - let ref = cellRef( - column: index < result.columns.count ? result.columns[index] : "", - row: row, - locator: locator, - keyIndices: keyIndices, - options: options - ) - switch value { - case .null: - return .null - // Bytes stay binary: shown as hex text they would read as an editable value and match no row. - case .bytes(let data): - return .binary(byteCount: data.count, ref: ref) - case .text(let text): - return Cell.from(text: text, options: options, ref: ref) - } - } - continuation.yield(.row(Row(cells: cells, locator: locator))) - emitted += 1 + guard rows.emit(row, locator: locator, into: continuation) else { return } } if let message = result.statusMessage { @@ -240,29 +214,13 @@ nonisolated class PluginBackedDriver: DatabaseDriver, CatalogQuerying, ExportRow } // A plugin that capped the read itself returns exactly the cap and says it stopped there. if result.isTruncated { - let reason: TruncationReason = emitted >= options.maxRows + let reason: TruncationReason = rows.emitted >= options.maxRows ? .rowCap(options.maxRows) : .driverLimit("driver returned isTruncated=true") continuation.yield(.truncated(reason: reason)) } } - private static func cellRef( - column: String, - row: [PluginCellValue], - locator: String?, - keyIndices: [Int?]?, - options: StreamOptions - ) -> CellRef? { - guard let context = options.lazyContext, let keyIndices, !keyIndices.isEmpty else { return nil } - var components: [PrimaryKeyComponent] = [] - for (key, index) in zip(context.primaryKeyColumns, keyIndices) { - guard let index, index < row.count, case .text(let value) = row[index] else { return nil } - components.append(PrimaryKeyComponent(column: key, value: value)) - } - return CellRef(table: context.table, column: column, primaryKey: components, locator: locator) - } - // MARK: - Catalog // A catalog read shares the connection a cancel reaches, so it takes its turn with statements: a Stop for a @@ -387,10 +345,96 @@ nonisolated class PluginBackedDriver: DatabaseDriver, CatalogQuerying, ExportRow guard plugin.supportsTransactions else { return .idle } switch await plugin.sessionTransactionState() { case .idle: return .idle - case .inTransaction, .abortedTransaction: return .explicitTransaction + case .inTransaction: return .explicitTransaction + case .abortedTransaction: return .abortedTransaction case .holdsSessionLocks: return .implicitTransaction case .unknown: return .unknown @unknown default: return .unknown } } } + +// A plugin's rows as stream elements, one at a time: each cut for display as it comes, up to the cap. +nonisolated struct PluginRowEmitter { + let options: StreamOptions + private var columns: [String] = [] + private var keyIndices: [Int?]? + private(set) var emitted = 0 + + init(options: StreamOptions) { + self.options = options + } + + mutating func begin( + columns: [String], + typeNames: [String], + into continuation: AsyncThrowingStream.Continuation + ) { + self.columns = columns + continuation.yield(.columns(zip(columns, typeNames).enumerated().map { index, pair in + ColumnInfo(name: pair.0, typeName: pair.1, ordinalPosition: index) + })) + keyIndices = options.lazyContext.map { context in + context.primaryKeyColumns.map { key in columns.firstIndex(of: key) } + } + } + + // False once a row past the cap arrived, after saying the read stopped there. + mutating func emit( + _ row: [PluginCellValue], + locator: String?, + into continuation: AsyncThrowingStream.Continuation + ) -> Bool { + guard emitted < options.maxRows else { + continuation.yield(.truncated(reason: .rowCap(options.maxRows))) + return false + } + let keyText: (Int) -> String? = { index in + guard index < row.count, case .text(let value) = row[index] else { return nil } + return value + } + let cells = row.enumerated().map { index, value -> Cell in + let ref = ref(column: index < columns.count ? columns[index] : "", keyText: keyText, locator: locator) + switch value { + case .null: + return .null + // Bytes stay binary: shown as hex text they would read as an editable value and match no row. + case .bytes(let data): + return .binary(byteCount: data.count, ref: ref) + case .text(let text): + return Cell.from(text: text, options: options, ref: ref) + } + } + return emit(cells: cells, locator: locator, into: continuation) + } + + // A row whose cells the caller made, under the same cap. + mutating func emit( + cells: [Cell], + locator: String?, + into continuation: AsyncThrowingStream.Continuation + ) -> Bool { + guard emitted < options.maxRows else { + continuation.yield(.truncated(reason: .rowCap(options.maxRows))) + return false + } + continuation.yield(.row(Row(cells: cells, locator: locator))) + emitted += 1 + return true + } + + func column(at index: Int) -> String { + index < columns.count ? columns[index] : "" + } + + // The key a long value is read back by, from the row's key columns as text. + func ref(column: String, keyText: (Int) -> String?, locator: String?) -> CellRef? { + guard let context = options.lazyContext, let keyIndices, !keyIndices.isEmpty else { return nil } + var components: [PrimaryKeyComponent] = [] + for (key, index) in zip(context.primaryKeyColumns, keyIndices) { + guard let index, let value = keyText(index) else { return nil } + components.append(PrimaryKeyComponent(column: key, value: value)) + } + return CellRef(table: context.table, column: column, primaryKey: components, locator: locator) + } +} diff --git a/apple/TableProMobile/TableProMobile/Localizable.xcstrings b/apple/TableProMobile/TableProMobile/Localizable.xcstrings index d54c0294ae..99c3591a33 100644 --- a/apple/TableProMobile/TableProMobile/Localizable.xcstrings +++ b/apple/TableProMobile/TableProMobile/Localizable.xcstrings @@ -671,6 +671,16 @@ } } }, + "%@ is using %@. Only one app can open a DuckDB file for writing." : { + "localizations" : { + "en" : { + "stringUnit" : { + "state" : "new", + "value" : "%1$@ is using %2$@. Only one app can open a DuckDB file for writing." + } + } + } + }, "%@ no longer exists" : { "extractionState" : "manual", "generatesSymbol" : false, @@ -3070,6 +3080,9 @@ "Americas" : { "extractionState" : "manual", "generatesSymbol" : false + }, + "An auto-increment column takes its values from a sequence, so it cannot also have a default." : { + }, "An earlier import made a table named %@ with other columns. Choose another name." : { @@ -3205,6 +3218,9 @@ } } } + }, + "Another app is using %@. Only one app can open a DuckDB file for writing." : { + }, "Another connection closes this one and opens that one with the file." : { @@ -3813,6 +3829,9 @@ } } } + }, + "Automatic" : { + }, "Automatic (%@)" : { @@ -4550,6 +4569,9 @@ } } } + }, + "Certificate Fingerprint" : { + }, "Certificate Name Mismatch" : { @@ -6044,6 +6066,9 @@ } } } + }, + "Connecting to the remote DuckDB database timed out." : { + }, "Connecting…" : { "localizations" : { @@ -6386,6 +6411,9 @@ } } } + }, + "Connection Type" : { + }, "Connections" : { "localizations" : { @@ -7682,6 +7710,9 @@ "Database & Storage" : { "extractionState" : "manual", "generatesSymbol" : false + }, + "Database Alias" : { + }, "Database File" : { "localizations" : { @@ -8810,6 +8841,9 @@ } } } + }, + "DuckDB could not allocate a configuration to open the file" : { + }, "DuckDB could not install its %@ extension. It downloads the extension from extensions.duckdb.org the first time it connects to a remote database." : { "extractionState" : "manual", @@ -8822,10 +8856,22 @@ "DuckDB could not read the CA Certificate. It reads PEM files only." : { "extractionState" : "manual", "generatesSymbol" : false + }, + "DuckDB could not say whether this session holds a transaction, so the statement did not run." : { + }, "DuckDB could not verify the server's certificate. Either no CA it trusts signed it, or it was not issued for this host name. DuckDB checks certificates against /etc/ssl/cert.pem and the CA Certificate, and does not read the macOS keychain, so a CA added in Keychain Access is not trusted." : { "extractionState" : "manual", "generatesSymbol" : false + }, + "DuckDB opened %d catalogs and none of them is current" : { + + }, + "DuckDB opened the file but reported no catalog to browse" : { + + }, + "DuckDB reads %lld statements in this text. Run them one at a time." : { + }, "DuckDB reported: %@" : { "extractionState" : "manual", @@ -13944,6 +13990,9 @@ } } } + }, + "Local File" : { + }, "Local Network access is required. Open Settings > Privacy & Security > Local Network and turn TablePro on." : { "extractionState" : "stale", @@ -15504,6 +15553,9 @@ }, "No fields found in the file." : { + }, + "No file at %@" : { + }, "No Foreign Keys" : { "localizations" : { @@ -16917,6 +16969,9 @@ }, "Open Table" : { + }, + "Open the File Read-Only" : { + }, "Open this connection in TablePro and connect from there to answer the question." : { @@ -17044,6 +17099,9 @@ } } } + }, + "Operation not supported" : { + }, "Operator" : { "localizations" : { @@ -17072,6 +17130,9 @@ } } } + }, + "Optional" : { + }, "Optional, for a single-tenant directory" : { "extractionState" : "manual", @@ -18989,6 +19050,12 @@ } } } + }, + "Quit or disconnect the other app, or turn on Open the File Read-Only to join it as a reader." : { + + }, + "Quit or disconnect the other app, then try again." : { + }, "Quote" : { @@ -19515,6 +19582,12 @@ } } } + }, + "Release File Lock" : { + + }, + "Release the File Lock After (minutes, 0 to keep it)" : { + }, "Reload" : { "localizations" : { @@ -19546,6 +19619,9 @@ }, "Reload the table to see the row as it is now." : { + }, + "Remote (Quack, experimental)" : { + }, "Remove" : { "localizations" : { @@ -19913,6 +19989,9 @@ } } } + }, + "Required (skip verify)" : { + }, "Reset" : { "localizations" : { @@ -23971,6 +24050,9 @@ "TablePro could not read the CA Certificate at %@: %@" : { "extractionState" : "manual", "generatesSymbol" : false + }, + "TablePro could not read what this connection is holding, so it kept the file." : { + }, "TablePro could not read your connection library, so nothing was imported." : { "localizations" : { @@ -25164,6 +25246,9 @@ } } } + }, + "The connection has no current DuckDB catalog to read metadata from" : { + }, "The connection moved to another database or schema. Choose the row again." : { @@ -25498,6 +25583,12 @@ } } } + }, + "the database file" : { + + }, + "The database file is no longer at %@." : { + }, "The database had already ended the import's transaction, so none of its rows were kept." : { @@ -27665,6 +27756,21 @@ } } } + }, + "This build of DuckDB does not accept a limit on how deep an expression nests" : { + + }, + "This build of DuckDB does not accept a read-only access mode" : { + + }, + "This build of DuckDB does not accept running its tasks on threads TablePro starts" : { + + }, + "This build of DuckDB does not accept the storage version that keeps files readable by DuckDB 1.x" : { + + }, + "This build of DuckDB does not accept turning off persistent secrets" : { + }, "This certificate file needs a password. Certificate files exported without one cannot be read on iOS." : { "localizations" : { @@ -27861,18 +27967,27 @@ }, "This connection has an open transaction. Commit or roll it back first." : { + }, + "This connection has another database attached, which closing the file would detach." : { + }, "This connection has open HANDLER cursors, which reconnecting would close." : { }, "This connection has prepared statements, which reconnecting would discard." : { + }, + "This connection has session objects, such as a temporary table, a macro or a prepared statement, which closing the file would delete." : { + }, "This connection has session settings changed, which reconnecting would reset." : { }, "This connection has session variables set, which reconnecting would clear." : { + }, + "This connection has settings that closing the file would reset." : { + }, "This connection has temporary tables, which reconnecting would delete." : { @@ -30511,6 +30626,9 @@ }, "Verify CA needs a CA certificate. On the connection's Network tab, choose the CA certificate that signed the server's certificate, or set SSL Mode to Verify Identity." : { + }, + "Verify Fingerprint" : { + }, "Verify Fingerprint needs the server's Certificate Fingerprint. Run quack_server_list() on the server to read it." : { "extractionState" : "manual", diff --git a/apple/TableProMobile/TableProMobile/Platform/IOSDriverFactory.swift b/apple/TableProMobile/TableProMobile/Platform/IOSDriverFactory.swift index 1365e95be7..52d7dea438 100644 --- a/apple/TableProMobile/TableProMobile/Platform/IOSDriverFactory.swift +++ b/apple/TableProMobile/TableProMobile/Platform/IOSDriverFactory.swift @@ -170,7 +170,7 @@ nonisolated final class IOSDriverFactory: DriverFactory { case .sqlite: return SQLiteDriver(source: try sqliteSource(for: connection)) case .duckdb: - return DuckDBDriver(source: try duckDBSource(for: connection)) + return DuckDBBackedDriver(source: try duckDBSource(for: connection)) case .mysql, .mariadb, .tidb, .oceanbase: guard connection.macSocketPath == nil else { throw ConnectionError.localSocketNotSupported diff --git a/apple/TableProMobile/TableProMobile/Platform/LocalDatabaseFileCreator.swift b/apple/TableProMobile/TableProMobile/Platform/LocalDatabaseFileCreator.swift index cd938da3d6..d2ebcf8a8d 100644 --- a/apple/TableProMobile/TableProMobile/Platform/LocalDatabaseFileCreator.swift +++ b/apple/TableProMobile/TableProMobile/Platform/LocalDatabaseFileCreator.swift @@ -44,7 +44,7 @@ nonisolated struct DriverDatabaseFileCreator: LocalDatabaseFileCreating { case .sqlite: return SQLiteDriver(source: .file(url), openMode: .createNew) case .duckdb: - return DuckDBDriver(source: .file(url), openMode: .createNew) + return DuckDBBackedDriver(source: .file(url), openMode: .createNew) default: throw ConnectionError.driverNotFound(type.rawValue) } diff --git a/apple/TableProMobile/TableProMobile/Transfer/Engines/DuckDBTransferEngine.swift b/apple/TableProMobile/TableProMobile/Transfer/Engines/DuckDBTransferEngine.swift deleted file mode 100644 index d7e90cdc8d..0000000000 --- a/apple/TableProMobile/TableProMobile/Transfer/Engines/DuckDBTransferEngine.swift +++ /dev/null @@ -1,164 +0,0 @@ -import Foundation -import TableProDatabase -import TableProDuckDBCore -import TableProModels -import TableProPluginKit -import TableProSQLGrammar -import TableProSQLQuoting - -nonisolated extension DuckDBDriver: MobileTransferEngine { - func makeExportCatalog(context: MobileTransferContext) async throws -> any MobileExportCatalog { - let catalog = try await catalogQuery("SELECT current_database()").rows.first?[safe: 0]?.asText - guard let catalog else { throw DuckDBDriverError.queryFailed("The database did not name its catalog") } - return DuckDBTransferCatalog( - driver: self, catalog: catalog, defaultSchema: context.schema ?? currentSchema ?? Self.defaultSchema - ) - } - - func makeWriteDialect(context: MobileTransferContext) async throws -> any MobileWriteDialect { - DuckDBWriteDialect(defaultSchema: context.schema ?? currentSchema ?? Self.defaultSchema) - } - - static let defaultSchema = "main" -} - -// The Mac plugin's export answers (`DuckDBPlugin`), read through the driver the transfer runs on. Every read names the -// catalog, because `duckdb_*()` spans every attached database; an object's container is its schema, as on the Mac. -nonisolated struct DuckDBTransferCatalog: MobileExportCatalog { - let driver: any CatalogQuerying - let catalog: String - let defaultSchema: String - - var databaseTypeId: String { duckdbDatabaseTypeId } - - private var run: DuckDBExportCatalog.Run { - { [driver] sql, parameters in try await driver.catalogQuery(sql, parameters: parameters) } - } - - private func schema(for databaseName: String) -> String { - databaseName.isEmpty ? defaultSchema : databaseName - } - - func exportObjects(database: String, schema: String?) async throws -> [PluginExportTable] { - let container = schema ?? defaultSchema - let tables = try await DuckDBExportCatalog.tables(catalog: catalog, schema: container, run: run) - let (catalog, run) = (catalog, run) - return tables.compactMap { ExportCatalogItems.relation($0, container: container) } - + (await ExportCatalogItems.listing("macros") { - ExportCatalogItems.routines( - try await DuckDBExportCatalog.routines(catalog: catalog, schema: container, run: run), - container: container - ) - }) - } - - func quoteIdentifier(_ identifier: String) -> String { - DuckDBSchemaQueries.quoteIdentifier(identifier) - } - - func escapeStringLiteral(_ value: String) -> String { - SQLQuoting.stringLiteralBody(value) - } - - func fetchTableDDL(table: String, databaseName: String) async throws -> String { - try await DuckDBExportCatalog.tableDDL(catalog: catalog, schema: schema(for: databaseName), table: table, run: run) - } - - func fetchColumns(table: String, databaseName: String) async throws -> [PluginColumnInfo] { - try await DuckDBExportCatalog.columns(catalog: catalog, schema: schema(for: databaseName), table: table, run: run) - } - - func fetchAllColumns(databaseName: String) async throws -> [String: [PluginColumnInfo]] { - try await DuckDBExportCatalog.allColumns( - catalog: catalog, schema: schema(for: databaseName), keepsSpellingsApart: true, run: run - ) - } - - func fetchForeignKeys(table: String, databaseName: String) async throws -> [PluginForeignKeyInfo] { - try await DuckDBExportCatalog.foreignKeys( - catalog: catalog, schema: schema(for: databaseName), table: table, run: run - ) - } - - // The plugin has no schema-wide read, so it asks table by table; this does the same. - func fetchAllForeignKeys(databaseName: String) async throws -> [String: [PluginForeignKeyInfo]] { - let container = schema(for: databaseName) - let (catalog, run) = (catalog, run) - let tables = try await DuckDBExportCatalog.tables(catalog: catalog, schema: container, run: run) - return try await PluginNameSpellings.readEachTable(tables.map(\.name)) { - try await DuckDBExportCatalog.foreignKeys(catalog: catalog, schema: container, table: $0, run: run) - } - } - - var tableDDLIncludesForeignKeys: Bool { DuckDBExportCatalog.tableDDLIncludesForeignKeys } - - func fetchIndexDDL(table: String, databaseName: String) async throws -> [String] { - try await DuckDBExportCatalog.indexDDL(catalog: catalog, schema: schema(for: databaseName), table: table, run: run) - } - - func fetchObjectDDL(_ object: PluginExportTable) async throws -> String { - let container = schema(for: object.databaseName) - switch object.kind { - case .table, .foreignTable: - return try await DuckDBExportCatalog.tableDDL(catalog: catalog, schema: container, table: object.name, run: run) - case .view, .materializedView: - return try await DuckDBExportCatalog.viewDefinition( - catalog: catalog, schema: container, view: object.name, run: run - ) - case .routine: - let routines = try await DuckDBExportCatalog.routines(catalog: catalog, schema: container, run: run) - let routine = try ExportCatalogItems.routine(matching: object, in: routines) - return try await DuckDBExportCatalog.routineDDL(routine, catalog: catalog, run: run) - default: - throw PluginObjectSourceError.unsupported(object.name) - } - } - - // The identity is the shared listing's signature, which names a table macro's kind. - func dropStatement(for object: PluginExportTable) -> String? { - guard object.kind == .routine else { return nil } - return DuckDBObjectQueries.dropMacro( - name: object.name, - schema: schema(for: object.databaseName), - isTableMacro: DuckDBObjectQueries.namesTableMacro(object.identity) - ) - } - - private var script: ExportCatalogScript { - ExportCatalogScript(databaseTypeId: databaseTypeId, session: nil) - } - - var lexicalFeatures: SQLLexicalFeatures { script.lexicalFeatures } - - func scriptText(for ddl: String) -> String { - script.scriptText(for: ddl) - } -} - -nonisolated struct DuckDBWriteDialect: MobileWriteDialect { - let defaultSchema: String - - var databaseTypeId: String { duckdbDatabaseTypeId } - - func importStatements(table: String, schema: String?, columns: [ColumnInfo]) async throws -> SQLImportStatements { - let quote = DuckDBSchemaQueries.quoteIdentifier - return SQLImportStatements( - databaseTypeId: databaseTypeId, - qualifiedTableName: ImportTableNames.qualified(table, schema: schema, quote: quote), - parameterStyle: .dollar, - quoteIdentifier: quote, - columnTypeNames: ImportTableNames.columnTypeNames(columns) - ) - } - - func createTableStatements(definition: PluginCreateTableDefinition, schema: String?) throws -> [String] { - guard let statements = duckdbCreateTableStatements( - definition: definition, - schema: schema.flatMap(\.nilIfEmpty) ?? defaultSchema, - quote: DuckDBSchemaQueries.quoteIdentifier - ) else { - throw ImportTableNames.noStatement - } - return statements - } -} diff --git a/apple/TableProMobile/TableProMobile/Transfer/Engines/PluginBackedTransferEngine.swift b/apple/TableProMobile/TableProMobile/Transfer/Engines/PluginBackedTransferEngine.swift index cdb3f3daf2..2011ac2247 100644 --- a/apple/TableProMobile/TableProMobile/Transfer/Engines/PluginBackedTransferEngine.swift +++ b/apple/TableProMobile/TableProMobile/Transfer/Engines/PluginBackedTransferEngine.swift @@ -4,14 +4,15 @@ import TableProModels import TableProPluginKit import TableProSQLGrammar -// ClickHouse, Cloudflare D1 and MongoDB run their Mac plugin whole, so an export asks that plugin what the Mac's -// `ExportDataSourceAdapter` asks it. MongoDB takes no rows from a file, as on the Mac (D9). +// ClickHouse, Cloudflare D1, DuckDB and MongoDB run their Mac plugin whole, so an export asks that plugin what the +// Mac's `ExportDataSourceAdapter` asks it. MongoDB takes no rows from a file, as on the Mac (D9). nonisolated extension PluginBackedDriver: MobileTransferEngine { func makeExportCatalog(context: MobileTransferContext) async throws -> any MobileExportCatalog { PluginTransferCatalog( driver: self, databaseTypeId: context.databaseType.rawValue, groupsByDatabase: context.databaseType == .clickhouse, + listsBySchema: context.databaseType == .duckdb, switchesDatabase: context.databaseType == .mongodb, openedDatabase: context.database?.nilIfEmpty ?? currentDatabase ) @@ -28,12 +29,14 @@ nonisolated extension PluginBackedDriver: MobileTransferEngine { } // `groupsByDatabase`: ClickHouse's tree names each database, as the Mac's does; D1 and MongoDB are flat, so an object -// carries no container. `switchesDatabase`: a MongoDB export reads the collection in its own database, so the -// transfer's own driver moves there first. +// carries no container. `listsBySchema`: DuckDB lists a macro of every schema when asked for none, so each listing +// names the schema the export reads, as the Mac's loader does. `switchesDatabase`: a MongoDB export reads the +// collection in its own database, so the transfer's own driver moves there first. nonisolated struct PluginTransferCatalog: MobileExportCatalog { let driver: PluginBackedDriver let databaseTypeId: String let groupsByDatabase: Bool + let listsBySchema: Bool let switchesDatabase: Bool let openedDatabase: String? private let routineLists = ExportCatalogListCache() @@ -46,12 +49,14 @@ nonisolated struct PluginTransferCatalog: MobileExportCatalog { driver: PluginBackedDriver, databaseTypeId: String, groupsByDatabase: Bool, + listsBySchema: Bool = false, switchesDatabase: Bool, openedDatabase: String? ) { self.driver = driver self.databaseTypeId = databaseTypeId self.groupsByDatabase = groupsByDatabase + self.listsBySchema = listsBySchema self.switchesDatabase = switchesDatabase self.openedDatabase = openedDatabase } @@ -249,7 +254,8 @@ nonisolated struct PluginTransferCatalog: MobileExportCatalog { // What the listing passes as `schema:`: nothing for the database the export opened on, as the Mac's loader reads it. private func listSchema(_ container: String) -> String? { - groupsByDatabase && container != openedDatabase ? container.nilIfEmpty : nil + if listsBySchema { return exportSchema(for: container) } + return groupsByDatabase && container != openedDatabase ? container.nilIfEmpty : nil } private func listedRoutines(_ container: String) async throws -> [PluginRoutineInfo] { diff --git a/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBDriverSuspensionTests.swift b/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBDriverSuspensionTests.swift index a44692f2c1..5e535de491 100644 --- a/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBDriverSuspensionTests.swift +++ b/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBDriverSuspensionTests.swift @@ -1,16 +1,25 @@ +import Foundation +import TableProDatabase @testable import TableProMobile -import XCTest +import Testing -final class DuckDBDriverSuspensionTests: XCTestCase { - func testInMemoryDatabaseHoldsNoSuspensionBlockingResource() { - let driver = DuckDBDriver(source: .inMemory) +struct DuckDBDriverSuspensionTests { + @Test("An in-memory database holds no file through a suspension") + func inMemoryHoldsNothing() { + #expect(!DuckDBBackedDriver(source: .inMemory).holdsSuspensionBlockingResource) + } + + @Test("A file the session opens holds it through a suspension") + func fileIsHeld() { + let driver = DuckDBBackedDriver(source: .file(URL(fileURLWithPath: "/tmp/analytics.duckdb"))) - XCTAssertFalse(driver.holdsSuspensionBlockingResource) + #expect(driver.holdsSuspensionBlockingResource) } - func testFileBackedDatabaseHoldsSuspensionBlockingResource() { - let driver = DuckDBDriver(source: .file(URL(fileURLWithPath: "/tmp/analytics.duckdb"))) + @Test("The flag reaches a caller that sees only a DatabaseDriver") + func flagReachesTheProtocol() { + let driver: any DatabaseDriver = DuckDBBackedDriver(source: .file(URL(fileURLWithPath: "/tmp/analytics.duckdb"))) - XCTAssertTrue(driver.holdsSuspensionBlockingResource) + #expect(driver.holdsSuspensionBlockingResource) } } diff --git a/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBDriverTests.swift b/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBDriverTests.swift index b3aedaaae9..320ffd994b 100644 --- a/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBDriverTests.swift +++ b/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBDriverTests.swift @@ -3,62 +3,91 @@ import Foundation import TableProDatabase @testable import TableProMobile import TableProModels +import TableProPluginKit import Testing -import XCTest -final class DuckDBDriverTests: XCTestCase { - private var driver: DuckDBDriver? +private func connectedDuckDB() async throws -> DuckDBBackedDriver { + let driver = DuckDBBackedDriver(source: .inMemory) + try await driver.connect() + return driver +} - override func setUp() async throws { - let driver = DuckDBDriver(source: .inMemory) - try await driver.connect() - self.driver = driver - } +private func scratchDirectory(_ name: String) throws -> URL { + let directory = FileManager.default.temporaryDirectory + .appendingPathComponent("\(name)-\(UUID().uuidString)", isDirectory: true) + try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true) + return directory +} - func testMissingFileIsAnErrorAndCreatesNothing() async throws { +struct DuckDBDriverFileTests { + @Test("A missing file is an error and creates nothing") + func missingFileIsAnError() async throws { let missing = FileManager.default.temporaryDirectory .appendingPathComponent("duckdb-missing-\(UUID().uuidString).duckdb") - let fileDriver = DuckDBDriver(source: .file(missing)) - - do { - try await fileDriver.connect() - XCTFail("Opening a missing DuckDB file must fail") - } catch { - XCTAssertEqual( - error as? LocalDatabaseFileError, - .unavailable(fileName: missing.lastPathComponent, reason: .missing) - ) + + await #expect(throws: LocalDatabaseFileError.unavailable(fileName: missing.lastPathComponent, reason: .missing)) { + try await DuckDBBackedDriver(source: .file(missing)).connect() } - XCTAssertFalse(FileManager.default.fileExists(atPath: missing.path)) + #expect(!FileManager.default.fileExists(atPath: missing.path)) } - func testCreatedDatabaseReopensWithItsTable() async throws { - let directory = FileManager.default.temporaryDirectory - .appendingPathComponent("duckdb-create-\(UUID().uuidString)", isDirectory: true) - try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true) + @Test("A created database reopens with its table, its file closed by the first driver's disconnect") + func createdDatabaseReopens() async throws { + let directory = try scratchDirectory("duckdb-create") defer { try? FileManager.default.removeItem(at: directory) } let file = directory.appendingPathComponent("cube.duckdb") - let creator = DuckDBDriver(source: .file(file), openMode: .createNew) + let creator = DuckDBBackedDriver(source: .file(file), openMode: .createNew) try await creator.connect() _ = try await creator.execute(query: "CREATE TABLE facts (id INTEGER, label VARCHAR)") _ = try await creator.execute(query: "INSERT INTO facts VALUES (1, 'kept')") try await creator.disconnect() - let reopened = DuckDBDriver(source: .file(file)) + let reopened = DuckDBBackedDriver(source: .file(file)) try await reopened.connect() let result = try await reopened.execute(query: "SELECT label FROM facts") try await reopened.disconnect() - XCTAssertEqual(result.rows.first?.first ?? nil, "kept") + #expect(result.rows == [["kept"]]) } - override func tearDown() async throws { - try await driver?.disconnect() - driver = nil + @Test("A database the driver creates or attaches stays readable by DuckDB 1.x") + func createdAndAttachedFilesStayOnAOneXStorageVersion() async throws { + let directory = try scratchDirectory("duckdb-storage") + defer { try? FileManager.default.removeItem(at: directory) } + let attached = directory.appendingPathComponent("side.duckdb") + + let driver = DuckDBBackedDriver(source: .file(directory.appendingPathComponent("cube.duckdb")), openMode: .createNew) + try await driver.connect() + _ = try await driver.execute(query: "CREATE TABLE facts (id INTEGER)") + _ = try await driver.execute(query: "ATTACH '\(attached.path)' AS side") + _ = try await driver.execute(query: "CREATE TABLE side.facts (id INTEGER)") + let rows = try await driver.execute(query: """ + SELECT database_name, tags['storage_version'] FROM duckdb_databases() + WHERE database_name IN ('cube', 'side') ORDER BY database_name + """).rows + try await driver.disconnect() + + #expect(rows.map { $0[0] } == ["cube", "side"]) + #expect(rows.allSatisfy { $0[1]?.hasPrefix("v1.") == true }) + } + + @Test("No extension is installed or loaded from the network on iOS") + func extensionDownloadsStayOff() async throws { + let driver = try await connectedDuckDB() + let settings = try await driver.execute(query: """ + SELECT current_setting('autoinstall_known_extensions'), current_setting('autoload_known_extensions') + """).rows + let json = try await driver.execute(query: "SELECT json_extract('{\"a\": 7}', '$.a')").rows + try await driver.disconnect() + + #expect(settings == [["false", "false"]]) + #expect(json == [["7"]]) } +} - private func streamedRows(_ driver: DuckDBDriver, _ query: String) async throws -> [[String?]] { +struct DuckDBDriverQueryTests { + private func streamedRows(_ driver: DuckDBBackedDriver, _ query: String) async throws -> [[String?]] { var rows: [[String?]] = [] for try await element in driver.executeStreaming(query: query, options: .default) { if case .row(let row) = element { @@ -71,8 +100,9 @@ final class DuckDBDriverTests: XCTestCase { return rows } - func testStreamingMatchesMaterializedAcrossTypes() async throws { - let driver = try XCTUnwrap(driver) + @Test("A streamed row reads as the materialized one for every type, a BLOB as a binary cell") + func streamingMatchesMaterialized() async throws { + let driver = try await connectedDuckDB() let query = """ SELECT 42::INTEGER AS i, @@ -94,250 +124,362 @@ final class DuckDBDriverTests: XCTestCase { """ let materialized = try await driver.execute(query: query) let streamed = try await streamedRows(driver, query) + try await driver.disconnect() - XCTAssertEqual(streamed.count, 1) - XCTAssertEqual(materialized.rows.count, 1) - // A streamed BLOB is a binary cell, as on every other engine; `execute` still carries its base64. let payload = 10 - XCTAssertEqual(streamed[0][payload], Cell.binary(byteCount: 3, ref: nil).displayString) - XCTAssertEqual(materialized.rows[0][payload], Data("abc".utf8).base64EncodedString()) + try #require(streamed.count == 1 && materialized.rows.count == 1) + #expect(streamed[0][payload] == Cell.binary(byteCount: 3, ref: nil).displayString) + // A materialized BLOB is spelled in hex, as every plugin-backed engine spells one. + #expect(materialized.rows[0][payload] == "616263") var streamedRest = streamed[0] var materializedRest = materialized.rows[0] streamedRest.remove(at: payload) materializedRest.remove(at: payload) - XCTAssertEqual(streamedRest, materializedRest, "streamed output must match the materialized path for every other type") + #expect(streamedRest == materializedRest) } - func testStreamingMultiRowOrder() async throws { - let driver = try XCTUnwrap(driver) + @Test("Rows stream in order") + func streamingMultiRowOrder() async throws { + let driver = try await connectedDuckDB() _ = try await driver.execute(query: "CREATE TABLE nums (id INTEGER, label VARCHAR)") _ = try await driver.execute(query: "INSERT INTO nums SELECT i, 'row' || i FROM range(1, 2001) t(i)") let streamed = try await streamedRows(driver, "SELECT id, label FROM nums ORDER BY id") - XCTAssertEqual(streamed.count, 2_000) - XCTAssertEqual(streamed.first, ["1", "row1"]) - XCTAssertEqual(streamed.last, ["2000", "row2000"]) + try await driver.disconnect() + + #expect(streamed.count == 2_000) + #expect(streamed.first == ["1", "row1"]) + #expect(streamed.last == ["2000", "row2000"]) } - func testExecuteRendersComplexAndScalarTypes() async throws { - let driver = try XCTUnwrap(driver) + @Test("A read is capped at the row limit and says so") + func readIsCapped() async throws { + let driver = try await connectedDuckDB() + var rows = 0 + var cappedAt: Int? + for try await element in driver.executeStreaming( + query: "SELECT i FROM range(1000) t(i)", options: StreamOptions(maxRows: 10) + ) { + switch element { + case .row: rows += 1 + case .truncated(reason: .rowCap(let cap)): cappedAt = cap + default: break + } + } + try await driver.disconnect() + + #expect(rows == 10) + #expect(cappedAt == 10) + } + + @Test("Complex and scalar types render as text") + func executeRendersComplexAndScalarTypes() async throws { + let driver = try await connectedDuckDB() let result = try await driver.execute(query: """ SELECT [1,2,3] AS lst, {'a':1,'b':2} AS strct, 12.34::DECIMAL(5,2) AS dec, - '550e8400-e29b-41d4-a716-446655440000'::UUID AS uid, DATE '2024-03-09' AS dt, - TIMESTAMP '2024-03-09 12:34:56' AS ts, 'abc'::BLOB AS payload + '550e8400-e29b-41d4-a716-446655440000'::UUID AS uid, DATE '2024-03-09' AS dt """) - XCTAssertEqual(result.rows.count, 1) - XCTAssertEqual(result.rows[0][0], "[1, 2, 3]") - XCTAssertEqual(result.rows[0][1], "{'a': 1, 'b': 2}") - XCTAssertEqual(result.rows[0][2], "12.34") - XCTAssertEqual(result.rows[0][3], "550e8400-e29b-41d4-a716-446655440000") - XCTAssertEqual(result.rows[0][4], "2024-03-09") - } + try await driver.disconnect() - func testPing() async throws { - let driver = try XCTUnwrap(driver) - let alive = try await driver.ping() - XCTAssertTrue(alive) + #expect(result.rows == [["[1, 2, 3]", "{'a': 1, 'b': 2}", "12.34", "550e8400-e29b-41d4-a716-446655440000", "2024-03-09"]]) } - func testPingInsideAnAbortedTransactionKeepsTheSession() async throws { - let driver = try XCTUnwrap(driver) - _ = try await driver.execute(query: "CREATE TABLE keep (x INTEGER)") - _ = try await driver.execute(query: "INSERT INTO keep VALUES (1)") - _ = try await driver.execute(query: "CREATE TABLE u (x INTEGER PRIMARY KEY)") - _ = try await driver.execute(query: "BEGIN TRANSACTION") - _ = try await driver.execute(query: "INSERT INTO u VALUES (1)") - do { - _ = try await driver.execute(query: "INSERT INTO u VALUES (1)") - XCTFail("A duplicate key must fail") - } catch {} - do { - _ = try await driver.execute(query: "SELECT 1") - XCTFail("An aborted DuckDB transaction must refuse a statement") - } catch {} - - let alive = try await driver.ping() - XCTAssertTrue(alive) + @Test("TIMESTAMPTZ and VARIANT render as text") + func sessionSpelledTypesRender() async throws { + let driver = try await connectedDuckDB() + let stamp = try await driver.execute(query: "SELECT TIMESTAMPTZ '2024-01-02 03:04:05+00' AS ts").rows + let variant = try await driver.execute(query: "SELECT {'a': 42, 'b': [1, 2, 3]}::VARIANT AS v").rows + try await driver.disconnect() - _ = try await driver.execute(query: "ROLLBACK") - let kept = try await driver.execute(query: "SELECT x FROM keep") - XCTAssertEqual(kept.rows.first?.first ?? nil, "1") + #expect(stamp.first?.first??.contains("2024-01-02") == true) + #expect(variant.first?.first??.contains("42") == true) } - func testPingAfterDisconnectFails() async throws { - let closed = DuckDBDriver(source: .inMemory) - try await closed.connect() - try await closed.disconnect() - do { - _ = try await closed.ping() - XCTFail("A closed DuckDB session must fail its ping") - } catch DuckDBDriverError.notConnected {} - } + @Test("A NULL reads as nil") + func nullRendersAsNil() async throws { + let driver = try await connectedDuckDB() + let result = try await driver.execute(query: "SELECT NULL AS value") + try await driver.disconnect() - func testServerVersionIsReported() async throws { - let driver = try XCTUnwrap(driver) - XCTAssertNotNil(driver.serverVersion) + #expect(result.rows == [[nil]]) } - func testCreateInsertSelect() async throws { - let driver = try XCTUnwrap(driver) + @Test("CREATE, INSERT and SELECT round-trip") + func createInsertSelect() async throws { + let driver = try await connectedDuckDB() _ = try await driver.execute(query: "CREATE TABLE items (id INTEGER PRIMARY KEY, label VARCHAR, active BOOLEAN)") _ = try await driver.execute(query: "INSERT INTO items VALUES (1, 'first', true), (2, 'second', false)") - let result = try await driver.execute(query: "SELECT id, label, active FROM items ORDER BY id") - XCTAssertEqual(result.columns.map(\.name), ["id", "label", "active"]) - XCTAssertEqual(result.rows.count, 2) - XCTAssertEqual(result.rows[0], ["1", "first", "true"]) - XCTAssertEqual(result.rows[1], ["2", "second", "false"]) - } - - func testTimestampTzRendersAsText() async throws { - let driver = try XCTUnwrap(driver) - let result = try await driver.execute(query: "SELECT TIMESTAMPTZ '2024-01-02 03:04:05+00' AS ts") - XCTAssertEqual(result.rows.count, 1) - let value = try XCTUnwrap(result.rows[0][0]) - XCTAssertTrue(value.contains("2024-01-02"), "expected rendered timestamptz, got \(value)") - } + try await driver.disconnect() - func testVariantRendersAsText() async throws { - let driver = try XCTUnwrap(driver) - let result = try await driver.execute(query: "SELECT {'a': 42, 'b': [1, 2, 3]}::VARIANT AS v") - XCTAssertEqual(result.rows.count, 1) - let value = try XCTUnwrap(result.rows[0][0]) - XCTAssertTrue(value.contains("42"), "expected rendered variant text, got \(value)") + #expect(result.columns.map(\.name) == ["id", "label", "active"]) + #expect(result.rows == [["1", "first", "true"], ["2", "second", "false"]]) } - func testStreamThrowsAnErrorRaisedAfterItsFirstChunks() async throws { - let driver = try XCTUnwrap(driver) - // A 1 MB buffer holds about 128k rows of a streaming result ahead of the reader, so the failing row lies past - // it and the error comes from a fetch rather than from executing the query. DuckDB 2.0's default is 10 MiB. + @Test("A stream whose later rows fail throws instead of ending early") + func streamThrowsALaterError() async throws { + let driver = try await connectedDuckDB() _ = try await driver.execute(query: "SET streaming_buffer_size = '1MB'") let query = "SELECT CASE WHEN i = 250000 THEN error('boom at 250000') ELSE i END AS v FROM range(250001) t(i)" - var rows = 0 - do { - for try await element in driver.executeStreaming(query: query, options: StreamOptions(maxRows: 1_000_000)) { - if case .row = element { rows += 1 } - } - XCTFail("a stream whose later rows fail must throw, not end after \(rows) rows") - } catch { - XCTAssertTrue(error.localizedDescription.contains("boom at 250000"), "unexpected error: \(error)") + + let failure = await #expect(throws: (any Error).self) { + for try await _ in driver.executeStreaming(query: query, options: StreamOptions(maxRows: 1_000_000)) {} } - XCTAssertGreaterThan(rows, 0, "the error must come from a later fetch for this test to cover it") + try await driver.disconnect() + + #expect(failure?.localizedDescription.contains("boom at 250000") == true) } - func testSupersededStreamCannotReadOrEndTheNextStream() async throws { - let actor = try XCTUnwrap(driver).actor - guard case .rowSet(_, let first) = try await actor.beginStream( - query: "SELECT i FROM range(5) t(i)", token: DuckDBStreamToken() - ) else { - return XCTFail("a SELECT must stream") + @Test("A statement sent while a stream is read leaves both whole") + func statementBesideAStream() async throws { + let driver = try await connectedDuckDB() + var iterator = driver.executeStreaming(query: "SELECT i FROM range(100000) t(i)", options: StreamOptions(maxRows: 200_000)) + .makeAsyncIterator() + _ = try await iterator.next() + let other = try await driver.execute(query: "SELECT 42") + var rows = 0 + while let element = try await iterator.next() { + if case .row = element { rows += 1 } } - guard case .rowSet(_, let second) = try await actor.beginStream( - query: "SELECT i FROM range(100, 103) t(i)", token: DuckDBStreamToken() - ) else { - return XCTFail("a SELECT must stream") + try await driver.disconnect() + + #expect(other.rows == [["42"]]) + #expect(rows == 100_000) + } + + @Test("A text of several statements is refused and runs none of them, as on the Mac") + func severalStatementsAreRefused() async throws { + let driver = try await connectedDuckDB() + await #expect(throws: (any Error).self) { + try await driver.execute(query: "CREATE TABLE never (i INTEGER); SELECT 456") } + let tables = try await driver.execute(query: "SELECT count(*) FROM duckdb_tables() WHERE table_name = 'never'") + try await driver.disconnect() - do { - _ = try await actor.fetchStreamChunk(stream: first, options: .default) - XCTFail("a superseded stream must not read the stream that replaced it") - } catch is CancellationError {} + #expect(tables.rows == [["0"]]) + } - try await actor.endStream(first) - let chunk = try await actor.fetchStreamChunk(stream: second, options: .default) - XCTAssertEqual(chunk?.map { $0.first?.displayString }, ["100", "101", "102"]) - try await actor.endStream(second) + @Test("NUL text inserts and edits by its whole primary key") + func nulTextInsertsAndEditsByItsKeyWhole() async throws { + let driver = try await connectedDuckDB() + _ = try await driver.execute(query: "CREATE TABLE notes (id VARCHAR PRIMARY KEY, body VARCHAR)") + let columns = try await driver.fetchColumns(table: "notes", schema: nil) + let key = "k\u{0}1" + let insert = try #require(SQLBuilder.buildInsert( + table: "notes", schema: nil, type: .duckdb, driver: driver, columns: ["id", "body"], values: [key, "a\u{0}b"] + )) + try await driver.executeWrite([insert, "INSERT INTO notes VALUES ('k', 'other')"]) + let inserted = try await driver.execute(query: "SELECT body FROM notes WHERE body <> 'other'") + + try await driver.executeWrite([SQLBuilder.buildUpdate( + table: "notes", schema: nil, type: .duckdb, driver: driver, + changes: [(column: "body", value: "x\u{0}y")], primaryKeys: [(column: "id", value: key)], columns: columns + )]) + let after = try await driver.execute(query: "SELECT id, body FROM notes ORDER BY id") + try await driver.disconnect() + + #expect(inserted.rows == [["a\u{0}b"]]) + #expect(after.rows == [["k", "other"], [key, "x\u{0}y"]]) } +} - func testAnotherStatementEndsTheOpenStreamAsCancelled() async throws { - let driver = try XCTUnwrap(driver) - guard case .rowSet(_, let stream) = try await driver.actor.beginStream( - query: "SELECT i FROM range(100000) t(i)", token: DuckDBStreamToken() - ) else { - return XCTFail("a SELECT must stream") - } - _ = try await driver.actor.fetchStreamChunk(stream: stream, options: .default) +struct DuckDBDriverSessionTests { + @Test("Ping answers on an open session") + func ping() async throws { + let driver = try await connectedDuckDB() + let alive = try await driver.ping() + try await driver.disconnect() - _ = try await driver.execute(query: "SELECT 42") + #expect(alive) + #expect(driver.serverVersion != nil) + } - do { - _ = try await driver.actor.fetchStreamChunk(stream: stream, options: .default) - XCTFail("a stream closed by another statement must end as cancelled") - } catch is CancellationError {} + @Test("Ping inside an aborted transaction keeps the session and its transaction") + func pingInsideAnAbortedTransaction() async throws { + let driver = try await connectedDuckDB() + _ = try await driver.execute(query: "CREATE TABLE keep (x INTEGER)") + _ = try await driver.execute(query: "INSERT INTO keep VALUES (1)") + _ = try await driver.execute(query: "CREATE TABLE u (x INTEGER PRIMARY KEY)") + _ = try await driver.execute(query: "BEGIN TRANSACTION") + _ = try await driver.execute(query: "INSERT INTO u VALUES (1)") + await #expect(throws: (any Error).self) { try await driver.execute(query: "INSERT INTO u VALUES (1)") } + await #expect(throws: (any Error).self) { try await driver.execute(query: "SELECT 1") } + + let alive = try await driver.ping() + _ = try await driver.execute(query: "ROLLBACK") + let kept = try await driver.execute(query: "SELECT x FROM keep") + try await driver.disconnect() + + #expect(alive) + #expect(kept.rows == [["1"]]) } - func testCancellingTheConsumerInterruptsTheRunningQuery() async throws { - let driver = try XCTUnwrap(driver) + @Test("Ping after a disconnect fails") + func pingAfterDisconnectFails() async throws { + let driver = try await connectedDuckDB() + try await driver.disconnect() + + await #expect(throws: (any Error).self) { _ = try await driver.ping() } + } + + @Test("Stop interrupts the running query rather than queueing behind it") + func cancellingTheConsumerInterruptsTheQuery() async throws { + let driver = try await connectedDuckDB() // About 30 seconds of work on ten cores, all of it before the first chunk is ready. - let query = "SELECT sum(i) FROM range(50000000000) t(i)" let consumer = Task { - for try await _ in driver.executeStreaming(query: query, options: .default) {} + for try await _ in driver.executeStreaming(query: "SELECT sum(i) FROM range(50000000000) t(i)", options: .default) {} } try await Task.sleep(for: .milliseconds(300)) consumer.cancel() let start = ContinuousClock.now let alive = try await driver.ping() - XCTAssertTrue(alive) - XCTAssertLessThan(ContinuousClock.now - start, .seconds(5), "the cancel must interrupt the query, not queue behind it") + let waited = ContinuousClock.now - start + try await driver.disconnect() + + #expect(alive) + #expect(waited < .seconds(5)) } - func testCancelWithoutRunningQueryIsSafe() async throws { - let driver = try XCTUnwrap(driver) + @Test("A cancel with nothing running is harmless") + func cancelWithoutRunningQueryIsSafe() async throws { + let driver = try await connectedDuckDB() try await driver.cancelCurrentQuery() let alive = try await driver.ping() - XCTAssertTrue(alive) - } + try await driver.disconnect() - func testNullRendersAsNil() async throws { - let driver = try XCTUnwrap(driver) - let result = try await driver.execute(query: "SELECT NULL AS value") - XCTAssertEqual(result.rows.count, 1) - XCTAssertNil(result.rows[0][0]) + #expect(alive) } +} - func testFetchTablesAndColumns() async throws { - let driver = try XCTUnwrap(driver) +struct DuckDBDriverCatalogTests { + @Test("Tables and columns list with their keys and nullability") + func fetchTablesAndColumns() async throws { + let driver = try await connectedDuckDB() _ = try await driver.execute(query: "CREATE TABLE people (id INTEGER PRIMARY KEY, name VARCHAR NOT NULL)") - + _ = try await driver.execute(query: "CREATE VIEW people_view AS SELECT name FROM people") let tables = try await driver.fetchTables(schema: "main") - XCTAssertTrue(tables.contains { $0.name == "people" && $0.type == .table }) - let columns = try await driver.fetchColumns(table: "people", schema: "main") - XCTAssertEqual(columns.map(\.name), ["id", "name"]) - let idColumn = try XCTUnwrap(columns.first { $0.name == "id" }) - XCTAssertTrue(idColumn.isPrimaryKey) - let nameColumn = try XCTUnwrap(columns.first { $0.name == "name" }) - XCTAssertFalse(nameColumn.isNullable) + let schemas = try await driver.fetchSchemas() + try await driver.disconnect() + + #expect(tables.contains { $0.name == "people" && $0.type == .table }) + #expect(tables.contains { $0.name == "people_view" && $0.type == .view }) + #expect(columns.map(\.name) == ["id", "name"]) + #expect(columns.map(\.isPrimaryKey) == [true, false]) + #expect(columns.map(\.isNullable) == [false, false]) + #expect(schemas.contains("main")) + } + + @Test("A schema switch moves where unqualified names read") + func switchSchema() async throws { + let driver = try await connectedDuckDB() + _ = try await driver.execute(query: "CREATE SCHEMA side") + _ = try await driver.execute(query: "CREATE TABLE side.only_here (x INTEGER)") + try await driver.switchSchema(to: "side") + let tables = try await driver.fetchTables(schema: nil) + let read = try await driver.execute(query: "SELECT count(*) FROM only_here") + let current = driver.currentSchema + try await driver.disconnect() + + #expect(current == "side") + #expect(tables.map(\.name) == ["only_here"]) + #expect(read.rows == [["0"]]) } +} - func testFetchSchemasIncludesMain() async throws { - let driver = try XCTUnwrap(driver) - let schemas = try await driver.fetchSchemas() - XCTAssertTrue(schemas.contains("main")) +struct DuckDBGridDecodeTests { + private static func read( + _ text: String, + column: String = "body", + options: StreamOptions = StreamOptions() + ) -> DuckDBGridValue { + let reader = DuckDBBackedDriver.gridReader(options: options) + var bytes = Array(text.utf8) + return bytes.withUnsafeMutableBytes { reader(column, .text(UnsafeRawBufferPointer($0))) } + } + + @Test("Long text is cut while it is decoded, keeping its length") + func longTextIsCutAtDecode() { + guard case .cut(let prefix, let totalBytes) = Self.read(String(repeating: "x", count: 1 << 20)) else { + Issue.record("a 1 MiB value must be cut as it is decoded") + return + } + #expect(prefix.utf8.count == Cell.previewByteLimit) + #expect(totalBytes == 1 << 20) + } + + @Test("A cut ends on a whole character, short text and a key column stay whole") + func cutsKeepCharactersWhole() { + let limit = Cell.previewByteLimit + let straddling = String(repeating: "a", count: limit - 1) + "e\u{301}" + String(repeating: "b", count: 100) + guard case .cut(let prefix, _) = Self.read(straddling) else { + Issue.record("text past the limit must be cut") + return + } + let keyed = StreamOptions(lazyContext: LazyContext(table: "t", primaryKeyColumns: ["id"])) + let longKey = String(repeating: "k", count: limit * 2) + + #expect(prefix == String(repeating: "a", count: limit - 1)) + #expect(Self.read("short") == .text("short")) + #expect(Self.read(longKey, column: "id", options: keyed) == .text(longKey)) } - func testViewIsReportedAsView() async throws { - let driver = try XCTUnwrap(driver) - _ = try await driver.execute(query: "CREATE TABLE base (n INTEGER)") - _ = try await driver.execute(query: "CREATE VIEW base_view AS SELECT n FROM base") + @Test("Long text the budget admits stays whole, once the budget is spent it is cut") + func budgetAdmitsLongText() { + var options = StreamOptions() + options.textBudget = TextBudget(bytes: 10_000) + let long = String(repeating: "y", count: 6_000) - let tables = try await driver.fetchTables(schema: "main") - let view = try XCTUnwrap(tables.first { $0.name == "base_view" }) - XCTAssertEqual(view.type, .view) + #expect(Self.read(long, options: options) == .admitted(long)) + guard case .cut = Self.read(long, options: options) else { + Issue.record("a value past the spent budget must be cut") + return + } } - func testBlobIsBase64Encoded() async throws { - let driver = try XCTUnwrap(driver) - let result = try await driver.execute(query: "SELECT 'abc'::BLOB AS payload") - XCTAssertEqual(result.rows[0][0], Data("abc".utf8).base64EncodedString()) + @Test("Bytes are counted, never copied") + func bytesAreCounted() { + let reader = DuckDBBackedDriver.gridReader(options: StreamOptions()) + var bytes = [UInt8](repeating: 7, count: 1 << 20) + let value = bytes.withUnsafeMutableBytes { reader("payload", .bytes(UnsafeRawBufferPointer($0))) } + + #expect(value == .bytes(count: 1 << 20)) + } + + @Test("The plugin hands the grid each large value already cut, and a BLOB as its length") + func pluginReadCutsAtDecode() async throws { + let config = DriverConnectionConfig( + host: "", port: 0, username: "", password: "", database: ":memory:", + additionalFields: ["duckdbMode": "local", "duckdbFilePath": ":memory:"] + ) + let duck = DuckDBPluginDriver(config: config) + try await duck.connect() + let options = StreamOptions() + var values: [DuckDBGridValue] = [] + for try await element in duck.pulledValues( + query: "SELECT repeat('x', 32768 + i % 2) AS body, repeat('z', 32768)::BLOB AS payload FROM range(2100) t(i)", + context: PluginStatementContext(), + reading: DuckDBBackedDriver.gridReader(options: options) + ) { + if case .rows(let batch) = element { values += batch.flatMap { $0 } } + } + await duck.close() + + #expect(values.count == 4_200) + #expect(values.allSatisfy { value in + switch value { + case .cut(let prefix, let totalBytes): prefix.utf8.count <= Cell.previewByteLimit && totalBytes >= 32_768 + case .bytes(let count): count == 32_768 + default: false + } + }) } } struct DuckDBBlobStreamingTests { @Test("A streamed BLOB is a binary cell of its byte count, with the ref every other column gets") func blobStreamsAsBinary() async throws { - let driver = DuckDBDriver(source: .inMemory) - try await driver.connect() + let driver = try await connectedDuckDB() _ = try await driver.execute(query: "CREATE TABLE files (id INTEGER PRIMARY KEY, payload BLOB)") _ = try await driver.execute(query: "INSERT INTO files VALUES (1, 'abc'::BLOB)") let options = StreamOptions(maxRows: 10, lazyContext: LazyContext(table: "files", primaryKeyColumns: ["id"])) @@ -358,22 +500,16 @@ struct DuckDBBlobStreamingTests { } struct DuckDBDriverTransactionStateTests { - private func connectedDriver() async throws -> DuckDBDriver { - let driver = DuckDBDriver(source: .inMemory) - try await driver.connect() - return driver - } - @Test("A new session holds no transaction") func idleAfterConnect() async throws { - let driver = try await connectedDriver() + let driver = try await connectedDuckDB() #expect(await driver.sessionTransactionState() == .idle) try await driver.disconnect() } @Test("BEGIN opens a transaction and COMMIT ends it") func beginThenCommit() async throws { - let driver = try await connectedDriver() + let driver = try await connectedDuckDB() _ = try await driver.execute(query: "BEGIN TRANSACTION") #expect(await driver.sessionTransactionState() == .explicitTransaction) _ = try await driver.execute(query: "COMMIT") @@ -383,7 +519,7 @@ struct DuckDBDriverTransactionStateTests { @Test("A statement that fails inside a transaction leaves it aborted until ROLLBACK") func failureInsideTransactionAborts() async throws { - let driver = try await connectedDriver() + let driver = try await connectedDuckDB() _ = try await driver.execute(query: "CREATE TABLE u (x INTEGER PRIMARY KEY)") _ = try await driver.execute(query: "BEGIN TRANSACTION") _ = try await driver.execute(query: "INSERT INTO u VALUES (1)") @@ -398,7 +534,7 @@ struct DuckDBDriverTransactionStateTests { @Test("Asking twice inside a transaction keeps it and its row for the COMMIT") func probingKeepsTheTransactionForCommit() async throws { - let driver = try await connectedDriver() + let driver = try await connectedDuckDB() _ = try await driver.execute(query: "CREATE TABLE kept (x INTEGER)") _ = try await driver.execute(query: "BEGIN TRANSACTION") _ = try await driver.execute(query: "INSERT INTO kept VALUES (1)") @@ -406,45 +542,37 @@ struct DuckDBDriverTransactionStateTests { #expect(await driver.sessionTransactionState() == .explicitTransaction) _ = try await driver.execute(query: "COMMIT") let rows = try await driver.execute(query: "SELECT x FROM kept").rows - #expect(rows == [["1"]]) try await driver.disconnect() + + #expect(rows == [["1"]]) } @Test("Asking inside a transaction commits nothing, so a ROLLBACK still undoes the row") func probingCommitsNothing() async throws { - let driver = try await connectedDriver() + let driver = try await connectedDuckDB() _ = try await driver.execute(query: "CREATE TABLE undone (x INTEGER)") _ = try await driver.execute(query: "BEGIN TRANSACTION") _ = try await driver.execute(query: "INSERT INTO undone VALUES (1)") #expect(await driver.sessionTransactionState() == .explicitTransaction) _ = try await driver.execute(query: "ROLLBACK") let rows = try await driver.execute(query: "SELECT count(*) FROM undone").rows - #expect(rows == [["0"]]) try await driver.disconnect() + + #expect(rows == [["0"]]) } - @Test("An open stream is left running and the state is not guessed") - func openStreamIsNotEnded() async throws { - let driver = try await connectedDriver() - guard case .rowSet(_, let stream) = try await driver.actor.beginStream( - query: "SELECT i FROM range(100000) t(i)", token: DuckDBStreamToken() - ) else { - Issue.record("a SELECT must stream") - return - } - _ = try await driver.actor.fetchStreamChunk(stream: stream, options: .default) - #expect(await driver.sessionTransactionState() == .unknown) - let next = try await driver.actor.fetchStreamChunk(stream: stream, options: .default) - #expect(next?.isEmpty == false) - try await driver.actor.endStream(stream) + @Test("A streamed read leaves the session idle") + func streamedReadLeavesTheSessionIdle() async throws { + let driver = try await connectedDuckDB() + for try await _ in driver.executeStreaming(query: "SELECT i FROM range(100000) t(i)", options: .default) {} #expect(await driver.sessionTransactionState() == .idle) try await driver.disconnect() } @Test("A session that is not open cannot say") func unopenedSessionIsUnknown() async throws { - #expect(await DuckDBDriver(source: .inMemory).sessionTransactionState() == .unknown) - let closed = try await connectedDriver() + #expect(await DuckDBBackedDriver(source: .inMemory).sessionTransactionState() == .unknown) + let closed = try await connectedDuckDB() try await closed.disconnect() #expect(await closed.sessionTransactionState() == .unknown) } @@ -453,85 +581,28 @@ struct DuckDBDriverTransactionStateTests { struct DuckDBTransactionProbeTests { @Test("Only DuckDB's own catalog goes on to the transaction id") func nativeCatalogIsProbedFurther() { - #expect(DuckDBTransactionProbe.state(catalogType: .value("duckdb")) == nil) - #expect(DuckDBTransactionProbe.state(catalogType: .value("DuckDB")) == nil) + #expect(DuckDBTransactionProbe.state(catalogType: .value("duckdb"), tracksOpenTransaction: false) == nil) + #expect(DuckDBTransactionProbe.state(catalogType: .value("DuckDB"), tracksOpenTransaction: true) == nil) } - @Test("Another engine's catalog is never asked for a transaction id") - func foreignCatalogIsUnknown() { - #expect(DuckDBTransactionProbe.state(catalogType: .value("sqlite")) == .unknown) - #expect(DuckDBTransactionProbe.state(catalogType: .value("postgres")) == .unknown) + @Test("Another engine's catalog answers from the statements the driver saw, never from a transaction id") + func foreignCatalogFollowsTrackedStatements() { + #expect(DuckDBTransactionProbe.state(catalogType: .value("sqlite"), tracksOpenTransaction: false) == .idle) + #expect(DuckDBTransactionProbe.state(catalogType: .value("postgres"), tracksOpenTransaction: true) == .inTransaction) } @Test("A refused catalog read is an aborted transaction, an unreadable one says nothing") func catalogRefusals() { - #expect(DuckDBTransactionProbe.state(catalogType: .abortedTransaction) == .abortedTransaction) - #expect(DuckDBTransactionProbe.state(catalogType: .unreadable) == .unknown) + #expect(DuckDBTransactionProbe.state(catalogType: .abortedTransaction, tracksOpenTransaction: false) == .abortedTransaction) + #expect(DuckDBTransactionProbe.state(catalogType: .unreadable, tracksOpenTransaction: false) == .unknown) } @Test("Two ids that differ are two statements' own transactions, the same id is one open transaction") func transactionIds() { #expect(DuckDBTransactionProbe.state(first: .value("6"), second: .value("10")) == .idle) - #expect(DuckDBTransactionProbe.state(first: .value("12"), second: .value("12")) == .explicitTransaction) - } - - @Test("An aborted reading wins, and an unreadable one says nothing") - func transactionIdRefusals() { + #expect(DuckDBTransactionProbe.state(first: .value("12"), second: .value("12")) == .inTransaction) #expect(DuckDBTransactionProbe.state(first: .abortedTransaction, second: .unreadable) == .abortedTransaction) - #expect(DuckDBTransactionProbe.state(first: .value("12"), second: .abortedTransaction) == .abortedTransaction) #expect(DuckDBTransactionProbe.state(first: .value("12"), second: .unreadable) == .unknown) - #expect(DuckDBTransactionProbe.state(first: .unreadable, second: .value("12")) == .unknown) - } -} - -struct DuckDBDriverStorageVersionTests { - @Test("A database the driver creates or attaches stays readable by DuckDB 1.x") - func createdAndAttachedFilesStayOnAOneXStorageVersion() async throws { - let directory = FileManager.default.temporaryDirectory - .appendingPathComponent("duckdb-storage-\(UUID().uuidString)", isDirectory: true) - try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true) - defer { try? FileManager.default.removeItem(at: directory) } - let attached = directory.appendingPathComponent("side.duckdb") - - let driver = DuckDBDriver(source: .file(directory.appendingPathComponent("cube.duckdb")), openMode: .createNew) - try await driver.connect() - _ = try await driver.execute(query: "CREATE TABLE facts (id INTEGER)") - _ = try await driver.execute(query: "ATTACH '\(attached.path)' AS side") - _ = try await driver.execute(query: "CREATE TABLE side.facts (id INTEGER)") - let rows = try await driver.execute(query: """ - SELECT database_name, tags['storage_version'] FROM duckdb_databases() - WHERE database_name IN ('cube', 'side') ORDER BY database_name - """).rows - try await driver.disconnect() - - #expect(rows.map { $0[0] } == ["cube", "side"]) - #expect(rows.allSatisfy { $0[1]?.hasPrefix("v1.") == true }) - } -} - -struct DuckDBNulTextTests { - @Test("NUL text inserts and edits by its whole primary key") - func nulTextInsertsAndEditsByItsKeyWhole() async throws { - let driver = DuckDBDriver(source: .inMemory) - try await driver.connect() - _ = try await driver.execute(query: "CREATE TABLE notes (id VARCHAR PRIMARY KEY, body VARCHAR)") - let columns = try await driver.fetchColumns(table: "notes", schema: nil) - let key = "k\u{0}1" - let insert = try #require(SQLBuilder.buildInsert( - table: "notes", schema: nil, type: .duckdb, driver: driver, columns: ["id", "body"], values: [key, "a\u{0}b"] - )) - try await driver.executeWrite([insert, "INSERT INTO notes VALUES ('k', 'other')"]) - let inserted = try await driver.execute(query: "SELECT body FROM notes WHERE body <> 'other'") - - try await driver.executeWrite([SQLBuilder.buildUpdate( - table: "notes", schema: nil, type: .duckdb, driver: driver, - changes: [(column: "body", value: "x\u{0}y")], primaryKeys: [(column: "id", value: key)], columns: columns - )]) - let after = try await driver.execute(query: "SELECT id, body FROM notes ORDER BY id") - - try await driver.disconnect() - #expect(inserted.rows == [["a\u{0}b"]]) - #expect(after.rows == [["k", "other"], [key, "x\u{0}y"]]) } } @@ -570,6 +641,10 @@ struct DuckDBDeepExpressionTests { return file } + private func threadCounts(_ driver: DuckDBBackedDriver) async throws -> [[String?]] { + try await driver.execute(query: "SELECT current_setting('threads'), current_setting('external_threads')").rows + } + @Test("A CHECK nested 900 deep opens, and reading its table's keys fails at the depth limit instead of overflowing") func deepCheckOpensAndItsKeysAreRefused() async throws { let directory = FileManager.default.temporaryDirectory @@ -577,9 +652,9 @@ struct DuckDBDeepExpressionTests { defer { try? FileManager.default.removeItem(at: directory) } let file = try await deepFile(in: directory) - let driver = DuckDBDriver(source: .file(file)) + let driver = DuckDBBackedDriver(source: .file(file)) try await driver.connect() - let refusal = await #expect(throws: DuckDBDriverError.self) { + let refusal = await #expect(throws: (any Error).self) { try await driver.fetchColumns(table: "t", schema: nil) } try await driver.disconnect() @@ -587,22 +662,6 @@ struct DuckDBDeepExpressionTests { #expect(refusal?.localizedDescription.contains("Max expression depth limit of 250 exceeded") == true) } - @Test("An ATTACH of a file nested 900 deep reads its catalog without overflowing") - func deepFileAttaches() async throws { - let directory = FileManager.default.temporaryDirectory - .appendingPathComponent("duckdb-deep-attach-\(UUID().uuidString)", isDirectory: true) - defer { try? FileManager.default.removeItem(at: directory) } - let file = try await deepFile(in: directory) - - let driver = DuckDBDriver(source: .inMemory) - try await driver.connect() - _ = try await driver.execute(query: "ATTACH '\(file.path)' AS deep (READ_ONLY)") - let tables = try await driver.execute(query: "SELECT table_name FROM duckdb_tables() WHERE database_name = 'deep'") - try await driver.disconnect() - - #expect(tables.rows == [["t"]]) - } - @Test("A file nested 900 deep attaches a hundred times, each read on a thread with DuckDB's stack") func deepFileAttachesRepeatedly() async throws { let directory = FileManager.default.temporaryDirectory @@ -610,17 +669,20 @@ struct DuckDBDeepExpressionTests { defer { try? FileManager.default.removeItem(at: directory) } let file = try await deepFile(in: directory) - let driver = DuckDBDriver(source: .inMemory) - try await driver.connect() + let driver = try await connectedDuckDB() + _ = try await driver.execute(query: "ATTACH '\(file.path)' AS deep (READ_ONLY)") + let tables = try await driver.execute(query: "SELECT table_name FROM duckdb_tables() WHERE database_name = 'deep'") + _ = try await driver.execute(query: "DETACH deep") for _ in 0..<100 { _ = try await driver.execute(query: "ATTACH '\(file.path)' AS deep (READ_ONLY)") _ = try await driver.execute(query: "DETACH deep") } - let threads = try await driver.execute(query: "SELECT current_setting('threads'), current_setting('external_threads')") + let threads = try await threadCounts(driver) try await driver.disconnect() let count = String(ProcessInfo.processInfo.processorCount) - #expect(threads.rows == [[count, count]]) + #expect(tables.rows == [["t"]]) + #expect(threads == [[count, count]]) } @Test( @@ -633,8 +695,7 @@ struct DuckDBDeepExpressionTests { defer { try? FileManager.default.removeItem(at: directory) } let file = try await deepFile(in: directory) - let driver = DuckDBDriver(source: .inMemory) - try await driver.connect() + let driver = try await connectedDuckDB() let base = ProcessInfo.processInfo.processorCount var counts: [[String?]] = [] for statement in [ @@ -645,11 +706,9 @@ struct DuckDBDeepExpressionTests { _ = try await driver.execute(query: "ATTACH '\(file.path)' AS deep (READ_ONLY)") _ = try await driver.execute(query: "DETACH deep") } - counts += try await driver.execute( - query: "SELECT current_setting('threads'), current_setting('external_threads')" - ).rows + counts += try await threadCounts(driver) } - let lowering = await #expect(throws: DuckDBDriverError.self) { + let lowering = await #expect(throws: (any Error).self) { try await driver.execute(query: "SET threads = \(base)") } try await driver.disconnect() @@ -659,56 +718,6 @@ struct DuckDBDeepExpressionTests { #expect(lowering?.localizedDescription.contains("external threads") == true) } - @Test( - "A text of several statements takes each raised count over before the next statement reads a deep file", - .timeLimit(.minutes(1)) - ) - func threadCountFollowsSetsInOneText() async throws { - let directory = FileManager.default.temporaryDirectory - .appendingPathComponent("duckdb-deep-text-\(UUID().uuidString)", isDirectory: true) - defer { try? FileManager.default.removeItem(at: directory) } - let file = try await deepFile(in: directory) - - let driver = DuckDBDriver(source: .inMemory) - try await driver.connect() - let base = ProcessInfo.processInfo.processorCount - let selected = try await driver.execute( - query: "SET threads = \(base + 8); SET threads = \(base + 16); SELECT 42" - ) - var threads = base + 16 - for _ in 0..<20 { - threads += 1 - _ = try await driver.execute( - query: "SET threads = \(threads); ATTACH '\(file.path)' AS deep (READ_ONLY); DETACH deep" - ) - } - _ = try await driver.execute(query: "SET threads = \(base + 48); SET lock_configuration = true") - for _ in 0..<20 { - _ = try await driver.execute(query: "ATTACH '\(file.path)' AS deep (READ_ONLY); DETACH deep") - } - let counts = try await driver.execute(query: "SELECT current_setting('threads'), current_setting('external_threads')") - try await driver.disconnect() - - #expect(selected.rows == [["42"]]) - #expect(counts.rows == [[String(base + 48), String(base + 48)]]) - } - - @Test("A text DuckDB cannot parse runs none of its statements") - func unparsedTextRunsNothing() async throws { - let driver = DuckDBDriver(source: .inMemory) - try await driver.connect() - await #expect(throws: DuckDBDriverError.self) { - try await driver.execute(query: "SET threads = 64; CREATE TABLE never (i INTEGER); SELEC 1") - } - let counts = try await driver.execute(query: "SELECT current_setting('threads'), current_setting('external_threads')") - let tables = try await driver.execute(query: "SELECT count(*) FROM duckdb_tables() WHERE table_name = 'never'") - try await driver.disconnect() - - let all = String(ProcessInfo.processInfo.processorCount) - #expect(counts.rows == [[all, all]]) - #expect(tables.rows == [["0"]]) - } - @Test( "An import whose statements raise the count and lock the configuration leaves the threads to the app", .timeLimit(.minutes(1)) @@ -726,45 +735,16 @@ struct DuckDBDeepExpressionTests { ) try "".write(to: folder.appendingPathComponent("load.sql"), atomically: true, encoding: .utf8) - let driver = DuckDBDriver(source: .inMemory) - try await driver.connect() + let driver = try await connectedDuckDB() _ = try await driver.execute(query: "IMPORT DATABASE '\(folder.path)'") for _ in 0..<20 { _ = try await driver.execute(query: "ATTACH '\(file.path)' AS deep (READ_ONLY)") _ = try await driver.execute(query: "DETACH deep") } - let counts = try await driver.execute(query: "SELECT current_setting('threads'), current_setting('external_threads')") - try await driver.disconnect() - - #expect(counts.rows == [[raised, raised]]) - } - - @Test("A SET that fails for another reason runs once") - func failedSetRunsOnce() async throws { - let driver = DuckDBDriver(source: .inMemory) - try await driver.connect() - _ = try await driver.execute(query: "CREATE SEQUENCE seq") - await #expect(throws: DuckDBDriverError.self) { - try await driver.execute( - query: "SET VARIABLE x = CASE WHEN nextval('seq') = 1 THEN error('fails once') ELSE 42 END" - ) - } - let current = try await driver.execute(query: "SELECT currval('seq')") - try await driver.disconnect() - - #expect(current.rows == [["1"]]) - } - - @Test("A text of several statements returns the result DuckDB picks for it") - func severalStatementsKeepTheirResult() async throws { - let driver = DuckDBDriver(source: .inMemory) - try await driver.connect() - let wrapped = try await driver.execute(query: "BEGIN; SELECT 123; COMMIT") - let first = try await driver.execute(query: "SELECT 123; SELECT 456") + let counts = try await threadCounts(driver) try await driver.disconnect() - #expect(wrapped.rows == [["123"]]) - #expect(first.rows == [["123"]]) + #expect(counts == [[raised, raised]]) } @Test("A locked configuration keeps DuckDB's tasks on threads with its stack") @@ -774,17 +754,31 @@ struct DuckDBDeepExpressionTests { defer { try? FileManager.default.removeItem(at: directory) } let file = try await deepFile(in: directory) - let driver = DuckDBDriver(source: .inMemory) - try await driver.connect() + let driver = try await connectedDuckDB() _ = try await driver.execute(query: "SET lock_configuration = true") for _ in 0..<20 { _ = try await driver.execute(query: "ATTACH '\(file.path)' AS deep (READ_ONLY)") _ = try await driver.execute(query: "DETACH deep") } - let counts = try await driver.execute(query: "SELECT current_setting('threads'), current_setting('external_threads')") + let counts = try await threadCounts(driver) try await driver.disconnect() let all = String(ProcessInfo.processInfo.processorCount) - #expect(counts.rows == [[all, all]]) + #expect(counts == [[all, all]]) + } + + @Test("A SET that fails for another reason runs once") + func failedSetRunsOnce() async throws { + let driver = try await connectedDuckDB() + _ = try await driver.execute(query: "CREATE SEQUENCE seq") + await #expect(throws: (any Error).self) { + try await driver.execute( + query: "SET VARIABLE x = CASE WHEN nextval('seq') = 1 THEN error('fails once') ELSE 42 END" + ) + } + let current = try await driver.execute(query: "SELECT currval('seq')") + try await driver.disconnect() + + #expect(current.rows == [["1"]]) } } diff --git a/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBReadOnlyStatementTests.swift b/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBReadOnlyStatementTests.swift index e8f985425e..4866c5821f 100644 --- a/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBReadOnlyStatementTests.swift +++ b/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBReadOnlyStatementTests.swift @@ -1,14 +1,10 @@ -// -// DuckDBReadOnlyStatementTests.swift -// TableProMobileTests -// -// Plugins/DuckDBDriverPlugin/DuckDBReadOnlyStatement.swift, compiled into this target: the Mac plugin is a registry -// plugin with no test bundle of its own. -// +// Plugins/DuckDBDriverPlugin/DuckDBReadOnlyStatement.swift, which the app compiles: the Mac plugin is a registry plugin +// with no test bundle of its own. import CDuckDB import Foundation import TableProPluginKit +@testable import TableProMobile import Testing struct DuckDBReadOnlyStatementTests { diff --git a/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBSafeModeReadOnlyTests.swift b/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBSafeModeReadOnlyTests.swift index 17535c2a15..c9dc3e93f3 100644 --- a/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBSafeModeReadOnlyTests.swift +++ b/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBSafeModeReadOnlyTests.swift @@ -1,14 +1,10 @@ -// -// DuckDBSafeModeReadOnlyTests.swift -// TableProMobileTests -// -// Plugins/DuckDBDriverPlugin/DuckDBReadOnlyStatement.swift, compiled into this target: the Mac plugin is a registry -// plugin with no test bundle of its own. -// +// Plugins/DuckDBDriverPlugin/DuckDBReadOnlyStatement.swift, which the app compiles: the Mac plugin is a registry plugin +// with no test bundle of its own. import CDuckDB import Foundation import TableProPluginKit +@testable import TableProMobile import Testing struct DuckDBSafeModeReadOnlyTests { diff --git a/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBSideEffectingBindTests.swift b/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBSideEffectingBindTests.swift index 982d0e529c..9e66576d9b 100644 --- a/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBSideEffectingBindTests.swift +++ b/apple/TableProMobile/TableProMobileTests/Drivers/DuckDBSideEffectingBindTests.swift @@ -8,14 +8,15 @@ import Testing // DuckDB 2.0 invalidates the database when a prepare's own transaction commits what its binding wrote // (core/docs/decisions/0040-duckdb-prepares-inside-a-transaction-it-runs-in.md). struct DuckDBSideEffectingBindTests { - private func connectedDriver() async throws -> DuckDBDriver { - let driver = DuckDBDriver(source: .inMemory) + private func connectedDriver() async throws -> DuckDBBackedDriver { + let driver = DuckDBBackedDriver(source: .inMemory) try await driver.connect() - _ = try await driver.execute(query: "CREATE SEQUENCE seq START 20; CREATE TABLE t AS SELECT 1 AS a") + _ = try await driver.execute(query: "CREATE SEQUENCE seq START 20") + _ = try await driver.execute(query: "CREATE TABLE t AS SELECT 1 AS a") return driver } - private func streamedRowCount(_ driver: DuckDBDriver, _ query: String) async throws -> Int { + private func streamedRowCount(_ driver: DuckDBBackedDriver, _ query: String) async throws -> Int { var count = 0 for try await element in driver.executeStreaming(query: query, options: .default) { if case .row = element { count += 1 } diff --git a/apple/TableProMobile/TableProMobileTests/Drivers/LazyCellKeyTests.swift b/apple/TableProMobile/TableProMobileTests/Drivers/LazyCellKeyTests.swift index ff6afb9c36..93cb0353c4 100644 --- a/apple/TableProMobile/TableProMobileTests/Drivers/LazyCellKeyTests.swift +++ b/apple/TableProMobile/TableProMobileTests/Drivers/LazyCellKeyTests.swift @@ -60,7 +60,7 @@ struct LazyCellKeyTests { } private static func duckDBBody(selecting query: String) async throws -> [Cell] { - let driver = DuckDBDriver(source: .inMemory) + let driver = DuckDBBackedDriver(source: .inMemory) try await driver.connect() _ = try await driver.execute(query: "CREATE TABLE notes (id INTEGER PRIMARY KEY, body VARCHAR)") _ = try await driver.execute(query: "INSERT INTO notes VALUES (7, repeat('x', 5000))") diff --git a/apple/TableProMobile/TableProMobileTests/Platform/IOSDriverFactoryLocalFileTests.swift b/apple/TableProMobile/TableProMobileTests/Platform/IOSDriverFactoryLocalFileTests.swift index 7aca7091f9..0ea8093f54 100644 --- a/apple/TableProMobile/TableProMobileTests/Platform/IOSDriverFactoryLocalFileTests.swift +++ b/apple/TableProMobile/TableProMobileTests/Platform/IOSDriverFactoryLocalFileTests.swift @@ -106,7 +106,7 @@ struct IOSDriverFactoryLocalFileTests { @Test("A bookmark left over from an earlier pick is ignored for a DuckDB file in Documents") func lingeringBookmarkIsIgnored() async throws { let file = documentsDirectory.appendingPathComponent("cube.duckdb") - let creator = DuckDBDriver(source: .file(file), openMode: .createNew) + let creator = DuckDBBackedDriver(source: .file(file), openMode: .createNew) try await creator.connect() try await creator.disconnect() let connection = DatabaseConnection(type: .duckdb, port: 0, database: file.path) diff --git a/apple/TableProMobile/TableProMobileTests/Transfer/Engines/DuckDBTransferEngineTests.swift b/apple/TableProMobile/TableProMobileTests/Transfer/Engines/DuckDBTransferEngineTests.swift index 2ebc5d5f04..cfd63c7f20 100644 --- a/apple/TableProMobile/TableProMobileTests/Transfer/Engines/DuckDBTransferEngineTests.swift +++ b/apple/TableProMobile/TableProMobileTests/Transfer/Engines/DuckDBTransferEngineTests.swift @@ -6,8 +6,8 @@ import TableProPluginKit import Testing struct DuckDBTransferEngineTests { - private func session() async throws -> DuckDBDriver { - let driver = DuckDBDriver(source: .inMemory) + private func session() async throws -> DuckDBBackedDriver { + let driver = DuckDBBackedDriver(source: .inMemory) try await driver.connect() return driver } @@ -122,13 +122,17 @@ struct DuckDBTransferEngineTests { #expect(!transfer.holdsSuspensionBlockingResource) #expect(before == "1") #expect(during == "1") - await #expect(throws: DuckDBDriverError.self) { _ = try await transfer.ping() } + await #expect(throws: (any Error).self) { _ = try await transfer.ping() } } - @Test("A grid statement on the session does not end a read the session streams for an export") + // Past the 64 batches a stream buffers, so a read that held the session's executor would never let the grid run. + @Test( + "A grid statement on the session does not end a read the session streams for an export", + .timeLimit(.minutes(1)) + ) func sessionExportSurvivesGridStatements() async throws { let driver = try await session() - _ = try await driver.execute(query: "CREATE TABLE t AS SELECT i FROM range(0, 10000) AS r(i)") + _ = try await driver.execute(query: "CREATE TABLE t AS SELECT i FROM range(0, 400000) AS r(i)") var iterator = driver.exportRows(query: "SELECT i FROM t ORDER BY i", readOnly: false).makeAsyncIterator() _ = try await iterator.next() @@ -139,6 +143,65 @@ struct DuckDBTransferEngineTests { } try await driver.disconnect() - #expect(count == 10_000) + #expect(count == 400_000) + } + + @Test( + "A transfer read paused past its buffer lets the session run, and its close ends it", + .timeLimit(.minutes(1)) + ) + func pausedTransferReadLetsTheSessionRun() async throws { + let driver = try await session() + _ = try await driver.execute(query: "CREATE TABLE big AS SELECT i FROM range(0, 400000) AS r(i)") + let transfer = try #require(try await driver.openTransferDriver() as? any ExportRowStreaming) + + var iterator = transfer.exportRows(query: "SELECT i FROM big", readOnly: false).makeAsyncIterator() + _ = try await iterator.next() + _ = try await iterator.next() + let other = try await driver.execute(query: "SELECT 42") + try await transfer.disconnect() + let after = try await driver.execute(query: "SELECT count(*) FROM big") + try await driver.disconnect() + + #expect(other.rows == [["42"]]) + #expect(after.rows == [["400000"]]) + } + + @Test("A transfer read reads every row once, a batch at a time") + func transferReadIsWhole() async throws { + let driver = try await session() + _ = try await driver.execute(query: "CREATE TABLE big AS SELECT i FROM range(0, 300000) AS r(i)") + let transfer = try #require(try await driver.openTransferDriver() as? any ExportRowStreaming) + + var rows = 0 + var sum = 0 + for try await element in transfer.exportRows(query: "SELECT i FROM big", readOnly: true) { + if case .rows(let batch) = element { + rows += batch.count + sum += batch.reduce(0) { $0 + (Int($1[0].asText ?? "") ?? 0) } + } + } + try await transfer.disconnect() + try await driver.disconnect() + + #expect(rows == 300_000) + #expect(sum == 299_999 * 300_000 / 2) + } + + @Test("Macros list from the schema the export reads, so one named alike in another schema stays out") + func macrosListFromTheExportSchema() async throws { + let driver = try await session() + _ = try await driver.execute(query: "CREATE SCHEMA other") + _ = try await driver.execute(query: "CREATE MACRO main.twin(x) AS x + 1") + _ = try await driver.execute(query: "CREATE MACRO other.twin(x) AS x + 2") + let catalog = try await driver.makeExportCatalog(context: Self.context) + + let macros = try await catalog.exportObjects(database: "", schema: nil).filter { $0.kind == .routine } + let ddl = try await catalog.fetchObjectDDL(try #require(macros.first)) + try await driver.disconnect() + + #expect(macros.map(\.name) == ["twin"]) + #expect(ddl.contains("+ 1")) + #expect(!ddl.contains("+ 2")) } } diff --git a/apple/TableProMobile/TableProMobileTests/Transfer/Engines/ExportTwinNameTests.swift b/apple/TableProMobile/TableProMobileTests/Transfer/Engines/ExportTwinNameTests.swift index 5f36ab7925..ec7731f7bc 100644 --- a/apple/TableProMobile/TableProMobileTests/Transfer/Engines/ExportTwinNameTests.swift +++ b/apple/TableProMobile/TableProMobileTests/Transfer/Engines/ExportTwinNameTests.swift @@ -41,7 +41,7 @@ struct ExportTwinNameTests { @Test("DuckDB: the export reads throw on two tables named alike in different Unicode forms") func duckDBThrowsOnTwins() async throws { - let driver = DuckDBDriver(source: .inMemory) + let driver = DuckDBBackedDriver(source: .inMemory) try await driver.connect() _ = try await driver.execute(query: "CREATE TABLE p (id INTEGER PRIMARY KEY)") _ = try await driver.execute(query: "CREATE TABLE \"\(composed)\" (id INTEGER PRIMARY KEY, r INTEGER REFERENCES p (id))") @@ -63,7 +63,7 @@ struct ExportTwinNameTests { @Test("DuckDB: only the key column is a key when another column is named alike in another Unicode form") func duckDBTwinColumnIsNotAKey() async throws { - let driver = DuckDBDriver(source: .inMemory) + let driver = DuckDBBackedDriver(source: .inMemory) try await driver.connect() _ = try await driver.execute(query: "CREATE TABLE t (\"\u{E9}\" INTEGER PRIMARY KEY, \"e\u{301}\" INTEGER, v INTEGER)") let catalog = try await driver.makeExportCatalog( diff --git a/apple/TableProMobile/project.yml b/apple/TableProMobile/project.yml index cda7b2f9ee..cf6797c09f 100644 --- a/apple/TableProMobile/project.yml +++ b/apple/TableProMobile/project.yml @@ -78,10 +78,6 @@ targets: # The socket key a Mac connection stores, so iOS refuses exactly what the Mac driver dials # through a socket. - ../Plugins/MySQLDriverPlugin/MySQLLocalSocket.swift - # The expression depth limit and the open's stack both apps open a DuckDB file with. - - ../Plugins/DuckDBDriverPlugin/DuckDBExpressionDepth.swift - # The transaction both apps prepare a DuckDB statement inside. - - ../Plugins/DuckDBDriverPlugin/DuckDBPreparedRun.swift - ../Plugins/Shared/PluginQueryTimeout.swift # The toolbar glyph rule both apps follow on and before the 26 releases. - ../TablePro/Core/Services/Infrastructure/Toolbar/ToolbarSymbols.swift @@ -99,6 +95,11 @@ targets: - Info.plist - ../Plugins/Shared/PluginConnectTimeout.swift - ../Plugins/Shared/PluginRedirectRefusingDelegate.swift + # The DuckDB plugin driver runs whole behind PluginBackedDriver; the iOS CDuckDB bridge stands in for the plugin's own. + - path: ../Plugins/DuckDBDriverPlugin + excludes: + - Info.plist + - CDuckDB/** # The MongoDB plugin driver runs behind PluginBackedDriver too; the iOS CLibMongoc bridge stands in for the # plugin's own, and the principal class stays on the Mac. - path: ../Plugins/MongoDBDriverPlugin @@ -186,11 +187,6 @@ targets: - ../Plugins/SQLiteDriverPlugin/SQLiteTemporarySchema.swift - ../Plugins/SQLiteDriverPlugin/SQLiteCheckConstraintParser.swift - ../Plugins/SQLiteDriverPlugin/SQLiteDefaultValue.swift - - ../Plugins/DuckDBDriverPlugin/DuckDBExportCatalog.swift - - ../Plugins/DuckDBDriverPlugin/DuckDBCreateTableSQL.swift - - ../Plugins/DuckDBDriverPlugin/DuckDBSchemaQueries.swift - - ../Plugins/DuckDBDriverPlugin/DuckDBIndexClauses.swift - - ../Plugins/DuckDBDriverPlugin/DuckDBLexicalFeatures.swift - ../Plugins/PostgreSQLDriverPlugin/PostgreSQLCatalogExport.swift - ../Plugins/PostgreSQLDriverPlugin/PostgreSQLCreateTableSQL.swift - ../Plugins/PostgreSQLDriverPlugin/RedshiftCatalogExport.swift @@ -389,7 +385,6 @@ targets: platform: iOS sources: - TableProMobileTests - - ../Plugins/DuckDBDriverPlugin/DuckDBReadOnlyStatement.swift dependencies: - target: TableProMobile - package: TableProCore diff --git a/apple/changelog.d/4400.fixed.md b/apple/changelog.d/4400.fixed.md new file mode 100644 index 0000000000..4a4def924d --- /dev/null +++ b/apple/changelog.d/4400.fixed.md @@ -0,0 +1 @@ +DuckDB: an empty binary value saved or imported into a BLOB column stays empty instead of turning into NULL. diff --git a/apple/scripts/build-duckdb-ios.sh b/apple/scripts/build-duckdb-ios.sh index 33002b746d..71e373ed23 100755 --- a/apple/scripts/build-duckdb-ios.sh +++ b/apple/scripts/build-duckdb-ios.sh @@ -10,7 +10,7 @@ set -euo pipefail # # DuckDB ships no official iOS binary, so we compile it from source with the # leetal/ios-cmake toolchain. The extensions in scripts/duckdb-ios-extensions.cmake -# link in statically. Automatic installs stay off at runtime (DuckDBDriver.connect): +# link in statically. Automatic installs stay off at runtime (DuckDBExtensionPolicy in the plugin): # iOS apps may not download executable code (App Store Review Guideline 2.5.2), and # this build links no way to load it. #