1919
2020package org .apache .comet .rules
2121
22+ import java .util .concurrent .ConcurrentLinkedQueue
23+
24+ import scala .jdk .CollectionConverters ._
2225import scala .util .Random
2326
27+ import org .scalatest .PrivateMethodTester ._
28+
2429import org .apache .logging .log4j .Level
2530import org .apache .spark .sql ._
2631import org .apache .spark .sql .catalyst .FunctionIdentifier
2732import org .apache .spark .sql .catalyst .expressions .{Attribute , AttributeReference , Expression , ExpressionInfo , In , InSet , KnownFloatingPointNormalized , Literal , Not }
2833import org .apache .spark .sql .catalyst .expressions .aggregate .{AggregateExpression , BloomFilterAggregate , Final , Min , Partial , PartialMerge }
2934import org .apache .spark .sql .catalyst .optimizer .NormalizeNaNAndZero
35+ import org .apache .spark .sql .catalyst .plans .logical .{LocalRelation , LogicalPlan }
36+ import org .apache .spark .sql .catalyst .rules .Rule
3037import org .apache .spark .sql .comet ._
3138import org .apache .spark .sql .comet .execution .shuffle .CometShuffleExchangeExec
3239import org .apache .spark .sql .execution ._
33- import org .apache .spark .sql .execution .adaptive .{QueryStageExec , ShuffleQueryStageExec }
40+ import org .apache .spark .sql .execution .adaptive .{AdaptiveSparkPlanExec , BroadcastQueryStageExec , LogicalQueryStage , QueryStageExec , ShuffleQueryStageExec , SimpleCost , SimpleCostEvaluator }
3441import org .apache .spark .sql .execution .aggregate .{HashAggregateExec , ObjectHashAggregateExec }
3542import org .apache .spark .sql .execution .datasources .v2 .BatchScanExec
3643import org .apache .spark .sql .execution .exchange .{BroadcastExchangeExec , ShuffleExchangeExec }
3744import org .apache .spark .sql .internal .SQLConf
3845import org .apache .spark .sql .types .{DataTypes , DoubleType , FloatType , StructField , StructType }
3946
40- import org .apache .comet .{CometConf , CometCoverageStats , CometExplainInfo , ExtendedExplainInfo }
47+ import org .apache .comet .{CometConf , CometCoverageStats , CometExplainInfo , CometSparkSessionExtensions , ExtendedExplainInfo }
4148import org .apache .comet .CometSparkSessionExtensions .{isSpark35Plus , isSpark40Plus , isSpark42Plus , withFallbackReason }
4249import org .apache .comet .serde .{CometAggregateExpressionSerde , Compatible , ExprOuterClass , QueryPlanSerde , Unsupported }
4350import org .apache .comet .testing .{DataGenOptions , FuzzDataGenerator }
@@ -49,6 +56,40 @@ import org.apache.comet.testing.{DataGenOptions, FuzzDataGenerator}
4956 */
5057class CometExecRuleSuite extends CometTestBase {
5158
59+ // The observers are active only during the DPP lifecycle regression below. AQE can prepare
60+ // subqueries on different threads, so publish the callbacks and pair each thread's invocations.
61+ @ volatile private var beforeCometPreparation : SparkPlan => Unit = (_ : SparkPlan ) => ()
62+ @ volatile private var afterCometPreparation : SparkPlan => Unit = (_ : SparkPlan ) => ()
63+
64+ override protected def createSparkSession : SparkSessionType = {
65+ SparkSession .clearActiveSession()
66+ SparkSession .clearDefaultSession()
67+ SparkSession
68+ .builder()
69+ .config(sparkContext.getConf)
70+ .withExtensions { extensions =>
71+ extensions.injectQueryStagePrepRule { _ =>
72+ new Rule [SparkPlan ] {
73+ override def apply (plan : SparkPlan ): SparkPlan = {
74+ beforeCometPreparation(plan)
75+ plan
76+ }
77+ }
78+ }
79+ new CometSparkSessionExtensions ().apply(extensions)
80+ extensions.injectQueryStagePrepRule { _ =>
81+ new Rule [SparkPlan ] {
82+ override def apply (plan : SparkPlan ): SparkPlan = {
83+ afterCometPreparation(plan)
84+ plan
85+ }
86+ }
87+ }
88+ }
89+ .getOrCreate()
90+ .asInstanceOf [SparkSessionType ]
91+ }
92+
5293 /** Helper method to apply CometExecRule and return the transformed plan */
5394 private def applyCometExecRule (plan : SparkPlan ): SparkPlan = {
5495 CometExecRule (spark).apply(stripAQEPlan(plan))
@@ -106,6 +147,192 @@ class CometExecRuleSuite extends CometTestBase {
106147 case a : ObjectHashAggregateExec if a.aggregateExpressions.forall(_.mode == Partial ) => a
107148 }.get
108149
150+ /** A native final aggregate over a shuffle stage, as reused by AQE replanning. */
151+ private def createAdaptiveAggregate (): CometHashAggregateExec = {
152+ val plan = createSparkPlan(
153+ spark,
154+ " SELECT id % 3 AS k, SUM(id) AS total FROM range(0, 100, 1, 2) GROUP BY id % 3" )
155+ val aggregate = applyCometExecRule(plan).asInstanceOf [CometHashAggregateExec ]
156+ val shuffle = aggregate.child.asInstanceOf [CometShuffleExchangeExec ]
157+ aggregate
158+ .withNewChildren(Seq (ShuffleQueryStageExec (0 , shuffle, shuffle.canonicalized)))
159+ .asInstanceOf [CometHashAggregateExec ]
160+ }
161+
162+ test(" CometExecRule preserves the current direct AQE logical link" ) {
163+ withSQLConf(
164+ SQLConf .ADAPTIVE_EXECUTION_ENABLED .key -> " false" ,
165+ SQLConf .WHOLESTAGE_CODEGEN_ENABLED .key -> " false" ,
166+ CometConf .COMET_SPARK_TO_ARROW_SUPPORTED_OPERATOR_LIST .key -> " Range" ) {
167+ val originalTags =
168+ Seq (Some (SparkPlan .LOGICAL_PLAN_TAG ), Some (SparkPlan .LOGICAL_PLAN_INHERITED_TAG ), None )
169+ originalTags.foreach { originalTag =>
170+ withClue(s " original logical tag: $originalTag" ) {
171+ val aggregate = createAdaptiveAggregate()
172+ val original = aggregate.originalPlan
173+ val originalLogicalPlan = original.logicalLink.get
174+ original.unsetTagValue(SparkPlan .LOGICAL_PLAN_TAG )
175+ original.unsetTagValue(SparkPlan .LOGICAL_PLAN_INHERITED_TAG )
176+ originalTag.foreach(original.setTagValue(_, originalLogicalPlan))
177+
178+ var current : SparkPlan = aggregate
179+ (1 to 2 ).foreach { _ =>
180+ val logicalStage = LogicalQueryStage (originalLogicalPlan, current)
181+ val replanned = spark.sessionState.planner.plan(logicalStage).next()
182+ assert(replanned eq current)
183+ assert(replanned.getTagValue(SparkPlan .LOGICAL_PLAN_TAG ).exists(_ eq logicalStage))
184+
185+ current = applyCometExecRule(replanned)
186+ assert(current.getTagValue(SparkPlan .LOGICAL_PLAN_TAG ).exists(_ eq logicalStage))
187+ }
188+ }
189+ }
190+ }
191+ }
192+
193+ test(" CometExecRule repairs ordinary and inherited logical links from the original plan" ) {
194+ withSQLConf(
195+ SQLConf .ADAPTIVE_EXECUTION_ENABLED .key -> " false" ,
196+ SQLConf .WHOLESTAGE_CODEGEN_ENABLED .key -> " false" ,
197+ CometConf .COMET_SPARK_TO_ARROW_SUPPORTED_OPERATOR_LIST .key -> " Range" ) {
198+ val originalTags =
199+ Seq (Some (SparkPlan .LOGICAL_PLAN_TAG ), Some (SparkPlan .LOGICAL_PLAN_INHERITED_TAG ), None )
200+ for (originalTag <- originalTags; hasDirectLink <- Seq (false , true )) {
201+ withClue(s " original logical tag: $originalTag, ordinary direct link: $hasDirectLink" ) {
202+ val aggregate = createAdaptiveAggregate()
203+ val original = aggregate.originalPlan
204+ val originalLogicalPlan = original.logicalLink.get
205+ original.unsetTagValue(SparkPlan .LOGICAL_PLAN_TAG )
206+ original.unsetTagValue(SparkPlan .LOGICAL_PLAN_INHERITED_TAG )
207+ originalTag.foreach(original.setTagValue(_, originalLogicalPlan))
208+
209+ aggregate.unsetTagValue(SparkPlan .LOGICAL_PLAN_TAG )
210+ aggregate.setTagValue(
211+ SparkPlan .LOGICAL_PLAN_INHERITED_TAG ,
212+ LogicalQueryStage (originalLogicalPlan, aggregate))
213+ if (hasDirectLink) {
214+ aggregate.setTagValue(SparkPlan .LOGICAL_PLAN_TAG , LocalRelation (aggregate.output))
215+ }
216+
217+ val transformed = applyCometExecRule(aggregate)
218+ if (originalTag.isDefined) {
219+ assert(transformed.logicalLink.exists(_ eq originalLogicalPlan))
220+ } else {
221+ assert(transformed.getTagValue(SparkPlan .LOGICAL_PLAN_TAG ).isEmpty)
222+ assert(transformed.getTagValue(SparkPlan .LOGICAL_PLAN_INHERITED_TAG ).isEmpty)
223+ }
224+ }
225+ }
226+ }
227+ }
228+
229+ test(" AQE DPP broadcast roots retain temporary logical links after an unchanged replan" ) {
230+ assume(isSpark35Plus, " Native AQE DPP requires Spark 3.5+" )
231+ withSQLConf(
232+ SQLConf .USE_V1_SOURCE_LIST .key -> " parquet" ,
233+ SQLConf .ADAPTIVE_EXECUTION_ENABLED .key -> " true" ,
234+ SQLConf .ADAPTIVE_FORCE_OPTIMIZE_SKEWED_JOIN .key -> " false" ,
235+ SQLConf .DYNAMIC_PARTITION_PRUNING_ENABLED .key -> " true" ,
236+ SQLConf .DYNAMIC_PARTITION_PRUNING_REUSE_BROADCAST_ONLY .key -> " true" ,
237+ SQLConf .SHUFFLE_PARTITIONS .key -> " 2" ,
238+ CometConf .COMET_SHUFFLE_MODE .key -> " native" ) {
239+ withTempDir { dir =>
240+ withTempView(" dpp_link_fact" , " dpp_link_dim" ) {
241+ withSQLConf(CometConf .COMET_ENABLED .key -> " false" ) {
242+ spark
243+ .range(64 )
244+ .selectExpr(" CAST(id % 8 AS INT) AS k" , " id AS v" )
245+ .write
246+ .partitionBy(" k" )
247+ .parquet(s " $dir/fact " )
248+ spark
249+ .range(32 )
250+ .selectExpr(
251+ " CAST(id % 8 AS INT) AS k" ,
252+ " id AS v" ,
253+ " IF(id % 2 = 0, 'DE', 'US') AS country" )
254+ .write
255+ .parquet(s " $dir/dim " )
256+ }
257+ spark.read.parquet(s " $dir/fact " ).createOrReplaceTempView(" dpp_link_fact" )
258+ spark.read.parquet(s " $dir/dim " ).createOrReplaceTempView(" dpp_link_dim" )
259+
260+ assert(
261+ spark.sessionState.conf.getConf(SQLConf .ADAPTIVE_CUSTOM_COST_EVALUATOR_CLASS ).isEmpty)
262+ type Replan = (SparkPlan , LogicalPlan )
263+ val pending = new ThreadLocal [List [Option [Replan ]]] {
264+ override def initialValue (): List [Option [Replan ]] = Nil
265+ }
266+ val observed = new ConcurrentLinkedQueue [(CometBroadcastExchangeExec , LogicalPlan )]()
267+ val tempTag = AdaptiveSparkPlanExec .TEMP_LOGICAL_PLAN_TAG
268+ val costEvaluator = SimpleCostEvaluator (forceOptimizeSkewedJoin = false )
269+ beforeCometPreparation = plan => {
270+ val replan = plan match {
271+ case broadcast : CometBroadcastExchangeExec =>
272+ broadcast.getTagValue(SparkPlan .LOGICAL_PLAN_TAG ).collect {
273+ case stage : LogicalQueryStage =>
274+ assert(stage.physicalPlan eq broadcast)
275+ assert(broadcast.getTagValue(tempTag).exists(_ eq stage.logicalPlan))
276+ (broadcast.clone(), stage.logicalPlan)
277+ }
278+ case _ => None
279+ }
280+ pending.set(replan :: pending.get())
281+ }
282+ afterCometPreparation = plan => {
283+ val replan = pending.get().head
284+ val remaining = pending.get().tail
285+ if (remaining.isEmpty) pending.remove() else pending.set(remaining)
286+ replan.foreach { case (previous, logicalPlan) =>
287+ val broadcast = plan.asInstanceOf [CometBroadcastExchangeExec ]
288+ assert(broadcast.logicalLink.exists(_ eq logicalPlan))
289+ assert(broadcast.getTagValue(tempTag).exists(_ eq logicalPlan))
290+ // Spark rejects an equal-cost candidate when its physical tree is unchanged.
291+ // Pin both inputs to that decision, including Comet's retained temporary link.
292+ assert(previous == broadcast)
293+ assert(costEvaluator.evaluateCost(previous) == SimpleCost (0 ))
294+ assert(costEvaluator.evaluateCost(broadcast) == SimpleCost (0 ))
295+ observed.add(
296+ (broadcast.clone().asInstanceOf [CometBroadcastExchangeExec ], logicalPlan))
297+ }
298+ }
299+ try {
300+ val df = sql("""
301+ |SELECT /*+ BROADCAST(d) */ f.k, f.total, d.total
302+ |FROM (SELECT k, SUM(v) AS total FROM dpp_link_fact GROUP BY k) f
303+ |JOIN (SELECT k, SUM(v) AS total FROM dpp_link_dim
304+ | WHERE country = 'DE' GROUP BY k) d ON f.k = d.k
305+ |""" .stripMargin)
306+ QueryTest .checkAnswer(
307+ df,
308+ (0 until 8 by 2 ).map(k => Row (k, 224L + 8L * k, 48L + 4L * k)),
309+ checkToRDD = false )
310+ val plan = df.queryExecution.executedPlan
311+ assert(collect(plan) { case b : CometBroadcastHashJoinExec => b }.nonEmpty)
312+ assert(collectWithSubqueries(plan) { case s : CometSubqueryBroadcastExec =>
313+ s
314+ }.nonEmpty)
315+ assert(! observed.isEmpty, " Expected a DPP broadcast root with a direct logical stage" )
316+ observed.iterator().asScala.foreach { case (broadcast, logicalPlan) =>
317+ // Give the isolated snapshot conflicting links to pin Spark's TEMP-over-direct
318+ // precedence, which would otherwise be invisible after Comet repairs both.
319+ broadcast.setLogicalLink(LogicalQueryStage (logicalPlan, broadcast))
320+ val stage = BroadcastQueryStageExec (0 , broadcast, broadcast.canonicalized)
321+ val setStageLink = PrivateMethod [Unit ](Symbol (" setLogicalLinkForNewQueryStage" ))
322+ plan
323+ .asInstanceOf [AdaptiveSparkPlanExec ]
324+ .invokePrivate(setStageLink(stage, broadcast))
325+ assert(stage.logicalLink.exists(_ eq logicalPlan))
326+ }
327+ } finally {
328+ beforeCometPreparation = _ => ()
329+ afterCometPreparation = _ => ()
330+ }
331+ }
332+ }
333+ }
334+ }
335+
109336 test(" expression-level fallback reasons are rolled up onto the operator that falls back" ) {
110337 // Extended explain only walks plan nodes, so a reason recorded on a sub-expression is
111338 // invisible unless CometExecRule lifts it onto the enclosing operator. Disabling a single
0 commit comments