org.apache.lucene.index.TermState Java Examples

private TermContext adjustTTF(TermContext termContext, long sumTTF) {
    if (sumTTF == -1 && termContext.totalTermFreq() == -1) {
        return termContext;
    }
    TermContext newTermContext = new TermContext(termContext.topReaderContext);
    List<LeafReaderContext> leaves = termContext.topReaderContext.leaves();
    final int len;
    if (leaves == null) {
        len = 1;
    } else {
        len = leaves.size();
    }
    int df = termContext.docFreq();
    long ttf = sumTTF;
    for (int i = 0; i < len; i++) {
        TermState termState = termContext.get(i);
        if (termState == null) {
            continue;
        }
        newTermContext.register(termState, i, df, ttf);
        df = 0;
        ttf = 0;
    }
    return newTermContext;
}
 

@Override
public void seekExact(BytesRef target, TermState otherState) {
  // if (DEBUG) {
  //   System.out.println("BTTR.seekExact termState seg=" + segment + " target=" + target.utf8ToString() + " " + target + " state=" + otherState);
  // }
  assert clearEOF();
  if (target.compareTo(term) != 0 || !termExists) {
    assert otherState != null && otherState instanceof BlockTermState;
    currentFrame = staticFrame;
    currentFrame.state.copyFrom(otherState);
    term.copyBytes(target);
    currentFrame.metaDataUpto = currentFrame.getTermBlockOrd();
    assert currentFrame.metaDataUpto > 0;
    validIndexPrefix = 0;
  } else {
    // if (DEBUG) {
    //   System.out.println("  skip seek: already on target state=" + currentFrame.state);
    // }
  }
}
 

/** Try to collect terms from the given terms enum and return count=sum(df) for terms visited so far
 *  or (-count - 1) if this should be rewritten into a boolean query.
 *  The termEnum will already be positioned on the next term if not exhausted.
 */
private long collectTerms(LeafReaderContext context, TermsEnum termsEnum, List<TermAndState> terms) throws IOException {
  long count = 0;
  final int threshold = Math.min(BOOLEAN_REWRITE_TERM_COUNT_THRESHOLD, IndexSearcher.getMaxClauseCount());
  for (int i = 0; i < threshold; ++i) {
    final BytesRef term = termsEnum.next();
    if (term == null) {
      return -count - 1;
    }
    TermState state = termsEnum.termState();
    int df = termsEnum.docFreq();
    count += df;
    terms.add(new TermAndState(BytesRef.deepCopyOf(term), state, df, termsEnum.totalTermFreq()));
  }
  return termsEnum.next() == null ? (-count - 1) : count;
}
 

private static TermStates adjustFrequencies(IndexReaderContext readerContext,
                                            TermStates ctx, int artificialDf, long artificialTtf) throws IOException {
  List<LeafReaderContext> leaves = readerContext.leaves();
  final int len;
  if (leaves == null) {
    len = 1;
  } else {
    len = leaves.size();
  }
  TermStates newCtx = new TermStates(readerContext);
  for (int i = 0; i < len; ++i) {
    TermState termState = ctx.get(leaves.get(i));
    if (termState == null) {
      continue;
    }
    newCtx.register(termState, i);
  }
  newCtx.accumulateStatistics(artificialDf, artificialTtf);
  return newCtx;
}
 

@Override
public void seekExact(BytesRef target, TermState otherState) {
  // if (DEBUG) {
  //   System.out.println("BTTR.seekExact termState seg=" + segment + " target=" + target.utf8ToString() + " " + target + " state=" + otherState);
  // }
  assert clearEOF();
  if (target.compareTo(term.get()) != 0 || !termExists) {
    assert otherState != null && otherState instanceof BlockTermState;
    BlockTermState blockState = (BlockTermState) otherState;
    currentFrame = staticFrame;
    currentFrame.state.copyFrom(otherState);
    term.copyBytes(target);
    currentFrame.metaDataUpto = currentFrame.getTermBlockOrd();
    currentFrame.termOrd = blockState.ord+1;
    assert currentFrame.metaDataUpto > 0;
    validIndexPrefix = 0;
  } else {
    // if (DEBUG) {
    //   System.out.println("  skip seek: already on target state=" + currentFrame.state);
    // }
  }
  positioned = true;
}
 

