protected[sql] def translateExpression()

in integration/spark/src/main/scala/org/apache/spark/sql/optimizer/CarbonFilters.scala [75:166]
91 lines of code
49 McCabe index (conditional complexity)

  protected[sql] def translateExpression(
      relation: CarbonDatasourceHadoopRelation,
      predicate: SparkExpression,
      columnTypes: Map[String, SparkDataType],
      isOr: Boolean = false): Option[Expression] = {

    predicate match {
      case u: ScalaUDF =>
        translateUDF(u.children, u.function, relation)
      case Or(left, right) =>
        translateOr(left, right, relation, columnTypes)
      case And(left, right) =>
        translateAnd(left, right, relation, columnTypes, isOr)
      case EqualTo(a: Attribute, Literal(v, _)) =>
        translateEqualTo(a.name, v, columnTypes)
      case EqualTo(Literal(v, _), a: Attribute) =>
        translateEqualTo(a.name, v, columnTypes)
      case c@EqualTo(Cast(_: Attribute, _, _), _: Literal) =>
        CastExpressionOptimization.checkIfCastCanBeRemove(c)
      case c@EqualTo(_: Literal, Cast(_: Attribute, _, _)) =>
        CastExpressionOptimization.checkIfCastCanBeRemove(c)
      case Not(EqualTo(a: Attribute, Literal(v, _))) =>
        translateNotEqualTo(a.name, v, columnTypes)
      case Not(EqualTo(Literal(v, _), a: Attribute)) =>
        translateNotEqualTo(a.name, v, columnTypes)
      case c@Not(EqualTo(Cast(_: Attribute, _, _), _: Literal)) =>
        CastExpressionOptimization.checkIfCastCanBeRemove(c)
      case c@Not(EqualTo(_: Literal, Cast(_: Attribute, _, _))) =>
        CastExpressionOptimization.checkIfCastCanBeRemove(c)
      case IsNotNull(a: Attribute) =>
        translateNotEqualTo(a.name, null, columnTypes, true)
      case IsNull(a: Attribute) =>
        translateEqualTo(a.name, null, columnTypes, true)
      case Not(In(a: Attribute, list)) if list.forall(_.isInstanceOf[Literal]) =>
        translateNotIn(a.name, list.map(e => e.eval(EmptyRow)), columnTypes)
      case In(a: Attribute, list) if list.forall(_.isInstanceOf[Literal]) =>
        translateIn(a.name, list.map(e => e.eval(EmptyRow)), columnTypes)
      case c@Not(In(Cast(_: Attribute, _, _), list)) if list.forall(_.isInstanceOf[Literal]) =>
        Some(transformExpression(c))
      case c@In(Cast(_: Attribute, _, _), list) if list.forall(_.isInstanceOf[Literal]) =>
        Some(transformExpression(c))
      case InSet(a: Attribute, set) =>
        translateIn(a.name, set.toSeq, columnTypes)
      case Not(InSet(a: Attribute, set)) =>
        translateNotIn(a.name, set.toSeq, columnTypes)
      case GreaterThan(a: Attribute, Literal(v, _)) =>
        translateGreaterThan(a.name, v, columnTypes)
      case GreaterThan(Literal(v, _), a: Attribute) =>
        translateLessThan(a.name, v, columnTypes)
      case c@GreaterThan(Cast(_: Attribute, _, _), _: Literal) =>
        CastExpressionOptimization.checkIfCastCanBeRemove(c)
      case c@GreaterThan(_: Literal, Cast(_: Attribute, _, _)) =>
        CastExpressionOptimization.checkIfCastCanBeRemove(c)
      case LessThan(a: Attribute, Literal(v, _)) =>
        translateLessThan(a.name, v, columnTypes)
      case LessThan(Literal(v, _), a: Attribute) =>
        translateGreaterThan(a.name, v, columnTypes)
      case c@LessThan(Cast(_: Attribute, _, _), _: Literal) =>
        CastExpressionOptimization.checkIfCastCanBeRemove(c)
      case c@LessThan(_: Literal, Cast(_: Attribute, _, _)) =>
        CastExpressionOptimization.checkIfCastCanBeRemove(c)
      case GreaterThanOrEqual(a: Attribute, Literal(v, _)) =>
        translateGreaterThanEqual(a.name, v, columnTypes)
      case GreaterThanOrEqual(Literal(v, _), a: Attribute) =>
        translateLessThanEqual(a.name, v, columnTypes)
      case c@GreaterThanOrEqual(Cast(_: Attribute, _, _), _: Literal) =>
        CastExpressionOptimization.checkIfCastCanBeRemove(c)
      case c@GreaterThanOrEqual(_: Literal, Cast(_: Attribute, _, _)) =>
        CastExpressionOptimization.checkIfCastCanBeRemove(c)
      case LessThanOrEqual(a: Attribute, Literal(v, _)) =>
        translateLessThanEqual(a.name, v, columnTypes)
      case LessThanOrEqual(Literal(v, _), a: Attribute) =>
        translateGreaterThanEqual(a.name, v, columnTypes)
      case c@LessThanOrEqual(Cast(_: Attribute, _, _), Literal(v, t)) =>
        CastExpressionOptimization.checkIfCastCanBeRemove(c)
      case c@LessThanOrEqual(_: Literal, Cast(_: Attribute, _, _)) =>
        CastExpressionOptimization.checkIfCastCanBeRemove(c)
      case StartsWith(a: Attribute, Literal(v, _)) if v.toString.nonEmpty =>
        translateStartsWith(a.name, v, columnTypes)
      case c@EndsWith(_: Attribute, _: Literal) =>
        Some(getSparkUnknownExpression(c, ExpressionType.ENDSWITH))
      case c@Contains(_: Attribute, _: Literal) =>
        Some(getSparkUnknownExpression(c, ExpressionType.CONTAINSWITH))
      case Literal(v, _) if v == null =>
        Some(new FalseExpression(null))
      case ArrayContains(a: Attribute, Literal(v, _)) =>
        translateArrayContains(a, v, columnTypes)
      case ac@ArrayContains(Cast(_: Attribute, _, _), _: Literal) =>
        CastExpressionOptimization.checkIfCastCanBeRemove(EqualTo(ac.left, ac.right))
      case _ => None
    }
  }