use of ai.grakn.concept.Type in project grakn by graknlabs.
the class RelationshipAtom method inferPossibleRelationConfigurations.
/**
* @return a map of relationships and corresponding roles that could be played by this atom
*/
private Multimap<RelationshipType, Role> inferPossibleRelationConfigurations(Answer sub) {
Set<Role> roles = getExplicitRoles().filter(r -> !Schema.MetaSchema.isMetaLabel(r.getLabel())).collect(toSet());
Map<Var, Type> varTypeMap = getParentQuery().getVarTypeMap(sub);
Set<Type> types = getRolePlayers().stream().filter(varTypeMap::containsKey).map(varTypeMap::get).collect(toSet());
if (roles.isEmpty() && types.isEmpty()) {
RelationshipType metaRelationType = tx().admin().getMetaRelationType();
Multimap<RelationshipType, Role> compatibleTypes = HashMultimap.create();
metaRelationType.subs().filter(rt -> !rt.equals(metaRelationType)).forEach(rt -> compatibleTypes.putAll(rt, rt.relates().collect(toSet())));
return compatibleTypes;
}
// intersect relation types from roles and types
Multimap<RelationshipType, Role> compatibleTypes;
Multimap<RelationshipType, Role> compatibleTypesFromRoles = compatibleRelationTypesWithRoles(roles, new RoleConverter());
Multimap<RelationshipType, Role> compatibleTypesFromTypes = compatibleRelationTypesWithRoles(types, new TypeConverter());
if (roles.isEmpty()) {
compatibleTypes = compatibleTypesFromTypes;
} else // no types from roles -> roles correspond to mutually exclusive relations
if (compatibleTypesFromRoles.isEmpty() || types.isEmpty()) {
compatibleTypes = compatibleTypesFromRoles;
} else {
compatibleTypes = multimapIntersection(compatibleTypesFromTypes, compatibleTypesFromRoles);
}
return compatibleTypes;
}
use of ai.grakn.concept.Type in project grakn by graknlabs.
the class RelationshipAtom method inferRoles.
/**
* attempt to infer role types of this relation and return a fresh relationship with inferred role types
* @return either this if nothing/no roles can be inferred or fresh relation with inferred role types
*/
private RelationshipAtom inferRoles(Answer sub) {
// return if all roles known and non-meta
List<Role> explicitRoles = getExplicitRoles().collect(Collectors.toList());
Map<Var, Type> varTypeMap = getParentQuery().getVarTypeMap(sub);
boolean allRolesMeta = explicitRoles.stream().allMatch(role -> Schema.MetaSchema.isMetaLabel(role.getLabel()));
boolean roleRecomputationViable = allRolesMeta && (!sub.isEmpty() || !Sets.intersection(varTypeMap.keySet(), getRolePlayers()).isEmpty());
if (explicitRoles.size() == getRelationPlayers().size() && !roleRecomputationViable)
return this;
GraknTx graph = getParentQuery().tx();
Role metaRole = graph.admin().getMetaRole();
List<RelationPlayer> allocatedRelationPlayers = new ArrayList<>();
RelationshipType relType = getSchemaConcept() != null ? getSchemaConcept().asRelationshipType() : null;
// explicit role types from castings
List<RelationPlayer> inferredRelationPlayers = new ArrayList<>();
getRelationPlayers().forEach(rp -> {
Var varName = rp.getRolePlayer().var();
VarPatternAdmin rolePattern = rp.getRole().orElse(null);
if (rolePattern != null) {
Label roleLabel = rolePattern.getTypeLabel().orElse(null);
// allocate if variable role or if label non meta
if (roleLabel == null || !Schema.MetaSchema.isMetaLabel(roleLabel)) {
inferredRelationPlayers.add(RelationPlayer.of(rolePattern, varName.admin()));
allocatedRelationPlayers.add(rp);
}
}
});
// remaining roles
// role types can repeat so no matter what has been allocated still the full spectrum of possibilities is present
// TODO make restrictions based on cardinality constraints
Set<Role> possibleRoles = relType != null ? relType.relates().collect(toSet()) : inferPossibleTypes(sub).stream().filter(Concept::isRelationshipType).map(Concept::asRelationshipType).flatMap(RelationshipType::relates).collect(toSet());
// possible role types for each casting based on its type
Map<RelationPlayer, Set<Role>> mappings = new HashMap<>();
getRelationPlayers().stream().filter(rp -> !allocatedRelationPlayers.contains(rp)).forEach(rp -> {
Var varName = rp.getRolePlayer().var();
Type type = varTypeMap.get(varName);
mappings.put(rp, top(type != null ? compatibleRoles(type, possibleRoles) : possibleRoles));
});
// allocate all unambiguous mappings
mappings.entrySet().stream().filter(entry -> entry.getValue().size() == 1).forEach(entry -> {
RelationPlayer rp = entry.getKey();
Var varName = rp.getRolePlayer().var();
Role role = Iterables.getOnlyElement(entry.getValue());
VarPatternAdmin rolePattern = Graql.var().label(role.getLabel()).admin();
inferredRelationPlayers.add(RelationPlayer.of(rolePattern, varName.admin()));
allocatedRelationPlayers.add(rp);
});
// fill in unallocated roles with metarole
getRelationPlayers().stream().filter(rp -> !allocatedRelationPlayers.contains(rp)).forEach(rp -> {
Var varName = rp.getRolePlayer().var();
VarPatternAdmin rolePattern = rp.getRole().orElse(null);
rolePattern = rolePattern != null ? rolePattern.var().label(metaRole.getLabel()).admin() : Graql.var().label(metaRole.getLabel()).admin();
inferredRelationPlayers.add(RelationPlayer.of(rolePattern, varName.admin()));
});
VarPattern relationPattern = relationPattern(getVarName(), inferredRelationPlayers);
VarPatternAdmin newPattern = (isDirect() ? relationPattern.directIsa(getPredicateVariable()) : relationPattern.isa(getPredicateVariable())).admin();
return create(newPattern, getPredicateVariable(), getTypeId(), getParentQuery());
}
use of ai.grakn.concept.Type in project grakn by graknlabs.
the class ResourceAtom method validateOntologically.
@Override
public Set<String> validateOntologically() {
SchemaConcept type = getSchemaConcept();
Set<String> errors = new HashSet<>();
if (type == null)
return errors;
if (!type.isAttributeType()) {
errors.add(ErrorMessage.VALIDATION_RULE_INVALID_RESOURCE_TYPE.getMessage(type.getLabel()));
return errors;
}
Type ownerType = getParentQuery().getVarTypeMap().get(getVarName());
if (ownerType != null && ownerType.attributes().noneMatch(rt -> rt.equals(type.asAttributeType()))) {
errors.add(ErrorMessage.VALIDATION_RULE_RESOURCE_OWNER_CANNOT_HAVE_RESOURCE.getMessage(type.getLabel(), ownerType.getLabel()));
}
return errors;
}
use of ai.grakn.concept.Type in project grakn by graknlabs.
the class EntityTypeTest method whenSettingMetaTypeToAbstract_Throw.
@Test
public void whenSettingMetaTypeToAbstract_Throw() {
Type meta = tx.getMetaEntityType();
expectedException.expect(GraknTxOperationException.class);
expectedException.expectMessage(GraknTxOperationException.metaTypeImmutable(meta.getLabel()).getMessage());
meta.setAbstract(true);
}
use of ai.grakn.concept.Type in project grakn by graknlabs.
the class EntityTypeTest method whenGettingTheSuperSet_ReturnAllOfItsSuperTypes.
@Test
public void whenGettingTheSuperSet_ReturnAllOfItsSuperTypes() throws Exception {
EntityType entityType = tx.admin().getMetaEntityType();
EntityType c1 = tx.putEntityType("c1");
EntityType c2 = tx.putEntityType("c2").sup(c1);
EntityType c3 = tx.putEntityType("c3").sup(c2);
EntityType c4 = tx.putEntityType("c4").sup(c1);
Set<Type> c1SuperTypes = EntityTypeImpl.from(c1).sups().collect(toSet());
Set<Type> c2SuperTypes = EntityTypeImpl.from(c2).sups().collect(toSet());
Set<Type> c3SuperTypes = EntityTypeImpl.from(c3).sups().collect(toSet());
Set<Type> c4SuperTypes = EntityTypeImpl.from(c4).sups().collect(toSet());
assertThat(c1SuperTypes, containsInAnyOrder(entityType, c1));
assertThat(c2SuperTypes, containsInAnyOrder(entityType, c2, c1));
assertThat(c3SuperTypes, containsInAnyOrder(entityType, c3, c2, c1));
assertThat(c4SuperTypes, containsInAnyOrder(entityType, c4, c1));
}
Aggregations