org.lumongo.client.command.Query Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of lumongo-client Show documentation
$project.description
There is a newer version: 0.52
package org.lumongo.client.command;

import com.google.protobuf.RpcController;
import com.google.protobuf.ServiceException;
import org.lumongo.client.command.base.SimpleCommand;
import org.lumongo.client.pool.LumongoConnection;
import org.lumongo.client.result.QueryResult;
import org.lumongo.cluster.message.Lumongo;
import org.lumongo.cluster.message.Lumongo.CountRequest;
import org.lumongo.cluster.message.Lumongo.ExternalService;
import org.lumongo.cluster.message.Lumongo.FacetRequest;
import org.lumongo.cluster.message.Lumongo.FieldSort;
import org.lumongo.cluster.message.Lumongo.FieldSort.Direction;
import org.lumongo.cluster.message.Lumongo.LMFacet;
import org.lumongo.cluster.message.Lumongo.Query.Operator;
import org.lumongo.cluster.message.Lumongo.QueryRequest;
import org.lumongo.cluster.message.Lumongo.QueryResponse;
import org.lumongo.cluster.message.Lumongo.SortRequest;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

/**
 * Runs a query on one of more LuMongo indexes.
 * @author mdavis
 *
 */
public class Query extends SimpleCommand {

	private String query;
	private int amount;
	private int start;
	private Collection indexes;
	private Lumongo.LastResult lastResult;
	private List countRequests = Collections.emptyList();
	private List drillDowns = Collections.emptyList();
	private List fieldSorts = Collections.emptyList();
	private Set queryFields = Collections.emptySet();
	private List filterQueries = Collections.emptyList();
	private Integer minimumNumberShouldMatch;
	private Operator defaultOperator;
	private Lumongo.FetchType resultFetchType;
	private Set documentFields = Collections.emptySet();
	private Set documentMaskedFields = Collections.emptySet();

	public Query(String index, String query, int amount) {
		this(new String[] { index }, query, amount);
	}

	public Query(String[] indexes, String query, int amount) {
		this(new ArrayList<>(Arrays.asList(indexes)), query, amount);
	}

	public Query(Collection indexes, String query, int amount) {
		this.indexes = indexes;
		this.query = query;
		this.amount = amount;
	}

	public String getQuery() {
		return query;
	}

	public Query setQuery(String query) {
		this.query = query;
		return this;
	}

	public int getAmount() {
		return amount;
	}

	public Query setAmount(int amount) {
		this.amount = amount;
		return this;
	}

	public int getStart() {
		return start;
	}

	public void setStart(int start) {
		this.start = start;
	}

	public Integer getMinimumNumberShouldMatch() {
		return minimumNumberShouldMatch;
	}

	public void setMinimumNumberShouldMatch(Integer minimumNumberShouldMatch) {
		this.minimumNumberShouldMatch = minimumNumberShouldMatch;
	}

	public Collection getIndexes() {
		return indexes;
	}

	public Query setIndexes(Collection indexes) {
		this.indexes = indexes;
		return this;
	}

	public Query setLastResult(QueryResult lastQueryResult) {
		this.lastResult = lastQueryResult.getLastResult();
		return this;
	}

	public Lumongo.LastResult getLastResult() {
		return lastResult;
	}

	public Query setLastResult(Lumongo.LastResult lastResult) {
		this.lastResult = lastResult;
		return this;
	}

	public Query addDrillDown(String label, String path) {
		if (drillDowns.isEmpty()) {
			this.drillDowns = new ArrayList<>();
		}

		drillDowns.add(LMFacet.newBuilder().setLabel(label).setPath(path).build());
		return this;
	}

	public List getDrillDowns() {
		return drillDowns;
	}

	public Set getQueryFields() {
		return queryFields;
	}

	public void setQueryFields(Collection queryFields) {
		this.queryFields = new HashSet(queryFields);
	}

	public void setQueryFields(String... queryFields) {
		this.queryFields = new HashSet<>(Arrays.asList(queryFields));

	}

	public Query addQueryField(String queryField) {
		if (queryFields.isEmpty()) {
			this.queryFields = new HashSet<>();
		}

		queryFields.add(queryField);
		return this;
	}

	public Query addQueryField(String... queryFields) {
		if (this.queryFields.isEmpty()) {
			this.queryFields = new HashSet<>();
		}

		for (String queryField : queryFields) {
			this.queryFields.add(queryField);
		}
		return this;
	}

	public List getFilterQueries() {
		return filterQueries;
	}

	public void setFilterQueries(List filterQueries) {
		this.filterQueries = filterQueries;
	}

	public Query addFilterQuery(String query) {
		return addFilterQuery(query, null, null, null);
	}

	public Query addFilterQuery(String query, Collection queryFields) {
		return addFilterQuery(query, queryFields, null, null);
	}

	public Query addFilterQuery(String query, Collection queryFields, Operator defaultOperator) {
		return addFilterQuery(query, queryFields, defaultOperator, null);
	}

	public Query addFilterQuery(String query, Collection queryFields, Integer minimumNumberShouldMatch) {
		return addFilterQuery(query, queryFields, null, minimumNumberShouldMatch);
	}

	public Query addFilterQuery(String query, Collection queryFields, Operator defaultOperator, Integer minimumNumberShouldMatch) {
		if (filterQueries.isEmpty()) {
			this.filterQueries = new ArrayList<>();
		}

		Lumongo.Query.Builder builder = Lumongo.Query.newBuilder();
		if (query != null && !query.isEmpty()) {
			builder.setQ(query);
		}
		if (minimumNumberShouldMatch != null) {
			builder.setMm(minimumNumberShouldMatch);
		}
		if (defaultOperator != null) {
			builder.setDefaultOp(defaultOperator);
		}
		if (queryFields != null && !queryFields.isEmpty()) {
			builder.addAllQf(queryFields);
		}
		filterQueries.add(builder.build());
		return this;
	}

