BitmapQuadsIterator

hdt-java-core/src/main/java/org/rdfhdt/hdt/quads/impl/BitmapQuadsIterator.java

@@ -0,0 +1,117 @@
+package org.rdfhdt.hdt.quads.impl;
+
+import java.util.List;
+
+import org.rdfhdt.hdt.compact.bitmap.Bitmap;
+import org.rdfhdt.hdt.enums.TripleComponentOrder;
+import org.rdfhdt.hdt.exceptions.NotImplementedException;
+import org.rdfhdt.hdt.triples.TripleID;
+import org.rdfhdt.hdt.triples.impl.BitmapTriples;
+import org.rdfhdt.hdt.triples.impl.BitmapTriplesIterator;
+import org.rdfhdt.hdt.triples.impl.TripleOrderConvert;
+
+public class BitmapQuadsIterator extends BitmapTriplesIterator {
+
+	// resolves ????, S???, SP??, SPO? queries
+
+	private List<Bitmap> bitmapsGraph; // one bitmap per graph
+	private int numberOfGraphs;
+	private long posG; // the current graph bitmap
+	private int g; // g is variable
+
+	public BitmapQuadsIterator(BitmapTriples triples, TripleID pattern) {
+		super();
+		this.triples = triples;
+		this.returnTriple = new TripleID();
+		this.pattern = new TripleID();
+		this.bitmapsGraph = triples.getQuadInfoAG();
+		this.numberOfGraphs = bitmapsGraph.size();
+		newSearch(pattern);
+	}
+
+	@Override
+	public void goToStart() {
+		super.goToStart();
+		posG = 0;
+		while(!bitmapsGraph.get((int) posG).access(posZ)) {
+			posG++;
+		}
+		g = (int) posG + 1;
+	}
+
+	@Override
+	public long estimatedNumResults() {
+		long results = 0;
+		for(int i = 0; i < numberOfGraphs; i++) {
+			results += bitmapsGraph.get(i).rank1(maxZ - 1) - bitmapsGraph.get(i).rank1(minZ - 1); 
+		}
+		return results;
+	}
+
+	/* 
+	 * Get the next solution
+	 */
+	@Override
+	public TripleID next() {
+		z = (int) adjZ.get(posZ); // get the next object (Z). We just retrieve it from the list of objects (AdjZ) from current position posZ
+		if(posZ>=nextZ) { // if, with the current position of the object (posZ), we have reached the next list of objects (starting in nexZ), then we should update the associated predicate (Y) and, potentially, also the associated subject (X)
+			posY = triples.bitmapZ.rank1(posZ-1);	// move to the next position of predicates
+			y = (int) adjY.get(posY); // get the next predicate (Y). We just retrieve it from the list of predicates(AdjY) from current position posY
+			nextZ = adjZ.findNext(posZ)+1;	// update nextZ, storing in which position (in adjZ) ends the list of objects associated with the current subject,predicate
+			if(posY>=nextY) { // if we have reached the next list of objects (starting in nexZ) we should update the associated predicate (Y) and, potentially, also the associated subject (X)
+				x = (int) triples.bitmapY.rank1(posY - 1) + 1;	// get the next subject (X)
+				nextY = adjY.findNext(posY)+1;	// update nextY, storing in which position (in AdjY) ends the list of predicates associated with the current subject
+			}
+		}
+
+		g = (int) posG + 1;
+
+		// set posG to the next graph of this triple
+		do {
+			posG++;
+		} while(posG+1 <= numberOfGraphs && !bitmapsGraph.get((int) posG).access(posZ));
+
+		if(posG == numberOfGraphs) { // there are no further graphs for this triple
+			posZ++;
+			if(posZ < maxZ) {
+				posG = 0;
+				while(!bitmapsGraph.get((int) posG).access(posZ)) {
+					posG++;
+				}
+			}
+		}
+
+		updateOutput(); // set the components (subject,predicate,object,graph) of the returned triple
+		return returnTriple; // return the triple as solution
+	}
+
+	/*
+	 * Set the components (subject,predicate,object) of the returned triple 
+	 */
+	@Override
+	protected void updateOutput() {
+		returnTriple.setAll(x, y, z, g);
+		TripleOrderConvert.swapComponentOrder(returnTriple, triples.order, TripleComponentOrder.SPO);
+	}
+
+	@Override
+	public boolean hasPrevious() {
+		throw new NotImplementedException();
+	}
+
+	@Override
+	public TripleID previous() {
+		throw new NotImplementedException();
+	}
+
+	@Override
+	public boolean canGoTo() {
+		throw new NotImplementedException();
+	}
+
+	@Override
+	public void goTo(long pos) {
+		throw new NotImplementedException();
+	}
+
+}

