Example usage for org.apache.solr.client.solrj SolrQuery setStart

List of usage examples for org.apache.solr.client.solrj SolrQuery setStart

  1. HOME
  2. Java
  3. org.apache.solr
  4. org.apache.solr.client.solrj.*
  5. SolrQuery
  6. setStart

Introduction

In this page you can find the example usage for org.apache.solr.client.solrj SolrQuery setStart.

Prototype

public SolrQuery setStart(Integer start)

Source Link

Usage

From source file:org.pentaho.di.trans.steps.solrinput.SolrInput.java

License:Apache License

/**
 * Once the transformation starts executing, the processRow() method is called repeatedly
 * by PDI for as long as it returns true. To indicate that a step has finished processing rows
 * this method must call setOutputDone() and return false;
 * /* ww w  .  j a v a 2s .co  m*/
 * Steps which process incoming rows typically call getRow() to read a single row from the
 * input stream, change or add row content, call putRow() to pass the changed row on 
 * and return true. If getRow() returns null, no more rows are expected to come in, 
 * and the processRow() implementation calls setOutputDone() and returns false to
 * indicate that it is done too.
 * 
 * Steps which generate rows typically construct a new row Object[] using a call to
 * RowDataUtil.allocateRowData(numberOfFields), add row content, and call putRow() to
 * pass the new row on. Above process may happen in a loop to generate multiple rows,
 * at the end of which processRow() would call setOutputDone() and return false;
 * 
 * @param smi the step meta interface containing the step settings
 * @param sdi the step data interface that should be used to store
 * 
 * @return true to indicate that the function should be called again, false if the step is done
 */
