SegmentState(ReadersAndUpdates rld, IOUtils.IOConsumer<ReadersAndUpdates> onClose, SegmentCommitInfo info) throws IOException { this.rld = rld; reader = rld.getReader(IOContext.READ); startDelCount = rld.getDelCount(); delGen = info.getBufferedDeletesGen(); this.onClose = onClose; }
if (readerPool.isReaderPoolingEnabled() && mergedSegmentWarmer != null) { final ReadersAndUpdates rld = getPooledInstance(merge.info, true); final SegmentReader sr = rld.getReader(IOContext.READ); try { mergedSegmentWarmer.warm(sr);
public synchronized boolean delete(int docID) throws IOException { if (reader == null && pendingDeletes.mustInitOnDelete()) { getReader(IOContext.READ).decRef(); // pass a reader to initialize the pending deletes } return pendingDeletes.delete(docID); }
if (readerPool.isReaderPoolingEnabled() && mergedSegmentWarmer != null) { final ReadersAndUpdates rld = getPooledInstance(merge.info, true); final SegmentReader sr = rld.getReader(IOContext.READ); try { mergedSegmentWarmer.warm(sr);
/** Returns a reader for merge, with the latest doc values updates and deletions. */ synchronized MergeReader getReaderForMerge(IOContext context) throws IOException { // We must carry over any still-pending DV updates because they were not // successfully written, e.g. because there was a hole in the delGens, // or they arrived after we wrote all DVs for merge but before we set // isMerging here: for (Map.Entry<String, List<DocValuesFieldUpdates>> ent : pendingDVUpdates.entrySet()) { List<DocValuesFieldUpdates> mergingUpdates = mergingDVUpdates.get(ent.getKey()); if (mergingUpdates == null) { mergingUpdates = new ArrayList<>(); mergingDVUpdates.put(ent.getKey(), mergingUpdates); } mergingUpdates.addAll(ent.getValue()); } SegmentReader reader = getReader(context); if (pendingDeletes.needsRefresh(reader)) { // beware of zombies: assert pendingDeletes.getLiveDocs() != null; reader = createNewReaderWithLatestLiveDocs(reader); } assert pendingDeletes.verifyDocCounts(reader); return new MergeReader(reader, pendingDeletes.getHardLiveDocs()); }
if (poolReaders && mergedSegmentWarmer != null) { final ReadersAndUpdates rld = readerPool.get(merge.info, true); final SegmentReader sr = rld.getReader(IOContext.READ); try { mergedSegmentWarmer.warm(sr);
private synchronized CodecReader getLatestReader() throws IOException { if (this.reader == null) { // get a reader and dec the ref right away we just make sure we have a reader getReader(IOContext.READ).decRef(); } if (pendingDeletes.needsRefresh(reader)) { // we have a reader but its live-docs are out of sync. let's create a temporary one that we never share swapNewReaderWithLatestLiveDocs(); } return reader; }
if (poolReaders && mergedSegmentWarmer != null) { final ReadersAndUpdates rld = readerPool.get(merge.info, true); final SegmentReader sr = rld.getReader(IOContext.READ); try { mergedSegmentWarmer.warm(sr);
/** * Returns a ref to a clone. NOTE: you should decRef() the reader when you're * done (ie do not call close()). */ public synchronized SegmentReader getReadOnlyClone(IOContext context) throws IOException { if (reader == null) { getReader(context).decRef(); assert reader != null; } // force new liveDocs Bits liveDocs = pendingDeletes.getLiveDocs(); if (liveDocs != null) { return new SegmentReader(info, reader, liveDocs, pendingDeletes.getHardLiveDocs(), pendingDeletes.numDocs(), true); } else { // liveDocs == null and reader != null. That can only be if there are no deletes assert reader.getLiveDocs() == null; reader.incRef(); return reader; } }
/** * Returns a reader for merge. This method applies field updates if there are * any and marks that this segment is currently merging. */ synchronized SegmentReader getReaderForMerge(IOContext context) throws IOException { assert Thread.holdsLock(writer); // must execute these two statements as atomic operation, otherwise we // could lose updates if e.g. another thread calls writeFieldUpdates in // between, or the updates are applied to the obtained reader, but then // re-applied in IW.commitMergedDeletes (unnecessary work and potential // bugs). isMerging = true; return getReader(context); }
/** * Returns a reader for merge. This method applies field updates if there are * any and marks that this segment is currently merging. */ synchronized SegmentReader getReaderForMerge(IOContext context) throws IOException { assert Thread.holdsLock(writer); // must execute these two statements as atomic operation, otherwise we // could lose updates if e.g. another thread calls writeFieldUpdates in // between, or the updates are applied to the obtained reader, but then // re-applied in IW.commitMergedDeletes (unnecessary work and potential // bugs). isMerging = true; return getReader(context); }
SegmentState(ReadersAndUpdates rld, IOUtils.IOConsumer<ReadersAndUpdates> onClose, SegmentCommitInfo info) throws IOException { this.rld = rld; reader = rld.getReader(IOContext.READ); startDelCount = rld.getDelCount(); delGen = info.getBufferedDeletesGen(); this.onClose = onClose; }
public SegmentState(IndexWriter.ReaderPool pool, SegmentCommitInfo info) throws IOException { rld = pool.get(info, true); startDelCount = rld.getPendingDeleteCount(); reader = rld.getReader(IOContext.READ); delGen = info.getBufferedDeletesGen(); }
/** Returns a reader for merge, with the latest doc values updates and deletions. */ synchronized MergeReader getReaderForMerge(IOContext context) throws IOException { // We must carry over any still-pending DV updates because they were not // successfully written, e.g. because there was a hole in the delGens, // or they arrived after we wrote all DVs for merge but before we set // isMerging here: for (Map.Entry<String, List<DocValuesFieldUpdates>> ent : pendingDVUpdates.entrySet()) { List<DocValuesFieldUpdates> mergingUpdates = mergingDVUpdates.get(ent.getKey()); if (mergingUpdates == null) { mergingUpdates = new ArrayList<>(); mergingDVUpdates.put(ent.getKey(), mergingUpdates); } mergingUpdates.addAll(ent.getValue()); } SegmentReader reader = getReader(context); if (pendingDeletes.needsRefresh(reader)) { // beware of zombies: assert pendingDeletes.getLiveDocs() != null; reader = createNewReaderWithLatestLiveDocs(reader); } assert pendingDeletes.verifyDocCounts(reader); return new MergeReader(reader, pendingDeletes.getHardLiveDocs()); }
public synchronized boolean delete(int docID) throws IOException { if (reader == null && pendingDeletes.mustInitOnDelete()) { getReader(IOContext.READ).decRef(); // pass a reader to initialize the pending deletes } return pendingDeletes.delete(docID); }
private synchronized CodecReader getLatestReader() throws IOException { if (this.reader == null) { // get a reader and dec the ref right away we just make sure we have a reader getReader(IOContext.READ).decRef(); } if (pendingDeletes.needsRefresh(reader)) { // we have a reader but its live-docs are out of sync. let's create a temporary one that we never share swapNewReaderWithLatestLiveDocs(); } return reader; }
public SegmentState(IndexWriter.ReaderPool pool, SegmentCommitInfo info) throws IOException { rld = pool.get(info, true); startDelCount = rld.getPendingDeleteCount(); reader = rld.getReader(IOContext.READ); delGen = info.getBufferedDeletesGen(); }
/** * Returns a ref to a clone. NOTE: you should decRef() the reader when you're * done (ie do not call close()). */ public synchronized SegmentReader getReadOnlyClone(IOContext context) throws IOException { if (reader == null) { getReader(context).decRef(); assert reader != null; } // force new liveDocs in initWritableLiveDocs even if it's null liveDocsShared = true; if (liveDocs != null) { return new SegmentReader(reader.getSegmentInfo(), reader, liveDocs, info.info.maxDoc() - info.getDelCount() - pendingDeleteCount); } else { // liveDocs == null and reader != null. That can only be if there are no deletes assert reader.getLiveDocs() == null; reader.incRef(); return reader; } }
/** * Returns a ref to a clone. NOTE: you should decRef() the reader when you're * done (ie do not call close()). */ public synchronized SegmentReader getReadOnlyClone(IOContext context) throws IOException { if (reader == null) { getReader(context).decRef(); assert reader != null; } // force new liveDocs Bits liveDocs = pendingDeletes.getLiveDocs(); if (liveDocs != null) { return new SegmentReader(info, reader, liveDocs, pendingDeletes.getHardLiveDocs(), pendingDeletes.numDocs(), true); } else { // liveDocs == null and reader != null. That can only be if there are no deletes assert reader.getLiveDocs() == null; reader.incRef(); return reader; } }
/** * Returns a ref to a clone. NOTE: you should decRef() the reader when you're * done (ie do not call close()). */ public synchronized SegmentReader getReadOnlyClone(IOContext context) throws IOException { if (reader == null) { getReader(context).decRef(); assert reader != null; } // force new liveDocs in initWritableLiveDocs even if it's null liveDocsShared = true; if (liveDocs != null) { return new SegmentReader(reader.getSegmentInfo(), reader, liveDocs, info.info.maxDoc() - info.getDelCount() - pendingDeleteCount); } else { // liveDocs == null and reader != null. That can only be if there are no deletes assert reader.getLiveDocs() == null; reader.incRef(); return reader; } }