@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; }
public Target getTarget(String name) { if (!nameToIdBiMap.containsKey(name)) { throw new RuntimeException("No Such target name: " + name); } int id = nameToIdBiMap.get(name); EvalNode evalNode = idToEvalBiMap.get(id); // if it is a constant value, just returns a constant because it can be evaluated everywhere. if (evalNode.getType() == EvalType.CONST) { return new Target(evalNode, name); } // if a name is not the primary name, it means that its expression may be already evaluated and // can just refer a value. Consider an example as follows: // // select l_orderkey + 1 as total1, l_orderkey + 1 as total2 from lineitem // // In this case, total2 will meet the following condition. Then, total2 can // just refer the result of total1 rather than calculating l_orderkey + 1. if (!isPrimaryName(id, name) && isEvaluated(getPrimaryName(id))) { evalNode = new FieldEval(getPrimaryName(id), evalNode.getValueType()); } // if it is a column reference itself, just returns a column reference without any alias. if (evalNode.getType() == EvalType.FIELD && evalNode.getName().equals(name)) { return new Target((FieldEval)evalNode); } else { // otherwise, it returns an expression. return new Target(evalNode, name); } }
public Target(final EvalNode eval, final String alias) { this.expr = eval; // force lower case String normalized = alias; // If an expr is a column reference and its alias is equivalent to column name, ignore a given alias. if (eval instanceof FieldEval && eval.getName().equals(normalized)) { column = ((FieldEval) eval).getColumnRef(); } else { column = new Column(normalized, eval.getValueType()); setAlias(alias); } }
@Test public final void testGetContainExprs() throws CloneNotSupportedException, TajoException { Expr expr = analyzer.parse(QUERIES[1]); LogicalPlan plan = planner.createPlan(defaultContext, expr, true); List<Target> targets = plan.getRootBlock().getRawTargets(); Column col1 = new Column("default.people.score", TajoDataTypes.Type.INT4); Collection<EvalNode> exprs = EvalTreeUtil.getContainExpr(targets.get(0).getEvalTree(), col1); BinaryEval node = (BinaryEval) exprs.iterator().next(); assertEquals(EvalType.LTH, node.getType()); assertEquals(EvalType.PLUS, node.getLeftExpr().getType()); assertEquals(new ConstEval(DatumFactory.createInt4(4)), node.getRightExpr()); Column col2 = new Column("default.people.age", TajoDataTypes.Type.INT4); exprs = EvalTreeUtil.getContainExpr(targets.get(1).getEvalTree(), col2); node = (BinaryEval) exprs.iterator().next(); assertEquals(EvalType.GTH, node.getType()); assertEquals("default.people.age", node.getLeftExpr().getName()); assertEquals(new ConstEval(DatumFactory.createInt4(5)), node.getRightExpr()); }
protected EvalNode visitStringPatternMatch(EvalCodeGenContext context, EvalNode patternEval, Stack<EvalNode> stack) { Class clazz = getStringPatternEvalClass(patternEval.getType()); String fieldName = context.symbols.get(patternEval); emitGetField(context, context.owner, fieldName, clazz); context.aload(1); // tuple context.invokeVirtual(clazz, "eval", Datum.class, new Class[]{Tuple.class}); context.convertToPrimitive(patternEval.getValueType()); return patternEval; }
@Override public Object clone() throws CloneNotSupportedException { ConstEval eval = (ConstEval) super.clone(); eval.datum = datum; return eval; }
public int hashCode() { return this.expr.getName().hashCode(); }
public EvalNode visitInPredicate(EvalCodeGenContext context, EvalNode patternEval, Stack<EvalNode> stack) { String fieldName = context.symbols.get(patternEval); emitGetField(context, context.owner, fieldName, InEval.class); context.aload(1); // tuple context.invokeVirtual(InEval.class, "eval", Datum.class, new Class[]{Tuple.class}); context.convertToPrimitive(patternEval.getValueType()); return patternEval; }
@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; }
public Target getTarget(String name) { if (!nameToIdBiMap.containsKey(name)) { throw new RuntimeException("No Such target name: " + name); } int id = nameToIdBiMap.get(name); EvalNode evalNode = idToEvalBiMap.get(id); // if it is a constant value, just returns a constant because it can be evaluated everywhere. if (evalNode.getType() == EvalType.CONST) { return new Target(evalNode, name); } // if a name is not the primary name, it means that its expression may be already evaluated and // can just refer a value. Consider an example as follows: // // select l_orderkey + 1 as total1, l_orderkey + 1 as total2 from lineitem // // In this case, total2 will meet the following condition. Then, total2 can // just refer the result of total1 rather than calculating l_orderkey + 1. if (!isPrimaryName(id, name) && isEvaluated(getPrimaryName(id))) { evalNode = new FieldEval(getPrimaryName(id), evalNode.getValueType()); } // if it is a column reference itself, just returns a column reference without any alias. if (evalNode.getType() == EvalType.FIELD && evalNode.getName().equals(name)) { return new Target((FieldEval)evalNode); } else { // otherwise, it returns an expression. return new Target(evalNode, name); } }
public Target(final EvalNode eval, final String alias) { this.expr = eval; // force lower case String normalized = alias; // If an expr is a column reference and its alias is equivalent to column name, ignore a given alias. if (eval instanceof FieldEval && eval.getName().equals(normalized)) { column = ((FieldEval) eval).getColumnRef(); } else { column = new Column(normalized, eval.getValueType()); setAlias(alias); } }
protected EvalNode visitStringPatternMatch(EvalCodeGenContext context, EvalNode patternEval, Stack<EvalNode> stack) { Class clazz = getStringPatternEvalClass(patternEval.getType()); String fieldName = context.symbols.get(patternEval); emitGetField(context, context.owner, fieldName, clazz); context.aload(1); // tuple context.invokeVirtual(clazz, "eval", Datum.class, new Class[]{Tuple.class}); context.convertToPrimitive(patternEval.getValueType()); return patternEval; }
public int hashCode() { return this.expr.getName().hashCode(); }
/** * It checks both expressions in a comparison operator are compatible to each other. */ private static void verifyComparisonOperator(VerificationState state, BinaryEval expr) { DataType leftType = expr.getLeftExpr().getValueType(); DataType rightType = expr.getRightExpr().getValueType(); if (!isCompatibleType(leftType, rightType)) { state.addVerification(new UndefinedOperatorException(expr.toString())); } }