Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.infinispan.query.remote.search;
  
  import  org.apache.lucene.search.Query;
  import  org.hibernate.hql.ast.spi.predicate.*;
  import  org.hibernate.hql.internal.util.Strings;
  import  org.hibernate.hql.lucene.internal.builder.LucenePropertyHelper;
  import  org.hibernate.hql.lucene.internal.builder.predicate.LuceneConjunctionPredicate;
  import  org.hibernate.hql.lucene.internal.builder.predicate.LuceneDisjunctionPredicate;
  import  org.hibernate.hql.lucene.internal.builder.predicate.LuceneNegationPredicate;
 import  org.hibernate.hql.lucene.internal.builder.predicate.LuceneRootPredicate;
 import  org.hibernate.search.engine.metadata.impl.TypeMetadata;
 import  org.hibernate.search.query.dsl.QueryBuilder;
 import  org.hibernate.search.query.dsl.QueryContextBuilder;
 
 import java.util.List;

Factory creating predicate instances based on Lucene.

Author(s):
Gunnar Morling
 
 class IspnLucenePredicateFactory implements PredicateFactory<Query> {
 
    private final QueryContextBuilder queryContextBuilder;
    private final LucenePropertyHelper propertyHelper;
    private QueryBuilder queryBuilder;
 
    public IspnLucenePredicateFactory(QueryContextBuilder queryContextBuilder, LucenePropertyHelper propertyHelper) {
       this. = queryContextBuilder;
       this. = propertyHelper;
    }
 
    @Override
    public RootPredicate<Query> getRootPredicate(Class<?> entityType) {
        = .forEntity(entityType).get();
       return new LuceneRootPredicate();
    }
 
    @Override
    public ComparisonPredicate<Query> getComparisonPredicate(Class<?> entityType, ComparisonPredicate.Type comparisonTypeList<StringpropertyPathObject value) {
       return new IspnLuceneComparisonPredicate(, Strings.join(propertyPath"."), comparisonTypevalue);
    }
 
    @Override
    public InPredicate<Query> getInPredicate(Class<?> entityTypeList<StringpropertyPathList<Objectvalues) {
       return new IspnLuceneInPredicate(, Strings.join(propertyPath"."), values);
    }
 
    @Override
    public RangePredicate<Query> getRangePredicate(Class<?> entityTypeList<StringpropertyPathObject lowerValueObject upperValue) {
       return new IspnLuceneRangePredicate(, Strings.join(propertyPath"."), lowerValueupperValue);
    }
 
    @Override
    public NegationPredicate<Query> getNegationPredicate() {
       return new LuceneNegationPredicate();
    }
 
    @Override
    public DisjunctionPredicate<Query> getDisjunctionPredicate() {
       return new LuceneDisjunctionPredicate();
    }
 
    @Override
    public ConjunctionPredicate<Query> getConjunctionPredicate() {
       return new LuceneConjunctionPredicate();
    }
 
    @Override
    public LikePredicate<Query> getLikePredicate(Class<?> entityTypeList<StringpropertyPathString patternValueCharacter escapeCharacter) {
       return new IspnLuceneLikePredicate(, Strings.join(propertyPath"."), patternValue);
    }
 
    @Override
    public IsNullPredicate<Query> getIsNullPredicate(Class<?> entityTypeList<StringpropertyPath) {
       TypeMetadata typeMetadata = .getLeafTypeMetadata(entityTypepropertyPath.toArray(new String[propertyPath.size()]));
 
 //      String nullToken;
 //      if (propertyHelper.isEmbedded(entityType, propertyPath)) {
 //         nullToken = ((EmbeddedTypeMetadata) typeMetadata).getEmbeddedNullToken();
 //      } else {
 //         PropertyMetadata propertyMetadata = typeMetadata.getPropertyMetadataForProperty(propertyPath.get(propertyPath.size() - 1));
 //         nullToken = propertyMetadata.getFieldMetadata().iterator().next().indexNullAs();
 //      }
 //
 //      return new IspnLuceneIsNullPredicate(queryBuilder, Strings.join(propertyPath, "."), nullToken);
 
       //todo [anistor] how can a user define the null token?
       return new IspnLuceneIsNullPredicate(, Strings.join(propertyPath"."), .);
    }
 
    public static boolean isNumericValue(Object value) {
       if (value != null) {
          Class numericClass = value.getClass();
          return numericClass.isAssignableFrom(Double.class) ||
                numericClass.isAssignableFrom(Long.class) ||
                numericClass.isAssignableFrom(Integer.class) ||
                numericClass.isAssignableFrom(Float.class);
      }
      return false;
   }
New to GrepCode? Check out our FAQ X