From e3c7b442fe401c437ffeb7fb11e68d525d806539 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Fri, 13 Nov 2026 15:13:39 +0700 Subject: [PATCH 1/2] fix(ai): count one-item deletes as writes, keep Edit off service topics and ScyllaDB's audit log, pin dashboard tiles, and read MATCH_RECOGNIZE at Read-Only --- apple/Packages/TableProCore/Package.swift | 2 +- .../SQLBareNameCalls+Parser.swift | 78 +++++++- .../SQLReadOnlyFunctionCalls.swift | 114 +++++++++++- .../SQLRowPatternClause.swift | 136 ++++++++++++++ ...QLStatementClassifier+DataStatements.swift | 4 +- .../SQLStatementClassifier.swift | 4 +- .../SQLUnfilteredWrite.swift | 158 +++++++++++++++- .../WeaviateStatementGenerator.swift | 20 +- .../SQLBareNameCallsTests.swift | 42 +++++ .../SQLDataStatementTests.swift | 15 ++ .../SQLReadOnlyFunctionCallsTests.swift | 45 +++++ .../SurrealRecordDeleteTests.swift | 72 ++++++++ .../WeaviateStatementGeneratorTests.swift | 37 ++++ .../EtcdDriverPlugin/EtcdCommandParser.swift | 16 +- ...ueryClassifier+CommandDataStatements.swift | 18 +- .../SQL/QueryClassifier+Memcached.swift | 41 ++++- ...ueryClassifier+RequestDataStatements.swift | 4 +- .../Core/Utilities/SQL/QueryClassifier.swift | 171 +++++++++++++----- .../ViewModels/DashboardTileBoard.swift | 10 +- .../ViewModels/ServerDashboardViewModel.swift | 42 +++-- .../Autocomplete/SQLSchemaProviderTests.swift | 4 + .../EditModeDataCommandsCommandTests.swift | 47 ++++- .../EditModeDataCommandsRequestTests.swift | 24 ++- .../ExternalStatementGateTests.swift | 12 ++ .../SQL/EtcdCommandParserTests.swift | 21 ++- ...ueryClassifierEmbeddedStatementTests.swift | 11 ++ .../SQL/QueryClassifierHardeningTests.swift | 72 +++++--- .../QueryClassifierOneItemDeleteTests.swift | 112 ++++++++++++ .../ViewModels/DashboardTileBoardTests.swift | 6 +- .../DashboardTileSessionTurnTests.swift | 106 +++++++++++ .../probes/check-match-recognize-calls.sh | 91 ++++++++++ 31 files changed, 1386 insertions(+), 149 deletions(-) create mode 100644 apple/Packages/TableProCore/Sources/TableProSQLGrammar/SQLRowPatternClause.swift create mode 100644 apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SurrealRecordDeleteTests.swift create mode 100644 apple/Packages/TableProCore/Tests/TableProWeaviateClientTests/WeaviateStatementGeneratorTests.swift create mode 100644 apple/TableProTests/Core/Utilities/SQL/QueryClassifierOneItemDeleteTests.swift create mode 100644 apple/TableProTests/ViewModels/DashboardTileSessionTurnTests.swift create mode 100755 apple/scripts/probes/check-match-recognize-calls.sh diff --git a/apple/Packages/TableProCore/Package.swift b/apple/Packages/TableProCore/Package.swift index ecf8b7d0dd..e32362d417 100644 --- a/apple/Packages/TableProCore/Package.swift +++ b/apple/Packages/TableProCore/Package.swift @@ -412,7 +412,7 @@ let package = Package( ), .testTarget( name: "TableProWeaviateClientTests", - dependencies: ["TableProWeaviateClient", "TableProTLSTestFixtures"], + dependencies: ["TableProWeaviateClient", "TableProWeaviateCore", "TableProTLSTestFixtures"], path: "Tests/TableProWeaviateClientTests" ), .testTarget( diff --git a/apple/Packages/TableProCore/Sources/TableProSQLGrammar/SQLBareNameCalls+Parser.swift b/apple/Packages/TableProCore/Sources/TableProSQLGrammar/SQLBareNameCalls+Parser.swift index dc36c771ff..4c129ee6bc 100644 --- a/apple/Packages/TableProCore/Sources/TableProSQLGrammar/SQLBareNameCalls+Parser.swift +++ b/apple/Packages/TableProCore/Sources/TableProSQLGrammar/SQLBareNameCalls+Parser.swift @@ -426,10 +426,11 @@ extension SQLBareNameCalls { blocks[body].sources.append(input.named(variable)) } } - expression( - (index + 1).., block: Int, commonTables: [String: CommonTable]) { + guard let first = range.first, + let clause = SQLRowPatternClause.read(tokens, body: range, text: code.code as NSString) + else { + expression(range, block: block, commonTables: commonTables, ordersBy: false, readsAfterAs: true) + return + } + let depth = tokens[first].depth + for list in [clause.partitionBy, clause.orderBy].compactMap({ $0 }) { + expression(list, block: block, commonTables: commonTables, ordersBy: false) + } + for item in clause.measures.map({ items($0, depth: depth) }) ?? [] { + let read = measureExpression(item, depth: depth) + expression(read, block: block, commonTables: commonTables, ordersBy: false, inRowPattern: true) + } + for item in items(clause.define, depth: depth) { + let read = definedCondition(item, depth: depth) + expression(read, block: block, commonTables: commonTables, ordersBy: false, inRowPattern: true) + } + } + + private func items(_ range: Range, depth: Int) -> [Range] { + var items: [Range] = [] + var start = range.lowerBound + for index in range.lowerBound...range.upperBound + where index == range.upperBound || (tokens[index].kind == .comma && tokens[index].depth == depth) { + if start < index { items.append(start.., depth: Int) -> Range { + if let alias = item.first(where: { tokens[$0].depth == depth && word(at: $0) == "AS" }) { + return item.lowerBound.. item.lowerBound, identifier(at: last) != nil, endsOperand(at: last - 1) else { return item } + return item.lowerBound.., depth: Int) -> Range { + guard let condition = item.first(where: { tokens[$0].depth == depth && word(at: $0) == "AS" }) else { + return item + } + return (condition + 1)..) -> [String] { var names: [String] = [] @@ -586,13 +640,15 @@ extension SQLBareNameCalls { // MARK: - Expressions - // `readsAfterAs`: MATCH_RECOGNIZE's `DEFINE v AS `, where AS leads an expression, not a type. + // `readsAfterAs`: a MATCH_RECOGNIZE clause read whole, where AS also leads a DEFINE condition. `inRowPattern`: a + // MATCH_RECOGNIZE measure or condition, where RUNNING and FINAL before a call are the clause's own words. private mutating func expression( _ range: Range, block: Int, commonTables: [String: CommonTable], ordersBy: Bool, - readsAfterAs: Bool = false + readsAfterAs: Bool = false, + inRowPattern: Bool = false ) { var index = range.lowerBound let end = range.upperBound @@ -605,7 +661,10 @@ extension SQLBareNameCalls { if startsQuery(inner) { _ = queryExpression(inner, parent: block, commonTables: commonTables) } else { - expression(inner, block: block, commonTables: commonTables, ordersBy: false, readsAfterAs: readsAfterAs) + expression( + inner, block: block, commonTables: commonTables, ordersBy: false, + readsAfterAs: readsAfterAs, inRowPattern: inRowPattern + ) } index = close + 1 afterAs = false @@ -616,6 +675,11 @@ extension SQLBareNameCalls { index += 1 continue } + if inRowPattern, token.word == "RUNNING" || token.word == "FINAL", index + 2 < end, + identifier(at: index + 1) != nil, tokens[index + 2].kind == .open { + index += 1 + continue + } guard let name = identifier(at: index) else { afterAs = false index += 1 diff --git a/apple/Packages/TableProCore/Sources/TableProSQLGrammar/SQLReadOnlyFunctionCalls.swift b/apple/Packages/TableProCore/Sources/TableProSQLGrammar/SQLReadOnlyFunctionCalls.swift index 55b33b16de..4f8163d628 100644 --- a/apple/Packages/TableProCore/Sources/TableProSQLGrammar/SQLReadOnlyFunctionCalls.swift +++ b/apple/Packages/TableProCore/Sources/TableProSQLGrammar/SQLReadOnlyFunctionCalls.swift @@ -72,6 +72,12 @@ public enum SQLReadOnlyFunctionCalls { "BOOL_AND", "BOOL_OR", "EVERY", "POW", "LOG10", "PI", "RANDOM", ] + // The engines here that read MATCH_RECOGNIZE; DM8 answers it with a syntax error. Measured on Oracle 23ai: in its + // MEASURES and DEFINE these call the clause's own navigation, never a user function of that name, and + // `PATTERN (...)` is a row pattern. Elsewhere, a query nested in the clause included, each is a user's name. + static let rowPatternEngines: Set = ["Oracle"] + static let rowPatternFunctions: Set = ["PREV", "NEXT", "FIRST", "LAST", "CLASSIFIER", "MATCH_NUMBER"] + private static let oracleFamily: Set = ["Oracle", "Dameng"] private static let mysqlFamily: Set = ["MySQL", "MariaDB", "OceanBase", "TiDB", "StarRocks", "Databend"] private static let postgresFamily: Set = ["PostgreSQL", "CockroachDB", "PGlite", "KingbaseES", "Redshift"] @@ -180,6 +186,7 @@ public enum SQLReadOnlyFunctionCalls { ) -> Bool { let typeNames = Set(typeNames.map { $0.uppercased() }) let known = builtins(forDatabaseTypeId: databaseTypeId) + let readsRowPatterns = rowPatternEngines.contains(databaseTypeId) let tiering = SQLStatementTiering(databaseTypeId: databaseTypeId, readings: readings, request: nil) return readings.all.contains { grammar in SQLStatementClassifier.statements(of: sql, grammar: grammar).contains { statement in @@ -187,7 +194,13 @@ public enum SQLReadOnlyFunctionCalls { if databaseTypeId == SQLStatementTiering.surrealDB { return tiering.callsSurrealStoredCode(StatementCode(statement, grammar: grammar)) } - return statementCallsUnlistedFunction(statement, grammar: grammar, builtins: known, typeNames: typeNames) + return statementCallsUnlistedFunction( + statement, + grammar: grammar, + builtins: known, + typeNames: typeNames, + readsRowPatterns: readsRowPatterns + ) } } } @@ -196,7 +209,8 @@ public enum SQLReadOnlyFunctionCalls { _ statement: String, grammar: SQLLexicalGrammar, builtins: Set, - typeNames: Set + typeNames: Set, + readsRowPatterns: Bool ) -> Bool { // A plain EXPLAIN plans its statement without running it. if let explain = SQLExplainStatement.read(statement, grammar: grammar) { @@ -209,8 +223,19 @@ public enum SQLReadOnlyFunctionCalls { } let source = statement as NSString let code = SQLCodeProjection.code(of: statement, grammar: grammar) as NSString + let calls = SQLFunctionCallScanner.calls(in: source, code: code) var quoted: [Range]? - return SQLFunctionCallScanner.calls(in: source, code: code).contains { call in + func site(of call: SQLFunctionCallScanner.Call, nameStart: Int) -> CallSite { + let spans = quoted ?? quotedSpans(in: source, grammar: grammar) + quoted = spans + return CallSite(code: code, quotedSpans: spans, nameStart: nameStart, parenthesis: call.parenthesis) + } + let rowPatterns = readsRowPatterns + ? RowPatternClauses(source: source, code: code, grammar: grammar, calls: calls) { + site(of: $0, nameStart: $1).matches(.afterOperand) + } + : nil + return calls.contains { call in guard case .named(let name, let start) = call.callee, !quoteOpeners.contains(source.character(at: start)) else { return true } @@ -224,11 +249,86 @@ public enum SQLReadOnlyFunctionCalls { break } if builtins.contains(word) || typeNames.contains(word) || reservedWords.contains(word) { return false } + if rowPatterns?.ownsCall(named: word, at: start) == true { return false } guard let rules = syntax[word] else { return true } - let spans = quoted ?? quotedSpans(in: source, grammar: grammar) - quoted = spans - let site = CallSite(code: code, quotedSpans: spans, nameStart: start, parenthesis: call.parenthesis) - return !rules.contains { site.matches($0) } + let callSite = site(of: call, nameStart: start) + return !rules.contains { callSite.matches($0) } + } + } + + // What each MATCH_RECOGNIZE clause holds: its row pattern, its MEASURES and DEFINE, where navigation is the clause's + // own, and the queries nested in it, which that navigation does not reach. A clause `SQLRowPatternClause` cannot read + // owns nothing. + private struct RowPatternClauses { + private enum Kind { + case clause + case navigation + case pattern + case query + } + + private var groups: [(range: Range, kind: Kind)] = [] + private var owned: Set = [] + + init( + source: NSString, + code: NSString, + grammar: SQLLexicalGrammar, + calls: [SQLFunctionCallScanner.Call], + opensClause: (SQLFunctionCallScanner.Call, Int) -> Bool + ) { + let openers = calls.filter { call in + guard case .named(let name, let start) = call.callee else { return false } + return name.uppercased() == "MATCH_RECOGNIZE" && opensClause(call, start) + } + guard !openers.isEmpty else { return } + let tokens = TSQLTokens.read(source, code: code, grammar: grammar) + for call in openers { + guard case .named(_, let start) = call.callee, + let open = tokens.firstIndex(where: { $0.kind == .open && $0.location == call.parenthesis }), + let close = Self.close(of: open, in: tokens), + let clause = SQLRowPatternClause.read(tokens, body: (open + 1).. Bool { + if owned.contains(start) { return true } + switch kind(at: start) { + case .pattern: + return true + case .navigation: + return SQLReadOnlyFunctionCalls.rowPatternFunctions.contains(word) + case .clause, .query, nil: + return false + } + } + + private func kind(at position: Int) -> Kind? { + groups.filter { $0.range.contains(position) }.max { $0.range.lowerBound < $1.range.lowerBound }?.kind + } + + private static func close(of open: Int, in tokens: [TSQLTokens.Token]) -> Int? { + ((open + 1)..? + private(set) var orderBy: Range? + private(set) var measures: Range? + let patternKeyword: Int + let pattern: Range + let define: Range + + private init(patternKeyword: Int, pattern: Range, define: Range) { + self.patternKeyword = patternKeyword + self.pattern = pattern + self.define = define + } + + private enum Section: Int { + case partitionBy + case orderBy + case measures + case rowsPerMatch + case afterMatch + case pattern + case subset + case define + } + + private struct Mark { + let section: Section + let keyword: Int + let content: Int + } + + // `body` is the tokens inside the clause's parentheses. + static func read(_ tokens: [TSQLTokens.Token], body: Range, text: NSString) -> SQLRowPatternClause? { + guard let first = body.first else { return nil } + let depth = tokens[first].depth + var marks: [Mark] = [] + var index = body.lowerBound + while index < body.upperBound { + guard tokens[index].depth == depth, let mark = mark(at: index, in: tokens, body: body, text: text) else { + index += 1 + continue + } + if let last = marks.last, mark.section.rawValue <= last.section.rawValue { return nil } + marks.append(mark) + if mark.section == .define { break } + index = mark.content + } + guard let patternAt = marks.firstIndex(where: { $0.section == .pattern }), + let define = marks.last, define.section == .define, + let close = close(of: marks[patternAt].content, in: tokens, before: body.upperBound), + marks[patternAt + 1].keyword == close + 1 + else { return nil } + let keyword = marks[patternAt].keyword + var clause = SQLRowPatternClause( + patternKeyword: keyword, + pattern: (marks[patternAt].content + 1).., + text: NSString + ) -> Mark? { + guard let word = tokens[index].word else { return nil } + let next = index + 1 < body.upperBound ? tokens[index + 1] : nil + let section: Section + switch word { + case "PARTITION" where next?.word == "BY": + section = .partitionBy + case "ORDER" where next?.word == "BY": + section = .orderBy + case "MEASURES": + section = .measures + case "ONE" where next?.word == "ROW", "ALL" where next?.word == "ROWS": + section = .rowsPerMatch + case "AFTER" where next?.word == "MATCH": + section = .afterMatch + // Its content starts at the parenthesis. + case "PATTERN" where next?.kind == .open: + section = .pattern + case "SUBSET": + section = .subset + case "DEFINE": + section = .define + default: + return nil + } + guard index == body.lowerBound || followsOperand(tokens[index - 1], text: text) else { return nil } + let length = section == .partitionBy || section == .orderBy ? 2 : 1 + return Mark(section: section, keyword: index, content: index + length) + } + + private static let operatorWords: Set = [ + "AS", "AND", "OR", "NOT", "IS", "IN", "LIKE", "BETWEEN", "CASE", "WHEN", "THEN", "ELSE", "BY", "MEASURES", + "SUBSET", "DEFINE", "PATTERN", "RUNNING", "FINAL", "PRIOR", "DISTINCT", "ALL", "ANY", "SOME", "EXISTS", "ESCAPE", + ] + + private static func followsOperand(_ token: TSQLTokens.Token, text: NSString) -> Bool { + switch token.kind { + case .close, .name, .quoted: + return true + case .word(let word): + return !operatorWords.contains(word) + case .other: + let unit = text.character(at: token.location) + return unit >= 0x30 && unit <= 0x39 + case .open, .comma, .terminator: + return false + } + } + + private static func close(of open: Int, in tokens: [TSQLTokens.Token], before end: Int) -> Int? { + guard open < end, tokens[open].kind == .open else { return nil } + return ((open + 1).. StatementClassification { diff --git a/apple/Packages/TableProCore/Sources/TableProSQLGrammar/SQLUnfilteredWrite.swift b/apple/Packages/TableProCore/Sources/TableProSQLGrammar/SQLUnfilteredWrite.swift index 4639b4203e..e69c29480a 100644 --- a/apple/Packages/TableProCore/Sources/TableProSQLGrammar/SQLUnfilteredWrite.swift +++ b/apple/Packages/TableProCore/Sources/TableProSQLGrammar/SQLUnfilteredWrite.swift @@ -6,14 +6,28 @@ public enum SQLUnfilteredWrite: Sendable, Equatable { case delete public static func writes(in sql: String, grammar: SQLLexicalGrammar) -> [SQLUnfilteredWrite] { + writes(in: sql, grammar: grammar, readsRecordIds: false) + } + + static func writes(in sql: String, grammar: SQLLexicalGrammar, readsRecordIds: Bool) -> [SQLUnfilteredWrite] { SQLStatementScanner.executableStatements(in: sql, grammar: grammar).flatMap { statement in // On T-SQL a statement can begin inside another without a `;`. SQLUnterminatedStatements.runnable(in: statement.sql, grammar: grammar).flatMap { text in - writes(inStatement: text as NSString, grammar: grammar) + writes(inStatement: text as NSString, grammar: grammar, readsRecordIds: readsRecordIds) } } } + // SurrealQL's `DELETE person:tobie` has no WHERE and removes the one record its id names. + private static func writes( + inStatement source: NSString, + grammar: SQLLexicalGrammar, + readsRecordIds: Bool + ) -> [SQLUnfilteredWrite] { + if readsRecordIds, SurrealRecordDelete.namesOneRecord(source, grammar: grammar) { return [] } + return writes(inStatement: source, grammar: grammar) + } + private static let period = UInt16(UnicodeScalar(".").value) private static let whereLength = "WHERE".utf16.count @@ -152,3 +166,145 @@ public enum SQLUnfilteredWrite: Sendable, Equatable { return previous.kind == .other && source.character(at: previous.location) == period } } + +// SurrealDB 2.3 and 3.0 (`parse_delete_stmt`) read `DELETE [FROM] [ONLY]`, the targets, then WITH, WHERE, RETURN, +// TIMEOUT, PARALLEL and EXPLAIN. A `table:key` target with the key right after the colon names one record +// (`parse_record_id_or_range`); a `..` or `>` after the key makes it a range. A table, a parameter, a subquery, an +// edge (`t:a->e`), a field (`t:a.f`), a second target or a key this does not read is every row. +private struct SurrealRecordDelete { + private static let clauses: Set = ["WITH", "WHERE", "RETURN", "TIMEOUT", "PARALLEL", "EXPLAIN"] + private static let openBracket = UInt16(UnicodeScalar("[").value) + private static let openBrace = UInt16(UnicodeScalar("{").value) + private static let closers: [UInt16: UInt16] = [ + SqlLexer.openParen: SqlLexer.closeParen, + openBracket: UInt16(UnicodeScalar("]").value), + openBrace: UInt16(UnicodeScalar("}").value), + ] + private static let closing = Set(closers.values) + private static let colon = UInt16(UnicodeScalar(":").value) + private static let period = UInt16(UnicodeScalar(".").value) + private static let plus = UInt16(UnicodeScalar("+").value) + private static let smallU = UInt16(UnicodeScalar("u").value) + + let text: NSString + let grammar: SQLLexicalGrammar + var index = 0 + + static func namesOneRecord(_ text: NSString, grammar: SQLLexicalGrammar) -> Bool { + var reader = SurrealRecordDelete(text: text, grammar: grammar) + return reader.readsOneRecordDelete() + } + + private mutating func readsOneRecordDelete() -> Bool { + skipBlanks() + guard word() == "DELETE" else { return false } + skipKeyword("FROM") + skipKeyword("ONLY") + skipBlanks() + guard readsName(), peek() == Self.colon else { return false } + index += 1 + guard readsKey() else { return false } + skipBlanks() + guard let next = peek() else { return true } + if next == SqlLexer.semicolon { + index += 1 + skipBlanks() + return peek() == nil + } + return word().map(Self.clauses.contains) == true + } + + // `parse_record_id_key`: an integer with or without a sign, a name, a `u"..."` UUID, or an array or object. A + // generated key such as `rand()` is left unread. + private mutating func readsKey() -> Bool { + guard let first = peek() else { return false } + if first == Self.plus || first == SqlLexer.dash { + index += 1 + let digits = index + while let next = peek(), next >= 0x30, next <= 0x39 { + index += 1 + } + return index > digits + } + if first == Self.smallU, index + 1 < text.length, + [SqlLexer.singleQuote, SqlLexer.doubleQuote].contains(text.character(at: index + 1)) { + return readsQuoted(at: index + 1) + } + if first == Self.openBracket || first == Self.openBrace { + return readsValues() + } + return readsName() + } + + // A string is a value, so `person:"tobie"` is not a key SurrealDB parses. + private mutating func readsName() -> Bool { + if let first = peek(), first == SqlLexer.backtick || first == SqlLexer.openAngleQuote { + return readsQuoted(at: index) + } + return word() != nil + } + + private mutating func readsQuoted(at start: Int) -> Bool { + guard let span = SQLNonCodeSpan.span(at: start, in: text, grammar: grammar), span.kind == .quoted, + span.isTerminated + else { return false } + index = span.end + return true + } + + // Whatever an array or object key holds, it is one key. A `..` inside is still read as a range. + private mutating func readsValues() -> Bool { + var expected: [UInt16] = [] + while let next = peek() { + if let span = SQLNonCodeSpan.span(at: index, in: text, grammar: grammar) { + index = max(span.end, index + 1) + continue + } + if let closer = Self.closers[next] { + expected.append(closer) + } else if Self.closing.contains(next) { + guard expected.popLast() == next else { return false } + if expected.isEmpty { + index += 1 + return true + } + } else if next == Self.period, index + 1 < text.length, text.character(at: index + 1) == Self.period { + return false + } + index += 1 + } + return false + } + + private mutating func skipKeyword(_ keyword: String) { + skipBlanks() + let start = index + if word() != keyword { index = start } + } + + private mutating func skipBlanks() { + while index < text.length { + let blank = StatementBlank.blankLength(in: text, at: index) + if blank > 0 { + index += blank + } else if let span = SQLNonCodeSpan.span(at: index, in: text, grammar: grammar), span.kind.isComment { + index = max(span.end, index + 1) + } else { + return + } + } + } + + private mutating func word() -> String? { + let start = index + while let next = peek(), SqlDollarQuote.isIdentifierPart(next) { + index += 1 + } + guard index > start else { return nil } + return text.substring(with: NSRange(location: start, length: index - start)).uppercased() + } + + private func peek() -> UInt16? { + index < text.length ? text.character(at: index) : nil + } +} diff --git a/apple/Packages/TableProCore/Sources/TableProWeaviateClient/WeaviateStatementGenerator.swift b/apple/Packages/TableProCore/Sources/TableProWeaviateClient/WeaviateStatementGenerator.swift index da95cafd5c..a958e54f9d 100644 --- a/apple/Packages/TableProCore/Sources/TableProWeaviateClient/WeaviateStatementGenerator.swift +++ b/apple/Packages/TableProCore/Sources/TableProWeaviateClient/WeaviateStatementGenerator.swift @@ -140,22 +140,18 @@ public enum WeaviateStatementGenerator { "properties": properties(from: patch, types: types) ] guard let body = try? WeaviateJSON.text(payload) else { return nil } - return WeaviateWriteRequest( - method: "PATCH", - path: "/v1/objects/\(WeaviatePathEncoding.segment(uuid))", - query: ["class": collection], - body: body - ) + return WeaviateWriteRequest(method: "PATCH", path: objectPath(collection: collection, uuid: uuid), body: body) } + // The server reads no `class` parameter on `/v1/objects/{id}` and deletes the id in every collection that holds it + // (Weaviate 1.40 `usecases/objects/delete.go`), so a row is named by its collection's route. private static func delete(collection: String, change: WeaviateTrackedChange) -> WeaviateWriteRequest? { guard let uuid = change.uuid, !uuid.isEmpty else { return nil } - return WeaviateWriteRequest( - method: "DELETE", - path: "/v1/objects/\(WeaviatePathEncoding.segment(uuid))", - query: ["class": collection], - body: nil - ) + return WeaviateWriteRequest(method: "DELETE", path: objectPath(collection: collection, uuid: uuid), body: nil) + } + + private static func objectPath(collection: String, uuid: String) -> String { + "/v1/objects/\(WeaviatePathEncoding.segment(collection))/\(WeaviatePathEncoding.segment(uuid))" } private static func properties(from values: [String: String?], types: [String: String]) -> [String: Any] { diff --git a/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SQLBareNameCallsTests.swift b/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SQLBareNameCallsTests.swift index 364d605e0b..9cd42c94a0 100644 --- a/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SQLBareNameCallsTests.swift +++ b/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SQLBareNameCallsTests.swift @@ -97,6 +97,31 @@ struct SQLBareNameCallsTests { #expect(!Self.calls("SELECT pk.f FROM orders pk", "Dameng", catalog: SQLCallableCatalog(functions: [], roots: []))) } + // Measured on Oracle 23ai: functions RUNNING, FINAL and WIPE did not run for these. + @Test("MATCH_RECOGNIZE's own words, a measure's alias, a pattern variable and RUNNING or FINAL before a call are not calls") + func rowPatternClauseNames() { + let catalog = SQLCallableCatalog( + functions: [ + "WIPE", "RUNNING", "FINAL", "MEASURES", "ONE", "ROW", "ROWS", "PER", "MATCH", "AFTER", "SKIP", "PAST", + "LAST", "NEXT", "FIRST", "SUBSET", "DEFINE", "X", "Y", "U", "EMPTY", "MATCHES", "SHOW", + ], + roots: [] + ) + for sql in [ + "SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id MEASURES x.id AS wipe ONE ROW PER MATCH PATTERN (x) DEFINE x AS 1 = 1)", + "SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id MEASURES FINAL LAST(x.purge) AS l, RUNNING COUNT(*) AS c " + + "ALL ROWS PER MATCH SHOW EMPTY MATCHES AFTER MATCH SKIP PAST LAST ROW PATTERN (x y*) SUBSET u = (x, y) " + + "DEFINE x AS RUNNING COUNT(*) < 9, y AS u.purge > PREV(y.purge))", + "SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id MEASURES x.id wipe AFTER MATCH SKIP TO NEXT ROW PATTERN (x) " + + "DEFINE x AS CAST(x.purge AS NUMBER) > 0)", + ] { + #expect(!Self.calls(sql, catalog: catalog), "\(sql)") + } + #expect(Self.calls( + "SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id PATTERN (x) DEFINE x AS final > 1)", catalog: catalog + )) + } + @Test("A VALUES row, a MATCH_RECOGNIZE condition and a PARTITION FOR value are read") func rowValuesAndConditions() { #expect(Self.calls("SELECT * FROM (VALUES (wipe)) t (a)")) @@ -106,6 +131,23 @@ struct SQLBareNameCallsTests { #expect(!Self.calls("SELECT * FROM orders MATCH_RECOGNIZE (PATTERN (x) DEFINE x AS purge = 100)")) #expect(!Self.calls("SELECT * FROM orders MATCH_RECOGNIZE (PATTERN (up+) DEFINE up AS up.purge > 1)")) #expect(Self.calls("SELECT * FROM orders MATCH_RECOGNIZE (PATTERN (up+) DEFINE up AS other.purge > 1)")) + #expect(Self.calls("SELECT * FROM orders MATCH_RECOGNIZE (MEASURES wipe AS w PATTERN (x) DEFINE x AS 1 = 1)")) + #expect(Self.calls("SELECT * FROM orders MATCH_RECOGNIZE (MEASURES x.id w, wipe m PATTERN (x) DEFINE x AS 1 = 1)")) + #expect(Self.calls("SELECT * FROM orders MATCH_RECOGNIZE (PARTITION BY wipe PATTERN (x) DEFINE x AS 1 = 1)")) + // Measured on Oracle 23ai: a section word as an alias or a column opens no section, and WIPE runs. + #expect(Self.calls( + "SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id MEASURES x.id AS subset, wipe AS w PATTERN (x) DEFINE x AS 1 = 1)" + )) + #expect(Self.calls( + "SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id MEASURES x.id AS define, wipe AS w PATTERN (x) DEFINE x AS 1 = 1)" + )) + #expect(Self.calls( + "SELECT * FROM (SELECT id, 1 AS subset FROM orders) MATCH_RECOGNIZE (ORDER BY id MEASURES x.subset + wipe AS m " + + "PATTERN (x) DEFINE x AS 1 = 1)" + )) + #expect(Self.calls("SELECT * FROM orders MATCH_RECOGNIZE (MEASURES subset + wipe AS m PATTERN (x) DEFINE x AS 1 = 1)")) + // Out of Oracle's order, so the clause is read whole, a name after AS included. + #expect(Self.calls("SELECT * FROM orders MATCH_RECOGNIZE (DEFINE x AS wipe = 1 PATTERN (x))")) #expect(Self.calls("SELECT * FROM orders, dual PIVOT (MAX(purge) FOR dummy IN ('X' AS x))")) #expect(!Self.calls("SELECT * FROM orders, dual PIVOT (MAX(dummy) FOR dummy IN ('X' AS x)) WHERE purge = 1")) #expect(Self.calls("SELECT * FROM orders PARTITION FOR (wipe)")) diff --git a/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SQLDataStatementTests.swift b/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SQLDataStatementTests.swift index 7c78e4123d..5ea34c4c7d 100644 --- a/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SQLDataStatementTests.swift +++ b/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SQLDataStatementTests.swift @@ -198,4 +198,19 @@ struct SQLDataStatementTests { #expect(SQLStatementClassifier.isSystemScope(database: "system_auth", schema: nil, databaseTypeId: engine)) #expect(!SQLStatementClassifier.isSystemScope(database: "shop", schema: nil, databaseTypeId: engine)) } + + @Test("ScyllaDB's audit keyspace holds its audit log, so a row change there is not data; on Cassandra it is a user's") + func scyllaAuditKeyspace() { + for sql in [ + "DELETE FROM audit.audit_log WHERE date = '2026-11-13' AND node = '10.0.0.1'", + "UPDATE \"audit\".audit_log SET operation = 'x' WHERE date = '2026-11-13' AND node = '10.0.0.1'", + "INSERT INTO AUDIT.audit_log (date, node) VALUES ('2026-11-13', '10.0.0.1')", + ] { + #expect(!Self.isData(sql, "ScyllaDB")) + #expect(Self.isData(sql, "Cassandra")) + } + #expect(Self.isData("SELECT * FROM audit.audit_log", "ScyllaDB")) + #expect(SQLStatementClassifier.isSystemScope(database: "audit", schema: nil, databaseTypeId: "ScyllaDB")) + #expect(!SQLStatementClassifier.isSystemScope(database: "audit", schema: nil, databaseTypeId: "Cassandra")) + } } diff --git a/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SQLReadOnlyFunctionCallsTests.swift b/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SQLReadOnlyFunctionCallsTests.swift index ca24b57fd7..af75fb77a9 100644 --- a/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SQLReadOnlyFunctionCallsTests.swift +++ b/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SQLReadOnlyFunctionCallsTests.swift @@ -36,6 +36,51 @@ struct SQLReadOnlyFunctionCallsTests { #expect(!SQLReadOnlyFunctionCalls.builtins(forDatabaseTypeId: "MySQL").contains("NVL")) } + // Measured on Oracle 23ai with user functions of each name (apple/scripts/probes/check-match-recognize-calls.sh): + // inside MEASURES and DEFINE none of them runs, outside the clause each does. + @Test("MATCH_RECOGNIZE's navigation and row pattern are the clause's own on Oracle", arguments: [ + "SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id MEASURES PREV(x.purge) AS p ALL ROWS PER MATCH " + + "PATTERN (x+) DEFINE x AS PREV(x.purge) IS NULL OR x.purge < PREV(x.purge, 1))", + "SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id MEASURES NEXT(x.purge) AS n ONE ROW PER MATCH " + + "PATTERN (x) DEFINE x AS NEXT(x.purge) IS NOT NULL)", + "SELECT * FROM orders MATCH_RECOGNIZE (PARTITION BY id ORDER BY id MEASURES FIRST(x.purge) AS f, " + + "FINAL LAST(x.purge) AS l, RUNNING COUNT(*) AS c ONE ROW PER MATCH PATTERN (x+) DEFINE x AS FIRST(x.purge) > 0)", + "SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id MEASURES CLASSIFIER() AS c, MATCH_NUMBER() AS m " + + "ALL ROWS PER MATCH PATTERN (^ PERMUTE(x, y) {- z -} $) DEFINE x AS 1 = 1, y AS 1 = 1, z AS 1 = 1)", + "SELECT * FROM (SELECT id FROM orders) MATCH_RECOGNIZE (ORDER BY id PATTERN (x) DEFINE x AS ABS(PREV(x.id)) > 0) mr", + ]) + func rowPatternNavigationIsListed(sql: String) { + #expect(!Self.callsUnlisted(sql, "Oracle")) + } + + @Test("Outside MATCH_RECOGNIZE, and in a query nested in it, those names are a user's functions", arguments: [ + "SELECT prev(1) FROM dual", + "SELECT first(1), last(1) FROM dual", + "SELECT classifier(), match_number() FROM dual", + "SELECT match_recognize(1) FROM dual", + "SELECT pattern(1) FROM dual", + "SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id PATTERN (x) DEFINE x AS x.purge > (SELECT prev(1) FROM dual))", + "SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id MEASURES wipe() AS w PATTERN (x) DEFINE x AS 1 = 1)", + "SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id PATTERN (x) DEFINE x AS pk.prev(x.id) > 0)", + "SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id PATTERN (x) DEFINE x AS \"PREV\"(x.id) > 0)", + "SELECT * FROM orders MATCH_RECOGNIZE (PARTITION BY prev(purge) ORDER BY id PATTERN (x) DEFINE x AS 1 = 1)", + "SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id MEASURES pattern(wipe()) AS m PATTERN (x) DEFINE x AS 1 = 1)", + "SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id MEASURES PREV(x.id) AS p PATTERN (x))", + "SELECT * FROM orders MATCH_RECOGNIZE (DEFINE x AS PREV(x.id) > 0 PATTERN (x))", + "SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id PATTERN (x) DEFINE x AS x.purge > " + + "((SELECT 1 FROM dual WHERE 1 = 0) UNION ALL SELECT prev(1) FROM dual))", + "SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id PATTERN (x) DEFINE x AS " + + "EXISTS ((SELECT 1 FROM dual WHERE 1 = 0) UNION ALL SELECT prev(1) FROM dual))", + ]) + func rowPatternNamesElsewhereAreUnlisted(sql: String) { + #expect(Self.callsUnlisted(sql, "Oracle")) + } + + @Test("An engine without MATCH_RECOGNIZE reads PREV as a user function") + func rowPatternIsOracleOnly() { + #expect(Self.callsUnlisted("SELECT * FROM t MATCH_RECOGNIZE (PATTERN (x) DEFINE x AS PREV(x.a) > 0)", "PostgreSQL")) + } + @Test("On SurrealDB only a stored body is unlisted: its built-ins are namespaced") func surrealStoredBodies() { #expect(Self.callsUnlisted("SELECT fn::mk() FROM ONLY person:one", "SurrealDB")) diff --git a/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SurrealRecordDeleteTests.swift b/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SurrealRecordDeleteTests.swift new file mode 100644 index 0000000000..81bcf85059 --- /dev/null +++ b/apple/Packages/TableProCore/Tests/TableProSQLGrammarTests/SurrealRecordDeleteTests.swift @@ -0,0 +1,72 @@ +import Foundation +import TableProSQLGrammar +import Testing + +// Record id and DELETE forms from SurrealDB 2.3 and 3.0's parser (`parse_record_id_key`, `parse_delete_stmt`). +struct SurrealRecordDeleteTests { + private static func deletesEveryRow(_ sql: String, _ engine: String = "SurrealDB") -> Bool { + let readings = SQLLexicalReadings.resolve(databaseTypeId: engine, declared: nil, session: nil) + return SQLStatementClassifier.deletesEveryRow(sql, databaseTypeId: engine, readings: readings) + } + + @Test("A SurrealQL DELETE of one record by its id does not delete every row", arguments: [ + "DELETE person:tobie", + "DELETE person:100", + "delete person:tobie;", + "DELETE ONLY person:tobie RETURN BEFORE", + "DELETE FROM person:tobie", + "DELETE person:-7", + "DELETE person:+7", + "DELETE person:⟨tobie smith⟩", + "DELETE person:`8424486b-85b2-4448-ac8d-5d51083391c7`", + "DELETE `Artykuł`:100", + #"DELETE person:u"0190d7e0-5f2e-7b1c-9a3e-2f6d2c8b4a10""#, + "DELETE weather:['London', d'2025-02-13T05:00:00Z']", + "DELETE k:{ a: 1, b: [2, 3] }", + "DELETE person:tobie TIMEOUT 5s", + "DELETE person:tobie WITH NOINDEX", + "DELETE person:tobie PARALLEL", + "DELETE person:tobie EXPLAIN FULL", + "/* one */ DELETE /* record */ person:tobie -- gone", + "SELECT * FROM (DELETE person:tobie)", + ]) + func oneRecordById(sql: String) { + #expect(!Self.deletesEveryRow(sql)) + } + + @Test("A SurrealQL DELETE of a table, a range, a parameter, a query or several records deletes every row", arguments: [ + "DELETE person", + "DELETE ONLY person", + "DELETE person:1..10", + "DELETE person:1..", + "DELETE person:..", + "DELETE person:..=5", + "DELETE person:1>..5", + "DELETE temperature:['London', NONE]..=['London', ..]", + "DELETE person:['a', ..]", + "DELETE $records", + "DELETE (SELECT VALUE id FROM person WHERE age > 20 LIMIT 2)", + "DELETE type::record('person', 1)", + "DELETE person:tobie->bought", + "DELETE person:tobie.friends", + "DELETE person:tobie, person:jaime", + "DELETE person:rand()", + #"DELETE person:"tobie""#, + #"DELETE r"person:tobie""#, + "DELETE person: tobie", + "DELETE person :tobie", + "DELETE person:tobie RETURN DELETE person", + "DELETE person:tobie; DELETE person", + "SELECT * FROM (DELETE person)", + ]) + func manyRecords(sql: String) { + #expect(Self.deletesEveryRow(sql)) + } + + @Test("Only SurrealDB reads a record id, and a driver's row change is read as before") + func otherEnginesReadAsBefore() { + #expect(Self.deletesEveryRow("DELETE person:tobie", "MySQL")) + let surrealQL = SQLLexicalReadings.resolve(databaseTypeId: "SurrealDB", declared: nil, session: nil).execution + #expect(SQLUnfilteredWrite.writes(in: "DELETE person:tobie", grammar: surrealQL).first == .delete) + } +} diff --git a/apple/Packages/TableProCore/Tests/TableProWeaviateClientTests/WeaviateStatementGeneratorTests.swift b/apple/Packages/TableProCore/Tests/TableProWeaviateClientTests/WeaviateStatementGeneratorTests.swift new file mode 100644 index 0000000000..aa462b71cd --- /dev/null +++ b/apple/Packages/TableProCore/Tests/TableProWeaviateClientTests/WeaviateStatementGeneratorTests.swift @@ -0,0 +1,37 @@ +import Foundation +import TableProWeaviateClient +import TableProWeaviateCore +import Testing + +struct WeaviateStatementGeneratorTests { + private static let uuid = "36ddd591-2dee-4e7e-a3cc-eb86d30a4303" + + private static func request(_ kind: WeaviateTrackedChange.Kind) -> WeaviateWriteRequest? { + let change = WeaviateTrackedChange( + kind: kind, + uuid: uuid, + values: ["title": "A"], + cellChanges: [WeaviateCellChange(column: "title", newText: "B")] + ) + return WeaviateStatementGenerator.generate( + collection: "Article", + columns: ["title"], + typeNames: ["text"], + changes: [change] + ).requests.first + } + + // `/v1/objects/{id}` deletes the id in every collection that holds it. + @Test("A row's delete and update name its collection in the route") + func rowChangesNameTheCollection() throws { + let delete = try #require(Self.request(.delete)) + #expect(delete.method == "DELETE") + #expect(delete.path == "/v1/objects/Article/\(Self.uuid)") + #expect(delete.query.isEmpty) + + let update = try #require(Self.request(.update)) + #expect(update.method == "PATCH") + #expect(update.path == "/v1/objects/Article/\(Self.uuid)") + #expect(update.query.isEmpty) + } +} diff --git a/apple/Plugins/EtcdDriverPlugin/EtcdCommandParser.swift b/apple/Plugins/EtcdDriverPlugin/EtcdCommandParser.swift index 3e021e148c..0ab463f54e 100644 --- a/apple/Plugins/EtcdDriverPlugin/EtcdCommandParser.swift +++ b/apple/Plugins/EtcdDriverPlugin/EtcdCommandParser.swift @@ -63,8 +63,11 @@ extension EtcdOperation { case .put, .create, .leaseGrant, .leaseKeepAlive, .authEnable, .userAdd, .roleAdd, .userGrantRole, .userRevokeRole: return .write - // A move takes the key away from its name, as a del does. - case .move, .del, .compaction, .leaseRevoke, .authDisable, .userDelete, .roleDelete: + // One key by name is a row change, as a keyed DELETE is. A prefix can take every key. + case .del(_, let prefix): + return prefix ? .destructive : .write + // A move takes the key away from its name. + case .move, .compaction, .leaseRevoke, .authDisable, .userDelete, .roleDelete: return .destructive case .unknown: return nil @@ -309,9 +312,14 @@ struct EtcdCommandParser { guard let key = positional.first?.bytes else { throw EtcdParseError.missingArgument("del requires a key") } + // etcdctl deletes a range for a range end, `--from-key` or `--prefix=true`, which `.del` cannot carry. + guard positional.count == 1, !flags.has("from-key"), flags.value(for: "from-key") == nil, + flags.value(for: "prefix") == nil + else { + throw EtcdParseError.invalidArgument("del takes one key, or a prefix with --prefix") + } - let prefix = flags.has("prefix") - return .del(key: key, prefix: prefix) + return .del(key: key, prefix: flags.has("prefix")) } private static func parseWatch(_ tokens: [EtcdCommandToken]) throws -> EtcdOperation { diff --git a/apple/TablePro/Core/Utilities/SQL/QueryClassifier+CommandDataStatements.swift b/apple/TablePro/Core/Utilities/SQL/QueryClassifier+CommandDataStatements.swift index c59404bc58..1df96aabb6 100644 --- a/apple/TablePro/Core/Utilities/SQL/QueryClassifier+CommandDataStatements.swift +++ b/apple/TablePro/Core/Utilities/SQL/QueryClassifier+CommandDataStatements.swift @@ -121,10 +121,24 @@ extension QueryClassifier { // Reads by the driver's own rule, `KafkaStatement.refusal`. The SQL tier reads CONSUME as a write. case .consume, .showTopics, .showBrokers, .showGroups, .showCluster, .describeGroup, .describeTopic: return [.read] - case .produce: - return [.named("PRODUCE")] + case .produce(let query): + return [kafkaNamesServiceTopic(query.topic) ? .refused : .named("PRODUCE")] case .dropTopic: return [.named("DROP TOPIC")] } } + + // The broker refuses a produce only into its own `__` topics. Schema Registry keeps its schemas in `_schemas` + // (`kafkastore.topic`), and Confluent names every internal topic with a leading `_`. Kafka's + // `ReplicationPolicy.isInternalTopic` (4.4) adds a leading `.` and MirrorMaker 2's `.internal` topics, its Connect + // stores among them. A Connect worker's stores have no default name; these are the ones Kafka ships in + // `config/connect-distributed.properties`. Kafka Streams names a store's log and a repartition topic with these + // suffixes. The broker does not say which topics a worker, a registry or an application uses. + private static let kafkaConnectTopics: Set = ["connect-configs", "connect-offsets", "connect-status"] + + static func kafkaNamesServiceTopic(_ topic: String) -> Bool { + if topic.hasPrefix("_") || topic.hasPrefix(".") || kafkaConnectTopics.contains(topic) { return true } + if topic.hasSuffix("-changelog") || topic.hasSuffix("-repartition") { return true } + return (topic.hasPrefix("mm2") && topic.hasSuffix(".internal")) || topic.hasSuffix(".checkpoints.internal") + } } diff --git a/apple/TablePro/Core/Utilities/SQL/QueryClassifier+Memcached.swift b/apple/TablePro/Core/Utilities/SQL/QueryClassifier+Memcached.swift index ee6ca9bb43..f729530930 100644 --- a/apple/TablePro/Core/Utilities/SQL/QueryClassifier+Memcached.swift +++ b/apple/TablePro/Core/Utilities/SQL/QueryClassifier+Memcached.swift @@ -4,33 +4,54 @@ // import Foundation +import TableProMemcachedCore import TableProSQLGrammar extension QueryClassifier { private static let memcachedReadCommands: Set = ["get", "gets", "version"] - private static let memcachedDestructiveCommands: Set = ["delete", "flush_all"] private static let memcachedReadingStats: Set = ["items", "slabs", "settings", "conns", "sizes", "cachedump"] - /// Only the `stats` forms that read are safe: `stats reset` clears the counters and `stats detail on` changes - /// what the server records. `gat` reads a value and moves its expiry, so it writes. The driver strips quotes - /// before it sends a word, so they are stripped here too. + // Read with the driver's own parser, which decodes `\xHH` and `\c` in a quoted word, so `"flush\x5fall"` is the + // `flush_all` it runs. Only the `stats` forms that read are safe: `stats reset` clears the counters and `stats detail + // on` changes what the server records. `gat` reads a value and moves its expiry, so it writes. `delete` removes one + // key, a write as a keyed DELETE is, and `flush_all` empties the cache. static func memcachedClassification(_ trimmed: String) -> QueryClassification { if trimmed.hasPrefix("MEMCACHED_BROWSE:") || trimmed.hasPrefix("MEMCACHED_REFUSAL:") { return .safe } + let write = QueryClassification(tier: .write, reachesFilesystemOrExecutesCode: false) + guard let command = try? MemcachedCommandParser.parse(trimmed) else { return memcachedUnparsedClassification(trimmed) } + switch command { + case .get, .version, .metadump: + return .safe + case .stats(let arguments): + return memcachedStatsRead(arguments.map { $0.lowercased() }) ? .safe : write + case .flushAll: + return QueryClassification(tier: .destructive, reachesFilesystemOrExecutesCode: false) + case .getAndTouch, .store, .compareAndSwap, .touch, .delete, .increment, .decrement: + return write + } + } + + private static func memcachedStatsRead(_ arguments: [String]) -> Bool { + guard let subcommand = arguments.first else { return true } + return memcachedReadingStats.contains(subcommand) || (subcommand == "detail" && arguments.dropFirst().first == "dump") + } + + // The driver refuses text its parser cannot read; it is tiered by its words all the same. + private static func memcachedUnparsedClassification(_ trimmed: String) -> QueryClassification { let words = trimmed.split(whereSeparator: \.isWhitespace).map { $0.lowercased().filter { $0 != "\"" && $0 != "'" } } guard let command = words.first else { return .safe } - let subcommand = words.dropFirst().first switch command { case "stats": - guard let subcommand, !memcachedReadingStats.contains(subcommand) else { return .safe } - if subcommand == "detail", words.dropFirst(2).first == "dump" { return .safe } - return QueryClassification(tier: .write, reachesFilesystemOrExecutesCode: false) - case "lru_crawler" where subcommand == "metadump": + return memcachedStatsRead(Array(words.dropFirst())) + ? .safe + : QueryClassification(tier: .write, reachesFilesystemOrExecutesCode: false) + case "lru_crawler" where words.dropFirst().first == "metadump": return .safe default: if memcachedReadCommands.contains(command) { return .safe } - let tier: QueryTier = memcachedDestructiveCommands.contains(command) ? .destructive : .write + let tier: QueryTier = command == "flush_all" ? .destructive : .write return QueryClassification(tier: tier, reachesFilesystemOrExecutesCode: false) } } diff --git a/apple/TablePro/Core/Utilities/SQL/QueryClassifier+RequestDataStatements.swift b/apple/TablePro/Core/Utilities/SQL/QueryClassifier+RequestDataStatements.swift index f74ee7a000..3e9c6360a8 100644 --- a/apple/TablePro/Core/Utilities/SQL/QueryClassifier+RequestDataStatements.swift +++ b/apple/TablePro/Core/Utilities/SQL/QueryClassifier+RequestDataStatements.swift @@ -102,7 +102,7 @@ extension QueryClassifier { private static let elasticsearchServerCommands: Set = ["_flush", "_refresh", "_reload_search_analyzers"] private static let elasticsearchBulkActions: Set = ["index", "create", "update", "delete"] private static let typesenseMethods: Set = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"] - private static let realtimeDatabaseMetadataKeys: Set = [".value", ".priority", ".sv"] + static let realtimeDatabaseMetadataKeys: Set = [".value", ".priority", ".sv"] private static let bigtableChanges: Set = ["INSERT", "PUT", "DELETE"] private static func elasticsearchRunsServerCommand(_ route: String) -> Bool { @@ -189,7 +189,7 @@ extension QueryClassifier { } // Read as `WeaviatePathEncoding.resolve` sends it, which keeps a dot segment as written. - private static func weaviateSegments(of path: String) -> [String]? { + static func weaviateSegments(of path: String) -> [String]? { guard let encoded = URLComponents(string: path)?.percentEncodedPath, let segments = requestSegments(of: encoded) else { return nil } diff --git a/apple/TablePro/Core/Utilities/SQL/QueryClassifier.swift b/apple/TablePro/Core/Utilities/SQL/QueryClassifier.swift index 46d0cd63e1..479213519e 100644 --- a/apple/TablePro/Core/Utilities/SQL/QueryClassifier.swift +++ b/apple/TablePro/Core/Utilities/SQL/QueryClassifier.swift @@ -107,7 +107,7 @@ enum QueryClassifier { // A MongoDB statement is JavaScript, where `delete d.x` removes a field from a local object. guard databaseType != .redis, databaseType != .mongodb else { return false } if databaseType == .neo4j { return cypherDeletesUnfiltered(sql) } - // A request engine's own reading already tiers each delete it can run as destructive. + // A request engine's own reading already tiers each delete of more than one item as destructive. guard documentStoreClassification(sql, databaseType: databaseType, readings: readings) == nil else { return false } @@ -320,9 +320,9 @@ extension QueryClassifier { "_rank_eval", "_mvt" ] - /// Read the way `ElasticsearchConsoleParser` reads a console request: the method and path on the - /// first line, the rest a body. The driver sends a GET or HEAD that carries a body as a POST, so - /// `GET /orders/_delete_by_query` with a query under it deletes, and it is classified as that POST. + // Read the way `ElasticsearchConsoleParser` reads a console request: the method and path on the first line, the + // rest a body. The driver sends a GET or HEAD that carries a body as a POST, so `GET /orders/_delete_by_query` with + // a query under it deletes, and it is classified as that POST. static func elasticsearchClassification(_ sql: String) -> QueryClassification { let request = sql.trimmingCharacters(in: .whitespacesAndNewlines) var lines = request.components(separatedBy: "\n") @@ -331,6 +331,7 @@ extension QueryClassifier { let parts = header.split(separator: " ", maxSplits: 1, omittingEmptySubsequences: true) let declared = parts.first.map { $0.uppercased() } ?? "" let method = hasBody && (declared == "GET" || declared == "HEAD") ? "POST" : declared + let path = parts.count == 2 ? parts[1].trimmingCharacters(in: .whitespaces) : "" let upper = request.uppercased() let touchesUnsafeSurface = upper.contains("_SCRIPTS") || upper.contains("_PAINLESS_EXECUTE") @@ -339,7 +340,6 @@ extension QueryClassifier { case "GET", "HEAD": tier = .safe case "POST": - let path = parts.count == 2 ? parts[1].trimmingCharacters(in: .whitespaces) : "" if path.lowercased().contains("_delete_by_query") { tier = .destructive } else { @@ -347,13 +347,31 @@ extension QueryClassifier { tier = readsOnly && !elasticsearchKeepsResults(path) ? .safe : .write } case "DELETE": - tier = .destructive + tier = elasticsearchDeletesOneDocument(path) ? .write : .destructive default: tier = .write } return QueryClassification(tier: tier, reachesFilesystemOrExecutesCode: touchesUnsafeSurface) } + // `//_doc/` on one concrete index. A name cannot start with `_`, `-` or `+`, one starting with `.` is a + // system index, and the characters below make a pattern, a list, date math or a remote target. An id starting with + // `_` stays destructive, as older servers read `///_query` as a delete by query. + static func elasticsearchDeletesOneDocument(_ path: String) -> Bool { + let rooted = path.hasPrefix("/") ? path : "/" + path + guard elasticsearchEndpoint(of: rooted) == "_doc" else { return false } + let route = rooted.prefix { $0 != "?" && $0 != "#" } + let segments = Array(route.split(separator: "/", omittingEmptySubsequences: false).dropFirst()) + guard segments.count == 3, segments[1] == "_doc", let idStart = segments[2].first, idStart != "_", + let indexStart = segments[0].first, !"_-+.".contains(indexStart) + else { return false } + return !segments[0].contains { elasticsearchIndexExpressionCharacters.contains($0) } + } + + private static let elasticsearchIndexExpressionCharacters: Set = [ + "*", "?", ",", "<", ">", ":", "|", "\"" + ] + /// The first path segment naming an API, `_search` in `/orders/_search/template`, since an index /// name cannot start with `_` and the body or an index may spell `_search` anywhere. Nil when the /// URL the driver builds could reach another path: a `.` or `..` segment resolves away, and a @@ -428,11 +446,18 @@ extension QueryClassifier { return QueryClassification(tier: .safe, reachesFilesystemOrExecutesCode: touchesUnsafeSurface) } if verb == "DELETE" { - return QueryClassification(tier: .destructive, reachesFilesystemOrExecutesCode: touchesUnsafeSurface) + let tier: QueryTier = route.map(typesenseNamesOneDocument) == true ? .write : .destructive + return QueryClassification(tier: tier, reachesFilesystemOrExecutesCode: touchesUnsafeSurface) } return QueryClassification(tier: .write, reachesFilesystemOrExecutesCode: touchesUnsafeSurface) } + // `/collections//documents/`. Without the id, a DELETE removes every document its `filter_by` matches. + static func typesenseNamesOneDocument(_ route: [String]) -> Bool { + route.count == 4 && route[0] == "COLLECTIONS" && route[2] == "DOCUMENTS" + && !["IMPORT", "EXPORT", "SEARCH"].contains(route[3]) + } + /// A bare operation, a `{"query": ...}` envelope and a console body are the same request, and /// the driver forwards the envelope verbatim, so the read-only gate has to read all three. static func weaviateDeclaresMutation(_ body: String) -> Bool { @@ -447,15 +472,18 @@ extension QueryClassifier { return query.trimmingCharacters(in: .whitespacesAndNewlines).lowercased().hasPrefix("mutation") } - /// Read in the order the driver reads it, with the driver's own console parser, so the request tiered is the one - /// the driver sends: `DELETE` and its path may be split by any whitespace. + // Read in the order the driver reads it, with the driver's own console parser, so the request tiered is the one the + // driver sends: `DELETE` and its path may be split by any whitespace. static func weaviateClassification(_ statement: String) -> QueryClassification { let trimmed = statement.trimmingCharacters(in: .whitespacesAndNewlines) if trimmed.lowercased() == "select 1" || WeaviateBrowseQuery.isTagged(trimmed) { return .safe } if WeaviateWriteCodec.isTagged(trimmed) { - return WeaviateWriteCodec.decode(trimmed)?.method.uppercased() == "DELETE" ? .destructive : .write + guard let tagged = WeaviateWriteCodec.decode(trimmed), tagged.method.uppercased() == "DELETE" else { + return .write + } + return weaviateDeletesOneObject(path: tagged.path) ? .write : .destructive } if let request = WeaviateConsoleParser.parse(trimmed) { return weaviateClassification(of: request) @@ -472,7 +500,7 @@ extension QueryClassifier { case "GET", "HEAD": return .safe case "DELETE": - return .destructive + return weaviateDeletesOneObject(path: request.path) ? .write : .destructive case "POST" where request.path.hasPrefix("/v1/graphql"): guard let body = request.body else { return .write } return weaviateDeclaresMutation(body) ? .write : .safe @@ -481,6 +509,21 @@ extension QueryClassifier { } } + // `/v1/objects//`, or one reference on one object, + // `/v1/objects/[/]/references/`. `/v1/objects/` without a class deletes that UUID in every + // class that holds one (Weaviate's `deleteObjectFromRepo`), so it stays destructive. + static func weaviateDeletesOneObject(path: String) -> Bool { + guard let segments = weaviateSegments(of: path), segments.count >= 4, + segments[0] == "v1", segments[1] == "objects" + else { return false } + switch segments.count { + case 4: return true + case 5: return segments[3] == "references" + case 6: return segments[4] == "references" + default: return false + } + } + // The driver runs what `QdrantConsoleParser` parses, so the gate reads the same request. static func qdrantClassification(_ trimmed: String) -> QueryClassification { if QdrantOperations.isTagged(trimmed) { @@ -491,34 +534,88 @@ extension QueryClassifier { let tier: QueryTier = switch kind.tier { case .read: .safe case .write: .write - case .remove: .destructive + case .remove: qdrantDeletesOnePoint(request) ? .write : .destructive } return QueryClassification(tier: tier, reachesFilesystemOrExecutesCode: kind.touchesServerFiles) } - /// A grid page is a tagged spec, which only reads. Anything else is read with the driver's own parser, so the path - /// tiered is the path the driver writes. A write that leaves a node holding nothing deletes it, so it ranks with DELETE. + // Qdrant's `PointsSelector` is a list of ids or a filter, either with an optional `shard_key`. Any other key, a + // filter or a second id can remove more than one point. + static func qdrantDeletesOnePoint(_ request: QdrantConsoleRequest) -> Bool { + guard request.method == "POST", + let route = QdrantPathEncoding.segments(of: request.path), route.count == 4, + route[0] == "collections", route[2] == "points", route[3] == "delete", + let data = request.body?.data(using: .utf8), + let selector = try? JSONSerialization.jsonObject(with: data) as? [String: Any], + Set(selector.keys).isSubset(of: ["points", "shard_key"]), + let points = selector["points"] as? [Any], points.count == 1 + else { return false } + switch points[0] { + case let number as NSNumber: + return CFGetTypeID(number) != CFBooleanGetTypeID() + case is String: + return true + default: + return false + } + } + + // A grid page is a tagged spec, which only reads. Anything else is read with the driver's own parser, so the path + // tiered is the path the driver writes. A write that leaves a node holding nothing deletes it, so it ranks with + // DELETE: a write when it removes one document or one record, destructive otherwise. static func firebaseClassification(_ statement: String, databaseType: DatabaseType) -> QueryClassification { let trimmed = statement.trimmingCharacters(in: .whitespacesAndNewlines) if trimmed.unicodeScalars.starts(with: FirebaseStatement.browseTag.unicodeScalars) { return .safe } - let destructive = QueryClassification(tier: .destructive, reachesFilesystemOrExecutesCode: false) - let write = QueryClassification(tier: .write, reachesFilesystemOrExecutesCode: false) // The driver refuses any other text, and an unknown request is a write all the same. - guard case .request(let request)? = try? FirebaseStatement.parse(trimmed) else { return write } + guard case .request(let request)? = try? FirebaseStatement.parse(trimmed) else { return .write } let body = request.body ?? "" + let path = request.path.unicodeScalars.split(separator: "/").map(String.init) + let realtimeDatabase = databaseType == .firebaseRealtimeDatabase switch request.method { case .get, .query: return .safe + case .delete where databaseType == .firestore: + return firestoreNamesDocument(path) ? .write : .destructive case .delete: - return destructive - case .put where request.path.isEmpty || firebaseHoldsNothing(body): - return destructive - case .patch where databaseType == .firebaseRealtimeDatabase && firebaseRemovesChild(body): - return destructive + return realtimeDatabase && realtimeDatabaseRemovesOnlyRecords([path]) ? .write : .destructive + case .put where request.path.isEmpty: + return .destructive + // A PUT replaces the node at its path, every record under a table's node with it. + case .put where realtimeDatabase: + if firebaseHoldsNothing(body) { return realtimeDatabaseRemovesOnlyRecords([path]) ? .write : .destructive } + return path.count >= 2 ? .write : .destructive + case .put where firebaseHoldsNothing(body): + return .destructive + case .patch where realtimeDatabase: + return realtimeDatabasePatchChangesOnlyRecords(path, body: body) ? .write : .destructive case .put, .patch, .post: - return write + return .write + } + } + + // An even number of segments names one document. Firestore refuses `.` and `..` as IDs, and the driver sends them as + // written, where the front end may resolve them to another path. + static func firestoreNamesDocument(_ path: [String]) -> Bool { + !path.isEmpty && path.count.isMultiple(of: 2) && !path.contains { $0 == "." || $0 == ".." } + } + + // The plugin lists `/` and each top-level key as tables (`FirebasePluginDriver.fetchTables`), so only a node two + // levels down is one record. A key cannot hold `.`, so a path through one names the server's own node. + static func realtimeDatabaseRemovesOnlyRecords(_ nodes: [[String]]) -> Bool { + nodes.allSatisfy { node in node.count >= 2 && !node.contains { $0.unicodeScalars.contains(".") } } + } + + // Each key of a PATCH body is a path below the request's, and the PATCH replaces each child it names: one set to + // nothing is removed, any other replaces every record under it. A metadata key sets its own node. + static func realtimeDatabasePatchChangesOnlyRecords(_ path: [String], body: String) -> Bool { + guard let members = firebaseJSON(body) as? [String: Any] else { return true } + return members.allSatisfy { key, value in + var node = path + key.unicodeScalars.split(separator: "/").map(String.init) + if firebaseHoldsNothing(json: value) { return realtimeDatabaseRemovesOnlyRecords([node]) } + if let last = node.last, realtimeDatabaseMetadataKeys.contains(last) { node.removeLast() } + return node.count >= 2 } } @@ -527,11 +624,6 @@ extension QueryClassifier { return firebaseHoldsNothing(json: json) } - static func firebaseRemovesChild(_ body: String) -> Bool { - guard let members = firebaseJSON(body) as? [String: Any] else { return false } - return members.values.contains { firebaseHoldsNothing(json: $0) } - } - private static func firebaseJSON(_ body: String) -> Any? { guard let data = body.trimmingCharacters(in: .whitespacesAndNewlines).data(using: .utf8) else { return nil } return try? JSONSerialization.jsonObject(with: data, options: [.fragmentsAllowed]) @@ -560,34 +652,17 @@ extension QueryClassifier { } } - /// A PUT that sets a cell to null deletes that cell, so it ranks with DELETE. INSERT refuses a - /// key that already has a row, so it never overwrites one. + // Every change names one row by its key (`BigtableRequest.parse`) and runs as one `mutateRow`, so a DELETE or a PUT + // that nulls a cell removes from that row only. static func bigtableClassification(_ trimmed: String) -> QueryClassification { if trimmed.hasPrefix("BIGTABLE_BROWSE:") { return .safe } - let write = QueryClassification(tier: .write, reachesFilesystemOrExecutesCode: false) - let destructive = QueryClassification(tier: .destructive, reachesFilesystemOrExecutesCode: false) switch trimmed.prefix(while: { !$0.isWhitespace }).uppercased() { case "GET", "SCAN", "READ": return .safe - case "DELETE": - return destructive - case "PUT": - return bigtableBodyDeletesCell(trimmed) ? destructive : write default: - return write - } - } - - /// The body is the JSON object that runs to the end of the text. A quoted row key may itself - /// hold a brace, so each brace is tried until one starts an object that parses. - private static func bigtableBodyDeletesCell(_ trimmed: String) -> Bool { - for brace in trimmed.indices where trimmed[brace] == "{" { - guard let data = String(trimmed[brace...]).data(using: .utf8), - let cells = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { continue } - return cells.values.contains { $0 is NSNull } + return .write } - return false } } diff --git a/apple/TablePro/ViewModels/DashboardTileBoard.swift b/apple/TablePro/ViewModels/DashboardTileBoard.swift index a3786e63d8..4bdaa4c089 100644 --- a/apple/TablePro/ViewModels/DashboardTileBoard.swift +++ b/apple/TablePro/ViewModels/DashboardTileBoard.swift @@ -21,7 +21,8 @@ final class DashboardTileBoard: ObservableObject { var isRunning = false } - typealias Execute = @MainActor (String) async throws -> QueryResult + // Runs the saved query in the scope the gate was asked about, nil when the gate was asked with none. + typealias Execute = @MainActor (String, DatabaseScope?) async throws -> QueryResult struct Environment { var loadCatalog: @MainActor (UUID) async -> DashboardSavedQueryCatalog @@ -33,7 +34,8 @@ final class DashboardTileBoard: ObservableObject { var nullDisplay: @MainActor () -> String var storage: ServerDashboardTileStorage var now: @MainActor () -> Date = Date.init - // Where a tile's query runs, so Read-Only reads an Oracle or Dameng catalog in that schema. + // Where a tile's query runs, so Read-Only reads an Oracle or Dameng catalog in that schema and the run is pinned + // there. var runsIn: @MainActor (UUID) -> DatabaseScope? = { _ in nil } @MainActor @@ -59,7 +61,7 @@ final class DashboardTileBoard: ObservableObject { chartsAvailable: { services.featureAccess.isAvailable(.resultCharts) }, nullDisplay: { services.appSettings.dataGrid.nullDisplay }, storage: ServerDashboardTileStorage(), - // A tile runs on the session itself, in whichever schema it is on. + // A tile runs on the session itself, in the schema it is on when the tile is checked. runsIn: { connectionId in guard let browse = services.databaseManager.browseScope(for: connectionId) else { return nil } let driver = services.databaseManager.driver(for: connectionId) as? SchemaSwitchable @@ -283,7 +285,7 @@ final class DashboardTileBoard: ObservableObject { } do { - let result = try await execute(sql) + let result = try await execute(sql, runsIn) if let error = result.error { throw error } diff --git a/apple/TablePro/ViewModels/ServerDashboardViewModel.swift b/apple/TablePro/ViewModels/ServerDashboardViewModel.swift index d12036f99d..5bdb0e1791 100644 --- a/apple/TablePro/ViewModels/ServerDashboardViewModel.swift +++ b/apple/TablePro/ViewModels/ServerDashboardViewModel.swift @@ -183,7 +183,10 @@ final class ServerDashboardViewModel: ObservableObject { await refresh(forcingTiles: true) } - private static func readExecutor(connectionId: UUID, services: AppServices) -> DashboardTileBoard.Execute { + private static func readExecutor( + connectionId: UUID, + services: AppServices + ) -> @MainActor (String) async throws -> QueryResult { { [connectionId, services] query in try await liveDriver(connectionId: connectionId, services: services).executeCatalogRead(query: query) } @@ -191,26 +194,35 @@ final class ServerDashboardViewModel: ObservableObject { // A saved query can return a whole table, so a tile stops at the rows it can draw. A driver with no bounded fetch // gets `executeRead`, which is also where a scripting engine refuses writes. At Read-Only, a driver that can runs - // the saved query in the engine's read-only mode. + // the saved query in the engine's read-only mode. It runs in the session's turn, pinned to the scope the gate was + // asked about, as a query tab's run is, so no tab moves the session's schema between the check and the run. private static func tileExecutor(connectionId: UUID, services: AppServices) -> DashboardTileBoard.Execute { - { [connectionId, services] query in - let driver = try liveDriver(connectionId: connectionId, services: services) - let policy = await MainActor.run { - services.databaseManager.session(for: connectionId)?.connection.maskingPolicy ?? .none + { [connectionId, services] query, runsIn in + let manager = services.databaseManager + guard let scope = runsIn ?? manager.browseScope(for: connectionId) else { + throw DatabaseError.connectionFailed(String(localized: "No active connection")) } + let policy = manager.session(for: connectionId)?.connection.maskingPolicy ?? .none let rowCap = DashboardTileTable.rowCap - let isReadOnly = ExecutionGateProvider.runsAtReadOnly(connectionId, in: services.databaseManager) - if let context = driver.readOnlyRunContext(safeModeIsReadOnly: isReadOnly) { - if let bounded = try await driver.executeBoundedQuery(query: query, rowCap: rowCap, context: context) { + let isReadOnly = ExecutionGateProvider.runsAtReadOnly(connectionId, in: manager) + return try await manager.withCancellableRead( + scope: scope, + route: manager.executionRoute(for: scope), + ownsSessionState: false, + readsOnly: true + ) { driver in + if let context = driver.readOnlyRunContext(safeModeIsReadOnly: isReadOnly) { + if let bounded = try await driver.executeBoundedQuery(query: query, rowCap: rowCap, context: context) { + return bounded.masked(by: policy) + } + return try await driver.executeUserQuery(query: query, rowCap: rowCap, parameters: nil, context: context) + .masked(by: policy) + } + if let bounded = try await driver.executeBoundedQuery(query: query, rowCap: rowCap) { return bounded.masked(by: policy) } - return try await driver.executeUserQuery(query: query, rowCap: rowCap, parameters: nil, context: context) - .masked(by: policy) - } - if let bounded = try await driver.executeBoundedQuery(query: query, rowCap: rowCap) { - return bounded.masked(by: policy) + return try await driver.executeRead(query: query).masked(by: policy) } - return try await driver.executeRead(query: query).masked(by: policy) } } diff --git a/apple/TableProTests/Core/Autocomplete/SQLSchemaProviderTests.swift b/apple/TableProTests/Core/Autocomplete/SQLSchemaProviderTests.swift index f1c4945f43..ea12aa4994 100644 --- a/apple/TableProTests/Core/Autocomplete/SQLSchemaProviderTests.swift +++ b/apple/TableProTests/Core/Autocomplete/SQLSchemaProviderTests.swift @@ -134,8 +134,12 @@ final class MockDatabaseDriver: DatabaseDriver, SchemaSwitchable, @unchecked Sen // A statement holding this text fails, the way a server rejects one statement of a script. var failsStatementContaining: (text: String, error: any Error)? + // Holds `execute` until the test opens it, whether or not the task awaiting it is cancelled. + var executeGate: AsyncGate? + func execute(query: String) async throws -> QueryResult { executedQueries.append(query) + await executeGate?.wait() if let failure = failsStatementContaining, query.contains(failure.text) { throw failure.error } if executeDelaySeconds > 0 { try await Task.sleep(nanoseconds: UInt64(executeDelaySeconds * 1_000_000_000)) diff --git a/apple/TableProTests/Core/Execution/EditModeDataCommandsCommandTests.swift b/apple/TableProTests/Core/Execution/EditModeDataCommandsCommandTests.swift index be5d5a9f94..fcdabc4ed7 100644 --- a/apple/TableProTests/Core/Execution/EditModeDataCommandsCommandTests.swift +++ b/apple/TableProTests/Core/Execution/EditModeDataCommandsCommandTests.swift @@ -81,10 +81,11 @@ struct EditModeDataCommandsCommandTests { #expect(refusal(sql, on: .memcached) == nil) } - @Test("A Memcached delete is a data change the destructive rule refuses") - func memcachedDeleteIsData() { + @Test("Edit runs a Memcached delete, which takes one key, and refuses flush_all as destructive") + func memcachedDeleteRunsInEdit() { #expect(QueryClassifier.isDataStatement("delete k", databaseType: .memcached)) - #expect(refusal("delete k", on: .memcached) == .denied(ExternalStatementGate.destructiveRefusal)) + #expect(refusal("delete k", on: .memcached) == nil) + #expect(refusal("flush_all", on: .memcached) == .denied(ExternalStatementGate.destructiveRefusal)) } @Test("Edit refuses an etcd command that changes no data", arguments: [ @@ -96,15 +97,22 @@ struct EditModeDataCommandsCommandTests { } @Test("Edit still refuses the etcd commands refused before", arguments: [ - "auth disable", "user delete app", "compaction 5", "lease revoke 694da1d22d63c20a", "del app/a", "defrag", + "auth disable", "user delete app", "compaction 5", "lease revoke 694da1d22d63c20a", "del app/ --prefix", "defrag", ]) func etcdKeepsEarlierRefusals(sql: String) { #expect(refusal(sql, on: .etcd) != nil) } + @Test("Edit refuses an etcd del of a prefix or a range as destructive", arguments: [ + "del app/ --prefix", "del --prefix app/", "del app/a app/z", "del --from-key app/a", "del app/ --prefix=true", + ]) + func etcdManyKeyDeleteIsDestructive(sql: String) { + #expect(refusal(sql, on: .etcd) == .denied(ExternalStatementGate.destructiveRefusal)) + } + @Test("Edit runs etcd reads and data changes", arguments: [ - "put app/a 1", "put app/a 1 --lease=694da1d22d63c20a", "create app/b 2", "lease grant 60", - "lease keep-alive 694da1d22d63c20a", "get app/ --prefix", "user list", + "put app/a 1", "put app/a 1 --lease=694da1d22d63c20a", "create app/b 2", "del app/a", "delete app/a", + "lease grant 60", "lease keep-alive 694da1d22d63c20a", "get app/ --prefix", "user list", ]) func etcdRunsDataWork(sql: String) { #expect(refusal(sql, on: .etcd) == nil) @@ -127,4 +135,31 @@ struct EditModeDataCommandsCommandTests { func kafkaRunsDataWork(sql: String) { #expect(refusal(sql, on: .kafka) == nil) } + + @Test("Edit refuses PRODUCE into a topic another service keeps its state in", arguments: [ + "PRODUCE INTO \"_schemas\" KEY \"k\" VALUE \"v\"", + "PRODUCE INTO \"_confluent-ksql-default__command_topic\" VALUE \"v\"", + "PRODUCE INTO \"__consumer_offsets\" VALUE \"v\"", + "PRODUCE INTO \"connect-configs\" KEY \"connector-sink\" VALUE \"{}\"", + "PRODUCE INTO \"connect-offsets\" VALUE \"v\"", + "PRODUCE INTO \"connect-status\" VALUE \"v\"", + "PRODUCE INTO \"mm2-configs.east.internal\" VALUE \"v\"", + "PRODUCE INTO \"east.checkpoints.internal\" VALUE \"v\"", + "PRODUCE INTO \".hidden\" VALUE \"v\"", + "PRODUCE INTO \"orders-app-counts-store-changelog\" VALUE \"v\"", + "PRODUCE INTO \"orders-app-KSTREAM-AGGREGATE-0000000003-repartition\" VALUE \"v\"", + ]) + func kafkaRefusesServiceTopics(sql: String) { + #expect(refusal(sql, on: .kafka) == .denied(ExternalStatementGate.dataStatementRefusal)) + } + + @Test("A topic that only looks like a service's is a user's", arguments: [ + "PRODUCE INTO \"schemas\" VALUE \"v\"", + "PRODUCE INTO \"my_connect-configs\" VALUE \"v\"", + "PRODUCE INTO \"orders.internal\" VALUE \"v\"", + "CONSUME \"_schemas\" FROM OLDEST LIMIT 10", + ]) + func kafkaRunsUserTopics(sql: String) { + #expect(refusal(sql, on: .kafka) == nil) + } } diff --git a/apple/TableProTests/Core/Execution/EditModeDataCommandsRequestTests.swift b/apple/TableProTests/Core/Execution/EditModeDataCommandsRequestTests.swift index a58d5543f6..8ee124d131 100644 --- a/apple/TableProTests/Core/Execution/EditModeDataCommandsRequestTests.swift +++ b/apple/TableProTests/Core/Execution/EditModeDataCommandsRequestTests.swift @@ -208,8 +208,7 @@ struct EditModeDataCommandsRequestTests { #expect(refusal(sql, on: .bigtable) == nil) } - // Every HTTP DELETE tiers destructive, so the destructive rule refuses it before the data rule reads the list. - @Test("A data delete is on its engine's list, and Edit still refuses it as destructive", arguments: [ + @Test("Edit runs a delete of one item by its id or key, which is a write", arguments: [ (DatabaseType.elasticsearch, "DELETE /orders/_doc/1"), (.typesense, "DELETE /collections/books/documents/1"), (.qdrant, #"POST /collections/docs/points/delete\#n{"points": [1]}"#), @@ -218,8 +217,27 @@ struct EditModeDataCommandsRequestTests { (.firebaseRealtimeDatabase, "DELETE users/alice"), (.bigtable, "DELETE events/user#42"), ]) - func dataDeleteIsListedButDestructive(type: DatabaseType, sql: String) { + func oneItemDeleteRunsInEdit(type: DatabaseType, sql: String) { #expect(QueryClassifier.isDataStatement(sql, databaseType: type)) + #expect(refusal(sql, on: type) == nil) + } + + @Test("Edit refuses a delete of a container, a batch, a filter or every item as destructive", arguments: [ + (DatabaseType.elasticsearch, "DELETE /orders"), + (.elasticsearch, "DELETE /orders,archive/_doc/1"), + (.elasticsearch, #"POST /orders/_delete_by_query\#n{"query": {"match_all": {}}}"#), + (.typesense, "DELETE /collections/books/documents?filter_by=year:<2000"), + (.qdrant, #"POST /collections/docs/points/delete\#n{"points": [1, 2]}"#), + (.qdrant, #"POST /collections/docs/points/delete\#n{"filter": {"must": [{"key": "city", "match": {"value": "x"}}]}}"#), + (.weaviate, "DELETE /v1/objects/36ddd591-2dee-4e7e-a3cc-eb86d30a4303"), + (.weaviate, #"DELETE /v1/batch/objects\#n{"match": {"class": "Article", "where": {"operator": "Like", "path": ["id"], "valueText": "*"}}}"#), + (.firestore, "DELETE users"), + (.firebaseRealtimeDatabase, "DELETE users"), + (.firebaseRealtimeDatabase, #"PATCH / {"users": null}"#), + (.firebaseRealtimeDatabase, #"PUT users {"x": {"name": "a"}}"#), + (.firebaseRealtimeDatabase, #"PATCH / {"users": {"x": 1}}"#), + ]) + func manyItemDeleteIsRefusedInEdit(type: DatabaseType, sql: String) { #expect(refusal(sql, on: type) == .denied(ExternalStatementGate.destructiveRefusal)) } diff --git a/apple/TableProTests/Core/Execution/ExternalStatementGateTests.swift b/apple/TableProTests/Core/Execution/ExternalStatementGateTests.swift index 5f2566a69f..c1ea551ec6 100644 --- a/apple/TableProTests/Core/Execution/ExternalStatementGateTests.swift +++ b/apple/TableProTests/Core/Execution/ExternalStatementGateTests.swift @@ -82,9 +82,21 @@ struct ExternalStatementGateTests { #expect(refused == (runs ? nil : .denied(ExternalStatementGate.dataStatementRefusal))) } + @Test("Edit runs a SurrealQL DELETE of one record by id, and refuses one of a table or a range as destructive", arguments: [ + ("DELETE person:three", false), + ("DELETE person", true), + ("DELETE person:1..3", true), + ]) + func surrealRecordDeleteInEdit(sql: String, refused: Bool) { + let edit = statement(sql, databaseType: .surrealdb, allowsDestructive: false, allowsOnlyDataStatements: true) + #expect(refusal(edit) == (refused ? .denied(ExternalStatementGate.destructiveRefusal) : nil)) + } + @Test("A write into a keyspace or database the engine keeps its own state in is a system scope") func systemScopesOfOtherLanguages() { #expect(QueryClassifier.writesSystemScope(database: "system_auth", schema: nil, databaseType: .cassandra)) + #expect(QueryClassifier.writesSystemScope(database: "audit", schema: nil, databaseType: .scylladb)) + #expect(!QueryClassifier.writesSystemScope(database: "audit", schema: nil, databaseType: .cassandra)) #expect(QueryClassifier.writesSystemScope(database: "admin", schema: nil, databaseType: .mongodb)) #expect(!QueryClassifier.writesSystemScope(database: "shop", schema: nil, databaseType: .mongodb)) #expect(!QueryClassifier.writesSystemScope(database: "admin", schema: nil, databaseType: .postgresql)) diff --git a/apple/TableProTests/Core/Utilities/SQL/EtcdCommandParserTests.swift b/apple/TableProTests/Core/Utilities/SQL/EtcdCommandParserTests.swift index 4b4a7a6637..129021733c 100644 --- a/apple/TableProTests/Core/Utilities/SQL/EtcdCommandParserTests.swift +++ b/apple/TableProTests/Core/Utilities/SQL/EtcdCommandParserTests.swift @@ -392,6 +392,23 @@ struct EtcdCommandParserDelTests { try EtcdCommandParser.parse("del") } } + + @Test("A del of one key is a write, and a del of a prefix is destructive") + func delTier() throws { + #expect(try EtcdCommandParser.parse("del mykey").tier == .write) + #expect(try EtcdCommandParser.parse("delete mykey").tier == .write) + #expect(try EtcdCommandParser.parse("del --prefix -- --cache/").tier == .destructive) + #expect(try EtcdCommandParser.parse("del /app/ --prefix").tier == .destructive) + #expect(try EtcdCommandParser.parse(#"del "" --prefix"#).tier == .destructive) + } + + @Test("A del etcdctl reads as a range is refused, and graded destructive", arguments: [ + "del /a /z", "del --from-key /a", "del /a --from-key=true", "del /a --prefix=true", "del /a --prefix=false", + ]) + func delOfARangeIsRefused(line: String) { + #expect(throws: EtcdParseError.self) { try EtcdCommandParser.parse(line) } + #expect(QueryClassifier.classifyTier(line, databaseType: .etcd) == .destructive) + } } struct EtcdCommandParserWatchTests { @@ -1162,10 +1179,10 @@ private let etcdReadLines = [ ] private let etcdWriteLines = [ "put /a v", "lease grant 60", "lease keep-alive 1", "auth enable", "user add bob pw", "role add readers", - "user grant-role bob readers", "user revoke-role bob readers", "create /a v", + "user grant-role bob readers", "user revoke-role bob readers", "create /a v", "del /a", "delete /a", ] private let etcdDeleteLines = [ - "del /a", #"del "" --prefix"#, "del /app/ --prefix", "compaction 5", "lease revoke 1", "auth disable", + #"del "" --prefix"#, "del /app/ --prefix", "compaction 5", "lease revoke 1", "auth disable", "user delete bob", "role delete readers", "mv /a /b v --mod-rev=3", "mv /a /b v", ] diff --git a/apple/TableProTests/Core/Utilities/SQL/QueryClassifierEmbeddedStatementTests.swift b/apple/TableProTests/Core/Utilities/SQL/QueryClassifierEmbeddedStatementTests.swift index 4233b88457..00c8c9d25d 100644 --- a/apple/TableProTests/Core/Utilities/SQL/QueryClassifierEmbeddedStatementTests.swift +++ b/apple/TableProTests/Core/Utilities/SQL/QueryClassifierEmbeddedStatementTests.swift @@ -67,6 +67,17 @@ struct QueryClassifierEmbeddedStatementTests { } } + @Test("A SurrealQL DELETE of one record by id is a row change, on its own or inside another statement") + func surrealQLRecordDeleteIsAWrite() { + for sql in ["DELETE person:tobie", "DELETE ONLY person:⟨tobie⟩ RETURN BEFORE", "SELECT * FROM (DELETE person:tobie)"] { + #expect(QueryClassifier.classifyTier(sql, databaseType: .surrealdb) == .write, "\(sql)") + #expect(!QueryClassifier.isDangerousQuery(sql, databaseType: .surrealdb), "\(sql)") + } + for sql in ["DELETE person", "DELETE person:1..10", "DELETE person:a, person:b", "SELECT * FROM (DELETE person:..)"] { + #expect(QueryClassifier.isDangerousQuery(sql, databaseType: .surrealdb), "\(sql)") + } + } + @Test("A CockroachDB SELECT from a bracketed statement that writes is a write", arguments: [ "SELECT * FROM [DELETE FROM orders RETURNING id]", "SELECT * FROM [ UPDATE orders SET total = 0 RETURNING id ]", diff --git a/apple/TableProTests/Core/Utilities/SQL/QueryClassifierHardeningTests.swift b/apple/TableProTests/Core/Utilities/SQL/QueryClassifierHardeningTests.swift index 01da6e95ba..cab145eb8f 100644 --- a/apple/TableProTests/Core/Utilities/SQL/QueryClassifierHardeningTests.swift +++ b/apple/TableProTests/Core/Utilities/SQL/QueryClassifierHardeningTests.swift @@ -685,7 +685,8 @@ struct QueryClassifierNonSqlTests { #expect(!QueryClassifier.isWriteQuery("get /keys", databaseType: .etcd)) #expect(!QueryClassifier.isWriteQuery("watch /keys", databaseType: .etcd)) #expect(QueryClassifier.isWriteQuery("put /keys value", databaseType: .etcd)) - #expect(QueryClassifier.classifyTier("del /keys", databaseType: .etcd) == .destructive) + #expect(QueryClassifier.classifyTier("del /keys", databaseType: .etcd) == .write) + #expect(QueryClassifier.classifyTier("del /keys --prefix", databaseType: .etcd) == .destructive) #expect(QueryClassifier.classifyTier("compact 5", databaseType: .etcd) == .destructive) #expect(QueryClassifier.reachesFilesystemOrExecutesCode("snapshot save backup.db", databaseType: .etcd)) } @@ -698,7 +699,7 @@ struct QueryClassifierNonSqlTests { "user delete alice", "role delete readers", "auth disable", - "delete /keys", + "delete /keys --prefix", "compaction 5 --physical" ] for statement in destructive { @@ -827,8 +828,9 @@ struct QueryClassifierNonSqlTests { QueryClassifier.classifyTier( "DELETE /collections/books/documents/1", databaseType: .typesense - ) == .destructive + ) == .write ) + #expect(QueryClassifier.classifyTier("DELETE /collections/books", databaseType: .typesense) == .destructive) } /// The body of a Typesense console request is the caller's own JSON. Scanning the whole @@ -1037,7 +1039,7 @@ struct QueryClassifierNonSqlTests { #expect(!QueryClassifier.reachesFilesystemOrExecutesCode("GET /collections", databaseType: .qdrant)) } - @Test("Memcached reads are safe, stores write, and delete and flush_all are destructive") + @Test("Memcached reads are safe, stores and delete write, and flush_all is destructive") func memcachedTiers() { #expect(!QueryClassifier.isWriteQuery("MEMCACHED_BROWSE:e30=", databaseType: .memcached)) #expect(!QueryClassifier.isWriteQuery("get user:1 user:2", databaseType: .memcached)) @@ -1054,12 +1056,16 @@ struct QueryClassifierNonSqlTests { #expect(QueryClassifier.classifyTier("set k 0 0 \"v\"", databaseType: .memcached) == .write) #expect(QueryClassifier.classifyTier("gat 60 k", databaseType: .memcached) == .write) #expect(QueryClassifier.classifyTier("touch k 0", databaseType: .memcached) == .write) - #expect(QueryClassifier.classifyTier("delete k", databaseType: .memcached) == .destructive) + #expect(QueryClassifier.classifyTier("delete k", databaseType: .memcached) == .write) #expect(QueryClassifier.classifyTier("FLUSH_ALL", databaseType: .memcached) == .destructive) #expect(QueryClassifier.classifyTier("get k; flush_all", databaseType: .memcached) == .destructive) + // The driver decodes an escape inside a quoted word before it names the command. + #expect(QueryClassifier.classifyTier(#""flush\x5fall""#, databaseType: .memcached) == .destructive) + #expect(QueryClassifier.classifyTier(#""flush\_all""#, databaseType: .memcached) == .destructive) + #expect(QueryClassifier.classifyTier(#""\x67et" k"#, databaseType: .memcached) == .safe) } - @Test("Bigtable request lines are tiered by their verb, and a PUT that nulls a cell is destructive") + @Test("Bigtable request lines are tiered by their verb, and a change to one row is a write, deletes included") func bigtableTiers() { #expect(!QueryClassifier.isWriteQuery("BIGTABLE_BROWSE:e30=", databaseType: .bigtable)) #expect(!QueryClassifier.isWriteQuery("GET events/user#42", databaseType: .bigtable)) @@ -1067,9 +1073,9 @@ struct QueryClassifierNonSqlTests { #expect(!QueryClassifier.isWriteQuery("READ events {\"rowsLimit\": \"5\"}", databaseType: .bigtable)) #expect(QueryClassifier.classifyTier("INSERT events/k {\"cf:a\": \"1\"}", databaseType: .bigtable) == .write) #expect(QueryClassifier.classifyTier("PUT events/k {\"cf:a\": \"1\"}", databaseType: .bigtable) == .write) - #expect(QueryClassifier.classifyTier("PUT events/k {\"cf:a\": null}", databaseType: .bigtable) == .destructive) - #expect(QueryClassifier.classifyTier("PUT events/\"a{b\" {\"cf:a\": null}", databaseType: .bigtable) == .destructive) - #expect(QueryClassifier.classifyTier("DELETE events/k", databaseType: .bigtable) == .destructive) + #expect(QueryClassifier.classifyTier("PUT events/k {\"cf:a\": null}", databaseType: .bigtable) == .write) + #expect(QueryClassifier.classifyTier("PUT events/\"a{b\" {\"cf:a\": null}", databaseType: .bigtable) == .write) + #expect(QueryClassifier.classifyTier("DELETE events/k", databaseType: .bigtable) == .write) #expect(QueryClassifier.isWriteQuery("SELECT * FROM events", databaseType: .bigtable)) } @@ -1166,19 +1172,27 @@ struct QueryClassifierNonSqlTests { #expect(QueryClassifier.isWriteQuery("POST users {}", databaseType: type)) #expect(QueryClassifier.isWriteQuery("PUT /config/maintenance false", databaseType: type)) #expect(QueryClassifier.isWriteQuery("SELECT * FROM users", databaseType: type)) - #expect(QueryClassifier.classifyTier("DELETE users/alice", databaseType: type) == .destructive) + #expect(QueryClassifier.classifyTier("DELETE users/alice", databaseType: type) == .write) + #expect(QueryClassifier.classifyTier("DELETE users", databaseType: type) == .destructive) } } - @Test("A Firebase write that replaces the root or leaves a node empty ranks with DELETE") + @Test("A Firebase write that replaces the root or a Realtime Database table, or leaves a node empty, ranks with DELETE") func firebaseWritesThatDelete() { for type in [DatabaseType.firestore, .firebaseRealtimeDatabase] { #expect(QueryClassifier.classifyTier("PUT / {\"a\": 1}", databaseType: type) == .destructive) #expect(QueryClassifier.classifyTier("PUT %2F 1", databaseType: type) == .destructive) #expect(QueryClassifier.classifyTier("PUT users null", databaseType: type) == .destructive) #expect(QueryClassifier.classifyTier("PUT users\n{\"a\": {}, \"b\": [null]}", databaseType: type) == .destructive) - #expect(QueryClassifier.classifyTier("PUT users {\"a\": 1}", databaseType: type) == .write) + #expect(QueryClassifier.classifyTier("PUT users/alice {\"a\": 1}", databaseType: type) == .write) } + #expect(QueryClassifier.classifyTier("PUT users {\"a\": 1}", databaseType: .firestore) == .write) + // A top-level node is a table: replacing it drops every record under it. + #expect(QueryClassifier.classifyTier("PUT users {\"a\": 1}", databaseType: .firebaseRealtimeDatabase) == .destructive) + #expect(QueryClassifier.classifyTier("PATCH / {\"users\": {\"x\": 1}}", databaseType: .firebaseRealtimeDatabase) == .destructive) + #expect(QueryClassifier.classifyTier("PATCH / {\"users/x\": 1}", databaseType: .firebaseRealtimeDatabase) == .write) + #expect(QueryClassifier.classifyTier("PATCH users {\"x\": {\"n\": 1}}", databaseType: .firebaseRealtimeDatabase) == .write) + #expect(QueryClassifier.classifyTier("POST users {\"n\": 1}", databaseType: .firebaseRealtimeDatabase) == .write) #expect(QueryClassifier.classifyTier("PATCH / {\"users\": null}", databaseType: .firebaseRealtimeDatabase) == .destructive) #expect(QueryClassifier.classifyTier("PATCH users/a {\"n\": 1}", databaseType: .firebaseRealtimeDatabase) == .write) #expect(QueryClassifier.classifyTier("PATCH users/a {\"n\": null}", databaseType: .firestore) == .write) @@ -1191,12 +1205,12 @@ struct QueryClassifierNonSqlTests { #expect(QueryClassifier.classifyTier("PUT users {\".value\": null, \".priority\": 1}", databaseType: type) == .destructive) #expect(QueryClassifier.classifyTier("PUT users {\"a\": {\".priority\": 1}}", databaseType: type) == .destructive) #expect(QueryClassifier.classifyTier("PUT users {\".value\": {\".priority\": 1}}", databaseType: type) == .destructive) - #expect(QueryClassifier.classifyTier("PUT users {\".value\": 5, \".priority\": 1}", databaseType: type) == .write) - #expect(QueryClassifier.classifyTier("PUT users {\".sv\": \"timestamp\"}", databaseType: type) == .write) - #expect(QueryClassifier.classifyTier("PUT users {\"a\": 1, \".priority\": 1}", databaseType: type) == .write) + #expect(QueryClassifier.classifyTier("PUT users/a {\".value\": 5, \".priority\": 1}", databaseType: type) == .write) + #expect(QueryClassifier.classifyTier("PUT users/a {\".sv\": \"timestamp\"}", databaseType: type) == .write) + #expect(QueryClassifier.classifyTier("PUT users/a {\"a\": 1, \".priority\": 1}", databaseType: type) == .write) } #expect(QueryClassifier.classifyTier("PATCH / {\"users\": {\".priority\": 1}}", databaseType: .firebaseRealtimeDatabase) == .destructive) - #expect(QueryClassifier.classifyTier("PATCH users {\".priority\": 1}", databaseType: .firebaseRealtimeDatabase) == .write) + #expect(QueryClassifier.classifyTier("PATCH users/a {\".priority\": 1}", databaseType: .firebaseRealtimeDatabase) == .write) } @Test("A Firebase path that starts with a mark is tiered as the driver reads it", arguments: [ @@ -1206,11 +1220,13 @@ struct QueryClassifierNonSqlTests { for type in [DatabaseType.firestore, .firebaseRealtimeDatabase] { #expect(QueryClassifier.classifyTier("PUT \(name) null", databaseType: type) == .destructive) #expect(QueryClassifier.classifyTier(FirebaseRequest(method: .put, path: name, body: "null").text, databaseType: type) == .destructive) - #expect(QueryClassifier.classifyTier("PUT \(name) {\"a\": 1}", databaseType: type) == .write) + #expect(QueryClassifier.classifyTier("PUT \(name)/a {\"a\": 1}", databaseType: type) == .write) #expect(QueryClassifier.classifyTier("DELETE \(name)", databaseType: type) == .destructive) #expect(QueryClassifier.classifyTier("GET \(name)", databaseType: type) == .safe) } - #expect(QueryClassifier.classifyTier("PATCH \(name) {\"x\": null}", databaseType: .firebaseRealtimeDatabase) == .destructive) + #expect(QueryClassifier.classifyTier("PUT \(name) {\"a\": 1}", databaseType: .firestore) == .write) + // Read as the root, this PATCH would remove a top-level node; read as the driver does, it removes one record. + #expect(QueryClassifier.classifyTier("PATCH \(name) {\"x\": null}", databaseType: .firebaseRealtimeDatabase) == .write) } @Test("A console body declaring a mutation is classified the same as a bare one") @@ -1247,13 +1263,12 @@ struct QueryClassifierNonSqlTests { } @Test("A request text is tiered by the requests the scanner hands the driver", arguments: [ - (DatabaseType.firestore, "GET users", "DELETE users/alice"), - (.firebaseRealtimeDatabase, "GET users", "DELETE users/alice"), - (.bigtable, "GET events/k", "DELETE events/k"), + (DatabaseType.firestore, "GET users", "DELETE users"), + (.firebaseRealtimeDatabase, "GET users", "DELETE users"), (.typesense, "GET /collections", "DELETE /collections/books"), (.weaviate, "GET /v1/schema", "DELETE /v1/schema/Article"), (.elasticsearch, "GET /_cat/indices", "DELETE /orders"), - (.etcd, "get /keys", "del /keys") + (.etcd, "get /keys", "del /keys --prefix") ]) func requestTextTiersWhatTheDriverReceives(type: DatabaseType, read: String, delete: String) { for text in [";\(delete)", "\(read);\(delete)", "--\n;\(delete)", "--\r\(read)\n;\(delete)", "/**/;\(delete)"] { @@ -1264,6 +1279,19 @@ struct QueryClassifierNonSqlTests { } } + // Every Bigtable change touches one row, so the hidden one is a write. + @Test("A Bigtable request text is tiered by the requests the scanner hands the driver") + func bigtableRequestTextTiersWhatTheDriverReceives() { + let read = "GET events/k" + let delete = "DELETE events/k" + for text in [";\(delete)", "\(read);\(delete)", "--\n;\(delete)", "--\r\(read)\n;\(delete)", "/**/;\(delete)"] { + #expect(QueryClassifier.classifyTier(text, databaseType: .bigtable) == .write, "\(text) must be a write") + } + for text in ["\(read);", ";\(read)", "-- note\n;\(read)", "-- \(delete)", ";"] { + #expect(QueryClassifier.classifyTier(text, databaseType: .bigtable) == .safe, "\(text) must be safe") + } + } + @Test("Elasticsearch stored scripts are flagged as code execution on both verbs") func elasticsearchScriptsAreFlagged() { #expect( diff --git a/apple/TableProTests/Core/Utilities/SQL/QueryClassifierOneItemDeleteTests.swift b/apple/TableProTests/Core/Utilities/SQL/QueryClassifierOneItemDeleteTests.swift new file mode 100644 index 0000000000..b33a43fd38 --- /dev/null +++ b/apple/TableProTests/Core/Utilities/SQL/QueryClassifierOneItemDeleteTests.swift @@ -0,0 +1,112 @@ +// +// QueryClassifierOneItemDeleteTests.swift +// TableProTests +// + +import Foundation +@testable import TablePro +import TableProSQLGrammar +import TableProWeaviateCore +import Testing + +struct QueryClassifierOneItemDeleteTests { + @Test("A delete of one item by its id or key is a write", arguments: [ + (DatabaseType.elasticsearch, "DELETE /orders/_doc/1"), + (.elasticsearch, "DELETE orders/_doc/1?refresh=true&routing=a"), + (.elasticsearch, "DELETE /orders/_doc/1\n{}"), + (.typesense, "DELETE /collections/books/documents/1"), + (.typesense, "DELETE /collections/books/documents/1?ignore_not_found=true"), + (.qdrant, #"POST /collections/docs/points/delete\#n{"points": [1]}"#), + (.qdrant, #"POST /collections/docs/points/delete?wait=true {"points": ["5c56c793-69f3-4fbf-87e6-c4bf54c28c26"]}"#), + (.qdrant, #"POST /collections/docs/points/delete\#n{"points": [7], "shard_key": "eu"}"#), + (.weaviate, "DELETE /v1/objects/Article/36ddd591-2dee-4e7e-a3cc-eb86d30a4303"), + (.weaviate, "DELETE /objects/Article/36ddd591-2dee-4e7e-a3cc-eb86d30a4303?tenant=t1"), + (.weaviate, #"DELETE /v1/objects/Article/36ddd591-2dee-4e7e-a3cc-eb86d30a4303/references/author\#n{"beacon": "weaviate://localhost/Author/1"}"#), + (.weaviate, "DELETE /v1/objects/36ddd591-2dee-4e7e-a3cc-eb86d30a4303/references/author"), + (.firestore, "DELETE users/alice"), + (.firestore, "DELETE users/alice/orders/1"), + (.firebaseRealtimeDatabase, "DELETE users/alice"), + (.firebaseRealtimeDatabase, "DELETE /users/alice/age"), + (.firebaseRealtimeDatabase, "PUT users/alice null"), + (.firebaseRealtimeDatabase, #"PUT users/alice {".priority": 1}"#), + (.firebaseRealtimeDatabase, #"PATCH users {"alice": null}"#), + (.firebaseRealtimeDatabase, #"PATCH / {"users/alice": null, "users/bob/age": 3}"#), + (.firebaseRealtimeDatabase, #"PATCH users/alice {"age": null}"#), + (.bigtable, "DELETE events/user#42"), + (.bigtable, "DELETE events/user#42 profile:name"), + (.bigtable, #"PUT events/user#42 {"profile:name": null}"#), + (.bigtable, #"PUT events/"a{b" {"cf:a": null}"#), + ]) + func oneItemDeleteIsAWrite(type: DatabaseType, request: String) { + #expect(QueryClassifier.classifyTier(request, databaseType: type) == .write) + #expect(!QueryClassifier.isDangerousQuery(request, databaseType: type)) + } + + @Test("A delete of a container, every item, a batch, a filter or a range stays destructive", arguments: [ + (DatabaseType.elasticsearch, "DELETE /orders"), + (.elasticsearch, "DELETE /orders/_doc"), + (.elasticsearch, "DELETE /orders/_doc/"), + (.elasticsearch, "DELETE /orders/_doc/1/extra"), + (.elasticsearch, "DELETE /orders/_doc/_query"), + (.elasticsearch, "DELETE /_all/_doc/1"), + (.elasticsearch, "DELETE /a,b/_doc/1"), + (.elasticsearch, "DELETE /orders*/_doc/1"), + (.elasticsearch, "DELETE /remote:orders/_doc/1"), + (.elasticsearch, "DELETE /-orders/_doc/1"), + (.elasticsearch, "DELETE /.security-7/_doc/1"), + (.elasticsearch, "DELETE /%3Clogs-%7Bnow%7D%3E/_doc/1"), + (.elasticsearch, "DELETE /orders/_doc/../_doc/1"), + (.elasticsearch, "DELETE //orders/_doc/1"), + (.typesense, "DELETE /collections/books"), + (.typesense, "DELETE /collections/books/documents?filter_by=x:1"), + (.typesense, "DELETE /collections/books/documents/1/../"), + (.typesense, "DELETE /aliases/a"), + (.typesense, "DELETE /keys/1"), + (.qdrant, #"POST /collections/docs/points/delete\#n{"points": [1, 2]}"#), + (.qdrant, #"POST /collections/docs/points/delete\#n{"filter": {"must": [{"key": "city", "match": {"value": "x"}}]}}"#), + (.qdrant, #"POST /collections/docs/points/delete\#n{"points": [1], "filter": {}}"#), + (.qdrant, #"POST /collections/docs/points/delete\#n{"points": [[1]]}"#), + (.qdrant, "POST /collections/docs/points/delete"), + (.qdrant, #"POST /collections/docs/points/payload/delete\#n{"keys": ["a"], "points": [1]}"#), + (.qdrant, #"POST /collections/docs/points/vectors/delete\#n{"vector": ["v"], "points": [1]}"#), + (.qdrant, #"POST /collections/docs/points/batch\#n{"operations": [{"delete": {"points": [1]}}]}"#), + (.qdrant, "DELETE /collections/docs"), + (.weaviate, "DELETE /v1/batch/objects"), + (.weaviate, "DELETE /v1/schema/Article"), + (.weaviate, "DELETE /v1/schema/Article/tenants"), + (.weaviate, "DELETE /v1/objects/36ddd591-2dee-4e7e-a3cc-eb86d30a4303"), + (.weaviate, "DELETE /v1/objects/Article/../36ddd591-2dee-4e7e-a3cc-eb86d30a4303"), + (.firestore, "DELETE users"), + (.firestore, "DELETE /"), + (.firestore, "DELETE ./alice"), + (.firebaseRealtimeDatabase, "DELETE users"), + (.firebaseRealtimeDatabase, "DELETE /"), + (.firebaseRealtimeDatabase, "PUT users null"), + (.firebaseRealtimeDatabase, #"PATCH / {"users": null}"#), + (.firebaseRealtimeDatabase, #"PATCH / {"users": {"alice": null}}"#), + (.firebaseRealtimeDatabase, #"PATCH / {"users/alice": null, "orders": null}"#), + (.firebaseRealtimeDatabase, #"PATCH users {"": null}"#), + (.firebaseRealtimeDatabase, "DELETE .settings/rules"), + ]) + func manyItemDeleteStaysDestructive(type: DatabaseType, request: String) { + #expect(QueryClassifier.classifyTier(request, databaseType: type) == .destructive) + #expect(QueryClassifier.isDangerousQuery(request, databaseType: type)) + } + + // The server deletes a class-less `/v1/objects/` in every class, so only the class route is one object. + @Test("A grid delete of a Weaviate object is tiered by the path it sends", arguments: [ + ("/v1/objects/Article/36ddd591-2dee-4e7e-a3cc-eb86d30a4303", QueryTier.write), + ("/v1/objects/36ddd591-2dee-4e7e-a3cc-eb86d30a4303", .destructive), + ("/v1/batch/objects", .destructive), + ]) + func weaviateTaggedDeleteFollowsItsPath(path: String, tier: QueryTier) { + let write = WeaviateWriteRequest(method: "DELETE", path: path, query: ["class": "Article"], body: nil) + #expect(QueryClassifier.weaviateClassification(WeaviateWriteCodec.encode(write)).tier == tier) + } + + @Test("Firestore PUT and PATCH keep their tiers") + func firestorePutAndPatchUnchanged() { + #expect(QueryClassifier.classifyTier("PUT users/alice null", databaseType: .firestore) == .destructive) + #expect(QueryClassifier.classifyTier(#"PATCH users/alice {"age": null}"#, databaseType: .firestore) == .write) + } +} diff --git a/apple/TableProTests/ViewModels/DashboardTileBoardTests.swift b/apple/TableProTests/ViewModels/DashboardTileBoardTests.swift index 43904ad2fd..ca22114b39 100644 --- a/apple/TableProTests/ViewModels/DashboardTileBoardTests.swift +++ b/apple/TableProTests/ViewModels/DashboardTileBoardTests.swift @@ -21,6 +21,7 @@ struct DashboardTileBoardTests { let changes = PassthroughSubject() var catalog: DashboardSavedQueryCatalog var executed: [String] = [] + var executedIn: [DatabaseScope?] = [] var answer: (String) throws -> QueryResult = { _ in Fixture.result(columns: ["count"], rows: [["12"]]) } var clock = Date(timeIntervalSince1970: 1_000_000) var gate: any ExecutionGate = AlwaysAllowGate() @@ -59,8 +60,9 @@ struct DashboardTileBoardTests { connectionId: connectionId, databaseType: databaseType, environment: environment - ) { sql in + ) { sql, scope in self.executed.append(sql) + self.executedIn.append(scope) if let hold = self.holdExecution { await hold.wait() } @@ -194,11 +196,13 @@ struct DashboardTileBoardTests { await board.refresh(force: false) #expect(await gate.requests.count == 1) #expect(await gate.requests.first?.runsIn?.schema == "HR") + #expect(fixture.executedIn.last == fixture.runsIn) fixture.runsIn = DatabaseScope(connectionId: fixture.connectionId, database: "FREEPDB1", schema: "APP") await board.refresh(force: false) #expect(await gate.requests.count == 2) #expect(await gate.requests.last?.runsIn?.schema == "APP") + #expect(fixture.executedIn.last == fixture.runsIn) fixture.clock.addTimeInterval(61) await board.refresh(force: false) diff --git a/apple/TableProTests/ViewModels/DashboardTileSessionTurnTests.swift b/apple/TableProTests/ViewModels/DashboardTileSessionTurnTests.swift new file mode 100644 index 0000000000..aff3d9d75b --- /dev/null +++ b/apple/TableProTests/ViewModels/DashboardTileSessionTurnTests.swift @@ -0,0 +1,106 @@ +// +// DashboardTileSessionTurnTests.swift +// TableProTests +// + +import Combine +import Foundation +@testable import TablePro +import TableProPluginKit +import TableProTestSupport +import Testing + +@MainActor +struct DashboardTileSessionTurnTests { + private static let saved = SQLFavorite(name: "Queued jobs", query: "SELECT count(*) FROM jobs") + + private struct Fixture { + let connection: DatabaseConnection + let driver: MockDatabaseDriver + let viewModel: ServerDashboardViewModel + let suite: EphemeralDefaults + } + + // The tile layout is stored before the dashboard opens, so nothing runs until the test asks. + private func makeFixture(checked schema: String) throws -> Fixture { + let connection = TestFixtures.makeConnection(database: "app", type: .mysql) + let driver = MockDatabaseDriver(connection: connection) + driver.currentSchema = schema + var session = ConnectionSession(connection: connection, driver: driver) + session.status = .connected + session.browseDatabase = "app" + DatabaseManager.shared.injectSession(session, for: connection.id) + + let suite = try EphemeralDefaults() + let defaults = suite.defaults + let storage = ServerDashboardTileStorage(defaults: { defaults }) + storage.save(ServerDashboardTileLayout(tiles: [DashboardTile(favoriteId: Self.saved.id)]), for: connection.id) + let checked = DatabaseScope(connectionId: connection.id, database: "app", schema: schema) + let viewModel = ServerDashboardViewModel( + connectionId: connection.id, + databaseType: .mysql, + services: .live, + tileEnvironment: DashboardTileBoard.Environment( + loadCatalog: { _ in DashboardSavedQueryCatalog(favorites: [Self.saved], folders: []) }, + savedQueriesDidChange: Empty().eraseToAnyPublisher(), + gate: AlwaysAllowGate(), + forcesWrite: { _ in false }, + safeModeLevel: { _ in .silent }, + chartsAvailable: { false }, + nullDisplay: { "NULL" }, + storage: storage, + runsIn: { _ in checked } + ) + ) + return Fixture(connection: connection, driver: driver, viewModel: viewModel, suite: suite) + } + + // A tab moves the shared driver to its own schema in its turn and leaves it there. + @Test("A tile waits for the session's turn and runs in the schema the gate was asked about") + func tileRunsInItsTurnPinnedToTheCheckedSchema() async throws { + let fixture = try makeFixture(checked: "hr") + defer { DatabaseManager.shared.removeSession(for: fixture.connection.id) } + let driver = fixture.driver + + let acquired = AsyncGate() + let release = AsyncGate() + let tab = Task { @MainActor in + try await DatabaseManager.shared.sessionDriverGate.withExclusiveAccess( + DatabaseManager.shared.browsedGateKey(for: fixture.connection.id) + ) { + driver.currentSchema = "sales" + await acquired.open() + await release.wait() + } + } + await acquired.wait() + + let refresh = Task { await fixture.viewModel.tileBoard.refresh(force: true) } + try await waitUntil { DatabaseManager.shared.sessionDriverGate.waiterCount(for: fixture.connection.id) >= 1 } + #expect(driver.executedQueries.isEmpty) + + await release.open() + try await tab.value + await refresh.value + + #expect(driver.executedQueries.contains(Self.saved.query)) + #expect(driver.currentSchema == "hr") + } + + @Test("Cancelling a tile's run cancels its statement on the server") + func cancelledTileStopsOnTheServer() async throws { + let fixture = try makeFixture(checked: "hr") + defer { DatabaseManager.shared.removeSession(for: fixture.connection.id) } + let driver = fixture.driver + let held = AsyncGate() + driver.executeGate = held + + let refresh = Task { await fixture.viewModel.tileBoard.refresh(force: true) } + try await waitUntil { driver.executedQueries.contains(Self.saved.query) } + refresh.cancel() + try await waitUntil { driver.cancelQueryCallCount >= 1 } + + await held.open() + await refresh.value + } +} diff --git a/apple/scripts/probes/check-match-recognize-calls.sh b/apple/scripts/probes/check-match-recognize-calls.sh new file mode 100755 index 0000000000..5aa5b6e57e --- /dev/null +++ b/apple/scripts/probes/check-match-recognize-calls.sh @@ -0,0 +1,91 @@ +#!/usr/bin/env bash +# +# Check that MATCH_RECOGNIZE's navigation calls never reach a user function of the same name, which +# Packages/TableProCore/Sources/TableProSQLGrammar/SQLReadOnlyFunctionCalls.swift (RowPatternClauses) and +# SQLBareNameCalls+Parser.swift (the row pattern clause) rely on, and that the same names outside the clause do. +# +# Usage: +# scripts/probes/check-match-recognize-calls.sh oracle # gvenzl/oracle-free:23-slim-faststart, APP_USER probe +# scripts/probes/check-match-recognize-calls.sh dameng # a DM8 image, SYSDBA password in DM8_PASSWORD +# +# Creates functions PREV, NEXT, FIRST, LAST, CLASSIFIER, MATCH_NUMBER, RUNNING, FINAL and WIPE, each writing a row, +# and tables ORDERS and AUDIT_LOG. Each line prints the query and `calls` (a user function ran), `runs` (none ran) +# or `error` (the server refused the query); compare with SQLReadOnlyFunctionCallsTests and SQLBareNameCallsTests. + +set -uo pipefail + +ENGINE="${1:?oracle or dameng}" +CONTAINER="${2:?container name}" + +case "$ENGINE" in + oracle) + run_sql() { docker exec -i "$CONTAINER" sqlplus -s probe/probe_pw@FREEPDB1; } + ;; + dameng) + PASSWORD="${DM8_PASSWORD:?set DM8_PASSWORD}" + run_sql() { + docker exec -i "$CONTAINER" bash -c "cat > /tmp/tp-probe.sql && cd /home/dmdba/dmdbms/bin \ + && ./disql -S SYSDBA/$PASSWORD@localhost:5236 \\\`/tmp/tp-probe.sql" + } + ;; + *) + echo "unknown engine: $ENGINE" >&2 + exit 3 + ;; +esac + +{ + echo "CREATE TABLE orders (id NUMBER, purge NUMBER);" + echo "INSERT INTO orders VALUES (1, 100);" + echo "INSERT INTO orders VALUES (2, 50);" + echo "INSERT INTO orders VALUES (3, 80);" + echo "CREATE TABLE audit_log (n NUMBER);" + echo "COMMIT;" + for name in prev next first last; do + printf 'CREATE OR REPLACE FUNCTION %s(v NUMBER) RETURN NUMBER IS PRAGMA AUTONOMOUS_TRANSACTION; BEGIN INSERT INTO audit_log VALUES (1); COMMIT; RETURN v; END;\n/\n' "$name" + done + for name in classifier match_number running final wipe; do + printf 'CREATE OR REPLACE FUNCTION %s RETURN NUMBER IS PRAGMA AUTONOMOUS_TRANSACTION; BEGIN INSERT INTO audit_log VALUES (2); COMMIT; RETURN 7; END;\n/\n' "$name" + done + echo "EXIT" +} | run_sql > /dev/null + +MR="SELECT * FROM orders MATCH_RECOGNIZE (ORDER BY id" + +while IFS= read -r query; do + out="$(printf 'DELETE FROM audit_log;\nCOMMIT;\n%s\nSELECT '"'"'audit='"'"' || COUNT(*) FROM audit_log;\nEXIT\n' "$query" | run_sql 2>&1)" + if printf '%s' "$out" | grep -qE 'ORA-|\[-[0-9]+\]'; then + verdict=error + elif printf '%s' "$out" | grep -q 'audit=0'; then + verdict=runs + else + verdict=calls + fi + printf '%-6s %s\n' "$verdict" "$query" +done < 0); +$MR MEASURES CLASSIFIER() AS c, MATCH_NUMBER() AS m ALL ROWS PER MATCH PATTERN (x) DEFINE x AS 1 = 1); +$MR MEASURES FINAL LAST(x.purge) AS l, RUNNING COUNT(*) AS c ALL ROWS PER MATCH PATTERN (x+) DEFINE x AS 1 = 1); +$MR MEASURES RUNNING LAST(x.purge) AS l ALL ROWS PER MATCH PATTERN (x+) DEFINE x AS RUNNING COUNT(*) < 9); +$MR MEASURES x.id AS wipe ONE ROW PER MATCH PATTERN (x) DEFINE x AS 1 = 1); +$MR MEASURES wipe AS w ONE ROW PER MATCH PATTERN (x) DEFINE x AS 1 = 1); +$MR MEASURES wipe() AS w ONE ROW PER MATCH PATTERN (x) DEFINE x AS 1 = 1); +$MR MEASURES x.id AS i ONE ROW PER MATCH PATTERN (x) DEFINE x AS wipe = 7); +$MR MEASURES x.id AS i ONE ROW PER MATCH PATTERN (PERMUTE(x, y)) DEFINE x AS x.id = 1, y AS y.id = 2); +$MR MEASURES x.id AS i ONE ROW PER MATCH AFTER MATCH SKIP TO LAST y PATTERN (x y) DEFINE x AS 1 = 1, y AS 1 = 1); +$MR MEASURES x.id AS i ONE ROW PER MATCH PATTERN (x) DEFINE x AS x.purge > (SELECT prev(1) FROM dual)); +$MR MEASURES x.id AS i ALL ROWS PER MATCH PATTERN (^ x {- y -} z* $) DEFINE x AS PREV(x.purge, 1) IS NULL, y AS ABS(PREV(y.purge)) > 0, z AS 1 = 1); +SELECT * FROM orders MATCH_RECOGNIZE (PARTITION BY prev(purge) ORDER BY id MEASURES x.id AS i ONE ROW PER MATCH PATTERN (x) DEFINE x AS 1 = 1); +$MR MEASURES x.id AS subset, wipe AS w ONE ROW PER MATCH PATTERN (x) DEFINE x AS 1 = 1); +$MR MEASURES x.id AS define, wipe AS w ONE ROW PER MATCH PATTERN (x) DEFINE x AS 1 = 1); +$MR MEASURES x.id AS i ONE ROW PER MATCH PATTERN (x) DEFINE x AS x.purge > ((SELECT 1 FROM dual WHERE 1 = 0) UNION ALL SELECT prev(1) FROM dual)); +$MR MEASURES x.id AS i ONE ROW PER MATCH PATTERN (x) DEFINE x AS EXISTS ((SELECT 1 FROM dual WHERE 1 = 0) UNION ALL SELECT prev(1) FROM dual)); +SELECT * FROM (SELECT id, purge, 1 AS subset FROM orders) MATCH_RECOGNIZE (ORDER BY id MEASURES x.subset + wipe AS m ONE ROW PER MATCH PATTERN (x) DEFINE x AS 1 = 1); +QUERIES From 519c774a52a9ebf3504cd0ae5549a74738339d60 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Fri, 13 Nov 2026 15:14:28 +0700 Subject: [PATCH 2/2] chore(macos): add changelog fragments for #4262 --- apple/changelog.d/4262.changed.1.md | 1 + apple/changelog.d/4262.changed.md | 1 + apple/changelog.d/4262.fixed.1.md | 1 + apple/changelog.d/4262.fixed.md | 1 + apple/changelog.d/4262.security.1.md | 1 + apple/changelog.d/4262.security.2.md | 1 + apple/changelog.d/4262.security.md | 1 + 7 files changed, 7 insertions(+) create mode 100644 apple/changelog.d/4262.changed.1.md create mode 100644 apple/changelog.d/4262.changed.md create mode 100644 apple/changelog.d/4262.fixed.1.md create mode 100644 apple/changelog.d/4262.fixed.md create mode 100644 apple/changelog.d/4262.security.1.md create mode 100644 apple/changelog.d/4262.security.2.md create mode 100644 apple/changelog.d/4262.security.md diff --git a/apple/changelog.d/4262.changed.1.md b/apple/changelog.d/4262.changed.1.md new file mode 100644 index 0000000000..86f415c409 --- /dev/null +++ b/apple/changelog.d/4262.changed.1.md @@ -0,0 +1 @@ +Read-Only runs Oracle MATCH_RECOGNIZE queries that use PREV, NEXT, FIRST, LAST, CLASSIFIER or MATCH_NUMBER. diff --git a/apple/changelog.d/4262.changed.md b/apple/changelog.d/4262.changed.md new file mode 100644 index 0000000000..e2e666f0a6 --- /dev/null +++ b/apple/changelog.d/4262.changed.md @@ -0,0 +1 @@ +Deleting one document, row or key by its ID is a write, so AI Edit mode and MCP's execute_query can run it. diff --git a/apple/changelog.d/4262.fixed.1.md b/apple/changelog.d/4262.fixed.1.md new file mode 100644 index 0000000000..33e66e9af5 --- /dev/null +++ b/apple/changelog.d/4262.fixed.1.md @@ -0,0 +1 @@ +An etcd del with a range end or --from-key deleted only its first key. diff --git a/apple/changelog.d/4262.fixed.md b/apple/changelog.d/4262.fixed.md new file mode 100644 index 0000000000..23dc692d20 --- /dev/null +++ b/apple/changelog.d/4262.fixed.md @@ -0,0 +1 @@ +Deleting a Weaviate row in the grid also deleted objects with the same ID in other collections. diff --git a/apple/changelog.d/4262.security.1.md b/apple/changelog.d/4262.security.1.md new file mode 100644 index 0000000000..fb17948cce --- /dev/null +++ b/apple/changelog.d/4262.security.1.md @@ -0,0 +1 @@ +A Server Dashboard tile runs in the schema Read-Only checked, after any statement a query tab is running. diff --git a/apple/changelog.d/4262.security.2.md b/apple/changelog.d/4262.security.2.md new file mode 100644 index 0000000000..2f3e142407 --- /dev/null +++ b/apple/changelog.d/4262.security.2.md @@ -0,0 +1 @@ +Replacing a Realtime Database top-level node, or an escaped Memcached flush_all, now counts as destructive. diff --git a/apple/changelog.d/4262.security.md b/apple/changelog.d/4262.security.md new file mode 100644 index 0000000000..75e50bb03f --- /dev/null +++ b/apple/changelog.d/4262.security.md @@ -0,0 +1 @@ +AI Edit mode refuses writes into ScyllaDB's audit log and Kafka topics of Schema Registry, Connect or Streams.