package org.apache.solr.request.uninverted;
import java.io.IOException;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.SegmentReader;
import org.apache.lucene.util.OpenBitSet;
import org.apache.solr.common.util.NamedList;
import org.apache.solr.handler.component.StatsValues;
import org.apache.solr.request.BlockBufferPool.BlockArray;
import org.apache.solr.request.uninverted.RamDocValue.DocValueReadInterface;
import org.apache.solr.request.uninverted.UnInvertedFieldUtils.FieldDatatype;
import org.apache.solr.schema.FieldType;
import org.apache.solr.schema.IndexSchema;
import org.apache.solr.schema.SchemaField;
import org.apache.solr.schema.TrieField;
import org.apache.solr.search.BitDocSet;
import org.apache.solr.search.DocSet;
import org.apache.solr.search.SolrIndexSearcher;
public class UnInvertedFieldBase implements GrobalCache.ILruMemSizeCache {
// public static Logger log = LoggerFactory.getLogger(UnInvertedFieldBase.class);
public AtomicInteger refCnt = new AtomicInteger(0);
public UnInvertedFieldUtils.FieldDatatype fieldDataType = UnInvertedFieldUtils.FieldDatatype.d_default;
public String field;
public FieldType ft;
public TermIndex ti;
public RamDocValue ramDocValue =null;
//mark history
public BitDocSet bits;
//read current
public BitDocSet baseAdvanceDocs = null;
private boolean isShutDown = false;
public boolean isShutDown() {
return isShutDown;
}
public boolean isMultiValued = false;
public boolean isNullField = false;
public DocValueReadInterface tnr;
public void init(String field, IndexReader reader,IndexSchema schema) throws IOException
{
this.bits = new BitDocSet(new OpenBitSet(reader.maxDoc()));
this.field = field;
FieldType schemaft=schema.getFieldType(field);
String prefix=TrieField.getMainValuePrefix(schemaft);
SchemaField sf = schema.getField(field);
this.ft = sf.getType();
this.isMultiValued = this.ft.isMultiValued();
this.fieldDataType = UnInvertedFieldUtils.getDataType(this.ft);
this.ramDocValue=new RamDocValue(this.fieldDataType);
this.ti = new TermIndex(field, prefix);
}
public void setTmValueDouble(int tm, double val) {
// log.info("setTmValueDouble "+tm+","+val);
this.ramDocValue.tmValue.termValueDouble.set(tm, val);
}
public void setTmValueLong(int tm, long val) {
// log.info("setTmValueLong "+tm+","+val);
this.ramDocValue.tmValue.termValueLong.set(tm, val);
}
public BlockArray<Double> getTmValueDouble() {
return this.ramDocValue.tmValue.termValueDouble;
}
public BlockArray<Long> getTmValueLong() {
return this.ramDocValue.tmValue.termValueLong;
}
public void markDocTm(int doc, int termNum, boolean isinit)
throws IOException {
if (isinit) {
this.ramDocValue.index.set(doc, termNum);
} else {
this.tnr.setTermNum(doc, termNum);
}
}
public void startRamDocValue(int maxDoc, IndexReader reader,
boolean isReadDouble) {
ramDocValue.startInitValue(maxDoc, reader, isReadDouble);
}
public void endRamDocValue(boolean isReadDouble, int maxTermNum) {
this.ramDocValue.endInitValue(isReadDouble, maxTermNum);
}
public boolean checkEmpty() throws IOException {
if (this.field.indexOf("higoempty_") >= 0) {
this.isNullField = true;
}
if (this.isNullField) {
this.tnr = this.ramDocValue.getDocReaderNull();
return true;
}
if(this.isMultiValued)
{
throw new IOException("unsupport MultiValued");
}
return false;
}
public TermNumEnumerator getTi(SolrIndexSearcher searcher)
throws IOException {
return ti.getEnumerator(searcher.getReader());
}
public TermNumEnumerator getTi(SegmentReader reader) throws IOException {
return ti.getEnumerator(reader);
}
public int getNullTm() {
return this.ramDocValue.tmValue.nullTermNum;
}
public Integer termNum(int doc) throws IOException {
return this.tnr.termNum(doc, this.getNullTm());
}
// group by
public String tNumToString(int tnum, FieldType ft, TermNumEnumerator te,
String def) throws IOException {
String rtn= this.tnr.tNumToString(tnum, ft, te, def);
return rtn;
}
// sum,dist
public double quickToDouble(int doc, FieldType ft, TermNumEnumerator te)
throws IOException {
try{
return this.tnr.quickToDouble(doc, ft, te);
}catch(Throwable e)
{
return RamTermNumValue.TERMNUM_NAN_VALUE;
}
}
public int getTermNum(TermNumEnumerator te, String text, FieldType ft)
throws IOException {
//TODO ----这个地方显得多余，之后考虑注释掉 在试试 ----
if ((text.startsWith("_") || text.startsWith("null"))&& !this.fieldDataType.equals(FieldDatatype.d_string)) {
return this.getNullTm();
}
if (te.skipTo(ft.toInternal(text))) {
return te.getTermNumber();
} else {
return this.getNullTm();
}
}
@Override
public String toString() {
return "{field=" + field + ",memSize=" + (memSize() * 1.0 / 1024 / 1024) + "mb" + ",nullTermNum=" + this.getNullTm() + this.ramDocValue.toString() +",bits.size="+this.bits.size()+ "}";
}
private void freeMem() {
if (isShutDown) {
return;
}
isShutDown = true;
this.ramDocValue.free();
}
public void LRUclean() {
if (this.refCnt.get() == 0) {
this.freeMem();
}
}
protected void finalize() throws Throwable {
super.finalize();
this.freeMem();
}
long sz = -1;
public synchronized long memSize() {
if (sz > 0) {
return sz;
}
sz = 8 * 8 + 32; // local fields
if (bits != null)
sz += bits.memSize();
if (baseAdvanceDocs != null)
sz += baseAdvanceDocs.memSize();
sz += ramDocValue.getmemsize();
sz += ti.memSize();
return sz;
}
/**
* 旧的solr接口，已经废弃
*/
public NamedList getCounts(SolrIndexSearcher searcher, DocSet baseDocs,
int offset, int limit, Integer mincount, boolean missing,
String sort, String prefix, Boolean returnPair, boolean isRow)
throws IOException {
return new NamedList();
}
/**
* 旧的solr接口，已经废弃
*/
public StatsValues getStats(SolrIndexSearcher searcher, DocSet baseDocs,
String[] facet) throws IOException {
return null;
}
}