Examples with ConnectorExpression io.trino.spi.expression.ConnectorExpression used on opensource projects

Example 21 with ConnectorExpression

use of io.trino.spi.expression.ConnectorExpression in project trino by trinodb.

the class TestConnectorExpressionTranslator method assertTranslationFromConnectorExpression.

private void assertTranslationFromConnectorExpression(Session session, ConnectorExpression connectorExpression, Expression expected) {
    Expression translation = ConnectorExpressionTranslator.translate(session, connectorExpression, PLANNER_CONTEXT, variableMappings, LITERAL_ENCODER);
    assertEquals(translation, expected);
}

Example 22 with ConnectorExpression

use of io.trino.spi.expression.ConnectorExpression in project trino by trinodb.

the class AggregateFunctionRewriter method rewrite.

public Optional<AggregationResult> rewrite(ConnectorSession session, AggregateFunction aggregateFunction, Map<String, ColumnHandle> assignments) {
    requireNonNull(aggregateFunction, "aggregateFunction is null");
    requireNonNull(assignments, "assignments is null");
    RewriteContext<ExpressionResult> context = new RewriteContext<>() {

        @Override
        public Map<String, ColumnHandle> getAssignments() {
            return assignments;
        }

        @Override
        public ConnectorSession getSession() {
            return session;
        }

        @Override
        public Optional<ExpressionResult> rewriteExpression(ConnectorExpression expression) {
            return connectorExpressionRewriter.rewrite(session, expression, assignments);
        }
    };
    for (AggregateFunctionRule<AggregationResult, ExpressionResult> rule : rules) {
        Iterator<Match> matches = rule.getPattern().match(aggregateFunction, context).iterator();
        while (matches.hasNext()) {
            Match match = matches.next();
            Optional<AggregationResult> rewritten = rule.rewrite(aggregateFunction, match.captures(), context);
            if (rewritten.isPresent()) {
                return rewritten;
            }
        }
    }
    return Optional.empty();
}

Example 23 with ConnectorExpression

use of io.trino.spi.expression.ConnectorExpression in project trino by trinodb.

the class PartialTranslator method extractPartialTranslations.

/**
 * Produces {@link ConnectorExpression} translations for disjoint components in the {@param inputExpression} in a
 * top-down manner. i.e. if an expression node is translatable, we do not consider its children.
 */
public static Map<NodeRef<Expression>, ConnectorExpression> extractPartialTranslations(Expression inputExpression, Session session, TypeAnalyzer typeAnalyzer, TypeProvider typeProvider, PlannerContext plannerContext) {
    requireNonNull(inputExpression, "inputExpression is null");
    requireNonNull(session, "session is null");
    requireNonNull(typeAnalyzer, "typeAnalyzer is null");
    requireNonNull(typeProvider, "typeProvider is null");
    Map<NodeRef<Expression>, ConnectorExpression> partialTranslations = new HashMap<>();
    new Visitor(session, typeAnalyzer.getTypes(session, typeProvider, inputExpression), partialTranslations, plannerContext).process(inputExpression);
    return ImmutableMap.copyOf(partialTranslations);
}

Example 24 with ConnectorExpression

use of io.trino.spi.expression.ConnectorExpression in project trino by trinodb.

the class HiveMetadata method applyProjection.

