SolrQueryProcessor.java

/*******************************************************************************
 * Copyright (c) 2013 aegif.
 *
 * This file is part of NemakiWare.
 *
 * NemakiWare is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * NemakiWare is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with NemakiWare.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * Contributors:
 *     linzhixing(https://github.com/linzhixing) - initial API and implementation
 ******************************************************************************/
package jp.aegif.nemaki.cmis.aspect.query.solr;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.Lock;

import jp.aegif.nemaki.businesslogic.ContentService;
import jp.aegif.nemaki.cmis.aspect.CompileService;
import jp.aegif.nemaki.cmis.aspect.ExceptionService;
import jp.aegif.nemaki.cmis.aspect.PermissionService;
import jp.aegif.nemaki.cmis.aspect.query.QueryProcessor;
import jp.aegif.nemaki.cmis.aspect.type.TypeManager;
import jp.aegif.nemaki.model.Content;
import jp.aegif.nemaki.util.lock.ThreadLockService;

import org.antlr.runtime.tree.Tree;
import org.apache.chemistry.opencmis.commons.PropertyIds;
import org.apache.chemistry.opencmis.commons.data.ObjectList;
import org.apache.chemistry.opencmis.commons.definitions.TypeDefinition;
import org.apache.chemistry.opencmis.commons.definitions.TypeDefinitionContainer;
import org.apache.chemistry.opencmis.commons.enums.IncludeRelationships;
import org.apache.chemistry.opencmis.commons.impl.dataobjects.ObjectListImpl;
import org.apache.chemistry.opencmis.commons.server.CallContext;
import org.apache.chemistry.opencmis.server.support.query.QueryObject;
import org.apache.chemistry.opencmis.server.support.query.QueryObject.SortSpec;
import org.apache.chemistry.opencmis.server.support.query.QueryUtilStrict;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.TermQuery;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrServer;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;
import org.apache.solr.common.params.CommonParams;

public class SolrQueryProcessor implements QueryProcessor {

	private TypeManager typeManager;
	private ContentService contentService;
	private PermissionService permissionService;
	private CompileService compileService;
	private ExceptionService exceptionService;
	private ThreadLockService threadLockService;
	private SolrUtil solrUtil;
	private static final Log logger = LogFactory
			.getLog(SolrQueryProcessor.class);

	public SolrQueryProcessor() {

	}

	private class CmisTypeManager implements org.apache.chemistry.opencmis.server.support.TypeManager{
		private String repositoryId;
		private TypeManager typeManager;
		
		public CmisTypeManager(String repositoryId, TypeManager typeManager){
			this.repositoryId = repositoryId;
			this.typeManager = typeManager;
		}
		@Override
		public void addTypeDefinition(TypeDefinition arg0, boolean arg1) {
			// TODO Auto-generated method stub
			
		}
		@Override
		public void deleteTypeDefinition(String typeId) {
			typeManager.deleteTypeDefinition(repositoryId, typeId);
			
		}
		@Override
		public String getPropertyIdForQueryName(TypeDefinition typeDefinition, String propQueryName) {
			return typeManager.getPropertyIdForQueryName(repositoryId, typeDefinition, propQueryName);
		}
		@Override
		public List<TypeDefinitionContainer> getRootTypes() {
			return typeManager.getRootTypes(repositoryId);
		}
		@Override
		public TypeDefinitionContainer getTypeById(String typeId) {
			return typeManager.getTypeById(repositoryId, typeId);
		}
		@Override
		public TypeDefinition getTypeByQueryName(String typeQueryName) {
			return typeManager.getTypeByQueryName(repositoryId, typeQueryName);
		}
		@Override
		public Collection<TypeDefinitionContainer> getTypeDefinitionList() {
			return typeManager.getTypeDefinitionList(repositoryId);
		}
		@Override
		public void updateTypeDefinition(TypeDefinition typeDefinition) {
			typeManager.updateTypeDefinition(repositoryId, typeDefinition);
			
		}
	}
	
