def transformExpression()

in integration/spark/src/main/scala/org/apache/spark/sql/optimizer/CarbonFilters.scala [462:547]
86 lines of code
45 McCabe index (conditional complexity)

  def transformExpression(expr: SparkExpression): Expression = {
    expr match {
      case plan if CarbonHiveIndexMetadataUtil.checkNIUDF(plan) =>
        transformExpression(CarbonHiveIndexMetadataUtil.getNIChildren(plan))
      case Or(left, right) if canPushDown(left, right) =>
        new OrExpression(transformExpression(left), transformExpression(right))
      case And(left, right) if canPushDown(left, right) =>
        new AndExpression(transformExpression(left), transformExpression(right))
      case EqualTo(left, right) if canPushDown(left, right) =>
        new EqualToExpression(transformExpression(left), transformExpression(right))
      case Not(EqualTo(left, right)) if canPushDown(left, right) =>
        new NotEqualsExpression(transformExpression(left), transformExpression(right))
      case IsNotNull(child) if canPushDown(child) =>
        new NotEqualsExpression(transformExpression(child), transformExpression(Literal(null)),
          true)
      case IsNull(child) if canPushDown(child) =>
        new EqualToExpression(transformExpression(child), transformExpression(Literal(null)), true)
      case Not(In(left, right)) if canPushDown(left) =>
        if (right.contains(null)) {
          new FalseExpression(transformExpression(left))
        } else {
          new NotInExpression(transformExpression(left),
            new ListExpression(convertToJavaList(right.map(transformExpression)))
          )
        }
      case In(left, right) if canPushDown(left) =>
        left match {
          case left: AttributeReference
            if left.name.equalsIgnoreCase(CarbonCommonConstants.POSITION_ID) =>
            new InExpression(transformExpression(left),
              new ImplicitExpression(convertToJavaList(right.filter(_ != null)
                .filter(!isNullLiteral(_))
                .map(transformExpression))))
          case _ =>
            new InExpression(transformExpression(left), new ListExpression(convertToJavaList(
              right.filter(_ != null).filter(!isNullLiteral(_)).map(transformExpression))))
        }
      case InSet(left, right) if canPushDown(left) =>
        val validData = right.filter(_ != null).map { x =>
          transformExpression(Literal(x.toString))
        }.toList
        new InExpression(transformExpression(left),
          new ListExpression(convertToJavaList(validData)))
      case Not(InSet(left, right)) if canPushDown(left) =>
        if (right.contains(null)) {
          new FalseExpression(transformExpression(left))
        } else {
          val r = right.map { x =>
            val strVal = if (null == x) {
              x
            } else {
              x.toString
            }
            transformExpression(Literal(strVal))
          }.toList
          new NotInExpression(transformExpression(left), new ListExpression(convertToJavaList(r)))
        }
      case GreaterThan(left, right) if canPushDown(left, right) =>
        new GreaterThanExpression(transformExpression(left), transformExpression(right))
      case GreaterThanOrEqual(left, right) if canPushDown(left, right) =>
        new GreaterThanEqualToExpression(transformExpression(left), transformExpression(right))
      case LessThan(left, right) if canPushDown(left, right) =>
        new LessThanExpression(transformExpression(left), transformExpression(right))
      case LessThanOrEqual(left, right) if canPushDown(left, right) =>
        new LessThanEqualToExpression(transformExpression(left), transformExpression(right))
      case AttributeReference(name, dataType, _, _) =>
        new ColumnExpression(name, CarbonSparkDataSourceUtil.convertSparkToCarbonDataType(dataType))
      case Literal(name, dataType) => new
          LiteralExpression(name,
            CarbonSparkDataSourceUtil.convertSparkToCarbonDataType(dataType))
      case StartsWith(left, right@Literal(pattern, dataType))
        if pattern.toString.nonEmpty && canPushDown(left, right) =>
        val l = new GreaterThanEqualToExpression(transformExpression(left),
          transformExpression(right))
        val patternText = pattern.toString
        val lastChar = (patternText.charAt(patternText.length - 1).toInt + 1).toChar
        val maxValueLimit = patternText.substring(0, patternText.length - 1) + lastChar
        val r = new LessThanExpression(transformExpression(left),
          new LiteralExpression(maxValueLimit,
            CarbonSparkDataSourceUtil.convertSparkToCarbonDataType(dataType)))
        new AndExpression(l, r)
      case strTrim: StringTrim if isStringTrimCompatibleWithCarbon(strTrim) =>
        transformExpression(strTrim)
      case _ => getSparkUnknownExpression(expr)
    }
  }