Author: epbernard Date: 2009-04-02 08:24:02 -0400 (Thu, 02 Apr 2009) New Revision: 16250 Modified: search/trunk/src/main/java/org/hibernate/search/cfg/PropertyDescriptor.java search/trunk/src/main/java/org/hibernate/search/impl/MappingModelMetadataProvider.java search/trunk/src/main/java/org/hibernate/search/impl/SearchFactoryImpl.java search/trunk/src/test/java/org/hibernate/search/test/configuration/ProgrammaticMappingTest.java Log: HSEARCH-352 add analyzerDef support Modified: search/trunk/src/main/java/org/hibernate/search/cfg/PropertyDescriptor.java =================================================================== --- search/trunk/src/main/java/org/hibernate/search/cfg/PropertyDescriptor.java 2009-04-02 12:10:40 UTC (rev 16249) +++ search/trunk/src/main/java/org/hibernate/search/cfg/PropertyDescriptor.java 2009-04-02 12:24:02 UTC (rev 16250) @@ -4,6 +4,8 @@ import java.util.HashSet; import java.util.Map; import java.util.Set; +import java.util.Collection; +import java.util.ArrayList; /** * @author Emmanuel Bernard @@ -11,7 +13,7 @@ public class PropertyDescriptor { private ElementType type; private String name; - private Set<Map<String, Object>> fields = new HashSet<Map<String, Object>>(); + private Collection<Map<String, Object>> fields = new ArrayList<Map<String, Object>>(); public PropertyDescriptor(String name, ElementType type) { this.name = name; @@ -22,7 +24,7 @@ fields.add( field ); } - public Set<Map<String, Object>> getFields() { + public Collection<Map<String, Object>> getFields() { return fields; } } Modified: search/trunk/src/main/java/org/hibernate/search/impl/MappingModelMetadataProvider.java =================================================================== --- search/trunk/src/main/java/org/hibernate/search/impl/MappingModelMetadataProvider.java 2009-04-02 12:10:40 UTC (rev 16249) +++ search/trunk/src/main/java/org/hibernate/search/impl/MappingModelMetadataProvider.java 2009-04-02 12:24:02 UTC (rev 16250) @@ -5,6 +5,7 @@ import java.util.Set; import java.util.ArrayList; import java.util.HashMap; +import java.util.Collection; import java.lang.reflect.AnnotatedElement; import java.lang.reflect.Field; import java.lang.reflect.Method; @@ -25,6 +26,11 @@ import org.hibernate.search.annotations.Indexed; import org.hibernate.search.annotations.Analyzer; import org.hibernate.search.annotations.Fields; +import org.hibernate.search.annotations.AnalyzerDef; +import org.hibernate.search.annotations.TokenizerDef; +import org.hibernate.search.annotations.Parameter; +import org.hibernate.search.annotations.TokenFilterDef; +import org.hibernate.search.annotations.AnalyzerDefs; /** * @author Emmanuel Bernard @@ -44,13 +50,22 @@ private final MetadataProvider delegate; private final SearchMapping mapping; private final Map<AnnotatedElement, AnnotationReader> cache = new HashMap<AnnotatedElement, AnnotationReader>(100); + private Map<Object, Object> defaults; public MappingModelMetadataProvider(MetadataProvider delegate, SearchMapping mapping) { this.delegate = delegate; this.mapping = mapping; } + public Map<Object, Object> getDefaults() { - return delegate.getDefaults(); + if (defaults == null) { + final Map<Object, Object> delegateDefaults = delegate.getDefaults(); + defaults = delegateDefaults == null ? + new HashMap<Object, Object>() : + new HashMap<Object, Object>(delegateDefaults); + defaults.put( AnalyzerDefs.class, createAnalyzerDefArray() ); + } + return defaults; } public AnnotationReader getAnnotationReader(AnnotatedElement annotatedElement) { @@ -62,6 +77,78 @@ return reader; } + private AnalyzerDef[] createAnalyzerDefArray() { + AnalyzerDef[] defs = new AnalyzerDef[ mapping.getAnalyzerDefs().size() ]; + int index = 0; + for ( Map<String, Object> analyzerDef : mapping.getAnalyzerDefs() ) { + defs[index] = createAnalyzerDef( analyzerDef ); + index++; + } + return defs; + } + + private AnalyzerDef createAnalyzerDef(Map<String, Object> analyzerDef) { + AnnotationDescriptor analyzerDefAnnotation = new AnnotationDescriptor( AnalyzerDef.class ); + for ( Map.Entry<String, Object> entry : analyzerDef.entrySet() ) { + if ( entry.getKey().equals( "tokenizer" ) ) { + AnnotationDescriptor tokenizerAnnotation = new AnnotationDescriptor( TokenizerDef.class ); + @SuppressWarnings( "unchecked" ) + Map<String, Object> tokenizer = (Map<String, Object>) entry.getValue(); + for( Map.Entry<String, Object> tokenizerEntry : tokenizer.entrySet() ) { + if ( tokenizerEntry.getKey().equals( "params" ) ) { + Parameter[] paramsArray = createParams( (List<Map<String, Object>>) tokenizerEntry.getValue() ); + tokenizerAnnotation.setValue( "params", paramsArray ); + } + else { + tokenizerAnnotation.setValue( tokenizerEntry.getKey(), tokenizerEntry.getValue() ); + } + } + analyzerDefAnnotation.setValue( "tokenizer", AnnotationFactory.create( tokenizerAnnotation ) ); + } + else if ( entry.getKey().equals( "filters" ) ) { + TokenFilterDef[] filtersArray = createFilters( (List<Map<String, Object>>) entry.getValue() ); + analyzerDefAnnotation.setValue( "filters", filtersArray ); + } + else { + analyzerDefAnnotation.setValue( entry.getKey(), entry.getValue() ); + } + } + return AnnotationFactory.create( analyzerDefAnnotation ); + } + + private TokenFilterDef[] createFilters(List<Map<String, Object>> filters) { + TokenFilterDef[] filtersArray = new TokenFilterDef[filters.size()]; + int index = 0; + for (Map<String, Object> filter : filters) { + AnnotationDescriptor filterAnn = new AnnotationDescriptor( TokenFilterDef.class ); + for ( Map.Entry<String, Object> filterEntry : filter.entrySet() ) { + if ( filterEntry.getKey().equals( "params" ) ) { + Parameter[] paramsArray = createParams( (List<Map<String, Object>>) filterEntry.getValue() ); + filterAnn.setValue( "params", paramsArray ); + } + else { + filterAnn.setValue( filterEntry.getKey(), filterEntry.getValue() ); + } + } + filtersArray[index] = AnnotationFactory.create( filterAnn ); + index++; + } + return filtersArray; + } + + private Parameter[] createParams(List<Map<String, Object>> params) { + Parameter[] paramArray = new Parameter[ params.size() ]; + int index = 0; + for ( Map<String, Object> entry : params) { + AnnotationDescriptor paramAnnotation = new AnnotationDescriptor( Parameter.class ); + paramAnnotation.setValue( "name", entry.get("name") ); + paramAnnotation.setValue( "value", entry.get("value") ); + paramArray[index] = AnnotationFactory.create( paramAnnotation ); + index++; + } + return paramArray; + } + private static class MappingModelAnnotationReader implements AnnotationReader { private AnnotationReader delegate; private SearchMapping mapping; @@ -147,7 +234,7 @@ } private void createFields(PropertyDescriptor property) { - final Set<Map<String,Object>> fields = property.getFields(); + final Collection<Map<String,Object>> fields = property.getFields(); List<org.hibernate.search.annotations.Field> fieldAnnotations = new ArrayList<org.hibernate.search.annotations.Field>( fields.size() ); for(Map<String, Object> field : fields) { @@ -172,7 +259,8 @@ final org.hibernate.search.annotations.Field[] fieldArray = new org.hibernate.search.annotations.Field[fieldAnnotations.size()]; - fieldsAnnotation.setValue( "value", fieldAnnotations.toArray( fieldArray )); + final org.hibernate.search.annotations.Field[] fieldAsArray = fieldAnnotations.toArray( fieldArray ); + fieldsAnnotation.setValue( "value", fieldAsArray ); annotations.put( Fields.class, AnnotationFactory.create( fieldsAnnotation ) ); } Modified: search/trunk/src/main/java/org/hibernate/search/impl/SearchFactoryImpl.java =================================================================== --- search/trunk/src/main/java/org/hibernate/search/impl/SearchFactoryImpl.java 2009-04-02 12:10:40 UTC (rev 16249) +++ search/trunk/src/main/java/org/hibernate/search/impl/SearchFactoryImpl.java 2009-04-02 12:24:02 UTC (rev 16250) @@ -33,6 +33,8 @@ import org.hibernate.search.annotations.FullTextFilterDefs; import org.hibernate.search.annotations.Indexed; import org.hibernate.search.annotations.Key; +import org.hibernate.search.annotations.AnalyzerDef; +import org.hibernate.search.annotations.AnalyzerDefs; import org.hibernate.search.backend.BackendQueueProcessorFactory; import org.hibernate.search.backend.LuceneIndexingParameters; import org.hibernate.search.backend.LuceneWork; @@ -403,6 +405,8 @@ Iterator<Class<?>> iter = cfg.getClassMappings(); DirectoryProviderFactory factory = new DirectoryProviderFactory(); + initProgrammaticAnalyzers(context, reflectionManager); + while ( iter.hasNext() ) { Class mappedClass = iter.next(); if ( mappedClass == null ) { @@ -452,6 +456,17 @@ factory.startDirectoryProviders(); } + private void initProgrammaticAnalyzers(InitContext context, ReflectionManager reflectionManager) { + final Map defaults = reflectionManager.getDefaults(); + + if (defaults != null) { + AnalyzerDef[] defs = (AnalyzerDef[]) defaults.get( AnalyzerDefs.class ); + for (AnalyzerDef def : defs) { + context.addAnalyzerDef( def ); + } + } + } + private static FilterCachingStrategy buildFilterCachingStrategy(Properties properties) { FilterCachingStrategy filterCachingStrategy; String impl = properties.getProperty( Environment.FILTER_CACHING_STRATEGY ); Modified: search/trunk/src/test/java/org/hibernate/search/test/configuration/ProgrammaticMappingTest.java =================================================================== --- search/trunk/src/test/java/org/hibernate/search/test/configuration/ProgrammaticMappingTest.java 2009-04-02 12:10:40 UTC (rev 16249) +++ search/trunk/src/test/java/org/hibernate/search/test/configuration/ProgrammaticMappingTest.java 2009-04-02 12:24:02 UTC (rev 16250) @@ -7,6 +7,7 @@ import org.apache.solr.analysis.LowerCaseFilterFactory; import org.apache.solr.analysis.NGramFilterFactory; import org.apache.lucene.queryParser.QueryParser; +import org.apache.lucene.queryParser.MultiFieldQueryParser; import org.apache.lucene.analysis.standard.StandardAnalyzer; import org.hibernate.search.cfg.SearchMapping; @@ -17,6 +18,8 @@ import org.hibernate.search.FullTextSession; import org.hibernate.search.Search; import org.hibernate.search.FullTextQuery; +import org.hibernate.search.store.RAMDirectoryProvider; +import org.hibernate.search.store.FSDirectoryProvider; import org.hibernate.cfg.Configuration; import org.hibernate.Transaction; @@ -39,7 +42,7 @@ tx = s.beginTransaction(); - QueryParser parser = new QueryParser( "id", new StandardAnalyzer() ); + QueryParser parser = new QueryParser( "id", new StandardAnalyzer( ) ); org.apache.lucene.search.Query luceneQuery = parser.parse( "street1:peachtree" ); FullTextQuery query = s.createFullTextQuery( luceneQuery ).setProjection( "idx_street2", FullTextQuery.THIS ); assertEquals( "Not properly indexed", 1, query.getResultSize() ); @@ -52,16 +55,49 @@ } + public void testAnalyzerDef() throws Exception{ + Address address = new Address(); + address.setStreet1( "3340 Peachtree Rd NE" ); + address.setStreet2( "JBoss" ); + + FullTextSession s = Search.getFullTextSession( openSession() ); + Transaction tx = s.beginTransaction(); + s.persist( address ); + tx.commit(); + + s.clear(); + + tx = s.beginTransaction(); + + QueryParser parser = new QueryParser( "id", new StandardAnalyzer( ) ); + org.apache.lucene.search.Query luceneQuery = parser.parse( "street1_ngram:pea" ); + System.out.print( luceneQuery.toString() ); + final FullTextQuery query = s.createFullTextQuery( luceneQuery ); + assertEquals( "Analyzer inoperant", 1, query.getResultSize() ); + + s.delete( query.list().get( 0 )); + tx.commit(); + s.close(); + + } + @Override protected void configure(Configuration cfg) { super.configure( cfg ); + //cfg.setProperty( "hibernate.search.default.directory_provider", FSDirectoryProvider.class.getName() ); SearchMapping mapping = new SearchMapping(); - mapping.indexedClass( Address.class ) - .property( "street1", ElementType.FIELD ) - .field() - .property( "street2", ElementType.METHOD ) - .field().name( "idx_street2" ) - .store( Store.YES ); + mapping.analyzerDef( "ngram", StandardTokenizerFactory.class ) + .filter( LowerCaseFilterFactory.class ) + .filter( NGramFilterFactory.class ) + .param( "minGramSize", "3" ) + .param( "maxGramSize", "3" ) + + .indexedClass( Address.class ) + .property( "street1", ElementType.FIELD ) + .field() + .field().name( "street1_ngram" ).analyzer( "ngram" ) + .property( "street2", ElementType.METHOD ) + .field().name( "idx_street2" ).store( Store.YES ); cfg.getProperties().put( "hibernate.search.mapping_model", mapping ); }