org.compass.annotations
Annotation Type Searchable


@Target(value=TYPE)
@Retention(value=RUNTIME)
public @interface Searchable

Marks a class as searchable. A searchable class is assoiated with an alias, and allows to perform full text search on it's mapped properties/fields.

The searchable class is associated with an alias, which can be used to reference the class when performing search operations, or for other mappings to extend it.

A class mapping has it's own fully functional index, unless using the subIndex() to join several searchable classes into the same index (when joining several searchalbe classes into the same index, the search will be much faster, but updates perform locks on the sub index level, so it might slow it down). More fine grained control can be acheived using the SearchableSubIndexHash annotation.

A searchable class creates an internal "all" meta-data, which holds searchable information of all the class searchable content. Controlling the "all" property using the SearchableAllMetaData annotation.

A searchable class can have constant meta-data associated with it. They can be defined using the SearchableConstant and SearchableConstants.

Searchable class can have annotations defined on either it's fields, or on the field getter accessor. The possible annotions for them are: SearchableId, SearchableProperty, SearchableComponent, and SearchableReference. Note that collections are automatically detected and handled by Compass if annotated.

If the searchable class extends a class, or implement intefaces, they will be automatically detected and added to it in a revrse order. If the same annotaion is defined in both the searcable class and one of it's super class / interfaces, it will be overriden unless defined otherwise. The annotaions will be included even if the inteface/superclass do not implement the Searchable annotation.

The seachable class can have a specialized analyzer (different from the default one) associated with it using analyzer(). Note, that this will associate the class statically with an analyzer. Dynamically associating the class with an analyzer, the SearchableAnalyzerProperty can be used to annotated the dynamic value for the analyzer to use.

The searchable class can extend other mappings defined elsewhere (either by the xml mappings, or annotations). Remember, that the searchable class will already include all the annotations in it's super class or interface (recursivly). So there is no need to specify them in extend(). Note, that xml mapping contracts can be extended as well.

By default, the searchable class is defined as a root class. A root class is a top level searchable class. A non root class can be used to define mappings definitions for SearchableComponent, and it is preferable that classes that are only used as component mapping definitions, will be defined with root() false.

The poly() can be used to mapped polymprphic inheritance tree. This is the less prefable way to map an inhertiance tree, since the fact that a searchable class automatically inhertis all it's base class and interface mappings, means that the same result can be acheived by marking the all the inheritance tree classes as Searchable.

Compass provides it's own internal converter for searchable classes ClassMappingConverter. For advance usage, the converter can be set using converter() IT will convert the ClassMapping definitions.

Author:
kimchy
See Also:
SearchableId, SearchableProperty, SearchableComponent, SearchableReference, SearchableAnalyzerProperty

Optional Element Summary
 String alias
          The alias that is associated with the class.
 String analyzer
          A specialized analyzer (different from the default one) associated with the searchable class.
 float boost
          Boost level for the searchable class.
 String converter
          Allows to set a converter for the ClassMapping of the searchable class.
 String[] extend
          A list of aliases to extend.
 FilterDuplicates filterDuplicates
          Controls if the Searchable class should filter duplciates.
 ManagedId managedId
          Controls the managed id value for all the mapped properties that have no explicit setting of the managed id (also default to NA).
 boolean poly
          Used to mapped polymprphic inheritance tree.
 Class polyClass
          In cases where poly is set to true, allows to set the class that will be used to instantiate in all inheritance tree cases.
 boolean root
          Defines if the searchable class is a root class.
 SpellCheck spellCheck
          What is the default mode for the given searchable class in including/excluding properties from the spell check index.
 String subIndex
          The sub index the searchable class will be saved to.
 SupportUnmarshall supportUnmarshall
          Controls if the searchable class will support unmarshalling from the search engine or using Resource is enough.
 

alias

public abstract String alias
The alias that is associated with the class. Can be used to refernce the searchable class when performing search operations, or for other mappings to extend it.

Default value is the short name of the class.

