private def collectFallbackNodes()

in gluten-core/src/main/scala/org/apache/spark/sql/execution/GlutenImplicits.scala [98:158]
57 lines of code
22 McCabe index (conditional complexity)

    private def collectFallbackNodes(plan: QueryPlan[_]): FallbackInfo = {
      var numGlutenNodes = 0
      val fallbackNodeToReason = new mutable.HashMap[String, String]

      def collect(tmp: QueryPlan[_]): Unit = {
        tmp.foreachUp {
          case _: ExecutedCommandExec =>
          case _: CommandResultExec =>
          case _: V2CommandExec =>
          case _: DataWritingCommandExec =>
          case _: WholeStageCodegenExec =>
          case _: WholeStageTransformer =>
          case _: InputAdapter =>
          case _: InputIteratorTransformer =>
          case _: ColumnarToRowTransition =>
          case _: RowToColumnarTransition =>
          case p: ReusedExchangeExec =>
          case p: AdaptiveSparkPlanExec if isFinalAdaptivePlan(p) =>
            collect(p.executedPlan)
          case p: AdaptiveSparkPlanExec =>
            // if we are here that means we are inside table cache.
            val (innerNumGlutenNodes, innerFallbackNodeToReason) =
              withSQLConf(SQLConf.ADAPTIVE_EXECUTION_ENABLED.key -> "false") {
                // re-plan manually to skip cached data
                val newSparkPlan = QueryExecution.createSparkPlan(
                  dateset.sparkSession,
                  dateset.sparkSession.sessionState.planner,
                  p.inputPlan.logicalLink.get)
                val newExecutedPlan = QueryExecution.prepareExecutedPlan(
                  dateset.sparkSession,
                  newSparkPlan
                )
                processPlan(
                  newExecutedPlan,
                  new PlanStringConcat().append,
                  Some(plan => collectFallbackNodes(plan)))
              }
            numGlutenNodes += innerNumGlutenNodes
            fallbackNodeToReason.++=(innerFallbackNodeToReason)
          case p: QueryStageExec => collect(p.plan)
          case p: GlutenPlan =>
            numGlutenNodes += 1
            p.innerChildren.foreach(collect)
          case i: InMemoryTableScanExec =>
            if (PlanUtil.isGlutenTableCache(i)) {
              numGlutenNodes += 1
            } else {
              addFallbackNodeWithReason(i, "Columnar table cache is disabled", fallbackNodeToReason)
            }
            collect(i.relation.cachedPlan)
          case _: AQEShuffleReadExec => // Ignore
          case p: SparkPlan =>
            handleVanillaSparkPlan(p, fallbackNodeToReason)
            p.innerChildren.foreach(collect)
          case _ =>
        }
      }

      collect(plan)
      (numGlutenNodes, fallbackNodeToReason.toMap)
    }