public VertexLongList(StandardTitanTx tx) { this(tx,new LongArrayList(10),true); }
public VertexLongList(StandardJanusGraphTx tx) { this(tx,new LongArrayList(10),true); }
public static LongArrayList singleton(long el) { LongArrayList l = new LongArrayList(1); l.add(el); return l; }
public static LongArrayList singleton(long el) { LongArrayList l = new LongArrayList(1); l.add(el); return l; }
/** * Utility method used to convert the list of vertices into a list of vertex ids (assuming all vertices have ids) * * @param vertices * @return */ private static final LongArrayList toLongList(List<TitanVertex> vertices) { LongArrayList result = new LongArrayList(vertices.size()); for (TitanVertex n : vertices) { result.add(n.longId()); } return result; }
/** * Utility method used to convert the list of vertices into a list of vertex ids (assuming all vertices have ids) * * @param vertices * @return */ private static LongArrayList toLongList(List<JanusGraphVertex> vertices) { LongArrayList result = new LongArrayList(vertices.size()); for (JanusGraphVertex n : vertices) { result.add(n.longId()); } return result; }
/** * Returns the list of adjacent vertex ids for this query. By reading those ids * from the entries directly (without creating objects) we get much better performance. * * @return */ public VertexList vertexIds() { LongArrayList list = new LongArrayList(); long previousId = 0; for (Long id : Iterables.transform(this,new Function<Entry, Long>() { @Nullable @Override public Long apply(@Nullable Entry entry) { return edgeSerializer.readRelation(entry,true,tx).getOtherVertexId(); } })) { list.add(id); if (id>=previousId && previousId>=0) previousId=id; else previousId=-1; } return new VertexLongList(tx,list,previousId>=0); }
@Override public VertexList subList(int fromPosition, int length) { LongArrayList subList = new LongArrayList(length); subList.add(vertices.buffer, fromPosition, length); assert subList.size()==length; return new VertexLongList(tx,subList,sorted); }
/** * Returns the list of adjacent vertex ids for this query. By reading those ids * from the entries directly (without creating objects) we get much better performance. * * @return */ public VertexList vertexIds() { LongArrayList list = new LongArrayList(); long previousId = 0; for (Long id : Iterables.transform(this,new Function<Entry, Long>() { @Nullable @Override public Long apply(@Nullable Entry entry) { return edgeSerializer.readRelation(entry,true,tx).getOtherVertexId(); } })) { list.add(id); if (id>=previousId && previousId>=0) previousId=id; else previousId=-1; } return new VertexLongList(tx,list,previousId>=0); }
@Override public VertexList subList(int fromPosition, int length) { LongArrayList subList = new LongArrayList(length); subList.add(vertices.buffer, fromPosition, length); assert subList.size()==length; return new VertexLongList(tx,subList,sorted); }
@Override public void addAll(VertexList vertexlist) { LongArrayList othervertexids = null; if (vertexlist instanceof VertexLongList) { othervertexids = ((VertexLongList) vertexlist).vertices; } else if (vertexlist instanceof VertexArrayList) { VertexArrayList other = (VertexArrayList) vertexlist; othervertexids = new LongArrayList(other.size()); for (int i = 0; i < other.size(); i++) othervertexids.add(other.getID(i)); } else { throw new IllegalArgumentException("Unsupported vertex-list: " + vertexlist.getClass()); } if (sorted && vertexlist.isSorted()) { //Merge join vertices = AbstractLongListUtil.mergeSort(vertices,othervertexids); } else { sorted = false; vertices.add(othervertexids.buffer, 0, othervertexids.size()); } }
@Override public void addAll(VertexList vertexlist) { final LongArrayList otherVertexIds; if (vertexlist instanceof VertexLongList) { otherVertexIds = ((VertexLongList) vertexlist).vertices; } else if (vertexlist instanceof VertexArrayList) { VertexArrayList other = (VertexArrayList) vertexlist; otherVertexIds = new LongArrayList(other.size()); for (int i = 0; i < other.size(); i++) otherVertexIds.add(other.getID(i)); } else { throw new IllegalArgumentException("Unsupported vertex-list: " + vertexlist.getClass()); } if (sorted && vertexlist.isSorted()) { //Merge join vertices = AbstractLongListUtil.mergeSort(vertices,otherVertexIds); } else { sorted = false; vertices.add(otherVertexIds.buffer, 0, otherVertexIds.size()); } }
LongArrayList vids = new LongArrayList(ids.length); for (long id : ids) { if (isValidVertexId(id)) {
public void executeMultiQuery(final Collection<InternalVertex> vertices, final SliceQuery sq, final QueryProfiler profiler) { LongArrayList vids = new LongArrayList(vertices.size()); for (InternalVertex v : vertices) { if (!v.isNew() && v.hasId() && (v instanceof CacheVertex) && !v.hasLoadedRelations(sq)) vids.add(v.longId()); } if (!vids.isEmpty()) { List<EntryList> results = QueryProfiler.profile(profiler, sq, true, q -> graph.edgeMultiQuery(vids, q, txHandle)); int pos = 0; for (TitanVertex v : vertices) { if (pos<vids.size() && vids.get(pos) == v.longId()) { final EntryList vresults = results.get(pos); ((CacheVertex) v).loadRelations(sq, new Retriever<SliceQuery, EntryList>() { @Override public EntryList get(SliceQuery query) { return vresults; } }); pos++; } } } }
public void executeMultiQuery(final Collection<InternalVertex> vertices, final SliceQuery sq, final QueryProfiler profiler) { LongArrayList vertexIds = new LongArrayList(vertices.size()); for (InternalVertex v : vertices) { if (!v.isNew() && v.hasId() && (v instanceof CacheVertex) && !v.hasLoadedRelations(sq)) vertexIds.add(v.longId()); } if (!vertexIds.isEmpty()) { List<EntryList> results = QueryProfiler.profile(profiler, sq, true, q -> graph.edgeMultiQuery(vertexIds, q, txHandle)); int pos = 0; for (JanusGraphVertex v : vertices) { if (pos<vertexIds.size() && vertexIds.get(pos) == v.longId()) { final EntryList vresults = results.get(pos); ((CacheVertex) v).loadRelations(sq, query -> vresults); pos++; } } } }
final LongArrayList vertexIds = new LongArrayList(ids.length); for (long id : ids) { if (isValidVertexId(id)) {
public static LongArrayList mergeSort(LongArrayList a, LongArrayList b) { int posa=0, posb=0; LongArrayList result = new LongArrayList(a.size()+b.size()); while (posa<a.size() || posb<b.size()) { long next; if (posa>=a.size()) { next=b.get(posb++); } else if (posb>=b.size()) { next=a.get(posa++); } else if (a.get(posa)<=b.get(posb)) { next=a.get(posa++); } else { next=b.get(posb++); } Preconditions.checkArgument(result.isEmpty() || result.get(result.size()-1)<=next, "The input lists are not sorted"); result.add(next); } return result; }
public static LongArrayList mergeSort(LongArrayList a, LongArrayList b) { int positionA=0, positionB=0; LongArrayList result = new LongArrayList(a.size()+b.size()); while (positionA<a.size() || positionB<b.size()) { long next; if (positionA>=a.size()) { next=b.get(positionB++); } else if (positionB>=b.size()) { next=a.get(positionA++); } else if (a.get(positionA)<=b.get(positionB)) { next=a.get(positionA++); } else { next=b.get(positionB++); } Preconditions.checkArgument(result.isEmpty() || result.get(result.size()-1)<=next, "The input lists are not sorted"); result.add(next); } return result; }
int sizeA = a.size(); int sizeB = b.size(); LongArrayList merge = new LongArrayList(Math.min(sizeA, sizeB)); int resultSize = 0; while (counterA < sizeA && counterB < sizeB) {
int sizeA = a.size(); int sizeB = b.size(); LongArrayList merge = new LongArrayList(Math.min(sizeA, sizeB)); int resultSize = 0; while (counterA < sizeA && counterB < sizeB) {