Default:
""

subIndex

public abstract String subIndex
The sub index the searchable class will be saved to. A sub index is a fully functional index.

When joining several searchalbe classes into the same index, the search will be much faster, but updates perform locks on the sub index level, so it might slow it down.

Defaults to the searchable class alias() value.

More fine grained control can be used with SearchableSubIndexHash.

Default:
""

boost

public abstract float boost
Boost level for the searchable class. Controls the ranking of hits when performing searches.

Default:
1.0f

root

public abstract boolean root
Defines if the searchable class is a root class. A root class is a top level searchable class. You should define the searchable class with false if it only acts as mapping definitions for a SearchableComponent.

Default:
true

poly

public abstract boolean poly
Used to mapped polymprphic inheritance tree. This is the less prefable way to map an inheritance tree, since the fact that a searchable class automatically inhertis all it's base class and interface mappings, means that the same result can be acheived by marking the all the inheritance tree classes as Searchable, in a more performant way.

If poly is set to true, the actual class implementation will be persisted to the index, later be used to instantiate it when un-marhsalling. If a specific class need to be used to instantiate all classes, use the {polyClass() to set it.

Default:
false

polyClass

public abstract Class polyClass
In cases where poly is set to true, allows to set the class that will be used to instantiate in all inheritance tree cases.

If not set, the actual class will be saved to the index, later be used to instantiate it when un-marhsalling

Default:
java.lang.Object.class

analyzer

public abstract String analyzer
A specialized analyzer (different from the default one) associated with the searchable class. Note, that this will associate the class statically with an analyzer. Dynamically associating the class with an analyzer can be done by using the SearchableAnalyzerProperty to use the property value to dynamically lookup the value for the analyzer to use.

Default:
""

supportUnmarshall

public abstract SupportUnmarshall supportUnmarshall
Controls if the searchable class will support unmarshalling from the search engine or using Resource is enough. Un-marshalling is the process of converting a raw Resource into the actual domain object. If support un-marshall is enabled extra information will be stored within the search engine, as well as consumes extra memory.

By default Compass global osem setting supportUnmarshall controls it unless exlicitly set here.

Default:
NA

filterDuplicates

public abstract FilterDuplicates filterDuplicates
Controls if the Searchable class should filter duplciates. Duplciates are objects that have already been marshalled during the marshalling process of a single root object (and its object graph). Filtering them out means reducing the size of the index (content, of course, is still searchable), though object graph queries and possible "boost" information by having it several times is lost.

By default, controlled by global setting CompassEnvironment.Osem.FILTER_DUPLICATES which defaults to false.

Default:
NA

managedId

public abstract ManagedId managedId
Controls the managed id value for all the mapped properties that have no explicit setting of the managed id (also default to NA). The default value for the managed id is derived from globabl Compass settings and defaults to NO_STORE.

Default:
NA

extend

public abstract String[] extend
A list of aliases to extend. Extending the aliases allows to include other mapping definitions, defined via annotations or xml.

Remember, that the searchable class will already include all the annotations in it's super class or interface (recursivly). So there is no need to specify them in extend(). Note, that xml mapping code>contracts can be extended as well.

Default:
{}

spellCheck

public abstract SpellCheck spellCheck
What is the default mode for the given searchable class in including/excluding properties from the spell check index.

If set to NA, will use the globablly defined mode. If set the INCLUDE will automatically incldue all the given proeprties mappings unless specific properties are mapped with EXCLUDE. If set to EXCLUDE will automatically exclude all the given properties unless they are marked with INCLUDE.

A special note when both this is set to NA, and the global setting is set to NA as well (which is the default): In this case, Compass will use the all proeprty as the only property to add to the spell check index.

Default:
NA

converter

public abstract String converter
Allows to set a converter for the ClassMapping of the searchable class.

This is advance setting, since Compass comes with it's own internal ClassMappingConverter.

Default:
""


Copyright (c) 2004-2009 The Compass Project.