Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
16 commits
Select commit Hold shift + click to select a range
0f26eff
fix(ios): name the SQL Server database in Tables tab statements and r…
datlechin Nov 13, 2026
fad62aa
docs(changelog): add D-8 and D-11 fragments
datlechin Nov 13, 2026
132d55c
test(ios): refuse a Read-Only read under LOCK TABLES in the driver, a…
datlechin Nov 13, 2026
9f54614
Merge remote-tracking branch 'origin/main' into fix/d-ios
datlechin Nov 13, 2026
4c9e658
fix(core): refuse statements that turn a read-only session read-write…
datlechin Nov 13, 2026
3380728
fix(macos): tell the driver whether a Read-Only read calls an unliste…
datlechin Nov 13, 2026
8d02743
Merge remote-tracking branch 'origin/fix/d-ios' into fix/d-ro
datlechin Nov 13, 2026
14da4ab
fix(macos): run Read-Only reads in an open transaction, and take the …
datlechin Nov 13, 2026
0dc9da1
fix: read diagnostics texts every way the server may, keep old-server…
datlechin Nov 13, 2026
edec804
fix(core): read a MySQL variable name with trailing spaces as the name
datlechin Nov 13, 2026
34a9948
Merge remote-tracking branch 'origin/main' into fix/d-ios
datlechin Nov 13, 2026
1811283
Merge remote-tracking branch 'origin/fix/d-ios' into fix/d-ro
datlechin Nov 13, 2026
9e163e3
Merge remote-tracking branch 'origin/main' into fix/d-ios
datlechin Nov 13, 2026
2eee61a
Merge remote-tracking branch 'origin/fix/d-ios' into fix/d-ro
datlechin Nov 13, 2026
2d8db56
Merge remote-tracking branch 'origin/main' into fix/d-ro
datlechin Nov 13, 2026
76ed65c
chore: changelog fragments for #4264
datlechin Nov 13, 2026
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -31,6 +31,26 @@ struct SQLStatementClassifierTests {
#expect(Self.deletesEveryRow(sql, "DuckDB"))
}

// Read-Only refuses a write on both apps before the driver sees it, so none of these reaches the server.
@Test("A statement that turns a transaction or the session read-write is a write", arguments: [
("PostgreSQL", "SET TRANSACTION READ WRITE"),
("PostgreSQL", "SET LOCAL transaction_read_only = off"),
("PostgreSQL", "SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE"),
("PostgreSQL", "SET default_transaction_read_only = off"),
("PostgreSQL", "BEGIN READ WRITE"),
("PostgreSQL", "START TRANSACTION READ WRITE"),
("PostgreSQL", "SELECT set_config('default_transaction_read_only', 'off', false)"),
("MySQL", "SET SESSION TRANSACTION READ WRITE"),
("MySQL", "SET TRANSACTION READ WRITE"),
("MySQL", "SET @@session.transaction_read_only = 0"),
("MySQL", "START TRANSACTION READ WRITE"),
("MariaDB", "SET tx_read_only = 0"),
("MariaDB", "/*!50000 SET SESSION TRANSACTION READ WRITE */"),
])
func turningReadOnlyOffIsAWrite(engine: String, sql: String) {
#expect(Self.tier(sql, engine) == .write)
}