public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException {

    if (first) {
        first = false;
        // Create the output row meta-data
        data.outputRowMeta = new RowMeta();
        meta.getFields(data.outputRowMeta, getStepname(), null, null, this, repository, metaStore);
        // For String to <type> conversions, we allocate a conversion meta data row as well...
        data.convertRowMeta = data.outputRowMeta.cloneToType(ValueMetaInterface.TYPE_STRING);

        // get real values
        boolean tryCursor = true;
        Integer startRecord = 0;
        Integer chunkRowSize = 20;
        String realURL = meta.getURL();
        String realQ = meta.getQ();
        String realSort = meta.getSort();
        String realCursor = meta.getCursor();
        String realFq = meta.getFq();
        String realFl = meta.getFl();
        String realFacetQuery = meta.getFacetQuery();
        String realFacetField = meta.getFacetField();
        /* Send and Get the report */
        SolrQuery query = new SolrQuery();
        query.set("rows", chunkRowSize);
        if (realQ != null && !realQ.equals("")) {
            query.set("q", realQ);
        }
        if (realSort != null && !realSort.equals("")) {
            query.set("sort", realSort);
        } else {
            tryCursor = false;
        }
        if (realCursor != null && !realCursor.equals("")) {
            if (realCursor.equals("No")) {
                tryCursor = false;
            }
        }
        if (realFl != null && !realFl.equals("")) {
            query.set("fl", realFl);
        }
        if (realFq != null && !realFq.equals("")) {
            query.set("fq", realFq);
        }
        if (realFacetField != null && !realFacetField.equals("")) {
            //TODO incorporate multiple facet fields at once
            //String[] facetFields = realFacetField.split("\\s*,\\s*");
            //for(int i =0; i < facetFields.length; i++){
            query.addFacetField(realFacetField);
            //}
            query.setFacet(true);
            query.setFacetLimit(-1);
            query.setFacetMinCount(0);
            query.setFacetSort("count");
            query.set("rows", 0);
            tryCursor = false;
            data.facetRequested = true;
        }
        if (realFacetQuery != null && !realFacetQuery.equals("")) {
            query.addFacetQuery(realFacetQuery);
        }
        // You can't use "TimeAllowed" with "CursorMark"
        // The documentation says "Values <= 0 mean 
        // no time restriction", so setting to 0.
        query.setTimeAllowed(0);
        HttpSolrServer solr = new HttpSolrServer(realURL);
        String cursorMark = CursorMarkParams.CURSOR_MARK_START;
        boolean done = false;
        QueryResponse rsp = null;
        while (!done) {
            if (tryCursor) {
                query.set(CursorMarkParams.CURSOR_MARK_PARAM, cursorMark);
            } else {
                query.setStart(startRecord);
            }
            try {
                rsp = solr.query(query);
            } catch (SolrServerException e) {
                e.printStackTrace();
            }
            if (data.facetRequested) {
                data.facetCountName = rsp.getFacetFields().get(0).getName();
                data.facetCounts = rsp.getFacetFields().get(0).getValues();
                done = true;
            } else {
                SolrDocumentList theseDocs = rsp.getResults();
                for (SolrDocument doc : theseDocs) {
                    data.documentList.add(doc);
                }
            }
            if (tryCursor) {
                String nextCursorMark = rsp.getNextCursorMark();
                if (cursorMark.equals(nextCursorMark)) {
                    done = true;
                } else {
                    cursorMark = nextCursorMark;
                }
            } else {
                startRecord = startRecord + chunkRowSize;
                if (startRecord >= rsp.getResults().getNumFound()) {
                    done = true;
                }
            }
        }
    }

    Object[] outputRowData = null;

    try {
        if (data.facetRequested) {
            // get one row if we can
            if (data.facetCounts.size() - 1 < data.recordIndex) {
                setOutputDone();
                return false;
            }
            FacetField.Count facetRecord = data.facetCounts.get(data.recordIndex);
            outputRowData = prepareFacetRecord(facetRecord);
        } else {
            // get one row if we can
            if (data.documentList.size() - 1 < data.recordIndex) {
                setOutputDone();
                return false;
            }
            SolrDocument record = data.documentList.get(data.recordIndex);
            outputRowData = prepareRecord(record);
        }
        putRow(data.outputRowMeta, outputRowData); // copy row to output rowset(s);
        data.recordIndex++;
        return true;
    } catch (KettleException e) {
        boolean sendToErrorRow = false;
        String errorMessage = null;
        if (getStepMeta().isDoingErrorHandling()) {
            sendToErrorRow = true;
            errorMessage = e.toString();
        } else {
            logError(BaseMessages.getString(PKG, "SolrInput.log.Exception", e.getMessage()));
            logError(Const.getStackTracker(e));
            setErrors(1);
            stopAll();
            setOutputDone(); // signal end to receiver(s)
            return false;
        }
        if (sendToErrorRow) {
            // Simply add this row to the error row
            putError(getInputRowMeta(), outputRowData, 1, errorMessage, null, "SolrInput001");
        }
    }
    return true;
}

From source file:org.pentaho.di.ui.trans.steps.solrinput.SolrInputDialog.java

License:Apache License

