You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@sedona.apache.org by ji...@apache.org on 2022/10/09 20:14:10 UTC

[incubator-sedona] branch master updated: [SEDONA-176] Make ST_Contains conform with OGC standard, and add ST_Covers and ST_CoveredBy functions. (#698)

This is an automated email from the ASF dual-hosted git repository.

jiayu pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-sedona.git


The following commit(s) were added to refs/heads/master by this push:
     new ff2a4dd0 [SEDONA-176] Make ST_Contains conform with OGC standard, and add ST_Covers and ST_CoveredBy functions. (#698)
ff2a4dd0 is described below

commit ff2a4dd0e801d3338472279910aa8505c27bd1df
Author: Kristin Cowalcijk <mo...@yeah.net>
AuthorDate: Mon Oct 10 04:14:02 2022 +0800

    [SEDONA-176] Make ST_Contains conform with OGC standard, and add ST_Covers and ST_CoveredBy functions. (#698)
---
 docs/api/flink/Predicate.md                        |  47 +++++++-
 docs/api/sql/Predicate.md                          |  30 ++++++
 .../main/java/org/apache/sedona/flink/Catalog.java |   3 +
 .../sedona/flink/expressions/Predicates.java       | 120 +++++++++++++++++++++
 .../org/apache/sedona/flink/PredicateTest.java     |  27 +++++
 python/sedona/sql/st_predicates.py                 |  28 +++++
 python/tests/sql/test_dataframe_api.py             |   6 ++
 .../scala/org/apache/sedona/sql/UDF/Catalog.scala  |   2 +
 .../sql/sedona_sql/expressions/Predicates.scala    |  73 ++++++++++++-
 .../sql/sedona_sql/expressions/st_predicates.scala |   8 +-
 .../strategy/join/JoinQueryDetector.scala          |   4 +
 .../apache/sedona/sql/dataFrameAPITestScala.scala  |  16 +++
 .../apache/sedona/sql/predicateJoinTestScala.scala |  35 ++++++
 .../org/apache/sedona/sql/predicateTestScala.scala |  36 +++++++
 14 files changed, 431 insertions(+), 4 deletions(-)

diff --git a/docs/api/flink/Predicate.md b/docs/api/flink/Predicate.md
index baf20923..86ce3679 100644
--- a/docs/api/flink/Predicate.md
+++ b/docs/api/flink/Predicate.md
@@ -43,6 +43,21 @@ FROM pointdf
 WHERE ST_Intersects(ST_PolygonFromEnvelope(1.0,100.0,1000.0,1100.0), pointdf.arealandmark)
 ```
 
+## ST_Within
+
+Introduction: Return true if A is within B
+
+Format: `ST_Within (A:geometry, B:geometry)`
+
+Since: `v1.3.0`
+
+SQL example:
+```SQL
+SELECT * 
+FROM pointdf 
+WHERE ST_Within(pointdf.arealandmark, ST_PolygonFromEnvelope(1.0,100.0,1000.0,1100.0))
+```
+
 ## ST_OrderingEquals
 Introduction: Returns true if the geometries are equal and the coordinates are in the same order
 
@@ -62,4 +77,34 @@ SQL example 2:
 SELECT ST_OrderingEquals(ST_GeomFromWKT('POLYGON((2 0, 0 2, -2 0, 2 0))'), ST_GeomFromWKT('POLYGON((0 2, -2 0, 2 0, 0 2))'))
 ```
 
-Output: `false`
\ No newline at end of file
+Output: `false`
+
+## ST_Covers
+
+Introduction: Return true if A covers B
+
+Format: `ST_Covers (A:geometry, B:geometry)`
+
+Since: `v1.3.0`
+
+SQL example:
+```SQL
+SELECT * 
+FROM pointdf 
+WHERE ST_Covers(ST_PolygonFromEnvelope(1.0,100.0,1000.0,1100.0), pointdf.arealandmark)
+```
+
+## ST_CoveredBy
+
+Introduction: Return true if A is covered by B
+
+Format: `ST_CoveredBy (A:geometry, B:geometry)`
+
+Since: `v1.3.0`
+
+SQL example:
+```SQL
+SELECT * 
+FROM pointdf 
+WHERE ST_CoveredBy(pointdf.arealandmark, ST_PolygonFromEnvelope(1.0,100.0,1000.0,1100.0))
+```
diff --git a/docs/api/sql/Predicate.md b/docs/api/sql/Predicate.md
index c3ecac7a..e4e2714d 100644
--- a/docs/api/sql/Predicate.md
+++ b/docs/api/sql/Predicate.md
@@ -137,3 +137,33 @@ SELECT *
 FROM pointdf 
 WHERE ST_Within(pointdf.arealandmark, ST_PolygonFromEnvelope(1.0,100.0,1000.0,1100.0))
 ```
+
+## ST_Covers
+
+Introduction: Return true if A covers B
+
+Format: `ST_Covers (A:geometry, B:geometry)`
+
+Since: `v1.3.0`
+
+Spark SQL example:
+```SQL
+SELECT * 
+FROM pointdf 
+WHERE ST_Covers(ST_PolygonFromEnvelope(1.0,100.0,1000.0,1100.0), pointdf.arealandmark)
+```
+
+## ST_CoveredBy
+
+Introduction: Return true if A is covered by B
+
+Format: `ST_CoveredBy (A:geometry, B:geometry)`
+
+Since: `v1.3.0`
+
+Spark SQL example:
+```SQL
+SELECT * 
+FROM pointdf 
+WHERE ST_CoveredBy(pointdf.arealandmark, ST_PolygonFromEnvelope(1.0,100.0,1000.0,1100.0))
+```
diff --git a/flink/src/main/java/org/apache/sedona/flink/Catalog.java b/flink/src/main/java/org/apache/sedona/flink/Catalog.java
index 289cfe38..9b6d634f 100644
--- a/flink/src/main/java/org/apache/sedona/flink/Catalog.java
+++ b/flink/src/main/java/org/apache/sedona/flink/Catalog.java
@@ -89,6 +89,9 @@ public class Catalog {
         return new UserDefinedFunction[]{
                 new Predicates.ST_Intersects(),
                 new Predicates.ST_Contains(),
+                new Predicates.ST_Within(),
+                new Predicates.ST_Covers(),
+                new Predicates.ST_CoveredBy(),
                 new Predicates.ST_Disjoint(),
                 new Predicates.ST_OrderingEquals(),
         };
diff --git a/flink/src/main/java/org/apache/sedona/flink/expressions/Predicates.java b/flink/src/main/java/org/apache/sedona/flink/expressions/Predicates.java
index 55f7945b..2a6bacb3 100644
--- a/flink/src/main/java/org/apache/sedona/flink/expressions/Predicates.java
+++ b/flink/src/main/java/org/apache/sedona/flink/expressions/Predicates.java
@@ -81,6 +81,86 @@ public class Predicates {
         public ST_Contains() {
         }
 
+        @DataTypeHint("Boolean")
+        public Boolean eval(@DataTypeHint(value = "RAW", bridgedTo = org.locationtech.jts.geom.Geometry.class) Object o1, @DataTypeHint(value = "RAW", bridgedTo = org.locationtech.jts.geom.Geometry.class) Object o2) {
+            Geometry geom1 = (Geometry) o1;
+            Geometry geom2 = (Geometry) o2;
+            return geom1.contains(geom2);
+        }
+
+        /**
+         * Check spatial relation with duplicates removal
+         * @param key
+         * @param o1
+         * @param o2
+         * @return
+         */
+        @DataTypeHint("Boolean")
+        public Boolean eval(@DataTypeHint("INT") Integer key, @DataTypeHint(value = "RAW", bridgedTo = org.locationtech.jts.geom.Geometry.class) Object o1, @DataTypeHint(value = "RAW", bridgedTo = org.locationtech.jts.geom.Geometry.class) Object o2) {
+            Objects.requireNonNull(grids, "This predicate has to be initialized by a partitioner.");
+            Geometry geom1 = (Geometry) o1;
+            Geometry geom2 = (Geometry) o2;
+            HalfOpenRectangle halfOpenRectangle = new HalfOpenRectangle(grids.get(key));
+            return JudgementHelper.match(geom1, geom2, halfOpenRectangle, false);
+        }
+    }
+
+    public static class ST_Within extends ScalarFunction {
+        private List<Envelope> grids;
+
+        /**
+         * Constructor for duplicate removal
+         */
+        public ST_Within(PartitioningUtils partitioner) {
+            grids = partitioner.fetchLeafZones();
+        }
+
+        /**
+         * Constructor for relation checking without duplicate removal
+         */
+        public ST_Within() {
+        }
+
+        @DataTypeHint("Boolean")
+        public Boolean eval(@DataTypeHint(value = "RAW", bridgedTo = org.locationtech.jts.geom.Geometry.class) Object o1, @DataTypeHint(value = "RAW", bridgedTo = org.locationtech.jts.geom.Geometry.class) Object o2) {
+            Geometry geom1 = (Geometry) o1;
+            Geometry geom2 = (Geometry) o2;
+            return geom1.within(geom2);
+        }
+
+        /**
+         * Check spatial relation with duplicates removal
+         * @param key
+         * @param o1
+         * @param o2
+         * @return
+         */
+        @DataTypeHint("Boolean")
+        public Boolean eval(@DataTypeHint("INT") Integer key, @DataTypeHint(value = "RAW", bridgedTo = org.locationtech.jts.geom.Geometry.class) Object o1, @DataTypeHint(value = "RAW", bridgedTo = org.locationtech.jts.geom.Geometry.class) Object o2) {
+            Objects.requireNonNull(grids, "This predicate has to be initialized by a partitioner.");
+            Geometry geom1 = (Geometry) o1;
+            Geometry geom2 = (Geometry) o2;
+            HalfOpenRectangle halfOpenRectangle = new HalfOpenRectangle(grids.get(key));
+            return JudgementHelper.match(geom1, geom2, halfOpenRectangle, true);
+        }
+    }
+
+    public static class ST_Covers extends ScalarFunction {
+        private List<Envelope> grids;
+
+        /**
+         * Constructor for duplicate removal
+         */
+        public ST_Covers(PartitioningUtils partitioner) {
+            grids = partitioner.fetchLeafZones();
+        }
+
+        /**
+         * Constructor for relation checking without duplicate removal
+         */
+        public ST_Covers() {
+        }
+
         @DataTypeHint("Boolean")
         public Boolean eval(@DataTypeHint(value = "RAW", bridgedTo = org.locationtech.jts.geom.Geometry.class) Object o1, @DataTypeHint(value = "RAW", bridgedTo = org.locationtech.jts.geom.Geometry.class) Object o2) {
             Geometry geom1 = (Geometry) o1;
@@ -105,6 +185,46 @@ public class Predicates {
         }
     }
 
+    public static class ST_CoveredBy extends ScalarFunction {
+        private List<Envelope> grids;
+
+        /**
+         * Constructor for duplicate removal
+         */
+        public ST_CoveredBy(PartitioningUtils partitioner) {
+            grids = partitioner.fetchLeafZones();
+        }
+
+        /**
+         * Constructor for relation checking without duplicate removal
+         */
+        public ST_CoveredBy() {
+        }
+
+        @DataTypeHint("Boolean")
+        public Boolean eval(@DataTypeHint(value = "RAW", bridgedTo = org.locationtech.jts.geom.Geometry.class) Object o1, @DataTypeHint(value = "RAW", bridgedTo = org.locationtech.jts.geom.Geometry.class) Object o2) {
+            Geometry geom1 = (Geometry) o1;
+            Geometry geom2 = (Geometry) o2;
+            return geom1.coveredBy(geom2);
+        }
+
+        /**
+         * Check spatial relation with duplicates removal
+         * @param key
+         * @param o1
+         * @param o2
+         * @return
+         */
+        @DataTypeHint("Boolean")
+        public Boolean eval(@DataTypeHint("INT") Integer key, @DataTypeHint(value = "RAW", bridgedTo = org.locationtech.jts.geom.Geometry.class) Object o1, @DataTypeHint(value = "RAW", bridgedTo = org.locationtech.jts.geom.Geometry.class) Object o2) {
+            Objects.requireNonNull(grids, "This predicate has to be initialized by a partitioner.");
+            Geometry geom1 = (Geometry) o1;
+            Geometry geom2 = (Geometry) o2;
+            HalfOpenRectangle halfOpenRectangle = new HalfOpenRectangle(grids.get(key));
+            return JudgementHelper.match(geom1, geom2, halfOpenRectangle, true);
+        }
+    }
+
     public static class ST_Disjoint extends ScalarFunction {
         private List<Envelope> grids;
 
diff --git a/flink/src/test/java/org/apache/sedona/flink/PredicateTest.java b/flink/src/test/java/org/apache/sedona/flink/PredicateTest.java
index dd146ca7..1b991f93 100644
--- a/flink/src/test/java/org/apache/sedona/flink/PredicateTest.java
+++ b/flink/src/test/java/org/apache/sedona/flink/PredicateTest.java
@@ -52,6 +52,33 @@ public class PredicateTest extends TestBase{
         assertEquals(1, count(result));
     }
 
+    @Test
+    public void testWithin() {
+        Table pointTable = createPointTable(testDataSize);
+        String polygon = createPolygonWKT(testDataSize).get(0).getField(0).toString();
+        String expr = "ST_Within(geom_point, ST_GeomFromWkt('" + polygon + "'))";
+        Table result = pointTable.filter(expr);
+        assertEquals(1, count(result));
+    }
+
+    @Test
+    public void testCovers() {
+        Table pointTable = createPointTable(testDataSize);
+        String polygon = createPolygonWKT(testDataSize).get(0).getField(0).toString();
+        String expr = "ST_Covers(ST_GeomFromWkt('" + polygon + "'), geom_point)";
+        Table result = pointTable.filter(expr);
+        assertEquals(1, count(result));
+    }
+
+    @Test
+    public void testCoveredBy() {
+        Table pointTable = createPointTable(testDataSize);
+        String polygon = createPolygonWKT(testDataSize).get(0).getField(0).toString();
+        String expr = "ST_CoveredBy(geom_point, ST_GeomFromWkt('" + polygon + "'))";
+        Table result = pointTable.filter(expr);
+        assertEquals(1, count(result));
+    }
+
     @Test
     public void testOrderingEquals() {
         Table lineStringTable = createLineStringTable(testDataSize);
diff --git a/python/sedona/sql/st_predicates.py b/python/sedona/sql/st_predicates.py
index e73f04cf..31a00503 100644
--- a/python/sedona/sql/st_predicates.py
+++ b/python/sedona/sql/st_predicates.py
@@ -145,3 +145,31 @@ def ST_Within(a: ColumnOrName, b: ColumnOrName) -> Column:
     :rtype: Column
     """
     return _call_predicate_function("ST_Within", (a, b))
+
+
+@validate_argument_types
+def ST_Covers(a: ColumnOrName, b: ColumnOrName) -> Column:
+    """Check whether geometry a covers geometry b.
+
+    :param a: Geometry column to check.
+    :type a: ColumnOrName
+    :param b: Geometry column to check.
+    :type b: ColumnOrName
+    :return: True if a covers b and False otherwise, as a boolean column.
+    :rtype: Column
+    """
+    return _call_predicate_function("ST_Covers", (a, b))
+
+
+@validate_argument_types
+def ST_CoveredBy(a: ColumnOrName, b: ColumnOrName) -> Column:
+    """Check if geometry a is covered by geometry b.
+
+    :param a: Geometry column to check.
+    :type a: ColumnOrName
+    :param b: Geometry column to check.
+    :type b: ColumnOrName
+    :return: True if a is covered by b and False otherwise, as a boolean column.
+    :rtype: Column
+    """
+    return _call_predicate_function("ST_CoveredBy", (a, b))
diff --git a/python/tests/sql/test_dataframe_api.py b/python/tests/sql/test_dataframe_api.py
index e072e3e2..ed04c47b 100644
--- a/python/tests/sql/test_dataframe_api.py
+++ b/python/tests/sql/test_dataframe_api.py
@@ -119,6 +119,12 @@ test_configurations = [
     (stp.ST_Overlaps, ("a", "b"), "overlapping_polys", "", True),
     (stp.ST_Touches, ("a", "b"), "touching_polys", "", True),
     (stp.ST_Within, (lambda: f.expr("ST_Point(0.5, 0.25)"), "geom"), "triangle_geom", "", True),
+    (stp.ST_Covers, ("geom", lambda: f.expr("ST_Point(0.5, 0.25)")), "triangle_geom", "", True),
+    (stp.ST_CoveredBy, (lambda: f.expr("ST_Point(0.5, 0.25)"), "geom"), "triangle_geom", "", True),
+    (stp.ST_Contains, ("geom", lambda: f.expr("ST_Point(0.0, 0.0)")), "triangle_geom", "", False),
+    (stp.ST_Within, (lambda: f.expr("ST_Point(0.0, 0.0)"), "geom"), "triangle_geom", "", False),
+    (stp.ST_Covers, ("geom", lambda: f.expr("ST_Point(0.0, 0.0)")), "triangle_geom", "", True),
+    (stp.ST_CoveredBy, (lambda: f.expr("ST_Point(0.0, 0.0)"), "geom"), "triangle_geom", "", True),
 
     # aggregates
     (sta.ST_Envelope_Aggr, ("geom",), "exploded_points", "", "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))"),
diff --git a/sql/src/main/scala/org/apache/sedona/sql/UDF/Catalog.scala b/sql/src/main/scala/org/apache/sedona/sql/UDF/Catalog.scala
index 2f5280e6..07c65fb5 100644
--- a/sql/src/main/scala/org/apache/sedona/sql/UDF/Catalog.scala
+++ b/sql/src/main/scala/org/apache/sedona/sql/UDF/Catalog.scala
@@ -43,6 +43,8 @@ object Catalog {
     ST_Contains,
     ST_Intersects,
     ST_Within,
+    ST_Covers,
+    ST_CoveredBy,
     ST_Disjoint,
     ST_Distance,
     ST_3DDistance,
diff --git a/sql/src/main/scala/org/apache/spark/sql/sedona_sql/expressions/Predicates.scala b/sql/src/main/scala/org/apache/spark/sql/sedona_sql/expressions/Predicates.scala
index aca0360a..3a84245f 100644
--- a/sql/src/main/scala/org/apache/spark/sql/sedona_sql/expressions/Predicates.scala
+++ b/sql/src/main/scala/org/apache/spark/sql/sedona_sql/expressions/Predicates.scala
@@ -53,7 +53,7 @@ case class ST_Contains(inputExpressions: Seq[Expression])
 
     val rightGeometry = GeometrySerializer.deserialize(rightArray)
 
-    leftGeometry.covers(rightGeometry)
+    leftGeometry.contains(rightGeometry)
   }
 
   override def dataType = BooleanType
@@ -131,6 +131,75 @@ case class ST_Within(inputExpressions: Seq[Expression])
   }
 }
 
+/**
+  * Test if leftGeometry covers rightGeometry
+  *
+  * @param inputExpressions
+  */
+case class ST_Covers(inputExpressions: Seq[Expression])
+  extends ST_Predicate with CodegenFallback {
+
+  // This is a binary expression
+  assert(inputExpressions.length == 2)
+
+  override def nullable: Boolean = false
+
+  override def toString: String = s" **${ST_Covers.getClass.getName}**  "
+
+  override def children: Seq[Expression] = inputExpressions
+
+  override def eval(inputRow: InternalRow): Any = {
+    val leftArray = inputExpressions(0).eval(inputRow).asInstanceOf[ArrayData]
+    val rightArray = inputExpressions(1).eval(inputRow).asInstanceOf[ArrayData]
+
+    val leftGeometry = GeometrySerializer.deserialize(leftArray)
+
+    val rightGeometry = GeometrySerializer.deserialize(rightArray)
+
+    leftGeometry.covers(rightGeometry)
+  }
+
+  override def dataType = BooleanType
+
+  protected def withNewChildrenInternal(newChildren: IndexedSeq[Expression]) = {
+    copy(inputExpressions = newChildren)
+  }
+}
+
+/**
+  * Test if leftGeometry is covered by rightGeometry
+  *
+  * @param inputExpressions
+  */
+case class ST_CoveredBy(inputExpressions: Seq[Expression])
+  extends ST_Predicate with CodegenFallback {
+
+  // This is a binary expression
+  assert(inputExpressions.length == 2)
+
+  override def nullable: Boolean = false
+
+  override def toString: String = s" **${ST_CoveredBy.getClass.getName}**  "
+
+  override def children: Seq[Expression] = inputExpressions
+
+  override def eval(inputRow: InternalRow): Any = {
+    val leftArray = inputExpressions(0).eval(inputRow).asInstanceOf[ArrayData]
+    val rightArray = inputExpressions(1).eval(inputRow).asInstanceOf[ArrayData]
+
+    val leftGeometry = GeometrySerializer.deserialize(leftArray)
+
+    val rightGeometry = GeometrySerializer.deserialize(rightArray)
+
+    leftGeometry.coveredBy(rightGeometry)
+  }
+
+  override def dataType = BooleanType
+
+  protected def withNewChildrenInternal(newChildren: IndexedSeq[Expression]) = {
+    copy(inputExpressions = newChildren)
+  }
+}
 
 /**
   * Test if leftGeometry crosses rightGeometry
@@ -338,4 +407,4 @@ case class ST_OrderingEquals(inputExpressions: Seq[Expression])
   protected def withNewChildrenInternal(newChildren: IndexedSeq[Expression]) = {
     copy(inputExpressions = newChildren)
   }
-}
\ No newline at end of file
+}
diff --git a/sql/src/main/scala/org/apache/spark/sql/sedona_sql/expressions/st_predicates.scala b/sql/src/main/scala/org/apache/spark/sql/sedona_sql/expressions/st_predicates.scala
index 2ab1f34e..2a3abade 100644
--- a/sql/src/main/scala/org/apache/spark/sql/sedona_sql/expressions/st_predicates.scala
+++ b/sql/src/main/scala/org/apache/spark/sql/sedona_sql/expressions/st_predicates.scala
@@ -48,4 +48,10 @@ object st_predicates extends DataFrameAPI {
 
   def ST_Within(a: Column, b: Column): Column = wrapExpression[ST_Within](a, b)
   def ST_Within(a: String, b: String): Column = wrapExpression[ST_Within](a, b)
-}
\ No newline at end of file
+
+  def ST_Covers(a: Column, b: Column): Column = wrapExpression[ST_Covers](a, b)
+  def ST_Covers(a: String, b: String): Column = wrapExpression[ST_Covers](a, b)
+
+  def ST_CoveredBy(a: Column, b: Column): Column = wrapExpression[ST_CoveredBy](a, b)
+  def ST_CoveredBy(a: String, b: String): Column = wrapExpression[ST_CoveredBy](a, b)
+}
diff --git a/sql/src/main/scala/org/apache/spark/sql/sedona_sql/strategy/join/JoinQueryDetector.scala b/sql/src/main/scala/org/apache/spark/sql/sedona_sql/strategy/join/JoinQueryDetector.scala
index 18a8141a..79b24264 100644
--- a/sql/src/main/scala/org/apache/spark/sql/sedona_sql/strategy/join/JoinQueryDetector.scala
+++ b/sql/src/main/scala/org/apache/spark/sql/sedona_sql/strategy/join/JoinQueryDetector.scala
@@ -61,6 +61,10 @@ class JoinQueryDetector(sparkSession: SparkSession) extends Strategy {
           Some(JoinQueryDetection(left, right, leftShape, rightShape, true, extraCondition))
         case ST_Within(Seq(leftShape, rightShape)) =>
           Some(JoinQueryDetection(right, left, rightShape, leftShape, false, extraCondition))
+        case ST_Covers(Seq(leftShape, rightShape)) =>
+          Some(JoinQueryDetection(left, right, leftShape, rightShape, false, extraCondition))
+        case ST_CoveredBy(Seq(leftShape, rightShape)) =>
+          Some(JoinQueryDetection(right, left, rightShape, leftShape, false, extraCondition))
         case ST_Overlaps(Seq(leftShape, rightShape)) =>
           Some(JoinQueryDetection(right, left, rightShape, leftShape, false, extraCondition))
         case ST_Touches(Seq(leftShape, rightShape)) =>
diff --git a/sql/src/test/scala/org/apache/sedona/sql/dataFrameAPITestScala.scala b/sql/src/test/scala/org/apache/sedona/sql/dataFrameAPITestScala.scala
index ce7aa0af..df19a75d 100644
--- a/sql/src/test/scala/org/apache/sedona/sql/dataFrameAPITestScala.scala
+++ b/sql/src/test/scala/org/apache/sedona/sql/dataFrameAPITestScala.scala
@@ -815,6 +815,22 @@ class dataFrameAPITestScala extends TestBaseScala {
       assert(!actualResult)
     }
 
+    it("Passed ST_Covers") {
+      val baseDf = sparkSession.sql("SELECT ST_GeomFromWKT('POLYGON ((0 0, 1 0, 1 1, 0 0))') AS a, ST_Point(1.0, 0.0) AS b, ST_Point(0.0, 1.0) AS c")
+      val df = baseDf.select(ST_Covers("a", "b"), ST_Covers("a", "c"))
+      val actualResult = df.take(1)(0)
+      assert(actualResult.getBoolean(0))
+      assert(!actualResult.getBoolean(1))
+    }
+
+    it("Passed ST_CoveredBy") {
+      val baseDf = sparkSession.sql("SELECT ST_GeomFromWKT('POLYGON ((0 0, 1 0, 1 1, 0 0))') AS a, ST_Point(1.0, 0.0) AS b, ST_Point(0.0, 1.0) AS c")
+      val df = baseDf.select(ST_CoveredBy("b", "a"), ST_CoveredBy("c", "a"))
+      val actualResult = df.take(1)(0)
+      assert(actualResult.getBoolean(0))
+      assert(!actualResult.getBoolean(1))
+    }
+
     // aggregates
     it("Passed ST_Envelope_Aggr") {
       val baseDf = sparkSession.sql("SELECT explode(array(ST_Point(0.0, 0.0), ST_Point(1.0, 1.0))) AS geom")
diff --git a/sql/src/test/scala/org/apache/sedona/sql/predicateJoinTestScala.scala b/sql/src/test/scala/org/apache/sedona/sql/predicateJoinTestScala.scala
index 688016b3..221724a6 100644
--- a/sql/src/test/scala/org/apache/sedona/sql/predicateJoinTestScala.scala
+++ b/sql/src/test/scala/org/apache/sedona/sql/predicateJoinTestScala.scala
@@ -127,6 +127,41 @@ class predicateJoinTestScala extends TestBaseScala {
       assert(rangeJoinDf.count() == 1000)
     }
 
+    it("Passed ST_Covers in a join") {
+      val sedonaConf = new SedonaConf(sparkSession.sparkContext.getConf)
+      println(sedonaConf)
+
+      var polygonCsvDf = sparkSession.read.format("csv").option("delimiter", ",").option("header", "false").load(csvPolygonInputLocation)
+      polygonCsvDf.createOrReplaceTempView("polygontable")
+      var polygonDf = sparkSession.sql("select ST_PolygonFromEnvelope(cast(polygontable._c0 as Decimal(24,20)),cast(polygontable._c1 as Decimal(24,20)), cast(polygontable._c2 as Decimal(24,20)), cast(polygontable._c3 as Decimal(24,20))) as polygonshape from polygontable")
+      polygonDf.createOrReplaceTempView("polygondf")
+
+      var pointCsvDF = sparkSession.read.format("csv").option("delimiter", ",").option("header", "false").load(csvPointInputLocation)
+      pointCsvDF.createOrReplaceTempView("pointtable")
+      var pointDf = sparkSession.sql("select ST_Point(cast(pointtable._c0 as Decimal(24,20)),cast(pointtable._c1 as Decimal(24,20))) as pointshape from pointtable")
+      pointDf.createOrReplaceTempView("pointdf")
+
+      var rangeJoinDf = sparkSession.sql("select * from polygondf, pointdf where ST_Covers(polygondf.polygonshape,pointdf.pointshape) ")
+
+      assert(rangeJoinDf.count() == 1000)
+    }
+
+    it("Passed ST_CoveredBy in a join") {
+      var polygonCsvDf = sparkSession.read.format("csv").option("delimiter", ",").option("header", "false").load(csvPolygonInputLocation)
+      polygonCsvDf.createOrReplaceTempView("polygontable")
+      var polygonDf = sparkSession.sql("select ST_PolygonFromEnvelope(cast(polygontable._c0 as Decimal(24,20)),cast(polygontable._c1 as Decimal(24,20)), cast(polygontable._c2 as Decimal(24,20)), cast(polygontable._c3 as Decimal(24,20))) as polygonshape from polygontable")
+      polygonDf.createOrReplaceTempView("polygondf")
+
+      var pointCsvDF = sparkSession.read.format("csv").option("delimiter", ",").option("header", "false").load(csvPointInputLocation)
+      pointCsvDF.createOrReplaceTempView("pointtable")
+      var pointDf = sparkSession.sql("select ST_Point(cast(pointtable._c0 as Decimal(24,20)),cast(pointtable._c1 as Decimal(24,20))) as pointshape from pointtable")
+      pointDf.createOrReplaceTempView("pointdf")
+
+      var rangeJoinDf = sparkSession.sql("select * from polygondf, pointdf where ST_CoveredBy(pointdf.pointshape, polygondf.polygonshape) ")
+
+      assert(rangeJoinDf.count() == 1000)
+    }
+
     it("Passed ST_Intersects in a join with singleton dataframe") {
       var polygonCsvDf = sparkSession.read.format("csv").option("delimiter", ",").option("header", "false").load(csvPolygonInputLocation).limit(1).repartition(1)
       polygonCsvDf.createOrReplaceTempView("polygontable")
diff --git a/sql/src/test/scala/org/apache/sedona/sql/predicateTestScala.scala b/sql/src/test/scala/org/apache/sedona/sql/predicateTestScala.scala
index cfec4917..c870e058 100644
--- a/sql/src/test/scala/org/apache/sedona/sql/predicateTestScala.scala
+++ b/sql/src/test/scala/org/apache/sedona/sql/predicateTestScala.scala
@@ -50,6 +50,24 @@ class predicateTestScala extends TestBaseScala {
       var resultDf = sparkSession.sql("select * from pointdf where ST_Within(pointdf.arealandmark, ST_PolygonFromEnvelope(1.0,100.0,1000.0,1100.0))")
       assert(resultDf.count() == 999)
     }
+    it("Passed ST_Covers") {
+      var pointCsvDF = sparkSession.read.format("csv").option("delimiter", ",").option("header", "false").load(csvPointInputLocation)
+      pointCsvDF.createOrReplaceTempView("pointtable")
+      var pointDf = sparkSession.sql("select ST_Point(cast(pointtable._c0 as Decimal(24,20)), cast(pointtable._c1 as Decimal(24,20))) as arealandmark from pointtable")
+      pointDf.createOrReplaceTempView("pointdf")
+
+      var resultDf = sparkSession.sql("select * from pointdf where ST_Covers(ST_PolygonFromEnvelope(1.0,100.0,101.0,201.0), pointdf.arealandmark)")
+      assert(resultDf.count() == 100)
+    }
+    it("Passed ST_CoveredBy") {
+      var pointCsvDF = sparkSession.read.format("csv").option("delimiter", ",").option("header", "false").load(csvPointInputLocation)
+      pointCsvDF.createOrReplaceTempView("pointtable")
+      var pointDf = sparkSession.sql("select ST_Point(cast(pointtable._c0 as Decimal(24,20)), cast(pointtable._c1 as Decimal(24,20))) as arealandmark from pointtable")
+      pointDf.createOrReplaceTempView("pointdf")
+
+      var resultDf = sparkSession.sql("select * from pointdf where ST_CoveredBy(pointdf.arealandmark, ST_PolygonFromEnvelope(1.0,100.0,101.0,201.0))")
+      assert(resultDf.count() == 100)
+    }
 
     it("Passed ST_Equals for ST_Point") {
       // Select a point from the table and check if any point in the table is equal to the selected point.
@@ -209,5 +227,23 @@ class predicateTestScala extends TestBaseScala {
       assert(!notOrderEqualsDiffGeom.take(1)(0).get(0).asInstanceOf[Boolean])
       assert(!notOrderEqualsDiffOrder.take(1)(0).get(0).asInstanceOf[Boolean])
     }
+
+    it("Passed edge cases of ST_Contains and ST_Covers") {
+      val testtable = sparkSession.sql("select ST_GeomFromWKT('POLYGON((2 0, 0 2, -2 0, 2 0))') AS a, ST_GeomFromWKT('POINT(2 0)') AS b")
+      testtable.createOrReplaceTempView("testtable")
+      val contains = sparkSession.sql("select ST_Contains(a, b) from testtable").take(1)(0)
+      val covers = sparkSession.sql("select ST_Covers(a, b) from testtable").take(1)(0)
+      assert(!contains.get(0).asInstanceOf[Boolean])
+      assert(covers.get(0).asInstanceOf[Boolean])
+    }
+
+    it("Passed edge cases of ST_Within and ST_CoveredBy") {
+      val testtable = sparkSession.sql("select ST_GeomFromWKT('POLYGON((2 0, 0 2, -2 0, 2 0))') AS a, ST_GeomFromWKT('POINT(2 0)') AS b")
+      testtable.createOrReplaceTempView("testtable")
+      val within = sparkSession.sql("select ST_Within(b, a) from testtable").take(1)(0)
+      val coveredBy = sparkSession.sql("select ST_CoveredBy(b, a) from testtable").take(1)(0)
+      assert(!within.get(0).asInstanceOf[Boolean])
+      assert(coveredBy.get(0).asInstanceOf[Boolean])
+    }
   }
 }