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

Introduction

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

Prototype

public MultiFieldQueryParser(String[] fields, Analyzer analyzer) 

Source Link

Document

Creates a MultiFieldQueryParser.

Usage

From source file:org.wallride.repository.ArticleRepositoryImpl.java

License:Apache License

private FullTextQuery buildFullTextQuery(ArticleSearchRequest request, Pageable pageable, Criteria criteria) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Article.class)
            .get();//from  w  w  w  .  j  a  va 2  s .  c  o m

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    junction.must(qb.keyword().onField("drafted").ignoreAnalyzer().matching("_null_").createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "title", "body", "categories.name", "tags.name",
                "customFieldValues.value" };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }
    if (request.getStatus() != null) {
        junction.must(qb.keyword().onField("status").matching(request.getStatus()).createQuery());
    }
    if (StringUtils.hasText(request.getLanguage())) {
        junction.must(qb.keyword().onField("language").matching(request.getLanguage()).createQuery());
    }

    if (request.getDateFrom() != null) {
        junction.must(qb.range().onField("date").above(request.getDateFrom()).createQuery());
    }
    if (request.getDateTo() != null) {
        junction.must(qb.range().onField("date").below(request.getDateTo()).createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getCategoryIds())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (long categoryId : request.getCategoryIds()) {
            subJunction.should(qb.keyword().onField("categories.id").matching(categoryId).createQuery());
        }
        junction.must(subJunction.createQuery());
    }
    if (!CollectionUtils.isEmpty(request.getCategoryCodes())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (String categoryCode : request.getCategoryCodes()) {
            subJunction.should(qb.keyword().onField("categories.code").matching(categoryCode).createQuery());
        }
        junction.must(subJunction.createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getTagIds())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (long tagId : request.getTagIds()) {
            subJunction.should(qb.keyword().onField("tags.id").matching(tagId).createQuery());
        }
        junction.must(subJunction.createQuery());
    }
    if (!CollectionUtils.isEmpty(request.getTagNames())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (String tagName : request.getTagNames()) {
            subJunction.should(qb.phrase().onField("tags.name").sentence(tagName).createQuery());
        }
        junction.must(subJunction.createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getCustomFields())) {
        javax.persistence.Query query = entityManager.createQuery(
                "from CustomField where language = :language and code in (:codes)", CustomField.class);
        query.setParameter("language", request.getLanguage()).setParameter("codes",
                request.getCustomFields().keySet());
        List<CustomField> customFields = query.getResultList();

        if (!CollectionUtils.isEmpty(customFields)) {
            Map<String, CustomField> customFieldMap = customFields.stream()
                    .collect(Collectors.toMap(CustomField::getCode, Function.identity()));

            BooleanJunction<BooleanJunction> subJunction = qb.bool();
            for (String key : request.getCustomFields().keySet()) {
                List<Object> values = (List<Object>) request.getCustomFields().get(key);
                CustomField target = customFieldMap.get(key);
                BooleanJunction<BooleanJunction> customFieldJunction = qb.bool();
                switch (target.getFieldType()) {
                case TEXT:
                case TEXTAREA:
                case HTML:
                    for (Object value : values) {
                        customFieldJunction.must(qb.keyword().onField("customFieldValues." + key)
                                .ignoreFieldBridge().matching(value.toString()).createQuery());
                    }
                    break;
                default:
                    for (Object value : values) {
                        customFieldJunction.must(qb.phrase().onField("customFieldValues." + key)
                                .ignoreFieldBridge().sentence(value.toString()).createQuery());
                    }
                }
                subJunction.must(customFieldJunction.createQuery());
            }
            junction.must(subJunction.createQuery());
        }
    }

    if (request.getAuthorId() != null) {
        junction.must(qb.keyword().onField("author.id").matching(request.getAuthorId()).createQuery());
    }

    Query searchQuery = junction.createQuery();

    Sort sort = new Sort(new SortField("sortDate", SortField.Type.STRING, true),
            new SortField("sortId", SortField.Type.LONG, true));

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, Article.class)
            .setCriteriaQuery(criteria).setSort(sort);
    if (pageable != null) {
        persistenceQuery.setFirstResult(pageable.getOffset());
        persistenceQuery.setMaxResults(pageable.getPageSize());
    }
    return persistenceQuery;
}

