private Var getVariable(Token variable) { // Remove '$' prefix return Graql.var(variable.getText().substring(1)); }
@Override public final Pattern and(Pattern pattern) { return Graql.and(this, pattern); }
public static void printWholeCompletionMessage(MigrationOptions options){ System.out.println("Migration complete."); if(options.isVerbose()) { System.out.println("Gathering information about migrated data. If in a hurry, you can ctrl+c now."); GraknTx tx = new Grakn(options.getUri()).session(options.getKeyspace()).transaction(GraknTxType.WRITE); QueryBuilder qb = tx.graql(); StringBuilder builder = new StringBuilder(); builder.append("Graph schema contains:\n"); builder.append("\t ").append(tx.admin().getMetaEntityType().instances().count()).append(" entity types\n"); builder.append("\t ").append(tx.admin().getMetaRelationType().instances().count()).append(" relation types\n"); builder.append("\t ").append(tx.admin().getMetaRole().subs().count()).append(" roles\n\n"); builder.append("\t ").append(tx.admin().getMetaAttributeType().instances().count()).append(" resource types\n"); builder.append("\t ").append(tx.admin().getMetaRule().subs().count()).append(" rules\n\n"); builder.append("Graph data contains:\n"); builder.append("\t ").append(qb.match(var("x").isa(label(ENTITY.getLabel()))).aggregate(count()).execute()).append(" entities\n"); builder.append("\t ").append(qb.match(var("x").isa(label(RELATIONSHIP.getLabel()))).aggregate(count()).execute()).append(" relations\n"); builder.append("\t ").append(qb.match(var("x").isa(label(ATTRIBUTE.getLabel()))).aggregate(count()).execute()).append(" resources\n"); builder.append("\t ").append(qb.match(var("x").isa(label(RULE.getLabel()))).aggregate(count()).execute()).append(" rules\n\n"); System.out.println(builder); tx.close(); } }
/** * Helper method to check whether the concept types in the scope have any instances * * @return */ private boolean scopeContainsInstance() { if (scopeTypeLabels().isEmpty()) return false; List<Pattern> checkSubtypes = scopeTypeLabels().stream() .map(type -> Graql.var("x").isa(Graql.label(type))).collect(Collectors.toList()); return tx.graql().infer(false).match(Graql.or(checkSubtypes)).iterator().hasNext(); }
public static Pattern convert(GrpcConcept.Pattern pattern ) { return Graql.parser().parsePattern(pattern.getValue()); }
@SuppressWarnings("unchecked") private void registerDefaultAggregates() { registerAggregate("count", 0, Integer.MAX_VALUE, args -> Graql.count()); registerAggregate("sum", 1, args -> Aggregates.sum((Var) args.get(0))); registerAggregate("max", 1, args -> Aggregates.max((Var) args.get(0))); registerAggregate("min", 1, args -> Aggregates.min((Var) args.get(0))); registerAggregate("mean", 1, args -> Aggregates.mean((Var) args.get(0))); registerAggregate("median", 1, args -> Aggregates.median((Var) args.get(0))); registerAggregate("std", 1, args -> Aggregates.std((Var) args.get(0))); registerAggregate("group", 1, 2, args -> { if (args.size() < 2) { return Aggregates.group((Var) args.get(0)); } else { return Aggregates.group((Var) args.get(0), (Aggregate) args.get(1)); } }); }
@Override public final VarPattern has(String type, Object value) { return has(type, Graql.eq(value)); }
@Override public final VarPattern plays(String type) { return plays(Graql.label(type)); }
@Nullable @Override public final Pattern then() { ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder() .setRuleThenReq(ConceptProto.Rule.Then.Req.getDefaultInstance()).build(); ConceptProto.Rule.Then.Res response = runMethod(method).getRuleThenRes(); switch (response.getResCase()) { case NULL: return null; case PATTERN: return Graql.parser().parsePattern(response.getPattern()); default: throw CommonUtil.unreachableStatement("Unexpected response " + response); } }
@Override public final VarPattern val(Object value) { return val(Graql.eq(value)); }
/** * Create an aggregate that will sum the values of a variable. */ @CheckReturnValue public static Aggregate<Value> sum(String var) { return Aggregates.sum(Graql.var(var)); }
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; } }
@Override public final VarPattern isaExplicit(String type) { return isaExplicit(Graql.label(type)); }
@Nullable @Override public final Pattern when() { ConceptProto.Method.Req method = ConceptProto.Method.Req.newBuilder() .setRuleWhenReq(ConceptProto.Rule.When.Req.getDefaultInstance()).build(); ConceptProto.Rule.When.Res response = runMethod(method).getRuleWhenRes(); switch (response.getResCase()) { case NULL: return null; case PATTERN: return Graql.parser().parsePattern(response.getPattern()); default: throw CommonUtil.unreachableStatement("Unexpected response " + response); } }
/** * @param patterns an array of patterns to match * @return a pattern that will match only when all contained patterns match */ @CheckReturnValue public static Pattern and(Pattern... patterns) { return and(Arrays.asList(patterns)); }
@Override public ValuePredicate visitPredicateEq(GraqlParser.PredicateEqContext ctx) { return eq(visitValue(ctx.value())); }
/** * Create an aggregate that will find the unbiased sample standard deviation of a variable's values. * @param var the variable to find the standard deviation of */ @CheckReturnValue public static Aggregate<Value> std(String var) { return Aggregates.std(Graql.var(var)); }
/** * 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(); }