@Override
public void seekExact(BytesRef target, TermState otherState) {
  // if (DEBUG) {
  //   System.out.println("BTTR.seekExact termState seg=" + segment + " target=" + target.utf8ToString() + " " + target + " state=" + otherState);
  // }
  assert clearEOF();
  if (target.compareTo(term.get()) != 0 || !termExists) {
    assert otherState != null && otherState instanceof BlockTermState;
    currentFrame = staticFrame;
    currentFrame.state.copyFrom(otherState);
    term.copyBytes(target);
    currentFrame.metaDataUpto = currentFrame.getTermBlockOrd();
    assert currentFrame.metaDataUpto > 0;
    validIndexPrefix = 0;
  } else {
    // if (DEBUG) {
    //   System.out.println("  skip seek: already on target state=" + currentFrame.state);
    // }
  }
}
 

@Override
public void seekExact(BytesRef target, TermState otherState) {
  // if (DEBUG) {
  //   System.out.println("BTTR.seekExact termState seg=" + segment + " target=" + target.utf8ToString() + " " + target + " state=" + otherState);
  // }
  assert clearEOF();
  if (target.compareTo(term.get()) != 0 || !termExists) {
    assert otherState != null && otherState instanceof BlockTermState;
    currentFrame = staticFrame;
    currentFrame.state.copyFrom(otherState);
    term.copyBytes(target);
    currentFrame.metaDataUpto = currentFrame.getTermBlockOrd();
    assert currentFrame.metaDataUpto > 0;
    validIndexPrefix = 0;
  } else {
    // if (DEBUG) {
    //   System.out.println("  skip seek: already on target state=" + currentFrame.state);
    // }
  }
}
 

@Override
public TermState termState() throws IOException {
  assert !eof;
  currentFrame.decodeMetaData();
  TermState ts = currentFrame.state.clone();
  //if (DEBUG) System.out.println("BTTR.termState seg=" + segment + " state=" + ts);
  return ts;
}
 

@Override
public TermState termState() throws IOException {
  assert !eof;
  currentFrame.decodeMetaData();
  TermState ts = currentFrame.state.clone();
  //if (DEBUG) System.out.println("BTTR.termState seg=" + segment + " state=" + ts);
  return ts;
}
 

@Override
public void copyFrom(TermState _other) {
  super.copyFrom(_other);
  IntBlockTermState other = (IntBlockTermState) _other;
  docStartFP = other.docStartFP;
  posStartFP = other.posStartFP;
  payStartFP = other.payStartFP;
  lastPosBlockOffset = other.lastPosBlockOffset;
  skipOffset = other.skipOffset;
  singletonDocID = other.singletonDocID;
}
 

@Override
public void copyFrom(TermState _other) {
  super.copyFrom(_other);
  IntBlockTermState other = (IntBlockTermState) _other;
  docStartFP = other.docStartFP;
  posStartFP = other.posStartFP;
  payStartFP = other.payStartFP;
  lastPosBlockOffset = other.lastPosBlockOffset;
  skipOffset = other.skipOffset;
  singletonDocID = other.singletonDocID;
}
 

@Override
public void copyFrom(TermState _other) {
  assert _other instanceof BlockTermState : "can not copy from " + _other.getClass().getName();
  BlockTermState other = (BlockTermState) _other;
  super.copyFrom(_other);
  docFreq = other.docFreq;
  totalTermFreq = other.totalTermFreq;
  termBlockOrd = other.termBlockOrd;
  blockFilePointer = other.blockFilePointer;
}
 

@Override
public TermState termState() throws IOException {
  assert !eof;
  currentFrame.decodeMetaData();
  TermState ts = currentFrame.state.clone();
  //if (DEBUG) System.out.println("BTTR.termState seg=" + segment + " state=" + ts);
  return ts;
}
 

