Use sqlite3_trace_v2 where available

Author: jberkel

SQLite/Core/Connection.swift

@@ -412,23 +412,67 @@ public final class Connection {
     ///
     ///       db.trace { SQL in print(SQL) }
     public func trace(_ callback: ((String) -> Void)?) {
+        if #available(iOS 10.0, OSX 10.12, tvOS 10.0, watchOS 3.0, *) {
+            trace_v2(callback)
+        } else {
+            trace_v1(callback)
+        }
+    }
+
+    fileprivate func trace_v1(_ callback: ((String) -> Void)?) {
         guard let callback = callback else {
-            sqlite3_trace(handle, nil, nil)
+            sqlite3_trace(handle, nil /* xCallback */, nil /* pCtx */)
             trace = nil
             return
         }
-
-        let box: Trace = { callback(String(cString: $0)) }
-        sqlite3_trace(handle, {
-            (callback: UnsafeMutableRawPointer?, SQL: UnsafePointer<Int8>?) in
-                 guard let callback = callback, let SQL = SQL else { return }
-                 unsafeBitCast(callback, to: Trace.self)(SQL)
+        let box: Trace = { (pointer: UnsafeRawPointer) in
+            callback(String(cString: pointer.assumingMemoryBound(to: UInt8.self)))
+        }
+        sqlite3_trace(handle,
+            {
+                (C: UnsafeMutableRawPointer?, SQL: UnsafePointer<Int8>?) in
+                    if let C = C, let SQL = SQL {
+                        unsafeBitCast(C, to: Trace.self)(SQL)
+                    }
             },
             unsafeBitCast(box, to: UnsafeMutableRawPointer.self)
         )
         trace = box
     }
-    fileprivate typealias Trace = @convention(block) (UnsafePointer<Int8>) -> Void
+
+    @available(iOS 10.0, OSX 10.12, tvOS 10.0, watchOS 3.0, *)
+    fileprivate func trace_v2(_ callback: ((String) -> Void)?) {
+        guard let callback = callback else {
+            // If the X callback is NULL or if the M mask is zero, then tracing is disabled.
+            sqlite3_trace_v2(handle, 0 /* mask */, nil /* xCallback */, nil /* pCtx */)
+            trace = nil
+            return
+        }
+
+        let box: Trace = { (pointer: UnsafeRawPointer) in
+            callback(String(cString: pointer.assumingMemoryBound(to: UInt8.self)))
+        }
+        sqlite3_trace_v2(handle,
+            UInt32(SQLITE_TRACE_STMT) /* mask */,
+            {
+                // A trace callback is invoked with four arguments: callback(T,C,P,X).
+                // The T argument is one of the SQLITE_TRACE constants to indicate why the
+                // callback was invoked. The C argument is a copy of the context pointer.
+                // The P and X arguments are pointers whose meanings depend on T.
+                (T: UInt32, C: UnsafeMutableRawPointer?, P: UnsafeMutableRawPointer?, X: UnsafeMutableRawPointer?) in
+                    if let P = P,
+                       let expandedSQL = sqlite3_expanded_sql(OpaquePointer(P)) {
+                        unsafeBitCast(C, to: Trace.self)(expandedSQL)
+                        sqlite3_free(expandedSQL)
+                    }
+                    return Int32(0) // currently ignored
+            },
+            unsafeBitCast(box, to: UnsafeMutableRawPointer.self) /* pCtx */
+        )
+        trace = box
+    }
+
+    fileprivate typealias Trace = @convention(block) (UnsafeRawPointer) -> Void
     fileprivate var trace: Trace?
 
     /// Registers a callback to be invoked whenever a row is inserted, updated,

SQLiteTests/ConnectionTests.swift

@@ -94,6 +94,12 @@ class ConnectionTests : SQLiteTestCase {
         AssertSQL("SELECT count(*) FROM users WHERE admin = 0", 4)
     }
 
+    func test_execute_comment() {
+        try! db.run("-- this is a comment\nSELECT 1")
+        AssertSQL("-- this is a comment", 0)
+        AssertSQL("SELECT 1", 0)
+    }
+
     func test_transaction_executesBeginDeferred() {
         try! db.transaction(.deferred) {}