Examples with Direction nl.knaw.huygens.timbuctoo.v5.datastores.quadstore.dto.Direction used on opensource projects

Example 6 with Direction

use of nl.knaw.huygens.timbuctoo.v5.datastores.quadstore.dto.Direction in project timbuctoo by HuygensING.

the class BdbSchemaStore method onChangedSubject.

@Override
public void onChangedSubject(String subject, ChangeFetcher changeFetcher) {
    // Step 1: Get the types that where added, unchanged, removed
    List<Type> addedTypes = new ArrayList<>();
    List<Type> removedTypes = new ArrayList<>();
    List<Type> unchangedTypes = new ArrayList<>();
    try (Stream<CursorQuad> subjTypes = changeFetcher.getPredicates(subject, RDF_TYPE, OUT, true, true, true)) {
        subjTypes.forEach(type -> {
            boolean hadTypesBefore = false;
            final Type typeOfSubject = types.computeIfAbsent(type.getObject(), TYPE_MAKER);
            if (type.getChangeType() == ChangeType.ASSERTED) {
                typeOfSubject.registerSubject(1);
                addedTypes.add(typeOfSubject);
            } else if (type.getChangeType() == ChangeType.RETRACTED) {
                hadTypesBefore = true;
                typeOfSubject.registerSubject(-1);
                removedTypes.add(typeOfSubject);
            } else if (type.getChangeType() == ChangeType.UNCHANGED) {
                hadTypesBefore = true;
                unchangedTypes.add(typeOfSubject);
            }
            if (!hadTypesBefore) {
                try (Stream<CursorQuad> predicates = changeFetcher.getPredicates(subject, true, true, false)) {
                    boolean subjectIsNew = !predicates.findAny().isPresent();
                    if (!subjectIsNew) {
                        final Type unknown = types.computeIfAbsent(UNKNOWN, TYPE_MAKER);
                        removedTypes.add(unknown);
                        unknown.registerSubject(-1);
                    }
                }
            }
        });
    }
    if (addedTypes.isEmpty() && unchangedTypes.isEmpty()) {
        // subject currently has no types
        if (removedTypes.isEmpty()) {
            // subject had no types either
            try (Stream<CursorQuad> predicates = changeFetcher.getPredicates(subject, true, true, false)) {
                boolean subjectIsNew = !predicates.findAny().isPresent();
                if (subjectIsNew) {
                    final Type unknown = types.computeIfAbsent(UNKNOWN, TYPE_MAKER);
                    addedTypes.add(unknown);
                    unknown.registerSubject(1);
                } else {
                    unchangedTypes.add(types.computeIfAbsent(UNKNOWN, TYPE_MAKER));
                }
            }
        } else {
            // subject has become unknown
            final Type unknown = types.computeIfAbsent(UNKNOWN, TYPE_MAKER);
            addedTypes.add(unknown);
            unknown.registerSubject(1);
        }
    }
    // it it was asserted -> add it to the unchanged types and to the added types
    try (Stream<CursorQuad> predicates = changeFetcher.getPredicates(subject, true, true, true)) {
        String prevPred = "";
        Direction[] prevDir = new Direction[] { null };
        int retractedCount = 0;
        int assertedCount = 0;
        int unchangedCount = 0;
        // updatePredicateOccurrence)
        for (CursorQuad quad : (Iterable<CursorQuad>) predicates::iterator) {
            boolean predicateSameAsPrev = prevPred.equals(quad.getPredicate()) && prevDir[0] == quad.getDirection();
            if (!predicateSameAsPrev) {
                updatePredicateOccurrence(addedTypes, removedTypes, unchangedTypes, retractedCount, unchangedCount, assertedCount, prevPred, prevDir[0]);
                prevPred = quad.getPredicate();
                prevDir[0] = quad.getDirection();
                retractedCount = 0;
                assertedCount = 0;
                unchangedCount = 0;
            }
            if (quad.getChangeType() == ChangeType.RETRACTED) {
                retractedCount++;
            } else if (quad.getChangeType() == ChangeType.UNCHANGED) {
                unchangedCount++;
            } else if (quad.getChangeType() == ChangeType.ASSERTED) {
                assertedCount++;
            }
            if (quad.getDirection() != Direction.IN) {
                if (quad.getChangeType() == ChangeType.RETRACTED) {
                    for (Type type : unchangedTypes) {
                        updatePredicateType(type, quad, false, changeFetcher);
                    }
                    for (Type type : removedTypes) {
                        updatePredicateType(type, quad, false, changeFetcher);
                    }
                } else if (quad.getChangeType() == ChangeType.UNCHANGED) {
                    for (Type type : removedTypes) {
                        updatePredicateType(type, quad, false, changeFetcher);
                    }
                    for (Type type : addedTypes) {
                        updatePredicateType(type, quad, true, changeFetcher);
                    }
                } else if (quad.getChangeType() == ChangeType.ASSERTED) {
                    for (Type type : unchangedTypes) {
                        updatePredicateType(type, quad, true, changeFetcher);
                    }
                    for (Type type : addedTypes) {
                        updatePredicateType(type, quad, true, changeFetcher);
                    }
                }
            }
        }
        updatePredicateOccurrence(addedTypes, removedTypes, unchangedTypes, retractedCount, unchangedCount, assertedCount, prevPred, prevDir[0]);
    }
}