private void getFields() {

    try {//from   www  .j  a  va2 s .  co  m
        SolrInputMeta meta = new SolrInputMeta();
        getInfo(meta);
        // clear the current fields grid
        wFields.removeAll();
        // get real values
        boolean tryCursor = true;
        boolean facetRequested = false;
        Integer startRecord = 0;
        Integer chunkRowSize = 20;
        String realURL = transMeta.environmentSubstitute(meta.getURL());
        String realQ = transMeta.environmentSubstitute(meta.getQ());
        String realSort = transMeta.environmentSubstitute(meta.getSort());
        String realCursor = transMeta.environmentSubstitute(meta.getCursor());
        String realFq = transMeta.environmentSubstitute(meta.getFq());
        String realFl = transMeta.environmentSubstitute(meta.getFl());
        String realFacetQuery = transMeta.environmentSubstitute(meta.getFacetQuery());
        String realFacetField = transMeta.environmentSubstitute(meta.getFacetField());
        /* Send and Get the report */
        SolrQuery query = new SolrQuery();
        query.set("rows", chunkRowSize);
        if (realQ != null && !realQ.equals("")) {
            query.set("q", realQ);
        }
        if (realSort != null && !realSort.equals("")) {
            query.set("sort", realSort);
        } else {
            tryCursor = false;
        }
        if (realCursor != null && !realCursor.equals("")) {
            if (realCursor.equals("No")) {
                tryCursor = false;
            }
        }
        if (realFl != null && !realFl.equals("")) {
            query.set("fl", realFl);
        }
        if (realFq != null && !realFq.equals("")) {
            query.set("fq", realFq);
        }
        if (realFacetField != null && !realFacetField.equals("")) {
            //TODO incorporate multiple facet fields at once
            //String[] facetFields = realFacetField.split("\\s*,\\s*");
            //for(int i =0; i < facetFields.length; i++){
            query.addFacetField(realFacetField);
            //}
            query.setFacet(true);
            query.setFacetLimit(-1);
            query.setFacetMinCount(0);
            query.setFacetSort("count");
            query.set("rows", 0);
            tryCursor = false;
            facetRequested = true;
        }
        if (realFacetQuery != null && !realFacetQuery.equals("")) {
            query.addFacetQuery(realFacetQuery);
        }
        // You can't use "TimeAllowed" with "CursorMark"
        // The documentation says "Values <= 0 mean 
        // no time restriction", so setting to 0.
        query.setTimeAllowed(0);
        HttpSolrServer solr = new HttpSolrServer(realURL);
        String cursorMark = CursorMarkParams.CURSOR_MARK_START;
        boolean done = false;
        List<String> headerNames = new ArrayList<String>();
        QueryResponse rsp = null;
        while (!done) {
            if (tryCursor) {
                query.set(CursorMarkParams.CURSOR_MARK_PARAM, cursorMark);
            } else {
                query.setStart(startRecord);
            }
            try {
                rsp = solr.query(query);
            } catch (SolrServerException e) {
                e.printStackTrace();
            }
            if (facetRequested) {
                headerNames.add(rsp.getFacetFields().get(0).getName());
                headerNames.add("count");
                done = true;
            } else {
                SolrDocumentList docs = rsp.getResults();
                for (SolrDocument doc : docs) {
                    Collection<String> thisNamesArray = doc.getFieldNames();
                    String[] a = thisNamesArray.toArray(new String[thisNamesArray.size()]);
                    for (int j = 0; j < a.length; j++) {
                        if (!headerNames.contains(a[j])) {
                            headerNames.add(a[j]);
                        }
                    }
                }
            }
            if (tryCursor) {
                String nextCursorMark = rsp.getNextCursorMark();
                if (cursorMark.equals(nextCursorMark)) {
                    done = true;
                } else {
                    cursorMark = nextCursorMark;
                }
            } else {
                startRecord = startRecord + chunkRowSize;
                if (startRecord >= rsp.getResults().getNumFound()) {
                    done = true;
                }
            }
        }
        getTableView().table.setItemCount(headerNames.size());
        for (int j = 0; j < headerNames.size(); j++) {
            TableItem item = getTableView().table.getItem(j);
            item.setText(1, headerNames.get(j));
        }
        wFields.removeEmptyRows();
        wFields.setRowNums();
        wFields.optWidth(true);
        getInput().setChanged();
    } catch (Exception e) {
        new ErrorDialog(shell, BaseMessages.getString(PKG, "SolrInputMeta.ErrorRetrieveData.DialogTitle"),
                BaseMessages.getString(PKG, "SolrInputMeta.ErrorRetrieveData.DialogMessage"), e);
    }
}

From source file:org.roda.core.index.utils.SolrUtils.java

