Example usage for org.apache.lucene.queryparser.classic MultiFieldQueryParser parse

List of usage examples for org.apache.lucene.queryparser.classic MultiFieldQueryParser parse

  1. HOME
  2. Java
  3. org.apache.lucene
  4. org.apache.lucene.queryparser.classic.*
  5. MultiFieldQueryParser
  6. parse

Introduction

In this page you can find the example usage for org.apache.lucene.queryparser.classic MultiFieldQueryParser parse.

Prototype

public static Query parse(String[] queries, String[] fields, BooleanClause.Occur[] flags, Analyzer analyzer)
        throws ParseException

Source Link

Document

Parses a query, searching on the fields specified.

Usage

From source file:buscador.SearchFiles.java

License:Apache License

/** Simple command-line based search demo. */
public static void main(String[] args) throws Exception {
    String usage = "Usage:\tjava org.apache.lucene.demo.SearchFiles [-index dir] [-field f] [-repeat n] [-queries file] [-query string] [-raw] [-paging hitsPerPage]\n\nSee http://lucene.apache.org/core/4_1_0/demo/ for details.";
    if (args.length > 0 && ("-h".equals(args[0]) || "-help".equals(args[0]))) {
        System.out.println(usage);
        System.exit(0);// w  w  w  . j  a v  a 2  s .com
    }

    String index = "Zaguan1";
    String[] fields = { "title", "description", "identifier", "date", "creator" };
    BooleanClause.Occur[] flags = { BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD,
            BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD };

    String queries = null;
    int repeat = 0;
    boolean raw = false;
    String queryString = null;
    int hitsPerPage = 10;

    for (int i = 0; i < args.length; i++) {
        if ("-index".equals(args[i])) {
            index = args[i + 1];
            i++;

        } else if ("-queries".equals(args[i])) {
            queries = args[i + 1];
            i++;
        } else if ("-query".equals(args[i])) {
            queryString = args[i + 1];
            i++;
        } else if ("-repeat".equals(args[i])) {
            repeat = Integer.parseInt(args[i + 1]);
            i++;
        } else if ("-raw".equals(args[i])) {
            raw = true;
        } else if ("-paging".equals(args[i])) {
            hitsPerPage = Integer.parseInt(args[i + 1]);
            if (hitsPerPage <= 0) {
                System.err.println("There must be at least 1 hit per page.");
                System.exit(1);
            }
            i++;
        }
    }

    IndexReader reader = DirectoryReader.open(FSDirectory.open(new File(index)));
    IndexSearcher searcher = new IndexSearcher(reader);
    Analyzer analyzer = new SpanishAnalyzer(Version.LATEST);

    BufferedReader in = null;
    if (queries != null) {
        in = new BufferedReader(new InputStreamReader(new FileInputStream(queries), "UTF-8"));
    } else {
        in = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
    }

    while (true) {
        if (queries == null && queryString == null) { // prompt the user
            System.out.println("Enter query: ");
        }

        String line = queryString != null ? queryString : in.readLine();

        if (line == null || line.length() == -1) {
            break;
        }

        line = line.trim();
        if (line.length() == 0) {
            break;
        }

        Query query = MultiFieldQueryParser.parse(line, fields, flags, analyzer);

        if (repeat > 0) { // repeat & time as benchmark
            Date start = new Date();
            for (int i = 0; i < repeat; i++) {
                searcher.search(query, 100);
            }
            Date end = new Date();
            System.out.println("Time: " + (end.getTime() - start.getTime()) + "ms");
        }

        doPagingSearch(in, searcher, query, hitsPerPage, raw, queries == null && queryString == null);

        if (queryString != null) {
            break;
        }
    }
    reader.close();
}

From source file:com.aurel.track.lucene.search.associatedFields.AbstractAssociatedFieldSearcher.java

License:Open Source License

/**
 * Gets the lucene query object//w  w  w . ja  v  a 2s. c om
 * @param fieldValue
 * @return
 */
protected Query getAssociatedFieldQuery(Analyzer analyzer, String fieldValue) {
    Query query = null;
    String[] searchFieldNames = getSearchFieldNames();
    if (searchFieldNames != null && searchFieldNames.length > 0) {
        if (searchFieldNames.length == 1) {
            QueryParser queryParser = new QueryParser(searchFieldNames[0], analyzer);
            try {
                query = queryParser.parse(fieldValue);
            } catch (ParseException e) {
                LOGGER.error("Parsing the query string '" + fieldValue + "' for  " + getLuceneFieldName()
                        + " failed with " + e.getMessage());
                LOGGER.debug(ExceptionUtils.getStackTrace(e));
            }
        } else {
            BooleanClause.Occur[] orFlags = LuceneSearcher.getOrFlagsArray(searchFieldNames.length);
            try {
                query = MultiFieldQueryParser.parse(fieldValue, searchFieldNames, orFlags, analyzer);
            } catch (ParseException e) {
                LOGGER.error("Parsing the query string '" + fieldValue + "' for " + getLuceneFieldName()
                        + " failed with " + e.getMessage());
                LOGGER.debug(ExceptionUtils.getStackTrace(e));
            }
        }
    }
    return query;
}