Example 7 with Direction

use of nl.knaw.huygens.timbuctoo.v5.datastores.quadstore.dto.Direction in project timbuctoo by HuygensING.

the class PredicateMutationRdfPatcher method sendQuads.

@Override
public void sendQuads(RdfPatchSerializer saver, Consumer<String> importStatusConsumer, DataSet dataSet) throws LogStorageFailedException {
    final QuadStore quadStore = dataSet.getQuadStore();
    final Map<String, String> foundSubjects = new HashMap<>();
    for (Map.Entry<UUID, PredicateMutation.SubjectFinder> entry : mutation.getSubjectFinders().entrySet()) {
        foundSubjects.put(entry.getKey().toString(), entry.getValue().getSubject(quadStore));
    }
    for (CursorQuad newValue : mutation.getFullRetractions()) {
        final String subject = foundSubjects.getOrDefault(newValue.getSubject(), newValue.getSubject());
        final String predicate = newValue.getPredicate();
        final Direction direction = newValue.getDirection();
        try (Stream<CursorQuad> quads = quadStore.getQuads(subject, predicate, direction, "")) {
            for (CursorQuad oldValue : (Iterable<CursorQuad>) quads::iterator) {
                saver.delQuad(oldValue.getSubject(), oldValue.getPredicate(), oldValue.getObject(), oldValue.getValuetype().orElse(null), oldValue.getLanguage().orElse(null), null);
            }
        }
    }
    for (CursorQuad oldValue : mutation.getRetractions()) {
        saver.delQuad(foundSubjects.getOrDefault(oldValue.getSubject(), oldValue.getSubject()), oldValue.getPredicate(), foundSubjects.getOrDefault(oldValue.getObject(), oldValue.getObject()), oldValue.getValuetype().orElse(null), oldValue.getLanguage().orElse(null), null);
    }
    for (CursorQuad newValue : mutation.getAdditions()) {
        if (newValue.getObject() != null) {
            saver.onQuad(foundSubjects.getOrDefault(newValue.getSubject(), newValue.getSubject()), newValue.getPredicate(), foundSubjects.getOrDefault(newValue.getObject(), newValue.getObject()), newValue.getValuetype().orElse(null), newValue.getLanguage().orElse(null), null);
        }
    }
}

Example 8 with Direction

use of nl.knaw.huygens.timbuctoo.v5.datastores.quadstore.dto.Direction in project timbuctoo by HuygensING.

the class StoreUpdater method deleteQuad.

private void deleteQuad(String subject, String predicate, Direction direction, String object, String valueType, String language) throws RdfProcessingFailedException {
    try {
        final boolean wasChanged = tripleStore.deleteQuad(subject, predicate, direction, object, valueType, language);
        if (wasChanged && currentversion >= 0) {
            truePatchStore.put(subject, currentversion, predicate, direction, false, object, valueType, language);
            updatedPerPatchStore.put(currentversion, subject);
        }
    } catch (DatabaseWriteException e) {
        throw new RdfProcessingFailedException(e);
    }
}

Example 9 with Direction

use of nl.knaw.huygens.timbuctoo.v5.datastores.quadstore.dto.Direction in project timbuctoo by HuygensING.

the class StoreUpdater method putQuad.

private void putQuad(String subject, String predicate, Direction direction, String object, String valueType, String language) throws RdfProcessingFailedException {
    try {
        final boolean wasChanged = tripleStore.putQuad(subject, predicate, direction, object, valueType, language);
        if (wasChanged && currentversion >= 0) {
            truePatchStore.put(subject, currentversion, predicate, direction, true, object, valueType, language);
            updatedPerPatchStore.put(currentversion, subject);
        }
    } catch (DatabaseWriteException e) {
        throw new RdfProcessingFailedException(e);
    }
}

