Examples with Entity ai.grakn.concept.Entity used on opensource projects

Example 56 with Entity

use of ai.grakn.concept.Entity in project grakn by graknlabs.

the class ShortestPathTest method testResourceVerticesAndEdges.

@Test
public void testResourceVerticesAndEdges() {
    ConceptId idPerson1;
    ConceptId idPerson2;
    ConceptId idPerson3;
    ConceptId idPower1;
    ConceptId idPower2;
    ConceptId idPower3;
    ConceptId idRelationPerson1Power1;
    ConceptId idRelationPerson2Power2;
    ConceptId idRelationPerson1Person3;
    List<ConceptId> pathPerson2Power1 = new ArrayList<>();
    List<ConceptId> pathPower3Power1 = new ArrayList<>();
    List<ConceptId> pathPerson3Power3 = new ArrayList<>();
    try (GraknTx tx = session.open(GraknTxType.WRITE)) {
        EntityType person = tx.putEntityType("person");
        AttributeType<Long> power = tx.putAttributeType("power", AttributeType.DataType.LONG);
        person.attribute(power);
        // manually construct the attribute relation
        Role resourceOwner = tx.getRole(Schema.ImplicitType.HAS_OWNER.getLabel(Label.of("power")).getValue());
        Role resourceValue = tx.getRole(Schema.ImplicitType.HAS_VALUE.getLabel(Label.of("power")).getValue());
        RelationshipType relationType = tx.getRelationshipType(Schema.ImplicitType.HAS.getLabel(Label.of("power")).getValue());
        Entity person1 = person.addEntity();
        idPerson1 = person1.getId();
        Entity person2 = person.addEntity();
        idPerson2 = person2.getId();
        Entity person3 = person.addEntity();
        idPerson3 = person3.getId();
        Attribute power1 = power.putAttribute(1L);
        idPower1 = power1.getId();
        Attribute power2 = power.putAttribute(2L);
        idPower2 = power2.getId();
        Attribute power3 = power.putAttribute(3L);
        idPower3 = power3.getId();
        assert relationType != null;
        idRelationPerson1Power1 = relationType.addRelationship().addRolePlayer(resourceOwner, person1).addRolePlayer(resourceValue, power1).getId();
        idRelationPerson2Power2 = relationType.addRelationship().addRolePlayer(resourceOwner, person2).addRolePlayer(resourceValue, power2).getId();
        // add implicit resource relationships as well
        person.attribute(power);
        person1.attribute(power2);
        person3.attribute(power3);
        // finally add a relation between persons to make it more interesting
        Role role1 = tx.putRole("role1");
        Role role2 = tx.putRole("role2");
        person.plays(role1).plays(role2);
        RelationshipType relationTypePerson = tx.putRelationshipType(related).relates(role1).relates(role2);
        idRelationPerson1Person3 = relationTypePerson.addRelationship().addRolePlayer(role1, person1).addRolePlayer(role2, person3).getId();
        tx.commit();
    }
    try (GraknTx graph = session.open(GraknTxType.READ)) {
        List<List<Concept>> allPaths;
        // Path from power3 to power3
        pathPerson3Power3.add(idPerson3);
        if (null != getResourceEdgeId(graph, idPower3, idPerson3)) {
            pathPerson3Power3.add(getResourceEdgeId(graph, idPower3, idPerson3));
        }
        pathPerson3Power3.add(idPower3);
        allPaths = graph.graql().compute().paths().from(idPerson3).to(idPower3).includeAttribute().execute();
        assertEquals(1, allPaths.size());
        checkPathsAreEqual(pathPerson3Power3, allPaths.get(0));
        // Path from person2 to power1
        pathPerson2Power1.add(idPerson2);
        pathPerson2Power1.add(idRelationPerson2Power2);
        pathPerson2Power1.add(idPower2);
        if (null != getResourceEdgeId(graph, idPerson1, idPower2)) {
            pathPerson2Power1.add(getResourceEdgeId(graph, idPerson1, idPower2));
        }
        pathPerson2Power1.add(idPerson1);
        pathPerson2Power1.add(idRelationPerson1Power1);
        pathPerson2Power1.add(idPower1);
        allPaths = graph.graql().compute().paths().from(idPerson2).to(idPower1).includeAttribute().execute();
        assertEquals(1, allPaths.size());
        checkPathsAreEqual(pathPerson2Power1, allPaths.get(0));
        // Path from power3 to power1
        pathPower3Power1.add(idPower3);
        if (null != getResourceEdgeId(graph, idPower3, idPerson3)) {
            pathPower3Power1.add(getResourceEdgeId(graph, idPower3, idPerson3));
        }
        pathPower3Power1.add(idPerson3);
        pathPower3Power1.add(idRelationPerson1Person3);
        pathPower3Power1.add(idPerson1);
        pathPower3Power1.add(idRelationPerson1Power1);
        pathPower3Power1.add(idPower1);
        allPaths = graph.graql().compute().paths().includeAttribute().from(idPower3).to(idPower1).execute();
        assertEquals(1, allPaths.size());
        checkPathsAreEqual(pathPower3Power1, allPaths.get(0));
    }
}

