Hi, I find it causes ReuseExchange issue, I find you add combineFilters, do you have any suggestions for that, I think it may meet the same issue @Zouxxyy

Oh, I checked the commit history, and this PR (#6296) changed ExpressionSet to a regular Set. The original ExpressionSet compared expressions based on both determinism and canonical representation, whereas a regular Set only compares expressions directly (using their default equals/hashCode).

It seems what we actually need is comparison based on canonicalized forms. Perhaps we could modify the code like this:

def subtractFilters(left: Seq[Expression], right: Seq[Expression]): Seq[Expression] = {
  val rightCanonicalSet = right.map(_.canonicalized).toSet
  left.filterNot(expr => rightCanonicalSet.contains(expr.canonicalized))
}

def combineFilters(left: Seq[Expression], right: Seq[Expression]): Seq[Expression] = {
  val seen = scala.collection.mutable.Set[Expression]()
  val result = scala.collection.mutable.ListBuffer[Expression]()

  def tryAdd(expr: Expression): Unit = {
    val canon = expr.canonicalized
    if (!seen.contains(canon)) {
      seen += canon
      result += expr
    }
  }

  (left ++ right).foreach(tryAdd)
  result.toList
}

Maybe here we cannot use canonicalized expression, otherwise, will throw subquery is not finished exception. with following code

val scanSet = left.map(_.canonicalized).toSet
scanSet.toSeq ++ right.filter(f => !scanSet.contains(f.canonicalized))

Keep current code now

Maybe the previous version has extra subquery, the filter should not affect ReusedSubquery, Gluten with Spark4.0 result is same with jvm Spark