hdt-java-core/src/main/java/org/rdfhdt/hdt/triples/impl/BitmapQuadTriples.java

@@ -52,6 +52,7 @@
 import org.rdfhdt.hdt.options.ControlInfo;
 import org.rdfhdt.hdt.options.ControlInformation;
 import org.rdfhdt.hdt.options.HDTOptions;
+import org.rdfhdt.hdt.quads.impl.BitmapQuadsIterator;
 import org.rdfhdt.hdt.triples.IteratorTripleID;
 import org.rdfhdt.hdt.triples.TempTriples;
 import org.rdfhdt.hdt.triples.TripleID;
@@ -294,12 +295,11 @@ public SuppliableIteratorTripleID search(TripleID pattern) {
 			}
 		}
 
-		SuppliableIteratorTripleID bitIt = new BitmapTriplesIterator(
+		SuppliableIteratorTripleID bitIt = new BitmapQuadsIterator(
 			this,
-			pattern,
-			true
+			pattern
 		);
-		if(patternString.equals("???") || patternString.equals("S??") || patternString.equals("SP?") || patternString.equals("SPO")) {
+		if(patternString.equals("????") || patternString.equals("S???") || patternString.equals("SP??") || patternString.equals("SPO?")) {
 			return bitIt;
 		} else {
 			return new SequentialSearchIteratorTripleID(pattern, bitIt);

hdt-java-core/src/main/java/org/rdfhdt/hdt/triples/impl/BitmapTriples.java

@@ -81,10 +81,10 @@
 public class BitmapTriples implements TriplesPrivate {
 	protected static final Logger log = LoggerFactory.getLogger(BitmapTriples.class);
 
-	protected TripleComponentOrder order;
+	public TripleComponentOrder order;
 
 	protected Sequence seqY, seqZ, indexZ, predicateCount;
-	protected Bitmap bitmapY, bitmapZ, bitmapIndexZ;
+	public Bitmap bitmapY, bitmapZ, bitmapIndexZ;
 
 	protected AdjacencyList adjY, adjZ, adjIndex;
 

hdt-java-core/src/main/java/org/rdfhdt/hdt/triples/impl/BitmapTriplesIterator.java

@@ -27,12 +27,7 @@
 
 package org.rdfhdt.hdt.triples.impl;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.stream.Collectors;
-
 import org.rdfhdt.hdt.compact.bitmap.AdjacencyList;
-import org.rdfhdt.hdt.compact.bitmap.Bitmap;
 import org.rdfhdt.hdt.enums.ResultEstimationType;
 import org.rdfhdt.hdt.enums.TripleComponentOrder;
 import org.rdfhdt.hdt.iterator.SuppliableIteratorTripleID;
@@ -44,35 +39,26 @@
  */
 public class BitmapTriplesIterator implements SuppliableIteratorTripleID {
 
-	private final BitmapTriples triples;
-	private final TripleID pattern, returnTriple;
-	private long lastPosition;
-	private long patX, patY, patZ;
+	protected BitmapTriples triples;
+	protected TripleID pattern, returnTriple;
+	protected long lastPosition;
+	protected long patX, patY, patZ;
+
+	protected AdjacencyList adjY, adjZ;
+	protected long posY, posZ, minY, minZ, maxY, maxZ;
+	protected long nextY, nextZ;
+	protected long x, y, z;
 
-	private AdjacencyList adjY, adjZ;
-	long posY, posZ, minY, minZ, maxY, maxZ, posG;
-	private long nextY, nextZ;
-	private long x, y, z, g;
-	private List<Long> currentGs;
-	private boolean isHDTQ;
+	protected BitmapTriplesIterator() {
+	}
 
 	public BitmapTriplesIterator(BitmapTriples triples, TripleID pattern) {
 		this.triples = triples;
 		this.returnTriple = new TripleID();
 		this.pattern = new TripleID();
-		this.currentGs = new ArrayList<Long>();
 		newSearch(pattern);
 	}
 
-	public BitmapTriplesIterator(
-		BitmapTriples triples,
-		TripleID pattern,
-		boolean isHDTQ
-	) {
-		this(triples, pattern);
-		this.isHDTQ = isHDTQ;
-	}
-
 	public BitmapTriplesIterator(BitmapTriples triples, long minZ, long maxZ) {
 		this.triples = triples;
 		this.returnTriple = new TripleID();
@@ -104,12 +90,9 @@ public void newSearch(TripleID pattern) {
 		goToStart();
 	}
 
-	private void updateOutput() {
+	protected void updateOutput() {
 		lastPosition = posZ;
-		if (isHDTQ)
-			returnTriple.setAll(x, y, z, g);
-		else
-			returnTriple.setAll(x, y, z);
+		returnTriple.setAll(x, y, z);
 		TripleOrderConvert.swapComponentOrder(
 			returnTriple,
 			triples.order,
@@ -166,44 +149,7 @@ private void findRange() {
 	 */
 	@Override
 	public boolean hasNext() {
-		return posZ < maxZ || currentGs.size() > 0;
-	}
-	class Indexed<T> {
-		public T value;
-		public int index;
-		public Indexed(T value, int index) {
-			this.value = value;
-			this.index = index;
-		}
-	}
-	public void updateCurrentGs() {
-		if (!isHDTQ) return;
-		if (!currentGs.isEmpty()) {
-			throw new RuntimeException("CurrentGs should not be updated if it is not empty");
-		}
-		List<Bitmap> quadInfo = triples.getQuadInfoAG();
-		// for (int i = 0; i < quadInfo.size(); i++) {
-		// 	Bitmap graph = quadInfo.get(i);
-		// 	if (graph.access((int)posG))
-		// 		currentGs.add((long) i + 1);
-		// }
-		currentGs = quadInfo
-			.stream()
-			.parallel()
-			.filter(graph -> graph.access((int)posG))
-			.map(graph -> quadInfo.indexOf(graph) + 1L)
-			.collect(Collectors.toList());
-		// currentGs = IntStream
-		// 	.range(0, quadInfo.size())
-		// 	.parallel()
-		// 	.mapToObj(i -> new Indexed<Bitmap>(quadInfo.get(i), i))
-		// 	.filter(ib -> ib.value.access((int)posG))
-		// 	.map(ib -> (long) ib.index + 1)
-		// 	.collect(Collectors.toList());
-		if (currentGs.isEmpty()) {
-			throw new RuntimeException("CurrentGs should not be empty");
-		}
-		posG++;
+		return posZ < maxZ;
 	}
 
 	/*
@@ -213,11 +159,6 @@ public void updateCurrentGs() {
 	 */
 	@Override
 	public TripleID next() {
-		if (isHDTQ && !currentGs.isEmpty()) {
-			g = currentGs.remove(0);
-			updateOutput();
-			return returnTriple;
-		}
 		z = adjZ.get(posZ);
 		if(posZ==nextZ) {
 			posY++;
@@ -232,11 +173,6 @@ public TripleID next() {
 			}
 		}
 
-		if (isHDTQ) {
-			updateCurrentGs();
-			g = currentGs.remove(0);
-		}
-
 		updateOutput();
 
 		posZ++;