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])
+ }
}
}