@Test("A CockroachDB b'' string continued after a line break hides no statement")
func continuedEscapeBytesHidesNoStatement() {
#expect(Self.deletesEveryRow("SELECT b'a'\n'\\''; COMMIT; DELETE FROM orders; --'", "CockroachDB"))
Expand Down
2 changes: 2 additions & 0 deletions apple/Plugins/MySQLDriverPlugin/MariaDBPluginConnection.swift
Original file line number Diff line number Diff line change
Expand Up @@ -936,6 +936,7 @@ final class MariaDBPluginConnection: @unchecked Sendable {
return try MySQLReadOnlyTransaction.run(
state: scope.sessionState(isInTransaction),
reason: scope.reason,
runsInOpenTransaction: scope.runsInOpenTransaction,
send: { _ = try executeQuerySync($0) },
statement: {
guard let params else {
Expand Down Expand Up @@ -1511,6 +1512,7 @@ final class MariaDBPluginConnection: @unchecked Sendable {
try MySQLReadOnlyTransaction.run(
state: readOnly.sessionState(isInTransaction),
reason: readOnly.reason,
runsInOpenTransaction: readOnly.runsInOpenTransaction,
send: { _ = try executeQuerySync($0) },
statement: stream
)
Expand Down
19 changes: 14 additions & 5 deletions apple/Plugins/MySQLDriverPlugin/MySQLPluginDriver.swift
Original file line number Diff line number Diff line change
Expand Up @@ -178,7 +178,10 @@ final class MySQLPluginDriver: PluginDatabaseDriver, @unchecked Sendable {
capabilities.insert(.temporaryTables)
}
if flavor.enforcesReadOnlyTransactions {
capabilities.formUnion([.readOnlyStatements, .enforcesReadOnlyMode])
capabilities.insert(.readOnlyStatements)
}
if holdsForServer(MySQLReadOnlyTransaction.isAvailable(banner:flavor:)) {
capabilities.insert(.enforcesReadOnlyMode)
}
return capabilities
}
Expand Down Expand Up @@ -1497,11 +1500,17 @@ extension MySQLPluginDriver {
}

private func readOnlyScope(_ context: PluginStatementContext) -> MySQLReadOnlyTransaction.Scope? {
guard let reason = MySQLReadOnlyTransaction.reason(for: context, flavor: flavor) else { return nil }
let identity = serverIdentity
guard let reason = MySQLReadOnlyTransaction.reason(for: context, flavor: identity.flavor, banner: identity.banner)
else { return nil }
// The lock comes from the footprint, because the status flags never show it.
return MySQLReadOnlyTransaction.Scope(reason: reason, sessionState: { isInTransaction in
self.sessionLock.withLock { self.footprint.transactionState(isInTransaction: isInTransaction) }
})
return MySQLReadOnlyTransaction.Scope(
reason: reason,
runsInOpenTransaction: context.enforcesReadOnly && !context.callsUnlistedFunction,
sessionState: { isInTransaction in
self.sessionLock.withLock { self.footprint.transactionState(isInTransaction: isInTransaction) }
}
)
}

private func readOnlyRead(
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -10,6 +10,7 @@ extension MySQLReadOnlyTransaction {
// The session state is read on the statement's own queue, so nothing queued behind it can open a transaction first.
struct Scope: Sendable {
let reason: Reason
let runsInOpenTransaction: Bool
let sessionState: @Sendable (Bool) -> PluginSessionTransactionState
}

Expand All @@ -21,25 +22,33 @@ extension MySQLReadOnlyTransaction {
MariaDBPluginError(code: 0, message: notIdleMessage(.safeMode), sqlState: nil)
}

static func reason(for context: PluginStatementContext, flavor: MySQLServerFlavor) -> Reason? {
// An external read stays wrapped on a server too old for the mode, where the begin fails and nothing runs: no host
// check stands behind it at a writable level. Safe Mode's function check stands behind Read-Only.
static func reason(for context: PluginStatementContext, flavor: MySQLServerFlavor, banner: String? = nil) -> Reason? {
guard flavor.enforcesReadOnlyTransactions else { return nil }
if context.readOnly, context.origin == .external { return .externalClients }
if context.enforcesReadOnly { return .safeMode }
if context.enforcesReadOnly, isAvailable(banner: banner, flavor: flavor) { return .safeMode }
return nil
}

static func applies(to context: PluginStatementContext, flavor: MySQLServerFlavor) -> Bool {
reason(for: context, flavor: flavor) != nil
}

// `START TRANSACTION` would commit the user's open transaction and release their `LOCK TABLES`.
// `START TRANSACTION` would commit the user's open transaction and release their `LOCK TABLES`, so a session that
// holds either runs a statement the host checked for unlisted function calls as it is. A `SET autocommit = 0`
// session holds a transaction from its first statement on.
static func run<Result>(
state: PluginSessionTransactionState,
reason: Reason,
runsInOpenTransaction: Bool = false,
send: (String) throws -> Void,
statement: () throws -> Result
) throws -> Result {
guard state == .idle else { throw notIdle(reason) }
guard state == .idle else {
guard runsInOpenTransaction else { throw notIdle(reason) }
return try statement()
}
do {
try send(begin)
} catch {
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -21,6 +21,11 @@ nonisolated internal enum MySQLReadOnlyTransaction {
// ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION.
static let refusalCode: UInt32 = 1_792

// MySQL 5.5.62 and MariaDB 5.5.64 answer `begin` with 1064 (measured), so an older server runs a read as it is.
static func isAvailable(banner: String?, flavor: MySQLServerFlavor) -> Bool {
flavor.enforcesReadOnlyTransactions && MySQLServerVersion.hasReadOnlyTransactions(banner: banner, flavor: flavor)
}

static func notIdleMessage(_ reason: Reason) -> String {
switch reason {
case .externalClients:
Expand Down
47 changes: 47 additions & 0 deletions apple/Plugins/MySQLDriverTests/MySQLReadOnlyTransactionTests.swift
Original file line number Diff line number Diff line change
Expand Up @@ -187,6 +187,53 @@ struct MySQLReadOnlyTransactionTests {
#expect(error?.code == 1_064)
}

// A `SET autocommit = 0` session always holds a transaction, so Read-Only could otherwise run nothing there.
@Test(
"At Read-Only a session that is not idle runs a statement with no unlisted call as it is",
arguments: [PluginSessionTransactionState.inTransaction, .holdsSessionLocks, .abortedTransaction, .unknown]
)
func runsInTheOpenTransaction(state: PluginSessionTransactionState) throws {
let wire = Wire()

let rows = try MySQLReadOnlyTransaction.run(
state: state, reason: .safeMode, runsInOpenTransaction: true, send: wire.send
) {
try wire.send(Self.statement)
return 3
}

#expect(rows == 3)
#expect(wire.sent == [Self.statement])
}

@Test("An idle session still takes the read-only transaction for a statement with no unlisted call")
func idleSessionStillWraps() throws {
let wire = Wire()

try MySQLReadOnlyTransaction.run(state: .idle, reason: .safeMode, runsInOpenTransaction: true, send: wire.send) {
try wire.send(Self.statement)
}

#expect(wire.sent == ["START TRANSACTION READ ONLY", Self.statement, "ROLLBACK"])
}

// Measured on MySQL 5.5.62 and MariaDB 5.5.64: `START TRANSACTION READ ONLY` is error 1064 there. Read-Only falls
// to Safe Mode's function check; an external read keeps failing at the begin, as nothing else checks it.
@Test("A server before the READ ONLY characteristic runs a Read-Only read as it is", arguments: [
("5.5.62", MySQLServerFlavor.mysql, false),
("5.6.4-m7", .mysql, false),
("5.6.5", .mysql, true),
("8.4.13", .mysql, true),
("5.5.64-MariaDB-1~trusty", .mariadb, false),
("10.0.38-MariaDB", .mariadb, true),
("11.4.13-MariaDB-ubu2404", .mariadb, true),
])
func olderServerIsNotWrapped(banner: String, flavor: MySQLServerFlavor, wraps: Bool) {
#expect(MySQLReadOnlyTransaction.isAvailable(banner: banner, flavor: flavor) == wraps)
#expect((MySQLReadOnlyTransaction.reason(for: Self.safeModeRead, flavor: flavor, banner: banner) != nil) == wraps)
#expect(MySQLReadOnlyTransaction.reason(for: Self.externalRead, flavor: flavor, banner: banner) == .externalClients)
}

@Test("Only an external read or a Read-Only statement on MySQL or MariaDB is wrapped", arguments: [
(MySQLServerFlavor.mysql, true),
(.mariadb, true),
Expand Down
44 changes: 22 additions & 22 deletions apple/Plugins/PostgreSQLDriverPlugin/LibPQDriverCore.swift
Original file line number Diff line number Diff line change
Expand Up @@ -334,23 +334,23 @@ final class LibPQDriverCore: @unchecked Sendable {
func executeReadOnly(
query: String,
parameters: [PluginCellValue]?,
reason: LibPQReadOnlyTransaction.Reason
scope: LibPQReadOnlyTransaction.Scope
) async throws -> PluginQueryResult {
let pqConn = try connection()
let startTime = Date()
let result = try await pqConn.executeReadOnlyStatement(query, parameters: parameters, reason: reason)
let result = try await pqConn.executeReadOnlyStatement(query, parameters: parameters, scope: scope)
return Self.answer(result, since: startTime)
}

func executeBoundedReadOnly(
query: String,
parameters: [PluginCellValue]?,
bound: LibPQReadBound,
reason: LibPQReadOnlyTransaction.Reason
scope: LibPQReadOnlyTransaction.Scope
) async throws -> PluginQueryResult {
let pqConn = try connection()
let startTime = Date()
let result = try await pqConn.boundedReadOnlyStatement(query, parameters: parameters, bound: bound, reason: reason)
let result = try await pqConn.boundedReadOnlyStatement(query, parameters: parameters, bound: bound, scope: scope)
return Self.answer(result, since: startTime)
}

Expand All @@ -360,16 +360,16 @@ final class LibPQDriverCore: @unchecked Sendable {
func executeExternalStatement(
query: String,
parameters: [PluginCellValue]?,
readOnly: LibPQReadOnlyTransaction.Reason?,
readOnly: LibPQReadOnlyTransaction.Scope?,
bound: LibPQReadBound?
) async throws -> PluginQueryResult {
let pqConn = try connection()
let startTime = Date()
let result: LibPQPluginQueryResult
if let readOnly, let bound {
result = try await pqConn.boundedReadOnlyStatement(query, parameters: parameters, bound: bound, reason: readOnly)
result = try await pqConn.boundedReadOnlyStatement(query, parameters: parameters, bound: bound, scope: readOnly)
} else if let readOnly {
result = try await pqConn.executeReadOnlyStatement(query, parameters: parameters, reason: readOnly)
result = try await pqConn.executeReadOnlyStatement(query, parameters: parameters, scope: readOnly)
} else if let parameters {
result = try await pqConn.executeParameterizedQuery(query, parameters: parameters)
} else {
Expand Down Expand Up @@ -431,7 +431,7 @@ final class LibPQDriverCore: @unchecked Sendable {

func streamRows(
query: String,
readOnly: LibPQReadOnlyTransaction.Reason? = nil
readOnly: LibPQReadOnlyTransaction.Scope? = nil
) -> AsyncThrowingStream<PluginStreamElement, Error> {
guard let pqConn = libpqConnection else {
return AsyncThrowingStream { $0.finish(throwing: LibPQPluginError.notConnected) }
Expand Down Expand Up @@ -634,7 +634,7 @@ extension LibPQBackedDriver {
parameters: [PluginCellValue]?,
context: PluginStatementContext
) async throws -> PluginQueryResult {
let readOnly = readOnlyReason(context)
let readOnly = readOnlyScope(context)
if context.origin == .external {
let answer = try await core.executeExternalStatement(
query: query,
Expand All @@ -648,16 +648,16 @@ extension LibPQBackedDriver {
return try await executeUserQuery(query: query, rowCap: rowCap, parameters: parameters)
}
let answer = try await readOnlyRead(
query: query, parameters: parameters, rowCap: rowCap, context: context, reason: readOnly
query: query, parameters: parameters, rowCap: rowCap, context: context, scope: readOnly
)
return Self.capped(answer, rowCap: rowCap)
}

// An app read the host marked `readOnly` alone, a catalog read among them, has no read-only reason and keeps its pin.
// One that also sets `enforcesReadOnly` runs read-only and unpinned.
func execute(query: String, context: PluginStatementContext) async throws -> PluginQueryResult {
if let readOnly = readOnlyReason(context) {
return try await readOnlyRead(query: query, parameters: nil, rowCap: nil, context: context, reason: readOnly)
if let readOnly = readOnlyScope(context) {
return try await readOnlyRead(query: query, parameters: nil, rowCap: nil, context: context, scope: readOnly)
}
// The catalog entry runs its text as a multi-statement string, so it takes only the app's own SQL.
if context.readsCatalog, context.origin == .app { return try await catalogRead(query) }
Expand All @@ -669,14 +669,14 @@ extension LibPQBackedDriver {
parameters: [PluginCellValue],
context: PluginStatementContext
) async throws -> PluginQueryResult {
guard let readOnly = readOnlyReason(context) else {
guard let readOnly = readOnlyScope(context) else {
return try await executeParameterized(query: query, parameters: parameters)
}
return try await readOnlyRead(query: query, parameters: parameters, rowCap: nil, context: context, reason: readOnly)
return try await readOnlyRead(query: query, parameters: parameters, rowCap: nil, context: context, scope: readOnly)
}

private func readOnlyReason(_ context: PluginStatementContext) -> LibPQReadOnlyTransaction.Reason? {
LibPQReadOnlyTransaction.reason(for: context, capabilities: capabilities)
private func readOnlyScope(_ context: PluginStatementContext) -> LibPQReadOnlyTransaction.Scope? {
LibPQReadOnlyTransaction.scope(for: context, capabilities: capabilities)
}

// Bounded at the source when the caller set a row cap or a byte limit, whole otherwise.
Expand All @@ -685,12 +685,12 @@ extension LibPQBackedDriver {
parameters: [PluginCellValue]?,
rowCap: Int?,
context: PluginStatementContext,
reason: LibPQReadOnlyTransaction.Reason
scope: LibPQReadOnlyTransaction.Scope
) async throws -> PluginQueryResult {
guard let bound = LibPQReadBound.ifSet(rowCap: rowCap, byteLimit: context.resultByteLimit) else {
return try await core.executeReadOnly(query: query, parameters: parameters, reason: reason)
return try await core.executeReadOnly(query: query, parameters: parameters, scope: scope)
}
return try await core.executeBoundedReadOnly(query: query, parameters: parameters, bound: bound, reason: reason)
return try await core.executeBoundedReadOnly(query: query, parameters: parameters, bound: bound, scope: scope)
}

private static func capped(_ raw: PluginQueryResult, rowCap: Int?) -> PluginQueryResult {
Expand Down Expand Up @@ -718,7 +718,7 @@ extension LibPQBackedDriver {
rowCap: Int,
context: PluginStatementContext
) async throws -> PluginQueryResult? {
guard let readOnly = readOnlyReason(context) else {
guard let readOnly = readOnlyScope(context) else {
guard !context.enforcesReadOnly, !context.readOnly, !context.readsCatalog,
context.allowsDestructive, context.allowsServerCode
else { return nil }
Expand All @@ -728,15 +728,15 @@ extension LibPQBackedDriver {
guard context.origin == .app else {
return try await core.executeExternalStatement(query: query, parameters: nil, readOnly: readOnly, bound: bound)
}
return try await core.executeBoundedReadOnly(query: query, parameters: nil, bound: bound, reason: readOnly)
return try await core.executeBoundedReadOnly(query: query, parameters: nil, bound: bound, scope: readOnly)
}

func streamRows(query: String) -> AsyncThrowingStream<PluginStreamElement, Error> {
core.streamRows(query: query)
}

func streamRows(query: String, context: PluginStatementContext) -> AsyncThrowingStream<PluginStreamElement, Error> {
guard let readOnly = readOnlyReason(context) else { return streamRows(query: query) }
guard let readOnly = readOnlyScope(context) else { return streamRows(query: query) }
return core.streamRows(query: query, readOnly: readOnly)
}

Expand Down
Loading
Loading