Example 10 with Direction

use of nl.knaw.huygens.timbuctoo.v5.datastores.quadstore.dto.Direction in project timbuctoo by HuygensING.

the class SerializerExecutionStrategy method execute.

@Override
public CompletableFuture<ExecutionResult> execute(ExecutionContext executionContext, ExecutionStrategyParameters parameters) throws NonNullableFieldWasNullException {
    Map<String, java.util.List<Field>> fields = parameters.fields();
    GraphQLObjectType parentType = parameters.typeInfo().castType(GraphQLObjectType.class);
    return super.execute(executionContext, parameters).thenApply(sourceResult -> {
        Map<String, Object> data = sourceResult.getData();
        if (parameters.source() instanceof TypedValue) {
            String value = ((TypedValue) parameters.source()).getValue();
            String typename = ((TypedValue) parameters.source()).getType();
            Value result;
            if (value == null) {
                result = null;
            } else if (data.containsKey("__typename")) {
                result = Value.create(value, typename, (String) data.get("__typename"));
            } else {
                result = Value.create(value, typename);
            }
            return new ExecutionResultImpl(result, sourceResult.getErrors(), sourceResult.getExtensions());
        } else if (parameters.source() instanceof SubjectReference) {
            final String uri = ((SubjectReference) parameters.source()).getSubjectUri();
            final Set<String> types = ((SubjectReference) parameters.source()).getTypes();
            final String graphqlType = getDirectiveArgument(parentType, "rdfType", "uri").orElse(null);
            String type;
            if (graphqlType != null && types.contains(graphqlType)) {
                type = graphqlType;
            } else {
                Optional<String> firstType = types.stream().sorted().findFirst();
                if (firstType.isPresent()) {
                    type = firstType.get();
                } else {
                    LOG.error("No type present on " + uri + ". Expected at least TIM_UNKNOWN");
                    type = RdfConstants.UNKNOWN;
                }
            }
            LinkedHashMap<PredicateInfo, Serializable> copy = new LinkedHashMap<>();
            for (Map.Entry<String, Object> entry : data.entrySet()) {
                final String graphqlFieldName = entry.getKey();
                final GraphQLFieldDefinition fieldDesc = parentType.getFieldDefinition(entry.getKey());
                Optional<String> predicateUri = getDirectiveArgument(fieldDesc, "rdf", "predicate");
                Optional<Direction> direction = getDirectiveArgument(fieldDesc, "rdf", "direction").map(Direction::valueOf);
                final PredicateInfo predicateInfo;
                predicateInfo = predicateUri.map(predUri -> PredicateInfo.predicateInfo(graphqlFieldName, predUri, direction.orElse(Direction.OUT))).orElseGet(() -> PredicateInfo.predicateInfo(graphqlFieldName, null, Direction.OUT));
                if (entry.getValue() == null || entry.getValue() instanceof Serializable) {
                    copy.put(predicateInfo, (Serializable) entry.getValue());
                } else {
                    copy.put(predicateInfo, Value.fromRawJavaType(entry.getValue()));
                }
            }
            return new ExecutionResultImpl(Entity.entity(uri, type, copy), sourceResult.getErrors(), sourceResult.getExtensions());
        } else if (parameters.source() instanceof PaginatedList) {
            PaginatedList<? extends DatabaseResult> source = (PaginatedList) parameters.source();
            return new ExecutionResultImpl(serializableList(source.getPrevCursor().orElse(null), source.getNextCursor().orElse(null), ((GraphqlIntrospectionList) data.get("items")).getItems()), sourceResult.getErrors(), sourceResult.getExtensions());
        } else if (executionContext.getGraphQLSchema().getQueryType() == parentType) {
            return new ExecutionResultImpl(QueryContainer.queryContainer(sourceResult.getData()), sourceResult.getErrors(), sourceResult.getExtensions());
        } else {
            LinkedHashMap<String, Serializable> copy = new LinkedHashMap<>();
            for (Map.Entry<String, Object> entry : data.entrySet()) {
                if (entry.getValue() == null || entry.getValue() instanceof Serializable) {
                    copy.put(entry.getKey(), (Serializable) entry.getValue());
                } else {
                    copy.put(entry.getKey(), GraphqlIntrospectionValue.fromRawJavaType(entry.getValue()));
                }
            }
            return new ExecutionResultImpl(graphqlIntrospectionObject(copy), sourceResult.getErrors(), sourceResult.getExtensions());
        }
    });
}