Examples with Name org.neo4j.procedure.Name used on opensource projects

Example 1 with Name

use of org.neo4j.procedure.Name in project neo4j by neo4j.

the class MethodSignatureCompiler method signatureFor.

public List<FieldSignature> signatureFor(Method method) throws ProcedureException {
    Parameter[] params = method.getParameters();
    Type[] types = method.getGenericParameterTypes();
    List<FieldSignature> signature = new ArrayList<>(params.length);
    boolean seenDefault = false;
    for (int i = 0; i < params.length; i++) {
        Parameter param = params[i];
        Type type = types[i];
        if (!param.isAnnotationPresent(Name.class)) {
            throw new ProcedureException(Status.Procedure.ProcedureRegistrationFailed, "Argument at position %d in method `%s` is missing an `@%s` annotation.%n" + "Please add the annotation, recompile the class and try again.", i, method.getName(), Name.class.getSimpleName());
        }
        Name parameter = param.getAnnotation(Name.class);
        String name = parameter.value();
        if (name.trim().length() == 0) {
            throw new ProcedureException(Status.Procedure.ProcedureRegistrationFailed, "Argument at position %d in method `%s` is annotated with a name,%n" + "but the name is empty, please provide a non-empty name for the argument.", i, method.getName());
        }
        try {
            NeoValueConverter valueConverter = typeMappers.converterFor(type);
            Optional<Neo4jValue> defaultValue = valueConverter.defaultValue(parameter);
            //it is not allowed to have holes in default values
            if (seenDefault && !defaultValue.isPresent()) {
                throw new ProcedureException(Status.Procedure.ProcedureRegistrationFailed, "Non-default argument at position %d with name %s in method %s follows default argument. " + "Add a default value or rearrange arguments so that the non-default values comes first.", i, parameter.value(), method.getName());
            }
            seenDefault = defaultValue.isPresent();
            signature.add(new FieldSignature(name, valueConverter.type(), defaultValue));
        } catch (ProcedureException e) {
            throw new ProcedureException(e.status(), "Argument `%s` at position %d in `%s` with%n" + "type `%s` cannot be converted to a Neo4j type: %s", name, i, method.getName(), param.getType().getSimpleName(), e.getMessage());
        }
    }
    return signature;
}

Example 2 with Name

use of org.neo4j.procedure.Name in project neo4j by neo4j.

the class BuiltInProcedures method listConstraints.

@Description("List all constraints in the database.")
@Procedure(name = "db.constraints", mode = READ)
public Stream<ConstraintResult> listConstraints() {
    Statement statement = tx.acquireStatement();
    ReadOperations operations = statement.readOperations();
    TokenNameLookup tokens = new StatementTokenNameLookup(operations);
    return asList(operations.constraintsGetAll()).stream().map((constraint) -> constraint.prettyPrint(tokens)).sorted().map(ConstraintResult::new).onClose(statement::close);
}

Example 3 with Name

use of org.neo4j.procedure.Name in project neo4j-apoc-procedures by neo4j-contrib.

the class Grouping method group.

