return false;

    }

    private HoldingContainer visitReturnValueExpression(ReturnValueExpression e, ClassGenerator<?> generator) {

      // Preconditions.checkArgument(child.getMajorType().equals(Types.REQUIRED_BOOLEAN));

      if (e.isReturnTrueOnOne()) {

        generator.getEvalBlock()._return(hc.getValue().eq(JExpr.lit(1)));

      } else {

        generator.getEvalBlock()._return(hc.getValue());

      }

  }

  public static LogicalExpression materialize(LogicalExpression expr, VectorAccessible batch, ErrorCollector errorCollector, FunctionImplementationRegistry registry,

      boolean allowComplexWriterExpr) {

   

    if (!errorCollector.hasErrors()) {

    }

   

    if(out instanceof NullExpression){

      return new TypedNullConstant(Types.optional(MinorType.INT));

    }else{

    @Override

    public LogicalExpression visitBooleanOperator(BooleanOperator op, FunctionImplementationRegistry registry) {

      List<LogicalExpression> args = Lists.newArrayList();

      for (int i = 0; i < op.args.size(); ++i) {

        assert newExpr != null : String.format("Materialization of %s return a null expression.", op.args.get(i));

        args.add(newExpr);

      }

      //replace with a new function call, since its argument could be changed.

    @Override

    public LogicalExpression visitFunctionCall(FunctionCall call, FunctionImplementationRegistry registry) {

      List<LogicalExpression> args = Lists.newArrayList();

      for (int i = 0; i < call.args.size(); ++i) {

        assert newExpr != null : String.format("Materialization of %s return a null expression.", call.args.get(i));

        args.add(newExpr);

      }

      //replace with a new function call, since its argument could be changed.

      call = new FunctionCall(call.getName(), args, call.getPosition());

      FunctionResolver resolver = FunctionResolverFactory.getResolver(call);

      DrillFuncHolder matchedFuncHolder = registry.findDrillFunction(resolver, call);

      if (matchedFuncHolder instanceof DrillComplexWriterFuncHolder && ! allowComplexWriter) {

        errorCollector.addGeneralError(call.getPosition(), "Only ProjectRecordBatch could have complex writer function. You are using complex writer function " + call.getName() + " in a non-project operation!");

      }

     

      //new arg lists, possible with implicit cast inserted.

      List<LogicalExpression> argsWithCast = Lists.newArrayList();

      if (matchedFuncHolder!=null) {

        //Compare parm type against arg type. Insert cast on top of arg, whenever necessary.

        for (int i = 0; i < call.args.size(); ++i) {

          TypeProtos.MajorType parmType = matchedFuncHolder.getParmMajorType(i);

          //Case 1: If  1) the argument is NullExpression

          //            2) the parameter of matchedFuncHolder allows null input, or func's null_handling is NULL_IF_NULL (means null and non-null are exchangable).

          //        then replace NullExpression with a TypedNullConstant

            ( parmType.getMode().equals(TypeProtos.DataMode.OPTIONAL) ||

              matchedFuncHolder.getNullHandling() == FunctionTemplate.NullHandling.NULL_IF_NULL)) {

            argsWithCast.add(new TypedNullConstant(parmType));

                     matchedFuncHolder.isFieldReader(i)) {

            //Case 2: argument and parameter matches, or parameter is FieldReader.  Do nothing.

            argsWithCast.add(currentArg);

          } else {

            //Case 3: insert cast if param type is different from arg type.

            argsWithCast.add(addCastExpression(call.args.get(i), parmType, registry));

          }

        }

        return matchedFuncHolder.getExpr(call.getName(), argsWithCast, call.getPosition());

      }

      // as no drill func is found, search for a non-Drill function.

      AbstractFuncHolder matchedNonDrillFuncHolder = registry.findNonDrillFunction(call);

      if (matchedNonDrillFuncHolder != null) {

        // Insert implicit cast function holder expressions if required

        List<LogicalExpression> extArgsWithCast = Lists.newArrayList();

        for (int i = 0; i < call.args.size(); ++i) {

          TypeProtos.MajorType parmType = matchedNonDrillFuncHolder.getParmMajorType(i);

            extArgsWithCast.add(currentArg);

          } else {

            // Insert cast if param type is different from arg type.

            extArgsWithCast.add(addCastExpression(call.args.get(i), parmType, registry));

          }

    @Override

    public LogicalExpression visitIfExpression(IfExpression ifExpr, FunctionImplementationRegistry registry) {

      IfExpression.IfCondition conditions = ifExpr.ifCondition;

      conditions = new IfExpression.IfCondition(newCondition, newExpr);

      MinorType thenType = conditions.expression.getMajorType().getMinorType();

      MinorType elseType = newElseExpr.getMajorType().getMinorType();

    @Override

    public LogicalExpression visitCastExpression(CastExpression e, FunctionImplementationRegistry value){

      // if the cast is pointless, remove it.

      MajorType newMajor = e.getMajorType();

      if(newMinor == MinorType.LATE){

        // if the type still isn't fully bound, leave as cast expression.

        return new CastExpression(input, e.getMajorType(), e.getPosition());

      } else if (newMinor == MinorType.NULL) {

    return ret.e;

  }

  private String getExpressionCode(String expression, RecordBatch batch) throws Exception {

    ErrorCollector error = new ErrorCollectorImpl();

    if (error.getErrorCount() != 0) {

      logger.error("Failure while materializing expression [{}].  Errors: {}", expression, error);

      assertEquals(0, error.getErrorCount());

    }

    ClassGenerator<Projector> cg = CodeGenerator.get(Projector.TEMPLATE_DEFINITION, new FunctionImplementationRegistry(DrillConfig.create())).getRoot();

    return cg.getCodeGenerator().generate();

  }

  @Test

  public void testMaterializingConstantTree(@Injectable RecordBatch batch) throws SchemaChangeException {

    ErrorCollector ec = new ErrorCollectorImpl();

        ExpressionPosition.UNKNOWN), batch, ec, registry);

    assertTrue(expr instanceof ValueExpressions.LongExpression);

    assertEquals(1L, ValueExpressions.LongExpression.class.cast(expr).getLong());

    assertFalse(ec.hasErrors());

  }

      }

    };

    ErrorCollector ec = new ErrorCollectorImpl();

        ExpressionPosition.UNKNOWN), batch, ec, registry);

    assertFalse(ec.hasErrors());

  }

    ErrorCollector ec = new ErrorCollectorImpl();

        .setIfCondition(new IfExpression.IfCondition(new ValueExpressions.BooleanExpression("true", ExpressionPosition.UNKNOWN),

            new FieldReference("test1", ExpressionPosition.UNKNOWN)))

        .build();

        .setIfCondition(new IfExpression.IfCondition(new FieldReference("test", ExpressionPosition.UNKNOWN), new ValueExpressions.LongExpression(2L, ExpressionPosition.UNKNOWN)))

        .setElse(elseExpression).build();

    assertTrue(newExpr instanceof IfExpression);

    IfExpression newIfExpr = (IfExpression) newExpr;

    //assertEquals(1, newIfExpr.conditions.size());

    IfExpression.IfCondition ifCondition = newIfExpr.ifCondition;

    assertTrue(newIfExpr.elseExpression instanceof IfExpression);