@Override
public Optional<ProjectionApplicationResult<ConnectorTableHandle>> applyProjection(ConnectorSession session, ConnectorTableHandle handle, List<ConnectorExpression> projections, Map<String, ColumnHandle> assignments) {
    if (!isProjectionPushdownEnabled(session)) {
        return Optional.empty();
    }
    // Create projected column representations for supported sub expressions. Simple column references and chain of
    // dereferences on a variable are supported right now.
    Set<ConnectorExpression> projectedExpressions = projections.stream().flatMap(expression -> extractSupportedProjectedColumns(expression).stream()).collect(toImmutableSet());
    Map<ConnectorExpression, ProjectedColumnRepresentation> columnProjections = projectedExpressions.stream().collect(toImmutableMap(Function.identity(), HiveApplyProjectionUtil::createProjectedColumnRepresentation));
    HiveTableHandle hiveTableHandle = (HiveTableHandle) handle;
    // all references are simple variables
    if (columnProjections.values().stream().allMatch(ProjectedColumnRepresentation::isVariable)) {
        Set<ColumnHandle> projectedColumns = ImmutableSet.copyOf(assignments.values());
        if (hiveTableHandle.getProjectedColumns().equals(projectedColumns)) {
            return Optional.empty();
        }
        List<Assignment> assignmentsList = assignments.entrySet().stream().map(assignment -> new Assignment(assignment.getKey(), assignment.getValue(), ((HiveColumnHandle) assignment.getValue()).getType())).collect(toImmutableList());
        return Optional.of(new ProjectionApplicationResult<>(hiveTableHandle.withProjectedColumns(projectedColumns), projections, assignmentsList, false));
    }
    Map<String, Assignment> newAssignments = new HashMap<>();
    ImmutableMap.Builder<ConnectorExpression, Variable> newVariablesBuilder = ImmutableMap.builder();
    ImmutableSet.Builder<ColumnHandle> projectedColumnsBuilder = ImmutableSet.builder();
    for (Map.Entry<ConnectorExpression, ProjectedColumnRepresentation> entry : columnProjections.entrySet()) {
        ConnectorExpression expression = entry.getKey();
        ProjectedColumnRepresentation projectedColumn = entry.getValue();
        ColumnHandle projectedColumnHandle;
        String projectedColumnName;
        // See if input already contains a columnhandle for this projected column, avoid creating duplicates.
        Optional<String> existingColumn = find(assignments, projectedColumn);
        if (existingColumn.isPresent()) {
            projectedColumnName = existingColumn.get();
            projectedColumnHandle = assignments.get(projectedColumnName);
        } else {
            // Create a new column handle
            HiveColumnHandle oldColumnHandle = (HiveColumnHandle) assignments.get(projectedColumn.getVariable().getName());
            projectedColumnHandle = createProjectedColumnHandle(oldColumnHandle, projectedColumn.getDereferenceIndices());
            projectedColumnName = ((HiveColumnHandle) projectedColumnHandle).getName();
        }
        Variable projectedColumnVariable = new Variable(projectedColumnName, expression.getType());
        Assignment newAssignment = new Assignment(projectedColumnName, projectedColumnHandle, expression.getType());
        newAssignments.put(projectedColumnName, newAssignment);
        newVariablesBuilder.put(expression, projectedColumnVariable);
        projectedColumnsBuilder.add(projectedColumnHandle);
    }
    // Modify projections to refer to new variables
    Map<ConnectorExpression, Variable> newVariables = newVariablesBuilder.buildOrThrow();
    List<ConnectorExpression> newProjections = projections.stream().map(expression -> replaceWithNewVariables(expression, newVariables)).collect(toImmutableList());
    List<Assignment> outputAssignments = newAssignments.values().stream().collect(toImmutableList());
    return Optional.of(new ProjectionApplicationResult<>(hiveTableHandle.withProjectedColumns(projectedColumnsBuilder.build()), newProjections, outputAssignments, false));
}

Example 25 with ConnectorExpression

use of io.trino.spi.expression.ConnectorExpression in project trino by trinodb.

the class TestMySqlClient method testImplementSum.

@Test
public void testImplementSum() {
    Variable bigintVariable = new Variable("v_bigint", BIGINT);
    Variable doubleVariable = new Variable("v_double", DOUBLE);
    Optional<ConnectorExpression> filter = Optional.of(new Variable("a_filter", BOOLEAN));
    // sum(bigint)
    testImplementAggregation(new AggregateFunction("sum", BIGINT, List.of(bigintVariable), List.of(), false, Optional.empty()), Map.of(bigintVariable.getName(), BIGINT_COLUMN), Optional.of("sum(`c_bigint`)"));
    // sum(double)
    testImplementAggregation(new AggregateFunction("sum", DOUBLE, List.of(doubleVariable), List.of(), false, Optional.empty()), Map.of(doubleVariable.getName(), DOUBLE_COLUMN), Optional.of("sum(`c_double`)"));
    // sum(DISTINCT bigint)
    testImplementAggregation(new AggregateFunction("sum", BIGINT, List.of(bigintVariable), List.of(), true, Optional.empty()), Map.of(bigintVariable.getName(), BIGINT_COLUMN), // distinct not supported
    Optional.empty());
    // sum(bigint) FILTER (WHERE ...)
    testImplementAggregation(new AggregateFunction("sum", BIGINT, List.of(bigintVariable), List.of(), false, filter), Map.of(bigintVariable.getName(), BIGINT_COLUMN), // filter not supported
    Optional.empty());
}