performance improvements

Author: hmottestad

core/common/io/src/main/java/org/eclipse/rdf4j/common/io/NioFile.java

@@ -56,6 +56,29 @@ public final class NioFile implements Closeable {
 
 	private volatile boolean explictlyClosed;
 
+	/**
+	 * Optional factory used to create FileChannel instances, primarily for testing where a delegating channel can
+	 * simulate failures. If not set, {@link FileChannel#open(Path, java.nio.file.OpenOption...)} is used directly.
+	 */
+	private static volatile ChannelFactory channelFactory;
+
+	/**
+	 * Functional interface for creating FileChannel instances. Intended for test injection.
+	 */
+	@FunctionalInterface
+	public interface ChannelFactory {
+		FileChannel open(Path path, Set<StandardOpenOption> options) throws IOException;
+	}
+
+	/**
+	 * Install a factory that will be used to create FileChannel instances. Intended for tests only.
+	 *
+	 * Passing {@code null} restores the default behavior.
+	 */
+	public static void setChannelFactoryForTesting(ChannelFactory factory) {
+		channelFactory = factory;
+	}
+
 	/**
 	 * Constructor Opens a file in read/write mode, creating a new one if the file doesn't exist.
 	 *
@@ -110,7 +133,12 @@ private static Set<StandardOpenOption> toOpenOptions(String mode) {
 	 * @throws IOException
 	 */
 	private void open() throws IOException {
-		fc = FileChannel.open(file.toPath(), openOptions);
+		ChannelFactory factory = channelFactory;
+		if (factory != null) {
+			fc = factory.open(file.toPath(), openOptions);
+		} else {
+			fc = FileChannel.open(file.toPath(), openOptions);
+		}
 	}
 
 	/**
@@ -423,4 +451,5 @@ public int readInt(long offset) throws IOException {
 		}
 		return buf.getInt(0);
 	}
+
 }

core/sail/nativerdf/src/main/java/org/eclipse/rdf4j/sail/nativerdf/NativeStatementIterator.java

@@ -13,9 +13,10 @@
 import static org.eclipse.rdf4j.sail.nativerdf.NativeStore.SOFT_FAIL_ON_CORRUPT_DATA_AND_REPAIR_INDEXES;
 
 import java.io.IOException;
+import java.util.NoSuchElementException;
 
 import org.eclipse.rdf4j.common.io.ByteArrayUtil;
-import org.eclipse.rdf4j.common.iteration.LookAheadIteration;
+import org.eclipse.rdf4j.common.iteration.CloseableIteration;
 import org.eclipse.rdf4j.model.IRI;
 import org.eclipse.rdf4j.model.Resource;
 import org.eclipse.rdf4j.model.Statement;
@@ -32,35 +33,21 @@
  * A statement iterator that wraps a RecordIterator containing statement records and translates these records to
  * {@link Statement} objects.
  */
-class NativeStatementIterator extends LookAheadIteration<Statement> {
+class NativeStatementIterator implements CloseableIteration<Statement> {
 
 	private static final Logger logger = LoggerFactory.getLogger(NativeStatementIterator.class);
 
-	/*-----------*
-	 * Variables *
-	 *-----------*/
-
 	private final RecordIterator btreeIter;
-
 	private final ValueStore valueStore;
 
-	/*--------------*
-	 * Constructors *
-	 *--------------*/
+	private Statement nextElement;
+	private boolean closed = false;
 
-	/**
-	 * Creates a new NativeStatementIterator.
-	 */
 	public NativeStatementIterator(RecordIterator btreeIter, ValueStore valueStore) {
 		this.btreeIter = btreeIter;
 		this.valueStore = valueStore;
 	}
 
-	/*---------*
-	 * Methods *
-	 *---------*/
-
-	@Override
 	public Statement getNextElement() throws SailException {
 		try {
 			byte[] nextValue;
@@ -107,7 +94,6 @@ public Statement getNextElement() throws SailException {
 		}
 	}
 
-	@Override
 	protected void handleClose() throws SailException {
 		try {
 			btreeIter.close();
@@ -119,4 +105,79 @@ protected void handleClose() throws SailException {
 	protected SailException causeIOException(IOException e) {
 		return new SailException(e);
 	}
+
+	@Override
+	public final boolean hasNext() {
+		if (isClosed()) {
+			return false;
+		}
+
+		try {
+			return lookAhead() != null;
+		} catch (NoSuchElementException logged) {
+			// The lookAhead() method shouldn't throw a NoSuchElementException since it should return null when there
+			// are no more elements.
+			logger.trace("LookAheadIteration threw NoSuchElementException:", logged);
+			return false;
+		}
+	}
+
+	@Override
+	public final Statement next() {
+		if (isClosed()) {
+			throw new NoSuchElementException("The iteration has been closed.");
+		}
+		Statement result = lookAhead();
+
+		if (result != null) {
+			nextElement = null;
+			return result;
+		} else {
+			throw new NoSuchElementException();
+		}
+	}
+
+	/**
+	 * Fetches the next element if it hasn't been fetched yet and stores it in {@link #nextElement}.
+	 *
+	 * @return The next element, or null if there are no more results.
+	 */
+	private Statement lookAhead() {
+		if (nextElement == null) {
+			nextElement = getNextElement();
+
+			if (nextElement == null) {
+				close();
+			}
+		}
+		return nextElement;
+	}
+
+	/**
+	 * Throws an {@link UnsupportedOperationException}.
+	 */
+	@Override
+	public void remove() {
+		throw new UnsupportedOperationException();
+	}
+
+	/**
+	 * Checks whether this CloseableIteration has been closed.
+	 *
+	 * @return <var>true</var> if the CloseableIteration has been closed, <var>false</var> otherwise.
+	 */
+	public final boolean isClosed() {
+		return closed;
+	}
+
+	/**
+	 * Calls {@link #handleClose()} upon first call and makes sure the resource closures are only executed once.
+	 */
+	@Override
+	public final void close() {
+		if (!closed) {
+			closed = true;
+			handleClose();
+		}
+	}
 }