Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -134,7 +134,21 @@ case class CometIcebergNativeScanExec(
// CometPlanAdaptiveDynamicPruningFilters converts the DPP placeholders, so serializing the
// tasks here would run a placeholder subquery. At execution, CometNativeExec sizes the native
// RDD from perPartitionData instead.
override lazy val outputPartitioning: Partitioning = UnknownPartitioning(0)
//
// A storage-partitioned scan reports a key-grouped partitioning (KeyGroupedPartitioning, called
// KeyedPartitioning from Spark 4.2). Spark takes it from the partitions it plans, before any DPP
// filtering, and plans the operators above the scan on that basis, with no exchange for a join
// or aggregate that the partitioning already satisfies. The scan reports the same, so reading it
// resolves no DPP subquery. Otherwise EnsureRequirements, which AQE runs again over a DPP
// subquery's converted plan, inserts exchanges inside a native block that is already serialized
// (#7441). serializePartitions keeps one partition for each of Spark's partitions when DPP
// prunes some, as Spark does.
override lazy val outputPartitioning: Partitioning =
if (originalPlan == null) {
UnknownPartitioning(0)
} else {
originalPlan.outputPartitioning
}

override lazy val outputOrdering: Seq[SortOrder] = Nil

Expand Down
43 changes: 39 additions & 4 deletions spark/src/main/scala/org/apache/spark/sql/comet/operators.scala
Original file line number Diff line number Diff line change
Expand Up @@ -45,7 +45,7 @@ import org.apache.spark.sql.execution.adaptive.{AdaptiveSparkPlanExec, AQEShuffl
import org.apache.spark.sql.execution.aggregate.{BaseAggregateExec, HashAggregateExec, ObjectHashAggregateExec, SortAggregateExec}
import org.apache.spark.sql.execution.columnar.InMemoryTableScanExec
import org.apache.spark.sql.execution.datasources.v2.DataSourceV2ScanExecBase
import org.apache.spark.sql.execution.exchange.ReusedExchangeExec
import org.apache.spark.sql.execution.exchange.{ReusedExchangeExec, ShuffleExchangeLike}
import org.apache.spark.sql.execution.joins.{BroadcastHashJoinExec, BroadcastNestedLoopJoinExec, CartesianProductExec, HashJoin, ShuffledHashJoinExec, SortMergeJoinExec}
import org.apache.spark.sql.execution.metric.{SQLMetric, SQLMetrics}
import org.apache.spark.sql.internal.SQLConf
Expand Down Expand Up @@ -747,17 +747,52 @@ abstract class CometExec extends CometPlan {
* Declares the distribution of the Spark operator that a Comet operator replaces. Without it
* AQE's OptimizeSkewInRebalancePartitions can split a skewed partition under an operator that
* needs its input clustered, because ValidateRequirements has nothing to reject, and one key then
* yields several rows. Mix it into operators that replace a clustering aggregate, window or join.
* yields several rows. Mix it into operators that replace a clustering aggregate or window. A
* join mixes in [[CometDelegatesJoinChildDistribution]] instead.
*/
trait CometDelegatesRequiredChildDistribution extends CometExec {
override def requiredChildDistribution: Seq[Distribution] =
originalPlan.requiredChildDistribution
}

/**
* [[CometDelegatesRequiredChildDistribution]] for a join. A storage-partitioned join, whose sides
* are key-grouped scans that Spark joins with no exchange, declares no requirement. No shuffle
* sits below it for AQE to split. EnsureRequirements only accepts such a join when it is Spark's
* own join operator, and in Spark 4.1 only over Spark's own scans. So when AQE plans a DPP
* subquery's converted plan again, it would put an exchange under each side that it has no
* logical link for (#7441). The sides are the join's current children, which are Comet operators,
* because conversion works bottom-up and AQE can later swap in query stages.
*/
trait CometDelegatesJoinChildDistribution extends CometDelegatesRequiredChildDistribution {
override def requiredChildDistribution: Seq[Distribution] =
if (children.forall(CometExec.isStoragePartitioned)) {
children.map(_ => UnspecifiedDistribution)
} else {
super.requiredChildDistribution
}
}

object CometExec {
final class InvalidSparkFallbackException(message: String)
extends IllegalArgumentException(message)

/**
* Whether `plan` reads only key-grouped scans, with no shuffle above them. This is how Spark
* plans each side of a storage-partitioned join. A scan counts only when the scan it replaces
* or wraps was planned key-grouped, so a table read without grouping does not.
*/
private[comet] def isStoragePartitioned(plan: SparkPlan): Boolean =
!plan.exists(_.isInstanceOf[ShuffleExchangeLike]) &&
plan.collectLeaves().forall {
// Spark's own scans, and CometBatchScanExec, which extends DataSourceV2ScanExecBase.
case scan: DataSourceV2ScanExecBase => scan.keyGroupedPartitioning.isDefined
// originalPlan is null on a canonicalized copy
case scan: CometIcebergNativeScanExec =>
scan.originalPlan != null && scan.originalPlan.keyGroupedPartitioning.isDefined
case _ => false
}

// An unique id for each CometExecIterator, used to identify the native query execution.
private val curId = new java.util.concurrent.atomic.AtomicLong()

Expand Down Expand Up @@ -3456,7 +3491,7 @@ case class CometHashJoinExec(
override val right: SparkPlan,
override val serializedPlanOpt: SerializedPlan)
extends CometBinaryExec
with CometDelegatesRequiredChildDistribution {
with CometDelegatesJoinChildDistribution {

override def outputPartitioning: Partitioning = joinType match {
case _: InnerLike =>
Expand Down Expand Up @@ -3846,7 +3881,7 @@ case class CometSortMergeJoinExec(
override val right: SparkPlan,
override val serializedPlanOpt: SerializedPlan)
extends CometBinaryExec
with CometDelegatesRequiredChildDistribution {
with CometDelegatesJoinChildDistribution {

override def outputPartitioning: Partitioning = joinType match {
case _: InnerLike =>
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -7259,6 +7259,101 @@ class CometIcebergNativeSuite
}
}

// The fact table is partitioned on the column the DPP join uses and the two dimension tables on
// theirs, so Spark reads every scan key-grouped and joins the dimensions without a shuffle. The
// drops sit in a finally because a table left behind by a failing test makes the next test fail
// on CREATE TABLE, which hides that test's own result.
private def withStoragePartitionedDppTables(f: => Unit): Unit = {
withTempIcebergDir { warehouseDir =>
withSQLConf(
"spark.sql.catalog.aqe_cat" -> "org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.aqe_cat.type" -> "hadoop",
"spark.sql.catalog.aqe_cat.warehouse" -> warehouseDir.getAbsolutePath,
SQLConf.ADAPTIVE_EXECUTION_ENABLED.key -> "true",
SQLConf.DYNAMIC_PARTITION_PRUNING_REUSE_BROADCAST_ONLY.key -> "true",
SQLConf.V2_BUCKETING_ENABLED.key -> "true",
SQLConf.V2_BUCKETING_PUSH_PART_VALUES_ENABLED.key -> "true",
"spark.sql.iceberg.planning.preserve-data-grouping" -> "true",
CometConf.COMET_ENABLED.key -> "true",
CometConf.COMET_EXEC_ENABLED.key -> "true",
CometConf.COMET_ICEBERG_NATIVE_ENABLED.key -> "true") {
try {
spark.sql("""
CREATE TABLE aqe_cat.db.spj_dpp_fact (amount INT, store_id INT)
USING iceberg PARTITIONED BY (store_id)
""")
spark.sql("""
CREATE TABLE aqe_cat.db.spj_dpp_dim_a (id INT, country STRING)
USING iceberg PARTITIONED BY (id)
""")
spark.sql("""
CREATE TABLE aqe_cat.db.spj_dpp_dim_b (id INT, name STRING)
USING iceberg PARTITIONED BY (id)
""")
spark.sql(
"INSERT INTO aqe_cat.db.spj_dpp_fact SELECT CAST(id AS INT), CAST(id % 10 AS INT) " +
"FROM range(0, 100)")
spark.sql(
"INSERT INTO aqe_cat.db.spj_dpp_dim_a SELECT CAST(id AS INT), " +
"IF(id < 3, 'X', 'Y') FROM range(0, 10)")
spark.sql(
"INSERT INTO aqe_cat.db.spj_dpp_dim_b SELECT CAST(id AS INT), concat('n', id) " +
"FROM range(0, 10)")
f
} finally {
Seq("spj_dpp_fact", "spj_dpp_dim_a", "spj_dpp_dim_b").foreach { table =>
spark.sql(s"DROP TABLE IF EXISTS aqe_cat.db.$table")
}
}
}
}
}

// The build side of the broadcast that prunes the fact scan joins the two dimensions, which
// needs no shuffle because both scans are key-grouped on id, and so does an aggregate on id
// above that join. AQE plans the converted subquery again, and EnsureRequirements has to find
// each requirement already met rather than put an exchange in it, because AQE has no logical
// link for one (#7441). The hint picks the join operator, so both Comet joins are covered.
for {
(shape, column, projection, grouping) <- Seq(
("storage-partitioned join", "name", "a.id, b.name", ""),
(
"aggregate over a storage-partitioned join",
"cnt",
"a.id, count(*) AS cnt",
"GROUP BY a.id"))
(hint, joinClass) <- Seq[(String, Class[_ <: SparkPlan])](
"MERGE" -> classOf[CometSortMergeJoinExec],
"SHUFFLE_HASH" -> classOf[CometHashJoinExec])
} {
test(s"AQE DPP - $shape on the DPP build side, $hint (#7441)") {
assume(icebergAvailable, "Iceberg not available")
withStoragePartitionedDppTables {
val query =
s"""SELECT /*+ BROADCAST(d) */ f.store_id, f.amount, d.$column
|FROM aqe_cat.db.spj_dpp_fact f JOIN (
| SELECT /*+ $hint(a, b) */ $projection
| FROM aqe_cat.db.spj_dpp_dim_a a JOIN aqe_cat.db.spj_dpp_dim_b b ON a.id = b.id
| WHERE a.country = 'X'
| $grouping
|) d ON f.store_id = d.id""".stripMargin
val (_, cometPlan) = checkSparkAnswer(query)
assertIcebergNativeScanPresent(cometPlan)
assertNoLeftoverCSAB(cometPlan)
assert(
collectIcebergDPPSubqueries(cometPlan).nonEmpty,
s"Expected the fact scan to carry a DPP filter:\n$cometPlan")
assert(
collectWithSubqueries(cometPlan) { case p if joinClass.isInstance(p) => p }.nonEmpty,
s"Expected a ${joinClass.getSimpleName} in the plan or in the DPP subquery's plan:\n" +
cometPlan)
assert(
collectWithSubqueries(cometPlan) { case e: ShuffleExchangeLike => e }.isEmpty,
s"Expected no exchange in the plan or in the DPP subquery's plan:\n$cometPlan")
}
}
}

// TPC-DS q64 shape (#6264): a broadcast of (fact SMJ other) per UNION ALL branch, with the
// dimension join above it. The two broadcasts differ only in the DPP filter of the fact scan
// inside a child shuffle stage, so they must not be reused for each other.
Expand Down