ISearch (Hibernate Generic DAO

All Known Subinterfaces:

IMutableSearch

All Known Implementing Classes:

FlexSearchWrapper, Search
```
public interface ISearch
```
The base search DTO (data transfer object). A Search object is passed into a DAO or Search Processor to define the parameters for a search. There are six types of parameters that can be set.
- SearchClass - The Class of the object(s) to search for.
- Filters - Any number of filters may be specified for the search. Filters specify a property and a condition that it must match for the object to be included in the result. Filters are "ANDed" together by default, but disjunction (OR) can be used instead by setting disjunction == true. See also the Filter class.
- Sorts - Any number of sorts may be specified. Each sort consists of a property, a flag for ascending or descending and a flag for whether or not to ignore case. The first sort added is the primary sort, the second, secondary and so on. See also the Sort class.
- Fields - By default the entity specified in search class is returned as the result for each row. However, by specifying fields, any combination of individual properties can be returned for each row in the result set. These properties can be returned as maps, lists, arrays or a single object depending on resultMode. See also the Field class.
  
  Additionally, fields can be specified using column operators: COUNT, COUNT DISTINCT, SUM, AVG, MAX, MIN. Note that fields with column operators can not be mixed with fields that do not use column operators.
  
  Set distinct to true in order to filter out duplicate results.
- Fetch - This determines which attached objects to pull along with the base search object. With Hibernate this eagerly loads the specified properties. Otherwise they might be loaded lazily. This is useful for performance and results that will be disconnected from Hibernate and copied to a remote client.
- Paging - The maximum number of results may be specified with maxResults. (This can also be thought of as results per page.) The first result can be specified using either firstResult or page.
ISearch is intended to be an immutable interface and only provides getters for each of the properties. The IMutableSearch interface extends ISearch by adding setters for all the properties.
Author:

dwolverton

See Also:
Filter, Field, Sort, IMutableSearch

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`RESULT_ARRAY` Value for result mode.
`static int`	`RESULT_AUTO` Value for result mode.
`static int`	`RESULT_LIST` Value for result mode.
`static int`	`RESULT_MAP` Value for result mode.
`static int`	`RESULT_SINGLE` Value for result mode.

Method Summary

Methods
Modifier and Type	Method and Description
`List<String>`	`getFetches()`
`List<Field>`	`getFields()`
`List<Filter>`	`getFilters()`
`int`	`getFirstResult()` Zero based index of first result record to return.
`int`	`getMaxResults()` The maximum number of records to return.
`int`	`getPage()` Zero based index of the page of records to return.
`int`	`getResultMode()` Result mode tells the search what form to use for the results.
`Class<?>`	`getSearchClass()`
`List<Sort>`	`getSorts()`
`boolean`	`isDisjunction()`
`boolean`	`isDistinct()`

- Field Detail
  - RESULT_AUTO
```
static final int RESULT_AUTO
```
    Value for result mode. This is the default value. With RESULT_AUTO the result mode is automatically determined according to the following rules:
    - If any field is specified with a key, use RESULT_MAP.
    - Otherwise, if zero or one fields are specified, use RESULT_SINGLE.
    - Otherwise, use RESULT_ARRAY.
    See Also:
    getResultMode(), Constant Field Values
  - RESULT_ARRAY
```
static final int RESULT_ARRAY
```
    Value for result mode. RESULT_ARRAY returns each result as an Object array (Object[]) with the entries corresponding to the fields added to the search. Here's an example:
```
 Search s = new Search(Person.class);
 s.setResultMode(Search.RESULT_ARRAY);
 s.addField("firstName");
 s.addField("lastName");
 for (Object[] array : dao.search(s)) {
        System.out.println(array[0] + " " + array[1]);
 }
 
```
    See Also:
    getResultMode(), Constant Field Values
  - RESULT_LIST
```
static final int RESULT_LIST
```
    Value for result mode. RESULT_LIST returns each result as a list of Objects (List<Object> ). Here's an example:
```
 Search s = new Search(Person.class);
 s.setResultMode(Search.RESULT_LIST);
 s.addField("firstName");
 s.addField("lastName");
 for (List<Object> list : dao.search(s)) {
        System.out.println(list.get(0) + " " + list.get(1));
 }
 
```
    See Also:
    getResultMode(), Constant Field Values
  - RESULT_MAP
```
static final int RESULT_MAP
```
    Value for result mode. RESULT_MAP returns each row as a map with properties' names or keys for keys to the corresponding values. Here's an example:
```
 Search s = new Search(Person.class);
 s.setResultMode(Search.RESULT_MAP;
 s.addField("firstName");
 s.addField("lastName", "ln");
 for (Map<String, Object> map : dao.search(s)) {
        System.out.println(map.get("firstName") + " " + map.get("ln"));
 }
 
```
    See Also:
    getResultMode(), Constant Field Values
  - RESULT_SINGLE
```
static final int RESULT_SINGLE
```
    Value for result mode. RESULT_SINGLE - Exactly one field or no fields must be specified to use this result mode. The result list contains just the value of that property for each element. Here's an example:
```
 Search s = new Search(Person.class);
 s.setResultMode(Search.RESULT_SINGLE);
 s.addField("firstName");
 for (Object name : dao.search(s)) {
        System.out.println(name);
 }
 
```
    See Also:
    getResultMode(), Constant Field Values
- Method Detail
  - getFirstResult
```
int getFirstResult()
```
    Zero based index of first result record to return.
    <= 0 for unspecified value.
  - getMaxResults
```
int getMaxResults()
```
    The maximum number of records to return. Also used as page size when calculating the first record to return based on page.
    <= 0 for unspecified value.
  - getPage
```
int getPage()
```
    Zero based index of the page of records to return. The size of a page is determined by maxResults. If both page and maxResults are specified (i.e. > 0), the first result returned is calculated by page * maxResults.
    firstResult has precedence over page. So if firstResult is specified (i.e. > 0), page is ignored.
    <= 0 for unspecified value.
  - getSearchClass
```
Class<?> getSearchClass()
```
  - getFilters
```
List<Filter> getFilters()
```
  - isDisjunction
```
boolean isDisjunction()
```
  - getSorts
```
List<Sort> getSorts()
```
  - getFields
```
List<Field> getFields()
```
  - isDistinct
```
boolean isDistinct()
```
  - getFetches
```
List<String> getFetches()
```
  - getResultMode
```
int getResultMode()
```
    Result mode tells the search what form to use for the results. Options include RESULT_AUTO, RESULT_ARRAY, RESULT_LIST , RESULT_MAP and RESULT_SINGLE.
    
    See Also:
    RESULT_AUTO, RESULT_ARRAY, RESULT_LIST, RESULT_MAP, RESULT_SINGLE

Interface ISearch

Field Summary

Method Summary

Field Detail

RESULT_AUTO

RESULT_ARRAY

RESULT_LIST

RESULT_MAP

RESULT_SINGLE

Method Detail

getFirstResult

getMaxResults

getPage

getSearchClass

getFilters

isDisjunction

getSorts

getFields

isDistinct

getFetches

getResultMode