	@Override
	public ObjectList query(CallContext callContext, String repositoryId,
			String statement, Boolean searchAllVersions,
			Boolean includeAllowableActions, IncludeRelationships includeRelationships,
			String renditionFilter, BigInteger maxItems, BigInteger skipCount) {

		SolrServer solrServer = solrUtil.getSolrServer();

		// TODO walker is required?
		QueryUtilStrict util = new QueryUtilStrict(statement, new CmisTypeManager(repositoryId, typeManager), null);
		QueryObject queryObject = util.getQueryObject();

		// Get where caluse as Tree
		Tree whereTree = null;
		try {
			util.processStatement();
			Tree tree = util.parseStatement();
			whereTree = extractWhereTree(tree);
		} catch (Exception e) {
			e.printStackTrace();
		}

		// Build solr statement of WHERE
		String whereQueryString = "";
		if (whereTree == null || whereTree.isNil()) {
			whereQueryString = "*:*";
		} else {
			try {
				SolrPredicateWalker solrPredicateWalker = new SolrPredicateWalker(repositoryId,
						queryObject, solrUtil, contentService);
				Query whereQuery = solrPredicateWalker.walkPredicate(whereTree);
				whereQueryString = whereQuery.toString();
			} catch (Exception e) {
				e.printStackTrace();
				// TODO Output more detailed exception
				exceptionService.invalidArgument("Invalid CMIS SQL statement!");
			}
		}

		// Build solr query of FROM
		String fromQueryString = "";
		
		String repositoryQuery = "repository_id:" + repositoryId;
		
		fromQueryString += repositoryQuery + " AND ";
		
		TypeDefinition td = queryObject.getMainFromName();
		// includedInSupertypeQuery
		List<TypeDefinitionContainer> typeDescendants = typeManager
				.getTypesDescendants(repositoryId, td.getId(), BigInteger.valueOf(-1), false);
		Iterator<TypeDefinitionContainer> iterator = typeDescendants.iterator();
		List<String> tables = new ArrayList<String>();
		while (iterator.hasNext()) {
			TypeDefinition descendant = iterator.next().getTypeDefinition();
			if (td.getId() != descendant.getId()) {
				boolean isq = (descendant.isIncludedInSupertypeQuery() == null) ? false
						: descendant.isIncludedInSupertypeQuery();
				if (!isq)
					continue;
			}
			String table = descendant.getQueryName();
			tables.add(table.replaceAll(":", "\\\\:"));
		}
		
		Term t = new Term(
				solrUtil.getPropertyNameInSolr(PropertyIds.OBJECT_TYPE_ID),
				StringUtils.join(tables, " "));
		fromQueryString += new TermQuery(t).toString();

		// Execute query
		SolrQuery solrQuery = new SolrQuery();
		solrQuery.setQuery(whereQueryString);
		solrQuery.setFilterQueries(fromQueryString);
		
		//TEST
		solrQuery.set(CommonParams.START, 0);
		solrQuery.set(CommonParams.ROWS, maxItems.intValue());
		

		QueryResponse resp = null;
		try {
			resp = solrServer.query(solrQuery);
		} catch (SolrServerException e) {
			e.printStackTrace();
		}

		// Output search results to ObjectList
		if (resp != null && resp.getResults() != null
				&& resp.getResults().getNumFound() != 0) {
			SolrDocumentList docs = resp.getResults();

			List<Content> contents = new ArrayList<Content>();
			for (SolrDocument doc : docs) {
				String docId = (String) doc.getFieldValue("object_id");
				Content c = contentService.getContent(repositoryId, docId);

				// When for some reason the content is missed, pass through
				if (c == null) {
					logger.warn("[objectId=" + docId
							+ "]It is missed in DB but still rests in Solr.");
				} else {
					contents.add(c);
				}

			}
			
			
			List<Lock> locks = threadLockService.readLocks(repositoryId, contents);
			try{
				threadLockService.bulkLock(locks);
				
				// Filter out by permissions
				List<Content> permitted = permissionService.getFiltered(
						callContext, repositoryId, contents);

				// Filter return value with SELECT clause
				Map<String, String> requestedWithAliasKey = queryObject
						.getRequestedPropertiesByAlias();
				String filter = null;
				if (!requestedWithAliasKey.keySet().contains("*")) {
					// Create filter(queryNames) from query aliases
					filter = StringUtils.join(requestedWithAliasKey.values(), ",");
				}

				// Build ObjectList
				String orderBy = orderBy(queryObject);
				ObjectList result = compileService.compileObjectDataList(
						callContext, repositoryId, permitted, filter,
						includeAllowableActions, includeRelationships, renditionFilter, false,
						maxItems, skipCount, false, orderBy);

				return result;
				
			}finally{
				threadLockService.bulkUnlock(locks);
			}
		} else {
			ObjectListImpl nullList = new ObjectListImpl();
			nullList.setHasMoreItems(false);
			nullList.setNumItems(BigInteger.ZERO);
			return nullList;
		}
	}
	
	private String orderBy(QueryObject queryObject){
		List<SortSpec> sortSpecs = queryObject.getOrderBys();
		List<String> _orderBy = new ArrayList<String>();
		for (SortSpec sortSpec : sortSpecs) {
			List<String> _sortSpec = new ArrayList<String>();
			_sortSpec.add(sortSpec.getSelector().getName());
			if (!sortSpec.isAscending()) {
				_sortSpec.add("DESC");
			}

			_orderBy.add(StringUtils.join(_sortSpec, " "));
		}
		String orderBy = StringUtils.join(_orderBy, ",");
		return orderBy;
	}

	private Tree extractWhereTree(Tree tree){
		for (int i = 0; i < tree.getChildCount(); i++) {
			Tree selectTree = tree.getChild(i);
			if ("SELECT".equals(selectTree.getText())) {
				for(int j=0; j < selectTree.getChildCount(); j++){
					Tree whereTree = selectTree.getChild(j);
					if("WHERE".equals(whereTree.getText())){
						return whereTree.getChild(0);
					}
				}
				
			}
		}
		
		return null;
	}
	
	public void setTypeManager(TypeManager typeManager) {
		this.typeManager = typeManager;
	}

	public void setContentService(ContentService contentService) {
		this.contentService = contentService;
	}

	public void setPermissionService(PermissionService permissionService) {
		this.permissionService = permissionService;
	}

	public void setCompileService(CompileService compileService) {
		this.compileService = compileService;
	}

	public void setExceptionService(ExceptionService exceptionService) {
		this.exceptionService = exceptionService;
	}

	public void setSolrUtil(SolrUtil solrUtil) {
		this.solrUtil = solrUtil;
	}

	public void setThreadLockService(ThreadLockService threadLockService) {
		this.threadLockService = threadLockService;
	}
}