---

From source file:org.wallride.repository.CategoryRepositoryImpl.java

License:Apache License

@Override
public Page<Category> search(CategorySearchRequest request, Pageable pageable) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Category.class)
            .get();//  w w  w. ja  v  a  2 s .  c  o m

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "name" };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }

    if (StringUtils.hasText(request.getLanguage())) {
        junction.must(qb.keyword().onField("language").matching(request.getLanguage()).createQuery());
    }

    Query searchQuery = junction.createQuery();

    Session session = (Session) entityManager.getDelegate();
    Criteria criteria = session.createCriteria(Category.class);

    Sort sort = new Sort(new SortField("sortName", SortField.Type.STRING));

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, Category.class)
            .setCriteriaQuery(criteria).setSort(sort);
    if (pageable != null) {
        persistenceQuery.setFirstResult(pageable.getOffset());
        persistenceQuery.setMaxResults(pageable.getPageSize());
    }

    int resultSize = persistenceQuery.getResultSize();

    @SuppressWarnings("unchecked")
    List<Category> results = persistenceQuery.getResultList();
    return new PageImpl<>(results, pageable, resultSize);
}

---

From source file:org.wallride.repository.CommentRepositoryImpl.java

License:Apache License

@Override
public Page<Comment> search(CommentSearchRequest request, Pageable pageable) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Comment.class)
            .get();/*from ww  w  .  jav a2 s .co m*/

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "authorName", "content" };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }

    if (StringUtils.hasText(request.getLanguage())) {
        junction.must(qb.keyword().onField("post.language").matching(request.getLanguage()).createQuery());
    }

    if (request.getPostId() != null) {
        junction.must(qb.keyword().onField("post.id").matching(request.getPostId()).createQuery());
    }

    if (request.getApproved() != null) {
        junction.must(qb.keyword().onField("approved").matching(request.getApproved()).createQuery());
    }

    Query searchQuery = junction.createQuery();

    Session session = (Session) entityManager.getDelegate();
    Criteria criteria = session.createCriteria(Comment.class).setFetchMode("post", FetchMode.JOIN)
            .setFetchMode("author", FetchMode.JOIN);

    Sort sort = null;
    if (pageable.getSort() != null) {
        if (pageable.getSort().getOrderFor("date") != null) {
            Order order = pageable.getSort().getOrderFor("date");
            sort = new Sort(
                    new SortField("sortDate", SortField.Type.STRING,
                            order.getDirection().equals(Direction.DESC)),
                    new SortField("sortId", SortField.Type.LONG, order.getDirection().equals(Direction.DESC)));
        }
    }

    if (sort == null) {
        sort = new Sort(new SortField("sortDate", SortField.Type.STRING),
                new SortField("sortId", SortField.Type.LONG));
    }

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, Comment.class)
            .setCriteriaQuery(criteria).setSort(sort);
    persistenceQuery.setFirstResult(pageable.getOffset());
    persistenceQuery.setMaxResults(pageable.getPageSize());

    int resultSize = persistenceQuery.getResultSize();

    @SuppressWarnings("unchecked")
    List<Comment> results = persistenceQuery.getResultList();
    return new PageImpl<>(results, pageable, resultSize);
}

---

From source file:org.wallride.repository.CustomFieldRepositoryImpl.java

License:Apache License

public FullTextQuery buildFullTextQuery(CustomFieldSearchRequest request, Pageable pageable,
        Criteria criteria) {/*from  www.  j  a v  a 2s .  co m*/
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(CustomField.class)
            .get();

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "name", "code", "description" };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }

    if (StringUtils.hasText(request.getLanguage())) {
        junction.must(qb.keyword().onField("language").matching(request.getLanguage()).createQuery());
    }

    Query searchQuery = junction.createQuery();

    Sort sort = new Sort(new SortField("idx", SortField.Type.INT));

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, CustomField.class)
            .setCriteriaQuery(criteria).setSort(sort);
    if (pageable != null) {
        persistenceQuery.setFirstResult(pageable.getOffset());
        persistenceQuery.setMaxResults(pageable.getPageSize());
    }
    return persistenceQuery;
}

