private void disallowFullText(IckleParsingResult<TypeMetadata> parsingResult) { if (parsingResult.getWhereClause() != null) { if (parsingResult.getWhereClause().acceptVisitor(FullTextVisitor.INSTANCE)) { throw log.getFiltersCannotUseFullTextSearchException(); } } }
@Override public ObjectFilter getObjectFilter(String queryString, List<FieldAccumulator> acc) { final IckleParsingResult<TypeMetadata> parsingResult = IckleParser.parse(queryString, propertyHelper); disallowGroupingAndAggregations(parsingResult); // if the query is a contradiction just return an ObjectFilter that rejects everything if (parsingResult.getWhereClause() == ConstantBooleanExpr.FALSE) { return new RejectObjectFilter<>(null, parsingResult); } final MetadataAdapter<TypeMetadata, AttributeMetadata, AttributeId> metadataAdapter = createMetadataAdapter(parsingResult.getTargetEntityMetadata()); // if the query is a tautology or there is no query at all and there is no sorting or projections just return a special instance that accepts anything // in case we have sorting and projections we cannot take this shortcut because the computation of projections or sort projections is a bit more involved if ((parsingResult.getWhereClause() == null || parsingResult.getWhereClause() == ConstantBooleanExpr.TRUE) && parsingResult.getSortFields() == null && parsingResult.getProjectedPaths() == null) { return new AcceptObjectFilter<>(null, this, metadataAdapter, parsingResult); } FieldAccumulator[] accumulators = acc != null ? acc.toArray(new FieldAccumulator[acc.size()]) : null; return new ObjectFilterImpl<>(this, metadataAdapter, parsingResult, accumulators); }
normalizedQuery = booleanFilterNormalizer.normalize(parsingResult.getWhereClause());
if (parsingResult.getWhereClause() != null) { BooleanExpr normalizedWhereClause = booleanFilterNormalizer.normalize(parsingResult.getWhereClause()); if (normalizedWhereClause == ConstantBooleanExpr.FALSE) { return new EmptyResultQuery(queryFactory, cache, queryString, namedParameters, startOffset, maxResults);
if (parsingResult.getWhereClause() != null) { BooleanExpr normalizedWhereClause = booleanFilterNormalizer.normalize(parsingResult.getWhereClause()); if (normalizedWhereClause == ConstantBooleanExpr.FALSE) { return new EmptyResultQuery(queryFactory, cache, queryString, namedParameters, startOffset, maxResults);
@Override public FilterSubscription registerFilter(String queryString, Map<String, Object> namedParameters, FilterCallback callback, boolean isDeltaFilter, Object... eventType) { IckleParsingResult<TypeMetadata> parsingResult = IckleParser.parse(queryString, propertyHelper); disallowGroupingAndAggregations(parsingResult); disallowFullText(parsingResult); Map<TypeMetadata, FilterRegistry<TypeMetadata, AttributeMetadata, AttributeId>> filterMap = isDeltaFilter ? deltaFiltersByType : filtersByType; write.lock(); try { FilterRegistry<TypeMetadata, AttributeMetadata, AttributeId> filterRegistry = filterMap.get(parsingResult.getTargetEntityMetadata()); if (filterRegistry == null) { filterRegistry = new FilterRegistry<>(createMetadataAdapter(parsingResult.getTargetEntityMetadata()), true); filterMap.put(filterRegistry.getMetadataAdapter().getTypeMetadata(), filterRegistry); } return filterRegistry.addFilter(queryString, namedParameters, parsingResult.getWhereClause(), parsingResult.getProjections(), parsingResult.getProjectedTypes(), parsingResult.getSortFields(), callback, isDeltaFilter, eventType); } finally { write.unlock(); } }
if (parsingResult.getWhereClause() != null) { BooleanExpr normalizedWhereClause = booleanFilterNormalizer.normalize(parsingResult.getWhereClause()); if (normalizedWhereClause == ConstantBooleanExpr.FALSE) { return new EmptyResultQuery(queryFactory, cache, queryString, namedParameters, startOffset, maxResults);
if (parsingResult.getWhereClause() != null) { BooleanExpr normalizedWhereClause = booleanFilterNormalizer.normalize(parsingResult.getWhereClause()); if (normalizedWhereClause == ConstantBooleanExpr.FALSE) { return new EmptyResultQuery(queryFactory, cache, queryString, namedParameters, startOffset, maxResults);
if (parsingResult.getWhereClause() != null) { isFullTextQuery = parsingResult.getWhereClause().acceptVisitor(FullTextVisitor.INSTANCE); if (!isIndexed && isFullTextQuery) { throw new IllegalStateException("The cache must be indexed in order to use full-text queries."); BooleanExpr normalizedWhereClause = booleanFilterNormalizer.normalize(parsingResult.getWhereClause()); if (normalizedWhereClause == ConstantBooleanExpr.FALSE) {
if (parsingResult.getWhereClause() != null) { isFullTextQuery = parsingResult.getWhereClause().acceptVisitor(FullTextVisitor.INSTANCE); if (!isIndexed && isFullTextQuery) { throw new IllegalStateException("The cache must be indexed in order to use full-text queries."); BooleanExpr normalizedWhereClause = booleanFilterNormalizer.normalize(parsingResult.getWhereClause()); if (normalizedWhereClause == ConstantBooleanExpr.FALSE) {
public LuceneQueryParsingResult<TypeMetadata> transform(IckleParsingResult<TypeMetadata> parsingResult, Map<String, Object> namedParameters, Class<?> targetedType) { this.namedParameters = namedParameters; EntityContext entityContext = queryContextBuilder.forEntity(targetedType); fieldBridgeAndAnalyzerProvider.overrideAnalyzers(parsingResult, entityContext); queryBuilder = entityContext.get(); entityType = parsingResult.getTargetEntityMetadata(); AnalyzerReference analyzerReference = ((ExtendedSearchIntegrator) searchFactory).getAnalyzerReference(new PojoIndexedTypeIdentifier(targetedType)); if (analyzerReference.is(LuceneAnalyzerReference.class)) { entityAnalyzer = analyzerReference.unwrap(LuceneAnalyzerReference.class).getAnalyzer(); } Query query = makeQuery(parsingResult.getWhereClause()); // an all negative top level boolean query is not allowed; needs a bit of rewriting if (query instanceof BooleanQuery) { BooleanQuery booleanQuery = (BooleanQuery) query; boolean allClausesAreMustNot = booleanQuery.clauses().stream().allMatch(c -> c.getOccur() == BooleanClause.Occur.MUST_NOT); if (allClausesAreMustNot) { //It is illegal to have only must-not queries, in this case we need to add a positive clause to match everything else. BooleanQuery.Builder builder = new BooleanQuery.Builder(); for (BooleanClause clause : booleanQuery.clauses()) { builder.add(clause.getQuery(), BooleanClause.Occur.MUST_NOT); } builder.add(new MatchAllDocsQuery(), BooleanClause.Occur.FILTER); query = builder.build(); } } Sort sort = makeSort(parsingResult.getSortFields()); return new LuceneQueryParsingResult<>(query, parsingResult.getTargetEntityName(), parsingResult.getTargetEntityMetadata(), parsingResult.getProjections(), sort); }
public LuceneQueryParsingResult<TypeMetadata> transform(IckleParsingResult<TypeMetadata> parsingResult, Map<String, Object> namedParameters, Class<?> targetedType) { this.namedParameters = namedParameters; EntityContext entityContext = queryContextBuilder.forEntity(targetedType); fieldBridgeAndAnalyzerProvider.overrideAnalyzers(parsingResult, entityContext); queryBuilder = entityContext.get(); entityType = parsingResult.getTargetEntityMetadata(); AnalyzerReference analyzerReference = ((ExtendedSearchIntegrator) searchFactory).getAnalyzerReference(new PojoIndexedTypeIdentifier(targetedType)); if (analyzerReference.is(LuceneAnalyzerReference.class)) { entityAnalyzer = analyzerReference.unwrap(LuceneAnalyzerReference.class).getAnalyzer(); } Query query = makeQuery(parsingResult.getWhereClause()); // an all negative top level boolean query is not allowed; needs a bit of rewriting if (query instanceof BooleanQuery) { BooleanQuery booleanQuery = (BooleanQuery) query; boolean allClausesAreMustNot = booleanQuery.clauses().stream().allMatch(c -> c.getOccur() == BooleanClause.Occur.MUST_NOT); if (allClausesAreMustNot) { //It is illegal to have only must-not queries, in this case we need to add a positive clause to match everything else. BooleanQuery.Builder builder = new BooleanQuery.Builder(); for (BooleanClause clause : booleanQuery.clauses()) { builder.add(clause.getQuery(), BooleanClause.Occur.MUST_NOT); } builder.add(new MatchAllDocsQuery(), BooleanClause.Occur.FILTER); query = builder.build(); } } Sort sort = makeSort(parsingResult.getSortFields()); return new LuceneQueryParsingResult<>(query, parsingResult.getTargetEntityName(), parsingResult.getTargetEntityMetadata(), parsingResult.getProjections(), sort); }