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

Example 6 with TypeQLDefine

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

the class TraversalTest method test_closure_backtrack_clears_scopes.

@Test
public void test_closure_backtrack_clears_scopes() {
    session = databaseMgr.session(database, Arguments.Session.Type.SCHEMA);
    try (TypeDB.Transaction transaction = session.transaction(WRITE)) {
        TypeQLDefine query = TypeQL.parseQuery("define " + "lastname sub attribute, value string; " + "person sub entity, owns lastname; ");
        transaction.query().define(query);
        transaction.commit();
    }
    session.close();
    session = databaseMgr.session(database, Arguments.Session.Type.DATA);
    try (TypeDB.Transaction transaction = session.transaction(WRITE)) {
        TypeQLInsert query = TypeQL.parseQuery("insert " + "$x isa person," + "  has lastname \"Smith\"," + "  has name \"Alex\";" + "$y isa person," + "  has lastname \"Smith\"," + "  has name \"John\";" + "$r (friend: $x, friend: $y) isa friendship, has ref 1;" + "$r1 (friend: $x, friend: $y) isa friendship, has ref 2;" + "$reflexive (friend: $x, friend: $x) isa friendship, has ref 3;").asInsert();
        transaction.query().insert(query);
        transaction.commit();
    }
    try (CoreTransaction transaction = session.transaction(READ)) {
        GraphProcedure.Builder proc = GraphProcedure.builder(10);
        /*
            vertices:
            $_0 [thing] { hasIID: false, types: [name], predicates: [= <STRING>] } (end) // Alex
            $_1 [thing] { hasIID: false, types: [name], predicates: [= <STRING>] } (end) // John
            $f1 [thing] { hasIID: false, types: [friendship], predicates: [] }
            $n [thing] { hasIID: false, types: [lastname], predicates: [] } (start)
            $r1 [thing] { hasIID: false, types: [ref], predicates: [= <LONG>] } (end) // 3
            $r2 [thing] { hasIID: false, types: [ref], predicates: [= <LONG>] } (end) // 1
            $refl [thing] { hasIID: false, types: [friendship], predicates: [] }
            $x [thing] { hasIID: false, types: [person], predicates: [] }
            $y [thing] { hasIID: false, types: [person], predicates: [] }

             */
        ProcedureVertex.Thing _0 = proc.anonymousThing(0);
        _0.props().predicate(Predicate.Value.String.of(TypeQLToken.Predicate.Equality.EQ));
        _0.props().types(set(Label.of("name")));
        ProcedureVertex.Thing _1 = proc.anonymousThing(1);
        _1.props().predicate(Predicate.Value.String.of(TypeQLToken.Predicate.Equality.EQ));
        _1.props().types(set(Label.of("name")));
        ProcedureVertex.Thing f1 = proc.namedThing("f1");
        f1.props().types(set(Label.of("friendship")));
        ProcedureVertex.Thing refl = proc.namedThing("refl");
        refl.props().types(set(Label.of("friendship")));
        ProcedureVertex.Thing n = proc.namedThing("n", true);
        n.props().types(set(Label.of("lastname")));
        ProcedureVertex.Thing r1 = proc.namedThing("r1");
        r1.props().predicate(Predicate.Value.Numerical.of(TypeQLToken.Predicate.Equality.EQ, PredicateArgument.Value.LONG));
        r1.props().types(set(Label.of("ref")));
        ProcedureVertex.Thing r2 = proc.namedThing("r2");
        r2.props().predicate(Predicate.Value.Numerical.of(TypeQLToken.Predicate.Equality.EQ, PredicateArgument.Value.LONG));
        r2.props().types(set(Label.of("ref")));
        ProcedureVertex.Thing x = proc.namedThing("x");
        x.props().types(set(Label.of("person")));
        ProcedureVertex.Thing y = proc.namedThing("y");
        y.props().types(set(Label.of("person")));
        GraphTraversal.Thing.Parameters params = new GraphTraversal.Thing.Parameters();
        params.pushValue(_0.id().asVariable(), Predicate.Value.String.of(TypeQLToken.Predicate.Equality.EQ), new GraphTraversal.Thing.Parameters.Value("Alex"));
        params.pushValue(_1.id().asVariable(), Predicate.Value.String.of(TypeQLToken.Predicate.Equality.EQ), new GraphTraversal.Thing.Parameters.Value("John"));
        params.pushValue(r1.id().asVariable(), Predicate.Value.Numerical.of(TypeQLToken.Predicate.Equality.EQ, PredicateArgument.Value.LONG), new GraphTraversal.Thing.Parameters.Value(3L));
        params.pushValue(r2.id().asVariable(), Predicate.Value.Numerical.of(TypeQLToken.Predicate.Equality.EQ, PredicateArgument.Value.LONG), new GraphTraversal.Thing.Parameters.Value(1L));
        /*
            edges:
            1: ($n <--[HAS]--* $x)
            2: ($n <--[HAS]--* $y)
            3: ($x *--[HAS]--> $_0)
            4: ($x <--[ROLEPLAYER]--* $refl) { roleTypes: [friendship:friend] }
            5: ($x <--[ROLEPLAYER]--* $refl) { roleTypes: [friendship:friend] }
            6: ($x <--[ROLEPLAYER]--* $f1) { roleTypes: [friendship:friend] }
            7: ($y *--[HAS]--> $_1)
            8: ($y <--[ROLEPLAYER]--* $f1) { roleTypes: [friendship:friend] }
            9: ($refl *--[HAS]--> $r1)
            10: ($f1 *--[HAS]--> $r2)
             */
        proc.backwardHas(1, n, x);
        proc.backwardHas(2, n, y);
        proc.forwardHas(3, x, _0);
        proc.backwardRolePlayer(4, x, refl, set(Label.of("friend", "friendship")));
        proc.backwardRolePlayer(5, x, refl, set(Label.of("friend", "friendship")));
        proc.backwardRolePlayer(6, x, f1, set(Label.of("friend", "friendship")));
        proc.forwardHas(7, y, _1);
        proc.backwardRolePlayer(8, y, f1, set(Label.of("friend", "friendship")));
        proc.forwardHas(9, refl, r1);
        proc.forwardHas(10, f1, r2);
        Set<Identifier.Variable.Retrievable> filter = set(n.id().asVariable().asRetrievable(), x.id().asVariable().asRetrievable(), y.id().asVariable().asRetrievable(), refl.id().asVariable().asRetrievable(), f1.id().asVariable().asRetrievable(), r1.id().asVariable().asRetrievable(), r1.id().asVariable().asRetrievable(), _0.id().asVariable().asRetrievable(), _1.id().asVariable().asRetrievable());
        GraphProcedure procedure = proc.build();
        FunctionalIterator<VertexMap> vertices = procedure.iterator(transaction.traversal().graph(), params, filter);
        vertices.next();
    }
    session.close();
}

