/** Returns if the given segment should be upgraded. The default implementation * will return {@code !Version.LATEST.equals(si.getVersion())}, * so all segments created with a different version number than this Lucene version will * get upgraded. */ protected boolean shouldUpgradeSegment(SegmentCommitInfo si) { return !Version.LATEST.equals(si.info.getVersion()); }
/** Confirms that the incoming index sort (if any) matches the existing index sort (if any). * This is unfortunately just best effort, because it could be the old index only has unsorted flushed segments built * before {@link Version#LUCENE_6_5_0} (flushed segments are sorted in Lucene 7.0). */ private void validateIndexSort() throws CorruptIndexException { Sort indexSort = config.getIndexSort(); if (indexSort != null) { for(SegmentCommitInfo info : segmentInfos) { Sort segmentIndexSort = info.info.getIndexSort(); if (segmentIndexSort != null && indexSort.equals(segmentIndexSort) == false) { throw new IllegalArgumentException("cannot change previous indexSort=" + segmentIndexSort + " (from segment=" + info + ") to new indexSort=" + indexSort); } else if (segmentIndexSort == null && info.info.getVersion().onOrAfter(Version.LUCENE_6_5_0)) { // Flushed segments are not sorted if they were built with a version prior to 6.5.0 throw new CorruptIndexException("segment not sorted with indexSort=" + segmentIndexSort, info.info.toString()); } } } }
private boolean shouldUpgrade(SegmentCommitInfo info) { org.apache.lucene.util.Version old = info.info.getVersion(); org.apache.lucene.util.Version cur = Version.CURRENT.luceneVersion; // Something seriously wrong if this trips: assert old.major <= cur.major; if (cur.major > old.major) { // Always upgrade segment if Lucene's major version is too old return true; } if (upgradeOnlyAncientSegments == false && cur.minor > old.minor) { // If it's only a minor version difference, and we are not upgrading only ancient segments, // also upgrade: return true; } // Version matches, or segment is not ancient and we are only upgrading ancient segments: return false; }
String oldSegs = null; for (SegmentCommitInfo si : sis) { Version version = si.info.getVersion(); if (version == null) { segInfoStat.maxDoc = info.info.maxDoc(); final Version version = info.info.getVersion(); if (info.info.maxDoc() <= 0) { throw new RuntimeException("illegal number of documents: maxDoc=" + info.info.maxDoc());
Version segmentVersion = siPerCommit.info.getVersion(); if (minSegmentVersion == null || segmentVersion.onOrAfter(minSegmentVersion) == false) { minSegmentVersion = segmentVersion;
SegmentInfo newInfo = new SegmentInfo(directoryOrig, info.info.getVersion(), info.info.getMinVersion(), segName, info.info.maxDoc(), info.info.getUseCompoundFile(), info.info.getCodec(), info.info.getDiagnostics(), info.info.getId(), info.info.getAttributes(), info.info.getIndexSort());
si.getId(), ""); Version version = si.getVersion(); if (version.major < 7) { throw new IllegalArgumentException("invalid major version: should be >= 7 but got: " + version.major + " segment=" + si);
infos.add(siPerCommit); Version segmentVersion = info.getVersion();
final Version version = info.info.getVersion(); if (version == null) {
private void fillSegmentInfo(SegmentReader segmentReader, boolean verbose, boolean search, Map<String, Segment> segments) { SegmentCommitInfo info = segmentReader.getSegmentInfo(); assert segments.containsKey(info.info.name) == false; Segment segment = new Segment(info.info.name); segment.search = search; segment.docCount = segmentReader.numDocs(); segment.delDocCount = segmentReader.numDeletedDocs(); segment.version = info.info.getVersion(); segment.compound = info.info.getUseCompoundFile(); try { segment.sizeInBytes = info.sizeInBytes(); } catch (IOException e) { logger.trace(() -> new ParameterizedMessage("failed to get size for [{}]", info.info.name), e); } segment.memoryInBytes = segmentReader.ramBytesUsed(); segment.segmentSort = info.info.getIndexSort(); if (verbose) { segment.ramTree = Accountables.namedAccountable("root", segmentReader); } segment.attributes = info.info.getAttributes(); // TODO: add more fine grained mem stats values to per segment info here segments.put(info.info.name, segment); }
segment.docCount = info.info.maxDoc(); segment.delDocCount = info.getDelCount(); segment.version = info.info.getVersion(); segment.compound = info.info.getUseCompoundFile(); try {
private boolean shouldUpgrade(SegmentCommitInfo info) { org.apache.lucene.util.Version old = info.info.getVersion(); org.apache.lucene.util.Version cur = Version.CURRENT.luceneVersion; // Something seriously wrong if this trips: assert old.major <= cur.major; if (cur.major > old.major) { // Always upgrade segment if Lucene's major version is too old return true; } if (upgradeOnlyAncientSegments == false && cur.minor > old.minor) { // If it's only a minor version difference, and we are not upgrading only ancient segments, // also upgrade: return true; } // Version matches, or segment is not ancient and we are only upgrading ancient segments: return false; }
private boolean shouldUpgrade(SegmentCommitInfo info) { org.apache.lucene.util.Version old = info.info.getVersion(); org.apache.lucene.util.Version cur = Version.CURRENT.luceneVersion; // Something seriously wrong if this trips: assert old.major <= cur.major; if (cur.major > old.major) { // Always upgrade segment if Lucene's major version is too old return true; } if (upgradeOnlyAncientSegments == false && cur.minor > old.minor) { // If it's only a minor version difference, and we are not upgrading only ancient segments, // also upgrade: return true; } // Version matches, or segment is not ancient and we are only upgrading ancient segments: return false; }
private boolean shouldUpgrade(SegmentCommitInfo info) { org.apache.lucene.util.Version old = info.info.getVersion(); org.apache.lucene.util.Version cur = Version.CURRENT.luceneVersion; // Something seriously wrong if this trips: assert old.major <= cur.major; if (cur.major > old.major) { // Always upgrade segment if Lucene's major version is too old return true; } if (upgradeOnlyAncientSegments == false && cur.minor > old.minor) { // If it's only a minor version difference, and we are not upgrading only ancient segments, // also upgrade: return true; } // Version matches, or segment is not ancient and we are only upgrading ancient segments: return false; }
private boolean shouldUpgrade(SegmentCommitInfo info) { org.apache.lucene.util.Version old = info.info.getVersion(); org.apache.lucene.util.Version cur = Version.CURRENT.luceneVersion; // Something seriously wrong if this trips: assert old.major <= cur.major; if (cur.major > old.major) { // Always upgrade segment if Lucene's major version is too old return true; } if (upgradeOnlyAncientSegments == false && cur.minor > old.minor) { // If it's only a minor version difference, and we are not upgrading only ancient segments, // also upgrade: return true; } // Version matches, or segment is not ancient and we are only upgrading ancient segments: return false; }
/** Returns if the given segment should be upgraded. The default implementation * will return {@code !Version.LATEST.equals(si.getVersion())}, * so all segments created with a different version number than this Lucene version will * get upgraded. */ protected boolean shouldUpgradeSegment(SegmentCommitInfo si) { return !Version.LATEST.equals(si.info.getVersion()); }
/** Returns if the given segment should be upgraded. The default implementation * will return {@code !Version.LATEST.equals(si.getVersion())}, * so all segments created with a different version number than this Lucene version will * get upgraded. */ protected boolean shouldUpgradeSegment(SegmentCommitInfo si) { return !Version.LATEST.equals(si.info.getVersion()); }
/** Returns if the given segment should be upgraded. The default implementation * will return {@code !Version.LATEST.equals(si.getVersion())}, * so all segments created with a different version number than this Lucene version will * get upgraded. */ protected boolean shouldUpgradeSegment(SegmentCommitInfo si) { return !Version.LATEST.equals(si.info.getVersion()); }
/** Confirms that the incoming index sort (if any) matches the existing index sort (if any). * This is unfortunately just best effort, because it could be the old index only has unsorted flushed segments built * before {@link Version#LUCENE_6_5_0} (flushed segments are sorted in Lucene 7.0). */ private void validateIndexSort() throws CorruptIndexException { Sort indexSort = config.getIndexSort(); if (indexSort != null) { for(SegmentCommitInfo info : segmentInfos) { Sort segmentIndexSort = info.info.getIndexSort(); if (segmentIndexSort != null && indexSort.equals(segmentIndexSort) == false) { throw new IllegalArgumentException("cannot change previous indexSort=" + segmentIndexSort + " (from segment=" + info + ") to new indexSort=" + indexSort); } else if (segmentIndexSort == null && info.info.getVersion().onOrAfter(Version.LUCENE_6_5_0)) { // Flushed segments are not sorted if they were built with a version prior to 6.5.0 throw new CorruptIndexException("segment not sorted with indexSort=" + segmentIndexSort, info.info.toString()); } } } }
private void upgradeIndex(Directory dir) throws IOException { boolean doUpgrade = false; String lastSegmentsFile = SegmentInfos.getLastCommitSegmentsFileName(dir.listAll()); SegmentInfos sis = SegmentInfos.readCommit(dir, lastSegmentsFile); for (SegmentCommitInfo commit : sis) { if (!commit.info.getVersion().equals(Version.LATEST)) { logInfo("Found Index version %s", commit.info.getVersion().toString()); doUpgrade = true; break; } } if (doUpgrade) { logInfo("Upgrading index to %s", Version.LATEST.toString()); IndexWriterConfig iwc = new IndexWriterConfig(null); new IndexUpgrader(dir, iwc, false).upgrade(); this.writerUpdateTimeMicros = Utils.getNowMicrosUtc(); } }