From source file:com.aurel.track.lucene.search.LuceneSearcher.java

License:Open Source License

/**
 * Preprocess a userQueryString which do not have explicit field(s) specified
 * Uses some text fields as default fields but looks for the words 
 * also in the other lookup indexes /*from   w ww  .  j  a  v a2  s.  c  om*/
 * @param analyzer 
 * @param toBeProcessedString a part of the user entered query string
 * @param locale 
 * @return 
 */
private static Query preprocessNoExplicitField(Analyzer analyzer, String toBeProcessedString,
        Set<Integer> itemTypeIDs, boolean external, Locale locale) throws ParseException {
    //direct workItem fields
    BooleanQuery finalQuery = new BooleanQuery();
    BooleanClause.Occur[] orFlags;
    Query workItemDirectQuery = null;
    //initialize the QueryParser with text fields as default fields
    BooleanQuery workItemQuery = new BooleanQuery();
    List<IntegerStringBean> directTextFieldNames = getFieldNamesForPreprocessType(
            LuceneUtil.PREPROCESSTYPES.DIRECT);
    String[] fieldNamesArr = new String[directTextFieldNames.size()];
    for (int i = 0; i < directTextFieldNames.size(); i++) {
        fieldNamesArr[i] = directTextFieldNames.get(i).getLabel();
    }
    orFlags = getOrFlagsArray(directTextFieldNames.size());
    try {
        workItemDirectQuery = MultiFieldQueryParser.parse(toBeProcessedString, fieldNamesArr, orFlags,
                analyzer);
    } catch (ParseException e) {
        LOGGER.warn("Parsing without explicit field for workItem fields (MultiFieldQueryParser) failed with "
                + e.getMessage());
        LOGGER.debug(ExceptionUtils.getStackTrace(e));
        throw e;
    } catch (Exception e) {
        LOGGER.warn(
                "Parsing without explicit field for workItem fields (MultiFieldQueryParser) failed with throwable "
                        + e.getMessage());
        LOGGER.debug(ExceptionUtils.getStackTrace(e));
    }
    //combine with or all occurrences LOOKUPENTITYTYPES
    if (workItemDirectQuery != null) {
        workItemQuery.add(workItemDirectQuery, BooleanClause.Occur.SHOULD);
    }
    List<ILookupFieldSearcher> lookupFieldSearchers = getLookupFieldSearchers();
    for (ILookupFieldSearcher lookupFieldSearcher : lookupFieldSearchers) {
        Query query = lookupFieldSearcher.getNoExplicitFieldQuery(analyzer, toBeProcessedString, locale);
        if (query != null) {
            workItemQuery.add(query, BooleanClause.Occur.SHOULD);
        }
    }
    finalQuery.add(workItemQuery, BooleanClause.Occur.MUST);
    Query itemTypeQuery = getItemTypeQuery(itemTypeIDs, analyzer);
    if (itemTypeQuery != null) {
        LOGGER.debug("The item type query: " + itemTypeQuery.toString());
        BooleanClause.Occur occur = null;
        if (external) {
            occur = BooleanClause.Occur.MUST;
        } else {
            occur = BooleanClause.Occur.MUST_NOT;
        }
        finalQuery.add(itemTypeQuery, occur);
    }
    return finalQuery;
}

From source file:es.unizar.iaaa.crawler.butler.index.SearchFiles.java

License:Apache License

/**
 * Simple command-line based search demo.
 *///from   w  ww  .j  a va  2  s. c om
