Example usage for org.apache.lucene.search BooleanQuery BooleanQuery

List of usage examples for org.apache.lucene.search BooleanQuery BooleanQuery

  1. HOME
  2. Java
  3. org.apache.lucene
  4. org.apache.lucene.search.*
  5. BooleanQuery
  6. BooleanQuery

Introduction

In this page you can find the example usage for org.apache.lucene.search BooleanQuery BooleanQuery.

Prototype

BooleanQuery

Source Link

Usage

From source file:cn.b2b.index.product.index.ProductQueryOptimizer.java

@Override
public Writable explain(IndexSearcher searcher, Writable param) throws Exception {

    ExplainParam queryParam = (ExplainParam) param;
    Query oriquery = queryParam.getQuery();
    BooleanQuery original = QueryFilters.filter(oriquery, Constants.SLOP_SCORE_CVM_CLASS);
    BooleanQuery query = new BooleanQuery();
    BooleanQuery filterQuery = null;//from  www. j a v a  2s  .c  o m
    BooleanClause[] clauses = original.getClauses();
    for (int i = 0; i < clauses.length; i++) {
        BooleanClause c = clauses[i];
        if (c.isRequired() // required
                && c.getQuery().getBoost() == 0.0f // boost is zero
                && c.getQuery() instanceof TermQuery // TermQuery
                && (searcher.docFreq(((TermQuery) c.getQuery()).getTerm())
                        / (float) searcher.maxDoc()) >= threshold) { // check threshold
            if (filterQuery == null)
                filterQuery = new BooleanQuery();
            // lucene1.4.3 -> lucene2.0.0
            // filterQuery.add(c.getQuery(), true, false); // filter it
            filterQuery.add(c.getQuery(), BooleanClause.Occur.MUST); // filter
            // it
        } else {
            query.add(c); // query it
        }
    }

    Filter filter = null;
    if (filterQuery != null) {
        synchronized (cache) { // check cache
            filter = (Filter) cache.get(filterQuery);
        }
        if (filter == null) { // miss
            filter = new QueryFilter(filterQuery); // construct new entry
            synchronized (cache) {
                cache.put(filterQuery, filter); // cache it
            }
        }
    }
    ScoreParam scoreParam = new ScoreParam();
    // store segment query word
    query.setQueryStr(original.getQueryStr());

    float[] ranks = (float[]) MemoryFieldCache.get("rank");
    Explanation explain = searcher.explain(query, queryParam.getDoc());
    return new UTF8("RANK:" + ranks[queryParam.getDoc()] + "\t" + explain.toString());
}

From source file:cn.edu.thss.iise.beehivez.server.index.labelindex.LabelLuceneIndex.java

License:Open Source License