Example 7 with TypeQLDefine

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

the class TraversalTest method setup.

@BeforeClass
public static void setup() throws IOException {
    Util.resetDirectory(dataDir);
    databaseMgr = CoreDatabaseManager.open(options);
    databaseMgr.create(database);
    session = databaseMgr.session(database, Arguments.Session.Type.SCHEMA);
    try (TypeDB.Transaction transaction = session.transaction(WRITE)) {
        TypeQLDefine query = TypeQL.parseQuery("define " + "person sub entity, " + "  plays friendship:friend, " + "  owns name;" + "dog sub entity," + "  plays friendship:friend; " + "friendship sub relation, " + "  relates friend, " + "  owns ref;" + "name sub attribute, value string; " + "ref sub attribute, value long; ");
        transaction.query().define(query);
        transaction.commit();
    }
    session.close();
}

Example 8 with TypeQLDefine

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

the class QueryTest method test_query_delete.

@Test
public void test_query_delete() throws IOException {
    Util.resetDirectory(dataDir);
    try (TypeDB.DatabaseManager typedb = CoreDatabaseManager.open(options)) {
        typedb.create(database);
        try (TypeDB.Session session = typedb.session(database, Arguments.Session.Type.SCHEMA)) {
            try (TypeDB.Transaction transaction = session.transaction(Arguments.Transaction.Type.WRITE)) {
                TypeQLDefine query = TypeQL.parseQuery(new String(Files.readAllBytes(Paths.get("test/integration/schema.tql")), UTF_8));
                transaction.query().define(query);
                transaction.commit();
            }
        }
        try (TypeDB.Session session = typedb.session(database, Arguments.Session.Type.DATA)) {
            try (TypeDB.Transaction transaction = session.transaction(Arguments.Transaction.Type.WRITE)) {
                String insertString = "insert " + "$o isa organisation, has name 'vaticle'; " + "$t isa team, has name 'engineers', has symbol 'vaticle/engineers'; " + "$u isa user, has name 'butler', has email 'butler@vaticle.com'; " + "($o, $t) isa org-team; " + "($o, $u) isa org-member; " + "($t, $u) isa team-member;";
                TypeQLInsert insertQuery = TypeQL.parseQuery(insertString);
                transaction.query().insert(insertQuery);
                transaction.commit();
            }
            try (TypeDB.Transaction transaction = session.transaction(Arguments.Transaction.Type.WRITE)) {
                String deleteString = "match $x isa thing; delete $x isa thing;";
                TypeQLDelete deleteQuery = TypeQL.parseQuery(deleteString);
                transaction.query().delete(deleteQuery);
                transaction.commit();
            }
            try (TypeDB.Transaction transaction = session.transaction(Arguments.Transaction.Type.READ)) {
                String matchString = "match $x isa thing;";
                TypeQLMatch matchQuery = TypeQL.parseQuery(matchString);
                FunctionalIterator<ConceptMap> answers = transaction.query().match(matchQuery);
                assertFalse(answers.hasNext());
            }
        }
    }
}