public ArrayList<SearchResult> search(String dir, String queryS) throws Exception {

    String index = dir + "index";

    IndexReader reader = DirectoryReader.open(FSDirectory.open(new File(index)));
    IndexSearcher searcher = new IndexSearcher(reader);
    Analyzer analyzer = new EnglishAnalyzer();

    // para cada necesidad se preprocesa y se lanza una query

    String line = queryS;

    line = line.trim();
    // quiamos signos de puntuacion para el prefiltrado
    line = line.replace(".", " ");
    line = line.replace(",", " ");
    line = line.replace("(", " ");
    line = line.replace(")", " ");
    line = line.replace(";", " ");
    line = line.replace(":", " ");
    line = line.replace("-", " ");

    // quitamos palabrasvacias de signifcado y expanimos la consulta
    // semanticamente

    Query queryMultiple = null;
    BooleanQuery query = new BooleanQuery();// valor este de la caja de
    // consulta

    // Consulta generica sobre todos los indices
    if (!line.equals("")) {
        String[] fields = { "content" };
        // DEBE APARECER EN EL TITULO ALGO SOBRE ESTO
        BooleanClause.Occur[] flags = { BooleanClause.Occur.SHOULD };
        queryMultiple = MultiFieldQueryParser.parse(line, fields, flags, analyzer);
        query.add(queryMultiple, BooleanClause.Occur.SHOULD);

    }

    ArrayList<SearchResult> result = doPagingSearch(dir, searcher, query);

    reader.close();
    return result;
}

From source file:fr.paris.lutece.plugins.helpdesk.service.helpdesksearch.HelpdeskLuceneSearchEngine.java

License:Open Source License

/**
 * Return search results/*from   w  ww . ja v  a  2 s. c  o m*/
 * @param nIdFaq The id Faq
 * @param strContent The search query
 * @param dateBegin The date begin
 * @param dateEnd The date end
 * @param subject The {@link Subject}
 * @param bSearchSubSubjects true if the query must include sub-subjects
 * @param request The {@link HttpServletRequest}
 * @return Results as a collection of SearchResult
 */
public List<SearchResult> getSearchResults(int nIdFaq, String strContent, Date dateBegin, Date dateEnd,
        Subject subject, boolean bSearchSubSubjects, HttpServletRequest request) {
    ArrayList<SearchItem> listResults = new ArrayList<SearchItem>();
    IndexSearcher searcher = null;

    Query filterRole = getFilterRoles(request);

    try (Directory directory = IndexationService.getDirectoryIndex();
            IndexReader ir = DirectoryReader.open(directory);) {
        searcher = new IndexSearcher(ir);

        Collection<String> queries = new ArrayList<String>();
        Collection<String> fields = new ArrayList<String>();
        Collection<BooleanClause.Occur> flags = new ArrayList<BooleanClause.Occur>();

        //Faq Id
        if (nIdFaq != -1) {
            Query queryFaqId = new TermQuery(new Term(HelpdeskSearchItem.FIELD_FAQ_ID, String.valueOf(nIdFaq)));
            queries.add(queryFaqId.toString());
            fields.add(HelpdeskSearchItem.FIELD_FAQ_ID);
            flags.add(BooleanClause.Occur.MUST);
        }

        //Type (=helpdesk)
        PhraseQuery.Builder queryTypeBuilder = new PhraseQuery.Builder();
        queryTypeBuilder.add(new Term(HelpdeskSearchItem.FIELD_TYPE, HelpdeskPlugin.PLUGIN_NAME));
        PhraseQuery queryType = queryTypeBuilder.build();
        queries.add(queryType.toString());
        fields.add(HelpdeskSearchItem.FIELD_TYPE);
        flags.add(BooleanClause.Occur.MUST);

        //Content
        if ((strContent != null) && !strContent.equals(EMPTY_STRING)) {
            Query queryContent = new TermQuery(new Term(HelpdeskSearchItem.FIELD_CONTENTS, strContent));
            queries.add(queryContent.toString());
            fields.add(HelpdeskSearchItem.FIELD_CONTENTS);
            flags.add(BooleanClause.Occur.MUST);
        }

        //Dates
        if ((dateBegin != null) && (dateEnd != null)) {
            BytesRef strDateBegin = new BytesRef(DateTools.dateToString(dateBegin, DateTools.Resolution.DAY));
            BytesRef strDateEnd = new BytesRef(DateTools.dateToString(dateEnd, DateTools.Resolution.DAY));
            Query queryDate = new TermRangeQuery(HelpdeskSearchItem.FIELD_DATE, strDateBegin, strDateEnd, true,
                    true);
            queries.add(queryDate.toString());
            fields.add(HelpdeskSearchItem.FIELD_DATE);
            flags.add(BooleanClause.Occur.MUST);
        }

        //Subjects
        if ((bSearchSubSubjects) && (subject != null)) {
            Plugin plugin = PluginService.getPlugin(HelpdeskPlugin.PLUGIN_NAME);
            Collection<Term> listSubjects = new ArrayList<Term>();
            getListSubjects(listSubjects, subject, plugin);

            String strQuerySubject = OPEN_PARENTHESIS;

            for (Term term : listSubjects) {
                Query querySubject = new TermQuery(term);
                strQuerySubject += (querySubject.toString() + SPACE);
            }

            strQuerySubject += CLOSE_PARENTHESIS;
            queries.add(strQuerySubject);
            fields.add(HelpdeskSearchItem.FIELD_SUBJECT);
            flags.add(BooleanClause.Occur.MUST);
        } else {
            if ((subject != null)) {
                Query querySubject = new TermQuery(
                        new Term(HelpdeskSearchItem.FIELD_SUBJECT, String.valueOf(subject.getId())));
                queries.add(querySubject.toString());
                fields.add(HelpdeskSearchItem.FIELD_SUBJECT);
                flags.add(BooleanClause.Occur.MUST);
            }
        }

        Query queryMulti = MultiFieldQueryParser.parse((String[]) queries.toArray(new String[queries.size()]),
                (String[]) fields.toArray(new String[fields.size()]),
                (BooleanClause.Occur[]) flags.toArray(new BooleanClause.Occur[flags.size()]),
                IndexationService.getAnalyser());

        BooleanQuery.Builder bQueryMultiBuilder = new BooleanQuery.Builder();
        bQueryMultiBuilder.add(queryMulti, BooleanClause.Occur.MUST);
        if (filterRole != null) {
            bQueryMultiBuilder.add(filterRole, BooleanClause.Occur.FILTER);
        }

        TopDocs topDocs = searcher.search(bQueryMultiBuilder.build(), LuceneSearchEngine.MAX_RESPONSES);

        ScoreDoc[] hits = topDocs.scoreDocs;

        for (int i = 0; i < hits.length; i++) {
            int docId = hits[i].doc;
            Document document = searcher.doc(docId);
            SearchItem si = new SearchItem(document);
            listResults.add(si);
        }
    } catch (Exception e) {
        AppLogService.error(e.getMessage(), e);
    }

    return convertList(listResults);
}

