Configures a Compass instance. The name of the Compass instance. Will be used as the registration name when using Jndi registation. Controls osem level settings and configuration Controls if the default support for un-marshalling within class mappings will default to true or false (unless it is explicitly set in the class mapping). Defaults to true. A setting for managed id index feature. When an internal managed id is created, it's index setting will be created using this global setting (if not defined locally in the mapping file). Possible values are no and un_tokenized, with default value set to no. Controls search engine level settings and configuration. Controls the alias property settings. The name of the alias property. Controls the all property settings. The all property is an intenral Compass property for each resource that holds all the content of a Resource (except for the exceluded ones). The name of the all property. The TermVectory that will be used to store the all property. If all should be enabled globally or not. Defaults to true. Should the all property honor boost settings on sepecific proeprties when searching. Defaults to true. Configures a Highlighter within Compass. The highlighter is bound to a lookup name, which can be used to reference the highlighter. The default highlighter should be regsitered under the name default. Responsible for fragmenting the text. For a custom implementation of the Fragmenter class, use the custom type, and provide the fully qualified class name in the class attribute. The type of the fragmenter. A null Lucene Fragmenter. Does not fragment the text. A simple Lucene Fragmenter. Breaks text up into same-size fragments with no concerns over spotting sentence boundaries. Allows to specify a custom class implementation of Lucene Fragmenter class. The class can be defined in the class attribute. The fully qualified class name of the implementation of Lucene Fragmenter. Used when the type is custom. The size of the fragment. Applies to the simple fragmenter. Responsible for encoding the text. For a custom implementation of the Encoder class, use the custom type, and provide the fully qualified class name in the class attribute. The type of the fragmenter. Performs no encoding of the text. Simple encoder that encodes html tags. Allows to specify a custom class implementation of Lucene Encoder class. The class can be defined in the class attribute. The fully qualified class name of the implementation of Lucene Encoder. Used when the type is custom. A simple wrapper formatter. Wraps the highlight with pre and post string (can be html or xml tags) Controlls the text that is appened before the highlighted text. Controlls the text that is appened after the highlighted text. Wraps an html span tag around the highlighted text. The background and foreground colors can be controlled and will have different color intensity depending on the score. The score (and above) displayed as maxColor. The hex color used for representing IDF scores of zero eg #FFFFFF (white) or not set if no foreground color required. The largest hex color used for representing IDF scores eg #000000 (black) or not set if no foreground color required. The hex color used for representing IDF scores of zero eg #FFFFFF (white) or not set if no background color required. The largest hex color used for representing IDF scores eg #000000 (black) or not set if no background color required. A custom implementation of the Lucene Formatter. The fully qualified class name implementation of Lucene Formatter. The name the highlighter will be registered under. Controls the way text will be tokenized in order to perform the highlight operation. Will use term vector if available to tokenize the text, otherwise will use analyzer. Forces tokenization of the text using the analyzer. Forces tokenization of the text using the tem vector information. Low level. If the query will be rewritten befored it is used by the highlighter. If the idf value will be used during the highlighting process. Used by formatters that a) score selected fragments better b) use graded highlights eg chaning intensity of font color. Automatically assigned for the provided formatters. Sets the maximum number of fragments that will be returned. Sets the separator string between fragments if using the combined fragments highlight option. Maximum bytes to analyze. Default to 50*1024 bytes. Configures an Analyzer within Compass. The analyzer is bound to a lookup name, which can be used to reference the analyzer. Two internal names that Compass uses are: default and search. Allows adding stop words for the anlayzers, or completly replacing them. Sets a stop word. The value for the stop word. Replace the set of stop words that comes with certain analyzers. Configures additonal settings for the analyzer. Mainly used with custom analyzers. The name the analyzer will bind to. One of the internal analyzer types that comes with Compass. A CustomAnalyzer type is also provided for custom analyzers, which can be defined in the analyzerClass type. Used to define the fully qualified analyzer class name in case of a CustomAnalyzer type. If using the snowball analyzer, controlls the snowball analyzer type. A comma separated LuceneAnalyzerTokenFilterProviders lookup names to be used with the Analyzer. Configures a LuceneAnalyzerTokenFilterProvider to be used within Compass. The LuceneAnalyzerTokenFilterProvider is registed under a lookup name, which can then be reference in in the analyzer definition (i.e. analyzer filters). The name the analyzer filter will be registered under. The fully qulified class name of the LuceneAnalyzerTokenFilterProvider implementation. Configures a LuceneQueryParser to be used within Compass. The LuceneQueryParser is registed under a lookup name, which can then be reference when using query parsers builders. The name the query parser will be registered under. The fully qulified class name of the LuceneQueryParser implementation. Controls the optimizer that will be used to optimizer the search engine index. Optmizers are used to optimize the index for faster search. Optimizers can be controlled programatically, or scheduled. Sets the type of the optimizer that will be used by the Compass instance. Defaults to the adaptive optimizer. When the number of segments exceeds that specified mergeFactor, the segments will be merged from the last segment, until a segment with a higher resource count will be encountered. When the number of segments exceeds that specified mergeFactor, all the segments are merged into a single segment. Performs no optimization. Will not be scheduled even if the scheduled flag is true. If the optimizer is going to be scheduled. Determines the how often the optimizer will kick in (in seconds). Default is 10 seconds. Can be float number. The merge factor for Adaptive and Aggressive optimizers. Setting to turn on usage of a compound file. When on, multiple files for each segment are merged into a single file once the segment creation is finished. This is done regardless of what directory is in use. The maximum number of terms that will be indexed for a single field in a document. This limits the amount of memory required for indexing, so that collections with very large files will not crash the indexing process by running out of memory. Note that this effectively truncates large documents, excluding from the index terms that occur further in the document. If you know your source documents are large, be sure to set this value high enough to accomodate the expected size. If you set it to Integer.MAX_VALUE, then the only limit is your memory, but you should anticipate an OutOfMemoryError. By default, no more than 10,000 terms will be indexed for a field. Sets how often (in milliseconds) the index manager will check if the index cache needs to be invalidated. Defaults to 5000. Setting it to 0 means that the cache will check if it needs to be invalidated all the time. Setting it to -1 means that the cache will never check if it needs to be invalidated, note, that it is perfectly fine if a single instance is manipulating the index. It works, since the cache is invalidated when a transaction is committed and a dirty operation has occured. The index manager schedule interval (in seconds) where different actions related to index manager will happen (such as global cache interval checks). Defaults to false. If set to true, will cause the index manager operation (including replace index) to wait for all other compass instances to invalidate their cache. The time to wait will be the indexManagerScheduledInterval configuration setting. The default search that will be used for non prefixed query values. Defaults to the value of the "all" property. Configures a set of converters to work with Compass. Configures a Converter bounded under the specified name with the given type. Setting used to configure the Converter. The name of the Converter. Will be used as the converter lookup name. Can also be one of Compass default converter name, allowing to change default Converter types that comes with Compass. The fully qualified class name of the Converter. Must implement the Converter interface. Configures the naming strategy for paths Compass will use. Setting used to configure the Naming Strategy (if needed). The Naming Strategy must implement the CompassConfigurable interface for the to be injected. The type of the Property Naming Stratergy. The fully qualified class name of the naming strategy. Must implement the PropertyNamingStrategy interface. Configures a set of converters to work with Compass. Configures a custom property accessor Setting used to configure the Property Accessor (if needed). The Property Accessor must implement the CompassConfigurable interface for the to be injected. The name of the Property Accessor. Will be used as the property accessor lookup name. Can also have the value deafult, which will be used as teh deafult property accessor when nothing is set in the mapping definitions. The fully qualified class name of the property accessor. Must implement the PropertyAccessor interface. Controls compass cache settings. First level cache strategy and settings. Type of the first level cache handling. No first cache will be used. Default first level cache handling, storing Resource and Objects in the cache per session. Controls the search engine and global transaciton settings. Specialized settings for read_committed isolation level. The transactional log connection. Can be either ram:// or file://. Should the transactional log be optimized before added to the actual index. Defaults to true. Controls Jta lookup settings. Not requires since Compass will try and guess the environment its running in. The Jndi name of JTA UserTransaction object. Set whether to cache the JTA UserTransaction object fetched from JNDI. Default is "true": UserTransaction lookup will only happen at startup, reusing the same UserTransaction handle for all transactions of all threads. This is the most efficient choice for all application servers that provide a shared UserTransaction object (the typical case). Turn this flag off to enforce a fresh lookup of the UserTransaction for every transaction. This is only necessary for application servers that return a new UserTransaction for every transaction, keeping state tied to the UserTransaction object itself rather than the current thread. TransactionManagerLookup build in implementations to use for obtaining JTA TransactionManager. User defined TransactionManagerLookup implementation to use for obtaining JTA TransactionManager. Sets the transaciton integration strategy. Uses a local transaction which does not interact with other transaction mechanisms. Uses the JTA synchronization support to synchronize with the JTA transaction (not the same as two phase commit, meaning that if the transaction fails, the other resources that participate in the transaction will not roll back). If there is no existing JTA transaction, a new one will be started. Note, if using JTA with a Jdbc connection, be sure to set the commitBeforeCompletion to true. Can be tweaked using jtaSettings. Uses the JTA Transaction to enlist a Compass implemented XAResource. This allows for Compass to participate in a two phase commit operation. Note, the JTA implementation should automatically delist the resource when the transaction commit/rollback. If there is no existing JTA transaction, a new one will be started. Uses Spring synchronization support to synchronize with Spring transactions. Uses Hibernate transaction abstraction to synchronize with its underlying transaciton. Transaction isolation levels that Compass supports. The same read committed from data base systems. As fast for read only transactions. The same read committed from data base systems. Marks the transaciton as read only, which helps when integrating with transaction strageties that support read only flag. The same as serializable from data base systems. Performance killer, basically results in transactions executed sequentially. Same as Lucene transaction isolation level. An isolation level allowing for faster indexing at the expense of transactional sematics. Operations done during a transaction will not be visible to find/load/get operations within that transaction. When using external transaciton managers (like JTA and Spring) synchronization, if the transaciton should be committed in the beforeCompletion phase. Very important to set to true when using Jdbc. The amount of time a transaction will wait in order to obtain it's specific lock (in seconds) for dirty operations. Defaults to 10 seconds. The interval that the transaction will check to see if it can obtain the lock (in milliseconds). The default value is 100 milliseconds When opening a session, Compass tries to automatically start a transaction and join it. This might mean that transaction settings when running within a managed environemnt won't take affect. The settings allows to disable the auto joining of a session to a transaction. Controls the search engine connection type and settings. Allows to set lock factory to be used Defines a Lucene directory wrapper (an implementation of DirectoryWrapperProvider) Allows to set additonal settings to a DirectoryWrapperProvider. Handy when using user defined implementations. A file system based index. The path to the index directory. A GigaSpace based index. The name of the index The url of the Space connecting to. The bucket size of the index. A Coherence based index. The name of the cache The name of the index The bucket size of the index. The type of the coherence directory. Defaults to invocable. A Terracota based index. The buffer size of the index. The flush rate for the terracotta connection. A file system based index using NIO MMAp Class. Considered slower than the general file system one, but might have memory benefits (according to the Lucene documentation). The path to the index directory. Creates a memory based index, follows the Compass life-cycle. Created when the Compass is created, and disposed when Compass is closed. The logical path of the memory index. (Used to support multiple Compass instances with ram based index). A custom connection type. Uses the url and possibly additional settings to configure it. The url for the custom connection type. Uses Jdbc to store the index in a database. Configures the Jdbc DataSource provider. A simple DataSource provider, with no other dependencies. Returns a new Jdbc Connection for each getConnection DataSource call. Good for testing, but should not be used for production since no pooling is performed. The Jdbc url for the database connection. The user name for the database connection. The password for the database connection. The driver class of Jdbc. Sets the auto commit mode for the Jdbc connection. Can be either false, true, or external (will not set the auto commit on the connection) A c3p0 data source provider. Creates a new C3P0 pooled data source. For extra configuration, use a file called c3p0.properties and storing it as a top-level resource in the same CLASSPATH / classloader that loads c3p0's jar file. The Jdbc url for the database connection. The user name for the database connection. The password for the database connection. The driver class of Jdbc. Sets the auto commit mode for the Jdbc connection. Can be either false, true, or external (will not set the auto commit on the connection) A Jakarta Commons DBCP connection pool DataSource provider. The Jdbc url for the database connection. The user name for the database connection. The password for the database connection. The driver class of Jdbc. Sets the auto commit mode for the Jdbc connection. Can be either false, true, or external (will not set the auto commit on the connection) The default TransactionIsolation state of connections created by this pool. The initial number of connections that are created when the pool is started. The maximum number of active connections that can be allocated from this pool at the same time, or zero for no limit. The maximum number of active connections that can remain idle in the pool, without extra ones being released, or zero for no limit. The minimum number of active connections that can remain idle in the pool, without extra ones being created, or 0 to create none. The maximum number of milliseconds that the pool will wait (when there are no available connections) for a connection to be returned before throwing an exception, or -1 to wait indefinitely. The maximum number of open statements that can be allocated from the statement pool at the same time, or zero for no limit. Sets if the pool will cache prepared statements. Uses Jndi to lookup a Jdbc DataSource. If special Jndi configuration is needed, use the jndi element to set it. The Jndi lookup value. Will be used to lookup the DataSource. The user name for the database connection. Optional since most of the time will be set in Jndi. The password for the database connection. Optional since most of the time will be set in Jndi. Sets the auto commit mode for the Jdbc connection. Can be either false, true, or external (will not set the auto commit on the connection) A data source provider that can use an externally configured DataSource. In order to set the external DataSource to be used, the ExternalDataSourceProvider#setDataSource(javax.sql.DataSource) static method needs to be called before the Compass instance is created. The user name for the database connection. Optional since most of the time will already be set. The password for the database connection. Optional since most of the time will already be set. Sets the auto commit mode for the Jdbc connection. Can be either false, true, or external (will not set the auto commit on the connection) Control the database schema of the tables that will be created to store the index information. The schema definition of the name column. The name of the name column. The length of the name column. The schema definition of the value column. The name of the value column. The length (in K) of the value column (for databases that require it). The schema definition of the size column. The name of the size column. The schema definition of the last modified column. The name of the last modified column. The schema definition of the deleted column. The name of the deleted column. Allows for special configuration of file entries. Most of the times, the __default__ file entry name will be configured, usually using special bufferSize values for indexInput and bufferSize and threshold for indexOutput. Note, that Compass alreay comes with sensible defaults for the file entries. Configures a file entry handling strategy. Configures the IndexInput settings (applies only for specific FileEntryHandlers). The type of the IndexInput implementation. Allows to configure one of the implementations that comes with Compass. If not set, will use the default implementation. An IndexInput implementation, that for every buffer refill will go and fetch the data from the database. An IndexInput implementation that will read all the relevant data from the database when created, and will cache it untill it is closed. Caches blobs per transaction. Only supported for dialects that supports blobs per transaction. For user defined implementation of IndexInput, allows to set the fully qulified class name of the implementation. For IndexInput implementation that support it, allows to set the memory based cached buffer size. A larger value will usually mean less hits to the database. Configures the IndexOutput settings (applies only for specific FileEntryHandlers). The type of the IndexOutput implementation. Allows to configure one of the implementations that comes with Compass. If not set, will use the default implementation. An IndexOutput implementation that initially writes the data to a memory buffer. Once it exceeds the configured threshold, will start working with a temporary file, releasing the previous buffer. An IndexOutput implemenation that stores all the data written to it in memory, and flushes it to the database when the output is closed. For user defined implementation of IndexOutput, allows to set the fully qulified class name of the implementation. For IndexOutput implementation that support it, allows to set the memory based cached buffer size. Allows to set the threshold for RAMAndFileJdbcIndexOutput. Allows to set additonal settings to a FileEntryHanlder. Handy when using user defined implementations. The name can be either __default__ which is used for all unmapped files, it can be the full name of the file stored, or the suffix of the file (the last 3 charecters). The type of the file entry handler (implements FileEntryHandler interface). Allows using one of FileEntryHandler implementations that come with Compass. A No Operation file entry handler. Performs no actual dirty operations, and returns empty data for read operations. Does not delete entries from the database, just marks them for deletion by updating the deleted column to true. Allows for registration of IndexInput and IndexOutput handlers. Removes file entries from the database by deleting the relevant rows from the database. Allows for registration of IndexInput and IndexOutput handlers. For special user defined implementation of FileEntryHandler, allows to set the fully qualified class name of the implementation. If the connection is managed or not. Basically, if set to true, compass will commit and rollback the transaction. If set to false, compass will not perform it. Should be set to true if using external transaction managers (like JTA or Spring PlatformTransactionManager), and false if using LocalTransactionFactory. If set to true, no database schema level operations will be performed (drop and create tables). When deleting the data in the index, the content will be deleted, but the table will not be dropped. Default to false. The fully qualified user defined class name of the implementation of the Dialect class. A dialect allows to work with a specific database. One of Compass intenral provided dialects. Some of the entries in the database are marked as deleted, and not actually gets to be deleted from the database. The settings controls the delta time of when they should be deleted. They will be deleted if they were marked for deleted "delta" time ago (base on database time, if possible by dialect). The value is in milliseconds. The fully qulified class name of a user defined Lock implementation. A lock strategy implementation using one of Compass provided implementations. A lock based on select...for update. Note, that not all databases support select ... for update, if the database (dialect) does not support it, a exception will be thrown. Also note, that when using select for update locking, when the database is created, the commit and write locks will be created and the select for update will be performed on them. If one wishes to switch to PhantomReadLock, they must be manually deleted. A lock based on phantom reads and table level locking. For most database and most transaction isolation levels this lock is suffecient. The existance of the lock in the database, marks it as being locked. The benefits of using this lock is the ability to release it. A simple no op lock. Performs no locking. </