diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/CometIcebergNativeScanExec.scala b/spark/src/main/scala/org/apache/spark/sql/comet/CometIcebergNativeScanExec.scala index 2b6c3f31e21..70a91cc7325 100644 --- a/spark/src/main/scala/org/apache/spark/sql/comet/CometIcebergNativeScanExec.scala +++ b/spark/src/main/scala/org/apache/spark/sql/comet/CometIcebergNativeScanExec.scala @@ -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 diff --git a/spark/src/main/scala/org/apache/spark/sql/comet/operators.scala b/spark/src/main/scala/org/apache/spark/sql/comet/operators.scala index 5b5ce0131f8..98a03b3cc08 100644 --- a/spark/src/main/scala/org/apache/spark/sql/comet/operators.scala +++ b/spark/src/main/scala/org/apache/spark/sql/comet/operators.scala @@ -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 @@ -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() @@ -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 => @@ -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 => diff --git a/spark/src/test/scala/org/apache/comet/CometIcebergNativeSuite.scala b/spark/src/test/scala/org/apache/comet/CometIcebergNativeSuite.scala index 46740ddb20e..9e27a3a5bcc 100644 --- a/spark/src/test/scala/org/apache/comet/CometIcebergNativeSuite.scala +++ b/spark/src/test/scala/org/apache/comet/CometIcebergNativeSuite.scala @@ -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.