public ConditionQuery eq(HugeKeys key, Object value) { // Filter value by key return this.query(Condition.eq(key, value)); }
public ConditionQuery lt(HugeKeys key, Object value) { return this.query(Condition.lt(key, value)); }
public ConditionQuery lte(HugeKeys key, Object value) { return this.query(Condition.lte(key, value)); }
public ConditionQuery neq(HugeKeys key, Object value) { return this.query(Condition.neq(key, value)); }
public ConditionQuery key(HugeKeys key, Object value) { return this.query(Condition.containsKey(key, value)); }
public ConditionQuery gt(HugeKeys key, Object value) { return this.query(Condition.gt(key, value)); }
public ConditionQuery gte(HugeKeys key, Object value) { return this.query(Condition.gte(key, value)); }
public ConditionQuery prefix(HugeKeys key, Id value) { return this.query(Condition.prefix(key, value)); }
public ConditionQuery scan(String start, String end) { return this.query(Condition.scan(start, end)); }
private static ConditionQuery newQueryFromRelations(ConditionQuery query, Relations relations) { ConditionQuery cq = query.copy(); cq.resetConditions(); for (Relation relation : relations) { cq.query(relation); } return cq; }
public static ConditionQuery fillConditionQuery( List<HasContainer> hasContainers, ConditionQuery query, HugeGraph graph) { HugeType resultType = query.resultType(); for (HasContainer has : hasContainers) { Condition condition = convHas2Condition(has, resultType, graph); query.query(condition); } return query; }
@Test public void testFlattenWithMultiAnd() { Condition c1 = Condition.eq(IdGenerator.of("c1"), "1"); Condition c2 = Condition.eq(IdGenerator.of("c2"), "2"); Condition c3 = Condition.eq(IdGenerator.of("c3"), "3"); Condition c4 = Condition.eq(IdGenerator.of("c4"), "4"); ConditionQuery query = new ConditionQuery(HugeType.VERTEX); query.query(c1); query.query(c2); query.query(c3); query.query(c4); Assert.assertEquals(4, query.conditions().size()); List<ConditionQuery> queries = ConditionQueryFlatten.flatten(query); Assert.assertEquals(1, queries.size()); Set<Set<Condition>> expect; expect = ImmutableSet.of(ImmutableSet.of(c1, c2, c3, c4)); Set<Set<Condition>> actual = new HashSet<>(); for (ConditionQuery q : queries) { actual.add(q.conditions()); } Assert.assertEquals(expect, actual); }
@Test public void testFlattenWithOr() { Condition c1 = Condition.eq(IdGenerator.of("c1"), "1"); Condition c2 = Condition.eq(IdGenerator.of("c2"), "2"); ConditionQuery query = new ConditionQuery(HugeType.VERTEX); query.query(c1.or(c2)); Assert.assertEquals(1, query.conditions().size()); List<ConditionQuery> queries = ConditionQueryFlatten.flatten(query); Assert.assertEquals(2, queries.size()); Set<Set<Condition>> expect; expect = ImmutableSet.of(ImmutableSet.of(c1), ImmutableSet.of(c2)); Set<Set<Condition>> actual = new HashSet<>(); for (ConditionQuery q : queries) { actual.add(q.conditions()); } Assert.assertEquals(expect, actual); }
@Test public void testFlattenWithAnd() { Condition c1 = Condition.eq(IdGenerator.of("c1"), "1"); Condition c2 = Condition.eq(IdGenerator.of("c2"), "2"); ConditionQuery query = new ConditionQuery(HugeType.VERTEX); query.query(c1.and(c2)); Assert.assertEquals(1, query.conditions().size()); List<ConditionQuery> queries = ConditionQueryFlatten.flatten(query); Assert.assertEquals(1, queries.size()); Set<Set<Condition>> expect; expect = ImmutableSet.of(ImmutableSet.of(c1, c2)); Set<Set<Condition>> actual = new HashSet<>(); for (ConditionQuery q : queries) { actual.add(q.conditions()); } Assert.assertEquals(expect, actual); }
public Query query(CassandraSessionPool.Session session, Query query) { Set<Condition> conditions = query.conditions(); if (!(query instanceof ConditionQuery) || conditions.isEmpty()) { return query; } ConditionQuery q = ((ConditionQuery) query).copy(); String name = (String) q.condition(HugeKeys.NAME); if (name != null && q.allSysprop() && conditions.size() == 1 && q.containsCondition(HugeKeys.NAME, Condition.RelationType.EQ)) { Set<Integer> ids = queryByNameIndex(session, this.table, name); if (ids.isEmpty()) { // Not found data with the specified label return null; } q.resetConditions(); for (Integer id : ids) { q.query(IdGenerator.of(id)); } } return q; }
@Test public void testFlattenWithOrTree() { Condition c1 = Condition.eq(IdGenerator.of("c1"), "1"); Condition c2 = Condition.eq(IdGenerator.of("c2"), "2"); Condition c3 = Condition.eq(IdGenerator.of("c3"), "3"); Condition c4 = Condition.eq(IdGenerator.of("c4"), "4"); ConditionQuery query = new ConditionQuery(HugeType.VERTEX); query.query(c1.or(c2).or(c3.or(c4))); Assert.assertEquals(1, query.conditions().size()); List<ConditionQuery> queries = ConditionQueryFlatten.flatten(query); Assert.assertEquals(4, queries.size()); Set<Set<Condition>> expect; expect = ImmutableSet.of(ImmutableSet.of(c1), ImmutableSet.of(c2), ImmutableSet.of(c3), ImmutableSet.of(c4)); Set<Set<Condition>> actual = new HashSet<>(); for (ConditionQuery q : queries) { actual.add(q.conditions()); } Assert.assertEquals(expect, actual); }
private HugeVertex queryVariableVertex(String key) { ConditionQuery query = new ConditionQuery(HugeType.VERTEX); VertexLabel vl = this.graph.vertexLabel(Hidden.hide(VARIABLES)); query.eq(HugeKeys.LABEL, vl.id()); PropertyKey pkey = this.graph.propertyKey(Hidden.hide(VARIABLE_KEY)); query.query(Condition.eq(pkey.id(), key)); query.showHidden(true); Iterator<Vertex> vertices = this.graph.vertices(query); if (!vertices.hasNext()) { return null; } return (HugeVertex) vertices.next(); }
@Test public void testFlattenWithOrAndTree() { Condition c1 = Condition.eq(IdGenerator.of("c1"), "1"); Condition c2 = Condition.eq(IdGenerator.of("c2"), "2"); Condition c3 = Condition.eq(IdGenerator.of("c3"), "3"); Condition c4 = Condition.eq(IdGenerator.of("c4"), "4"); ConditionQuery query = new ConditionQuery(HugeType.VERTEX); query.query(c1.and(c2).or(c3.and(c4))); Assert.assertEquals(1, query.conditions().size()); List<ConditionQuery> queries = ConditionQueryFlatten.flatten(query); Assert.assertEquals(2, queries.size()); Set<Set<Condition>> expect; expect = ImmutableSet.of(ImmutableSet.of(c1, c2), ImmutableSet.of(c3, c4)); Set<Set<Condition>> actual = new HashSet<>(); for (ConditionQuery q : queries) { actual.add(q.conditions()); } Assert.assertEquals(expect, actual); } }
@Test public void testFlattenWithAndTree() { Condition c1 = Condition.eq(IdGenerator.of("c1"), "1"); Condition c2 = Condition.eq(IdGenerator.of("c2"), "2"); Condition c3 = Condition.eq(IdGenerator.of("c3"), "3"); Condition c4 = Condition.eq(IdGenerator.of("c4"), "4"); ConditionQuery query = new ConditionQuery(HugeType.VERTEX); query.query(c1.and(c2).and(c3.and(c4))); Assert.assertEquals(1, query.conditions().size()); List<ConditionQuery> queries = ConditionQueryFlatten.flatten(query); Assert.assertEquals(1, queries.size()); Set<Set<Condition>> expect; expect = ImmutableSet.of(ImmutableSet.of(c1, c2, c3, c4)); Set<Set<Condition>> actual = new HashSet<>(); for (ConditionQuery q : queries) { actual.add(q.conditions()); } Assert.assertEquals(expect, actual); }
private <V> Iterator<HugeTask<V>> queryTask(Map<String, Object> conditions, long limit) { return this.call(() -> { ConditionQuery query = new ConditionQuery(HugeType.VERTEX); VertexLabel vl = this.graph.vertexLabel(TaskTransaction.TASK); query.eq(HugeKeys.LABEL, vl.id()); for (Map.Entry<String, Object> entry : conditions.entrySet()) { PropertyKey pk = this.graph.propertyKey(entry.getKey()); query.query(Condition.eq(pk.id(), entry.getValue())); } query.showHidden(true); if (limit != NO_LIMIT) { query.limit(limit); } Iterator<Vertex> vertices = this.tx().queryVertices(query); Iterator<HugeTask<V>> tasks = new MapperIterator<>(vertices, HugeTask::fromVertex); // Convert iterator to list to avoid across thread tx accessed return IteratorUtils.list(tasks); }).iterator(); }