[SEDONA-2880] GeoParquet reader: ignore [0,0,0,0] bbox fingerprint

Defensively guard `LeafFilter.evaluate` against legacy GeoParquet files
written by buggy versions of Sedona that emitted `bbox: [0, 0, 0, 0]`
in the metadata of zero-row files. When a file's bbox matches that
exact fingerprint, treat it as untrusted and skip bbox-based pruning.

Without this guard, files written by legacy Sedona with `bbox: [0, 0,
0, 0]` would be incorrectly retained for any query window intersecting
Null Island and incorrectly pruned for query windows that don't, neither
of which reflects the file's real (empty) contents.

Note: this could in theory over-include a real file whose geometries
all sit exactly at (0, 0) with zero extent, but such a file would also
be uninteresting for any spatial query and the over-inclusion is
harmless.

Author: james-willis

spark/common/src/main/scala/org/apache/spark/sql/execution/datasources/geoparquet/GeoParquetSpatialFilter.scala

@@ -34,6 +34,13 @@ trait GeoParquetSpatialFilter {
 
 object GeoParquetSpatialFilter {
 
+  /**
+   * Bbox value emitted by buggy versions of Sedona's GeoParquet writer for files containing no
+   * geometries (e.g. when an empty Spark partition is written out). See issue #2880. Files with
+   * this fingerprint should not participate in bbox-based pruning.
+   */
+  private[geoparquet] val LegacyEmptyBboxFingerprint: Seq[Double] = Seq(0.0, 0.0, 0.0, 0.0)
+
   case class AndFilter(left: GeoParquetSpatialFilter, right: GeoParquetSpatialFilter)
       extends GeoParquetSpatialFilter {
     override def evaluate(columns: Map[String, GeometryFieldMetaData]): Boolean = {
@@ -72,6 +79,13 @@ object GeoParquetSpatialFilter {
         if (bbox.isEmpty) {
           return true
         }
+        // Defend against legacy GeoParquet files written by buggy versions of Sedona that
+        // emitted `bbox: [0, 0, 0, 0]` in the metadata of zero-row files (see issue #2880).
+        // The only legitimate file matching this fingerprint would contain geometries lying
+        // exactly at the origin with zero extent — pathological and not worth pruning on.
+        if (bbox == LegacyEmptyBboxFingerprint) {
+          return true
+        }
 
         val columnEnvelope =
           queryWindow.getFactory.toGeometry(new Envelope(bbox(0), bbox(2), bbox(1), bbox(3)))

spark/common/src/test/scala/org/apache/sedona/sql/GeoParquetSpatialFilterPushDownSuite.scala

@@ -29,7 +29,8 @@ import org.apache.spark.sql.DataFrame
 import org.apache.spark.sql.SparkSession
 import org.apache.spark.sql.execution.FileSourceScanExec
 import org.apache.spark.sql.execution.SimpleMode
-import org.apache.spark.sql.execution.datasources.geoparquet.{GeoParquetFileFormat, GeoParquetMetaData, GeoParquetSpatialFilter}
+import org.apache.spark.sql.execution.datasources.geoparquet.{GeoParquetFileFormat, GeoParquetMetaData, GeoParquetSpatialFilter, GeometryFieldMetaData}
+import org.apache.sedona.core.spatialOperator.SpatialPredicate
 import org.locationtech.jts.geom.Coordinate
 import org.locationtech.jts.geom.Geometry
 import org.locationtech.jts.geom.GeometryFactory
@@ -307,6 +308,49 @@ class GeoParquetSpatialFilterPushDownSuite extends TestBaseScala with TableDrive
       assert(explainString.contains("with spatial filter"))
     }
 
+    it("LeafFilter ignores legacy [0,0,0,0] bbox fingerprint (issue #2880)") {
+      // Buggy versions of the GeoParquet writer emitted [0, 0, 0, 0] as the bbox of zero-row
+      // files. The reader must not prune those files based on that fingerprint, since the
+      // metadata does not actually describe a real spatial extent. New writers omit bbox
+      // entirely for empty files, which is also handled here.
+      val geomFactory = new GeometryFactory()
+      val queryWindow =
+        geomFactory.toGeometry(new org.locationtech.jts.geom.Envelope(100.0, 200.0, 100.0, 200.0))
+      val filter = GeoParquetSpatialFilter.LeafFilter(
+        columnName = "geom",
+        predicateType = SpatialPredicate.INTERSECTS,
+        queryWindow = queryWindow)
+
+      // Legacy buggy file: bbox = [0, 0, 0, 0] is the buggy-writer fingerprint
+      val legacyBuggyMeta = GeometryFieldMetaData(
+        encoding = "WKB",
+        geometryTypes = Seq.empty,
+        bbox = Some(Seq(0.0, 0.0, 0.0, 0.0)))
+      assert(filter.evaluate(Map("geom" -> legacyBuggyMeta)))
+
+      // Spec-compliant empty file: bbox omitted entirely
+      val newEmptyMeta =
+        GeometryFieldMetaData(encoding = "WKB", geometryTypes = Seq.empty, bbox = None)
+      assert(filter.evaluate(Map("geom" -> newEmptyMeta)))
+
+      // Real file with bbox at the origin (but non-zero extent) should still participate
+      // in pruning — only the exact [0, 0, 0, 0] fingerprint is treated as untrusted.
+      val realOriginMeta = GeometryFieldMetaData(
+        encoding = "WKB",
+        geometryTypes = Seq("Point"),
+        bbox = Some(Seq(0.0, 0.0, 1.0, 1.0)))
+      assert(!filter.evaluate(Map("geom" -> realOriginMeta)))
+
+      // A file with empty geometry_types but a real (non-fingerprint) bbox should still
+      // be subject to pruning — the spec allows `geometry_types: []` to mean "types are
+      // not known" without invalidating the bbox.
+      val unknownTypesMeta = GeometryFieldMetaData(
+        encoding = "WKB",
+        geometryTypes = Seq.empty,
+        bbox = Some(Seq(50.0, 50.0, 60.0, 60.0)))
+      assert(!filter.evaluate(Map("geom" -> unknownTypesMeta)))
+    }
+
     it("Manually disable spatial filter push-down") {
       withConf(Map("spark.sedona.geoparquet.spatialFilterPushDown" -> "false")) {
         val dfFiltered = geoParquetDf.where(