public static <T extends IsIndexed> IndexResult<T> find(SolrClient index, Class<T> classToRetrieve,
        Filter filter, Sorter sorter, Sublist sublist, Facets facets, List<String> fieldsToReturn)
        throws GenericException, RequestNotValidException {
    IndexResult<T> ret;/*  w w  w .j av a2s  . c om*/
    SolrQuery query = new SolrQuery();
    query.setParam("q.op", DEFAULT_QUERY_PARSER_OPERATOR);
    query.setQuery(parseFilter(filter));
    query.setSorts(parseSorter(sorter));
    query.setStart(sublist.getFirstElementIndex());
    query.setRows(sublist.getMaximumElementCount());
    if (!fieldsToReturn.isEmpty()) {
        query.setFields(fieldsToReturn.toArray(new String[fieldsToReturn.size()]));
    }
    parseAndConfigureFacets(facets, query);

    try {
        QueryResponse response = index.query(getIndexName(classToRetrieve).get(0), query);
        ret = queryResponseToIndexResult(response, classToRetrieve, facets, fieldsToReturn);
    } catch (SolrServerException | IOException e) {
        throw new GenericException("Could not query index", e);
    } catch (SolrException e) {
        throw new RequestNotValidException(e);
    } catch (RuntimeException e) {
        throw new GenericException("Unexpected exception while querying index", e);
    }

    return ret;
}

From source file:org.roda.core.index.utils.SolrUtils.java

public static <T extends IsIndexed> IndexResult<T> find(SolrClient index, Class<T> classToRetrieve,
        Filter filter, Sorter sorter, Sublist sublist, Facets facets, User user, boolean justActive,
        List<String> fieldsToReturn) throws GenericException, RequestNotValidException {
    IndexResult<T> ret;//from   ww w.ja va2  s  .c om
    SolrQuery query = new SolrQuery();
    query.setParam("q.op", DEFAULT_QUERY_PARSER_OPERATOR);
    query.setQuery(parseFilter(filter));
    query.setSorts(parseSorter(sorter));
    query.setStart(sublist.getFirstElementIndex());
    query.setRows(sublist.getMaximumElementCount());
    query.setFields(fieldsToReturn.toArray(new String[fieldsToReturn.size()]));
    parseAndConfigureFacets(facets, query);
    if (hasPermissionFilters(classToRetrieve)) {
        query.addFilterQuery(getFilterQueries(user, justActive, classToRetrieve));
    }

    try {
        QueryResponse response = index.query(getIndexName(classToRetrieve).get(0), query);
        ret = queryResponseToIndexResult(response, classToRetrieve, facets, fieldsToReturn);
    } catch (SolrServerException | IOException e) {
        throw new GenericException("Could not query index", e);
    } catch (SolrException e) {
        throw new RequestNotValidException(e.getMessage());
    } catch (RuntimeException e) {
        throw new GenericException("Unexpected exception while querying index", e);
    }

    return ret;
}

From source file:org.rsc.liferay.solr.SolrIndexSearcher.java

License:Open Source License

