@Override public Object getValue(Symbol symbol) { return new QualifiedNameReference(symbol.toQualifiedName()); } }
public QualifiedNameReference toQualifiedNameReference() { return new QualifiedNameReference(toQualifiedName()); }
@Override public Object getValue(Symbol symbol) { ColumnHandle column = assignments.get(symbol); checkArgument(column != null, "Missing column assignment for %s", symbol); if (!bindings.containsKey(column)) { return new QualifiedNameReference(symbol.toQualifiedName()); } return bindings.get(column).getValue(); } }
private static ProjectNode getHashProjectNode(PlanNodeIdAllocator idAllocator, PlanNode source, Symbol hashSymbol, List<Symbol> partitioningSymbols) { checkArgument(!partitioningSymbols.isEmpty(), "partitioningSymbols is empty"); ImmutableMap.Builder<Symbol, Expression> outputSymbols = ImmutableMap.builder(); for (Symbol symbol : source.getOutputSymbols()) { Expression expression = new QualifiedNameReference(symbol.toQualifiedName()); outputSymbols.put(symbol, expression); } Expression hashExpression = getHashExpression(partitioningSymbols); outputSymbols.put(hashSymbol, hashExpression); return new ProjectNode(idAllocator.getNextId(), source, outputSymbols.build()); }
@Override public Void visitProject(ProjectNode node, Void context) { StringBuilder builder = new StringBuilder(); for (Map.Entry<Symbol, Expression> entry : node.getAssignments().entrySet()) { if ((entry.getValue() instanceof QualifiedNameReference) && ((QualifiedNameReference) entry.getValue()).getName().equals(entry.getKey().toQualifiedName())) { // skip identity assignments continue; } builder.append(format("%s := %s\\n", entry.getKey(), entry.getValue())); } printNode(node, "Project", builder.toString(), NODE_COLORS.get(NodeType.PROJECT)); return node.getSource().accept(this, context); }
public static Expression toPredicate(TupleDomain<Symbol> tupleDomain) { if (tupleDomain.isNone()) { return FALSE_LITERAL; } ImmutableList.Builder<Expression> conjunctBuilder = ImmutableList.builder(); for (Map.Entry<Symbol, Domain> entry : tupleDomain.getDomains().get().entrySet()) { Symbol symbol = entry.getKey(); QualifiedNameReference reference = new QualifiedNameReference(symbol.toQualifiedName()); conjunctBuilder.add(toPredicate(entry.getValue(), reference)); } return combineConjuncts(conjunctBuilder.build()); }
private static Expression equalsExpression(Symbol symbol1, Symbol symbol2) { return new ComparisonExpression(ComparisonExpression.Type.EQUAL, new QualifiedNameReference(symbol1.toQualifiedName()), new QualifiedNameReference(symbol2.toQualifiedName())); }
@Override public Void visitProject(ProjectNode node, Integer indent) { print(indent, "- Project => [%s]", formatOutputs(node.getOutputSymbols())); for (Map.Entry<Symbol, Expression> entry : node.getAssignments().entrySet()) { if (entry.getValue() instanceof QualifiedNameReference && ((QualifiedNameReference) entry.getValue()).getName().equals(entry.getKey().toQualifiedName())) { // skip identity assignments continue; } print(indent + 2, "%s := %s", entry.getKey(), entry.getValue()); } return processChildren(node, indent + 1); }
@Override public Expression rewriteQualifiedNameReference(QualifiedNameReference node, Void context, ExpressionTreeRewriter<Void> treeRewriter) { Symbol canonical = canonicalize(Symbol.fromQualifiedName(node.getName())); return new QualifiedNameReference(canonical.toQualifiedName()); } }, value);
private static QualifiedNameReference reference(Symbol symbol) { return new QualifiedNameReference(symbol.toQualifiedName()); }
private static Expression symbolExpr(Symbol symbol) { return new QualifiedNameReference(symbol.toQualifiedName()); }
private static Expression getHashFunctionCall(Expression previousHashValue, Symbol symbol) { FunctionCall functionCall = new FunctionCall(QualifiedName.of(HASH_CODE), Optional.<Window>empty(), false, ImmutableList.<Expression>of(new QualifiedNameReference(symbol.toQualifiedName()))); List<Expression> arguments = ImmutableList.of(previousHashValue, orNullHashCode(functionCall)); return new FunctionCall(QualifiedName.of("combine_hash"), arguments); }
private static Expression oneIfNull(Optional<Symbol> symbol) { if (symbol.isPresent()) { return new CoalesceExpression(new QualifiedNameReference(symbol.get().toQualifiedName()), new LongLiteral("1")); } else { return new LongLiteral("1"); } }
public Expression rewrite(FieldOrExpression fieldOrExpression) { if (fieldOrExpression.isFieldReference()) { int fieldIndex = fieldOrExpression.getFieldIndex(); Symbol symbol = fieldSymbols[fieldIndex]; checkState(symbol != null, "No mapping for field '%s'", fieldIndex); return new QualifiedNameReference(symbol.toQualifiedName()); } else { return rewrite(fieldOrExpression.getExpression()); } }
private PlanBuilder explicitCoercionSymbols(PlanBuilder subPlan, Iterable<Symbol> alreadyCoerced, Iterable<? extends Expression> uncoerced) { TranslationMap translations = copyTranslations(subPlan); ImmutableMap.Builder<Symbol, Expression> projections = ImmutableMap.builder(); projections.putAll(coerce(uncoerced, subPlan, translations)); for (Symbol symbol : alreadyCoerced) { projections.put(symbol, new QualifiedNameReference(symbol.toQualifiedName())); } return new PlanBuilder(translations, new ProjectNode(idAllocator.getNextId(), subPlan.getRoot(), projections.build()), subPlan.getSampleWeight()); }
/** * Evaluates an expression's response to binding the specified input symbols to NULL */ private Object nullInputEvaluator(final Collection<Symbol> nullSymbols, Expression expression) { IdentityHashMap<Expression, Type> expressionTypes = getExpressionTypes(session, metadata, sqlParser, symbolAllocator.getTypes(), expression); return ExpressionInterpreter.expressionOptimizer(expression, metadata, session, expressionTypes) .optimize(symbol -> nullSymbols.contains(symbol) ? null : new QualifiedNameReference(symbol.toQualifiedName())); }
private RelationPlan addConstantSampleWeight(RelationPlan subPlan) { ImmutableMap.Builder<Symbol, Expression> projections = ImmutableMap.builder(); for (Symbol symbol : subPlan.getOutputSymbols()) { Expression expression = new QualifiedNameReference(symbol.toQualifiedName()); projections.put(symbol, expression); } Expression one = new LongLiteral("1"); Symbol sampleWeightSymbol = symbolAllocator.newSymbol("$sampleWeight", BIGINT); projections.put(sampleWeightSymbol, one); ProjectNode projectNode = new ProjectNode(idAllocator.getNextId(), subPlan.getRoot(), projections.build()); return new RelationPlan(projectNode, subPlan.getDescriptor(), projectNode.getOutputSymbols(), Optional.of(sampleWeightSymbol)); }
public void put(FieldOrExpression fieldOrExpression, Symbol symbol) { if (fieldOrExpression.isFieldReference()) { int fieldIndex = fieldOrExpression.getFieldIndex(); fieldSymbols[fieldIndex] = symbol; expressionMappings.put(new QualifiedNameReference(rewriteBase.getSymbol(fieldIndex).toQualifiedName()), symbol); } else { put(fieldOrExpression.getExpression(), symbol); } }
@Override public Void visitIndexJoin(IndexJoinNode node, Integer indent) { List<Expression> joinExpressions = new ArrayList<>(); for (IndexJoinNode.EquiJoinClause clause : node.getCriteria()) { joinExpressions.add(new ComparisonExpression(ComparisonExpression.Type.EQUAL, new QualifiedNameReference(clause.getProbe().toQualifiedName()), new QualifiedNameReference(clause.getIndex().toQualifiedName()))); } print(indent, "- %sIndexJoin[%s] => [%s]", node.getType().getJoinLabel(), Joiner.on(" AND ").join(joinExpressions), formatOutputs(node.getOutputSymbols())); node.getProbeSource().accept(this, indent + 1); node.getIndexSource().accept(this, indent + 1); return null; }
private static QualifiedNameReference nameReference(String symbol) { return new QualifiedNameReference(new Symbol(symbol).toQualifiedName()); }