Examples with Scalar io.crate.metadata.Scalar used on opensource projects

Example 6 with Scalar

use of io.crate.metadata.Scalar in project crate by crate.

the class BaseImplementationSymbolVisitor method visitFunction.

@Override
public Input<?> visitFunction(Function function, C context) {
    Signature signature = function.signature();
    FunctionImplementation functionImplementation = nodeCtx.functions().getQualified(function, txnCtx.sessionSettings().searchPath());
    assert functionImplementation != null : "Function implementation not found using full qualified lookup";
    if (functionImplementation instanceof Scalar<?, ?>) {
        List<Symbol> arguments = function.arguments();
        Scalar<?, ?> scalarImpl = ((Scalar) functionImplementation).compile(arguments);
        Input[] argumentInputs = new Input[arguments.size()];
        int i = 0;
        for (Symbol argument : function.arguments()) {
            argumentInputs[i++] = argument.accept(this, context);
        }
        return new FunctionExpression<>(txnCtx, nodeCtx, scalarImpl, argumentInputs);
    } else {
        throw new UnsupportedFeatureException(String.format(Locale.ENGLISH, "Function %s(%s) is not a scalar function.", signature.getName(), Lists2.joinOn(", ", function.arguments(), x -> x.valueType().getName())));
    }
}

Example 7 with Scalar

use of io.crate.metadata.Scalar in project crate by crate.

the class TruncFunction method createTruncWithMode.

private static Scalar<Number, Number> createTruncWithMode(Signature signature, Signature boundSignature) {
    return new Scalar<>() {

        @Override
        public Signature signature() {
            return signature;
        }

        @Override
        public Signature boundSignature() {
            return boundSignature;
        }

        @Override
        public Number evaluate(TransactionContext txnCtx, NodeContext nodeCtx, Input<Number>... args) {
            Number n = args[0].value();
            Number nd = args[1].value();
            if (null == n || null == nd) {
                return null;
            }
            double val = n.doubleValue();
            int numDecimals = nd.intValue();
            RoundingMode mode = val >= 0 ? RoundingMode.FLOOR : RoundingMode.CEILING;
            return BigDecimal.valueOf(val).setScale(numDecimals, mode).doubleValue();
        }
    };
}

Example 8 with Scalar

use of io.crate.metadata.Scalar in project crate by crate.

the class DocSchemaInfoTest method setup.

@Before
public void setup() throws Exception {
    nodeCtx = createNodeContext();
    udfService = new UserDefinedFunctionService(clusterService, nodeCtx);
    udfService.registerLanguage(new UDFLanguage() {

        @Override
        public Scalar createFunctionImplementation(UserDefinedFunctionMetadata metadata, Signature signature) throws ScriptException {
            String error = validate(metadata);
            if (error != null) {
                throw new ScriptException("this is not Burlesque");
            }
            return new Scalar<>() {

                @Override
                public Object evaluate(TransactionContext txnCtx, NodeContext nodeCtx, Input[] args) {
                    return null;
                }

                @Override
                public Signature signature() {
                    return signature;
                }

                @Override
                public Signature boundSignature() {
                    return signature;
                }
            };
        }

        @Override
        @Nullable
        public String validate(UserDefinedFunctionMetadata metadata) {
            if (!metadata.definition().equals("\"Hello, World!\"Q")) {
                return "this is not Burlesque";
            }
            return null;
        }

        @Override
        public String name() {
            return "burlesque";
        }
    });
    docSchemaInfo = new DocSchemaInfo("doc", clusterService, nodeCtx, udfService, (ident, state) -> null, new TestingDocTableInfoFactory(Map.of()));
}

Example 9 with Scalar

use of io.crate.metadata.Scalar in project crate by crate.

the class ScalarTestCase method assertNormalize.

public void assertNormalize(String functionExpression, Matcher<? super Symbol> expectedSymbol, boolean evaluate) {
    // Explicit normalization happens further below
    sqlExpressions.context().allowEagerNormalize(false);
    Symbol functionSymbol = sqlExpressions.asSymbol(functionExpression);
    if (functionSymbol instanceof Literal) {
        assertThat(functionSymbol, expectedSymbol);
        return;
    }
    Function function = (Function) functionSymbol;
    FunctionImplementation impl = sqlExpressions.nodeCtx.functions().getQualified(function, txnCtx.sessionSettings().searchPath());
    assertThat("Function implementation not found using full qualified lookup", impl, Matchers.notNullValue());
    Symbol normalized = sqlExpressions.normalize(function);
    assertThat(String.format(Locale.ENGLISH, "expected <%s> to normalize to %s", functionExpression, expectedSymbol), normalized, expectedSymbol);
    if (evaluate && normalized instanceof Input && allArgsAreInputs(function.arguments())) {
        Input[] inputs = new Input[function.arguments().size()];
        for (int i = 0; i < inputs.length; i++) {
            inputs[i] = ((Input) function.arguments().get(i));
        }
        Object expectedValue = ((Input) normalized).value();
        assertThat(((Scalar) impl).evaluate(txnCtx, null, inputs), is(expectedValue));
        assertThat(((Scalar) impl).compile(function.arguments()).evaluate(txnCtx, sqlExpressions.nodeCtx, inputs), is(expectedValue));
    }
}

Example 10 with Scalar

use of io.crate.metadata.Scalar in project crate by crate.

the class ScalarTestCase method assertCompile.

public void assertCompile(String functionExpression, java.util.function.Function<Scalar, Matcher<Scalar>> matcher) {
    Symbol functionSymbol = sqlExpressions.asSymbol(functionExpression);
    functionSymbol = sqlExpressions.normalize(functionSymbol);
    assertThat("function expression was normalized, compile would not be hit", functionSymbol, not(instanceOf(Literal.class)));
    Function function = (Function) functionSymbol;
    Scalar scalar = (Scalar) sqlExpressions.nodeCtx.functions().getQualified(function, txnCtx.sessionSettings().searchPath());
    assertThat("Function implementation not found using full qualified lookup", scalar, Matchers.notNullValue());
    Scalar compiled = scalar.compile(function.arguments());
    assertThat(compiled, matcher.apply(scalar));
}