public static ConstEval newConst(Datum datum) { return new ConstEval(datum); }
public static ConstEval newConst(Datum datum) { return new ConstEval(datum); }
@Override public EvalNode visitNullLiteral(Context ctx, Stack<Expr> stack, NullLiteral expr) throws TajoException { return new ConstEval(NullDatum.get()); }
@Override public EvalNode visitNullLiteral(Context ctx, Stack<Expr> stack, NullLiteral expr) throws TajoException { return new ConstEval(NullDatum.get()); }
@Override public EvalNode visitLiteral(Context ctx, Stack<Expr> stack, LiteralValue expr) throws TajoException { switch (expr.getValueType()) { case Boolean: return new ConstEval(DatumFactory.createBool(Boolean.parseBoolean(expr.getValue()))); case String: return new ConstEval(DatumFactory.createText(expr.getValue())); case Unsigned_Integer: return new ConstEval(DatumFactory.createInt4(expr.getValue())); case Unsigned_Large_Integer: return new ConstEval(DatumFactory.createInt8(expr.getValue())); case Unsigned_Float: return new ConstEval(DatumFactory.createFloat8(expr.getValue())); default: throw new RuntimeException("Unsupported type: " + expr.getValueType()); } }
@Override public EvalNode visitUnaryEval(Object context, UnaryEval unaryEval, Stack<EvalNode> stack) { stack.push(unaryEval); EvalNode child = visit(context, unaryEval.getChild(), stack); stack.pop(); if (child.getType() == EvalType.CONST) { return new ConstEval(unaryEval.bind(null, null).eval(null)); } return unaryEval; }
@Override public EvalNode visitUnaryEval(Object context, UnaryEval unaryEval, Stack<EvalNode> stack) { stack.push(unaryEval); EvalNode child = visit(context, unaryEval.getChild(), stack); stack.pop(); if (child.getType() == EvalType.CONST) { return new ConstEval(unaryEval.bind(null, null).eval(null)); } return unaryEval; }
@Override public EvalNode visitIntervalLiteral(Context ctx, Stack<Expr> stack, IntervalLiteral expr) throws TajoException { return new ConstEval(new IntervalDatum(expr.getExprStr())); }
@Override public EvalNode visitIntervalLiteral(Context ctx, Stack<Expr> stack, IntervalLiteral expr) throws TajoException { return new ConstEval(new IntervalDatum(expr.getExprStr())); }
@Override public EvalNode visitUnaryEval(LogicalPlanner.PlanContext context, UnaryEval unaryEval, Stack<EvalNode> stack) { stack.push(unaryEval); EvalNode child = visit(context, unaryEval.getChild(), stack); stack.pop(); unaryEval.setChild(child); if (child.getType() == EvalType.CONST) { // session's time zone String timezoneId = context.getQueryContext().get(SessionVars.TIMEZONE); EvalContext evalContext = new EvalContext(); evalContext.setTimeZone(TimeZone.getTimeZone(timezoneId)); unaryEval.bind(evalContext, null); return new ConstEval(unaryEval.eval(null)); } return unaryEval; }
@Override public EvalNode visitBinaryEval(Object context, Stack<EvalNode> stack, BinaryEval binaryEval) { stack.push(binaryEval); EvalNode lhs = visit(context, binaryEval.getLeftExpr(), stack); EvalNode rhs = visit(context, binaryEval.getRightExpr(), stack); stack.pop(); if (!binaryEval.getLeftExpr().equals(lhs)) { binaryEval.setLeftExpr(lhs); } if (!binaryEval.getRightExpr().equals(rhs)) { binaryEval.setRightExpr(rhs); } if (lhs.getType() == EvalType.CONST && rhs.getType() == EvalType.CONST) { return new ConstEval(binaryEval.bind(null, null).eval(null)); } return binaryEval; }
@Override public EvalNode visitUnaryEval(LogicalPlanner.PlanContext context, UnaryEval unaryEval, Stack<EvalNode> stack) { stack.push(unaryEval); EvalNode child = visit(context, unaryEval.getChild(), stack); stack.pop(); unaryEval.setChild(child); if (child.getType() == EvalType.CONST) { // session's time zone String timezoneId = context.getQueryContext().get(SessionVars.TIMEZONE); EvalContext evalContext = new EvalContext(); evalContext.setTimeZone(TimeZone.getTimeZone(timezoneId)); unaryEval.bind(evalContext, null); return new ConstEval(unaryEval.eval(null)); } return unaryEval; }
@Override public EvalNode visitBinaryEval(Object context, Stack<EvalNode> stack, BinaryEval binaryEval) { stack.push(binaryEval); EvalNode lhs = visit(context, binaryEval.getLeftExpr(), stack); EvalNode rhs = visit(context, binaryEval.getRightExpr(), stack); stack.pop(); if (!binaryEval.getLeftExpr().equals(lhs)) { binaryEval.setLeftExpr(lhs); } if (!binaryEval.getRightExpr().equals(rhs)) { binaryEval.setRightExpr(rhs); } if (lhs.getType() == EvalType.CONST && rhs.getType() == EvalType.CONST) { return new ConstEval(binaryEval.bind(null, null).eval(null)); } return binaryEval; }
@Override public EvalNode visitCastExpr(Context ctx, Stack<Expr> stack, CastExpr expr) throws TajoException { EvalNode child = super.visitCastExpr(ctx, stack, expr); // if it is a casting operation for a constant value, it will be pre-computed and casted to a constant value. if (child.getType() == EvalType.CONST) { ConstEval constEval = (ConstEval) child; // some cast operation may require earlier evaluation with timezone. return new ConstEval( DatumFactory.cast(constEval.getValue(), LogicalPlanner.convertDataType(expr.getTarget()), ctx.timeZone)); } else { return new CastEval(ctx.queryContext, child, LogicalPlanner.convertDataType(expr.getTarget())); } }
@Override public EvalNode visitDateLiteral(Context context, Stack<Expr> stack, DateLiteral expr) throws TajoException { DateValue dateValue = expr.getDate(); int[] dates = dateToIntArray(dateValue.getYears(), dateValue.getMonths(), dateValue.getDays()); TimeMeta tm = new TimeMeta(); tm.years = dates[0]; tm.monthOfYear = dates[1]; tm.dayOfMonth = dates[2]; DateTimeUtil.j2date(DateTimeUtil.date2j(dates[0], dates[1], dates[2]), tm); return new ConstEval(new DateDatum(tm)); }
@Override public EvalNode visitDateLiteral(Context context, Stack<Expr> stack, DateLiteral expr) throws TajoException { DateValue dateValue = expr.getDate(); int[] dates = dateToIntArray(dateValue.getYears(), dateValue.getMonths(), dateValue.getDays()); TimeMeta tm = new TimeMeta(); tm.years = dates[0]; tm.monthOfYear = dates[1]; tm.dayOfMonth = dates[2]; DateTimeUtil.j2date(DateTimeUtil.date2j(dates[0], dates[1], dates[2]), tm); return new ConstEval(new DateDatum(tm)); }
@Test public final void testGetReturnType() { ConstEval e1; ConstEval e2; // PLUS e1 = new ConstEval(DatumFactory.createInt4(9)); e2 = new ConstEval(DatumFactory.createInt4(34)); BinaryEval expr = new BinaryEval(EvalType.PLUS, e1, e2); assertEquals(Type.Int4, expr.getValueType()); expr = new BinaryEval(EvalType.LTH, e1, e2); assertTrue(expr.bind(null, null).eval(null).asBool()); assertEquals(Type.Bool, expr.getValueType()); e1 = new ConstEval(DatumFactory.createFloat8(9.3)); e2 = new ConstEval(DatumFactory.createFloat8(34.2)); expr = new BinaryEval(EvalType.PLUS, e1, e2); assertEquals(Type.Float8, expr.getValueType()); }
@Override public EvalNode visitCastExpr(Context ctx, Stack<Expr> stack, CastExpr expr) throws TajoException { EvalNode child = super.visitCastExpr(ctx, stack, expr); // if it is a casting operation for a constant value, it will be pre-computed and casted to a constant value. if (child.getType() == EvalType.CONST) { ConstEval constEval = (ConstEval) child; // some cast operation may require earlier evaluation with timezone. return new ConstEval( DatumFactory.cast(constEval.getValue(), LogicalPlanner.convertDataType(expr.getTarget()).getDataType(), ctx.timeZone)); } else { return new CastEval(ctx.queryContext, child, LogicalPlanner.convertDataType(expr.getTarget()).getDataType()); } }
@Override public EvalNode visitTimeLiteral(Context ctx, Stack<Expr> stack, TimeLiteral expr) throws TajoException { TimeValue timeValue = expr.getTime(); int [] times = timeToIntArray(timeValue.getHours(), timeValue.getMinutes(), timeValue.getSeconds(), timeValue.getSecondsFraction()); long time; if (timeValue.hasSecondsFraction()) { time = DateTimeUtil.toTime(times[0], times[1], times[2], times[3] * 1000); } else { time = DateTimeUtil.toTime(times[0], times[1], times[2], 0); } TimeDatum timeDatum = new TimeDatum(time); TimeMeta tm = timeDatum.asTimeMeta(); return new ConstEval(new TimeDatum(DateTimeUtil.toTime(tm))); }
private EvalNode visitPatternMatchPredicate(Context ctx, Stack<Expr> stack, PatternMatchPredicate expr) throws TajoException { EvalNode field = visit(ctx, stack, expr.getPredicand()); ConstEval pattern = (ConstEval) visit(ctx, stack, expr.getPattern()); // A pattern is a const value in pattern matching predicates. // In a binary expression, the result is always null if a const value in left or right side is null. if (pattern.getValue() instanceof NullDatum) { return new ConstEval(NullDatum.get()); } else { if (expr.getType() == OpType.LikePredicate) { return new LikePredicateEval(expr.isNot(), field, pattern, expr.isCaseInsensitive()); } else if (expr.getType() == OpType.SimilarToPredicate) { return new SimilarToPredicateEval(expr.isNot(), field, pattern); } else { return new RegexPredicateEval(expr.isNot(), field, pattern, expr.isCaseInsensitive()); } } }