@Override protected Boolean visitSymbolReference(SymbolReference symbolReference, Void context) { return buildSymbols.contains(symbolReference.getName()); } }
@Override public Expression rewriteSymbolReference(SymbolReference node, Void context, ExpressionTreeRewriter<Void> treeRewriter) { if (excludedNames.contains(node.getName())) { return node; } Expression expression = mapping.apply(Symbol.from(node)); checkState(expression != null, "Cannot resolve symbol %s", node.getName()); return expression; }
private static Optional<SymbolReference> asBuildSymbolReference(Set<Symbol> buildLayout, Expression expression) { // Currently only we support only symbol as sort expression on build side if (expression instanceof SymbolReference) { SymbolReference symbolReference = (SymbolReference) expression; if (buildLayout.contains(new Symbol(symbolReference.getName()))) { return Optional.of(symbolReference); } } return Optional.empty(); }
public boolean isIdentity(Symbol output) { Expression expression = assignments.get(output); return expression instanceof SymbolReference && ((SymbolReference) expression).getName().equals(output.getName()); }
@Override protected String visitSymbolReference(SymbolReference node, Void context) { return formatIdentifier(node.getName()); }
public static Symbol from(Expression expression) { checkArgument(expression instanceof SymbolReference, "Unexpected expression: %s", expression); return new Symbol(((SymbolReference) expression).getName()); }
private void printAssignments(Assignments assignments, int indent) { for (Map.Entry<Symbol, Expression> entry : assignments.getMap().entrySet()) { if (entry.getValue() instanceof SymbolReference && ((SymbolReference) entry.getValue()).getName().equals(entry.getKey().getName())) { // skip identity assignments continue; } print(indent, "%s := %s", entry.getKey(), entry.getValue()); } }
public boolean isIdentity() { for (Map.Entry<Symbol, Expression> entry : assignments.entrySet()) { Expression expression = entry.getValue(); Symbol symbol = entry.getKey(); if (!(expression instanceof SymbolReference && ((SymbolReference) expression).getName().equals(symbol.getName()))) { return false; } } return true; }
@Override public Expression rewriteSymbolReference(SymbolReference node, Context context, ExpressionTreeRewriter<Context> treeRewriter) { context.getReferencedSymbols().add(new Symbol(node.getName())); return null; } }
@Override public Expression rewriteSymbolReference(SymbolReference node, Context context, ExpressionTreeRewriter<Context> treeRewriter) { Symbol symbol = Symbol.from(node); Integer channel = symbolToChannelMapping.get(symbol); if (channel == null) { checkArgument(context.isInLambda(), "Cannot resolve symbol %s", node.getName()); return node; } Type type = types.get(symbol); checkArgument(type != null, "Cannot resolve symbol %s", node.getName()); int parameter = fieldToParameter.computeIfAbsent(channel, field -> { inputChannels.add(field); inputTypes.add(type); return nextParameter++; }); return new FieldReference(parameter); }
@Override public Expression rewriteSymbolReference(SymbolReference node, Context context, ExpressionTreeRewriter<Context> treeRewriter) { Integer channel = symbolToChannelMapping.get(Symbol.from(node)); if (channel == null) { Preconditions.checkArgument(context.isInLambda(), "Cannot resolve symbol %s", node.getName()); return node; } return new FieldReference(channel); }
@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 SymbolReference) && ((SymbolReference) entry.getValue()).getName().equals(entry.getKey().getName())) { // 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); }
@Override protected RowExpression visitSymbolReference(SymbolReference node, Void context) { return new VariableReferenceExpression(node.getName(), getType(node)); }
static boolean matches(Collection<String> expectedAliases, Collection<Symbol> actualSymbols, SymbolAliases symbolAliases) { if (expectedAliases.size() != actualSymbols.size()) { return false; } List<Symbol> expectedSymbols = expectedAliases .stream() .map(alias -> new Symbol(symbolAliases.get(alias).getName())) .collect(toImmutableList()); for (Symbol symbol : expectedSymbols) { if (!actualSymbols.contains(symbol)) { return false; } } return true; }
public Symbol newSymbol(Expression expression, Type type, String suffix) { String nameHint = "expr"; if (expression instanceof Identifier) { nameHint = ((Identifier) expression).getValue(); } else if (expression instanceof FunctionCall) { nameHint = ((FunctionCall) expression).getName().getSuffix(); } else if (expression instanceof SymbolReference) { nameHint = ((SymbolReference) expression).getName(); } else if (expression instanceof GroupingOperation) { nameHint = "grouping"; } return newSymbol(nameHint, type, suffix); }
@Override protected Boolean visitSymbolReference(SymbolReference actual, Node expected) { if (!(expected instanceof SymbolReference)) { return false; } return symbolAliases.get(((SymbolReference) expected).getName()).equals(actual); }
@Override protected Type visitSymbolReference(SymbolReference node, StackableAstVisitorContext<Context> context) { if (context.getContext().isInLambda()) { Optional<ResolvedField> resolvedField = context.getContext().getScope().tryResolveField(node, QualifiedName.of(node.getName())); if (resolvedField.isPresent() && context.getContext().getFieldToLambdaArgumentDeclaration().containsKey(FieldId.from(resolvedField.get()))) { return setExpressionType(node, resolvedField.get().getType()); } } Type type = symbolTypes.get(Symbol.from(node)); return setExpressionType(node, type); }
@Override protected String visitSymbolReference(SymbolReference node, Void context) { return formatIdentifier(node.getName(), escape); }
@Override protected Void visitSymbolReference(SymbolReference node, Void context) { projectionExpressions.add(node); int idx = sourceLayout.size(); sourceLayout.put(new Symbol(node.getName().toString()), idx); int index = 0; for (int i = 0; i < columns.size(); i++) { Map.Entry<String, Type> entry = columns.get(i); if (entry.getKey().equals(node.getName())) { sourceTypes.put(index++, entry.getValue()); projectionProxies[idx] = i; break; } } return null; } }.process(filterExpression, null);
@Override protected String visitSymbolReference(SymbolReference node, Void context) { return formatIdentifier(node.getName()); }