TableProApp
diff --git a/‎CHANGELOG.md‎
Lines changed: 8 additions & 0 deletions b/‎CHANGELOG.md‎
Lines changed: 8 additions & 0 deletions
diff --git a/‎Packages/TableProCore/Package.swift‎
Lines changed: 11 additions & 0 deletions b/‎Packages/TableProCore/Package.swift‎
Lines changed: 11 additions & 0 deletions
diff --git a/‎Packages/TableProCore/Sources/TableProGeometry/GeoJSONGeometryReader.swift‎
Lines changed: 117 additions & 0 deletions b/‎Packages/TableProCore/Sources/TableProGeometry/GeoJSONGeometryReader.swift‎
Lines changed: 117 additions & 0 deletions
diff --git a/‎Packages/TableProCore/Sources/TableProGeometry/SpatialGeometry.swift‎
Lines changed: 138 additions & 0 deletions b/‎Packages/TableProCore/Sources/TableProGeometry/SpatialGeometry.swift‎
Lines changed: 138 additions & 0 deletions
@@ -28,6 +28,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Show DDL** and **Copy DDL** for views and materialized views. (#2726)
 - **Edit Comment…** for PostgreSQL tables, views, materialized views and foreign tables. (#2726)
 - UTF-16 LE, UTF-16 BE and Windows-1252 in the SQL import encoding menu.
+- Map view for a result holding a geometry column, drawn with MapKit over Apple's own tiles. (#2532)
 - **Max INSERT size** for SQL export, 1 MB by default. (#2533)
 - Largest INSERT written, in the SQL export summary. (#2533)
 
@@ -78,6 +79,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Snowflake foreign keys into another database opening the current database's same-named table.
 - Wrong database read, and written, by a connection whose startup commands select one of their own.
 - **None** in the foreign key picker's Label menu forgotten on reopen.
+- Elasticsearch `geo_point` columns classified as integers.
+- MySQL and MariaDB geometry values losing their SRID.
+- MySQL `GEOMETRYCOLLECTION` columns classified as text.
+- Empty `GEOMETRYCOLLECTION` from MySQL rendered as invalid WKT.
+- MySQL geometry with a Z or M ordinate read from the wrong offset.
+- Elasticsearch `geo_shape` values cut off at 10,000 characters.
+- A tab stranded in JSON or Chart mode, with no way back to Data, after a statement that returns no columns.
 - **Prompt for password** lost when importing a TablePlus connection set to **Ask everytime**.
 - TablePlus import saving a password for a connection TablePlus was set never to store one for.
 - TablePlus import reading the CA certificate and client key paths the wrong way round.
 
@@ -10,6 +10,7 @@ let package = Package(
     ],
     products: [
         .library(name: "TableProCoreTypes", targets: ["TableProCoreTypes"]),
+        .library(name: "TableProGeometry", targets: ["TableProGeometry"]),
         .library(name: "TableProPluginKit", targets: ["TableProPluginKit"]),
         .library(name: "TableProModels", targets: ["TableProModels"]),
         .library(name: "TableProImport", targets: ["TableProImport"]),
@@ -38,6 +39,11 @@ let package = Package(
             dependencies: [],
             path: "Sources/TableProCoreTypes"
         ),
+        .target(
+            name: "TableProGeometry",
+            dependencies: [],
+            path: "Sources/TableProGeometry"
+        ),
         .target(
             name: "TableProPluginKit",
             dependencies: [],
@@ -113,6 +119,11 @@ let package = Package(
             dependencies: [],
             path: "Sources/TableProR2SQLCore"
         ),
+        .testTarget(
+            name: "TableProGeometryTests",
+            dependencies: ["TableProGeometry"],
+            path: "Tests/TableProGeometryTests"
+        ),
         .testTarget(
             name: "TableProNumberFormattingTests",
             dependencies: ["TableProNumberFormatting"],
 
@@ -0,0 +1,117 @@
+import Foundation
+
+/// Reads the GeoJSON that MongoDB, Snowflake and Elasticsearch hand over.
+///
+/// RFC 7946 fixes two things this reader relies on: coordinates are `[longitude, latitude]`, and
+/// the coordinate reference system is always WGS84, so a decoded value reports SRID 4326 rather
+/// than nil. A third position is altitude and is dropped, exactly as `MKGeoJSONDecoder` does.
+///
+/// `MKGeoJSONDecoder` covers this format natively and is used in preference where a whole document
+/// is being read, but it rejects an entire document when one coordinate is out of range
+/// (`MKErrorDomain` code 6, measured), which would blank a result over a single bad row. Reading
+/// per value keeps one bad row to itself.
+public enum GeoJSONGeometryReader {
+    public static func read(_ text: String) -> Result<SpatialValue, SpatialReadFailure> {
+        guard let data = text.data(using: .utf8) else { return .failure(.notGeometry) }
+        return read(data)
+    }
+
+    public static func read(_ data: Data) -> Result<SpatialValue, SpatialReadFailure> {
+        guard let root = try? JSONSerialization.jsonObject(with: data),
+              let object = root as? [String: Any]
+        else {
+            return .failure(.notGeometry)
+        }
+        guard let geometry = geometry(from: object, depth: 1) else { return .failure(.notGeometry) }
+        return .success(SpatialValue(srid: 4326, geometry: geometry))
+    }
+
+    public static func looksLikeGeoJSON(_ text: String) -> Bool {
+        guard let first = text.first(where: { !$0.isWhitespace }), first == "{" else { return false }
+        return text.contains("\"type\"") && (text.contains("\"coordinates\"")
+            || text.contains("\"geometry\"")
+            || text.contains("\"geometries\"")
+            || text.contains("\"features\""))
+    }
+
+    private static func geometry(from object: [String: Any], depth: Int) -> SpatialGeometry? {
+        guard depth <= SpatialLimits.maximumNestingDepth else { return nil }
+        guard let type = object["type"] as? String else { return nil }
+        switch type {
+        case "Feature":
+            guard let nested = object["geometry"] as? [String: Any] else { return nil }
+            return geometry(from: nested, depth: depth + 1)
+        case "FeatureCollection":
+            guard let features = object["features"] as? [[String: Any]] else { return nil }
+            let children = features.compactMap { geometry(from: $0, depth: depth + 1) }
+            return children.count == 1 ? children[0] : .collection(children)
+        case "GeometryCollection":
+            guard let members = object["geometries"] as? [[String: Any]] else { return nil }
+            return .collection(members.compactMap { geometry(from: $0, depth: depth + 1) })
+        case "Point":
+            guard let point = position(object["coordinates"]) else { return nil }
+            return .point(point)
+        case "MultiPoint":
+            guard let points = positions(object["coordinates"]) else { return nil }
+            return .multiPoint(points)
+        case "LineString":
+            guard let points = positions(object["coordinates"]) else { return nil }
+            return .lineString(points)
+        case "MultiLineString":
+            guard let lines = positionRings(object["coordinates"]) else { return nil }
+            return .multiLineString(lines)
+        case "Polygon":
+            guard let rings = positionRings(object["coordinates"]) else { return nil }
+            return .polygon(rings: rings)
+        case "MultiPolygon":
+            guard let raw = object["coordinates"] as? [Any] else { return nil }
+            var polygons: [[[SpatialPoint]]] = []
+            polygons.reserveCapacity(raw.count)
+            for entry in raw {
+                guard let rings = positionRings(entry) else { return nil }
+                polygons.append(rings)
+            }
+            return .multiPolygon(polygons)
+        default:
+            return nil
+        }
+    }
+
+    private static func position(_ raw: Any?) -> SpatialPoint? {
+        guard let values = raw as? [Any], values.count >= 2,
+              let x = double(values[0]), let y = double(values[1])
+        else {
+            return nil
+        }
+        return SpatialPoint(x: x, y: y)
+    }
+
+    private static func positions(_ raw: Any?) -> [SpatialPoint]? {
+        guard let entries = raw as? [Any] else { return nil }
+        var points: [SpatialPoint] = []
+        points.reserveCapacity(entries.count)
+        for entry in entries {
+            guard let point = position(entry) else { return nil }
+            points.append(point)
+        }
+        return points
+    }
+
+    private static func positionRings(_ raw: Any?) -> [[SpatialPoint]]? {
+        guard let entries = raw as? [Any] else { return nil }
+        var rings: [[SpatialPoint]] = []
+        rings.reserveCapacity(entries.count)
+        for entry in entries {
+            guard let ring = positions(entry) else { return nil }
+            rings.append(ring)
+        }
+        return rings
+    }
+
+    private static func double(_ raw: Any) -> Double? {
+        if let value = raw as? Double { return value }
+        if let value = raw as? Int { return Double(value) }
+        if let value = raw as? NSNumber { return value.doubleValue }
+        return nil
+    }
+}
@@ -0,0 +1,138 @@
+import Foundation
+
+public struct SpatialPoint: Equatable, Sendable {
+    public let x: Double
+    public let y: Double
+
+    public init(x: Double, y: Double) {
+        self.x = x
+        self.y = y
+    }
+}
+
+/// A geometry as the database describes it, in the coordinate system its SRID names.
+///
+/// Deliberately not MapKit types: the same value has to survive projection, an extent fold and a
+/// refusal, and only the drawing layer knows about `CLLocationCoordinate2D`. Z and M ordinates are
+/// read so the cursor stays in step with the wire format and then dropped, because MapKit draws on
+/// a sphere and has nowhere to put them.
+public indirect enum SpatialGeometry: Equatable, Sendable {
+    case point(SpatialPoint)
+    case lineString([SpatialPoint])
+    /// The first ring is the exterior; every later ring is a hole.
+    case polygon(rings: [[SpatialPoint]])
+    case multiPoint([SpatialPoint])
+    case multiLineString([[SpatialPoint]])
+    case multiPolygon([[[SpatialPoint]]])
+    case collection([SpatialGeometry])
+    case empty
+}
+
+/// What the engine handed over, with the coordinate system it named.
+///
+/// `srid` is nil when the value carried none, which is not the same as zero. PostGIS writes no
+/// `SRID=` prefix for 0 and MySQL's wire format writes a literal 0, and both mean "unknown" rather
+/// than "a coordinate system numbered zero".
+public struct SpatialValue: Equatable, Sendable {
+    public let srid: Int32?
+    public let geometry: SpatialGeometry
+
+    public init(srid: Int32?, geometry: SpatialGeometry) {
+        self.srid = srid
+        self.geometry = geometry
+    }
+}
+
+/// Why a cell could not be read as a geometry.
+///
+/// `unsupportedGeometryType` carries the keyword so the pane can name it. PostGIS hands out
+/// `CIRCULARSTRING`, `CURVEPOLYGON` and `TIN` values that no amount of parsing turns into line
+/// segments, and a user told "3 shapes could not be drawn" learns nothing; told
+/// "CIRCULARSTRING is not supported" they know what to do.
+public enum SpatialReadFailure: Error, Equatable, Sendable {
+    case notGeometry
+    case unsupportedGeometryType(String)
+    case malformed
+}
+
+public extension SpatialGeometry {
+    var isEmpty: Bool {
+        switch self {
+        case .empty:
+            return true
+        case .point:
+            return false
+        case .lineString(let points), .multiPoint(let points):
+            return points.isEmpty
+        case .polygon(let rings):
+            return rings.allSatisfy(\.isEmpty)
+        case .multiLineString(let lines):
+            return lines.allSatisfy(\.isEmpty)
+        case .multiPolygon(let polygons):
+            return polygons.allSatisfy { $0.allSatisfy(\.isEmpty) }
+        case .collection(let children):
+            return children.allSatisfy(\.isEmpty)
+        }
+    }
+
+    /// Every coordinate in the geometry, in reading order.
+    ///
+    /// Used for the projectability envelope test and the vertex budget, both of which need the
+    /// count and the extremes rather than the structure.
+    var allPoints: [SpatialPoint] {
+        var out: [SpatialPoint] = []
+        collectPoints(into: &out)
+        return out
+    }
+
+    var pointCount: Int {
+        switch self {
+        case .empty:
+            return 0
+        case .point:
+            return 1
+        case .lineString(let points), .multiPoint(let points):
+            return points.count
+        case .polygon(let rings):
+            return rings.reduce(0) { $0 + $1.count }
+        case .multiLineString(let lines):
+            return lines.reduce(0) { $0 + $1.count }
+        case .multiPolygon(let polygons):
+            return polygons.reduce(0) { $0 + $1.reduce(0) { $0 + $1.count } }
+        case .collection(let children):
+            return children.reduce(0) { $0 + $1.pointCount }
+        }
+    }
+
+    private func collectPoints(into out: inout [SpatialPoint]) {
+        switch self {
+        case .empty:
+            return
+        case .point(let point):
+            out.append(point)
+        case .lineString(let points), .multiPoint(let points):
+            out.append(contentsOf: points)
+        case .polygon(let rings):
+            for ring in rings { out.append(contentsOf: ring) }
+        case .multiLineString(let lines):
+            for line in lines { out.append(contentsOf: line) }
+        case .multiPolygon(let polygons):
+            for polygon in polygons {
+                for ring in polygon { out.append(contentsOf: ring) }
+            }
+        case .collection(let children):
+            for child in children { child.collectPoints(into: &out) }
+        }
+    }
+}
+
+/// Bounds every reader shares, so one crafted value cannot cost more than a page of rows does.
+public enum SpatialLimits {
+    /// How deeply a geometry collection may nest before a value is refused.
+    ///
+    /// Each level of `GEOMETRYCOLLECTION(...)` is one more frame on the reader's stack, and the
+    /// wire formats put no limit on it, so a few hundred bytes of nothing but nested collection
+    /// headers would exhaust the stack rather than fail. Thirty-two is far past anything a database
+    /// writes: PostGIS, MySQL and MapKit's own GeoJSON decoder all produce at most two.
+    public static let maximumNestingDepth = 32
+}