diff --git a/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SQLStatementClassifierTests.swift b/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SQLStatementClassifierTests.swift index aff53133bc..46a0a0ce16 100644 --- a/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SQLStatementClassifierTests.swift +++ b/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SQLStatementClassifierTests.swift @@ -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")) diff --git a/apple/Plugins/MySQLDriverPlugin/MariaDBPluginConnection.swift b/apple/Plugins/MySQLDriverPlugin/MariaDBPluginConnection.swift index 1e4ac307e2..81662838f4 100644 --- a/apple/Plugins/MySQLDriverPlugin/MariaDBPluginConnection.swift +++ b/apple/Plugins/MySQLDriverPlugin/MariaDBPluginConnection.swift @@ -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 { @@ -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 ) diff --git a/apple/Plugins/MySQLDriverPlugin/MySQLPluginDriver.swift b/apple/Plugins/MySQLDriverPlugin/MySQLPluginDriver.swift index 925c77a4ab..6da86b8e0d 100644 --- a/apple/Plugins/MySQLDriverPlugin/MySQLPluginDriver.swift +++ b/apple/Plugins/MySQLDriverPlugin/MySQLPluginDriver.swift @@ -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 } @@ -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( diff --git a/apple/Plugins/MySQLDriverPlugin/MySQLReadOnlyTransaction+Statement.swift b/apple/Plugins/MySQLDriverPlugin/MySQLReadOnlyTransaction+Statement.swift index 7e08ce8487..906e361373 100644 --- a/apple/Plugins/MySQLDriverPlugin/MySQLReadOnlyTransaction+Statement.swift +++ b/apple/Plugins/MySQLDriverPlugin/MySQLReadOnlyTransaction+Statement.swift @@ -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 } @@ -21,10 +22,12 @@ 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 } @@ -32,14 +35,20 @@ extension MySQLReadOnlyTransaction { 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( 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 { diff --git a/apple/Plugins/MySQLDriverPlugin/MySQLReadOnlyTransaction.swift b/apple/Plugins/MySQLDriverPlugin/MySQLReadOnlyTransaction.swift index 65196a14c7..7a0fe12b41 100644 --- a/apple/Plugins/MySQLDriverPlugin/MySQLReadOnlyTransaction.swift +++ b/apple/Plugins/MySQLDriverPlugin/MySQLReadOnlyTransaction.swift @@ -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: diff --git a/apple/Plugins/MySQLDriverTests/MySQLReadOnlyTransactionTests.swift b/apple/Plugins/MySQLDriverTests/MySQLReadOnlyTransactionTests.swift index ed69a8c3fa..9c90e0f14b 100644 --- a/apple/Plugins/MySQLDriverTests/MySQLReadOnlyTransactionTests.swift +++ b/apple/Plugins/MySQLDriverTests/MySQLReadOnlyTransactionTests.swift @@ -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), diff --git a/apple/Plugins/PostgreSQLDriverPlugin/LibPQDriverCore.swift b/apple/Plugins/PostgreSQLDriverPlugin/LibPQDriverCore.swift index 5db63931ba..db64ba3433 100644 --- a/apple/Plugins/PostgreSQLDriverPlugin/LibPQDriverCore.swift +++ b/apple/Plugins/PostgreSQLDriverPlugin/LibPQDriverCore.swift @@ -334,11 +334,11 @@ 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) } @@ -346,11 +346,11 @@ final class LibPQDriverCore: @unchecked Sendable { 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) } @@ -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 { @@ -431,7 +431,7 @@ final class LibPQDriverCore: @unchecked Sendable { func streamRows( query: String, - readOnly: LibPQReadOnlyTransaction.Reason? = nil + readOnly: LibPQReadOnlyTransaction.Scope? = nil ) -> AsyncThrowingStream { guard let pqConn = libpqConnection else { return AsyncThrowingStream { $0.finish(throwing: LibPQPluginError.notConnected) } @@ -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, @@ -648,7 +648,7 @@ 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) } @@ -656,8 +656,8 @@ extension LibPQBackedDriver { // 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) } @@ -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. @@ -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 { @@ -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 } @@ -728,7 +728,7 @@ 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 { @@ -736,7 +736,7 @@ extension LibPQBackedDriver { } func streamRows(query: String, context: PluginStatementContext) -> AsyncThrowingStream { - 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) } diff --git a/apple/Plugins/PostgreSQLDriverPlugin/LibPQPluginConnection.swift b/apple/Plugins/PostgreSQLDriverPlugin/LibPQPluginConnection.swift index d45c9cc798..8c32a096dd 100644 --- a/apple/Plugins/PostgreSQLDriverPlugin/LibPQPluginConnection.swift +++ b/apple/Plugins/PostgreSQLDriverPlugin/LibPQPluginConnection.swift @@ -807,7 +807,7 @@ final class LibPQPluginConnection: @unchecked Sendable { func executeReadOnlyStatement( _ statement: String, parameters: [PluginCellValue]?, - reason: LibPQReadOnlyTransaction.Reason + scope: LibPQReadOnlyTransaction.Scope ) async throws -> LibPQPluginQueryResult { let statementToRun = String(statement) let params = parameters @@ -817,7 +817,7 @@ final class LibPQPluginConnection: @unchecked Sendable { if let ended = sessionEndedBeforeSending(conn) { throw ended } return try LibPQReadOnlyTransaction.run( state: transactionStateOnQueue().sessionTransactionState, - reason: reason, + scope: scope, send: { try runReadOnlyControl($0, on: conn) } ) { guard let params else { return try executeQuerySync(statementToRun, singleStatement: true) } @@ -1613,7 +1613,7 @@ final class LibPQPluginConnection: @unchecked Sendable { // only once the whole result has been read, which is no abort at all. func streamQuery( _ query: String, - readOnly: LibPQReadOnlyTransaction.Reason? = nil + readOnly: LibPQReadOnlyTransaction.Scope? = nil ) -> AsyncThrowingStream { let queryToRun = String(query) @@ -1659,7 +1659,7 @@ final class LibPQPluginConnection: @unchecked Sendable { // The extended protocol takes one statement, so no `COMMIT; INSERT` can follow the read. try LibPQReadOnlyTransaction.run( state: transactionStateOnQueue().sessionTransactionState, - reason: readOnly, + scope: readOnly, send: { try runReadOnlyControl($0, on: conn) } ) { try streamResults(stream, singleStatement: true) @@ -1984,7 +1984,7 @@ extension LibPQPluginConnection { _ statement: String, parameters: [PluginCellValue]?, bound: LibPQReadBound, - reason: LibPQReadOnlyTransaction.Reason + scope: LibPQReadOnlyTransaction.Scope ) async throws -> LibPQPluginQueryResult { let statementToRun = String(statement) let params = parameters ?? [] @@ -1994,7 +1994,7 @@ extension LibPQPluginConnection { if let ended = sessionEndedBeforeSending(conn) { throw ended } let read = try LibPQReadOnlyTransaction.run( state: transactionStateOnQueue().sessionTransactionState, - reason: reason, + scope: scope, send: { try runReadOnlyControl($0, on: conn) } ) { if suppressServerSideCancel, diff --git a/apple/Plugins/PostgreSQLDriverPlugin/LibPQReadOnlyTransaction+Statement.swift b/apple/Plugins/PostgreSQLDriverPlugin/LibPQReadOnlyTransaction+Statement.swift index a32d2af586..e7a913a03b 100644 --- a/apple/Plugins/PostgreSQLDriverPlugin/LibPQReadOnlyTransaction+Statement.swift +++ b/apple/Plugins/PostgreSQLDriverPlugin/LibPQReadOnlyTransaction+Statement.swift @@ -7,6 +7,11 @@ import Foundation import TableProPluginKit extension LibPQReadOnlyTransaction { + struct Scope: Sendable, Equatable { + let reason: Reason + let runsInOpenTransaction: Bool + } + static var sessionNotIdle: LibPQPluginError { LibPQPluginError(message: notIdleMessage(.externalClients), sqlState: nil, detail: nil) } @@ -29,14 +34,40 @@ extension LibPQReadOnlyTransaction { reason(for: context, capabilities: capabilities) != nil } - // Inside an open transaction the wrap would make the user's own transaction read-only. + static func scope(for context: PluginStatementContext, capabilities: PluginCapabilities) -> Scope? { + reason(for: context, capabilities: capabilities).map { reason in + Scope(reason: reason, runsInOpenTransaction: context.enforcesReadOnly && !context.callsUnlistedFunction) + } + } + + static func run( + state: PluginSessionTransactionState, + scope: Scope, + send: (String) throws -> Void, + statement: () throws -> Result + ) throws -> Result { + try run( + state: state, + reason: scope.reason, + runsInOpenTransaction: scope.runsInOpenTransaction, + send: send, + statement: statement + ) + } + + // Inside an open transaction the wrap would make the user's own transaction read-only, so a session holding one runs + // a statement the host checked for unlisted function calls in it as it is. static func run( 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 { diff --git a/apple/Plugins/PostgreSQLDriverTests/LibPQBoundedReadOnlyTests.swift b/apple/Plugins/PostgreSQLDriverTests/LibPQBoundedReadOnlyTests.swift index bd41cc39a6..e994340eb2 100644 --- a/apple/Plugins/PostgreSQLDriverTests/LibPQBoundedReadOnlyTests.swift +++ b/apple/Plugins/PostgreSQLDriverTests/LibPQBoundedReadOnlyTests.swift @@ -65,7 +65,7 @@ struct LibPQBoundedReadOnlyTests { query, parameters: parameters, bound: LibPQReadBound(rowCap: rowCap, byteLimit: byteLimit), - reason: .safeMode + scope: LibPQReadOnlyTransaction.Scope(reason: .safeMode, runsInOpenTransaction: false) ) } diff --git a/apple/Plugins/PostgreSQLDriverTests/LibPQReadOnlyTransactionTests.swift b/apple/Plugins/PostgreSQLDriverTests/LibPQReadOnlyTransactionTests.swift index 6d7479e8cc..91786656ca 100644 --- a/apple/Plugins/PostgreSQLDriverTests/LibPQReadOnlyTransactionTests.swift +++ b/apple/Plugins/PostgreSQLDriverTests/LibPQReadOnlyTransactionTests.swift @@ -154,6 +154,41 @@ struct LibPQReadOnlyTransactionTests { #expect(!wire.sent.contains(Self.statement)) } + @Test( + "At Read-Only a session that is not idle runs a statement with no unlisted call in its transaction as it is", + arguments: [PluginSessionTransactionState.inTransaction, .abortedTransaction, .holdsSessionLocks, .unknown] + ) + func runsInTheOpenTransaction(state: PluginSessionTransactionState) throws { + let wire = Wire() + var checked = Self.safeModeRead + checked.callsUnlistedFunction = false + let scope = try #require(LibPQReadOnlyTransaction.scope(for: checked, capabilities: .enforcesReadOnlyMode)) + + let rows = try LibPQReadOnlyTransaction.run(state: state, scope: scope, send: wire.send) { + try wire.send(Self.statement) + return 3 + } + + #expect(rows == 3) + #expect(wire.sent == [Self.statement]) + } + + @Test("Only a Read-Only statement the host found no unlisted call in may run in an open transaction") + func openTransactionNeedsTheCheck() { + var checked = Self.safeModeRead + checked.callsUnlistedFunction = false + var external = Self.externalRead + external.callsUnlistedFunction = false + let capabilities: PluginCapabilities = [.readOnlyStatements, .enforcesReadOnlyMode] + + #expect(LibPQReadOnlyTransaction.scope(for: checked, capabilities: capabilities)?.runsInOpenTransaction == true) + #expect( + LibPQReadOnlyTransaction.scope(for: Self.safeModeRead, capabilities: capabilities)?.runsInOpenTransaction + == false + ) + #expect(LibPQReadOnlyTransaction.scope(for: external, capabilities: capabilities)?.runsInOpenTransaction == false) + } + @Test("An external read and an app read at Read-Only are wrapped; the app's own read-only marks are not") func wrapsOnlyExternalAndSafeModeReads() { let capabilities = PostgreSQLPluginDriver(config: Self.config).capabilities diff --git a/apple/Plugins/TableProPluginKit/PluginStatementContext.swift b/apple/Plugins/TableProPluginKit/PluginStatementContext.swift index 18f43a58bd..09c2b1c98c 100644 --- a/apple/Plugins/TableProPluginKit/PluginStatementContext.swift +++ b/apple/Plugins/TableProPluginKit/PluginStatementContext.swift @@ -44,6 +44,11 @@ public struct PluginStatementContext: Sendable, Equatable { // the statement in the engine's read-only mode whatever the origin, or throws. public var enforcesReadOnly = false + // False when the host read the statement and found no call off the engine's built-in function list. At + // `enforcesReadOnly`, a driver whose session holds a transaction or a lock the read-only mode would end runs such a + // statement in it as it is, which Safe Mode's function check allows, and refuses any other. + public var callsUnlistedFunction = true + // Stop reading rows once the decoded rows pass this many bytes, keeping the row that crossed it, so the host sees // the limit was reached. Nil for no limit. The host sets it on reads only, since stopping a write cancels it. public var resultByteLimit: Int? diff --git a/apple/TablePro/Core/Compare/CompareRowService.swift b/apple/TablePro/Core/Compare/CompareRowService.swift index 6244a89580..86ec0e5923 100644 --- a/apple/TablePro/Core/Compare/CompareRowService.swift +++ b/apple/TablePro/Core/Compare/CompareRowService.swift @@ -271,7 +271,8 @@ private struct SideRead: Sendable { } private func stream(_ query: String, driver: any PluginDatabaseDriver) -> AsyncThrowingStream { - guard let context else { return driver.streamRows(query: query) } + guard var context else { return driver.streamRows(query: query) } + context.readFunctionCalls(in: query, databaseType: endpoint.databaseType) return driver.streamRows(query: query, context: context) } diff --git a/apple/TablePro/Core/ObjectCopy/ObjectCopyRowCopier.swift b/apple/TablePro/Core/ObjectCopy/ObjectCopyRowCopier.swift index 5a9db9dc2e..5380089732 100644 --- a/apple/TablePro/Core/ObjectCopy/ObjectCopyRowCopier.swift +++ b/apple/TablePro/Core/ObjectCopy/ObjectCopyRowCopier.swift @@ -103,8 +103,11 @@ internal struct ObjectCopyRowCopier: Sendable { var filler = SQLWriteBatchFiller<[PluginCellValue]>(budget: budget) let cut = OSAllocatedUnfairLock(initialState: nil) // The copy's SELECT states no engine ceiling, so only a limit the driver declares applies, as for its own export query. - let rows = readContext.map { sourceDriver.streamRows(query: step.sourceQuery, context: $0) } - ?? sourceDriver.streamRows(query: step.sourceQuery) + let rows = readContext.map { context in + var context = context + context.readFunctionCalls(in: step.sourceQuery, databaseType: sourceDatabaseType) + return sourceDriver.streamRows(query: step.sourceQuery, context: context) + } ?? sourceDriver.streamRows(query: step.sourceQuery) var stream = ExportRowCut.reporting(rows, engineCeiling: nil) { limit in cut.withLock { $0 = limit } }.makeAsyncIterator() diff --git a/apple/TablePro/Core/Plugins/PluginDriverAdapter+Export.swift b/apple/TablePro/Core/Plugins/PluginDriverAdapter+Export.swift index bbab92efda..15eb32cba2 100644 --- a/apple/TablePro/Core/Plugins/PluginDriverAdapter+Export.swift +++ b/apple/TablePro/Core/Plugins/PluginDriverAdapter+Export.swift @@ -22,6 +22,7 @@ extension PluginDriverAdapter { private func streamContext(_ query: String, _ safeModeIsReadOnly: Bool) -> PluginStatementContext { var context = statementContext(query) context.enforcesReadOnly = readOnlyRunContext(safeModeIsReadOnly: safeModeIsReadOnly) != nil + context.readFunctionCalls(in: query, databaseType: connection.type) return context } } diff --git a/apple/TablePro/Core/Plugins/PluginStatementContext+Statement.swift b/apple/TablePro/Core/Plugins/PluginStatementContext+Statement.swift index d900e3ab28..0ae23fab0f 100644 --- a/apple/TablePro/Core/Plugins/PluginStatementContext+Statement.swift +++ b/apple/TablePro/Core/Plugins/PluginStatementContext+Statement.swift @@ -25,6 +25,14 @@ extension PluginStatementContext { ) -> PluginStatementContext { var context = caller context.readOnly = caller.readOnly || statement(query, databaseType: databaseType).readOnly + context.readFunctionCalls(in: query, databaseType: databaseType) return context } + + // At Read-Only a session holding a transaction runs a read in it, outside the read-only mode, when the read calls + // only built-in functions. + mutating func readFunctionCalls(in query: String, databaseType: DatabaseType) { + guard enforcesReadOnly else { return } + callsUnlistedFunction = ReadOnlyFunctionCalls.callsUnlistedFunction(query, databaseType: databaseType) + } } diff --git a/apple/TablePro/Core/Services/Execution/ExecutionGateProvider.swift b/apple/TablePro/Core/Services/Execution/ExecutionGateProvider.swift index 2d35ed2aa5..9353562da0 100644 --- a/apple/TablePro/Core/Services/Execution/ExecutionGateProvider.swift +++ b/apple/TablePro/Core/Services/Execution/ExecutionGateProvider.swift @@ -62,6 +62,28 @@ internal enum ExecutionGateProvider { ) } + // A session holding a transaction or a table lock runs a read as it is, since the read-only mode would end what it + // holds, so a function the read calls is checked as on a driver without the mode. + static func liveReadOnlyFunctionPolicy( + connectionId: UUID, + databaseType: DatabaseType, + in manager: DatabaseManager? = nil + ) async -> ReadOnlyFunctionPolicy { + let (policy, driver): (ReadOnlyFunctionPolicy, DatabaseDriver?) = await MainActor.run { + let policy = readOnlyFunctionPolicy(connectionId: connectionId, databaseType: databaseType, in: manager) + guard case .live(let driver, _) = (manager ?? .shared).connectionState(connectionId) else { + return (policy, nil) + } + return (policy, driver) + } + guard !policy.functionsCanWrite, PluginMetadataRegistry.queryFunctionsCanWrite.contains(databaseType), + let driver + else { return policy } + var live = policy + live.functionsCanWrite = await driver.heldSessionTransactionState() != .idle + return live + } + static let shared: ExecutionGate = DefaultExecutionGate( confirming: AlertOperationConfirming(), authenticating: BiometricOperationAuthenticating(), @@ -87,7 +109,7 @@ internal enum ExecutionGateProvider { } }, readOnlyFunctionPolicyResolver: { connectionId, databaseType in - await readOnlyFunctionPolicy(connectionId: connectionId, databaseType: databaseType) + await liveReadOnlyFunctionPolicy(connectionId: connectionId, databaseType: databaseType) }, bareNameCallResolver: { request, reading in await callsBareFunction(request, reading: reading) diff --git a/apple/TableProMobile/TableProMobile/Drivers/MySQLDriver.swift b/apple/TableProMobile/TableProMobile/Drivers/MySQLDriver.swift index f4fb756211..68fb65dfca 100644 --- a/apple/TableProMobile/TableProMobile/Drivers/MySQLDriver.swift +++ b/apple/TableProMobile/TableProMobile/Drivers/MySQLDriver.swift @@ -140,8 +140,7 @@ nonisolated final class MySQLDriver: DatabaseDriver, SessionDatabaseReporting, @ } static func runsReadOnlyTransactions(for databaseType: DatabaseType, banner: String?) -> Bool { - let flavor = serverFlavor(for: databaseType, banner: banner) - return flavor.enforcesReadOnlyTransactions && MySQLServerVersion.hasReadOnlyTransactions(banner: banner, flavor: flavor) + MySQLReadOnlyTransaction.isAvailable(banner: banner, flavor: serverFlavor(for: databaseType, banner: banner)) } func connect() async throws { diff --git a/apple/TableProTests/Core/ObjectCopy/ObjectCopyRowCopierTests.swift b/apple/TableProTests/Core/ObjectCopy/ObjectCopyRowCopierTests.swift index f04ead34ba..554f16d353 100644 --- a/apple/TableProTests/Core/ObjectCopy/ObjectCopyRowCopierTests.swift +++ b/apple/TableProTests/Core/ObjectCopy/ObjectCopyRowCopierTests.swift @@ -59,6 +59,13 @@ private final class CopyDriver: PluginDriverStub, @unchecked Sendable { } } + var streamContexts: [PluginStatementContext] = [] + + func streamRows(query: String, context: PluginStatementContext) -> AsyncThrowingStream { + streamContexts.append(context) + return streamRows(query: query) + } + func quoteIdentifier(_ name: String) -> String { quote(name) } func beginTransaction() async throws { transactionEvents.append("begin") } @@ -114,6 +121,19 @@ struct ObjectCopyRowCopierTests { #expect(target.executedParameters.flatMap { $0 }.count == 10) } + // A source session holding a transaction runs the copy's SELECT in it at Read-Only, which needs the call check. + @Test + func aReadOnlySourceReadSaysItCallsNoUnlistedFunction() async throws { + let source = CopyDriver() + source.streamed = rows(1) + + _ = try await ObjectCopyRowCopier(step: step(), sourceDatabaseType: .mysql, targetDatabaseType: .mysql) + .copy(from: source, to: CopyDriver(), readContext: PluginStatementContext(enforcesReadOnly: true)) { _ in } + + #expect(source.streamContexts.map { $0.enforcesReadOnly } == [true]) + #expect(source.streamContexts.map { $0.callsUnlistedFunction } == [false]) + } + /// One multi-row INSERT per batch, not one per row: that is the whole reason the copy is /// faster than exporting to a file and importing it back. @Test diff --git a/apple/TableProTests/Core/Plugins/PluginDriverAdapterStatementContextTests.swift b/apple/TableProTests/Core/Plugins/PluginDriverAdapterStatementContextTests.swift index 61889d05b5..61394989e7 100644 --- a/apple/TableProTests/Core/Plugins/PluginDriverAdapterStatementContextTests.swift +++ b/apple/TableProTests/Core/Plugins/PluginDriverAdapterStatementContextTests.swift @@ -436,6 +436,25 @@ struct PluginDriverAdapterReadOnlyModeTests { #expect(driver.contexts.allSatisfy { $0.origin == .app && !$0.readOnly }) } + @Test("At Read-Only every entry point says whether the statement calls a function off the built-in list") + func everyEntryPointReadsTheFunctionCalls() async throws { + let driver = ContextRecordingDriver(capabilities: .enforcesReadOnlyMode) + let adapter = adapter(driver) + let bounding = BoundingContextDriver() + let boundingAdapter = self.adapter(bounding) + + for query in ["SELECT purge_orders()", "SELECT count(*) FROM orders"] { + _ = try await adapter.executeUserQuery(query: query, rowCap: 100, parameters: nil, context: Self.readOnly) + _ = try await adapter.execute(query: query, context: Self.readOnly) + for try await _ in adapter.streamRows(query: query, safeModeIsReadOnly: true) {} + _ = try await boundingAdapter.executeBoundedQuery(query: query, rowCap: 10, context: Self.readOnly) + } + _ = try await adapter.executeUserQuery(query: "SELECT count(*) FROM orders", rowCap: nil, parameters: nil) + + #expect(driver.contexts.map { $0.callsUnlistedFunction } == [true, true, true, false, false, false, true]) + #expect(bounding.boundedContexts.map { $0?.callsUnlistedFunction } == [true, false]) + } + @Test("The bounded read takes the context") func boundedReadForwardsTheField() async throws { let driver = BoundingContextDriver() diff --git a/apple/TableProTests/Core/Services/Execution/ExecutionGateTests.swift b/apple/TableProTests/Core/Services/Execution/ExecutionGateTests.swift index c2112f40d1..35d8e896e3 100644 --- a/apple/TableProTests/Core/Services/Execution/ExecutionGateTests.swift +++ b/apple/TableProTests/Core/Services/Execution/ExecutionGateTests.swift @@ -1252,10 +1252,37 @@ struct ReadOnlyFunctionPolicyTests { #expect(ExecutionGateProvider.runsAtReadOnly(connection.id)) } + // The read-only mode would end what a session holds, so the read runs outside it and its calls are checked. + @Test( + "A live MySQL driver with the mode is refused the call while its session holds a transaction or a lock", + arguments: [ + (PluginSessionTransactionState.idle, false), + (.inTransaction, true), + (.abortedTransaction, true), + (.holdsSessionLocks, true), + (.unknown, true), + ] + ) + func liveSessionStateDecides(state: PluginSessionTransactionState, refused: Bool) async { + let connection = DatabaseConnection(name: "Shop", database: "shop", type: .mysql, safeModeLevel: .readOnly) + defer { DatabaseManager.shared.removeSession(for: connection.id) } + install(connection, driver: SessionStateDriver(state)) + + let policy = await ExecutionGateProvider.liveReadOnlyFunctionPolicy( + connectionId: connection.id, databaseType: .mysql + ) + + #expect(policy.functionsCanWrite == refused) + } + private func install(_ connection: DatabaseConnection, capabilities: PluginCapabilities) { + install(connection, driver: CapabilityOnlyDriver(capabilities)) + } + + private func install(_ connection: DatabaseConnection, driver: any PluginDatabaseDriver) { var session = ConnectionSession( connection: connection, - driver: PluginDriverAdapter(connection: connection, pluginDriver: CapabilityOnlyDriver(capabilities)) + driver: PluginDriverAdapter(connection: connection, pluginDriver: driver) ) session.status = .connected DatabaseManager.shared.injectSession(session, for: connection.id) @@ -1272,6 +1299,19 @@ private final class CapabilityOnlyDriver: PluginDriverStub, @unchecked Sendable var capabilities: PluginCapabilities { declared } } +private final class SessionStateDriver: PluginDriverStub, @unchecked Sendable { + private let state: PluginSessionTransactionState + + init(_ state: PluginSessionTransactionState) { + self.state = state + } + + var capabilities: PluginCapabilities { [.readOnlyStatements, .enforcesReadOnlyMode] } + var supportsTransactions: Bool { true } + + func sessionTransactionState() async -> PluginSessionTransactionState { state } +} + // The editor's request for a text the gate must tier by what the server runs, behind each executable comment form. @MainActor struct ExecutionGateExecutableCommentTests { diff --git a/apple/changelog.d/4264.fixed.1.md b/apple/changelog.d/4264.fixed.1.md new file mode 100644 index 0000000000..1f4b615872 --- /dev/null +++ b/apple/changelog.d/4264.fixed.1.md @@ -0,0 +1 @@ +Read-Only refused every query while a transaction was open, as on MySQL and MariaDB with autocommit off. diff --git a/apple/changelog.d/4264.fixed.md b/apple/changelog.d/4264.fixed.md new file mode 100644 index 0000000000..6908cd22c4 --- /dev/null +++ b/apple/changelog.d/4264.fixed.md @@ -0,0 +1 @@ +Read-Only failed every query on MySQL before 5.6.5 and MariaDB before 10.0. diff --git a/core/crates/core/src/sql_syntax/mod.rs b/core/crates/core/src/sql_syntax/mod.rs index 8cb99eabd1..6095b99886 100644 --- a/core/crates/core/src/sql_syntax/mod.rs +++ b/core/crates/core/src/sql_syntax/mod.rs @@ -13,6 +13,7 @@ mod order_by; mod outside_reach; mod parse_expression; mod parse_type; +mod read_write_mode; pub mod redis; mod reserved_words; pub mod script; @@ -35,6 +36,7 @@ pub use order_by::with_order_by; pub use outside_reach::reaches_outside_database; pub use parse_expression::{MAX_EXPRESSION_LEN, ValidatedExpression, parse_expression}; pub use parse_type::{MAX_TYPE_LEN, TypeShape, ValidatedType, parse_type}; +pub use read_write_mode::turns_read_write; pub use sort_reference::{SortReference, sort_reference}; pub use source_table::{ SourceItem, SourceName, SourceRefusal, SourceTable, same_name, source_columns_for_result, source_table, diff --git a/core/crates/core/src/sql_syntax/read_write_mode.rs b/core/crates/core/src/sql_syntax/read_write_mode.rs new file mode 100644 index 0000000000..f5216ad6bd --- /dev/null +++ b/core/crates/core/src/sql_syntax/read_write_mode.rs @@ -0,0 +1,180 @@ +use crate::sql_syntax::SqlGrammar; +use crate::sql_syntax::script::{ScriptPlan, ScriptToken}; +use crate::sql_syntax::statement_access::{ + CLIENT_SPLITS, Code, Kind, code_of, decodes_unicode_names, is, may_be_space, spelled_in_escapes, split_at_blanks, +}; +use crate::unicode_blank::is_blank; + +// `tx_read_only` is the name MariaDB and MySQL before 8.0 also take. +const READ_ONLY_SETTINGS: [&str; 3] = ["transaction_read_only", "default_transaction_read_only", "tx_read_only"]; + +// A statement that makes a transaction or the session read-write, or sets or resets a read-only setting. A function +// it calls is out of sight, so a session read-only only by its default can still be turned off. +pub fn turns_read_write(sql: &str, grammar: SqlGrammar) -> bool { + if !grammar.is_sql() { + return false; + } + if turns_as_sent(sql, grammar, CLIENT_SPLITS) { + return true; + } + let letters = matches!(grammar, SqlGrammar::PostgreSql | SqlGrammar::Sqlite); + !letters && sql.contains(may_be_space) && turns_as_sent(&sql.replace(may_be_space, " "), grammar, CLIENT_SPLITS) +} + +fn turns_as_sent(sql: &str, grammar: SqlGrammar, splits: u8) -> bool { + turns_every_way(sql, grammar) + || (splits > 0 + && ScriptPlan::client_pieces(sql, grammar) + .into_iter() + .any(|piece| turns_as_sent(piece, grammar, splits - 1))) +} + +fn turns_every_way(sql: &str, grammar: SqlGrammar) -> bool { + let Some(mut plans) = ScriptPlan::server_readings(sql, grammar) else { + return true; + }; + plans.any(|plan| { + plan.statements().iter().any(|statement| { + let tokens: Vec = plan.tokens(statement.range.clone()).collect(); + let code = code_of(sql, &tokens); + let blanks_inside = code + .iter() + .any(|token| token.kind == Kind::Word && token.text.contains(is_blank)); + turns(&code, grammar) || (blanks_inside && turns(&split_at_blanks(&code), grammar)) + }) + }) +} + +fn turns(code: &[Code<'_>], grammar: SqlGrammar) -> bool { + code.split(|token| token.kind == Kind::End) + .filter(|part| !part.is_empty()) + .any(|part| { + let Some(opener) = part.first().filter(|first| first.kind == Kind::Word) else { + return false; + }; + let sets = is(opener.text, &["SET", "RESET"]); + (is(opener.text, &["SET", "BEGIN", "START"]) && says_read_write(part)) + || (sets && part.iter().any(names_read_only_setting)) + || (sets && decodes_unicode_names(grammar) && (0..part.len()).any(|at| spelled_in_escapes(part, at))) + }) +} + +fn says_read_write(part: &[Code<'_>]) -> bool { + part.windows(2) + .any(|pair| pair[0].is_word(&["READ"]) && pair[1].is_word(&["WRITE"])) +} + +// MySQL names a variable `@@session.transaction_read_only`, `SESSION transaction_read_only`, in backquotes, or in +// double quotes under ANSI_QUOTES, which an editor session takes from the server's global sql_mode. +fn names_read_only_setting(token: &Code<'_>) -> bool { + let text = match token.kind { + Kind::Word | Kind::Quoted => token.text, + Kind::Literal => match token.text.strip_prefix('"').and_then(|text| text.strip_suffix('"')) { + Some(text) => text, + None => return false, + }, + _ => return false, + }; + let name = text + .rsplit('.') + .next() + .unwrap_or(text) + .trim_start_matches('@') + .trim_end_matches(' '); + READ_ONLY_SETTINGS.iter().any(|setting| spells(name, setting)) +} + +// MySQL looks a variable up under utf8mb3_general_ci, which folds accents and ignores trailing spaces: 8.4.13 took `SET +// SESSION tránsaction_read_only = 0` and a backquoted name ending in spaces (measured). So a non-ASCII letter may stand +// for any letter of the name. +fn spells(word: &str, name: &str) -> bool { + word.chars().count() == name.len() + && word.chars().zip(name.chars()).all(|(written, letter)| { + written.eq_ignore_ascii_case(&letter) || (!written.is_ascii() && written.is_alphabetic()) + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn statements_that_turn_a_postgresql_transaction_or_session_read_write() { + for sql in [ + "SET TRANSACTION READ WRITE", + "set transaction isolation level serializable, read write", + "SET SESSION TRANSACTION READ WRITE", + "SET LOCAL transaction_read_only = off", + "SET transaction_read_only TO 'false'", + "SET \"transaction_read_only\" = 0", + "RESET transaction_read_only", + "SET default_transaction_read_only = off", + "RESET default_transaction_read_only", + "SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE", + "BEGIN READ WRITE", + "BEGIN ISOLATION LEVEL READ COMMITTED READ WRITE", + "begin transaction read write", + "START TRANSACTION READ WRITE", + "START TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ WRITE", + "SET U&\"transaction\\005fread_only\" = off", + "SET /* why */ TRANSACTION READ -- \n WRITE", + "SELECT 1; SET TRANSACTION READ WRITE", + ] { + assert!(turns_read_write(sql, SqlGrammar::PostgreSql), "{sql}"); + } + } + + #[test] + fn statements_that_turn_a_mysql_transaction_or_session_read_write() { + for sql in [ + "START TRANSACTION READ WRITE", + "START TRANSACTION WITH CONSISTENT SNAPSHOT, READ WRITE", + "SET TRANSACTION READ WRITE", + "SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED, READ WRITE", + "SET GLOBAL TRANSACTION READ WRITE", + "SET SESSION transaction_read_only = 0", + "SET @@transaction_read_only = OFF", + "SET @@session.transaction_read_only = DEFAULT", + "SET @@LOCAL.tx_read_only = 0", + "SET @x = 1, `transaction_read_only` = OFF", + "SET PERSIST transaction_read_only = 0", + "SET STATEMENT transaction_read_only = 0 FOR SELECT 1", + "/*!50000 SET SESSION TRANSACTION READ WRITE */", + "SET\u{3000}TRANSACTION READ WRITE", + "SET SESSION tr\u{e1}nsaction_read_only = 0", + "SET SESSION \"transaction_read_only\" = 0", + "SET SESSION `transaction_read_only ` = 0", + ] { + assert!(turns_read_write(sql, SqlGrammar::MySql), "{sql}"); + } + } + + #[test] + fn isolation_levels_reads_and_read_only_modes_are_not_read_write() { + for grammar in [SqlGrammar::PostgreSql, SqlGrammar::MySql] { + for sql in [ + "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE", + "SET TRANSACTION READ ONLY", + "SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED", + "BEGIN", + "BEGIN ISOLATION LEVEL REPEATABLE READ", + "START TRANSACTION READ ONLY", + "START TRANSACTION WITH CONSISTENT SNAPSHOT", + "COMMIT", + "SELECT 'SET TRANSACTION READ WRITE'", + "SELECT read, write FROM t", + "SELECT current_setting('transaction_read_only')", + "SET search_path = public", + "SHOW transaction_read_only", + ] { + assert!(!turns_read_write(sql, grammar), "{grammar:?}: {sql}"); + } + } + } + + #[test] + fn engines_without_these_statements_answer_no() { + assert!(!turns_read_write("SET TRANSACTION READ WRITE", SqlGrammar::Redis)); + assert!(!turns_read_write("db.t.find()", SqlGrammar::Mongo)); + } +} diff --git a/core/crates/core/src/sql_syntax/statement_access.rs b/core/crates/core/src/sql_syntax/statement_access.rs index a254ad7784..3eb1484822 100644 --- a/core/crates/core/src/sql_syntax/statement_access.rs +++ b/core/crates/core/src/sql_syntax/statement_access.rs @@ -872,6 +872,33 @@ mod tests { } } + // Read-Only keeps these back on every app before the driver sees them. + #[test] + fn statements_that_turn_read_only_off_are_writes() { + for (grammar, sql) in [ + (SqlGrammar::PostgreSql, "SET TRANSACTION READ WRITE"), + (SqlGrammar::PostgreSql, "SET LOCAL transaction_read_only = off"), + ( + SqlGrammar::PostgreSql, + "SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE", + ), + (SqlGrammar::PostgreSql, "SET default_transaction_read_only = off"), + (SqlGrammar::PostgreSql, "BEGIN READ WRITE"), + (SqlGrammar::PostgreSql, "START TRANSACTION READ WRITE"), + ( + SqlGrammar::PostgreSql, + "SELECT set_config('default_transaction_read_only', 'off', false)", + ), + (SqlGrammar::MySql, "SET SESSION TRANSACTION READ WRITE"), + (SqlGrammar::MySql, "SET TRANSACTION READ WRITE"), + (SqlGrammar::MySql, "SET @@session.transaction_read_only = 0"), + (SqlGrammar::MySql, "SET tx_read_only = 0"), + (SqlGrammar::MySql, "START TRANSACTION READ WRITE"), + ] { + assert!(access(sql, grammar) >= StatementAccess::Write, "{grammar:?}: {sql}"); + } + } + #[test] fn engine_specific_writes() { for (grammar, sql) in [ diff --git a/core/crates/drivers/mysql/src/editor_run.rs b/core/crates/drivers/mysql/src/editor_run.rs index 03f712a575..a8e10a6c02 100644 --- a/core/crates/drivers/mysql/src/editor_run.rs +++ b/core/crates/drivers/mysql/src/editor_run.rs @@ -5,9 +5,13 @@ use futures_util::{Stream, TryStreamExt}; use sqlx::mysql::{MySqlColumn, MySqlConnection, MySqlQueryResult, MySqlRow}; use sqlx::{AssertSqlSafe, Either, Executor as _, Row as _, SqlSafeStr as _, Statement as _}; use tablepro_core::column::ResultColumn; -use tablepro_core::sql_syntax::script::{LexicalSettings, ScriptPlan, ScriptTokenKind}; -use tablepro_core::sql_syntax::{SourceTable, SqlGrammar, StatementAccess, source_table, statement_access}; -use tablepro_core::{DriverError, ErrorCategory, ResultEvent, ResultSink, RowBatch, RowLimit, SinkFlow, Truncation}; +use tablepro_core::sql_syntax::script::{LexicalSettings, ScriptPlan, ScriptToken, ScriptTokenKind}; +use tablepro_core::sql_syntax::{ + SourceTable, SqlGrammar, StatementAccess, source_table, statement_access, turns_read_write, +}; +use tablepro_core::{ + DriverError, ErrorCategory, ReadOnlyRefusal, ResultEvent, ResultSink, RowBatch, RowLimit, SinkFlow, Truncation, +}; use tokio_util::sync::CancellationToken; use crate::catalog::result_column; @@ -34,14 +38,16 @@ enum TextKind { pub(crate) struct EditorLink { pub connection: MySqlConnection, + pub read_only: bool, // None once a SET failed, since a KILL that stopped it may have come after it took. pub select_limit: Option, } impl EditorLink { - pub(crate) fn new(connection: MySqlConnection) -> Self { + pub(crate) fn new(connection: MySqlConnection, read_only: bool) -> Self { Self { connection, + read_only, select_limit: Some(SelectLimit::Server), } } @@ -78,6 +84,11 @@ pub(crate) async fn run_script( stopped: &CancellationToken, halt: impl Fn() -> bool, ) -> Result { + // Measured on MySQL 8.4.13 and MariaDB 11.4.13: each of these turns the session's read-only default off, and + // START TRANSACTION READ WRITE overrides it. + if link.read_only && turns_read_write(sql, SqlGrammar::MySql) { + return Err(DriverError::ReadOnly(ReadOnlyRefusal::ClientGuard)); + } let texts = script_split::texts(sql); // The table is looked up once the run is over, when only a run of one statement still has what that statement read. let trace = match texts.as_slice() { @@ -101,33 +112,51 @@ pub(crate) async fn run_script( } let stopping = || stopped.is_cancelled() || halt(); let mut halted = false; - for (text, kind) in texts.into_iter().zip(kinds) { - if emitter.gone { - break; - } - if stopping() { - halted = true; - break; - } - let results = link - .connection - .fetch_many(sqlx::raw_sql(AssertSqlSafe(text.to_owned()))); - let read = emitter - .read(results, flavour, stopped, kind == TextKind::PlainRead) - .await; - if read.is_err() { - emitter.release().await; - } - read?; - // sqlx gives an empty set as its OK alone, and the prepare's columns tell it from a statement that sends no rows. - if let Some(rows_affected) = emitter.held_back.take() { - let columns = match stopping() { - true => Vec::new(), - false => described(&mut link.connection, flavour, text).await?, - }; - emitter.answered(rows_affected, &columns).await; + // A function a read calls can turn the session's read-only default off, measured on MySQL 8.4.13 and MariaDB + // 11.4.13, so at read-only every text but a diagnostics one opens a read-only transaction. Each START commits the + // one before. + let mut in_read_only = false; + let ran: Result<(), DriverError> = async { + for (text, kind) in texts.into_iter().zip(kinds) { + if emitter.gone { + break; + } + if stopping() { + halted = true; + break; + } + if link.read_only && !reads_diagnostics(text) { + in_read_only = true; + execute(&mut link.connection, flavour, READ_ONLY_BEGIN).await?; + } + let results = link + .connection + .fetch_many(sqlx::raw_sql(AssertSqlSafe(text.to_owned()))); + let read = emitter + .read(results, flavour, stopped, kind == TextKind::PlainRead) + .await; + if read.is_err() { + emitter.release().await; + } + read?; + // sqlx gives an empty set as its OK alone, and the prepare's columns tell it from a statement that sends no rows. + if let Some(rows_affected) = emitter.held_back.take() { + let columns = match stopping() { + true => Vec::new(), + false => described(&mut link.connection, flavour, text).await?, + }; + emitter.answered(rows_affected, &columns).await; + } } + Ok(()) } + .await; + let ended = match in_read_only { + true => execute(&mut link.connection, flavour, READ_ONLY_END).await, + false => Ok(()), + }; + ran?; + ended?; Ok(RunOutcome { consumer_gone: emitter.gone, halted, @@ -135,6 +164,52 @@ pub(crate) async fn run_script( }) } +const READ_ONLY_BEGIN: &str = "START TRANSACTION READ ONLY"; +const READ_ONLY_END: &str = "ROLLBACK"; + +async fn execute( + connection: &mut MySqlConnection, + flavour: MySqlFlavour, + sql: &'static str, +) -> Result<(), DriverError> { + connection + .execute(sql) + .await + .map(drop) + .map_err(|error| map_error(&error, flavour)) +} + +// SHOW WARNINGS, SHOW ERRORS and GET DIAGNOSTICS read what the text before them left, which a ROLLBACK clears on MySQL +// 8.4 (measured), and call no function, so they run in the transaction that text opened. Every way the server may read +// the text has to say so, since a `/*!99999 ... */` or `/*M! ... */` can hide the words it is read by. +fn reads_diagnostics(text: &str) -> bool { + let Some(mut readings) = ScriptPlan::server_readings(text, SqlGrammar::MySql) else { + return false; + }; + readings.all(|plan| { + let [statement] = plan.statements() else { + return false; + }; + let code: Vec = plan + .tokens(statement.range.clone()) + .filter(|token| !token.kind.is_trivia()) + .collect(); + let named = |index: usize, names: &[&str]| { + code.get(index) + .filter(|token| token.kind == ScriptTokenKind::Word) + .and_then(|token| text.get(token.range.clone())) + .is_some_and(|word| names.iter().any(|name| word.eq_ignore_ascii_case(name))) + }; + // `COUNT(*)` is the one call either statement takes. + let calls_nothing = code.iter().enumerate().all(|(index, token)| { + token.kind != ScriptTokenKind::OpenParen || (index > 0 && named(index - 1, &["COUNT"])) + }); + let shows = named(0, &["SHOW"]) && named(1, &["WARNINGS", "ERRORS", "COUNT"]); + let gets = named(0, &["GET"]) && named(1, &["DIAGNOSTICS", "CURRENT", "STACKED"]); + calls_nothing && (shows || gets) + }) +} + // The server cuts every top-level SELECT without a LIMIT, INTO OUTFILE and locking ones too, so one of those lifts it for the run. fn wanted_select_limit(kinds: &[TextKind], limit: RowLimit) -> Option { if kinds.contains(&TextKind::CutSelect) { @@ -542,4 +617,30 @@ mod tests { Some(SelectLimit::Server) ); } + + #[test] + fn only_a_lone_diagnostics_statement_runs_in_the_transaction_before_it() { + for text in [ + "SHOW WARNINGS", + "show errors limit 2", + "SHOW COUNT(*) WARNINGS", + "GET DIAGNOSTICS @n = NUMBER", + "get current diagnostics condition 1 @m = MESSAGE_TEXT", + ] { + assert!(reads_diagnostics(text), "{text}"); + } + for text in [ + "SELECT wr()", + "SHOW TABLES", + "SHOW WARNINGS; SELECT wr()", + "SHOW WARNINGS /*!99999 ; SELECT wr() */", + "SELECT @@warning_count", + "SHOW 'x\\'; SELECT wr(); -- '", + "SHOW /*M! WARNINGS */ TABLES WHERE wr() = 1", + "SHOW /*!99999 WARNINGS */ TABLES WHERE wr() = 1", + "GET DIAGNOSTICS CONDITION wr() @m = MESSAGE_TEXT", + ] { + assert!(!reads_diagnostics(text), "{text}"); + } + } } diff --git a/core/crates/drivers/mysql/src/editor_session.rs b/core/crates/drivers/mysql/src/editor_session.rs index e8b5cd17b0..5d395d8658 100644 --- a/core/crates/drivers/mysql/src/editor_session.rs +++ b/core/crates/drivers/mysql/src/editor_session.rs @@ -79,7 +79,10 @@ impl MysqlEditorSession { Ok(Arc::new(Self { id: EditorSessionId::new(), shared: Arc::new(Shared { - held: Arc::new(tokio::sync::Mutex::new(Some(EditorLink::new(physical.connection)))), + held: Arc::new(tokio::sync::Mutex::new(Some(EditorLink::new( + physical.connection, + limits.read_only, + )))), connection_id: physical.connection_id, flavour: physical.flavour, control: ControlLink::new(endpoint), diff --git a/core/crates/drivers/mysql/tests/integration/main.rs b/core/crates/drivers/mysql/tests/integration/main.rs index 583501623f..b863505df2 100644 --- a/core/crates/drivers/mysql/tests/integration/main.rs +++ b/core/crates/drivers/mysql/tests/integration/main.rs @@ -18,6 +18,7 @@ mod lenient_server; mod local_socket; mod metadata; mod non_transactional; +mod read_only; mod round_trip; mod row_limit; mod server_time_zone; diff --git a/core/crates/drivers/mysql/tests/integration/read_only.rs b/core/crates/drivers/mysql/tests/integration/read_only.rs new file mode 100644 index 0000000000..9584cf1f2a --- /dev/null +++ b/core/crates/drivers/mysql/tests/integration/read_only.rs @@ -0,0 +1,122 @@ +//! A read-only editor session stays read-only: no statement it is sent +//! and no function a read calls makes a later statement writable. + +use tablepro_core::{DriverError, ReadOnlyRefusal, RunEnd, Value}; + +use crate::support::{FLAVOURS, connect, run, run_ok, scalar, session, setup, start, text}; + +const FUNCTIONS: [&str; 3] = [ + "CREATE TABLE t (id int PRIMARY KEY)", + "CREATE FUNCTION flip() RETURNS int NOT DETERMINISTIC MODIFIES SQL DATA \ + BEGIN SET SESSION transaction_read_only = 0; RETURN 1; END", + "CREATE FUNCTION wr() RETURNS int NOT DETERMINISTIC MODIFIES SQL DATA \ + BEGIN INSERT INTO t VALUES (9); RETURN 1; END", +]; + +fn refused_by_server(end: &RunEnd) -> bool { + matches!( + end, + RunEnd::Failed(DriverError::ReadOnly(ReadOnlyRefusal::ServerRejected(_))) + ) +} + +// Measured on MySQL 8.4.13 and MariaDB 11.4.13 with only the session's default read-only: each of these made the +// INSERT after it commit. +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +#[ignore = "requires docker"] +async fn no_statement_turns_the_session_read_write() { + for flavour in FLAVOURS { + let fixture = start(flavour).await; + let owner = connect(&fixture, false).await; + setup(owner.as_ref(), &["CREATE TABLE t (id int PRIMARY KEY)"]).await; + let reader = connect(&fixture, true).await; + let editor = session(reader.as_ref()).await; + + for turn in [ + "START TRANSACTION READ WRITE", + "start transaction with consistent snapshot, read write", + "SET TRANSACTION READ WRITE", + "SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED, READ WRITE", + "SET SESSION transaction_read_only = 0", + "SET @@session.transaction_read_only = DEFAULT", + "SET @x = 1, `transaction_read_only` = OFF", + "SET tx_read_only = 0", + "/*!50000 SET SESSION TRANSACTION READ WRITE */", + ] { + let (turned, _) = run(editor.as_ref(), turn).await; + run(editor.as_ref(), "INSERT INTO t VALUES (1)").await; + run(editor.as_ref(), "COMMIT").await; + + assert_eq!( + turned.end, + RunEnd::Failed(DriverError::ReadOnly(ReadOnlyRefusal::ClientGuard)), + "{flavour:?}: {turn}" + ); + assert_eq!( + scalar(owner.as_ref(), "SELECT count(*) FROM t").await, + Value::Int(0), + "{flavour:?}: {turn}" + ); + } + editor.close().await; + reader.close().await.expect("a close"); + owner.close().await.expect("a close"); + } +} + +// Measured on MySQL 8.4.13 and MariaDB 11.4.13: under the session's default read-only alone, `SELECT flip()` turned +// it off and the next read's `wr()` wrote. A `SELECT` passes every gate as a read. +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +#[ignore = "requires docker"] +async fn a_function_a_read_calls_does_not_turn_the_session_read_write() { + for flavour in FLAVOURS { + let fixture = start(flavour).await; + let owner = connect(&fixture, false).await; + setup(owner.as_ref(), &FUNCTIONS).await; + let reader = connect(&fixture, true).await; + let editor = session(reader.as_ref()).await; + + run_ok(editor.as_ref(), "SELECT flip()").await; + run_ok(editor.as_ref(), "SELECT * FROM t").await; + let (later, _) = run(editor.as_ref(), "SELECT wr()").await; + let (same_run, _) = run(editor.as_ref(), "SELECT flip(); SELECT * FROM t; SELECT wr()").await; + let (one_text, _) = run( + editor.as_ref(), + "DELIMITER //\nSELECT flip(); SELECT wr()//\nDELIMITER ;", + ) + .await; + + assert!(refused_by_server(&later.end), "{flavour:?}: {:?}", later.end); + assert!(refused_by_server(&same_run.end), "{flavour:?}: {:?}", same_run.end); + assert!(refused_by_server(&one_text.end), "{flavour:?}: {:?}", one_text.end); + assert_eq!( + scalar(owner.as_ref(), "SELECT count(*) FROM t").await, + Value::Int(0), + "{flavour:?}" + ); + editor.close().await; + reader.close().await.expect("a close"); + owner.close().await.expect("a close"); + } +} + +// ROLLBACK clears MySQL 8.4's warnings (measured), so the read-only transaction a read runs in stays open for the +// SHOW WARNINGS after it. +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +#[ignore = "requires docker"] +async fn a_read_only_run_keeps_the_warnings_of_its_read() { + for flavour in FLAVOURS { + let fixture = start(flavour).await; + let reader = connect(&fixture, true).await; + let editor = session(reader.as_ref()).await; + + let warned = run_ok(editor.as_ref(), "SELECT CAST('x' AS SIGNED); SHOW WARNINGS").await; + let (summary, _) = run(editor.as_ref(), "SELECT 1").await; + + let codes: Vec = warned.rows().iter().filter_map(|row| row.get(1)).map(text).collect(); + assert!(codes.contains(&"1292".to_owned()), "{flavour:?}: {codes:?}"); + assert_eq!(summary.end, RunEnd::Completed, "{flavour:?}"); + editor.close().await; + reader.close().await.expect("a close"); + } +} diff --git a/core/crates/drivers/postgres/src/editor/run.rs b/core/crates/drivers/postgres/src/editor/run.rs index cdb71ad36e..8dac4841c9 100644 --- a/core/crates/drivers/postgres/src/editor/run.rs +++ b/core/crates/drivers/postgres/src/editor/run.rs @@ -3,8 +3,10 @@ use std::sync::atomic::Ordering; use futures_util::StreamExt; use tablepro_core::sql_syntax::script::{LexicalSettings, ScriptPlan, ScriptToken}; -use tablepro_core::sql_syntax::{SourceTable, SqlGrammar}; -use tablepro_core::{DriverError, ResultEvent, ResultSink, RowBatch, RowLimit, RunEnd, SinkFlow, Truncation, Value}; +use tablepro_core::sql_syntax::{SourceTable, SqlGrammar, turns_read_write}; +use tablepro_core::{ + DriverError, ReadOnlyRefusal, ResultEvent, ResultSink, RowBatch, RowLimit, RunEnd, SinkFlow, Truncation, Value, +}; use tokio_postgres::{SimpleQueryMessage, SimpleQueryStream}; use tracing::debug; @@ -127,6 +129,11 @@ impl<'a> Run<'a> { } async fn statement(&mut self, text: &str, class: StatementClass) -> Result, Lost> { + // Until its first query the user's transaction can still be made writable, after the SET TRANSACTION READ ONLY + // the driver sends behind their BEGIN too. + if self.core.read_only && turns_read_write(text, SqlGrammar::PostgreSql) { + return Ok(Some(DriverError::ReadOnly(ReadOnlyRefusal::ClientGuard))); + } match plan(class, self.core.tracker.state(), self.core.read_only) { Flight::Refuse(error) => Ok(Some(error)), Flight::Simple(wrap) => self.simple(text, class, wrap).await, diff --git a/core/crates/drivers/postgres/tests/integration/read_only.rs b/core/crates/drivers/postgres/tests/integration/read_only.rs index 0d31733a37..e23e357647 100644 --- a/core/crates/drivers/postgres/tests/integration/read_only.rs +++ b/core/crates/drivers/postgres/tests/integration/read_only.rs @@ -60,13 +60,70 @@ async fn editor_set_default_transaction_read_only_off_does_not_escape() { let reader = connect(&fixture, true).await; let session = session(reader.as_ref()).await; - run_ok(session.as_ref(), "SET default_transaction_read_only = off").await; + let (set, _) = run(session.as_ref(), "SET default_transaction_read_only = off").await; + run_ok( + session.as_ref(), + "SELECT set_config('default_transaction_read_only', 'off', false)", + ) + .await; let (summary, _) = run(session.as_ref(), "DELETE FROM t").await; + assert_eq!( + set.end, + RunEnd::Failed(DriverError::ReadOnly(ReadOnlyRefusal::ClientGuard)) + ); assert!(refused_by_server(&summary.end), "{:?}", summary.end); assert_eq!(scalar(owner.as_ref(), "SELECT count(*) FROM t").await, Value::Int(1)); } +// Before its first query the user's transaction can still be made writable, which the driver's own SET TRANSACTION +// READ ONLY after BEGIN does not stop. +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +#[ignore = "requires docker"] +async fn editor_cannot_turn_its_transaction_read_write() { + let fixture = start().await; + let owner = connect(&fixture, false).await; + setup(owner.as_ref(), &["CREATE TABLE t (id int)", "INSERT INTO t VALUES (1)"]).await; + let reader = connect(&fixture, true).await; + let session = session(reader.as_ref()).await; + + for (begin, turn) in [ + ("BEGIN", "SET TRANSACTION READ WRITE"), + ("BEGIN", "SET LOCAL transaction_read_only = off"), + ("BEGIN", "set transaction_read_only to 'false'"), + ( + "START TRANSACTION", + "SET TRANSACTION ISOLATION LEVEL READ COMMITTED, READ WRITE", + ), + ("BEGIN", "SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE"), + ("SELECT 1", "BEGIN READ WRITE"), + ("SELECT 1", "START TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ WRITE"), + ("SELECT 1", "SET default_transaction_read_only = off"), + ] { + run_ok(session.as_ref(), begin).await; + let (turned, _) = run(session.as_ref(), turn).await; + run(session.as_ref(), "DELETE FROM t").await; + run(session.as_ref(), "COMMIT").await; + + assert_eq!( + turned.end, + RunEnd::Failed(DriverError::ReadOnly(ReadOnlyRefusal::ClientGuard)), + "{turn}" + ); + assert_eq!( + scalar(owner.as_ref(), "SELECT count(*) FROM t").await, + Value::Int(1), + "{turn}" + ); + } + let (isolation, _) = run( + session.as_ref(), + "BEGIN; SET TRANSACTION ISOLATION LEVEL SERIALIZABLE; COMMIT", + ) + .await; + assert_eq!(isolation.end, RunEnd::Completed); +} + #[tokio::test(flavor = "multi_thread", worker_threads = 2)] #[ignore = "requires docker"] async fn editor_vacuum_refused_as_read_only() { diff --git a/core/crates/ffi/src/safe_mode_gate.rs b/core/crates/ffi/src/safe_mode_gate.rs index 730dbafb1a..bd7cb5ed20 100644 --- a/core/crates/ffi/src/safe_mode_gate.rs +++ b/core/crates/ffi/src/safe_mode_gate.rs @@ -150,6 +150,31 @@ mod tests { assert_eq!(read, RunGate::default()); } + #[test] + fn read_only_keeps_back_a_statement_that_turns_read_only_off() { + for (grammar, sql) in [ + ( + SqlGrammar::PostgreSql, + "BEGIN; SET TRANSACTION READ WRITE; DELETE FROM t", + ), + ( + SqlGrammar::PostgreSql, + "SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE", + ), + ( + SqlGrammar::PostgreSql, + "SELECT set_config('default_transaction_read_only', 'off', false)", + ), + (SqlGrammar::MySql, "SET SESSION transaction_read_only = 0"), + (SqlGrammar::MySql, "START TRANSACTION READ WRITE"), + ] { + assert!( + gate(sql, grammar, SafeModeLevel::ReadOnly).refused, + "{grammar:?}: {sql}" + ); + } + } + #[test] fn a_mysql_executable_comment_is_read_as_the_server_reads_it() { // MySQL 8.0 skips the second comment past its nested `/* */` and runs the DROP after it. diff --git a/linux/changelog.d/4264.security.md b/linux/changelog.d/4264.security.md new file mode 100644 index 0000000000..f0f6a43455 --- /dev/null +++ b/linux/changelog.d/4264.security.md @@ -0,0 +1 @@ +At Read-Only, a function a query called could make a MySQL or MariaDB connection writable for the next query. diff --git a/linux/docs/drivers/mysql.md b/linux/docs/drivers/mysql.md index 3fbc382f07..31606780c1 100644 --- a/linux/docs/drivers/mysql.md +++ b/linux/docs/drivers/mysql.md @@ -98,7 +98,14 @@ A call that timed out or lost its connection is checked before the link is decla ## Read-only -`ReadOnlyEnforcement::SessionDefault`: `SET SESSION TRANSACTION READ ONLY` on every session. Saves are refused before anything is sent, and a write through generated SQL fails with 1792. At Safe Mode Read-Only the app refuses every editor statement that does not read before it is sent, `SET TRANSACTION READ WRITE` included; a function a `SELECT` calls is the server's to refuse. For a guarantee, connect with a login that has no write privileges. +`ReadOnlyEnforcement::SessionDefault`: `SET SESSION TRANSACTION READ ONLY` on every session. Saves are refused before anything is sent, and a write through generated SQL fails with 1792. At Safe Mode Read-Only the app refuses every editor statement that does not read before it is sent, `SET TRANSACTION READ WRITE` included. + +The session default alone does not hold: a stored function a `SELECT` calls can run `SET SESSION transaction_read_only = 0`, and the next statement writes (measured on MySQL 8.4.13 and MariaDB 11.4.13). So on a read-only session the editor: + +- runs each text in `START TRANSACTION READ ONLY`, ended by the next text's `START` or a `ROLLBACK` after the last, so a function's write fails with 1792 whatever the session default says. A `SHOW WARNINGS`, `SHOW ERRORS` or `GET DIAGNOSTICS` text runs in the transaction of the text before it in the same run, since MySQL 8.4 clears the warnings at `ROLLBACK`; run on its own after a read, it finds them cleared there; +- refuses a run that makes a transaction or the session read-write before sending anything: `START TRANSACTION READ WRITE`, `SET [SESSION] TRANSACTION READ WRITE`, any `SET` of `transaction_read_only` or `tx_read_only` (`tablepro_core::sql_syntax::turns_read_write`). + +A statement that ends a transaction, such as `COMMIT`, `BEGIN`, DDL, `LOCK TABLES` or a `CALL` whose procedure commits, ends the read-only transaction too, and the rest of that text runs under the session default. At Read-Only the app refuses each of them before it is sent. An export, on any connection, runs in `START TRANSACTION READ ONLY` and refuses user SQL that Safe Mode would not count as a read (`tablepro_core::sql_syntax::statement_access`). The text protocol runs every statement a text holds, so user SQL is first prepared, which the server parses with multiple statements off: a text it reads as two fails there, and one it parses but does not prepare (1295, such as some `SHOW`) still runs. A read that finds no rows takes its columns from that prepare, since sqlx gives an empty set as its OK alone, so the export still has its header. diff --git a/linux/docs/drivers/postgresql.md b/linux/docs/drivers/postgresql.md index 6d58991c0e..15ebb632e9 100644 --- a/linux/docs/drivers/postgresql.md +++ b/linux/docs/drivers/postgresql.md @@ -75,8 +75,8 @@ A call that timed out or lost its connection is checked before the link is decla - Workspace reads run in `READ ONLY` transactions, and saves are refused before anything is sent (`ReadOnly(ClientGuard)`). - In the editor, a statement run outside a transaction is wrapped in `START TRANSACTION READ ONLY` and `COMMIT`. After the user's own `BEGIN`, the driver sends `SET TRANSACTION READ ONLY`. - A statement that cannot run inside a transaction block, such as `VACUUM`, fails inside the wrapper with 25001 and is reported as refused by read-only mode. `PREPARE TRANSACTION`, `COMMIT PREPARED` and `ROLLBACK PREPARED` are refused before sending. -- `SET default_transaction_read_only = off` does not escape, because each transaction is opened read-only explicitly. -- A user's own `SET TRANSACTION READ WRITE` inside their transaction can still lift it. For a guarantee, connect with a role that cannot write. +- A statement that makes a transaction or the session read-write is refused before sending: `SET TRANSACTION READ WRITE`, `BEGIN READ WRITE`, `SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE`, and any `SET` or `RESET` of `transaction_read_only` or `default_transaction_read_only` (`tablepro_core::sql_syntax::turns_read_write`). Before its first query a transaction can still be made writable, so the `SET TRANSACTION READ ONLY` after the user's `BEGIN` alone does not hold it. An isolation level still runs. +- A session default turned off another way, such as `set_config`, does not escape, because each transaction is opened read-only explicitly, and a function cannot make a transaction writable once a query has run in it. ## Writes