private def transformAggregate()

in mv/plan/src/main/scala/org/apache/carbondata/mv/plans/modular/AggregatePushDown.scala [83:207]
125 lines of code
37 McCabe index (conditional complexity)

  private def transformAggregate(aggregate: AggregateExpression,
      selAliasMap: AttributeMap[Attribute],
      ith: Int,
      fact: ModularRelation,
      map: scala.collection.mutable.Map[Int, (NamedExpression, Seq[NamedExpression])],
      aliasInfo: Option[(String, ExprId)]) = {
    aggregate match {
      case cnt: AggregateExpression if cnt.aggregateFunction.isInstanceOf[Count] &&
        cnt.aggregateFunction.children.length == 1 && cnt.aggregateFunction.children.head
        .isInstanceOf[Attribute] =>
        val exprs = cnt.aggregateFunction.children
        val tAttr = selAliasMap.get(exprs.head.asInstanceOf[Attribute]).getOrElse(exprs.head)
          .asInstanceOf[Attribute]
        if (fact.outputSet.contains(tAttr)) {
          val cnt1 = AggregateExpression(Count(tAttr), cnt.mode, isDistinct = false)
          val alias = Alias(cnt1, cnt1.toString)()
          val tSum = cnt.copy(Sum(alias.toAttribute), cnt.mode, isDistinct = false, resultId = cnt
            .resultId)
          val (name, id) = aliasInfo.getOrElse(("", NamedExpression.newExprId))
          map += (ith -> (Alias(tSum, name)(exprId = id), Seq(alias)))
        } else {
          Map.empty[Int, (NamedExpression, Seq[NamedExpression])]
        }
      case cnt: AggregateExpression if cnt.aggregateFunction.isInstanceOf[Count] &&
        cnt.aggregateFunction.children.length == 1 && cnt.aggregateFunction.children.head
        .isInstanceOf[Literal] =>
        val cnt1 = cnt.copy(Count(cnt.aggregateFunction.children.head), cnt.mode,
          isDistinct = false)
        val alias = Alias(cnt1, cnt1.toString)()
        val tSum = cnt.copy(Sum(alias.toAttribute), cnt.mode, isDistinct = false, resultId = cnt
          .resultId)
        val (name, id) = aliasInfo.getOrElse(("", NamedExpression.newExprId))
        map += (ith -> (Alias(tSum, name)(exprId = id), Seq(alias)))
      case sum: AggregateExpression if sum.aggregateFunction.isInstanceOf[Sum] &&
        sum.aggregateFunction.children.head.isInstanceOf[Attribute] =>
        val expr = sum.aggregateFunction.children.head
        val tAttr = selAliasMap.get(expr.asInstanceOf[Attribute]).getOrElse(expr)
          .asInstanceOf[Attribute]
        if (fact.outputSet.contains(tAttr)) {
          val sum1 = AggregateExpression(Sum(tAttr), sum.mode, isDistinct = false)
          val alias = Alias(sum1, sum1.toString)()
          val tSum = sum.copy(Sum(alias.toAttribute), sum.mode, isDistinct = false, resultId = sum
            .resultId)
          val (name, id) = aliasInfo.getOrElse(("", NamedExpression.newExprId))
          map += (ith -> (Alias(tSum, name)(exprId = id), Seq(alias)))
        } else {
          Map.empty[Int, (NamedExpression, Seq[NamedExpression])]
        }
      case sum@MatchAggregateExpression(Sum(cast@MatchCast(expr, dataType)), _, false, _, _) =>
        val tAttr = selAliasMap.get(expr.asInstanceOf[Attribute]).getOrElse(expr)
          .asInstanceOf[Attribute]
        if (fact.outputSet.contains(tAttr)) {
          val sum1 = AggregateExpression(Sum(cast), sum.mode, false)
          val alias = Alias(sum1, sum1.toString)()
          val tSum = sum.copy(Sum(alias.toAttribute), sum.mode, isDistinct = false, resultId = sum
            .resultId)
          val (name, id) = aliasInfo.getOrElse(("", NamedExpression.newExprId))
          map += (ith -> (Alias(tSum, name)(exprId = id), Seq(alias)))
        } else {
          Map.empty[Int, (NamedExpression, Seq[NamedExpression])]
        }
      case sum: AggregateExpression if sum.aggregateFunction.isInstanceOf[Sum] &&
        sum.aggregateFunction.children.head.isInstanceOf[Literal] =>
        val sum1 = AggregateExpression(Sum(sum.aggregateFunction.children.head), sum.mode,
          isDistinct = false)
        val alias = Alias(sum1, sum1.toString)()
        val tSum = sum.copy(Sum(alias.toAttribute), sum.mode, isDistinct = false, resultId = sum
          .resultId)
        val (name, id) = aliasInfo.getOrElse(("", NamedExpression.newExprId))
        map += (ith -> (Alias(tSum, name)(exprId = id), Seq(alias)))
      case max: AggregateExpression if max.aggregateFunction.isInstanceOf[Max] &&
        max.aggregateFunction.children.head.isInstanceOf[Attribute] =>
        val expr = max.aggregateFunction.children.head
        val tAttr = selAliasMap.get(expr.asInstanceOf[Attribute]).getOrElse(expr)
          .asInstanceOf[Attribute]
        if (fact.outputSet.contains(tAttr)) {
          val max1 = AggregateExpression(Sum(tAttr), max.mode, isDistinct = false)
          val alias = Alias(max1, max1.toString)()
          val tMax = max.copy(Max(alias.toAttribute), max.mode, isDistinct = false, resultId = max
            .resultId)
          val (name, id) = aliasInfo.getOrElse(("", NamedExpression.newExprId))
          map += (ith -> (Alias(tMax, name)(exprId = id), Seq(alias)))
        } else {
          Map.empty[Int, (NamedExpression, Seq[NamedExpression])]
        }
      case min: AggregateExpression if min.aggregateFunction.isInstanceOf[Min] &&
        min.aggregateFunction.children.head.isInstanceOf[Attribute] =>
        val expr = min.aggregateFunction.children.head
        val tAttr = selAliasMap.get(expr.asInstanceOf[Attribute]).getOrElse(expr)
          .asInstanceOf[Attribute]
        if (fact.outputSet.contains(tAttr)) {
          val min1 = AggregateExpression(Min(tAttr), min.mode, isDistinct = false)
          val alias = Alias(min1, min1.toString)()
          val tMin = min.copy(Max(alias.toAttribute), min.mode, isDistinct = false, resultId = min
            .resultId)
          val (name, id) = aliasInfo.getOrElse(("", NamedExpression.newExprId))
          map += (ith -> (Alias(tMin, name)(exprId = id), Seq(alias)))
        } else {
          Map.empty[Int, (NamedExpression, Seq[NamedExpression])]
        }
      case avg: AggregateExpression if (avg.aggregateFunction.isInstanceOf[Average] &&
        avg.aggregateFunction.children.head.isInstanceOf[Attribute]) =>
        val expr = avg.aggregateFunction.children.head
        val tAttr = selAliasMap.get(expr.asInstanceOf[Attribute]).getOrElse(expr)
          .asInstanceOf[Attribute]
        if (fact.outputSet.contains(tAttr)) {
          map += (ith ->  getAliasMapForAvgAggregate(tAttr, avg, aliasInfo))
        } else {
          Map.empty[Int, (NamedExpression, Seq[NamedExpression])]
        }
      case avg@MatchAggregateExpression(Average(cast@MatchCast(expr, dataType)), _, false, _, _) =>
        val tAttr = selAliasMap.get(expr.asInstanceOf[Attribute]).getOrElse(expr)
          .asInstanceOf[Attribute]
        if (fact.outputSet.contains(tAttr)) {
          map += (ith -> getAliasMapForAvgAggregate(cast, avg, aliasInfo))
        } else {
          Map.empty[Int, (NamedExpression, Seq[NamedExpression])]
        }
      case avg: AggregateExpression if avg.aggregateFunction.isInstanceOf[Average] &&
                                       avg.aggregateFunction.children.head.isInstanceOf[Literal] =>
        map +=
        (ith -> getAliasMapForAvgAggregate(avg.aggregateFunction.children.head, avg, aliasInfo))
      case _ => Map.empty[Int, (NamedExpression, Seq[NamedExpression])]
    }
  }