From source file:io.jpress.searcher.LuceneSearcher.java

License:LGPL

@Override
public Page<SearcherBean> search(String queryString, String module, int pageNum, int pageSize) {
    List<SearcherBean> list = new ArrayList<SearcherBean>();
    try {/*w w w .jav a2 s  .co  m*/
        IndexSearcher mIndexSearcher = getIndexSearcher();
        queryString = QueryParser.escape(queryString);

        String[] queries = { queryString, queryString, queryString };
        String[] fields = { "title", "description", "content" };
        BooleanClause.Occur[] flags = { BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD,
                BooleanClause.Occur.SHOULD };
        Query query = MultiFieldQueryParser.parse(queries, fields, flags,
                new JcsegAnalyzer5X(JcsegTaskConfig.COMPLEX_MODE));
        TopDocs topDocs = mIndexSearcher.search(query, 1000);//1000,?1000?

        if (topDocs != null && topDocs.totalHits > 0) {
            ScoreDoc[] scoreDocs = topDocs.scoreDocs;
            for (int i = 0; i < scoreDocs.length; i++) {
                int docId = scoreDocs[i].doc;
                Document doc = mIndexSearcher.doc(docId);
                list.add(createSearcherBean(doc));
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ParseException e) {
        e.printStackTrace();
    }
    return new Page<SearcherBean>(list, pageNum, pageSize, list.size() / pageSize, list.size());
}

From source file:org.eclipse.agail.recommenderserver.RecommendCloud.java

License:Open Source License

public void generateQuery(GatewayProfile profile) {

    String[] fields = { "locations", "pricing", "services", "runtimes" };
    String loc = "EU";
    String price = "free";
    String services = "TODO_ADD_MORE";

    if (profile.getLocation() != "")
        loc = profile.getLocation();//  ww w  .  ja v a 2s .  com

    if (profile.getPricingPreferences() != "")
        price = profile.getPricingPreferences().replaceAll(",", " OR ");

    if (profile.getLocation() != "")
        loc = profile.getLocation();

    if (profile.getRequiredServices() != "")
        services = profile.getRequiredServices().replaceAll(",", " OR ");

    String[] queries = { loc, price, services, "node" };

    BooleanClause.Occur[] flags = { BooleanClause.Occur.MUST, BooleanClause.Occur.SHOULD,
            BooleanClause.Occur.MUST, BooleanClause.Occur.MUST };

    MultiFieldQueryParser queryParserCloud = new MultiFieldQueryParser(queries,
            CloudMarketplace.analyzer_cloud);

    try {
        finalQuery = queryParserCloud.parse(queries, fields, flags, CloudMarketplace.analyzer_cloud);
    } catch (org.apache.lucene.queryparser.classic.ParseException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }
}