Example 57 with Entity

use of ai.grakn.concept.Entity in project grakn by graknlabs.

the class StatisticsTest method testHasResourceVerticesAndEdges.

@Test
public void testHasResourceVerticesAndEdges() {
    try (GraknTx tx = session.open(GraknTxType.WRITE)) {
        // manually construct the relation type and instance
        AttributeType<Long> power = tx.putAttributeType("power", AttributeType.DataType.LONG);
        EntityType person = tx.putEntityType("person").attribute(power);
        Role resourceOwner = tx.getRole(Schema.ImplicitType.HAS_OWNER.getLabel(Label.of("power")).getValue());
        Role resourceValue = tx.getRole(Schema.ImplicitType.HAS_VALUE.getLabel(Label.of("power")).getValue());
        person.attribute(power);
        Entity person1 = person.addEntity();
        Entity person2 = person.addEntity();
        Entity person3 = person.addEntity();
        Attribute power1 = power.putAttribute(1L);
        Attribute power2 = power.putAttribute(2L);
        Attribute power3 = power.putAttribute(3L);
        RelationshipType relationType = tx.putRelationshipType(Schema.ImplicitType.HAS.getLabel(Label.of("power"))).relates(resourceOwner).relates(resourceValue);
        relationType.addRelationship().addRolePlayer(resourceOwner, person1).addRolePlayer(resourceValue, power1);
        relationType.addRelationship().addRolePlayer(resourceOwner, person2).addRolePlayer(resourceValue, power2);
        person1.attribute(power2);
        person3.attribute(power3);
        tx.commit();
    }
    Optional<Number> result;
    try (GraknTx graph = session.open(GraknTxType.READ)) {
        // No need to test all statistics as most of them share the same vertex program
        result = graph.graql().compute().min().of("power").in().execute();
        assertEquals(1L, result.get().longValue());
        result = graph.graql().compute().max().of("power").in().execute();
        assertEquals(3L, result.get().longValue());
        result = graph.graql().compute().sum().of("power").in().execute();
        assertEquals(8L, result.get().longValue());
        result = graph.graql().compute().median().of("power").in().execute();
        assertEquals(2L, result.get().longValue());
    }
}

Example 58 with Entity

use of ai.grakn.concept.Entity in project grakn by graknlabs.

the class StatisticsTest method testMedian.

@Test
public void testMedian() throws Exception {
    Optional<Number> result;
    // resource-type has no instance
    addSchemaAndEntities();
    try (GraknTx graph = session.open(GraknTxType.READ)) {
        result = Graql.compute().median().of(resourceType1).in(Collections.emptyList()).withTx(graph).execute();
        assertFalse(result.isPresent());
        result = Graql.compute().median().of(resourceType1).withTx(graph).execute();
        assertFalse(result.isPresent());
        result = Graql.compute().withTx(graph).median().of(resourceType1).execute();
        assertFalse(result.isPresent());
        result = Graql.compute().median().withTx(graph).of(resourceType1).execute();
        assertFalse(result.isPresent());
        result = graph.graql().compute().median().of(resourceType2).execute();
        assertFalse(result.isPresent());
        result = graph.graql().compute().median().of(resourceType2, resourceType5).execute();
        assertFalse(result.isPresent());
        result = graph.graql().compute().median().of(resourceType2).withTx(graph).execute();
        assertFalse(result.isPresent());
        result = graph.graql().compute().withTx(graph).median().of(resourceType2).execute();
        assertFalse(result.isPresent());
    }
    // add resources, but resources are not connected to any entities
    addResourcesInstances();
    try (GraknTx graph = session.open(GraknTxType.READ)) {
        result = Graql.compute().median().of(resourceType1).withTx(graph).execute();
        assertFalse(result.isPresent());
        result = Graql.compute().median().of(resourceType1).in().withTx(graph).execute();
        assertFalse(result.isPresent());
        result = graph.graql().compute().median().of(resourceType2).in(thing, anotherThing).execute();
        assertFalse(result.isPresent());
        result = Graql.compute().median().of(resourceType2).withTx(graph).in(anotherThing).execute();
        assertFalse(result.isPresent());
    }
    // connect entity and resources
    addResourceRelations();
    try (GraknTx graph = session.open(GraknTxType.READ)) {
        result = graph.graql().compute().median().of(resourceType1).in().execute();
        assertEquals(1.5D, result.get().doubleValue(), delta);
        result = Graql.compute().withTx(graph).median().of(resourceType6).execute();
        assertEquals(7.5D, result.get().doubleValue(), delta);
        result = graph.graql().compute().median().of(resourceType1, resourceType6).execute();
        assertEquals(1.8D, result.get().doubleValue(), delta);
        result = Graql.compute().withTx(graph).median().of(resourceType2).execute();
        assertEquals(0L, result.get().longValue());
        result = Graql.compute().withTx(graph).median().in(thing).of(resourceType5).execute();
        assertEquals(-7L, result.get().longValue());
        result = graph.graql().compute().median().in(thing, anotherThing).of(resourceType2, resourceType5).execute();
        assertEquals(-7L, result.get().longValue());
        result = Graql.compute().withTx(graph).median().in(thing).of(resourceType2).execute();
        assertNotEquals(0L, result.get().longValue());
    }
    List<Long> list = new ArrayList<>();
    long workerNumber = 3L;
    if (GraknTestUtil.usingTinker())
        workerNumber = 1;
    for (long i = 0L; i < workerNumber; i++) {
        list.add(i);
    }
    List<Number> numberList = list.parallelStream().map(i -> {
        try (GraknTx graph = session.open(GraknTxType.READ)) {
            return graph.graql().compute().median().of(resourceType1).execute().get();
        }
    }).collect(Collectors.toList());
    numberList.forEach(value -> assertEquals(1.5D, value.doubleValue(), delta));
}

