@Override protected String visitRow(Row node, Void context) { return "ROW (" + Joiner.on(", ").join(node.getItems().stream() .map((child) -> process(child, context)) .collect(toList())) + ")"; }
@Override protected R visitRow(Row node, C context) { for (Expression expression : node.getItems()) { process(expression, context); } return null; }
@Override public Boolean visitRow(Row node, final Void context) { return node.getItems().stream() .allMatch(item -> process(item, context)); }
@Override protected Void visitRow(Row node, Integer indent) { builder.append("ROW("); boolean firstItem = true; for (Expression item : node.getItems()) { if (!firstItem) { builder.append(", "); } process(item, indent); firstItem = false; } builder.append(")"); return null; }
@Override protected RowExpression visitRow(Row node, Void context) { List<RowExpression> arguments = node.getItems().stream() .map(value -> process(value, context)) .collect(toImmutableList()); Type returnType = getType(node); List<Type> argumentTypes = node.getItems().stream() .map(this::getType) .collect(toImmutableList()); return call(rowConstructorSignature(returnType, argumentTypes), returnType, arguments); } }
@Override protected Type visitRow(Row node, StackableAstVisitorContext<Context> context) { List<Type> types = node.getItems().stream() .map((child) -> process(child, context)) .collect(toImmutableList()); Type type = RowType.anonymous(types); return setExpressionType(node, type); }
@Override protected RelationPlan visitValues(Values node, Void context) { Scope scope = analysis.getScope(node); ImmutableList.Builder<Symbol> outputSymbolsBuilder = ImmutableList.builder(); for (Field field : scope.getRelationType().getVisibleFields()) { Symbol symbol = symbolAllocator.newSymbol(field); outputSymbolsBuilder.add(symbol); } ImmutableList.Builder<List<Expression>> rows = ImmutableList.builder(); for (Expression row : node.getRows()) { ImmutableList.Builder<Expression> values = ImmutableList.builder(); if (row instanceof Row) { for (Expression item : ((Row) row).getItems()) { Expression expression = Coercer.addCoercions(item, analysis); values.add(ExpressionTreeRewriter.rewriteWith(new ParameterRewriter(analysis.getParameters(), analysis), expression)); } } else { Expression expression = Coercer.addCoercions(row, analysis); values.add(ExpressionTreeRewriter.rewriteWith(new ParameterRewriter(analysis.getParameters(), analysis), expression)); } rows.add(values.build()); } ValuesNode valuesNode = new ValuesNode(idAllocator.getNextId(), outputSymbolsBuilder.build(), rows.build()); return new RelationPlan(valuesNode, scope, outputSymbolsBuilder.build()); }
List<Expression> items = ((Row) row).getItems(); for (int i = 0; i < items.size(); i++) { Type expectedType = fieldTypes.get(i);
@Override protected Object visitRow(Row node, Object context) { RowType rowType = (RowType) type(node); List<Type> parameterTypes = rowType.getTypeParameters(); List<Expression> arguments = node.getItems(); int cardinality = arguments.size(); List<Object> values = new ArrayList<>(cardinality); for (Expression argument : arguments) { values.add(process(argument, context)); } if (hasUnresolvedValue(values)) { return new Row(toExpressions(values, parameterTypes)); } else { BlockBuilder blockBuilder = new RowBlockBuilder(parameterTypes, null, 1); BlockBuilder singleRowBlockWriter = blockBuilder.beginBlockEntry(); for (int i = 0; i < cardinality; ++i) { writeNativeValue(parameterTypes.get(i), singleRowBlockWriter, values.get(i)); } blockBuilder.closeEntry(); return rowType.getObject(blockBuilder, 0); } }
@Override protected String visitRow(Row node, Void context) { return "ROW (" + Joiner.on(", ").join(node.getItems().stream() .map((child) -> process(child, context)) .collect(toList())) + ")"; }
@Override protected Void visitRow(Row node, Integer indent) { builder.append("ROW("); boolean firstItem = true; for (Expression item : node.getItems()) { if (!firstItem) { builder.append(", "); } process(item, indent); firstItem = false; } builder.append(")"); return null; }
@Override protected R visitRow(Row node, C context) { for (Expression expression : node.getItems()) { process(expression, context); } return null; }
@Override protected String visitRow(Row node, Void context) { return "ROW (" + Joiner.on(", ").join(node.getItems().stream() .map((child) -> process(child, context)) .collect(toList())) + ")"; }
@Override public Boolean visitRow(Row node, final Void context) { return node.getItems().stream() .allMatch(item -> process(item, context)); }
@Override protected R visitRow(Row node, C context) { for (Expression expression : node.getItems()) { process(expression, context); } return null; }
@Override protected String visitRow(Row node, Boolean unmangleNames) { return "ROW (" + Joiner.on(", ").join(node.getItems().stream() .map((child) -> process(child, unmangleNames)) .collect(toList())) + ")"; }
@Override protected String visitRow(Row node, Boolean unmangleNames) { return "ROW (" + Joiner.on(", ").join(node.getItems().stream() .map((child) -> process(child, unmangleNames)) .collect(toList())) + ")"; }
@Override protected Void visitRow(Row node, Integer indent) { builder.append("ROW("); boolean firstItem = true; for (Expression item : node.getItems()) { if (!firstItem) { builder.append(", "); } process(item, indent); firstItem = false; } builder.append(")"); return null; }
@Override protected Type visitRow(Row node, StackableAstVisitorContext<AnalysisContext> context) { List<Type> types = node.getItems().stream() .map((child) -> process(child, context)) .collect(toImmutableList()); Type type = new RowType(types, Optional.empty()); expressionTypes.put(node, type); return type; }
/** * Parses the list with values to insert and returns them as Objects */ @Override public List<Object> visitValues(Values values, QueryState state){ List<Object> result = new ArrayList<Object>(); for(Expression rowExpression : values.getRows()){ if(rowExpression instanceof Row) { Row row = (Row)rowExpression; for(Expression rowValue : row.getItems()){ if(!(rowValue instanceof Literal)) { state.addException("Unable to parse non-literal value : "+rowValue); return result; } result.add(getObject((Literal)rowValue)); } }else if (rowExpression instanceof Literal){ result.add(getObject((Literal)rowExpression)); }else { state.addException("Unknown VALUES type "+rowExpression.getClass()+" encountered"); return null; } } return result; }