Examples with TypeQLMatch com.vaticle.typeql.lang.query.TypeQLMatch used on opensource projects

Example 6 with TypeQLMatch

use of com.vaticle.typeql.lang.query.TypeQLMatch in project grakn by graknlabs.

the class TypeQLSteps method each_answer_does_not_satisfy.

@Then("each answer does not satisfy")
public void each_answer_does_not_satisfy(String templatedTypeQLQuery) {
    String templatedQuery = String.join("\n", templatedTypeQLQuery);
    for (ConceptMap answer : answers) {
        String queryString = applyQueryTemplate(templatedQuery, answer);
        TypeQLMatch query = TypeQL.parseQuery(queryString).asMatch();
        long answerSize = tx().query().match(query).toList().size();
        assertEquals(0, answerSize);
    }
}

Example 7 with TypeQLMatch

use of com.vaticle.typeql.lang.query.TypeQLMatch in project grakn by graknlabs.

the class TypeQLSteps method templated_typeql_match_throws_exception.

@Then("templated typeql match; throws exception")
public void templated_typeql_match_throws_exception(String templatedTypeQLQuery) {
    String templatedQuery = String.join("\n", templatedTypeQLQuery);
    for (ConceptMap answer : answers) {
        String queryString = applyQueryTemplate(templatedQuery, answer);
        assertThrows(() -> {
            TypeQLMatch query = TypeQL.parseQuery(queryString).asMatch();
            tx().query().match(query).toList();
        });
    }
}

Example 8 with TypeQLMatch

use of com.vaticle.typeql.lang.query.TypeQLMatch in project grakn by graknlabs.

the class TypeQLSteps method typeql_match.

@When("get answers of typeql match")
public void typeql_match(String typeQLQueryStatements) {
    try {
        TypeQLMatch typeQLQuery = TypeQL.parseQuery(String.join("\n", typeQLQueryStatements)).asMatch();
        clearAnswers();
        answers = tx().query().match(typeQLQuery).toList();
    } catch (TypeQLException e) {
        // NOTE: We manually close transaction here, because we want to align with all non-java clients,
        // where parsing happens at server-side which closes transaction if they fail
        tx().close();
        throw e;
    }
}

Example 9 with TypeQLMatch

use of com.vaticle.typeql.lang.query.TypeQLMatch in project grakn by graknlabs.

the class TypeQLSteps method each_answer_satisfies.

/* private void checkExplanationEntry(List<ConceptMap> answers, Map<Integer, Map<String, String>> explanationTree, Integer entryId) {
        Map<String, String> explanationEntry = explanationTree.get(entryId);
        String[] vars = explanationEntry.get("vars").split(", ");
        String[] identifiers = explanationEntry.get("identifiers").split(", ");
        String[] children = explanationEntry.get("children").split(", ");

        if (vars.length != identifiers.length) {
            throw new ScenarioDefinitionException(String.format("vars and identifiers do not correspond for explanation entry %d. Found %d vars and %s identifiers", entryId, vars.length, identifiers.length));
        }

        Map<String, String> answerIdentifiers = IntStream.range(0, vars.length).boxed().collect(Collectors.toMap(i -> vars[i], i -> identifiers[i]));

        Optional<ConceptMap> matchingAnswer = answers.stream().filter(answer -> matchAnswer(answerIdentifiers, answer)).findFirst();

        assertTrue(String.format("No answer found for explanation entry %d that satisfies the vars and identifiers given", entryId), matchingAnswer.isPresent());
        ConceptMap answer = matchingAnswer.get();

        String queryWithIds = applyQueryTemplate(explanationEntry.get("pattern"), answer);
        Conjunction<?> queryWithIdsConj = TypeQL.and(TypeQL.parsePatternList(queryWithIds));
        assertEquals(
                String.format("Explanation entry %d has an incorrect pattern.\nExpected: %s\nActual: %s", entryId, queryWithIdsConj, answer.queryPattern()),
                queryWithIdsConj, answer.queryPattern()
        );

        String expectedRule = explanationEntry.get("rule");
        boolean hasExplanation = answer.hasExplanation();

        if (expectedRule.equals("lookup")) {

            assertFalse(String.format("Explanation entry %d is declared as a lookup, but an explanation was found", entryId), hasExplanation);

            String[] expectedChildren = {"-"};
            assertArrayEquals(String.format("Explanation entry %d is declared as a lookup, and so it should have no children, indicated as \"-\", but got children %s instead", entryId, Arrays.toString(children)), expectedChildren, children);
        } else {

            Explanation explanation = answer.explanation();
            List<ConceptMap> explAnswers = explanation.getAnswers();

            assertEquals(String.format("Explanation entry %d should have as many children as it has answers. Instead, %d children were declared, and %d answers were found.", entryId, children.length, explAnswers.size()), children.length, explAnswers.size());

            if (expectedRule.equals("join")) {
                assertNull(String.format("Explanation entry %d is declared as a join, and should not have a rule attached, but one was found", entryId), explanation.getRule());
            } else {
                // rule
                Rule.Remote rule = explanation.getRule();
                String ruleLabel = rule.getLabel();
                assertEquals(String.format("Incorrect rule label for explanation entry %d with rule %s.\nExpected: %s\nActual: %s", entryId, ruleLabel, expectedRule, ruleLabel), expectedRule, ruleLabel);

                Map<String, String> expectedRuleDefinition = rules.get(expectedRule);
                String when = Objects.requireNonNull(rule.getWhen()).toString();
                assertEquals(String.format("Incorrect rule body (when) for explanation entry %d with rule %s.\nExpected: %s\nActual: %s", entryId, ruleLabel, expectedRuleDefinition.get("when"), when), expectedRuleDefinition.get("when"), when);

                String then = Objects.requireNonNull(rule.getThen()).toString();
                assertEquals(String.format("Incorrect rule head (then) for explanation entry %d with rule %s.\nExpected: %s\nActual: %s", entryId, ruleLabel, expectedRuleDefinition.get("then"), then), expectedRuleDefinition.get("then"), then);
            }
            for (String child : children) {
                // Recurse
                checkExplanationEntry(explAnswers, explanationTree, Integer.valueOf(child));
            }
        }
    } */
@Then("each answer satisfies")
public void each_answer_satisfies(String templatedTypeQLQuery) {
    String templatedQuery = String.join("\n", templatedTypeQLQuery);
    for (ConceptMap answer : answers) {
        String query = applyQueryTemplate(templatedQuery, answer);
        TypeQLMatch typeQLQuery = TypeQL.parseQuery(query).asMatch();
        long answerSize = tx().query().match(typeQLQuery).toList().size();
        assertEquals(1, answerSize);
    }
}

Example 10 with TypeQLMatch

use of com.vaticle.typeql.lang.query.TypeQLMatch in project grakn by graknlabs.

the class QueryService method match.

private void match(String queryStr, Options.Query options, UUID reqID) {
    TypeQLMatch query = TypeQL.parseQuery(queryStr).asMatch();
    Context.Query context = new Context.Query(transactionSvc.context(), options.query(query), query);
    FunctionalIterator<ConceptMap> answers = queryMgr.match(query, context);
    transactionSvc.stream(answers, reqID, context.options(), a -> matchResPart(reqID, a));
}