Author: Srinivasarao
Date: 2009-07-21 05:16:48 -0700 (Tue, 21 Jul 2009)
New Revision: 17500
Added:
csplugins/trunk/soc/srinivasarao/search-api/src/main/java/org/cytoscape/search/util/NewMultiFieldQueryParser.java
Modified:
csplugins/trunk/soc/srinivasarao/search-api/src/main/java/org/cytoscape/search/util/CustomMultiFieldQueryParser.java
Log:
Modified:
csplugins/trunk/soc/srinivasarao/search-api/src/main/java/org/cytoscape/search/util/CustomMultiFieldQueryParser.java
===================================================================
---
csplugins/trunk/soc/srinivasarao/search-api/src/main/java/org/cytoscape/search/util/CustomMultiFieldQueryParser.java
2009-07-21 12:15:21 UTC (rev 17499)
+++
csplugins/trunk/soc/srinivasarao/search-api/src/main/java/org/cytoscape/search/util/CustomMultiFieldQueryParser.java
2009-07-21 12:16:48 UTC (rev 17500)
@@ -36,28 +36,22 @@
package org.cytoscape.search.util;
-import org.apache.lucene.queryParser.MultiFieldQueryParser;
-import org.apache.lucene.search.Query;
-import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.analysis.Analyzer;
-import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.document.NumberTools;
-import org.apache.lucene.search.RangeQuery;
import org.apache.lucene.index.Term;
+import org.apache.lucene.queryParser.ParseException;
+import org.apache.lucene.search.BooleanQuery;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.RangeQuery;
-import org.cytoscape.search.util.AttributeFields;
-import org.cytoscape.search.util.NumberUtils;
-//import cytoscape.data.CyAttributes;
-//import org.cytoscape.model.CyDataTable;
-
/**
* This custom MultiFieldQueryParser is used to parse queries containing
numerical values.
* Lucene treats all attribute field values as strings. During indexing,
numerical values were transformed
* into structured strings preserving their numerical sorting order. Now,
numerical values in query
* should also be transformed so they can be properly compared to the values
stored in the index.
*/
-public class CustomMultiFieldQueryParser extends MultiFieldQueryParser {
+public class CustomMultiFieldQueryParser extends NewMultiFieldQueryParser {
private AttributeFields attrFields;
Added:
csplugins/trunk/soc/srinivasarao/search-api/src/main/java/org/cytoscape/search/util/NewMultiFieldQueryParser.java
===================================================================
---
csplugins/trunk/soc/srinivasarao/search-api/src/main/java/org/cytoscape/search/util/NewMultiFieldQueryParser.java
(rev 0)
+++
csplugins/trunk/soc/srinivasarao/search-api/src/main/java/org/cytoscape/search/util/NewMultiFieldQueryParser.java
2009-07-21 12:16:48 UTC (rev 17500)
@@ -0,0 +1,322 @@
+package org.cytoscape.search.util;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.lucene.analysis.Analyzer;
+import org.apache.lucene.queryParser.ParseException;
+import org.apache.lucene.queryParser.QueryParser;
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.BooleanQuery;
+import org.apache.lucene.search.MultiPhraseQuery;
+import org.apache.lucene.search.PhraseQuery;
+import org.apache.lucene.search.Query;
+
+/**
+ * A QueryParser which constructs queries to search multiple fields.
+ *
+ *
+ * @version $Revision: 692921 $
+ */
+public class NewMultiFieldQueryParser extends QueryParser
+{
+ protected String[] fields;
+ protected Map boosts;
+
+ /**
+ * Creates a MultiFieldQueryParser.
+ * Allows passing of a map with term to Boost, and the boost to apply to
each term.
+ *
+ * <p>It will, when parse(String query)
+ * is called, construct a query like this (assuming the query consists of
+ * two terms and you specify the two fields <code>title</code> and
<code>body</code>):</p>
+ *
+ * <code>
+ * (title:term1 body:term1) (title:term2 body:term2)
+ * </code>
+ *
+ * <p>When setDefaultOperator(AND_OPERATOR) is set, the result will be:</p>
+ *
+ * <code>
+ * +(title:term1 body:term1) +(title:term2 body:term2)
+ * </code>
+ *
+ * <p>When you pass a boost (title=>5 body=>10) you can get </p>
+ *
+ * <code>
+ * +(title:term1^5.0 body:term1^10.0) +(title:term2^5.0 body:term2^10.0)
+ * </code>
+ *
+ * <p>In other words, all the query's terms must appear, but it doesn't
matter in
+ * what fields they appear.</p>
+ */
+ public NewMultiFieldQueryParser(String[] fields, Analyzer analyzer, Map
boosts) {
+ this(fields,analyzer);
+ this.boosts = boosts;
+ }
+
+ /**
+ * Creates a MultiFieldQueryParser.
+ *
+ * <p>It will, when parse(String query)
+ * is called, construct a query like this (assuming the query consists of
+ * two terms and you specify the two fields <code>title</code> and
<code>body</code>):</p>
+ *
+ * <code>
+ * (title:term1 body:term1) (title:term2 body:term2)
+ * </code>
+ *
+ * <p>When setDefaultOperator(AND_OPERATOR) is set, the result will be:</p>
+ *
+ * <code>
+ * +(title:term1 body:term1) +(title:term2 body:term2)
+ * </code>
+ *
+ * <p>In other words, all the query's terms must appear, but it doesn't
matter in
+ * what fields they appear.</p>
+ */
+ public NewMultiFieldQueryParser(String[] fields, Analyzer analyzer) {
+ super(null, analyzer);
+ this.fields = fields;
+ }
+
+ protected Query getFieldQuery(String field, String queryText, int slop)
throws ParseException {
+ if (field == null) {
+ List clauses = new ArrayList();
+ for (int i = 0; i < fields.length; i++) {
+ Query q = getFieldQuery(fields[i], queryText);
+ if (q != null) {
+ //If the user passes a map of boosts
+ if (boosts != null) {
+ //Get the boost from the map and apply them
+ Float boost = (Float)boosts.get(fields[i]);
+ if (boost != null) {
+ q.setBoost(boost.floatValue());
+ }
+ }
+ applySlop(q,slop);
+ clauses.add(new BooleanClause(q, BooleanClause.Occur.SHOULD));
+ }
+ }
+ if (clauses.size() == 0) // happens for stopwords
+ return null;
+ return getBooleanQuery(clauses, true);
+ }
+ Query q = super.getFieldQuery(field, queryText);
+ applySlop(q,slop);
+ return q;
+ }
+
+ private void applySlop(Query q, int slop) {
+ if (q instanceof PhraseQuery) {
+ ((PhraseQuery) q).setSlop(slop);
+ } else if (q instanceof MultiPhraseQuery) {
+ ((MultiPhraseQuery) q).setSlop(slop);
+ }
+ }
+
+
+ protected Query getFieldQuery(String field, String queryText) throws
ParseException {
+ return getFieldQuery(field, queryText, 0);
+ }
+
+
+ protected Query getFuzzyQuery(String field, String termStr, float
minSimilarity) throws ParseException
+ {
+ if (field == null) {
+ List clauses = new ArrayList();
+ for (int i = 0; i < fields.length; i++) {
+ clauses.add(new BooleanClause(getFuzzyQuery(fields[i], termStr,
minSimilarity),
+ BooleanClause.Occur.SHOULD));
+ }
+ return getBooleanQuery(clauses, true);
+ }
+ return super.getFuzzyQuery(field, termStr, minSimilarity);
+ }
+
+ protected Query getPrefixQuery(String field, String termStr) throws
ParseException
+ {
+ if (field == null) {
+ List clauses = new ArrayList();
+ for (int i = 0; i < fields.length; i++) {
+ clauses.add(new BooleanClause(getPrefixQuery(fields[i], termStr),
+ BooleanClause.Occur.SHOULD));
+ }
+ return getBooleanQuery(clauses, true);
+ }
+ return super.getPrefixQuery(field, termStr);
+ }
+
+ protected Query getWildcardQuery(String field, String termStr) throws
ParseException {
+ if (field == null) {
+ List clauses = new ArrayList();
+ for (int i = 0; i < fields.length; i++) {
+ clauses.add(new BooleanClause(getWildcardQuery(fields[i], termStr),
+ BooleanClause.Occur.SHOULD));
+ }
+ return getBooleanQuery(clauses, true);
+ }
+ return super.getWildcardQuery(field, termStr);
+ }
+
+
+ protected Query getRangeQuery(String field, String part1, String part2,
boolean inclusive) throws ParseException {
+ if (field == null) {
+ List clauses = new ArrayList();
+ for (int i = 0; i < fields.length; i++) {
+ clauses.add(new BooleanClause(getRangeQuery(fields[i], part1, part2,
inclusive),
+ BooleanClause.Occur.SHOULD));
+ }
+ return getBooleanQuery(clauses, true);
+ }
+ return super.getRangeQuery(field, part1, part2, inclusive);
+ }
+
+ /**
+ * Parses a query which searches on the fields specified.
+ * <p>
+ * If x fields are specified, this effectively constructs:
+ * <pre>
+ * <code>
+ * (field1:query1) (field2:query2) (field3:query3)...(fieldx:queryx)
+ * </code>
+ * </pre>
+ * @param queries Queries strings to parse
+ * @param fields Fields to search on
+ * @param analyzer Analyzer to use
+ * @throws ParseException if query parsing fails
+ * @throws IllegalArgumentException if the length of the queries array
differs
+ * from the length of the fields array
+ */
+ public static Query parse(String[] queries, String[] fields,
+ Analyzer analyzer) throws ParseException
+ {
+ if (queries.length != fields.length)
+ throw new IllegalArgumentException("queries.length != fields.length");
+ BooleanQuery bQuery = new BooleanQuery();
+ for (int i = 0; i < fields.length; i++)
+ {
+ QueryParser qp = new QueryParser(fields[i], analyzer);
+ Query q = qp.parse(queries[i]);
+ if (q!=null && // q never null, just being defensive
+ (!(q instanceof BooleanQuery) ||
((BooleanQuery)q).getClauses().length>0)) {
+ bQuery.add(q, BooleanClause.Occur.SHOULD);
+ }
+ }
+ return bQuery;
+ }
+
+ /**
+ * Parses a query, searching on the fields specified.
+ * Use this if you need to specify certain fields as required,
+ * and others as prohibited.
+ * <p><pre>
+ * Usage:
+ * <code>
+ * String[] fields = {"filename", "contents", "description"};
+ * BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
+ * BooleanClause.Occur.MUST,
+ * BooleanClause.Occur.MUST_NOT};
+ * MultiFieldQueryParser.parse("query", fields, flags, analyzer);
+ * </code>
+ * </pre>
+ *<p>
+ * The code above would construct a query:
+ * <pre>
+ * <code>
+ * (filename:query) +(contents:query) -(description:query)
+ * </code>
+ * </pre>
+ *
+ * @param query Query string to parse
+ * @param fields Fields to search on
+ * @param flags Flags describing the fields
+ * @param analyzer Analyzer to use
+ * @throws ParseException if query parsing fails
+ * @throws IllegalArgumentException if the length of the fields array differs
+ * from the length of the flags array
+ */
+ public static Query parse(String query, String[] fields,
+ BooleanClause.Occur[] flags, Analyzer analyzer) throws ParseException {
+ if (fields.length != flags.length)
+ throw new IllegalArgumentException("fields.length != flags.length");
+ BooleanQuery bQuery = new BooleanQuery();
+ for (int i = 0; i < fields.length; i++) {
+ QueryParser qp = new QueryParser(fields[i], analyzer);
+ Query q = qp.parse(query);
+ if (q!=null && // q never null, just being defensive
+ (!(q instanceof BooleanQuery) ||
((BooleanQuery)q).getClauses().length>0)) {
+ bQuery.add(q, flags[i]);
+ }
+ }
+ return bQuery;
+ }
+
+ /**
+ * Parses a query, searching on the fields specified.
+ * Use this if you need to specify certain fields as required,
+ * and others as prohibited.
+ * <p><pre>
+ * Usage:
+ * <code>
+ * String[] query = {"query1", "query2", "query3"};
+ * String[] fields = {"filename", "contents", "description"};
+ * BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
+ * BooleanClause.Occur.MUST,
+ * BooleanClause.Occur.MUST_NOT};
+ * MultiFieldQueryParser.parse(query, fields, flags, analyzer);
+ * </code>
+ * </pre>
+ *<p>
+ * The code above would construct a query:
+ * <pre>
+ * <code>
+ * (filename:query1) +(contents:query2) -(description:query3)
+ * </code>
+ * </pre>
+ *
+ * @param queries Queries string to parse
+ * @param fields Fields to search on
+ * @param flags Flags describing the fields
+ * @param analyzer Analyzer to use
+ * @throws ParseException if query parsing fails
+ * @throws IllegalArgumentException if the length of the queries, fields,
+ * and flags array differ
+ */
+ public static Query parse(String[] queries, String[] fields,
BooleanClause.Occur[] flags,
+ Analyzer analyzer) throws ParseException
+ {
+ if (!(queries.length == fields.length && queries.length == flags.length))
+ throw new IllegalArgumentException("queries, fields, and flags array
have have different length");
+ BooleanQuery bQuery = new BooleanQuery();
+ for (int i = 0; i < fields.length; i++)
+ {
+ QueryParser qp = new QueryParser(fields[i], analyzer);
+ Query q = qp.parse(queries[i]);
+ if (q!=null && // q never null, just being defensive
+ (!(q instanceof BooleanQuery) ||
((BooleanQuery)q).getClauses().length>0)) {
+ bQuery.add(q, flags[i]);
+ }
+ }
+ return bQuery;
+ }
+
+}
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"cytoscape-cvs" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to
[email protected]
For more options, visit this group at
http://groups.google.com/group/cytoscape-cvs?hl=en
-~----------~----~----~----~------~----~------~--~---
