private static boolean[] getAllowedDirections(AtomicQuery query) {
boolean[] dirs = new boolean[4];
if (query.queryProperties()) {
assert query.isAllowedDirection(EdgeDirection.OUT);
dirs[0] = true;
}
if (query.queryRelationships()) {
Direction d = Direction.BOTH;
if (query.hasDirectionCondition()) {
d = query.getDirectionCondition();
}
switch (d) {
case IN:
dirs[3] = true;
break;
case OUT:
dirs[2] = true;
break;
case BOTH:
dirs[2] = true;
dirs[3] = true;
break;
}
}
return dirs;
}
@Override
public void loadRelations(AtomicQuery query, InternalTitanTransaction tx) {
List<Entry> entries = queryForEntries(query, tx.getTxHandle());
RelationLoader factory = tx.getRelationFactory();
VertexRelationLoader loader = new StandardVertexRelationLoader(query.getNode(), factory);
loadRelations(entries, loader, tx);
query.getNode().loadedEdges(query);
}
@Override
public AbstractLongList getRawNeighborhood(AtomicQuery query, InternalTitanTransaction tx) {
Preconditions.checkArgument(
QueryUtil.queryCoveredByDiskIndexes(query),
"Raw retrieval is currently does not support in-memory filtering");
List<Entry> entries = queryForEntries(query, tx.getTxHandle());
InternalTitanVertex node = query.getNode();
TitanType titanType = null;
if (query.hasEdgeTypeCondition()) titanType = query.getTypeCondition();
AbstractLongList result = new LongArrayList();
for (Entry entry : entries) {
if (!query.hasEdgeTypeCondition()) {
long etid = IDHandler.readEdgeType(entry.getColumn(), idManager);
if (titanType == null || titanType.getID() != etid) {
titanType = getTypeFromID(etid, tx);
}
}
if (titanType.isPropertyKey() || (!titanType.isModifiable() && !query.queryUnmodifiable())) {
continue; // Skip since it does not match query
}
// Get neighboring node id
long iddiff = VariableLong.read(entry.getValue());
long nghid = iddiff + node.getID();
result.add(nghid);
if (result.size() >= query.getLimit()) break;
}
return result;
}
private List<Entry> queryForEntries(AtomicQuery query, TransactionHandle txh) {
ByteBuffer key = IDHandler.getKey(query.getVertexID());
List<Entry> entries = null;
LimitTracker limit = new LimitTracker(query);
boolean dirs[] = getAllowedDirections(query);
if (query.hasEdgeTypeCondition()) {
TitanType et = query.getTypeCondition();
if (!et.isNew()) { // Result set must be empty if TitanType is new
ArrayList<Object> applicableConstraints = null;
boolean isRange = false;
if (query.hasConstraints()) {
assert !et.isSimple();
TypeDefinition def = ((InternalTitanType) et).getDefinition();
String[] keysig = def.getKeySignature();
applicableConstraints = new ArrayList<Object>(keysig.length);
Map<String, Object> constraints = query.getConstraints();
for (int i = 0; i < keysig.length; i++) {
if (constraints.containsKey(keysig[i])) {
Object iv = constraints.get(keysig[i]);
applicableConstraints.add(iv);
if (iv != null && (iv instanceof AtomicInterval) && ((AtomicInterval) iv).isRange()) {
isRange = true;
break;
}
} else break;
}
if (applicableConstraints.isEmpty()) applicableConstraints = null;
}
for (int dirID = 0; dirID < 4; dirID++) {
if (dirs[dirID]) {
if (applicableConstraints != null) {
assert !applicableConstraints.isEmpty();
DataOutput start = serializer.getDataOutput(defaultOutputCapacity, true);
DataOutput end = null;
if (isRange) end = serializer.getDataOutput(defaultOutputCapacity, true);
IDHandler.writeEdgeType(start, et.getID(), dirID, idManager);
if (isRange) IDHandler.writeEdgeType(end, et.getID(), dirID, idManager);
// Write all applicable key constraints
for (Object iv : applicableConstraints) {
if (iv instanceof AtomicInterval) {
AtomicInterval interval = (AtomicInterval) iv;
if (interval.isPoint()) {
start.writeObject(interval.getStartPoint());
if (isRange) end.writeObject(interval.getStartPoint());
} else {
assert isRange;
assert interval.isRange();
ByteBuffer startColumn, endColumn;
if (interval.getStartPoint() != null) {
start.writeObject(interval.getStartPoint());
startColumn = start.getByteBuffer();
if (!interval.startInclusive())
startColumn = ByteBufferUtil.nextBiggerBuffer(startColumn);
} else {
assert interval.startInclusive();
startColumn = start.getByteBuffer();
}
if (interval.getEndPoint() != null) {
end.writeObject(interval.getEndPoint());
} else {
assert interval.endInclusive();
}
endColumn = end.getByteBuffer();
if (interval.endInclusive())
endColumn = ByteBufferUtil.nextBiggerBuffer(endColumn);
entries = appendResults(key, startColumn, endColumn, entries, limit, txh);
break; // redundant, this must be the last iteration because its a range
}
} else {
assert iv == null || (iv instanceof TitanVertex);
long id = 0;
if (iv != null) id = ((TitanVertex) iv).getID();
VariableLong.writePositive(start, id);
if (isRange) VariableLong.writePositive(end, id);
}
}
if (!isRange)
entries = appendResults(key, start.getByteBuffer(), entries, limit, txh);
} else {
ByteBuffer columnStart = IDHandler.getEdgeType(et.getID(), dirID, idManager);
entries = appendResults(key, columnStart, entries, limit, txh);
}
}
}
}
} else if (query.hasGroupCondition()) {
int groupid = query.getGroupCondition().getID();
for (int dirID = 0; dirID < 4; dirID++) {
if (dirs[dirID]) {
ByteBuffer columnStart = IDHandler.getEdgeTypeGroup(groupid, dirID, idManager);
entries = appendResults(key, columnStart, entries, limit, txh);
}
}
} else {
int lastDirID = -1;
for (int dirID = 0; dirID <= 4; dirID++) {
if ((dirID >= 4 || !dirs[dirID]) && lastDirID >= 0) {
ByteBuffer columnStart = IDHandler.getEdgeTypeGroup(0, lastDirID, idManager);
ByteBuffer columnEnd =
IDHandler.getEdgeTypeGroup(idManager.getMaxGroupID() + 1, dirID - 1, idManager);
entries = appendResults(key, columnStart, columnEnd, entries, limit, txh);
lastDirID = -1;
}
if (dirID < 4) {
if (dirs[dirID] && lastDirID == -1) lastDirID = dirID;
}
}
}
if (entries == null) return ImmutableList.of();
else return entries;
}