protected SolrQuery translateQuery(long companyId, Query query, Sort[] sorts, int start, int end)
        throws Exception {

    QueryConfig queryConfig = query.getQueryConfig();

    SolrQuery solrQuery = new SolrQuery();

    if (queryConfig.isHighlightEnabled()) {
        solrQuery.setHighlight(true);//from  w  w w.  j  a v a  2s  . c  om
        solrQuery.setHighlightFragsize(queryConfig.getHighlightFragmentSize());
        solrQuery.setHighlightSnippets(queryConfig.getHighlightSnippetSize());

        String localizedContentName = DocumentImpl.getLocalizedName(queryConfig.getLocale(), Field.CONTENT);

        String localizedTitleName = DocumentImpl.getLocalizedName(queryConfig.getLocale(), Field.TITLE);

        solrQuery.setParam("hl.fl", Field.CONTENT, localizedContentName, Field.TITLE, localizedTitleName);
    }

    solrQuery.setIncludeScore(queryConfig.isScoreEnabled());

    QueryTranslatorUtil.translateForSolr(query);

    String queryString = query.toString();

    StringBundler sb = new StringBundler(6);

    sb.append(queryString);
    sb.append(StringPool.SPACE);
    sb.append(StringPool.PLUS);
    sb.append(Field.COMPANY_ID);
    sb.append(StringPool.COLON);
    sb.append(companyId);

    solrQuery.setQuery(sb.toString());

    if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS)) {
        solrQuery.setRows(0);
    } else {
        solrQuery.setRows(end - start);
        solrQuery.setStart(start);
    }

    if (sorts != null) {
        for (Sort sort : sorts) {
            if (sort == null) {
                continue;
            }

            String sortFieldName = sort.getFieldName();

            if (DocumentImpl.isSortableTextField(sortFieldName)) {
                sortFieldName = DocumentImpl.getSortableFieldName(sortFieldName);
            }

            ORDER order = ORDER.asc;

            if (Validator.isNull(sortFieldName) || !sortFieldName.endsWith("sortable")) {

                sortFieldName = "score";

                order = ORDER.desc;
            }

            if (sort.isReverse()) {
                order = ORDER.desc;
            }

            solrQuery.addSort(new SortClause(sortFieldName, order));
        }
    }

    return solrQuery;
}

From source file:org.sakaiproject.nakamura.grouper.event.BatchJMSMessageProducer.java

License:Apache License

@Override
public void doGroups() throws SolrServerException, JMSException {
    int start = 0;
    int items = 25;

    SolrServer server = solrServerService.getServer();
    SolrQuery query = new SolrQuery();
    query.setQuery(allGroupsQuery);//from  ww w.  j  a  va  2 s  .  c  om
    query.setStart(start);
    query.setRows(items);

    QueryResponse response = server.query(query);
    long totalResults = response.getResults().getNumFound();

    List<String> groupIds = new ArrayList<String>();
    while (start < totalResults) {
        query.setStart(start);
        groupIds.clear();
        List<SolrDocument> resultDocs = response.getResults();
        for (SolrDocument doc : resultDocs) {
            String id = (String) doc.get("id");
            groupIds.add(id);
            // This is a HACK since I haven't figured out how to ask solr for the pseudo groups yet.
            for (String suffix : grouperConfiguration.getPseudoGroupSuffixes()) {
                groupIds.add(id + suffix);
                log.debug("Sending sync event for {}", id + suffix);
            }
        }
        sendGroupMessages(groupIds);
        start += resultDocs.size();
        log.debug("Found {} groups.", resultDocs.size());
    }
}

From source file:org.sakaiproject.nakamura.grouper.event.BatchJMSMessageProducer.java

License:Apache License

@Override
public void doContacts() throws SolrServerException, JMSException {
    int start = 0;
    int items = 25;

    SolrServer server = solrServerService.getServer();
    SolrQuery query = new SolrQuery();
    query.setQuery(allUsersQuery);/*  w w  w .  j ava2 s .c  o m*/
    query.setStart(start);
    query.setRows(items);

    QueryResponse response = server.query(query);
    long totalResults = response.getResults().getNumFound();

    List<String> groupIds = new ArrayList<String>();
    while (start < totalResults) {
        query.setStart(start);
        groupIds.clear();
        List<SolrDocument> resultDocs = response.getResults();
        for (SolrDocument doc : resultDocs) {
            groupIds.add("g-contacts-" + (String) doc.get("id"));
            log.debug("Syncing contacts for {}", (String) doc.get("id"));
        }
        sendGroupMessages(groupIds);

        start += resultDocs.size();
        log.debug("Found {} users.", resultDocs.size());
    }
}

From source file:org.sakaiproject.nakamura.search.solr.SolrResultSetFactory.java

License:Apache License

/**
 * @param request//w w  w .  ja v  a 2 s.  co  m
 * @param query
 * @param queryString
 * @return
 */