Example 9 with TypeQLDefine

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

the class QueryTest method test_query_define.

@Test
public void test_query_define() throws IOException {
    Util.resetDirectory(dataDir);
    try (TypeDB.DatabaseManager typedb = CoreDatabaseManager.open(options)) {
        typedb.create(database);
        try (TypeDB.Session session = typedb.session(database, Arguments.Session.Type.SCHEMA)) {
            try (TypeDB.Transaction transaction = session.transaction(Arguments.Transaction.Type.WRITE)) {
                TypeQLDefine query = TypeQL.parseQuery(new String(Files.readAllBytes(Paths.get("test/integration/schema.tql")), UTF_8));
                transaction.query().define(query);
                transaction.commit();
            }
            try (TypeDB.Transaction tx = session.transaction(Arguments.Transaction.Type.READ)) {
                AttributeType.String name = tx.concepts().getAttributeType("name").asString();
                AttributeType.String symbol = tx.concepts().getAttributeType("symbol").asString();
                AttributeType.Boolean active = tx.concepts().getAttributeType("active").asBoolean();
                AttributeType.Long priority = tx.concepts().getAttributeType("priority").asLong();
                assertNotNulls(name, symbol, active, priority);
                EntityType organisation = tx.concepts().getEntityType("organisation");
                EntityType team = tx.concepts().getEntityType("team");
                EntityType user = tx.concepts().getEntityType("user");
                EntityType repository = tx.concepts().getEntityType("repository");
                EntityType branchRule = tx.concepts().getEntityType("branch-rule");
                EntityType commit = tx.concepts().getEntityType("commit");
                assertNotNulls(organisation, team, user, repository, branchRule, commit);
                assertTrue(organisation.getOwns().anyMatch(a -> a.equals(name)));
                assertTrue(team.getOwns().anyMatch(a -> a.equals(symbol)));
                assertTrue(user.getOwns().anyMatch(a -> a.equals(name)));
                assertTrue(repository.getOwns().anyMatch(a -> a.equals(active)));
                assertTrue(branchRule.getOwns().anyMatch(a -> a.equals(priority)));
                assertTrue(commit.getOwns().anyMatch(a -> a.equals(symbol)));
                RelationType orgTeam = tx.concepts().getRelationType("org-team");
                RelationType teamMember = tx.concepts().getRelationType("team-member");
                RelationType repoDependency = tx.concepts().getRelationType("repo-dependency");
                assertNotNulls(orgTeam, teamMember, repoDependency);
                RoleType orgTeam_org = orgTeam.getRelates("org");
                RoleType orgTeam_team = orgTeam.getRelates("team");
                RoleType teamMember_team = teamMember.getRelates("team");
                RoleType teamMember_member = teamMember.getRelates("member");
                assertNotNulls(orgTeam_org, orgTeam_team, teamMember_team, teamMember_member);
                assertTrue(organisation.getPlays().anyMatch(r -> r.equals(orgTeam_org)));
                assertTrue(team.getPlays().anyMatch(r -> r.equals(orgTeam_team)));
                assertTrue(team.getPlays().anyMatch(r -> r.equals(teamMember_team)));
                assertTrue(user.getPlays().anyMatch(r -> r.equals(teamMember_member)));
                // check first 4 rules
                assertNotNull(tx.logic().getRule("repo-fork-rule"));
                assertNotNull(tx.logic().getRule("repo-dependency-transitive-rule"));
                assertNotNull(tx.logic().getRule("repo-dependency-transitive-type-rule"));
                assertNotNull(tx.logic().getRule("repo-collaborator-org-rule"));
                // check total count
                assertEquals(15, tx.logic().rules().toList().size());
            }
        }
    }
}

Example 10 with TypeQLDefine

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

the class TypeQLSteps method typeql_define.

@Given("typeql define")
public void typeql_define(String defineQueryStatements) {
    TypeQLDefine typeQLQuery = TypeQL.parseQuery(String.join("\n", defineQueryStatements)).asDefine();
    tx().query().define(typeQLQuery);
}