feat: D1 batch execution, DDL generation, skip transactions for unsupported drivers (#575)

Author: datlechin

CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Cloudflare D1: batch query execution via REST API for multi-statement SQL
+- Cloudflare D1: schema editing — CREATE TABLE, ADD/DROP COLUMN, CREATE/DROP INDEX
+
+### Fixed
+
+- Multi-statement SQL execution fails on Cloudflare D1, ClickHouse, and other drivers that don't support transactions
+
 ### Changed
 
 - Use Apple-standard `xcodebuild archive` + `exportArchive` build pipeline with dSYM collection

Plugins/CloudflareD1DriverPlugin/CloudflareD1Plugin.swift

@@ -25,7 +25,7 @@ final class CloudflareD1Plugin: NSObject, TableProPlugin, DriverPlugin {
     static let supportsSSL = false
     static let isDownloadable = true
     static let supportsImport = false
-    static let supportsSchemaEditing = false
+    static let supportsSchemaEditing = true
     static let databaseGroupingStrategy: GroupingStrategy = .flat
     static let brandColorHex = "#F6821F"
     static let urlSchemes: [String] = ["d1"]

Plugins/CloudflareD1DriverPlugin/CloudflareD1PluginDriver.swift

@@ -145,6 +145,21 @@ final class CloudflareD1PluginDriver: PluginDatabaseDriver, @unchecked Sendable
         return mapRawResult(payload, executionTime: executionTime)
     }
 
+    func executeBatch(queries: [String]) async throws -> [PluginQueryResult] {
+        guard let client = getClient() else {
+            throw CloudflareD1Error.notConnected
+        }
+
+        let startTime = Date()
+        let statements = queries.map { (sql: $0, params: nil as [Any?]?) }
+        let payloads = try await client.executeBatchRaw(statements: statements)
+        let elapsed = Date().timeIntervalSince(startTime)
+
+        return payloads.enumerated().map { _, payload in
+            mapRawResult(payload, executionTime: payload.meta?.duration ?? (elapsed / Double(payloads.count)))
+        }
+    }
+
     func cancelQuery() throws {
         lock.lock()
         httpClient?.cancelCurrentTask()
@@ -577,8 +592,111 @@ final class CloudflareD1PluginDriver: PluginDatabaseDriver, @unchecked Sendable
         throw CloudflareD1Error(message: String(localized: "Transactions are not supported by Cloudflare D1"))
     }
 
+    // MARK: - DDL Generation
+
+    func generateCreateTableSQL(definition: PluginCreateTableDefinition) -> String? {
+        guard !definition.columns.isEmpty else { return nil }
+
+        let tableName = quoteIdentifier(definition.tableName)
+        let pkColumns = definition.columns.filter { $0.isPrimaryKey }
+        let inlinePK = pkColumns.count == 1
+        var parts: [String] = definition.columns.map { d1ColumnDefinition($0, inlinePK: inlinePK) }
+
+        if pkColumns.count > 1 {
+            let pkCols = pkColumns.map { quoteIdentifier($0.name) }.joined(separator: ", ")
+            parts.append("PRIMARY KEY (\(pkCols))")
+        }
+
+        for fk in definition.foreignKeys {
+            parts.append(d1ForeignKeyDefinition(fk))
+        }
+
+        let sql = "CREATE TABLE \(tableName) (\n  " +
+            parts.joined(separator: ",\n  ") +
+            "\n);"
+
+        return sql
+    }
+
+    func generateAddColumnSQL(table: String, column: PluginColumnDefinition) -> String? {
+        var def = "\(quoteIdentifier(column.name)) \(column.dataType)"
+        if !column.isNullable { def += " NOT NULL" }
+        if let defaultValue = column.defaultValue, !defaultValue.isEmpty {
+            def += " DEFAULT \(d1DefaultValue(defaultValue))"
+        }
+        return "ALTER TABLE \(quoteIdentifier(table)) ADD COLUMN \(def)"
+    }
+
+    func generateDropColumnSQL(table: String, columnName: String) -> String? {
+        "ALTER TABLE \(quoteIdentifier(table)) DROP COLUMN \(quoteIdentifier(columnName))"
+    }
+
+    func generateAddIndexSQL(table: String, index: PluginIndexDefinition) -> String? {
+        let uniqueStr = index.isUnique ? "UNIQUE " : ""
+        let cols = index.columns.map { quoteIdentifier($0) }.joined(separator: ", ")
+        return "CREATE \(uniqueStr)INDEX \(quoteIdentifier(index.name)) ON \(quoteIdentifier(table)) (\(cols))"
+    }
+
+    func generateDropIndexSQL(table: String, indexName: String) -> String? {
+        "DROP INDEX IF EXISTS \(quoteIdentifier(indexName))"
+    }
+
+    func generateColumnDefinitionSQL(column: PluginColumnDefinition) -> String? {
+        d1ColumnDefinition(column, inlinePK: column.isPrimaryKey)
+    }
+
+    func generateIndexDefinitionSQL(index: PluginIndexDefinition, tableName: String?) -> String? {
+        let uniqueStr = index.isUnique ? "UNIQUE " : ""
+        let cols = index.columns.map { quoteIdentifier($0) }.joined(separator: ", ")
+        let onClause = tableName.map { " ON \(quoteIdentifier($0))" } ?? ""
+        return "CREATE \(uniqueStr)INDEX \(quoteIdentifier(index.name))\(onClause) (\(cols))"
+    }
+
+    func generateForeignKeyDefinitionSQL(fk: PluginForeignKeyDefinition) -> String? {
+        d1ForeignKeyDefinition(fk)
+    }
+
     // MARK: - Private Helpers
 
+    private func d1ColumnDefinition(_ col: PluginColumnDefinition, inlinePK: Bool) -> String {
+        var def = "\(quoteIdentifier(col.name)) \(col.dataType)"
+        if inlinePK && col.isPrimaryKey {
+            def += " PRIMARY KEY"
+            if col.autoIncrement {
+                def += " AUTOINCREMENT"
+            }
+        }
+        if !col.isNullable {
+            def += " NOT NULL"
+        }
+        if let defaultValue = col.defaultValue {
+            def += " DEFAULT \(d1DefaultValue(defaultValue))"
+        }
+        return def
+    }
+
+    private func d1DefaultValue(_ value: String) -> String {
+        let upper = value.uppercased()
+        if upper == "NULL" || upper == "CURRENT_TIMESTAMP" || upper == "CURRENT_DATE" || upper == "CURRENT_TIME"
+            || value.hasPrefix("'") || Int64(value) != nil || Double(value) != nil {
+            return value
+        }
+        return "'\(escapeStringLiteral(value))'"
+    }
+
+    private func d1ForeignKeyDefinition(_ fk: PluginForeignKeyDefinition) -> String {
+        let cols = fk.columns.map { quoteIdentifier($0) }.joined(separator: ", ")
+        let refCols = fk.referencedColumns.map { quoteIdentifier($0) }.joined(separator: ", ")
+        var def = "FOREIGN KEY (\(cols)) REFERENCES \(quoteIdentifier(fk.referencedTable)) (\(refCols))"
+        if fk.onDelete != "NO ACTION" {
+            def += " ON DELETE \(fk.onDelete)"
+        }
+        if fk.onUpdate != "NO ACTION" {
+            def += " ON UPDATE \(fk.onUpdate)"
+        }
+        return def
+    }
+
     private func getClient() -> D1HttpClient? {
         lock.lock()
         defer { lock.unlock() }

Plugins/CloudflareD1DriverPlugin/D1HttpClient.swift

@@ -200,6 +200,24 @@ final class D1HttpClient: @unchecked Sendable {
         return first
     }
 
+    func executeBatchRaw(statements: [(sql: String, params: [Any?]?)]) async throws -> [D1RawResultPayload] {
+        let dbId = databaseId
+        let batch = statements.map { stmt -> [String: Any] in
+            var entry: [String: Any] = ["sql": stmt.sql]
+            if let params = stmt.params {
+                entry["params"] = params.map { $0 ?? NSNull() }
+            }
+            return entry
+        }
+        let body = try JSONSerialization.data(withJSONObject: ["batch": batch])
+
+        let url = try baseURL(databaseId: dbId).appendingPathComponent("raw")
+        let data = try await performRequest(url: url, method: "POST", body: body)
+        let envelope = try JSONDecoder().decode(D1ApiResponse<[D1RawResultPayload]>.self, from: data)
+        try checkApiSuccess(envelope)
+        return envelope.result ?? []
+    }
+
     func getDatabaseDetails() async throws -> D1DatabaseInfo {
         let dbId = databaseId
         let url = try baseURL(databaseId: dbId)

TablePro/Core/Database/DatabaseDriver.swift

@@ -129,6 +129,9 @@ protocol DatabaseDriver: AnyObject {
 
     // MARK: - Transaction Management
 
+    /// Whether this driver supports transactions (e.g., Cloudflare D1, ClickHouse do not)
+    var supportsTransactions: Bool { get }
+
     /// Begin a transaction
     func beginTransaction() async throws
 
@@ -308,6 +311,8 @@ extension DatabaseDriver {
     /// Default: no schema support (MySQL/SQLite don't use schemas in the same way)
     func fetchSchemas() async throws -> [String] { [] }
 
+    var supportsTransactions: Bool { true }
+
     /// Default no-op implementation for drivers that don't support query cancellation
     func cancelQuery() throws {
         // No-op by default

TablePro/Core/Plugins/PluginDriverAdapter.swift

@@ -279,6 +279,10 @@ final class PluginDriverAdapter: DatabaseDriver, SchemaSwitchable {
 
     // MARK: - Transaction Management
 
+    var supportsTransactions: Bool {
+        pluginDriver.supportsTransactions
+    }
+
     func beginTransaction() async throws {
         try await pluginDriver.beginTransaction()
     }

TablePro/Views/Main/Extensions/MainContentCoordinator+MultiStatement.swift

@@ -48,12 +48,17 @@ extension MainContentCoordinator {
                     throw DatabaseError.notConnected
                 }
 
-                // Wrap in a transaction for atomicity
-                try await driver.beginTransaction()
+                let useTransaction = driver.supportsTransactions
+
+                if useTransaction {
+                    try await driver.beginTransaction()
+                }
 
                 /// Rollback transaction and reset executing state for early exits.
                 @MainActor func rollbackAndResetState() async {
-                    try? await driver.rollbackTransaction()
+                    if useTransaction {
+                        try? await driver.rollbackTransaction()
+                    }
                     if let idx = tabManager.tabs.firstIndex(where: { $0.id == tabId }) {
                         tabManager.tabs[idx].isExecuting = false
                     }
@@ -115,8 +120,9 @@ extension MainContentCoordinator {
                     }
                 }
 
-                // Commit the transaction
-                try await driver.commitTransaction()
+                if useTransaction {
+                    try await driver.commitTransaction()
+                }
 
                 // All statements succeeded — update tab with results
                 await MainActor.run {
@@ -131,8 +137,7 @@ extension MainContentCoordinator {
                     )
                 }
             } catch {
-                // Rollback on failure
-                if let driver = DatabaseManager.shared.driver(for: conn.id) {
+                if let driver = DatabaseManager.shared.driver(for: conn.id), driver.supportsTransactions {
                     try? await driver.rollbackTransaction()
                 }