Examples with Term io.confluent.ksql.execution.interpreter.terms.Term used on opensource projects

Example 11 with Term

use of io.confluent.ksql.execution.interpreter.terms.Term in project ksql by confluentinc.

the class TermCompiler method visitDereferenceExpression.

@Override
public Term visitDereferenceExpression(final DereferenceExpression node, final Context context) {
    final SqlType functionReturnSchema = expressionTypeManager.getExpressionSqlType(node, context.getLambdaSqlTypeMapping());
    final Term struct = process(node.getBase(), context);
    if (struct.getSqlType().baseType() != SqlBaseType.STRUCT) {
        throw new KsqlException("Can only dereference Struct type, instead got " + struct.getSqlType());
    }
    return new DereferenceTerm(struct, node.getFieldName(), functionReturnSchema);
}

Example 12 with Term

use of io.confluent.ksql.execution.interpreter.terms.Term in project ksql by confluentinc.

the class TermCompiler method visitArithmeticBinary.

@Override
public Term visitArithmeticBinary(final ArithmeticBinaryExpression node, final Context context) {
    final Term left = process(node.getLeft(), context);
    final Term right = process(node.getRight(), context);
    final SqlType schema = expressionTypeManager.getExpressionSqlType(node, context.getLambdaSqlTypeMapping());
    return ArithmeticInterpreter.doBinaryArithmetic(node.getOperator(), left, right, schema, ksqlConfig);
}

Example 13 with Term

use of io.confluent.ksql.execution.interpreter.terms.Term in project ksql by confluentinc.

the class TermCompiler method visitLambdaExpression.

@Override
public Term visitLambdaExpression(final LambdaFunctionCall lambdaFunctionCall, final Context context) {
    final Term lambdaBody = process(lambdaFunctionCall.getBody(), context);
    final ImmutableList.Builder<Pair<String, SqlType>> nameToType = ImmutableList.builder();
    for (final String lambdaArg : lambdaFunctionCall.getArguments()) {
        nameToType.add(Pair.of(lambdaArg, context.getLambdaSqlTypeMapping().get((lambdaArg))));
    }
    switch(lambdaFunctionCall.getArguments().size()) {
        case 1:
            return new LambdaFunction1Term(nameToType.build(), lambdaBody);
        case 2:
            return new LambdaFunction2Term(nameToType.build(), lambdaBody);
        case 3:
            return new LambdaFunction3Term(nameToType.build(), lambdaBody);
        default:
            throw new KsqlException("Interpreter only supports lambdas up to three arguments");
    }
}

Example 14 with Term

use of io.confluent.ksql.execution.interpreter.terms.Term in project ksql by confluentinc.

the class TermCompiler method visitSubscriptExpression.

@Override
public Term visitSubscriptExpression(final SubscriptExpression node, final Context context) {
    final SqlType internalSchema = expressionTypeManager.getExpressionSqlType(node.getBase(), context.getLambdaSqlTypeMapping());
    switch(internalSchema.baseType()) {
        case ARRAY:
            final SqlArray array = (SqlArray) internalSchema;
            final Term listTerm = process(node.getBase(), context);
            final Term indexTerm = process(node.getIndex(), context);
            return new SubscriptTerm(listTerm, indexTerm, (o, index) -> ArrayAccess.arrayAccess(((List<?>) o), (Integer) index), array.getItemType());
        case MAP:
            final SqlMap mapSchema = (SqlMap) internalSchema;
            final Term mapTerm = process(node.getBase(), context);
            final Term keyTerm = process(node.getIndex(), context);
            return new SubscriptTerm(mapTerm, keyTerm, (map, key) -> ((Map<?, ?>) map).get(key), mapSchema.getValueType());
        default:
            throw new UnsupportedOperationException();
    }
}

Example 15 with Term

use of io.confluent.ksql.execution.interpreter.terms.Term in project ksql by confluentinc.

the class TermCompiler method visitInPredicate.

@Override
public Term visitInPredicate(final InPredicate inPredicate, final Context context) {
    final InPredicate preprocessed = InListEvaluator.preprocess(inPredicate, expressionTypeManager, context.getLambdaSqlTypeMapping());
    final Term value = process(preprocessed.getValue(), context);
    final List<Term> valueList = preprocessed.getValueList().getValues().stream().map(v -> process(v, context)).collect(ImmutableList.toImmutableList());
    return new InPredicateTerm(value, valueList);
}