public boolean contain(String label) {
    try {/* w w  w .  j a  v a  2s.co m*/
        IndexReader reader = IndexReader.open(this.indexDir, true);
        Searcher searcher = new IndexSearcher(reader);
        // use the boolean query
        HashSet<String> queryTermSet = new HashSet<String>();
        TokenStream stream = analyzer.tokenStream(LabelDocument.FIELD_LABEL, new StringReader(label));
        TermAttribute termAtt = stream.addAttribute(TermAttribute.class);
        stream.reset();
        while (stream.incrementToken()) {
            queryTermSet.add(termAtt.term());
        }
        stream.end();
        stream.close();

        // construct the query
        BooleanQuery bq = new BooleanQuery();
        Iterator<String> it = queryTermSet.iterator();
        while (it.hasNext()) {
            String s = it.next();
            Term term = new Term(LabelDocument.FIELD_LABEL, s);
            TermQuery termQuery = new TermQuery(term);
            bq.add(termQuery, Occur.MUST);
        }

        ExactLabelQueryResultCollector collector = new ExactLabelQueryResultCollector(reader, label);
        searcher.search(bq, collector);
        boolean ret = collector.isExistQueryLabel();
        reader.close();
        return ret;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return false;
}

From source file:cn.edu.thss.iise.beehivez.server.index.labelindex.LabelLuceneIndex.java

License:Open Source License

public TreeSet<SimilarLabelQueryResult> getSimilarLabels(String query, float similarity) {
    TreeSet<SimilarLabelQueryResult> ret = new TreeSet<SimilarLabelQueryResult>();
    if (query == null) {
        ret.add(new SimilarLabelQueryResult(null, 1));
        return ret;
    }//from w w w.  j a v  a2  s . c om
    try {
        IndexReader reader = IndexReader.open(this.indexDir, true);
        Searcher searcher = new IndexSearcher(reader);

        // get terms from query
        HashSet<String> queryTermSet = new HashSet<String>();
        TokenStream stream = analyzer.tokenStream(LabelDocument.FIELD_LABEL, new StringReader(query));
        TermAttribute termAtt = stream.addAttribute(TermAttribute.class);
        stream.reset();
        while (stream.incrementToken()) {
            queryTermSet.add(termAtt.term());
        }
        stream.end();
        stream.close();

        // construct the query
        BooleanQuery bq = new BooleanQuery();
        Iterator<String> it = queryTermSet.iterator();
        SynonymMap synMap = SynonymIndex.getSynonymMap();
        HashSet<String> expandedQueryTermSet = new HashSet<String>(queryTermSet);

        while (it.hasNext()) {
            String s = it.next();
            Term term = new Term(LabelDocument.FIELD_LABEL, s);
            TermQuery termQuery = new TermQuery(term);
            bq.add(termQuery, Occur.SHOULD);
            // expand using synonyms
            for (String syn : synMap.getSynonyms(s)) {
                stemer.setCurrent(syn);
                stemer.stem();
                syn = stemer.getCurrent();
                if (expandedQueryTermSet.add(syn)) {
                    term = new Term(LabelDocument.FIELD_LABEL, syn);
                    termQuery = new TermQuery(term);
                    bq.add(termQuery, Occur.SHOULD);
                }
            }
        }

        // search in the label index
        SimilarLabelQueryResultCollector collector = new SimilarLabelQueryResultCollector(reader, queryTermSet,
                similarity);
        searcher.search(bq, collector);
        ret = collector.getQueryResult();
        searcher.close();
        reader.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return ret;
}

From source file:cn.edu.thss.iise.beehivez.server.index.petrinetindex.tarluceneindex.TARLuceneIndex.java

License:Open Source License

@Override
public TreeSet<ProcessQueryResult> getProcessModels(Object o, float similarity) {

    TreeSet<ProcessQueryResult> ret = new TreeSet<ProcessQueryResult>();

    try {//from  w ww .jav  a  2 s.  co  m
        if (o instanceof PetriNet) {
            PetriNet pn = (PetriNet) o;

            IndexReader reader = IndexReader.open(FSDirectory.open(INDEX_DIR), true);
            Searcher searcher = new IndexSearcher(reader);
            BooleanQuery bq = new BooleanQuery();
            bq.setMaxClauseCount(Integer.MAX_VALUE);

            // make it sure that every queryterm is unique
            HashSet<String> expandedTars = new HashSet();

            // expand the query tars with their similar ones
            HashSet<HashSet<String>> exQueryTars = new HashSet<HashSet<String>>();

            // calculate the tars
            Iterator<TransitionLabelPair> itTAR = PetriNetUtil.getTARSFromPetriNetByCFP(pn).iterator();

            if (GlobalParameter.isEnableSimilarLabel()) {
                // label similarity is enabled
                while (itTAR.hasNext()) {
                    TransitionLabelPair tlp = itTAR.next();
                    String tarString = tlp.getFirst().trim() + PetriNetTARsDocument.TARCONNECTOR
                            + tlp.getSecond().trim();

                    HashSet<String> similarTars = new HashSet<String>();

                    TreeSet<SimilarLabelQueryResult> pres = labelIndex.getSimilarLabels(tlp.getFirst().trim(),
                            GlobalParameter.getLabelSemanticSimilarity());

                    TreeSet<SimilarLabelQueryResult> sucs = labelIndex.getSimilarLabels(tlp.getSecond().trim(),
                            GlobalParameter.getLabelSemanticSimilarity());

                    Iterator<SimilarLabelQueryResult> itPre = pres.iterator();
                    while (itPre.hasNext()) {
                        String pre = itPre.next().getLabel();
                        Iterator<SimilarLabelQueryResult> itSuc = sucs.iterator();
                        while (itSuc.hasNext()) {
                            String suc = itSuc.next().getLabel();
                            String tar = pre + PetriNetTARsDocument.TARCONNECTOR + suc;
                            if (similarTars.add(tar)) {
                                if (expandedTars.add(tar)) {
                                    Term term = new Term(PetriNetTARsDocument.FIELDTARS, tar);
                                    TermQuery termQuery = new TermQuery(term);
                                    bq.add(termQuery, Occur.SHOULD);
                                }
                            }
                        }
                    }

                    if (similarTars.size() == 0) {
                        similarTars.add(tarString);
                    }
                    exQueryTars.add(similarTars);
                }
            } else {
                // label similarity is not enabled
                while (itTAR.hasNext()) {
                    TransitionLabelPair tlp = itTAR.next();
                    String tarString = tlp.getFirst().trim() + PetriNetTARsDocument.TARCONNECTOR
                            + tlp.getSecond().trim();

                    HashSet<String> similarTars = new HashSet<String>();
                    similarTars.add(tarString);

                    if (expandedTars.add(tarString)) {
                        Term term = new Term(PetriNetTARsDocument.FIELDTARS, tarString);
                        TermQuery termQuery = new TermQuery(term);
                        bq.add(termQuery, Occur.SHOULD);
                    }
                    exQueryTars.add(similarTars);
                }
            }

            // while (itTAR.hasNext()) {
            // TransitionLabelPair tlp = itTAR.next();
            // String tarString = tlp.getFirst().trim()
            // + PetriNetTARsDocument.TARCONNECTOR
            // + tlp.getSecond().trim();
            //
            // HashSet<String> similarTars = new HashSet<String>();
            //
            // // expand with its similar tars
            // if (GlobalParameter.isEnableSimilarLabel()) {
            // TreeSet<SimilarLabelQueryResult> pres = labelIndex
            // .getSimilarLabels(tlp.getFirst().trim(),
            // GlobalParameter
            // .getLabelSemanticSimilarity());
            //
            // TreeSet<SimilarLabelQueryResult> sucs = labelIndex
            // .getSimilarLabels(tlp.getSecond().trim(),
            // GlobalParameter
            // .getLabelSemanticSimilarity());
            //
            // Iterator<SimilarLabelQueryResult> itPre = pres
            // .iterator();
            // while (itPre.hasNext()) {
            // String pre = itPre.next().getLabel();
            // Iterator<SimilarLabelQueryResult> itSuc = sucs
            // .iterator();
            // while (itSuc.hasNext()) {
            // String suc = itSuc.next().getLabel();
            // String tar = pre
            // + PetriNetTARsDocument.TARCONNECTOR
            // + suc;
            // if (similarTars.add(tar)) {
            // if (expandedTars.add(tar)) {
            // Term term = new Term(
            // PetriNetTARsDocument.FIELDTARS,
            // tar);
            // TermQuery termQuery = new TermQuery(
            // term);
            // bq.add(termQuery, Occur.SHOULD);
            // }
            // }
            // }
            // }
            //
            // if (similarTars.size() == 0) {
            // similarTars.add(tarString);
            // }
            //
            // } else {
            // similarTars.add(tarString);
            //
            // if (expandedTars.add(tarString)) {
            // Term term = new Term(
            // PetriNetTARsDocument.FIELDTARS, tarString);
            // TermQuery termQuery = new TermQuery(term);
            // bq.add(termQuery, Occur.SHOULD);
            // }
            // }
            //
            // exQueryTars.add(similarTars);
            // }

            TARsQueryResultCollector collector = new TARsQueryResultCollector(reader, exQueryTars, similarity);
            searcher.search(bq, collector);
            ret = collector.getQueryResult();
            searcher.close();
            reader.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return ret;
}

From source file:cn.edu.thss.iise.beehivez.server.index.petrinetindex.taskedgeindex.TaskEdgeLuceneIndex.java

License:Open Source License

@Override
public TreeSet<ProcessQueryResult> getProcessModels(Object o, float similarity) {

    TreeSet<ProcessQueryResult> ret = new TreeSet<ProcessQueryResult>();

    try {//from www.j  av a2 s  .c  o m
        if (o instanceof PetriNet) {
            PetriNet pn = (PetriNet) o;

            IndexReader reader = IndexReader.open(FSDirectory.open(INDEX_DIR), true);
            Searcher searcher = new IndexSearcher(reader);
            BooleanQuery bq = new BooleanQuery();
            bq.setMaxClauseCount(Integer.MAX_VALUE);

            // make it sure that every queryterm is unique
            HashSet<String> expandedTaskEdges = new HashSet();

            // expand the query task edges with their similar ones
            HashSet<HashSet<String>> exQueryTaskEdges = new HashSet<HashSet<String>>();

            // calculate the task edges of query Petri net
            ArrayList<TaskLine4PetriNet> tls = TaskLine4PetriNet.getAllTaskLinesOfPetriNet(pn);

            if (GlobalParameter.isEnableSimilarLabel()) {
                // label similarity is enabled
                for (TaskLine4PetriNet tl : tls) {
                    String taskEdgeString = tl.getSrcTransition().getIdentifier().trim()
                            + PetriNetTaskEdgesDocument.TASKEDGECONNECTOR
                            + tl.getDestTransition().getIdentifier().trim();

                    HashSet<String> similarTaskEdges = new HashSet<String>();

                    TreeSet<SimilarLabelQueryResult> pres = labelIndex.getSimilarLabels(
                            tl.getSrcTransition().getIdentifier().trim(),
                            GlobalParameter.getLabelSemanticSimilarity());

                    TreeSet<SimilarLabelQueryResult> sucs = labelIndex.getSimilarLabels(
                            tl.getDestTransition().getIdentifier().trim(),
                            GlobalParameter.getLabelSemanticSimilarity());

                    Iterator<SimilarLabelQueryResult> itPre = pres.iterator();
                    while (itPre.hasNext()) {
                        String pre = itPre.next().getLabel();
                        Iterator<SimilarLabelQueryResult> itSuc = sucs.iterator();
                        while (itSuc.hasNext()) {
                            String suc = itSuc.next().getLabel();
                            String taskEdge = pre + PetriNetTaskEdgesDocument.TASKEDGECONNECTOR + suc;
                            if (similarTaskEdges.add(taskEdge)) {
                                if (expandedTaskEdges.add(taskEdge)) {
                                    Term term = new Term(PetriNetTaskEdgesDocument.FIELDTASKEDGES, taskEdge);
                                    TermQuery termQuery = new TermQuery(term);
                                    bq.add(termQuery, Occur.SHOULD);
                                }
                            }
                        }
                    }

                    if (similarTaskEdges.size() == 0) {
                        similarTaskEdges.add(taskEdgeString);
                    }
                    exQueryTaskEdges.add(similarTaskEdges);
                }
            } else {
                // label similarity is not enabled
                for (TaskLine4PetriNet tl : tls) {
                    String taskEdgeString = tl.getSrcTransition().getIdentifier().trim()
                            + PetriNetTaskEdgesDocument.TASKEDGECONNECTOR
                            + tl.getDestTransition().getIdentifier().trim();

                    HashSet<String> similarTaskEdges = new HashSet<String>();
                    similarTaskEdges.add(taskEdgeString);

                    if (expandedTaskEdges.add(taskEdgeString)) {
                        Term term = new Term(PetriNetTaskEdgesDocument.FIELDTASKEDGES, taskEdgeString);
                        TermQuery termQuery = new TermQuery(term);
                        bq.add(termQuery, Occur.SHOULD);
                    }
                    exQueryTaskEdges.add(similarTaskEdges);
                }
            }

            TaskEdgesQueryResultCollector collector = new TaskEdgesQueryResultCollector(reader,
                    exQueryTaskEdges, similarity);
            searcher.search(bq, collector);
            TreeSet<ProcessQueryResult> temp = collector.getQueryResult();
            searcher.close();
            reader.close();

            // verify the candidate model
            Iterator<ProcessQueryResult> it = temp.iterator();
            while (it.hasNext()) {
                ProcessQueryResult pqr = it.next();
                long id = pqr.getProcess_id();
                DataManager dm = DataManager.getInstance();
                PetriNet c = dm.getProcessPetriNet(id);
                float mcesSimilarity = PetriNetUtil.mcesSimilarity(c, pn);
                if (mcesSimilarity >= similarity) {
                    ret.add(new ProcessQueryResult(id, mcesSimilarity));
                }
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return ret;
}

From source file:cn.edu.thss.iise.beehivez.server.index.yawlindex.yawltasksluceneindex.YAWLTasksLuceneIndex.java

License:Open Source License

@Override
public TreeSet<ProcessQueryResult> getProcessModels(Object o, float similarity) {
    TreeSet<ProcessQueryResult> ret = new TreeSet<ProcessQueryResult>();

    try {// www  .  ja  v  a  2s  .c  om
        if (o instanceof YNet) {
            YNet query = (YNet) o;

            IndexReader reader = IndexReader.open(FSDirectory.open(INDEX_DIR), true);
            Searcher searcher = new IndexSearcher(reader);
            BooleanQuery bq = new BooleanQuery();
            BooleanQuery.setMaxClauseCount(Integer.MAX_VALUE);

            // expand the tasks with their similar ones
            HashSet<String> expandedTasks = new HashSet<String>();

            if (GlobalParameter.isEnableSimilarLabel()) {
                // label similarity is enabled
                for (YTask task : query.getNetTasks()) {
                    String taskName = task.getName().trim();
                    if (expandedTasks.add(taskName)) {
                        BooleanQuery subq = new BooleanQuery();
                        // Term term = new
                        // Term(YAWLTasksDocument.FIELDTASKS,
                        // taskName);
                        // TermQuery termQuery = new TermQuery(term);
                        // subq.add(termQuery, Occur.SHOULD);

                        TreeSet<SimilarLabelQueryResult> similarTasks = labelIndex.getSimilarLabels(taskName,
                                GlobalParameter.getLabelSemanticSimilarity());
                        Iterator<SimilarLabelQueryResult> it = similarTasks.iterator();
                        while (it.hasNext()) {
                            SimilarLabelQueryResult sl = it.next();
                            String similarTaskName = sl.getLabel();
                            Term term = new Term(YAWLTasksDocument.FIELDTASKS, similarTaskName);
                            TermQuery termQuery = new TermQuery(term);
                            subq.add(termQuery, Occur.SHOULD);
                        }
                        if (subq.getClauses().length > 0) {
                            bq.add(subq, Occur.MUST);
                        } else {
                            return ret;
                        }
                    }
                }
            } else {
                // label similarity is not enabled
                for (YTask task : query.getNetTasks()) {
                    String taskName = task.getName().trim();
                    if (expandedTasks.add(taskName)) {
                        Term term = new Term(YAWLTasksDocument.FIELDTASKS, taskName);
                        TermQuery termQuery = new TermQuery(term);
                        bq.add(termQuery, Occur.MUST);
                    }
                }
            }

            // for (YTask task : query.getNetTasks()) {
            // String taskName = task.getName().trim();
            // if (GlobalParameter.isEnableSimilarLabel()) {
            // // label similarity is enabled
            // if (expandedTasks.add(taskName)) {
            // BooleanQuery subq = new BooleanQuery();
            // // Term term = new
            // // Term(YAWLTasksDocument.FIELDTASKS,
            // // taskName);
            // // TermQuery termQuery = new TermQuery(term);
            // // subq.add(termQuery, Occur.SHOULD);
            //
            // TreeSet<SimilarLabelQueryResult> similarTasks = labelIndex
            // .getSimilarLabels(taskName, GlobalParameter
            // .getLabelSemanticSimilarity());
            // Iterator<SimilarLabelQueryResult> it = similarTasks
            // .iterator();
            // while (it.hasNext()) {
            // SimilarLabelQueryResult sl = it.next();
            // String similarTaskName = sl.getLabel();
            // Term term = new Term(
            // YAWLTasksDocument.FIELDTASKS,
            // similarTaskName);
            // TermQuery termQuery = new TermQuery(term);
            // subq.add(termQuery, Occur.SHOULD);
            // }
            // if (subq.getClauses().length > 0) {
            // bq.add(subq, Occur.MUST);
            // } else {
            // return ret;
            // }
            // }
            // } else {
            // // label similarity is not enabled
            // if (expandedTasks.add(taskName)) {
            // Term term = new Term(YAWLTasksDocument.FIELDTASKS,
            // taskName);
            // TermQuery termQuery = new TermQuery(term);
            // bq.add(termQuery, Occur.MUST);
            // }
            // }
            // }

            YAWLTasksQueryResultCollector collector = new YAWLTasksQueryResultCollector(reader);
            searcher.search(bq, collector);
            ret = collector.getQueryResult();
            searcher.close();
            reader.close();

            // sub graph isomorphism check using Ullman's algorithm
            // accurately match
            Iterator<ProcessQueryResult> it = ret.iterator();
            while (it.hasNext()) {
                ProcessQueryResult pqr = it.next();
                long process_id = pqr.getProcess_id();
                DataManager dm = DataManager.getInstance();
                YNet model = YAWLUtil.getYNetFromDefinition(dm.getProcessDefinitionBytes(process_id));
                if (!Ullman4YAWL.subGraphIsomorphism(query, model)) {
                    it.remove();
                }
                // if (!VF24YAWL.subGraphIsomorphism(query, model)) {
                // it.remove();
                // }
            }

        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return ret;
}

From source file:com.amalto.core.storage.hibernate.LuceneQueryGenerator.java

License:Open Source License

@Override
public Query visit(Compare condition) {
    condition.getLeft().accept(this);
    Expression right = condition.getRight();
    right.accept(this);
    if (condition.getPredicate() == Predicate.EQUALS || condition.getPredicate() == Predicate.CONTAINS
            || condition.getPredicate() == Predicate.STARTS_WITH) {
        String searchValue = String.valueOf(currentValue);
        BooleanQuery termQuery = new BooleanQuery();
        if (searchValue != null && searchValue.startsWith("\'") && searchValue.endsWith("\'")) { //$NON-NLS-1$ //$NON-NLS-2$
            PhraseQuery query = new PhraseQuery();
            StringTokenizer tokenizer = new StringTokenizer(searchValue.substring(1, searchValue.length() - 1));
            while (tokenizer.hasMoreTokens()) {
                query.add(new Term(currentFieldName, tokenizer.nextToken().toLowerCase()));
            }/*from   w  w w  . j  a v  a  2s . c  o m*/
            termQuery.add(query, BooleanClause.Occur.SHOULD);
        } else {
            StringTokenizer tokenizer = new StringTokenizer(searchValue);
            while (tokenizer.hasMoreTokens()) {
                TermQuery newTermQuery = new TermQuery(
                        new Term(currentFieldName, tokenizer.nextToken().toLowerCase()));
                termQuery.add(newTermQuery,
                        isBuildingNot ? BooleanClause.Occur.MUST_NOT : BooleanClause.Occur.MUST);
                if (condition.getPredicate() == Predicate.STARTS_WITH) {
                    break;
                }
            }
        }
        return termQuery;
    } else if (condition.getPredicate() == Predicate.GREATER_THAN
            || condition.getPredicate() == Predicate.GREATER_THAN_OR_EQUALS
            || condition.getPredicate() == Predicate.LOWER_THAN
            || condition.getPredicate() == Predicate.LOWER_THAN_OR_EQUALS) {
        throw new RuntimeException("Greater than, less than are not supported in full text searches."); //$NON-NLS-1$
    } else {
        throw new NotImplementedException("No support for predicate '" + condition.getPredicate() + "'"); //$NON-NLS-1$ //$NON-NLS-2$
    }
}

From source file:com.amalto.core.storage.hibernate.LuceneQueryGenerator.java

License:Open Source License

@Override
public Query visit(BinaryLogicOperator condition) {
    Query left = condition.getLeft().accept(this);
    Query right = condition.getRight().accept(this);
    BooleanQuery query = new BooleanQuery();
    if (condition.getPredicate() == Predicate.OR) {
        query.add(left, BooleanClause.Occur.SHOULD);
        query.add(right, BooleanClause.Occur.SHOULD);
    } else if (condition.getPredicate() == Predicate.AND) {
        query.add(left, isNotQuery(left) ? BooleanClause.Occur.SHOULD : BooleanClause.Occur.MUST);
        query.add(right, isNotQuery(right) ? BooleanClause.Occur.SHOULD : BooleanClause.Occur.MUST);
    } else {/*ww w.j  ava  2  s.  c  om*/
        throw new NotImplementedException("No support for '" + condition.getPredicate() + "'."); //$NON-NLS-1$ //$NON-NLS-2$
    }
    return query;
}

From source file:com.amalto.core.storage.hibernate.LuceneQueryGenerator.java

License:Open Source License

@Override
public Query visit(final FullText fullText) {
    // TODO Test me on conditions where many types share same field names.
    final Map<String, Boolean> fieldsMap = new HashMap<String, Boolean>();
    for (final ComplexTypeMetadata type : types) {
        type.accept(new DefaultMetadataVisitor<Void>() {

            @Override/*from  w  ww.  j a  v a 2s  .co  m*/
            public Void visit(ContainedComplexTypeMetadata containedType) {
                super.visit(containedType);
                for (ComplexTypeMetadata subType : containedType.getSubTypes()) {
                    subType.accept(this);
                }
                return null;
            }

            @Override
            public Void visit(ReferenceFieldMetadata referenceField) {
                ComplexTypeMetadata referencedType = referenceField.getReferencedType();
                if (!referencedType.isInstantiable()) {
                    referencedType.accept(this);
                }
                return null;
            }

            @Override
            public Void visit(SimpleTypeFieldMetadata simpleField) {
                if (!Storage.METADATA_TIMESTAMP.equals(simpleField.getName())
                        && !Storage.METADATA_TASK_ID.equals(simpleField.getName())) {
                    if (StorageMetadataUtils.isValueSearchable(fullText.getValue(), simpleField)) {
                        fieldsMap.put(simpleField.getName(), simpleField.isKey());
                    }
                }
                return null;
            }

            @Override
            public Void visit(EnumerationFieldMetadata enumField) {
                if (StorageMetadataUtils.isValueAssignable(fullText.getValue(), enumField)) {
                    fieldsMap.put(enumField.getName(), enumField.isKey());
                }
                return null;
            }
        });
    }

    String[] fieldsAsArray = fieldsMap.keySet().toArray(new String[fieldsMap.size()]);
    StringBuilder queryBuffer = new StringBuilder();
    Iterator<Map.Entry<String, Boolean>> fieldsIterator = fieldsMap.entrySet().iterator();
    String fullTextValue = getFullTextValue(fullText);
    BooleanQuery query = new BooleanQuery();
    Query idQuery = null;
    while (fieldsIterator.hasNext()) {
        Map.Entry<String, Boolean> next = fieldsIterator.next();
        if (next.getValue()) {
            queryBuffer.append(next.getKey()).append(ToLowerCaseFieldBridge.ID_POSTFIX + ':')
                    .append(fullTextValue);
            idQuery = new PrefixQuery(new Term(next.getKey(), fullText.getValue()));
        } else {
            queryBuffer.append(next.getKey()).append(':').append(fullTextValue);
        }
        if (fieldsIterator.hasNext()) {
            queryBuffer.append(" OR "); //$NON-NLS-1$
        }
    }

    String fullTextQuery = queryBuffer.toString();
    if (idQuery != null) {
        query.add(idQuery, BooleanClause.Occur.SHOULD);
    }
    query.add(parseQuery(fieldsAsArray, fullTextQuery, fullText.getValue()), BooleanClause.Occur.SHOULD);
    return query;
}

From source file:com.amalto.core.storage.hibernate.LuceneQueryGenerator.java

License:Open Source License

@Override
public Query visit(FieldFullText fieldFullText) {
    String fieldName = fieldFullText.getField().getFieldMetadata().getName();
    String[] fieldsAsArray = new String[] { fieldName };
    String fullTextValue = getFullTextValue(fieldFullText);
    String fullTextQuery = fieldName + ':' + fullTextValue;
    if (fieldFullText.getField().getFieldMetadata().isKey()) {
        BooleanQuery query = new BooleanQuery();
        query.add(new PrefixQuery(new Term(fieldName, fieldFullText.getValue())), BooleanClause.Occur.SHOULD);
        fieldsAsArray = new String[] { fieldName + ToLowerCaseFieldBridge.ID_POSTFIX };
        fullTextQuery = fieldName + ToLowerCaseFieldBridge.ID_POSTFIX + ":" + fullTextValue; //$NON-NLS-1$
        query.add(parseQuery(fieldsAsArray, fullTextQuery, fieldFullText.getValue()),
                BooleanClause.Occur.SHOULD);
        return query;
    }//from   ww  w  . j  a v a  2 s  .  c  o  m
    return parseQuery(fieldsAsArray, fullTextQuery, fieldFullText.getValue());
}