---

From source file:org.wallride.repository.PageRepositoryImpl.java

License:Apache License

private FullTextQuery buildFullTextQuery(PageSearchRequest request, Pageable pageable, Criteria criteria) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Page.class).get();

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    junction.must(qb.keyword().onField("drafted").ignoreAnalyzer().matching("_null_").createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "title", "body", "tags.name", };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;// w  w  w. j a va 2s .c  o  m
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }
    if (StringUtils.hasText(request.getLanguage())) {
        junction.must(qb.keyword().onField("language").matching(request.getLanguage()).createQuery());
    }

    if (request.getStatus() != null) {
        junction.must(qb.keyword().onField("status").matching(request.getStatus()).createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getCategoryIds())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (long categoryId : request.getCategoryIds()) {
            subJunction.should(qb.keyword().onField("categories.id").matching(categoryId).createQuery());
        }
        junction.must(subJunction.createQuery());
    }
    if (!CollectionUtils.isEmpty(request.getCategoryCodes())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (String categoryCode : request.getCategoryCodes()) {
            subJunction.should(qb.keyword().onField("categories.code").matching(categoryCode).createQuery());
        }
        junction.must(subJunction.createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getTagIds())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (long tagId : request.getTagIds()) {
            subJunction.should(qb.keyword().onField("tags.id").matching(tagId).createQuery());
        }
        junction.must(subJunction.createQuery());
    }
    if (!CollectionUtils.isEmpty(request.getTagNames())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (String tagName : request.getTagNames()) {
            subJunction.should(qb.phrase().onField("tags.name").sentence(tagName).createQuery());
        }
        junction.must(subJunction.createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getCustomFields())) {
        javax.persistence.Query query = entityManager.createQuery(
                "from CustomField where language = :language and code in (:codes)", CustomField.class);
        query.setParameter("language", request.getLanguage()).setParameter("codes",
                request.getCustomFields().keySet());
        List<CustomField> customFields = query.getResultList();

        if (!CollectionUtils.isEmpty(customFields)) {
            Map<String, CustomField> customFieldMap = customFields.stream()
                    .collect(Collectors.toMap(CustomField::getCode, Function.identity()));

            BooleanJunction<BooleanJunction> subJunction = qb.bool();
            for (String key : request.getCustomFields().keySet()) {
                List<Object> values = (List<Object>) request.getCustomFields().get(key);
                CustomField target = customFieldMap.get(key);
                subJunction.should(qb.keyword().onField("customFieldValues.customField.id")
                        .matching(target.getId()).createQuery());
                switch (target.getFieldType()) {
                case TEXT:
                case TEXTAREA:
                case HTML:
                    for (Object value : values) {
                        subJunction.must(
                                qb.phrase().onField("customFieldValues." + target.getFieldType().getValueType())
                                        .sentence(value.toString()).createQuery());
                    }
                    break;
                default:
                    for (Object value : values) {
                        subJunction.must(qb.keyword()
                                .onField("customFieldValues." + target.getFieldType().getValueType())
                                .matching(value.toString()).createQuery());
                    }
                }
            }
            junction.must(subJunction.createQuery());
        }
    }

    if (request.getAuthorId() != null) {
        junction.must(qb.keyword().onField("author.id").matching(request.getAuthorId()).createQuery());
    }

    Query searchQuery = junction.createQuery();

    Sort sort = new Sort(new SortField("sortLft", SortField.Type.INT));

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, Page.class)
            .setCriteriaQuery(criteria).setSort(sort);
    if (pageable != null) {
        persistenceQuery.setFirstResult(pageable.getOffset());
        persistenceQuery.setMaxResults(pageable.getPageSize());
    }
    return persistenceQuery;
}

---

From source file:org.wallride.repository.PostRepositoryImpl.java

License:Apache License

