@Override public String toString() { return this.functionIdentifier.getNamespace() + ":" + this.functionIdentifier.getName() + "@" + this.functionIdentifier.getArity(); }
public FunctionSignature(FunctionIdentifier fi) { this(fi.getNamespace(), fi.getName(), fi.getArity()); }
public FunctionManager(FunctionCollection functionCollection) { Map<Pair<FunctionIdentifier, Integer>, IFunctionDescriptorFactory> functionsMap = new HashMap<>(); Map<FunctionIdentifier, IFunctionTypeInferer> typeInferersMap = new HashMap<>(); for (IFunctionDescriptorFactory descriptorFactory : functionCollection.getFunctionDescriptorFactories()) { FunctionIdentifier fid = descriptorFactory.createFunctionDescriptor().getIdentifier(); functionsMap.put(new Pair<>(fid, fid.getArity()), descriptorFactory); IFunctionTypeInferer typeInferer = descriptorFactory.createFunctionTypeInferer(); if (typeInferer != null) { typeInferersMap.put(fid, typeInferer); } } this.functions = functionsMap; this.typeInferers = typeInferersMap; }
@Override public IFunctionDescriptor lookupFunction(FunctionIdentifier fid) throws AlgebricksException { Pair<FunctionIdentifier, Integer> key = new Pair<>(fid, fid.getArity()); IFunctionDescriptorFactory factory = functions.get(key); if (factory == null) { throw new AlgebricksException("Inappropriate use of function " + "'" + fid.getName() + "'"); } return factory.createFunctionDescriptor(); }
public IFunctionInfo get(FunctionIdentifier fid) { return get(fid.getNamespace(), fid.getName(), fid.getArity()); }
throws AlgebricksException { AbstractFunctionCallExpression f = (AbstractFunctionCallExpression) expression; if (f.getArguments().size() != BuiltinFunctions.FEED_COLLECT.getArity()) { throw new AlgebricksException("Incorrect number of arguments -> arity is " + BuiltinFunctions.FEED_COLLECT.getArity() + ", not " + f.getArguments().size());
private static IFunctionInfo getScalarFunctionInfo(MetadataTransactionContext txnCtx, Function function) throws AlgebricksException { FunctionIdentifier fid = new FunctionIdentifier(function.getDataverseName(), function.getName(), function.getArity()); IResultTypeComputer typeComputer = getResultTypeComputer(txnCtx, function); List<IAType> arguments = new ArrayList<>(); IAType returnType; List<String> argumentTypes = function.getArguments(); for (String argumentType : argumentTypes) { arguments.add(getTypeInfo(argumentType, txnCtx, function)); } returnType = getTypeInfo(function.getReturnType(), txnCtx, function); return new ExternalScalarFunctionInfo(fid.getNamespace(), fid.getName(), fid.getArity(), returnType, function.getFunctionBody(), function.getLanguage(), arguments, typeComputer); }
private void testFunction(IFunctionDescriptorFactory funcFactory) throws Exception { AbstractScalarFunctionDynamicDescriptor funcDesc = (AbstractScalarFunctionDynamicDescriptor) funcFactory.createFunctionDescriptor(); int inputArity = funcDesc.getIdentifier().getArity(); Iterator<IScalarEvaluatorFactory[]> argEvalFactoryIterator = getArgCombinations(inputArity); while (argEvalFactoryIterator.hasNext()) {
AbstractFunctionCallExpression f = UnnestToDataScanRule.getFunctionCall(opRef); List<Mutable<ILogicalExpression>> args = f.getArguments(); if (args.size() != functionId.getArity()) { throw new CompilationException(ErrorCode.COMPILATION_ERROR, f.getSourceLocation(), "Function " + functionId.getNamespace() + "." + functionId.getName() + " expects " + functionId.getArity() + " arguments");
private void testFunction(IFunctionDescriptorFactory funcFactory) throws Exception { IFunctionDescriptor functionDescriptor = funcFactory.createFunctionDescriptor(); if (!(functionDescriptor instanceof AbstractScalarFunctionDynamicDescriptor)) { return; } AbstractScalarFunctionDynamicDescriptor funcDesc = (AbstractScalarFunctionDynamicDescriptor) functionDescriptor; int inputArity = funcDesc.getIdentifier().getArity(); Iterator<IScalarEvaluatorFactory[]> argEvalFactoryIterator = getArgCombinations(inputArity); int index = 0; while (argEvalFactoryIterator.hasNext()) { IScalarEvaluatorFactory evalFactory = funcDesc.createEvaluatorFactory(argEvalFactoryIterator.next()); IHyracksTaskContext ctx = mock(IHyracksTaskContext.class); IScalarEvaluator evaluator = evalFactory.createScalarEvaluator(ctx); IPointable resultPointable = new VoidPointable(); evaluator.evaluate(null, resultPointable); if (index != 0) { Assert.assertTrue(resultPointable.getByteArray()[resultPointable .getStartOffset()] == ATypeTag.SERIALIZED_MISSING_TYPE_TAG); } else { Assert.assertTrue(resultPointable.getByteArray()[resultPointable .getStartOffset()] == ATypeTag.SERIALIZED_NULL_TYPE_TAG); } ++index; } }