	public Query addCountRequest(String label) {
		return (addCountRequest(label, null));
	}

	public Query addCountRequest(String label, Integer maxFacets) {
		return (addCountRequest(label, maxFacets, null));
	}

	public Query addCountRequest(String label, Integer maxFacets, Integer segmentFacets) {

		CountRequest.Builder countRequest = CountRequest.newBuilder().setFacetField(LMFacet.newBuilder().setLabel(label).build());
		if (maxFacets != null) {
			countRequest.setMaxFacets(maxFacets);
		}
		if (segmentFacets != null) {
			countRequest.setSegmentFacets(segmentFacets);
		}
		if (countRequests.isEmpty()) {
			this.countRequests = new ArrayList<>();
		}
		countRequests.add(countRequest.build());
		return this;
	}

	public List getCountRequests() {
		return countRequests;
	}

	public Query addFieldSort(String sort) {
		if (fieldSorts.isEmpty()) {
			this.fieldSorts = new ArrayList<>();
		}
		fieldSorts.add(FieldSort.newBuilder().setSortField(sort).setDirection(Direction.ASCENDING).build());
		return this;
	}

	public Query addFieldSort(String sort, Direction direction) {
		if (fieldSorts.isEmpty()) {
			this.fieldSorts = new ArrayList<>();
		}
		fieldSorts.add(FieldSort.newBuilder().setSortField(sort).setDirection(direction).build());
		return this;
	}

	public Operator getDefaultOperator() {
		return defaultOperator;
	}

	public Query setDefaultOperator(Operator defaultOperator) {
		this.defaultOperator = defaultOperator;
		return this;
	}

	public Lumongo.FetchType getResultFetchType() {
		return resultFetchType;
	}

	public Query setResultFetchType(Lumongo.FetchType resultFetchType) {
		this.resultFetchType = resultFetchType;
		return this;
	}

	public Set getDocumentMaskedFields() {
		return documentMaskedFields;
	}

	public Query addDocumentMaskedField(String documentMaskedField) {
		if (documentMaskedFields.isEmpty()) {
			documentMaskedFields = new LinkedHashSet<>();
		}

		documentMaskedFields.add(documentMaskedField);
		return this;
	}

	public Set getDocumentFields() {
		return documentFields;
	}

	public Query addDocumentField(String documentField) {
		if (documentFields.isEmpty()) {
			this.documentFields = new LinkedHashSet<>();
		}
		documentFields.add(documentField);
		return this;
	}

	@Override
	public QueryRequest getRequest() {
		QueryRequest.Builder requestBuilder = QueryRequest.newBuilder();
		requestBuilder.setAmount(amount);
		requestBuilder.setStart(start);

		if (query != null && !query.isEmpty()) {
			Lumongo.Query.Builder queryBuilder = Lumongo.Query.newBuilder();
			queryBuilder.setQ(query);
			if (minimumNumberShouldMatch != null) {
				queryBuilder.setMm(minimumNumberShouldMatch);
			}
			if (!queryFields.isEmpty()) {
				queryBuilder.addAllQf(queryFields);
			}
			if (defaultOperator != null) {
				queryBuilder.setDefaultOp(defaultOperator);
			}

			requestBuilder.setQuery(queryBuilder);
		}

		if (lastResult != null) {
			requestBuilder.setLastResult(lastResult);
		}

		for (String index : indexes) {
			requestBuilder.addIndex(index);
		}

		if (!drillDowns.isEmpty() || !countRequests.isEmpty()) {
			FacetRequest.Builder facetRequestBuilder = FacetRequest.newBuilder();

			facetRequestBuilder.addAllDrillDown(drillDowns);

			facetRequestBuilder.addAllCountRequest(countRequests);

			requestBuilder.setFacetRequest(facetRequestBuilder.build());

		}

		if (!filterQueries.isEmpty()) {
			requestBuilder.addAllFilterQuery(filterQueries);
		}

		if (resultFetchType != null) {
			requestBuilder.setResultFetchType(resultFetchType);
		}

		requestBuilder.addAllDocumentFields(documentFields);
		requestBuilder.addAllDocumentMaskedFields(documentMaskedFields);

		SortRequest.Builder sortRequestBuilder = SortRequest.newBuilder();
		sortRequestBuilder.addAllFieldSort(fieldSorts);
		requestBuilder.setSortRequest(sortRequestBuilder.build());

		return requestBuilder.build();
	}

	@Override
	public QueryResult execute(LumongoConnection lumongoConnection) throws ServiceException {

		ExternalService.BlockingInterface service = lumongoConnection.getService();

		RpcController controller = lumongoConnection.getController();

		QueryResponse queryResponse = service.query(controller, getRequest());

		return new QueryResult(queryResponse);

	}

	@Override
	public String toString() {
		return "Query{" +
				"query='" + query + '\'' +
				", amount=" + amount +
				", indexes=" + indexes +
				", lastResult=" + lastResult +
				", countRequests=" + countRequests +
				", drillDowns=" + drillDowns +
				", fieldSorts=" + fieldSorts +
				", queryFields=" + queryFields +
				", filterQueries=" + filterQueries +
				", minimumNumberShouldMatch=" + minimumNumberShouldMatch +
				", defaultOperator=" + defaultOperator +
				", resultFetchType=" + resultFetchType +
				", documentFields=" + documentFields +
				", documentMaskedFields=" + documentMaskedFields +
				'}';
	}
}