@Override
public Page<Post> search(PostSearchRequest request, Pageable pageable) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Post.class).get();

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    junction.must(qb.keyword().onField("drafted").ignoreAnalyzer().matching("_null_").createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "title", "body", "tags.name", };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;/*from  www.j  a  v a 2 s  .  c om*/
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }
    if (request.getStatus() != null) {
        junction.must(qb.keyword().onField("status").matching(request.getStatus()).createQuery());
    }
    if (StringUtils.hasText(request.getLanguage())) {
        junction.must(qb.keyword().onField("language").matching(request.getLanguage()).createQuery());
    }

    if (request.getDateFrom() != null) {
        junction.must(qb.range().onField("date").above(request.getDateFrom()).createQuery());
    }
    if (request.getDateTo() != null) {
        junction.must(qb.range().onField("date").below(request.getDateTo()).createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getTagNames())) {
        BooleanJunction<BooleanJunction> subJunction = qb.bool();
        for (String tagName : request.getTagNames()) {
            subJunction.should(qb.phrase().onField("tags.name").sentence(tagName).createQuery());
        }
        junction.must(subJunction.createQuery());
    }

    if (!CollectionUtils.isEmpty(request.getPostIds())) {
        BooleanJunction<BooleanJunction> bool = qb.bool();
        for (long postId : request.getPostIds()) {
            bool.should(qb.keyword().onField("id").matching(postId).createQuery());
        }
        junction.must(bool.createQuery());
    }

    Query searchQuery = junction.createQuery();

    Session session = (Session) entityManager.getDelegate();
    Criteria criteria = session.createCriteria(Post.class).setFetchMode("cover", FetchMode.JOIN)
            .setFetchMode("tags", FetchMode.JOIN).setFetchMode("categories", FetchMode.JOIN)
            .setFetchMode("customFieldValues", FetchMode.JOIN)
            .setFetchMode("customFieldValues.customField", FetchMode.JOIN)
            .setFetchMode("author", FetchMode.JOIN);

    Sort sort = new Sort(new SortField("sortDate", SortField.Type.STRING, true),
            new SortField("sortId", SortField.Type.LONG, true));

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, Post.class)
            .setCriteriaQuery(criteria).setSort(sort);
    persistenceQuery.setFirstResult(pageable.getOffset());
    persistenceQuery.setMaxResults(pageable.getPageSize());

    int resultSize = persistenceQuery.getResultSize();

    @SuppressWarnings("unchecked")
    List<Post> results = persistenceQuery.getResultList();
    return new PageImpl<>(results, pageable, resultSize);
}

---

From source file:org.wallride.repository.TagRepositoryImpl.java

License:Apache License

@Override
public Page<Tag> search(TagSearchRequest request, Pageable pageable) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Tag.class).get();

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "name" };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;//from   ww  w  . ja va 2 s.co m
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }

    if (StringUtils.hasText(request.getLanguage())) {
        junction.must(qb.keyword().onField("language").matching(request.getLanguage()).createQuery());
    }

    Query searchQuery = junction.createQuery();

    Session session = (Session) entityManager.getDelegate();
    Criteria criteria = session.createCriteria(Tag.class);

    Sort sort = new Sort(new SortField("sortName", SortField.Type.STRING));

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, Tag.class)
            .setCriteriaQuery(criteria).setSort(sort);
    persistenceQuery.setFirstResult(pageable.getOffset());
    persistenceQuery.setMaxResults(pageable.getPageSize());

    int resultSize = persistenceQuery.getResultSize();

    @SuppressWarnings("unchecked")
    List<Tag> results = persistenceQuery.getResultList();
    return new PageImpl<>(results, pageable, resultSize);
}

---

From source file:org.wallride.repository.UserRepositoryImpl.java

License:Apache License

