private static TInfo parseTerm(FunctionQParser fp) throws SyntaxError {
TInfo tinfo = new TInfo();
tinfo.indexedField = tinfo.field = fp.parseArg();
tinfo.val = fp.parseArg();
tinfo.indexedBytes = new BytesRef();
FieldType ft = fp.getReq().getSchema().getFieldTypeNoEx(tinfo.field);
if (ft == null) ft = new StrField();
if (ft instanceof TextField) {
// need to do analysis on the term
String indexedVal = tinfo.val;
Query q =
ft.getFieldQuery(fp, fp.getReq().getSchema().getFieldOrNull(tinfo.field), tinfo.val);
if (q instanceof TermQuery) {
Term term = ((TermQuery) q).getTerm();
tinfo.indexedField = term.field();
indexedVal = term.text();
}
UnicodeUtil.UTF16toUTF8(indexedVal, 0, indexedVal.length(), tinfo.indexedBytes);
} else {
ft.readableToIndexed(tinfo.val, tinfo.indexedBytes);
}
return tinfo;
}
private void postProcessChangeVO(
ChangeVO change, int windowNo, Map<String, String> context, String[] dataRow, UITab tab) {
// make an updated context to get the necessary listboxvos
Map<String, String> contextAfterUpdate = new HashMap<String, String>(context);
int j = 0;
for (UIField field : tab.getFields()) {
contextAfterUpdate.put(field.getColumnName(), dataRow[j]);
j++;
}
// now change rowData to remove password, and reload the changed
// listboxes
j = 0;
for (UIField field : tab.getFields()) {
// return an empty string for passwords etc
if (field.isEncryptedField()
|| field.isEncryptedColumn()
|| "Password".equals(field.getColumnName())) change.rowData[j] = "";
if (FieldType.isClientLookup(field.getAD_Reference_ID()) && field.isDependentValue()) {
if (change.changedDropDowns == null)
change.changedDropDowns = new HashMap<String, ArrayList<NamePair>>();
ArrayList<NamePair> values;
if (field.getAD_Reference_ID() == DisplayTypeConstants.Search) {
ArrayList<String> t = new ArrayList<String>(1);
t.add(context.get(field.getColumnName()));
values = getLookupValueDirect(field.getAD_Field_ID(), t, true);
} else values = getLookupData(windowNo, field.getAD_Field_ID(), context, true);
change.changedDropDowns.put(field.getColumnName(), values);
}
j++;
}
}
/** {@inheritDoc} */
public void setNextReader(LeafReaderContext ctx) throws IOException {
if (valueSource == null) {
// first time we've collected local values, get the right ValueSource
valueSource = (null == ft) ? statsField.getValueSource() : ft.getValueSource(sf, null);
vsContext = ValueSource.newContext(statsField.getSearcher());
}
values = valueSource.getValues(vsContext, ctx);
}
/** {@inheritDoc} */
@Override
public void accumulate(BytesRef value, int count) {
if (null == ft) {
throw new IllegalStateException(
"Can't collect & convert BytesRefs on stats that do't use a a FieldType: " + statsField);
}
T typedValue = (T) ft.toObject(sf, value);
accumulate(typedValue, count);
}
// Creates new field from index in fields TypeArray
private Field newField(int index) {
TypeArray fields = getFields();
short signatureIndex = fields.getShortAt(index + SIGNATURE_INDEX_OFFSET);
FieldType type = new FieldType((Symbol) getConstants().getObjAt(signatureIndex));
if (type.isOop()) {
if (VM.getVM().isCompressedOopsEnabled()) {
return new NarrowOopField(this, index);
} else {
return new OopField(this, index);
}
}
if (type.isByte()) {
return new ByteField(this, index);
}
if (type.isChar()) {
return new CharField(this, index);
}
if (type.isDouble()) {
return new DoubleField(this, index);
}
if (type.isFloat()) {
return new FloatField(this, index);
}
if (type.isInt()) {
return new IntField(this, index);
}
if (type.isLong()) {
return new LongField(this, index);
}
if (type.isShort()) {
return new ShortField(this, index);
}
if (type.isBoolean()) {
return new BooleanField(this, index);
}
throw new RuntimeException("Illegal field type at index " + index);
}
private void visitField(OopVisitor visitor, FieldType type, int index) {
Field f = newField(index);
if (type.isOop()) {
visitor.doOop((OopField) f, false);
return;
}
if (type.isByte()) {
visitor.doByte((ByteField) f, false);
return;
}
if (type.isChar()) {
visitor.doChar((CharField) f, false);
return;
}
if (type.isDouble()) {
visitor.doDouble((DoubleField) f, false);
return;
}
if (type.isFloat()) {
visitor.doFloat((FloatField) f, false);
return;
}
if (type.isInt()) {
visitor.doInt((IntField) f, false);
return;
}
if (type.isLong()) {
visitor.doLong((LongField) f, false);
return;
}
if (type.isShort()) {
visitor.doShort((ShortField) f, false);
return;
}
if (type.isBoolean()) {
visitor.doBoolean((BooleanField) f, false);
return;
}
}
public int searchTabResults(
int WindowNo,
int AD_Tab_ID,
int queryResultID,
int searchResultID,
String query,
int rowCount) {
UITab tab = getTab(AD_Tab_ID);
ArrayList<Integer> ids = new ArrayList<Integer>();
for (UIField field : tab.getFields()) {
if (field.isSelectionColumn()
|| field.isIdentifier() && FieldType.isText(field.getAD_Reference_ID())) {
ids.add(field.getAD_Field_ID());
}
}
return searchTabResults(WindowNo, tab, ids, queryResultID, searchResultID, query, rowCount);
}
protected DirectoryReader indexDocsWithLucene(TestDoc[] testDocs) throws IOException {
Map<String, Analyzer> mapping = new HashMap<String, Analyzer>();
for (TestFieldSetting field : testDocs[0].fieldSettings) {
if (field.storedPayloads) {
mapping.put(
field.name,
new Analyzer() {
@Override
protected TokenStreamComponents createComponents(String fieldName, Reader reader) {
Tokenizer tokenizer = new StandardTokenizer(Version.CURRENT.luceneVersion, reader);
TokenFilter filter = new LowerCaseFilter(Version.CURRENT.luceneVersion, tokenizer);
filter = new TypeAsPayloadTokenFilter(filter);
return new TokenStreamComponents(tokenizer, filter);
}
});
}
}
PerFieldAnalyzerWrapper wrapper =
new PerFieldAnalyzerWrapper(
new StandardAnalyzer(Version.CURRENT.luceneVersion, CharArraySet.EMPTY_SET), mapping);
Directory dir = new RAMDirectory();
IndexWriterConfig conf = new IndexWriterConfig(Version.CURRENT.luceneVersion, wrapper);
conf.setOpenMode(IndexWriterConfig.OpenMode.CREATE);
IndexWriter writer = new IndexWriter(dir, conf);
for (TestDoc doc : testDocs) {
Document d = new Document();
d.add(new Field("id", doc.id, StringField.TYPE_STORED));
for (int i = 0; i < doc.fieldContent.length; i++) {
FieldType type = new FieldType(TextField.TYPE_STORED);
TestFieldSetting fieldSetting = doc.fieldSettings[i];
type.setStoreTermVectorOffsets(fieldSetting.storedOffset);
type.setStoreTermVectorPayloads(fieldSetting.storedPayloads);
type.setStoreTermVectorPositions(
fieldSetting.storedPositions
|| fieldSetting.storedPayloads
|| fieldSetting.storedOffset);
type.setStoreTermVectors(true);
type.freeze();
d.add(new Field(fieldSetting.name, doc.fieldContent[i], type));
}
writer.updateDocument(new Term("id", doc.id), d);
writer.commit();
}
writer.close();
return DirectoryReader.open(dir);
}
public boolean hasField(FieldType fieldType) {
return fields.containsKey(fieldType.getName());
}
public void setNextReader(AtomicReaderContext ctx) throws IOException {
if (valueSource == null) {
valueSource = ft.getValueSource(sf, null);
}
values = valueSource.getValues(qcontext, ctx);
}
/** {@inheritDoc} */
@Override
public void accumulate(BytesRef value, int count) {
T typedValue = (T) ft.toObject(sf, value);
accumulate(typedValue, count);
}
public void sortResults(
int WindowNo, int AD_Tab_ID, int AD_Field_ID, int queryResultID, final boolean ascending) {
class SortCell {
String[] row;
String sort;
}
ArrayList<String[]> results = m_results.get(queryResultID);
if (results == null)
log.severe("cannot sort. results non-existent for queryResultID:" + queryResultID);
UITab tab = getTab(AD_Tab_ID);
final UIField field = getField(AD_Field_ID, WindowNo);
final int displayType = field.getAD_Reference_ID();
final int idx = tab.getFieldIndex(AD_Field_ID);
// if not a lookup, directly sort
if (!field.isLookup()) {
if (FieldType.isNumeric(displayType)) {
Collections.sort(
results,
new Comparator<String[]>() {
@Override
public int compare(String[] o1, String[] o2) {
if (o1[idx] == null) o1[idx] = "";
if (o2[idx] == null) o2[idx] = "";
BigDecimal s1 = new BigDecimal(o1[idx].equals("") ? "-1e-10" : o1[idx]);
BigDecimal s2 = new BigDecimal(o2[idx].equals("") ? "-1e-10" : o2[idx]);
return ascending ? s1.compareTo(s2) : s2.compareTo(s1);
}
});
} else if (FieldType.isDate(displayType)) {
Collections.sort(
results,
new Comparator<String[]>() {
@Override
public int compare(String[] o1, String[] o2) {
if (o1[idx] == null) o1[idx] = "";
if (o2[idx] == null) o2[idx] = "";
Long s1 = new Long(o1[idx].equals("") ? "-1000000" : o1[idx]);
Long s2 = new Long(o2[idx].equals("") ? "-1000000" : o2[idx]);
return ascending ? s1.compareTo(s2) : s2.compareTo(s1);
}
});
} else {
Collections.sort(
results,
new Comparator<String[]>() {
@Override
public int compare(String[] o1, String[] o2) {
if (o1[idx] == null) o1[idx] = "";
if (o2[idx] == null) o2[idx] = "";
String s1 = o1[idx];
String s2 = o2[idx];
return ascending ? s1.compareTo(s2) : s2.compareTo(s1);
}
});
}
return;
}
Comparator<SortCell> c =
new Comparator<SortCell>() {
public int compare(SortCell o1, SortCell o2) {
if (ascending) return o1.sort.compareTo(o2.sort);
else return o2.sort.compareTo(o1.sort);
}
};
// for look up, first get id values
ArrayList<String> fieldValues = new ArrayList<String>(results.size());
for (String[] row : results) {
fieldValues.add(row[idx]);
}
// then translate into real values
ArrayList<String> sorts = getLookupValueOnlyDirect(AD_Field_ID, fieldValues, true);
ArrayList<SortCell> toBeSorteds = new ArrayList<SortCell>(sorts.size());
for (int i = 0; i < sorts.size(); i++) {
SortCell toBeSorted = new SortCell();
toBeSorted.row = results.get(i);
toBeSorted.sort = sorts.get(i);
toBeSorteds.add(toBeSorted);
}
// sort
Collections.sort(toBeSorteds, c);
// after sorting, replace col with original values
int i = 0;
for (SortCell toBeSorted : toBeSorteds) {
results.set(i, toBeSorted.row);
i++;
}
}