@SuppressWarnings("unchecked")
private SolrQuery buildQuery(SlingHttpServletRequest request, String queryString, Map<String, Object> options) {
    // build the query
    SolrQuery solrQuery = new SolrQuery(queryString);
    long[] ranges = SolrSearchUtil.getOffsetAndSize(request, options);
    solrQuery.setStart((int) ranges[0]);
    solrQuery.setRows((int) ranges[1]);

    // add in some options
    if (options != null) {
        for (Entry<String, Object> option : options.entrySet()) {
            String key = option.getKey();
            Object val = option.getValue();
            if (CommonParams.SORT.equals(key)) {
                parseSort(solrQuery, String.valueOf(val));
            } else if (val instanceof Object[]) {
                for (Object v : (Object[]) val) {
                    solrQuery.add(key, String.valueOf(v));
                }
            } else if (val instanceof Iterable) {
                for (Object v : (Iterable<Object>) val) {
                    solrQuery.add(key, String.valueOf(v));
                }
            } else {
                solrQuery.add(key, String.valueOf(val));
            }
        }
    }
    return solrQuery;
}

From source file:org.sakaiproject.nakamura.upgrade.servlet.TagMigrator.java

License:Apache License

private SolrDocumentList getMoreDocuments(int start) throws SolrServerException {
    SolrQuery query = new SolrQuery("tag:*");
    query.setFields("tag"); // we only need the tag field
    query.setRows(ROWS_PER_SEARCH);/*from  w w  w  . ja  va2s .c o  m*/
    query.setStart(start);
    // go direct to solr server so we can get all documents more easily
    QueryResponse solrResponse = this.solrSearchService.getServer().query(query);
    LOGGER.info("Got " + solrResponse.getResults().getNumFound() + " tagged documents from solr index; "
            + "this batch starts at " + solrResponse.getResults().getStart());
    return solrResponse.getResults();
}

From source file:org.schedoscope.metascope.index.SolrQueryExecutor.java

License:Apache License

/**
 * Perform a query on the metascope solr index. Builds up the query string
 * from the given parameters and sends request to solr server
 * /*ww  w.  j  a v a 2s  .  c o m*/
 * @param params
 *          the parameters which are included in the filter query
 * @return a SolrQueryResult object containing the result of the query
 */