private FullTextQuery buildFullTextQuery(UserSearchRequest request, Pageable pageable, Criteria criteria) {
    FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
    QueryBuilder qb = fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(User.class).get();

    @SuppressWarnings("rawtypes")
    BooleanJunction<BooleanJunction> junction = qb.bool();
    junction.must(qb.all().createQuery());

    if (StringUtils.hasText(request.getKeyword())) {
        Analyzer analyzer = fullTextEntityManager.getSearchFactory().getAnalyzer("synonyms");
        String[] fields = new String[] { "loginId", "name.firstName", "name.lastName", };
        MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, analyzer);
        parser.setDefaultOperator(QueryParser.Operator.AND);
        Query query = null;/*from   w w w .  j a va  2  s  .  co  m*/
        try {
            query = parser.parse(request.getKeyword());
        } catch (ParseException e1) {
            try {
                query = parser.parse(QueryParser.escape(request.getKeyword()));
            } catch (ParseException e2) {
                throw new RuntimeException(e2);
            }
        }
        junction.must(query);
    }

    if (!CollectionUtils.isEmpty(request.getRoles())) {
        for (User.Role role : request.getRoles()) {
            junction.must(qb.keyword().onField("roles").matching(role).createQuery());
        }
    }

    Query searchQuery = junction.createQuery();

    Sort sort = new Sort(new SortField("sortId", SortField.Type.LONG, false));

    FullTextQuery persistenceQuery = fullTextEntityManager.createFullTextQuery(searchQuery, User.class)
            .setCriteriaQuery(criteria)
            //            .setProjection("id")
            .setSort(sort);
    if (pageable != null) {
        persistenceQuery.setFirstResult(pageable.getOffset());
        persistenceQuery.setMaxResults(pageable.getPageSize());
    }
    return persistenceQuery;
}

---

From source file:persistence.lucene.search.QueryExecutorHelper.java

License:Open Source License

List<QueryResult> queryDocuments(final String query, final String[] fields, final String user)
        throws ParseException, IOException, InvalidTokenOffsetsException {
    int hitsPerPage = 10;
    MultiFieldQueryParser queryParser = new MultiFieldQueryParser(fields, new StandardAnalyzer());

    Query luceneQuery = queryParser.parse(query);
    Highlighter highlighter = new Highlighter(new QueryScorer(luceneQuery));

    DirectoryReader indexReader = DirectoryReader.open(directory);
    IndexSearcher searcher = new IndexSearcher(indexReader);

    TopScoreDocCollector collector = TopScoreDocCollector.create(hitsPerPage, true);
    TermsFilter filter = new TermsFilter(new Term(FullTextSearchResource.DOCUMENT_OWNER, user.toLowerCase()));
    searcher.search(luceneQuery, filter, collector);

    ScoreDoc[] docs = collector.topDocs().scoreDocs;
    List<QueryResult> resultBeans = new ArrayList<>(docs.length);
    for (ScoreDoc doc : docs) {
        Document document = searcher.doc(doc.doc);
        String text = document.get(FullTextSearchResource.DOCUMENT_CONTENT_FIELD);
        TokenStream tokenStream = TokenSources.getAnyTokenStream(searcher.getIndexReader(), doc.doc,
                FullTextSearchResource.DOCUMENT_CONTENT_FIELD, standardAnalyzer);
        TextFragment[] fragments = highlighter.getBestTextFragments(tokenStream, text, false, 10);

        resultBeans.add(new QueryResult(doc.doc, doc.score, document, fragments));
    }//from  w ww .ja va 2s .co m

    indexReader.close();
    return resultBeans;
}

---

From source file:searching.SearchFiles.java

License:Apache License

private SearchResult executeSearch(String queryString, int startResult, int numberOfResults,
        String[] fieldnames) {//from w w w.  j a va2 s .c o  m
    SearchResult searchResult = null;

    try {
        QueryParser parser = new MultiFieldQueryParser(fieldnames, Config.analyzer);

        queryString = queryString.trim();

        if (queryString.length() == 0) {
            return null;
        }

        Query query = parser.parse(queryString);
        //         System.out.println("Query: " + query.toString());

        searchResult = doPagingSearch(searcher, query, startResult, numberOfResults);

    } catch (IOException e) {
        e.printStackTrace();
    } catch (ParseException e) {
        e.printStackTrace();
    } catch (InvalidAttributeValueException e) {
        e.printStackTrace();
    }

    return searchResult;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• »