@Procedure
@Description("Group all nodes and their relationships by given keys, create virtual nodes and relationships for the summary information, you can provide an aggregations map [{kids:'sum',age:['min','max','avg'],gender:'collect'},{`*`,'count'}]")
public Stream<GraphResult> group(@Name("labels") List<String> labels, @Name("groupByProperties") List<String> groupByProperties, @Name(value = "aggregations", defaultValue = "[{\"*\":\"count\"},{\"*\":\"count\"}]") List<Map<String, Object>> aggregations) {
    String[] keys = groupByProperties.toArray(new String[groupByProperties.size()]);
    Map<String, List<String>> nodeAggNames = (aggregations.size() > 0) ? toStringListMap(aggregations.get(0)) : emptyMap();
    String[] nodeAggKeys = keyArray(nodeAggNames, ASTERISK);
    Map<String, List<String>> relAggNames = (aggregations.size() > 1) ? toStringListMap(aggregations.get(1)) : emptyMap();
    String[] relAggKeys = keyArray(relAggNames, ASTERISK);
    Map<NodeKey, Set<Node>> grouped = new ConcurrentHashMap<>();
    Map<NodeKey, Node> virtualNodes = new ConcurrentHashMap<>();
    Map<RelKey, Relationship> virtualRels = new ConcurrentHashMap<>();
    List<Future> futures = new ArrayList<>(1000);
    ExecutorService pool = Pools.DEFAULT;
    for (String labelName : labels) {
        Label label = Label.label(labelName);
        Label[] singleLabel = { label };
        try (ResourceIterator<Node> nodes = (labelName.equals(ASTERISK)) ? db.getAllNodes().iterator() : db.findNodes(label)) {
            while (nodes.hasNext()) {
                List<Node> batch = Util.take(nodes, BATCHSIZE);
                futures.add(Util.inTxFuture(pool, db, () -> {
                    try {
                        for (Node node : batch) {
                            NodeKey key = keyFor(node, labelName, keys);
                            grouped.compute(key, (k, v) -> {
                                if (v == null)
                                    v = new HashSet<>();
                                v.add(node);
                                return v;
                            });
                            virtualNodes.compute(key, (k, v) -> {
                                if (v == null) {
                                    v = new VirtualNode(singleLabel, propertiesFor(node, keys), db);
                                }
                                Node vn = v;
                                if (!nodeAggNames.isEmpty()) {
                                    aggregate(vn, nodeAggNames, nodeAggKeys.length > 0 ? node.getProperties(nodeAggKeys) : Collections.emptyMap());
                                }
                                return vn;
                            });
                        }
                    } catch (Exception e) {
                        log.debug("Error grouping nodes", e);
                    }
                    return null;
                }));
                Util.removeFinished(futures);
            }
        }
    }
    Util.waitForFutures(futures);
    futures.clear();
    Iterator<Map.Entry<NodeKey, Set<Node>>> entries = grouped.entrySet().iterator();
    int size = 0;
    List<Map.Entry<NodeKey, Set<Node>>> batch = new ArrayList<>();
    while (entries.hasNext()) {
        Map.Entry<NodeKey, Set<Node>> outerEntry = entries.next();
        batch.add(outerEntry);
        size += outerEntry.getValue().size();
        if (size > BATCHSIZE || !entries.hasNext()) {
            ArrayList<Map.Entry<NodeKey, Set<Node>>> submitted = new ArrayList<>(batch);
            batch.clear();
            size = 0;
            futures.add(Util.inTxFuture(pool, db, () -> {
                try {
                    for (Map.Entry<NodeKey, Set<Node>> entry : submitted) {
                        for (Node node : entry.getValue()) {
                            NodeKey startKey = entry.getKey();
                            Node v1 = virtualNodes.get(startKey);
                            for (Relationship rel : node.getRelationships(Direction.OUTGOING)) {
                                Node endNode = rel.getEndNode();
                                for (NodeKey endKey : keysFor(endNode, labels, keys)) {
                                    Node v2 = virtualNodes.get(endKey);
                                    if (v2 == null)
                                        continue;
                                    virtualRels.compute(new RelKey(startKey, endKey, rel), (rk, vRel) -> {
                                        if (vRel == null)
                                            vRel = v1.createRelationshipTo(v2, rel.getType());
                                        if (!relAggNames.isEmpty()) {
                                            aggregate(vRel, relAggNames, relAggKeys.length > 0 ? rel.getProperties(relAggKeys) : Collections.emptyMap());
                                        }
                                        return vRel;
                                    });
                                }
                            }
                        }
                    }
                } catch (Exception e) {
                    log.debug("Error grouping relationships", e);
                }
                return null;
            }));
            Util.removeFinished(futures);
        }
    }
    Util.waitForFutures(futures);
    return fixAggregates(virtualNodes.values()).stream().map(n -> new GraphResult(singletonList(n), fixAggregates(Iterables.asList(n.getRelationships()))));
}

Example 4 with Name

use of org.neo4j.procedure.Name in project neo4j by neo4j.

the class BuiltInDbmsProcedures method listConfig.

@Admin
@SystemProcedure
@Description("List the currently active config of Neo4j.")
@Procedure(name = "dbms.listConfig", mode = DBMS)
public Stream<ConfigResult> listConfig(@Name(value = "searchString", defaultValue = "") String searchString) {
    String lowerCasedSearchString = searchString.toLowerCase();
    List<ConfigResult> results = new ArrayList<>();
    Config config = graph.getDependencyResolver().resolveDependency(Config.class);
    config.getValues().forEach((setting, value) -> {
        if (!setting.internal() && setting.name().toLowerCase().contains(lowerCasedSearchString)) {
            results.add(new ConfigResult(setting, value));
        }
    });
    return results.stream().sorted(Comparator.comparing(c -> c.name));
}

Example 5 with Name

use of org.neo4j.procedure.Name in project neo4j by neo4j.

the class BuiltInProcedures method listRelationshipTypes.

@SystemProcedure
@Description("List all available relationship types in the database.")
@Procedure(name = "db.relationshipTypes", mode = READ)
public Stream<RelationshipTypeResult> listRelationshipTypes() {
    if (callContext.isSystemDatabase()) {
        return Stream.empty();
    }
    AccessMode mode = kernelTransaction.securityContext().mode();
    TokenRead tokenRead = kernelTransaction.tokenRead();
    List<RelationshipTypeResult> relTypesInUse;
    try (KernelTransaction.Revertable ignore = kernelTransaction.overrideWith(SecurityContext.AUTH_DISABLED)) {
        // Get all relTypes that are in use as seen by a super user
        relTypesInUse = stream(RELATIONSHIP_TYPES.inUse(kernelTransaction)).filter(type -> mode.allowsTraverseRelType(tokenRead.relationshipType(type.name()))).map(RelationshipTypeResult::new).collect(Collectors.toList());
    }
    return relTypesInUse.stream();
}