Version: 5.3.3-ice35-b63
OmeroBlitz API
Version: 5.3.3-ice35-b63
|
Central search interface, allowing Web2.0 style queries. Each Search instance keeps up with several queries and lazily-loads the results as hasNext, next and results are called. These queries are created by the by* methods. Each instance also has a number of settings which can all be changed from their defaults via accessors, e.g. setBatchSize or setCaseSentivice. The only methods which are required for the proper functioning of a Search instance are:
Use of the allTypes method is discouraged, since it is possibly very resource intensive, which is why any attempt to receive results without specifically setting types or allowing all is prohibited.true if another call to
next is valid.Returns the number of active queries. This means that activeQueries gives the minimum number of remaining calls to results when batches are not merged.
number of active queries
Sets the maximum number of results that will be returned by one call to results. If batches are not merged, then results may often be less than the batch size. If batches are merged, then only the last call to results can be less than batch size. Note: some query types may not support batching at the query level, and all instances must then be loaded into memory simultaneously.
Returns the current batch size. If setBatchSize has not been called, the default value will be in effect.
maximum number of results per call to results
Set whether or not results from two separate queries can be returned in the same call to results.
Returns the current merged-batches setting. If setMergedBatches has not been called, the default value will be in effect.
Sets the case sensitivity on all queries where case-sensitivity is supported.
Returns the current case sensitivity setting. If setCaseSentivice has not been called, the default value will be in effect.
Determines if Lucene queries should not hit the database. Instead all values which are stored in the index will be loaded into the object, which includes the id. However, the entity will not be marked unloaded and therefore it is especially important to not allow a projection-instance to be saved back to the server. This can result in DATA LOSS.
Returns the current use-projection setting. If true, the client must be careful with all results that are returned. See setUseProjections for more. If setUseProjections has not been called, the default value will be in effect.
Determines if all results should be returned as unloaded objects. This is particularly useful for creating lists for further querying via IQuery. This value overrides the setUseProjections setting.
Returns the current return-unloaded setting. If true, all returned entities will be unloaded. If setReturnUnloaded has not been called, the default value will be in effect.
Permits full-text queries with a leading query if true.
Returns the current leading-wildcard setting. If false, byFullText and bySomeMustNone will throw an ApiUsageException, since leading-wildcard searches are quite slow. Use setAllowLeadingWildcard in order to permit this usage.
Restricts the search to a single type. All return values will match this type.
Restricts searches to a set of types. The entities returned are guaranteed to be one of these types.
Permits all types to be returned. For some types of queries, this carries a performance penalty as every database table must be hit.
Restricts the set of ids which will be checked. This is useful for testing one of the given restrictions on a reduced set of objects.
Uses the model::Details::getOwner and model::Details::getGroup information to restrict the entities which will be returned. If both are non-null, the two restrictions are joined by an AND.
Uses the model::Details::getOwner and model::Details::getGroup information to restrict the entities which will be returned. If both are non-null, the two restrictions are joined by an AND.
Restricts the time between which an entity may have been created.
Restricts the time between which an entity may have last been modified.
Restricts entities by the time in which any annotation (which matches the other filters) was added them. This matches the model::Details::getCreationEvent creation event of the omero::::model::Annotation.
Restricts entities by who has annotated them with an model::Annotation matching the other filters. As onlyOwnedBy, the model::Details::getOwner and model::Details::getGroup information is combined with an AND condition.
Restricts entities by who has not annotated them with an model::Annotation matching the other filters. As notOwnedBy, the model::Details::getOwner and model::Details::getGroup information is combined with an AND condition.
Restricts entities to having an
model::Annotation of all the given types. This
is useful in combination with the other onlyAnnotated*
methods to say, e.g., only annotated with a file by user X.
By default, this value is null and imposes no
restriction. Passing an empty array implies an object that
is not annotated at all.
Note: If the semantics were OR, then a client would have to
query each class individually, and compare all the various
values, checking which ids are where. However, since this
method defaults to AND, multiple calls (optionally with
isMergedBatches and isReturnUnloaded)
and combine the results. Duplicate ids are still possible
so a set of some form should be used to collect the results.
A path from the target entity which will be added to the current stack of order statements applied to the query.
A path from the target entity which will be added to the current stack of order statements applied to the query.
Removes the current stack of order statements.
Queries the database for all model::Annotation annotations of the given types for all returned instances.
Adds a fetch clause for loading non-annotation fields of returned entities. Each fetch is a hibernate clause in dot notation.
Resets all settings (non-query state) to the original default values, as if the instance had just be created.
Returns transient (without ID) model::TagAnnotation instances which represent all the model::TagAnnotation tags in the given group. The entities are transient and without ownership since multiple users can own the same tag. This method will override settings for types.
Creates a query which will return transient (without ID) model::TagAnnotation instances which represent all the model::TagAnnotation tag groups which the given tag belongs to. The entities are transient and without ownership since multiple users can own the same tag group. This method will override settings for types.
Passes the query as is to the Lucene backend.
Builds a Lucene query and passes it to the Lucene backend.
Returns transient (without ID) model::TextAnnotation instances which represent terms which are similar to the given terms. For example, if the argument is cell, one return value might have as its textValue: cellular while another has cellularize. No filtering or fetching is performed.
Delegates to IQuery::findAllByQuery method to take advantage of the and, or, and not methods, or queue-semantics.
Builds a Lucene query and passes it to byFullText.
Finds entities annotated with an model::Annotation similar to the example. This does not use Hibernate's IQuery::findByExample Query-By-Example} mechanism, since that cannot handle joins. The fields which are used are:
null it is assumed to
be a wildcard searched, and only the type of the annotation
is searched. Currently, ListAnnotations are not supported.
Removes all active queries (leaving resetDefaults settings alone), such that activeQueries will return 0.
Applies the next by* method to the previous by* method, so that a call hasNext, next, or results sees only the intersection of the two calls. For example,
service.onlyType(Image.class);
service.byFullText("foo");
service.intersection();
service.byAnnotatedWith(TagAnnotation.class);
will return only the Images with TagAnnotations.
Calling this method overrides a previous setting of or or not. If there is no active queries (i.e. activeQueries > 0), then an ApiUsageException will be thrown.
Applies the next by* method to the previous by* method, so that a call hasNext, next or results sees only the union of the two calls. For example,
service.onlyType(Image.class);
service.byFullText("foo");
service.or();
service.onlyType(Dataset.class);
service.byFullText("foo");
will return both Images and Datasets together.
Calling this method overrides a previous setting of
and or not. If there is no active queries
(i.e. activeQueries > 0), then an
ApiUsageException will be thrown.
Applies the next by* method to the previous by* method, so that a call hasNext, next, or results sees only the intersection of the two calls. For example,
service.onlyType(Image.class);
service.byFullText("foo");
service.complement();
service.byAnnotatedWith(TagAnnotation.class);
will return all the Images not annotated with
TagAnnotation. Calling this method overrides a previous setting of or or and. If there is no active queries (i.e. activeQueries > 0), then an ApiUsageException will be thrown.
Returns true if another call to
next is valid. A call to next may throw
an exception for another reason, however.
Returns the next entity from the current query. If the previous call returned the last entity from a given query, the first entity from the next query will be returned and activeQueries decremented. Since this method only returns the entity itself, a single call to currentMetadata may follow this call to gather the extra metadata which is returned in the map via results.
Returns up to getBatchSize batch size number of results along with the related query metadata. If isMergedBatches batches are merged then the results from multiple queries may be returned together.
Provides access to the extra query information (for example Lucene score and boost values) for a single call to next. This method may only be called once for any given call to next.
Provides access to the extra query information (for example Lucene score and boost values) for a single call to results. This method may only be called once for any given call to results.
Unsupported operation.
|