primary
IndexDeletionPolicy
PersistentSnapshotDeletionPolicy
IndexDeletionPolicy
that wraps any other IndexDeletionPolicy
and adds the
ability to hold and later release snapshots of an index. While a snapshot is held, the IndexWriter
will not remove any files associated with it even if the index is otherwise being
actively, arbitrarily changed. Because we wrap another arbitrary IndexDeletionPolicy
,
this gives you the freedom to continue using whatever IndexDeletionPolicy
you would
normally want to use with your index.
This class maintains all snapshots in-memory, and so the information is not persisted and not
protected against system failures. If persistence is important, you can use PersistentSnapshotDeletionPolicy
.
private class
IndexCommit
and prevents it from being deleted.protected final Map<Long,IndexCommit>
private boolean
protected IndexCommit
IndexCommit
.private final IndexDeletionPolicy
IndexDeletionPolicy
getIndexCommit(long gen)
IndexCommit
from its generation; returns null if this IndexCommit is not
currently snapshottedint
protected void
incRef(IndexCommit ic)
IndexCommit
.void
onCommit(List<? extends IndexCommit> commits)
void
onInit(List<? extends IndexCommit> commits)
void
release(IndexCommit commit)
protected void
releaseGen(long gen)
snapshot()
private List<IndexCommit>
wrapCommits(List<? extends IndexCommit> commits)
IndexCommit
as a SnapshotDeletionPolicy.SnapshotCommitPoint
.IndexDeletionPolicy
IndexCommit
.IndexDeletionPolicy
to wrap.IndexDeletionPolicy
The policy may now choose to delete old commit points by calling method delete()
of IndexCommit
.
This method is only called when IndexWriter.commit()
or IndexWriter.close()
is
called, or possibly not at all if the IndexWriter.rollback()
is called.
Note: the last CommitPoint is the most recent one, i.e. the "front index state". Be careful not to delete it, unless you know for sure what you are doing, and unless you can afford to lose the index content while doing that.
onCommit
in class IndexDeletionPolicy
commits
- List of IndexCommit
, sorted by age (the 0th one is the oldest commit).IOException
IndexDeletionPolicy
The writer locates all index commits present in the index directory and calls this method.
The policy may choose to delete some of the commit points, doing so by calling method delete()
of IndexCommit
.
Note: the last CommitPoint is the most recent one, i.e. the "front index state". Be careful not to delete it, unless you know for sure what you are doing, and unless you can afford to lose the index content while doing that.
onInit
in class IndexDeletionPolicy
commits
- List of current point-in-time commits
, sorted by age (the
0th one is the oldest commit). Note that for a new index this method is invoked with an
empty list.IOException
commit
- the commit previously returned by snapshot()
IOException
IOException
IndexCommit
.IndexDeletionPolicy
is used). The snapshot can be removed by
calling release(IndexCommit)
followed by a call to IndexWriter.deleteUnusedFiles()
.
NOTE: while the snapshot is held, the files it references will not be deleted, which will consume additional disk space in your index. If you take a snapshot at a particularly bad time (say just before you call forceMerge) then in the worst case this could consume an extra 1X of your total index size, until you release the snapshot.
IndexCommit
that was snapshotted.IllegalStateException
- if this index does not have any commits yetIOException
IndexCommit
from its generation; returns null if this IndexCommit is not
currently snapshottedIndexCommit
as a SnapshotDeletionPolicy.SnapshotCommitPoint
.