Example 59 with Entity

use of ai.grakn.concept.Entity in project grakn by graknlabs.

the class ConnectedComponentTest method addSchemaAndEntities.

private void addSchemaAndEntities() throws InvalidKBException {
    try (GraknTx graph = session.open(GraknTxType.WRITE)) {
        EntityType entityType1 = graph.putEntityType(thing);
        EntityType entityType2 = graph.putEntityType(anotherThing);
        Entity entity1 = entityType1.addEntity();
        Entity entity2 = entityType1.addEntity();
        Entity entity3 = entityType1.addEntity();
        Entity entity4 = entityType2.addEntity();
        entityId1 = entity1.getId();
        entityId2 = entity2.getId();
        entityId3 = entity3.getId();
        entityId4 = entity4.getId();
        Role role1 = graph.putRole("role1");
        Role role2 = graph.putRole("role2");
        entityType1.plays(role1).plays(role2);
        entityType2.plays(role1).plays(role2);
        RelationshipType relationshipType = graph.putRelationshipType(related).relates(role1).relates(role2);
        relationshipType.addRelationship().addRolePlayer(role1, entity1).addRolePlayer(role2, entity2).getId();
        relationshipType.addRelationship().addRolePlayer(role1, entity2).addRolePlayer(role2, entity3).getId();
        relationshipType.addRelationship().addRolePlayer(role1, entity2).addRolePlayer(role2, entity4).getId();
        List<AttributeType> attributeTypeList = new ArrayList<>();
        attributeTypeList.add(graph.putAttributeType(resourceType1, AttributeType.DataType.DOUBLE));
        attributeTypeList.add(graph.putAttributeType(resourceType2, AttributeType.DataType.LONG));
        attributeTypeList.add(graph.putAttributeType(resourceType3, AttributeType.DataType.LONG));
        attributeTypeList.add(graph.putAttributeType(resourceType4, AttributeType.DataType.STRING));
        attributeTypeList.add(graph.putAttributeType(resourceType5, AttributeType.DataType.LONG));
        attributeTypeList.add(graph.putAttributeType(resourceType6, AttributeType.DataType.DOUBLE));
        attributeTypeList.add(graph.putAttributeType(resourceType7, AttributeType.DataType.DOUBLE));
        attributeTypeList.forEach(attributeType -> {
            entityType1.attribute(attributeType);
            entityType2.attribute(attributeType);
        });
        graph.commit();
    }
}

Example 60 with Entity

use of ai.grakn.concept.Entity in project grakn by graknlabs.

the class DegreeTest method testRelationshipPlaysARole.

@Test
public void testRelationshipPlaysARole() throws InvalidKBException {
    Role pet = tx.putRole("pet");
    Role owner = tx.putRole("owner");
    RelationshipType mansBestFriend = tx.putRelationshipType("mans-best-friend").relates(pet).relates(owner);
    EntityType person = tx.putEntityType("person").plays(owner);
    EntityType animal = tx.putEntityType("animal").plays(pet);
    Role ownership = tx.putRole("ownership");
    Role ownershipResource = tx.putRole("ownership-resource");
    RelationshipType hasOwnershipResource = tx.putRelationshipType("has-ownership-resource").relates(ownership).relates(ownershipResource);
    AttributeType<String> startDate = tx.putAttributeType("start-date", AttributeType.DataType.STRING);
    startDate.plays(ownershipResource);
    mansBestFriend.plays(ownership);
    // add instances
    Entity coco = animal.addEntity();
    Entity dave = person.addEntity();
    Relationship daveOwnsCoco = mansBestFriend.addRelationship().addRolePlayer(owner, dave).addRolePlayer(pet, coco);
    Attribute aStartDate = startDate.putAttribute("01/01/01");
    hasOwnershipResource.addRelationship().addRolePlayer(ownershipResource, aStartDate).addRolePlayer(ownership, daveOwnsCoco);
    Map<Long, Set<String>> referenceDegrees = new HashMap<>();
    referenceDegrees.put(1L, Sets.newHashSet(coco.getId().getValue(), dave.getId().getValue(), aStartDate.getId().getValue(), daveOwnsCoco.getId().getValue()));
    tx.commit();
    try (GraknTx graph = session.open(GraknTxType.READ)) {
        Map<Long, Set<String>> degrees = graph.graql().compute().centrality().usingDegree().execute();
        assertEquals(referenceDegrees, degrees);
    }
}