| /* |
| * Copyright 2012-2014 Paul Merlin. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| * implied. |
| * |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.qi4j.index.elasticsearch; |
| |
| import java.util.HashMap; |
| import java.util.Map; |
| import org.elasticsearch.action.count.CountRequestBuilder; |
| import org.elasticsearch.action.count.CountResponse; |
| import org.elasticsearch.action.search.SearchRequestBuilder; |
| import org.elasticsearch.action.search.SearchResponse; |
| import org.elasticsearch.index.query.AndFilterBuilder; |
| import org.elasticsearch.index.query.FilterBuilder; |
| import org.elasticsearch.index.query.OrFilterBuilder; |
| import org.elasticsearch.index.query.QueryBuilder; |
| import org.elasticsearch.search.SearchHit; |
| import org.elasticsearch.search.sort.SortOrder; |
| import org.qi4j.api.composite.Composite; |
| import org.qi4j.api.entity.EntityReference; |
| import org.qi4j.api.injection.scope.This; |
| import org.qi4j.api.mixin.Mixins; |
| import org.qi4j.api.query.grammar.AndSpecification; |
| import org.qi4j.api.query.grammar.AssociationNotNullSpecification; |
| import org.qi4j.api.query.grammar.AssociationNullSpecification; |
| import org.qi4j.api.query.grammar.BinarySpecification; |
| import org.qi4j.api.query.grammar.ComparisonSpecification; |
| import org.qi4j.api.query.grammar.ContainsAllSpecification; |
| import org.qi4j.api.query.grammar.ContainsSpecification; |
| import org.qi4j.api.query.grammar.EqSpecification; |
| import org.qi4j.api.query.grammar.GeSpecification; |
| import org.qi4j.api.query.grammar.GtSpecification; |
| import org.qi4j.api.query.grammar.LeSpecification; |
| import org.qi4j.api.query.grammar.LtSpecification; |
| import org.qi4j.api.query.grammar.ManyAssociationContainsSpecification; |
| import org.qi4j.api.query.grammar.MatchesSpecification; |
| import org.qi4j.api.query.grammar.NamedAssociationContainsNameSpecification; |
| import org.qi4j.api.query.grammar.NamedAssociationContainsSpecification; |
| import org.qi4j.api.query.grammar.NeSpecification; |
| import org.qi4j.api.query.grammar.NotSpecification; |
| import org.qi4j.api.query.grammar.OrSpecification; |
| import org.qi4j.api.query.grammar.OrderBy; |
| import org.qi4j.api.query.grammar.PropertyNotNullSpecification; |
| import org.qi4j.api.query.grammar.PropertyNullSpecification; |
| import org.qi4j.api.query.grammar.QuerySpecification; |
| import org.qi4j.api.value.ValueComposite; |
| import org.qi4j.functional.Function; |
| import org.qi4j.functional.Iterables; |
| import org.qi4j.functional.Specification; |
| import org.qi4j.index.elasticsearch.ElasticSearchFinderSupport.ComplexTypeSupport; |
| import org.qi4j.spi.query.EntityFinder; |
| import org.qi4j.spi.query.EntityFinderException; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| import static org.elasticsearch.index.query.FilterBuilders.andFilter; |
| import static org.elasticsearch.index.query.FilterBuilders.existsFilter; |
| import static org.elasticsearch.index.query.FilterBuilders.missingFilter; |
| import static org.elasticsearch.index.query.FilterBuilders.notFilter; |
| import static org.elasticsearch.index.query.FilterBuilders.rangeFilter; |
| import static org.elasticsearch.index.query.FilterBuilders.regexpFilter; |
| import static org.elasticsearch.index.query.FilterBuilders.termFilter; |
| import static org.elasticsearch.index.query.QueryBuilders.filteredQuery; |
| import static org.elasticsearch.index.query.QueryBuilders.matchAllQuery; |
| import static org.elasticsearch.index.query.QueryBuilders.wrapperQuery; |
| import static org.qi4j.index.elasticsearch.ElasticSearchFinderSupport.resolveVariable; |
| |
| @Mixins( ElasticSearchFinder.Mixin.class ) |
| public interface ElasticSearchFinder |
| extends EntityFinder |
| { |
| class Mixin |
| implements EntityFinder |
| { |
| private static final Logger LOGGER = LoggerFactory.getLogger( ElasticSearchFinder.class ); |
| private static final Map<Class<?>, ComplexTypeSupport> COMPLEX_TYPE_SUPPORTS = new HashMap<>( 0 ); |
| |
| @This |
| private ElasticSearchSupport support; |
| |
| @Override |
| public Iterable<EntityReference> findEntities( Class<?> resultType, |
| Specification<Composite> whereClause, |
| OrderBy[] orderBySegments, |
| Integer firstResult, Integer maxResults, |
| Map<String, Object> variables ) |
| throws EntityFinderException |
| { |
| // Prepare request |
| SearchRequestBuilder request = support.client().prepareSearch( support.index() ); |
| |
| AndFilterBuilder filterBuilder = baseFilters( resultType ); |
| QueryBuilder queryBuilder = processWhereSpecification( filterBuilder, whereClause, variables ); |
| |
| request.setQuery( filteredQuery( queryBuilder, filterBuilder ) ); |
| if( firstResult != null ) |
| { |
| request.setFrom( firstResult ); |
| } |
| if( maxResults != null ) |
| { |
| request.setSize( maxResults ); |
| } |
| else |
| { |
| //request.setSize( Integer.MAX_VALUE ); // TODO Use scrolls? |
| } |
| if( orderBySegments != null ) |
| { |
| for( OrderBy order : orderBySegments ) |
| { |
| request.addSort( order.property().toString(), |
| order.order() == OrderBy.Order.ASCENDING ? SortOrder.ASC : SortOrder.DESC ); |
| } |
| } |
| |
| // Log |
| LOGGER.debug( "Will search Entities: {}", request ); |
| |
| // Execute |
| SearchResponse response = request.execute().actionGet(); |
| |
| return Iterables.map( new Function<SearchHit, EntityReference>() |
| { |
| @Override |
| public EntityReference map( SearchHit from ) |
| { |
| return EntityReference.parseEntityReference( from.id() ); |
| } |
| |
| }, response.getHits() ); |
| } |
| |
| @Override |
| public EntityReference findEntity( Class<?> resultType, |
| Specification<Composite> whereClause, |
| Map<String, Object> variables ) |
| throws EntityFinderException |
| { |
| // Prepare request |
| SearchRequestBuilder request = support.client().prepareSearch( support.index() ); |
| |
| AndFilterBuilder filterBuilder = baseFilters( resultType ); |
| QueryBuilder queryBuilder = processWhereSpecification( filterBuilder, whereClause, variables ); |
| |
| request.setQuery( filteredQuery( queryBuilder, filterBuilder ) ); |
| request.setSize( 1 ); |
| |
| // Log |
| LOGGER.debug( "Will search Entity: {}", request ); |
| |
| // Execute |
| SearchResponse response = request.execute().actionGet(); |
| |
| if( response.getHits().totalHits() == 1 ) |
| { |
| return EntityReference.parseEntityReference( response.getHits().getAt( 0 ).id() ); |
| } |
| |
| return null; |
| } |
| |
| @Override |
| public long countEntities( Class<?> resultType, |
| Specification<Composite> whereClause, |
| Map<String, Object> variables ) |
| throws EntityFinderException |
| { |
| // Prepare request |
| CountRequestBuilder request = support.client().prepareCount( support.index() ); |
| |
| AndFilterBuilder filterBuilder = baseFilters( resultType ); |
| QueryBuilder queryBuilder = processWhereSpecification( filterBuilder, whereClause, variables ); |
| |
| request.setQuery( filteredQuery( queryBuilder, filterBuilder ) ); |
| |
| // Log |
| LOGGER.debug( "Will count Entities: {}", request ); |
| |
| // Execute |
| CountResponse count = request.execute().actionGet(); |
| |
| return count.getCount(); |
| } |
| |
| private static AndFilterBuilder baseFilters( Class<?> resultType ) |
| { |
| return andFilter( termFilter( "_types", resultType.getName() ) ); |
| } |
| |
| private QueryBuilder processWhereSpecification( AndFilterBuilder filterBuilder, |
| Specification<Composite> spec, |
| Map<String, Object> variables ) |
| throws EntityFinderException |
| { |
| if( spec == null ) |
| { |
| return matchAllQuery(); |
| } |
| |
| if( spec instanceof QuerySpecification ) |
| { |
| return wrapperQuery( ( (QuerySpecification) spec ).query() ); |
| } |
| |
| processSpecification( filterBuilder, spec, variables ); |
| return matchAllQuery(); |
| } |
| |
| private void processSpecification( FilterBuilder filterBuilder, |
| Specification<Composite> spec, |
| Map<String, Object> variables ) |
| throws EntityFinderException |
| { |
| if( spec instanceof BinarySpecification ) |
| { |
| BinarySpecification binSpec = (BinarySpecification) spec; |
| processBinarySpecification( filterBuilder, binSpec, variables ); |
| } |
| else if( spec instanceof NotSpecification ) |
| { |
| NotSpecification notSpec = (NotSpecification) spec; |
| processNotSpecification( filterBuilder, notSpec, variables ); |
| } |
| else if( spec instanceof ComparisonSpecification ) |
| { |
| ComparisonSpecification<?> compSpec = (ComparisonSpecification<?>) spec; |
| processComparisonSpecification( filterBuilder, compSpec, variables ); |
| } |
| else if( spec instanceof ContainsAllSpecification ) |
| { |
| ContainsAllSpecification<?> contAllSpec = (ContainsAllSpecification) spec; |
| processContainsAllSpecification( filterBuilder, contAllSpec, variables ); |
| } |
| else if( spec instanceof ContainsSpecification ) |
| { |
| ContainsSpecification<?> contSpec = (ContainsSpecification) spec; |
| processContainsSpecification( filterBuilder, contSpec, variables ); |
| } |
| else if( spec instanceof MatchesSpecification ) |
| { |
| MatchesSpecification matchSpec = (MatchesSpecification) spec; |
| processMatchesSpecification( filterBuilder, matchSpec, variables ); |
| } |
| else if( spec instanceof PropertyNotNullSpecification ) |
| { |
| PropertyNotNullSpecification<?> propNotNullSpec = (PropertyNotNullSpecification) spec; |
| processPropertyNotNullSpecification( filterBuilder, propNotNullSpec ); |
| } |
| else if( spec instanceof PropertyNullSpecification ) |
| { |
| PropertyNullSpecification<?> propNullSpec = (PropertyNullSpecification) spec; |
| processPropertyNullSpecification( filterBuilder, propNullSpec ); |
| } |
| else if( spec instanceof AssociationNotNullSpecification ) |
| { |
| AssociationNotNullSpecification<?> assNotNullSpec = (AssociationNotNullSpecification) spec; |
| processAssociationNotNullSpecification( filterBuilder, assNotNullSpec ); |
| } |
| else if( spec instanceof AssociationNullSpecification ) |
| { |
| AssociationNullSpecification<?> assNullSpec = (AssociationNullSpecification) spec; |
| processAssociationNullSpecification( filterBuilder, assNullSpec ); |
| } |
| else if( spec instanceof ManyAssociationContainsSpecification ) |
| { |
| ManyAssociationContainsSpecification<?> manyAssContSpec = (ManyAssociationContainsSpecification) spec; |
| processManyAssociationContainsSpecification( filterBuilder, manyAssContSpec, variables ); |
| } |
| else if( spec instanceof NamedAssociationContainsSpecification ) |
| { |
| |
| NamedAssociationContainsSpecification<?> namedAssContSpec = (NamedAssociationContainsSpecification) spec; |
| processNamedAssociationContainsSpecification( filterBuilder, namedAssContSpec, variables ); |
| |
| } |
| else if( spec instanceof NamedAssociationContainsNameSpecification ) |
| { |
| |
| NamedAssociationContainsNameSpecification<?> namedAssContNameSpec = (NamedAssociationContainsNameSpecification) spec; |
| processNamedAssociationContainsNameSpecification( filterBuilder, namedAssContNameSpec, variables ); |
| |
| } |
| else |
| { |
| throw new UnsupportedOperationException( "Query specification unsupported by Elastic Search " |
| + "(New Query API support missing?): " |
| + spec.getClass() + ": " + spec ); |
| } |
| } |
| |
| private static void addFilter( FilterBuilder filter, FilterBuilder into ) |
| { |
| if( into instanceof AndFilterBuilder ) |
| { |
| ( (AndFilterBuilder) into ).add( filter ); |
| } |
| else if( into instanceof OrFilterBuilder ) |
| { |
| ( (OrFilterBuilder) into ).add( filter ); |
| } |
| else |
| { |
| throw new UnsupportedOperationException( "FilterBuilder is nor an AndFB nor an OrFB, cannot continue." ); |
| } |
| } |
| |
| private void processBinarySpecification( FilterBuilder filterBuilder, |
| BinarySpecification spec, |
| Map<String, Object> variables ) |
| throws EntityFinderException |
| { |
| LOGGER.trace( "Processing BinarySpecification {}", spec ); |
| Iterable<Specification<Composite>> operands = spec.operands(); |
| |
| if( spec instanceof AndSpecification ) |
| { |
| AndFilterBuilder andFilterBuilder = new AndFilterBuilder(); |
| for( Specification<Composite> operand : operands ) |
| { |
| processSpecification( andFilterBuilder, operand, variables ); |
| } |
| addFilter( andFilterBuilder, filterBuilder ); |
| } |
| else if( spec instanceof OrSpecification ) |
| { |
| OrFilterBuilder orFilterBuilder = new OrFilterBuilder(); |
| for( Specification<Composite> operand : operands ) |
| { |
| processSpecification( orFilterBuilder, operand, variables ); |
| } |
| addFilter( orFilterBuilder, filterBuilder ); |
| } |
| else |
| { |
| throw new UnsupportedOperationException( "Binary Query specification is nor an AndSpecification " |
| + "nor an OrSpecification, cannot continue." ); |
| } |
| } |
| |
| private void processNotSpecification( FilterBuilder filterBuilder, |
| NotSpecification spec, |
| Map<String, Object> variables ) |
| throws EntityFinderException |
| { |
| LOGGER.trace( "Processing NotSpecification {}", spec ); |
| AndFilterBuilder operandFilter = new AndFilterBuilder(); |
| processSpecification( operandFilter, spec.operand(), variables ); |
| addFilter( notFilter( operandFilter ), filterBuilder ); |
| } |
| |
| private void processComparisonSpecification( FilterBuilder filterBuilder, |
| ComparisonSpecification<?> spec, |
| Map<String, Object> variables ) |
| { |
| LOGGER.trace( "Processing ComparisonSpecification {}", spec ); |
| |
| if( spec.value() instanceof ValueComposite ) |
| { |
| // Query by "example value" |
| throw new UnsupportedOperationException( "ElasticSearch Index/Query does not support complex " |
| + "queries, ie. queries by 'example value'." ); |
| } |
| else if( COMPLEX_TYPE_SUPPORTS.get( spec.value().getClass() ) != null ) |
| { |
| // Query on complex type property |
| ComplexTypeSupport support = COMPLEX_TYPE_SUPPORTS.get( spec.value().getClass() ); |
| addFilter( support.comparison( spec, variables ), filterBuilder ); |
| } |
| else |
| { |
| // Query by simple property value |
| String name = spec.property().toString(); |
| Object value = resolveVariable( spec.value(), variables ); |
| if( spec instanceof EqSpecification ) |
| { |
| addFilter( termFilter( name, value ), filterBuilder ); |
| } |
| else if( spec instanceof NeSpecification ) |
| { |
| addFilter( andFilter( existsFilter( name ), |
| notFilter( termFilter( name, value ) ) ), |
| filterBuilder ); |
| } |
| else if( spec instanceof GeSpecification ) |
| { |
| addFilter( rangeFilter( name ).gte( value ), filterBuilder ); |
| } |
| else if( spec instanceof GtSpecification ) |
| { |
| addFilter( rangeFilter( name ).gt( value ), filterBuilder ); |
| } |
| else if( spec instanceof LeSpecification ) |
| { |
| addFilter( rangeFilter( name ).lte( value ), filterBuilder ); |
| } |
| else if( spec instanceof LtSpecification ) |
| { |
| addFilter( rangeFilter( name ).lt( value ), filterBuilder ); |
| } |
| else |
| { |
| throw new UnsupportedOperationException( "Query specification unsupported by Elastic Search " |
| + "(New Query API support missing?): " |
| + spec.getClass() + ": " + spec ); |
| } |
| } |
| } |
| |
| private void processContainsAllSpecification( FilterBuilder filterBuilder, |
| ContainsAllSpecification<?> spec, |
| Map<String, Object> variables ) |
| { |
| LOGGER.trace( "Processing ContainsAllSpecification {}", spec ); |
| Object firstValue = Iterables.first( spec.containedValues() ); |
| if( firstValue instanceof ValueComposite ) |
| { |
| // Query by complex property "example value" |
| throw new UnsupportedOperationException( "ElasticSearch Index/Query does not support complex " |
| + "queries, ie. queries by 'example value'." ); |
| } |
| else if( COMPLEX_TYPE_SUPPORTS.get( firstValue.getClass() ) != null ) |
| { |
| ComplexTypeSupport support = COMPLEX_TYPE_SUPPORTS.get( firstValue.getClass() ); |
| addFilter( support.containsAll( spec, variables ), filterBuilder ); |
| } |
| else |
| { |
| String name = spec.collectionProperty().toString(); |
| AndFilterBuilder contAllFilter = new AndFilterBuilder(); |
| for( Object value : spec.containedValues() ) |
| { |
| contAllFilter.add( termFilter( name, resolveVariable( value, variables ) ) ); |
| } |
| addFilter( contAllFilter, filterBuilder ); |
| } |
| } |
| |
| private void processContainsSpecification( FilterBuilder filterBuilder, |
| ContainsSpecification<?> spec, |
| Map<String, Object> variables ) |
| { |
| LOGGER.trace( "Processing ContainsSpecification {}", spec ); |
| String name = spec.collectionProperty().toString(); |
| if( spec.value() instanceof ValueComposite ) |
| { |
| // Query by complex property "example value" |
| throw new UnsupportedOperationException( "ElasticSearch Index/Query does not support complex " |
| + "queries, ie. queries by 'example value'." ); |
| } |
| else if( COMPLEX_TYPE_SUPPORTS.get( spec.value().getClass() ) != null ) |
| { |
| ComplexTypeSupport support = COMPLEX_TYPE_SUPPORTS.get( spec.value().getClass() ); |
| addFilter( support.contains( spec, variables ), filterBuilder ); |
| } |
| else |
| { |
| Object value = resolveVariable( spec.value(), variables ); |
| addFilter( termFilter( name, value ), filterBuilder ); |
| } |
| } |
| |
| private void processMatchesSpecification( FilterBuilder filterBuilder, |
| MatchesSpecification spec, |
| Map<String, Object> variables ) |
| { |
| LOGGER.trace( "Processing MatchesSpecification {}", spec ); |
| String name = spec.property().toString(); |
| String regexp = resolveVariable( spec.regexp(), variables ).toString(); |
| addFilter( regexpFilter( name, regexp ), filterBuilder ); |
| } |
| |
| private void processPropertyNotNullSpecification( FilterBuilder filterBuilder, |
| PropertyNotNullSpecification<?> spec ) |
| { |
| LOGGER.trace( "Processing PropertyNotNullSpecification {}", spec ); |
| addFilter( existsFilter( spec.property().toString() ), filterBuilder ); |
| } |
| |
| private void processPropertyNullSpecification( FilterBuilder filterBuilder, |
| PropertyNullSpecification<?> spec ) |
| { |
| LOGGER.trace( "Processing PropertyNullSpecification {}", spec ); |
| addFilter( missingFilter( spec.property().toString() ), filterBuilder ); |
| } |
| |
| private void processAssociationNotNullSpecification( FilterBuilder filterBuilder, |
| AssociationNotNullSpecification<?> spec ) |
| { |
| LOGGER.trace( "Processing AssociationNotNullSpecification {}", spec ); |
| addFilter( existsFilter( spec.association().toString() + ".identity" ), filterBuilder ); |
| } |
| |
| private void processAssociationNullSpecification( FilterBuilder filterBuilder, |
| AssociationNullSpecification<?> spec ) |
| { |
| LOGGER.trace( "Processing AssociationNullSpecification {}", spec ); |
| addFilter( missingFilter( spec.association().toString() + ".identity" ), filterBuilder ); |
| } |
| |
| private void processManyAssociationContainsSpecification( FilterBuilder filterBuilder, |
| ManyAssociationContainsSpecification<?> spec, |
| Map<String, Object> variables ) |
| { |
| LOGGER.trace( "Processing ManyAssociationContainsSpecification {}", spec ); |
| String name = spec.manyAssociation().toString() + ".identity"; |
| Object value = resolveVariable( spec.value(), variables ); |
| addFilter( termFilter( name, value ), filterBuilder ); |
| } |
| |
| private void processNamedAssociationContainsSpecification( FilterBuilder filterBuilder, |
| NamedAssociationContainsSpecification<?> spec, |
| Map<String, Object> variables ) |
| { |
| LOGGER.trace( "Processing NamedAssociationContainsSpecification {}", spec ); |
| String name = spec.namedAssociation().toString() + ".identity"; |
| Object value = resolveVariable( spec.value(), variables ); |
| addFilter( termFilter( name, value ), filterBuilder ); |
| } |
| |
| private void processNamedAssociationContainsNameSpecification( FilterBuilder filterBuilder, |
| NamedAssociationContainsNameSpecification<?> spec, |
| Map<String, Object> variables ) |
| { |
| LOGGER.trace( "Processing NamedAssociationContainsNameSpecification {}", spec ); |
| String name = spec.namedAssociation().toString() + "._named"; |
| Object value = resolveVariable( spec.name(), variables ); |
| addFilter( termFilter( name, value ), filterBuilder ); |
| } |
| } |
| |
| } |
