private List<Object> getSymbolValues(ValuesNode valuesNode, int symbolId, Session session, Type symbolType) { if (UNKNOWN.equals(symbolType)) { // special casing for UNKNOWN as evaluateConstantExpression does not handle that return IntStream.range(0, valuesNode.getRows().size()) .mapToObj(rowId -> null) .collect(toList()); } return valuesNode.getRows().stream() .map(row -> row.get(symbolId)) .map(expression -> evaluateConstantExpression(expression, symbolType, metadata, session, ImmutableList.of())) .collect(toList()); }
public static Object evaluateConstantExpression(Expression expression, Type expectedType, Metadata metadata, Session session, List<Expression> parameters) { ExpressionAnalyzer analyzer = createConstantAnalyzer(metadata, session, parameters, WarningCollector.NOOP); analyzer.analyze(expression, Scope.create()); Type actualType = analyzer.getExpressionTypes().get(NodeRef.of(expression)); if (!metadata.getTypeManager().canCoerce(actualType, expectedType)) { throw new SemanticException(SemanticErrorCode.TYPE_MISMATCH, expression, format("Cannot cast type %s to %s", actualType.getTypeSignature(), expectedType.getTypeSignature())); } Map<NodeRef<Expression>, Type> coercions = ImmutableMap.<NodeRef<Expression>, Type>builder() .putAll(analyzer.getExpressionCoercions()) .put(NodeRef.of(expression), expectedType) .build(); return evaluateConstantExpression(expression, coercions, analyzer.getTypeOnlyCoercions(), metadata, session, ImmutableSet.of(), parameters); }
private Object evaluatePropertyValue(Expression expression, Type expectedType, Session session, Metadata metadata, List<Expression> parameters) { Expression rewritten = ExpressionTreeRewriter.rewriteWith(new ParameterRewriter(parameters), expression); Object value = evaluateConstantExpression(rewritten, expectedType, metadata, session, parameters); // convert to object value type of SQL type BlockBuilder blockBuilder = expectedType.createBlockBuilder(null, 1); writeNativeValue(expectedType, blockBuilder, value); Object objectValue = expectedType.getObjectValue(session.toConnectorSession(), blockBuilder, 0); if (objectValue == null) { throw new PrestoException(propertyError, format("Invalid null value for %s property", propertyType)); } return objectValue; } }
public static Object evaluatePropertyValue(Expression expression, Type expectedType, Session session, Metadata metadata, List<Expression> parameters) { Expression rewritten = ExpressionTreeRewriter.rewriteWith(new ParameterRewriter(parameters), expression); Object value = evaluateConstantExpression(rewritten, expectedType, metadata, session, parameters); // convert to object value type of SQL type BlockBuilder blockBuilder = expectedType.createBlockBuilder(null, 1); writeNativeValue(expectedType, blockBuilder, value); Object objectValue = expectedType.getObjectValue(session.toConnectorSession(), blockBuilder, 0); if (objectValue == null) { throw new PrestoException(INVALID_SESSION_PROPERTY, "Session property value must not be null"); } return objectValue; }
checkCondition(type != null, INVALID_PROCEDURE_DEFINITION, "Unknown procedure argument type: %s", argument.getType()); Object value = evaluateConstantExpression(expression, type, metadata, session, parameters);
Iterator<Symbol> unnestedSymbolsIterator = unnestedSymbols.iterator(); for (Expression expression : node.getExpressions()) { Object constantValue = evaluateConstantExpression(expression, analysis.getCoercions(), metadata, session, analysis.getColumnReferences()); Type type = analysis.getType(expression); values.add(LiteralInterpreter.toExpression(constantValue, type));
public static Object evaluateConstantExpression(Expression expression, Type expectedType, Metadata metadata, Session session) { ExpressionAnalyzer analyzer = createConstantAnalyzer(metadata, session); analyzer.analyze(expression, new RelationType(), new AnalysisContext()); Type actualType = analyzer.getExpressionTypes().get(expression); if (!canCoerce(actualType, expectedType)) { throw new SemanticException(SemanticErrorCode.TYPE_MISMATCH, expression, String.format("Cannot cast type %s to %s", expectedType.getTypeSignature(), actualType.getTypeSignature())); } IdentityHashMap<Expression, Type> coercions = new IdentityHashMap<>(); coercions.putAll(analyzer.getExpressionCoercions()); coercions.put(expression, expectedType); return evaluateConstantExpression(expression, coercions, metadata, session, ImmutableSet.of()); }
@Override protected RelationPlan visitValues(Values node, Void context) { RelationType descriptor = analysis.getOutputDescriptor(node); ImmutableList.Builder<Symbol> outputSymbolsBuilder = ImmutableList.builder(); for (Field field : descriptor.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) { List<Expression> items = ((Row) row).getItems(); for (int i = 0; i < items.size(); i++) { Expression expression = items.get(i); Object constantValue = evaluateConstantExpression(expression, analysis.getCoercions(), metadata, session, analysis.getColumnReferences()); values.add(LiteralInterpreter.toExpression(constantValue, descriptor.getFieldByIndex(i).getType())); } } else { Object constantValue = evaluateConstantExpression(row, analysis.getCoercions(), metadata, session, analysis.getColumnReferences()); values.add(LiteralInterpreter.toExpression(constantValue, descriptor.getFieldByIndex(0).getType())); } rows.add(values.build()); } ValuesNode valuesNode = new ValuesNode(idAllocator.getNextId(), outputSymbolsBuilder.build(), rows.build()); return new RelationPlan(valuesNode, descriptor, outputSymbolsBuilder.build(), Optional.empty()); }
public static Object evaluatePropertyValue(Expression expression, Type expectedType, Session session, Metadata metadata) { Object value = evaluateConstantExpression(expression, expectedType, metadata, session); // convert to object value type of SQL type BlockBuilder blockBuilder = expectedType.createBlockBuilder(new BlockBuilderStatus(), 1); writeNativeValue(expectedType, blockBuilder, value); Object objectValue = expectedType.getObjectValue(session.toConnectorSession(), blockBuilder, 0); if (objectValue == null) { throw new PrestoException(INVALID_SESSION_PROPERTY, "Session property value must not be null"); } return objectValue; }
private static Object evaluatePropertyValue(Expression expression, Type expectedType, Session session, Metadata metadata) { Object value = evaluateConstantExpression(expression, expectedType, metadata, session); // convert to object value type of SQL type BlockBuilder blockBuilder = expectedType.createBlockBuilder(new BlockBuilderStatus(), 1); writeNativeValue(expectedType, blockBuilder, value); Object objectValue = expectedType.getObjectValue(session.toConnectorSession(), blockBuilder, 0); if (objectValue == null) { throw new PrestoException(INVALID_TABLE_PROPERTY, "Table property value cannot be null"); } return objectValue; } }
Type type = argument.getType(); Object value = evaluateConstantExpression(expression, type, metadata, session);