public IncompatibleTypeException(SourceLocation sourceLoc, FunctionIdentifier fid, ATypeTag typeTagLeft, ATypeTag typeTagRight) { super(ErrorCode.COMPILATION_TYPE_INCOMPATIBLE, sourceLoc, fid.getName(), typeTagLeft, typeTagRight); }
public static String getSimFunction(FunctionIdentifier simFuncId) { if (simFuncId.equals(BuiltinFunctions.SIMILARITY_JACCARD) || simFuncId.equals(BuiltinFunctions.SIMILARITY_JACCARD_CHECK)) { return JACCARD_FUNCTION_NAME; } else if (simFuncId.equals(BuiltinFunctions.EDIT_DISTANCE) || simFuncId.equals(BuiltinFunctions.EDIT_DISTANCE_CHECK)) { return EDIT_DISTANCE_FUNCTION_NAME; } return null; } }
public FunctionInfo(String namespace, String name, int arity, boolean isFunctional) { this(new FunctionIdentifier(namespace, name, arity), isFunctional); }
@Override public String toString() { return this.functionIdentifier.getNamespace() + ":" + this.functionIdentifier.getName() + "@" + this.functionIdentifier.getArity(); }
public StorageComponentsDatasource(INodeDomain domain, int datasetId) throws AlgebricksException { super(new DataSourceId(StorageComponentsRewriter.STORAGE_COMPONENTS.getNamespace(), StorageComponentsRewriter.STORAGE_COMPONENTS.getName()), domain); this.datasetId = datasetId; }
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); }
@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 static List<List<List<String>>> getFunctionDependencies(IQueryRewriter rewriter, Expression expression, MetadataProvider metadataProvider) throws CompilationException { Set<CallExpr> functionCalls = rewriter.getFunctionCalls(expression); //Get the List of used functions and used datasets List<List<String>> datasourceDependencies = new ArrayList<>(); List<List<String>> functionDependencies = new ArrayList<>(); for (CallExpr functionCall : functionCalls) { FunctionSignature signature = functionCall.getFunctionSignature(); FunctionIdentifier fid = new FunctionIdentifier(signature.getNamespace(), signature.getName(), signature.getArity()); if (fid.equals(BuiltinFunctions.DATASET)) { Pair<String, String> path = DatasetUtil.getDatasetInfo(metadataProvider, ((LiteralExpr) functionCall.getExprList().get(0)).getValue().getStringValue()); datasourceDependencies.add(Arrays.asList(path.first, path.second)); } else if (BuiltinFunctions.isBuiltinCompilerFunction(signature, false)) { continue; } else { functionDependencies.add(Arrays.asList(signature.getNamespace(), signature.getName(), Integer.toString(signature.getArity()))); } } List<List<List<String>>> dependencies = new ArrayList<>(); dependencies.add(datasourceDependencies); dependencies.add(functionDependencies); return dependencies; }
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 String toString() { return getNamespace() + ":" + name; }
public FunctionSignature(FunctionIdentifier fi) { this(fi.getNamespace(), fi.getName(), fi.getArity()); }
public DatasetResourcesDatasource(INodeDomain domain, int datasetId) throws AlgebricksException { super(new DataSourceId(DatasetResourcesRewriter.DATASET_RESOURCES.getNamespace(), DatasetResourcesRewriter.DATASET_RESOURCES.getName()), domain); this.datasetId = datasetId; }
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());
@Override public boolean equals(Object o) { if (super.equals(o)) { return true; } if (o instanceof FunctionIdentifier) { FunctionIdentifier ofi = (FunctionIdentifier) o; return ofi.getNamespace().equals(getNamespace()) && ofi.name.equals(name); } return false; }
public OverflowException(SourceLocation sourceLoc, FunctionIdentifier fid) { super(ErrorCode.OVERFLOW, sourceLoc, fid.getName()); } }
@Override protected boolean processArgumentsToFunction(FunctionIdentifier fi) { return fi.equals(BuiltinFunctions.GET_ITEM); }
public IFunctionInfo get(FunctionIdentifier fid) { return get(fid.getNamespace(), fid.getName(), fid.getArity()); }
public ExternalFunction(IExternalFunctionInfo finfo, IScalarEvaluatorFactory args[], IHyracksTaskContext context, IApplicationContext appCtx) throws HyracksDataException { this.finfo = finfo; this.evaluatorFactories = args; argumentEvaluators = new IScalarEvaluator[args.length]; for (int i = 0; i < args.length; i++) { argumentEvaluators[i] = args[i].createScalarEvaluator(context); } ILibraryManager libraryManager = appCtx.getLibraryManager(); String[] fnameComponents = finfo.getFunctionIdentifier().getName().split("#"); String functionLibary = fnameComponents[0]; String dataverse = finfo.getFunctionIdentifier().getNamespace(); functionHelper = new JavaFunctionHelper(finfo, resultBuffer, libraryManager.getFunctionParameters(dataverse, finfo.getFunctionIdentifier().getName())); ClassLoader libraryClassLoader = libraryManager.getLibraryClassLoader(dataverse, functionLibary); String classname = finfo.getFunctionBody().trim(); Class<?> clazz; try { clazz = Class.forName(classname, true, libraryClassLoader); externalFunctionFactory = (IFunctionFactory) clazz.newInstance(); externalFunction = externalFunctionFactory.getExternalFunction(); } catch (Exception e) { throw new RuntimeDataException(ErrorCode.LIBRARY_EXTERNAL_FUNCTION_UNABLE_TO_LOAD_CLASS, e, classname); } }
public Function(QName qname, Signature signature) { this.fid = new FunctionIdentifier(VXQUERY, "{" + qname.getNamespaceURI() + "}" + qname.getLocalPart()); this.qname = qname; this.signature = signature; this.documentOrderPropagationPolicy = new DocumentOrderYESPropagationPolicy(); this.uniqueNodesPropagationPolicy = new UniqueNodesYESPropagationPolicy(); }