@Override
public void copyFrom(TermState _other) {
  super.copyFrom(_other);
  IDVersionTermState other = (IDVersionTermState) _other;
  idVersion = other.idVersion;
  docID = other.docID;
}
 

private static TermContext adjustDF(TermContext ctx, int newDocFreq) {
    // Use a value of ttf that is consistent with the doc freq (ie. gte)
    long newTTF;
    if (ctx.totalTermFreq() < 0) {
        newTTF = -1;
    } else {
        newTTF = Math.max(ctx.totalTermFreq(), newDocFreq);
    }
    List<LeafReaderContext> leaves = ctx.topReaderContext.leaves();
    final int len;
    if (leaves == null) {
        len = 1;
    } else {
        len = leaves.size();
    }
    TermContext newCtx = new TermContext(ctx.topReaderContext);
    for (int i = 0; i < len; ++i) {
        TermState termState = ctx.get(i);
        if (termState == null) {
            continue;
        }
        newCtx.register(termState, i, newDocFreq, newTTF);
        newDocFreq = 0;
        newTTF = 0;
    }
    return newCtx;
}
 

@Override
public TermState termState() throws IOException {
  assert !eof;
  currentFrame.decodeMetaData();
  BlockTermState ts = (BlockTermState) currentFrame.state.clone();
  assert currentFrame.termOrd > 0;
  ts.ord = currentFrame.termOrd-1;
  //if (DEBUG) System.out.println("BTTR.termState seg=" + segment + " state=" + ts);
  return ts;
}
 

@Override
public TermState termState() throws IOException {
  //System.out.println("BTR.termState this=" + this);
  decodeMetaData();
  TermState ts = state.clone();
  //System.out.println("  return ts=" + ts);
  return ts;
}
 

@Override
public void seekExact(BytesRef target, TermState otherState) {
  //System.out.println("BTR.seekExact termState target=" + target.utf8ToString() + " " + target + " this=" + this);
  assert otherState != null && otherState instanceof BlockTermState;
  assert !doOrd || ((BlockTermState) otherState).ord < numTerms;
  state.copyFrom(otherState);
  seekPending = true;
  indexIsCurrent = false;
  term.copyBytes(target);
}
 

@Override
public void seekExact(BytesRef target, TermState otherState) {
  if (!target.equals(term)) {
    state.copyFrom(otherState);
    term = BytesRef.deepCopyOf(target);
    seekPending = true;
  }
}
 

@Override
public void seekExact(BytesRef term, TermState state) throws IOException {
  te.seekExact(term, state);
}
 

@Override
public void seekExact(BytesRef term, TermState state) throws IOException {
  termOrd = (int) ((OrdTermState) state).ord;
  setTerm();
  assert term.equals(scratch);
}
 

TermAndState(BytesRef term, TermState state, int docFreq, long totalTermFreq) {
  this.term = term;
  this.state = state;
  this.docFreq = docFreq;
  this.totalTermFreq = totalTermFreq;
}
 

@Override
public TermState termState() {
  OrdTermState state = new OrdTermState();
  state.ord = termOrd;
  return state;
}
 

@Override
public void seekExact(BytesRef term, TermState state) throws IOException {
  actualEnum.seekExact(term, state);
}
 

@Override
public TermState termState() throws IOException {
  return actualEnum.termState();
}
 

@Override
public TermState termState() throws IOException {
  currentFrame.decodeMetaData();
  return currentFrame.termState.clone();
}
 

@Override
public TermState termState() throws IOException {
  return te.termState();
}
 

TermAndState(BytesRef term, TermState state, int docFreq, long totalTermFreq) {
  this.term = term;
  this.state = state;
  this.docFreq = docFreq;
  this.totalTermFreq = totalTermFreq;
}
 

@Override
public TermState termState() throws IOException {
  decodeMetaData();
  return state.clone();
}
 

@Override
public TermState termState() throws IOException {
  currentFrame.decodeMetaData();
  return currentFrame.termState.clone();
}