@Override protected final VarPattern varPatternForAtom(Var varName, Var typeVariable) { return varName.isa(typeVariable); }
@Override public String getPredicateValue() { return getPredicate().getValue(); }
/** * @param label the label of a concept * @return a variable pattern that identifies a concept by label */ @CheckReturnValue public static VarPattern label(Label label) { return var().label(label); }
@Override public final boolean equals(Object o) { // This equals implementation is special: it considers all non-user-defined vars as equivalent if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; AbstractVarPattern var = (AbstractVarPattern) o; if (var().isUserDefinedName() != var.var().isUserDefinedName()) return false; // "simplifying" this makes it harder to read //noinspection SimplifiableIfStatement if (!properties().equals(var.properties())) return false; return !var().isUserDefinedName() || var().equals(var.var()); }
public static IsaAtom create(Var var, Var predicateVar, @Nullable ConceptId predicateId, boolean isDirect, ReasonerQuery parent) { VarPatternAdmin pattern = isDirect ? var.isaExplicit(predicateVar).admin() : var.isa(predicateVar).admin(); return new AutoValue_IsaAtom(var, predicateId, predicateVar, pattern, parent); }
public Pattern pattern(Attribute concept) { Var owner = Graql.var().asUserDefined(); VarPattern resourceVar = Graql.var().asUserDefined().val(concept.value()); return owner .has(concept.type().label(),resourceVar) .id(concept.owner().id()); } }
@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; StdAggregate that = (StdAggregate) o; return varName.equals(that.varName); }
/** * if any {@link Role} variable of the parent is user defined rewrite ALL {@link Role} variables to user defined (otherwise unification is problematic) * @param parentAtom parent atom that triggers rewrite * @return new relation atom with user defined {@link Role} variables if necessary or this */ private RelationshipAtom rewriteWithVariableRoles(Atom parentAtom){ if (!parentAtom.requiresRoleExpansion()) return this; VarPattern relVar = getPattern().admin().getProperty(IsaProperty.class) .map(prop -> getVarName().isa(prop.type())).orElse(getVarName()); for (RelationPlayer rp: getRelationPlayers()) { VarPatternAdmin rolePattern = rp.getRole().orElse(null); if (rolePattern != null) { Var roleVar = rolePattern.var(); Label roleLabel = rolePattern.getTypeLabel().orElse(null); relVar = relVar.rel(roleVar.asUserDefined().label(roleLabel), rp.getRolePlayer()); } else { relVar = relVar.rel(rp.getRolePlayer()); } } return create(relVar.admin(), this.getPredicateVariable(), this.getTypeId(), this.getPossibleTypes(), this.getParentQuery()); }
@Override protected Pattern createCombinedPattern(){ if (getPredicateVariable().isUserDefinedName()) return super.createCombinedPattern(); return getSchemaConcept() == null? getVarName().isa(getPredicateVariable()) : isDirect()? getVarName().isaExplicit(getSchemaConcept().label().getValue()) : getVarName().isa(getSchemaConcept().label().getValue()) ; }
public Pattern pattern(Entity concept) { Var entityVar = Graql.var().asUserDefined(); return entityVar .isa(Graql.label(concept.type().label())) .id(concept.id()); } }
/** * Helper method to check whether the concept types in the target have any instances * * @return true if they exist, false if they don't */ private boolean targetContainsInstance() { for (Label attributeType : targetTypeLabels()) { for (Label type : scopeTypeLabels()) { Boolean patternExist = tx.graql().infer(false).match( Graql.var("x").has(attributeType, Graql.var()), Graql.var("x").isa(Graql.label(type)) ).iterator().hasNext(); if (patternExist) return true; } } return false; //TODO: should use the following ask query when ask query is even lazier // List<Pattern> checkResourceTypes = statisticsResourceTypes.stream() // .map(type -> var("x").has(type, var())).collect(Collectors.toList()); // List<Pattern> checkSubtypes = inTypes.stream() // .map(type -> var("x").isa(Graql.label(type))).collect(Collectors.toList()); // // return tx.get().graql().infer(false) // .match(or(checkResourceTypes), or(checkSubtypes)).aggregate(ask()).execute(); }
private Var var() { Var var = Graql.var(); if (defineAllVars) { return var.asUserDefined(); } else { return var; } }
@Override public Atomic mapToAtom(VarPatternAdmin var, Set<VarPatternAdmin> vars, ReasonerQuery parent) { //NB: HasAttributeProperty always has (type) label specified Var varName = var.var().asUserDefined(); Var relationVariable = relationship().var(); Var attributeVariable = attribute().var().asUserDefined(); Set<ValuePredicate> predicates = getValuePredicates(attributeVariable, attribute(), vars, parent); IsaProperty isaProp = attribute().getProperties(IsaProperty.class).findFirst().orElse(null); VarPatternAdmin typeVar = isaProp != null? isaProp.type() : null; IdPredicate predicate = typeVar != null? getIdPredicate(attributeVariable, typeVar, vars, parent) : null; ConceptId predicateId = predicate != null? predicate.getPredicate() : null; //add resource atom VarPatternAdmin resVar = relationVariable.isUserDefinedName()? varName.has(type(), attributeVariable, relationVariable).admin() : varName.has(type(), attributeVariable).admin(); return ResourceAtom.create(resVar, attributeVariable, relationVariable, predicateId, predicates, parent); } }
public static VarPattern createValueVar(Var name, ai.grakn.graql.ValuePredicate pred) { return name.val(pred);}
inferredRelationPlayers.add(RelationPlayer.of(rolePattern, varName.admin())); allocatedRelationPlayers.add(rp); Var varName = rp.getRolePlayer().var(); Role role = Iterables.getOnlyElement(entry.getValue()); VarPatternAdmin rolePattern = Graql.var().label(role.label()).admin(); inferredRelationPlayers.add(RelationPlayer.of(rolePattern, varName.admin())); allocatedRelationPlayers.add(rp); }); rolePattern.var().label(metaRole.label()).admin() : Graql.var().label(metaRole.label()).admin(); inferredRelationPlayers.add(RelationPlayer.of(rolePattern, varName.admin())); });
.filter(prop -> !RelationshipProperty.class.isInstance(prop)) .anyMatch(prop -> !AbstractIsaProperty.class.isInstance(prop)); VarPattern relVar = isReified? var.var().asUserDefined() : var.var(); if (concept.isRole()) { Label roleLabel = concept.asSchemaConcept().label(); rolePattern = roleVar.label(roleLabel); } else { throw GraqlQueryException.nonRoleIdAssignedToRoleVariable(var); relVar.isaExplicit(typeVariable.asUserDefined()) : relVar.isa(typeVariable.asUserDefined()); return RelationshipAtom.create(relVar.admin(), typeVariable, predicateId, parent);
@Override public Atomic mapToAtom(VarPatternAdmin var, Set<VarPatternAdmin> vars, ReasonerQuery parent) { //NB: HasResourceType is a special case and it doesn't allow variables as resource types Var varName = var.var().asUserDefined(); Label label = this.resourceType().getTypeLabel().orElse(null); Var predicateVar = var().asUserDefined(); SchemaConcept schemaConcept = parent.tx().getSchemaConcept(label); ConceptId predicateId = schemaConcept != null? schemaConcept.id() : null; //isa part VarPatternAdmin resVar = varName.has(Graql.label(label)).admin(); return HasAtom.create(resVar, predicateVar, predicateId, parent); } }
@Override public Atom rewriteToUserDefined(Atom parentAtom) { return parentAtom.getPredicateVariable().isUserDefinedName()? createSelf(getVarName(), getPredicateVariable().asUserDefined(), getTypeId(), getParentQuery()) : this; } }
public Pattern pattern(Relationship concept) { VarPattern relationPattern = Graql.var(); Set<Pattern> idPatterns = new HashSet<>(); for (Map.Entry<Role, Set<Thing>> entry : concept.rolePlayersMap().entrySet()) { for (Thing var : entry.getValue()) { Var rolePlayer = Graql.var(); relationPattern = relationPattern.rel(Graql.label(entry.getKey().label()), rolePlayer); idPatterns.add(rolePlayer.asUserDefined().id(var.id())); } } relationPattern = relationPattern.isa(Graql.label(concept.type().label())); Pattern pattern = relationPattern; for (Pattern idPattern : idPatterns) { pattern = pattern.and(idPattern); } return pattern; } }
public static VarPatternAdmin varPattern(Var name, Set<VarProperty> properties) { if (properties.isEmpty()) { return name.admin(); } else { return new AutoValue_VarPatternImpl(name, properties); } }