public SolrQueryResult query(Map<String, String> params) {
    SolrQuery query = new SolrQuery();

    /* enable facetting */
    query.setFacet(true);

    /* list of all filters; key: name to display, value: entity parameter */
    List<SolrQueryParameter> filter = new ArrayList<SolrQueryParameter>();

    /* list of partition filter */
    List<SolrQueryParameter> partitionFilter = new ArrayList<SolrQueryParameter>();

    /*
     * list of filter which have been set by the user (key = filtername, value =
     * list of selections)
     */
    Map<String, List<String>> activeFilterValues = new HashMap<String, List<String>>();

    /*
     * determine on which type is searched for (either 'Table' or 'Partition')
     */
    String typeFilterValue = params.get(TYPE);
    filter.add(new SolrQueryParameter(FILTER_TYPE, TYPE, FilterType.EXCLUSIVE, FacetSort.COUNT));
    if (typeFilterValue != null && typeFilterValue.equalsIgnoreCase(TYPE_PARTITION)) {
        typeFilterValue = TYPE_PARTITION;
        for (String parameter : fieldEntityService.findDistinctParameters()) {
            partitionFilter.add(new SolrQueryParameter("Parameter: " + parameter, parameter + "_s",
                    FilterType.AND, FacetSort.INDEX));
        }
        for (SolrQueryParameter pFilter : partitionFilter) {
            query.addFacetField(pFilter.getName());
            query.add("f." + pFilter.getName() + ".facet.sort", "index");
            String filterValue = params.get(pFilter.getName());
            if (filterValue != null && !filterValue.isEmpty()) {
                query.addFilterQuery(pFilter.getName() + ":" + "(" + filterValue.replace(",", " AND ") + ")");
            }

        }
    } else {
        typeFilterValue = TYPE_TABLE;
    }
    query.addFilterQuery("{!tag=" + TYPE + "}" + TYPE + ":" + typeFilterValue);
    query.addFacetField("{!ex=" + TYPE + "}" + TYPE);

    /* set solr search query parameter 'q' */
    String searchQueryValue = params.get(URLUtil.SEARCH_QUERY_PARAM);
    if (searchQueryValue == null || searchQueryValue.isEmpty()) {
        searchQueryValue = "*";
        query.setQuery(searchQueryValue);
    } else {
        String[] queryTerms = searchQueryValue.trim().split(" ");
        String queryTerm = "";
        for (String term : queryTerms) {
            if (term.isEmpty()) {
                continue;
            }

            if (!queryTerm.isEmpty()) {
                queryTerm += " AND ";
            }
            queryTerm += "*" + term + "*";
        }
        query.setQuery(queryTerm);
        query.setHighlight(true);
        query.setHighlightSimplePre("<b>");
        query.setHighlightSimplePost("</b>");
        query.setHighlightSnippets(100);
        query.set("hl.fl", "*");
    }

    /* set the remaining filters */
    for (SolrQueryParameter queryFilter : facetFields) {
        filter.add(queryFilter);
        String value = params.get(queryFilter.getName());

        String filterQuery = "";
        String facetField = "";
        if (queryFilter.isExcludeFromFacet()) {
            if (value != null) {
                String[] multipleFilter = value.split(",");
                value = "(";
                for (int i = 0; i < multipleFilter.length; i++) {
                    String filterValue = cleanseValue(multipleFilter[i]).replace(" ", "*");
                    value += "(" + filterValue + ")";
                    if (i < multipleFilter.length - 1) {
                        value += " " + getOperator(queryFilter.getFilterType()) + " ";
                    }
                }
                value += ")";
            }
            filterQuery = "{!tag=" + queryFilter.getName() + "}" + queryFilter.getName() + ":" + value;
            facetField = "{!ex=" + queryFilter.getName() + "}" + queryFilter.getName();
        } else {
            if (value != null) {
                String[] multipleFilter = value.split(",");
                value = "(";
                for (int i = 0; i < multipleFilter.length; i++) {
                    String filterValue = cleanseValue(multipleFilter[i]).replace(" ", "*");
                    value += "(" + filterValue + ")";
                    if (i < multipleFilter.length - 1) {
                        value += " " + getOperator(queryFilter.getFilterType()) + " ";
                    }
                }
                value += ")";
            }
            filterQuery = queryFilter.getName() + ":" + value;
            facetField = queryFilter.getName();
        }

        if (value != null && !value.isEmpty()) {
            query.addFilterQuery(filterQuery);
        }
        query.addFacetField(facetField);

        if (queryFilter.getFacetSort().equals(FacetSort.INDEX)) {
            query.add("f." + queryFilter.getName() + ".facet.sort", "index");
        }
        query.add("f." + queryFilter.getName() + ".facet.limit", "-1");
    }

    /* set facet queries */
    Map<String, String> facetQueryMap = new HashMap<String, String>();
    long now = System.currentTimeMillis() / 1000;
    for (SolrFacetQuery solrFacetQuery : facetQueries) {
        for (SolrHourRange range : solrFacetQuery.getRanges()) {
            long from = range.getFrom() == Long.MAX_VALUE ? 0 : now - (range.getFrom() * 3600);
            String facetQueryString = solrFacetQuery.getName() + ":[" + from + " TO " + now + "]";
            query.addFacetQuery("{!ex=" + solrFacetQuery.getName() + "}" + facetQueryString);
            facetQueryMap.put(solrFacetQuery.getName() + range.getName(), facetQueryString);
        }
        String value = params.get(solrFacetQuery.getName());
        if (value != null) {
            String fq = "{!tag=" + solrFacetQuery.getName() + "}"
                    + facetQueryMap.get(solrFacetQuery.getName() + value);
            query.addFilterQuery(fq);
        }
    }

    /* always sort the entities (for a deterministic view) */
    query.setSort(ID, ORDER.asc);

    /* set pagination information */
    int page = getPageParameter(params);
    int elements = getElementsParameter(params);
    query.setRows(elements);
    query.setStart((page - 1) * elements);

    /* execute the query */
    QueryResponse queryResponse = null;
    try {
        queryResponse = solrClient.query(query);
    } catch (Exception e) {
        e.printStackTrace();
    }

    SolrDocumentList list = queryResponse.getResults();

    /* get table / view entities from local repository */
    List<SolrQueryResultEntity> resultEntities = new LinkedList<SolrQueryResultEntity>();
    String resultType = "";
    for (SolrDocument solrDocument : list) {
        String id = (String) solrDocument.get(ID);

        if (typeFilterValue.equalsIgnoreCase(TYPE_PARTITION)) {
            if (!searchQueryValue.equals("*")) {
                resultEntities.add(new SolrQueryResultEntity(viewEntityService.findByUrlPath(id),
                        queryResponse.getHighlighting().get(id)));
            } else {
                resultEntities.add(new SolrQueryResultEntity(viewEntityService.findByUrlPath(id)));
            }
            resultType = TYPE_PARTITION;
        } else if (typeFilterValue.equalsIgnoreCase(TYPE_TABLE)) {
            if (!searchQueryValue.equals("*")) {
                resultEntities.add(new SolrQueryResultEntity(tableEntityService.findByFqdn(id),
                        queryResponse.getHighlighting().get(id)));
            } else {
                resultEntities.add(new SolrQueryResultEntity(tableEntityService.findByFqdn(id)));
            }
        }
    }
    if (resultType.isEmpty()) {
        resultType = TYPE_TABLE;
    }

    filter.addAll(partitionFilter);

    /* get the facet values and counts */
    Map<String, List<SolrFacet>> facetValues = new HashMap<String, List<SolrFacet>>();
    for (SolrQueryParameter f : filter) {
        if (!f.getName().equals(URLUtil.SEARCH_QUERY_PARAM)) {
            List<SolrFacet> values = new ArrayList<SolrFacet>();
            FacetField facet = queryResponse.getFacetField(f.getName());
            for (Count count : facet.getValues()) {
                values.add(new SolrFacet(count.getName(), count.getCount()));
            }
            facetValues.put(f.getName(), values);
        }
    }

    /* remove the type filter */
    filter.remove(0);

    for (SolrFacetQuery solrFacetQuery : facetQueries) {
        filter.add(new SolrQueryParameter(solrFacetQuery.getDisplayName(), solrFacetQuery.getName(),
                FilterType.EXCLUSIVE));
        List<SolrFacet> values = new ArrayList<SolrFacet>();
        for (SolrHourRange range : solrFacetQuery.getRanges()) {
            long facetQueryCount = getFacetQueryCount(queryResponse, "{!ex=" + solrFacetQuery.getName() + "}"
                    + facetQueryMap.get(solrFacetQuery.getName() + range.getName()));
            values.add(new SolrFacet(range.getName(), facetQueryCount));
        }
        facetValues.put(solrFacetQuery.getName(), values);
    }

    /* get the active filter values which have been selected by the user */
    addToActiveFilterValues(activeFilterValues, params, filter);

    /* build and return the result */
    SolrQueryResult result = new SolrQueryResult().withResultEntities(resultEntities).withResultType(resultType)
            .withFilters(filter).withFacetValues(facetValues).withActiveFilterValues(activeFilterValues)
            .withSearchQuery(searchQueryValue).withPage(page).withElements(elements)
            .withTotalPages((int) Math.ceil(((double) list.getNumFound()) / elements))
            .withTotalResults(list.getNumFound());
    return result;
}