TaskQueryImpl (Camunda BPM Javadocs 7.14.20-ee)

java.lang.Object
- org.camunda.bpm.engine.impl.db.ListQueryParameterObject
- - org.camunda.bpm.engine.impl.AbstractQuery<TaskQuery,Task>
  - - org.camunda.bpm.engine.impl.TaskQueryImpl

All Implemented Interfaces:

Serializable, Command<Object>, Query<TaskQuery,Task>, TaskQuery
```
public class TaskQueryImpl
extends AbstractQuery<TaskQuery,Task>
implements TaskQuery
```
Author:

Joram Barrez, Tom Baeyens, Falko Menge

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected class TaskQueryImpl.TaskQueryVariableValueComparable
- Nested classes/interfaces inherited from class org.camunda.bpm.engine.impl.AbstractQuery
  AbstractQuery.ResultType

Nested Classes
Modifier and Type	Class and Description
`protected class`	`TaskQueryImpl.TaskQueryVariableValueComparable`

Field Summary

Fields
Modifier and Type	Field and Description
`protected String[]`	`activityInstanceIdIn`
`protected Boolean`	`assigned`
`protected String`	`assignee`
`protected Set<String>`	`assigneeIn`
`protected String`	`assigneeLike`
`protected Set<String>`	`assigneeNotIn`
`protected List<String>`	`cachedCandidateGroups`
`protected Map<String,List<String>>`	`cachedUserGroups`
`protected String`	`candidateGroup`
`protected List<String>`	`candidateGroups`
`protected String`	`candidateUser`
`protected String`	`caseDefinitionId`
`protected String`	`caseDefinitionKey`
`protected String`	`caseDefinitionName`
`protected String`	`caseDefinitionNameLike`
`protected String`	`caseExecutionId`
`protected String`	`caseInstanceBusinessKey`
`protected String`	`caseInstanceBusinessKeyLike`
`protected String`	`caseInstanceId`
`protected Date`	`createTime`
`protected Date`	`createTimeAfter`
`protected Date`	`createTimeBefore`
`protected DelegationState`	`delegationState`
`protected String`	`description`
`protected String`	`descriptionLike`
`protected Date`	`dueAfter`
`protected Date`	`dueBefore`
`protected Date`	`dueDate`
`protected boolean`	`excludeSubtasks`
`protected String`	`executionId`
`protected Date`	`followUpAfter`
`protected Date`	`followUpBefore`
`protected Date`	`followUpDate`
`protected boolean`	`followUpNullAccepted`
`protected Boolean`	`includeAssignedTasks`
`protected boolean`	`initializeFormKeys`
`protected String`	`involvedUser`
`protected boolean`	`isOrQueryActive`
`protected boolean`	`isWithoutTenantId`
`protected String`	`key`
`protected String`	`keyLike`
`protected Integer`	`maxPriority`
`protected Integer`	`minPriority`
`protected String`	`name`
`protected String`	`nameLike`
`protected String`	`nameNotEqual`
`protected String`	`nameNotLike`
`protected boolean`	`noDelegationState`
`protected String`	`owner`
`protected String`	`parentTaskId`
`protected Integer`	`priority`
`protected String`	`processDefinitionId`
`protected String`	`processDefinitionKey`
`protected String[]`	`processDefinitionKeys`
`protected String`	`processDefinitionName`
`protected String`	`processDefinitionNameLike`
`protected String`	`processInstanceBusinessKey`
`protected String`	`processInstanceBusinessKeyLike`
`protected String[]`	`processInstanceBusinessKeys`
`protected String`	`processInstanceId`
`protected String[]`	`processInstanceIdIn`
`protected List<TaskQueryImpl>`	`queries`
`protected SuspensionState`	`suspensionState`
`protected String[]`	`taskDefinitionKeys`
`protected String`	`taskId`
`protected boolean`	`taskNameCaseInsensitive`
`protected String[]`	`tenantIds`
`protected Boolean`	`unassigned`
`protected Boolean`	`variableNamesIgnoreCase`
`protected List<TaskQueryVariableValue>`	`variables`
`protected Boolean`	`variableValuesIgnoreCase`
`protected Boolean`	`withCandidateGroups`
`protected Boolean`	`withCandidateUsers`
`protected Boolean`	`withoutCandidateGroups`
`protected Boolean`	`withoutCandidateUsers`

Fields inherited from class org.camunda.bpm.engine.impl.AbstractQuery
commandExecutor, expressions, maxResultsLimitEnabled, resultType, SORTORDER_ASC, SORTORDER_DESC, validators

Fields inherited from class org.camunda.bpm.engine.impl.db.ListQueryParameterObject
authCheck, databaseType, firstResult, maxResults, orderingProperties, parameter, tenantCheck

Constructor Summary

Constructors
Constructor and Description

TaskQueryImpl()

TaskQueryImpl(CommandExecutor commandExecutor)

Constructors
Constructor and Description
`TaskQueryImpl()`
`TaskQueryImpl(CommandExecutor commandExecutor)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`TaskQuery`	`active()` Only select tasks which are active (ie.
`TaskQuery`	`activityInstanceIdIn(String... activityInstanceIds)` Only select task which have one of the activity instance ids.
`void`	`addOrQuery(TaskQueryImpl orQuery)`
`void`	`addVariable(String name, Object value, QueryOperator operator, boolean isTaskVariable, boolean isProcessInstanceVariable)`
`protected void`	`addVariable(TaskQueryVariableValue taskQueryVariableValue)`
`TaskQuery`	`caseDefinitionId(String caseDefinitionId)` Only select tasks which are part of a case instance which has the given case definition id.
`TaskQuery`	`caseDefinitionKey(String caseDefinitionKey)` Only select tasks which are part of a case instance which has the given case definition key.
`TaskQuery`	`caseDefinitionName(String caseDefinitionName)` Only select tasks which are part of a case instance which has the given case definition name.
`TaskQuery`	`caseDefinitionNameLike(String caseDefinitionNameLike)` Only select tasks which are part of a case instance which case definition name is like the given parameter.
`TaskQuery`	`caseExecutionId(String caseExecutionId)` Only select tasks for the given case execution.
`TaskQuery`	`caseInstanceBusinessKey(String caseInstanceBusinessKey)` Only select tasks for the given case instance business key
`TaskQuery`	`caseInstanceBusinessKeyLike(String caseInstanceBusinessKeyLike)` Only select tasks matching the given case instance business key.
`TaskQuery`	`caseInstanceId(String caseInstanceId)` Only select tasks for the given case instance id.
`TaskQuery`	`caseInstanceVariableValueEquals(String variableName, Object variableValue)` Only select tasks which are part of a case instance that have a variable with the given name set to the given value.
`TaskQuery`	`caseInstanceVariableValueGreaterThan(String variableName, Object variableValue)` Only select tasks which are part of a case instance that have a variable with the given name and a variable value greater than the passed value.
`TaskQuery`	`caseInstanceVariableValueGreaterThanOrEquals(String variableName, Object variableValue)` Only select tasks which are part of a case instance that have a variable value greater than or equal to the passed value.
`TaskQuery`	`caseInstanceVariableValueLessThan(String variableName, Object variableValue)` Only select tasks which are part of a case instance that have a variable value less than the passed value.
`TaskQuery`	`caseInstanceVariableValueLessThanOrEquals(String variableName, Object variableValue)` Only select tasks which are part of a case instance that have a variable value less than or equal to the passed value.
`TaskQuery`	`caseInstanceVariableValueLike(String variableName, String variableValue)` Only select tasks which are part of a case instance that have a variable value like the given value.
`TaskQuery`	`caseInstanceVariableValueNotEquals(String variableName, Object variableValue)` Only select tasks which are part of a case instance that have a variable with the given name, but with a different value than the passed value.
`protected void`	`decideAuthorizationJoinType(CommandContext commandContext)`
`TaskQuery`	`dueAfter(Date dueAfter)` Only select tasks which have a due date after the given date.
`TaskQuery`	`dueAfterExpression(String dueDateExpression)` Only select tasks which have a due date after the described date by the given expression.
`TaskQuery`	`dueBefore(Date dueBefore)` Only select tasks which have a due date before the given date.
`TaskQuery`	`dueBeforeExpression(String dueDate)` Only select tasks which have a due date before the described date by the given expression.
`TaskQuery`	`dueDate(Date dueDate)` Only select tasks with the given due date.
`TaskQuery`	`dueDateExpression(String dueDateExpression)` Only select tasks with the described due date by the given expression.
`TaskQuery`	`endOr()` endOr() terminates an OR query on which an arbitrary amount of filter criteria were applied.
`protected void`	`ensureOrExpressionsEvaluated()`
`protected void`	`ensureVariablesInitialized()`
`TaskQuery`	`excludeSubtasks()` Only select tasks that have no parent (i.e.
`long`	`executeCount(CommandContext commandContext)`
`List<Task>`	`executeList(CommandContext commandContext, Page page)` Executes the actual query to retrieve the list of results.
`TaskQueryImpl`	`executionId(String executionId)` Only select tasks for the given execution.
`TaskQuery`	`extend(TaskQuery extending)`
`TaskQuery`	`followUpAfter(Date followUpAfter)` Only select tasks which have a follow-up date after the given date.
`TaskQuery`	`followUpAfterExpression(String followUpAfterExpression)` Only select tasks which have a follow-up date after the described date by the given expression.
`TaskQuery`	`followUpBefore(Date followUpBefore)` Only select tasks which have a follow-up date before the given date.
`TaskQuery`	`followUpBeforeExpression(String followUpBeforeExpression)` Only select tasks which have a follow-up date before the described date by the given expression.
`TaskQuery`	`followUpBeforeOrNotExistent(Date followUpDate)` Only select tasks which have no follow-up date or a follow-up date before the given date.
`TaskQuery`	`followUpBeforeOrNotExistentExpression(String followUpDateExpression)` Only select tasks which have no follow-up date or a follow-up date before the described date by the given expression.
`TaskQuery`	`followUpDate(Date followUpDate)` Only select tasks with the given follow-up date.
`TaskQuery`	`followUpDateExpression(String followUpDateExpression)` Only select tasks with the described follow-up date by the given expression.
`String[]`	`getActivityInstanceIdIn()`
`String`	`getAssignee()`
`Set<String>`	`getAssigneeIn()`
`String`	`getAssigneeLike()`
`Set<String>`	`getAssigneeNotIn()`
`protected Map<String,List<String>>`	`getCachedUserGroups()`
`String`	`getCandidateGroup()`
`List<String>`	`getCandidateGroups()`
`List<String>`	`getCandidateGroupsInternal()`
`String`	`getCandidateUser()`
`String`	`getCaseDefinitionId()`
`String`	`getCaseDefinitionKey()`
`String`	`getCaseDefinitionName()`
`String`	`getCaseDefinitionNameLike()`
`String`	`getCaseExecutionId()`
`String`	`getCaseInstanceBusinessKey()`
`String`	`getCaseInstanceBusinessKeyLike()`
`String`	`getCaseInstanceId()`
`Date`	`getCreateTime()`
`Date`	`getCreateTimeAfter()`
`Date`	`getCreateTimeBefore()`
`DelegationState`	`getDelegationState()`
`String`	`getDelegationStateString()`
`String`	`getDescription()`
`String`	`getDescriptionLike()`
`Date`	`getDueAfter()`
`Date`	`getDueBefore()`
`Date`	`getDueDate()`
`String`	`getExecutionId()`
`Date`	`getFollowUpAfter()`
`Date`	`getFollowUpBefore()`
`Date`	`getFollowUpDate()`
`protected List<String>`	`getGroupsForCandidateUser(String candidateUser)`
`String`	`getInvolvedUser()`
`boolean`	`getIsTenantIdSet()`
`String`	`getKey()`
`String`	`getKeyLike()`
`String[]`	`getKeys()`
`Integer`	`getMaxPriority()`
`Integer`	`getMinPriority()`
`String`	`getName()`
`String`	`getNameLike()`
`String`	`getNameNotEqual()`
`String`	`getNameNotLike()`
`String`	`getOwner()`
`String`	`getParentTaskId()`
`Integer`	`getPriority()`
`String`	`getProcessDefinitionId()`
`String`	`getProcessDefinitionKey()`
`String[]`	`getProcessDefinitionKeys()`
`String`	`getProcessDefinitionName()`
`String`	`getProcessDefinitionNameLike()`
`String`	`getProcessInstanceBusinessKey()`
`String`	`getProcessInstanceBusinessKeyLike()`
`String[]`	`getProcessInstanceBusinessKeys()`
`String`	`getProcessInstanceId()`
`String[]`	`getProcessInstanceIdIn()`
`List<TaskQueryImpl>`	`getQueries()`
`SuspensionState`	`getSuspensionState()`
`String[]`	`getTaskDefinitionKeys()`
`String`	`getTaskId()`
`String[]`	`getTenantIds()`
`List<TaskQueryVariableValue>`	`getVariables()`
`protected boolean`	`hasExcludingConditions()` Whether or not the query has excluding conditions.
`TaskQuery`	`includeAssignedTasks()` Select both assigned and not assigned tasks for candidate user or group queries.
`TaskQuery`	`includeAssignedTasksInternal()`
`TaskQuery`	`initializeFormKeys()` If called, the form keys of the fetched tasks are initialized and `Task.getFormKey()` will return a value (in case the task has a form key).
`Boolean`	`isAssigned()`
`Boolean`	`isAssignedInternal()`
`boolean`	`isExcludeSubtasks()`
`boolean`	`isFollowUpNullAccepted()`
`boolean`	`isIncludeAssignedTasks()`
`Boolean`	`isIncludeAssignedTasksInternal()`
`boolean`	`isInitializeFormKeys()`
`boolean`	`isNoDelegationState()`
`boolean`	`isOrQueryActive()`
`boolean`	`isQueryForProcessTasksOnly()`
`boolean`	`isTaskNameCaseInsensitive()`
`boolean`	`isUnassigned()`
`Boolean`	`isUnassignedInternal()`
`Boolean`	`isVariableNamesIgnoreCase()`
`Boolean`	`isVariableValuesIgnoreCase()`
`Boolean`	`isWithCandidateGroups()`
`Boolean`	`isWithCandidateGroupsInternal()`
`Boolean`	`isWithCandidateUsers()`
`Boolean`	`isWithoutCandidateGroups()`
`Boolean`	`isWithoutCandidateGroupsInternal()`
`Boolean`	`isWithoutCandidateUsers()`
`boolean`	`isWithoutTenantId()`
`TaskQuery`	`matchVariableNamesIgnoreCase()` All queries for task-, process- and case-variables will match the variable names in a case-insensitive way.
`TaskQuery`	`matchVariableValuesIgnoreCase()` All queries for task-, process- and case-variables will match the variable values in a case-insensitive way.
`protected void`	`mergeVariables(TaskQueryImpl extendedQuery, TaskQueryImpl extendingQuery)` Simple implementation of variable merging.
`TaskQuery`	`or()` After calling or(), a chain of several filter criteria could follow.
`TaskQuery`	`orderByCaseExecutionId()` Order by case execution id (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByCaseExecutionVariable(String variableName, ValueType valueType)` Order by a task variable value of a certain type.
`TaskQuery`	`orderByCaseInstanceId()` Order by case instance id (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByCaseInstanceVariable(String variableName, ValueType valueType)` Order by a task variable value of a certain type.
`TaskQuery`	`orderByDueDate()` Order by due date (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByExecutionId()` Order by execution id (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByExecutionVariable(String variableName, ValueType valueType)` Order by an execution variable value of a certain type.
`TaskQuery`	`orderByFollowUpDate()` Order by follow-up date (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByProcessInstanceId()` Order by process instance id (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByProcessVariable(String variableName, ValueType valueType)` Order by a process instance variable value of a certain type.
`TaskQuery`	`orderByTaskAssignee()` Order by assignee (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByTaskCreateTime()` Order by the time on which the tasks were created (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByTaskDescription()` Order by description (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByTaskId()` Order by task id (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByTaskName()` Order by task name (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByTaskNameCaseInsensitive()` Order by task name case insensitive (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByTaskPriority()` Order by priority (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`orderByTaskVariable(String variableName, ValueType valueType)` Order by a task variable value of a certain type.
`TaskQuery`	`orderByTenantId()` Order by tenant id (needs to be followed by `Query.asc()` or `Query.desc()`).
`TaskQuery`	`processDefinitionId(String processDefinitionId)` Only select tasks which are part of a process instance which has the given process definition id.
`TaskQuery`	`processDefinitionKey(String processDefinitionKey)` Only select tasks which are part of a process instance which has the given process definition key.
`TaskQuery`	`processDefinitionKeyIn(String... processDefinitionKeys)` Only select tasks which are part of a process instance which has one of the given process definition keys.
`TaskQuery`	`processDefinitionName(String processDefinitionName)` Only select tasks which are part of a process instance which has the given process definition name.
`TaskQuery`	`processDefinitionNameLike(String processDefinitionName)` Only select tasks which are part of a process instance which process definition name is like the given parameter.
`TaskQueryImpl`	`processInstanceBusinessKey(String processInstanceBusinessKey)` Only select tasks for the given process instance business key
`TaskQuery`	`processInstanceBusinessKeyExpression(String processInstanceBusinessKeyExpression)` Only select tasks for the given process instance business key described by the given expression
`TaskQuery`	`processInstanceBusinessKeyIn(String... processInstanceBusinessKeys)` Only select tasks for any of the given the given process instance business keys.
`TaskQuery`	`processInstanceBusinessKeyLike(String processInstanceBusinessKey)` Only select tasks matching the given process instance business key.
`TaskQuery`	`processInstanceBusinessKeyLikeExpression(String processInstanceBusinessKeyLikeExpression)` Only select tasks matching the given process instance business key described by the given expression.
`TaskQueryImpl`	`processInstanceId(String processInstanceId)` Only select tasks for the given process instance id.
`TaskQuery`	`processInstanceIdIn(String... processInstanceIds)` Only select tasks for the given process instance ids.
`TaskQuery`	`processVariableValueEquals(String variableName, Object variableValue)` Only select tasks which have are part of a process that have a variable with the given name set to the given value.
`TaskQuery`	`processVariableValueGreaterThan(String variableName, Object variableValue)` Only select tasks which are part of a process that have a variable with the given name and a value greater than the given one.
`TaskQuery`	`processVariableValueGreaterThanOrEquals(String variableName, Object variableValue)` Only select tasks which are part of a process that have a variable with the given name and a value greater than or equal to the given one.
`TaskQuery`	`processVariableValueLessThan(String variableName, Object variableValue)` Only select tasks which are part of a process that have a variable with the given name and a value less than the given one.
`TaskQuery`	`processVariableValueLessThanOrEquals(String variableName, Object variableValue)` Only select tasks which are part of a process that have a variable with the given name and a value greater than or equal to the given one.
`TaskQuery`	`processVariableValueLike(String variableName, String variableValue)` Only select tasks which are part of a process that have a variable with the given name and matching the given value.
`TaskQuery`	`processVariableValueNotEquals(String variableName, Object variableValue)` Only select tasks which have a variable with the given name, but with a different value than the passed value.
`protected void`	`resetCachedCandidateGroups()`
`void`	`setFollowUpNullAccepted(boolean followUpNullAccepted)`
`void`	`setOrQueryActive()`
`TaskQuery`	`suspended()` Only select tasks which are suspended, because its process instance was suspended.
`TaskQuery`	`taskAssigned()` Only select tasks which have an assignee.
`TaskQueryImpl`	`taskAssignee(String assignee)` Only select tasks which are assigned to the given user.
`TaskQuery`	`taskAssigneeExpression(String assigneeExpression)` Only select tasks which are assigned to the user described by the given expression.
`TaskQuery`	`taskAssigneeIn(String... assignees)` Only select tasks which are assigned to one of the given users.
`TaskQuery`	`taskAssigneeLike(String assignee)` Only select tasks which are matching the given user.
`TaskQuery`	`taskAssigneeLikeExpression(String assigneeLikeExpression)` Only select tasks which are assigned to the user described by the given expression.
`TaskQuery`	`taskAssigneeNotIn(String... assignees)` Only select tasks which are not assigned to any of the given users.
`TaskQueryImpl`	`taskCandidateGroup(String candidateGroup)` Only select tasks for which users in the given group are candidates.
`TaskQuery`	`taskCandidateGroupExpression(String candidateGroupExpression)` Only select tasks for which users in the described group by the given expression are candidates.
`TaskQuery`	`taskCandidateGroupIn(List<String> candidateGroups)` Only select tasks for which the 'candidateGroup' is one of the given groups.
`TaskQuery`	`taskCandidateGroupInExpression(String candidateGroupsExpression)` Only select tasks for which the 'candidateGroup' is one of the described groups of the given expression.
`TaskQueryImpl`	`taskCandidateUser(String candidateUser)` Only select tasks for which the given user or one of his groups is a candidate.
`TaskQuery`	`taskCandidateUserExpression(String candidateUserExpression)` Only select tasks for which the described user by the given expression is a candidate.
`TaskQuery`	`taskCreatedAfter(Date after)` Only select tasks that are created after the given date.
`TaskQuery`	`taskCreatedAfterExpression(String afterExpression)` Only select tasks that are created after the described date by the given expression.
`TaskQuery`	`taskCreatedBefore(Date before)` Only select tasks that are created before the given date.
`TaskQuery`	`taskCreatedBeforeExpression(String beforeExpression)` Only select tasks that are created before the described date by the given expression.
`TaskQueryImpl`	`taskCreatedOn(Date createTime)` Only select tasks that are created on the given date.
`TaskQuery`	`taskCreatedOnExpression(String createTimeExpression)` Only select tasks that are created on the described date by the given expression.
`TaskQuery`	`taskDefinitionKey(String key)` Only select tasks with the given taskDefinitionKey.
`TaskQuery`	`taskDefinitionKeyIn(String... taskDefinitionKeys)` Only select tasks which have one of the taskDefinitionKeys.
`TaskQuery`	`taskDefinitionKeyLike(String keyLike)` Only select tasks with a taskDefinitionKey that match the given parameter.
`TaskQuery`	`taskDelegationState(DelegationState delegationState)` Only select tasks with the given `DelegationState`.
`TaskQueryImpl`	`taskDescription(String description)` Only select tasks with the given description.
`TaskQuery`	`taskDescriptionLike(String descriptionLike)` Only select tasks with a description matching the parameter .
`TaskQueryImpl`	`taskId(String taskId)` Only select tasks with the given task id (in practice, there will be maximum one of this kind)
`TaskQueryImpl`	`taskInvolvedUser(String involvedUser)` Only select tasks for which there exist an `IdentityLink` with the given user
`TaskQuery`	`taskInvolvedUserExpression(String involvedUserExpression)` Only select tasks for which there exist an `IdentityLink` with the described user by the given expression
`TaskQuery`	`taskMaxPriority(Integer maxPriority)` Only select tasks with the given priority or lower.
`TaskQuery`	`taskMinPriority(Integer minPriority)` Only select tasks with the given priority or higher.
`TaskQueryImpl`	`taskName(String name)` Only select tasks with the given name.
`TaskQuery`	`taskNameCaseInsensitive()`
`TaskQueryImpl`	`taskNameLike(String nameLike)` Only select tasks with a name matching the parameter.
`TaskQuery`	`taskNameNotEqual(String name)` Only select tasks with a name not matching the given name/ The query will match the names of tasks in a case-insensitive way.
`TaskQuery`	`taskNameNotLike(String nameNotLike)` Only select tasks with a name not matching the parameter.
`TaskQueryImpl`	`taskOwner(String owner)` Only select tasks for which the given user is the owner.
`TaskQuery`	`taskOwnerExpression(String ownerExpression)` Only select tasks for which the described user by the given expression is the owner.
`TaskQuery`	`taskParentTaskId(String taskParentTaskId)` Select the tasks which are sub tasks of the given parent task.
`TaskQuery`	`taskPriority(Integer priority)` Only select tasks with the given priority.
`TaskQuery`	`taskUnassigned()` Only select tasks which don't have an assignee.
`TaskQuery`	`taskUnnassigned()` Deprecated.
`TaskQuery`	`taskVariableValueEquals(String variableName, Object variableValue)` Only select tasks which have a local task variable with the given name set to the given value.
`TaskQuery`	`taskVariableValueGreaterThan(String variableName, Object variableValue)` Only select tasks which have a local task variable with the given name and a value greater than the given one.
`TaskQuery`	`taskVariableValueGreaterThanOrEquals(String variableName, Object variableValue)` Only select tasks which have a local task variable with the given name and a value greater than or equal to the given one.
`TaskQuery`	`taskVariableValueLessThan(String variableName, Object variableValue)` Only select tasks which have a local task variable with the given name and a value less than the given one.
`TaskQuery`	`taskVariableValueLessThanOrEquals(String variableName, Object variableValue)` Only select tasks which have a local task variable with the given name and a value less than or equal to the given one.
`TaskQuery`	`taskVariableValueLike(String variableName, String variableValue)` Only select tasks which have a local task variable with the given name matching the given value.
`TaskQuery`	`taskVariableValueNotEquals(String variableName, Object variableValue)` Only select tasks which have a local task variable with the given name, but with a different value than the passed value.
`TaskQuery`	`tenantIdIn(String... tenantIds)` Only select tasks with one of the given tenant ids.
`TaskQuery`	`withCandidateGroups()` Only select tasks which have a candidate group
`TaskQuery`	`withCandidateUsers()` Only select tasks which have a candidate user
`TaskQuery`	`withoutCandidateGroups()` Only select tasks which have no candidate group
`TaskQuery`	`withoutCandidateUsers()` Only select tasks which have no candidate user
`TaskQuery`	`withoutTenantId()` Only select tasks which have no tenant id.

Methods inherited from class org.camunda.bpm.engine.impl.db.ListQueryParameterObject
getAuthCheck, getDatabaseType, getFirstResult, getFirstRow, getLastRow, getMaxResults, getOrderingProperties, getParameter, getTenantCheck, setAuthCheck, setDatabaseType, setFirstResult, setMaxResults, setOrderingProperties, setParameter, setTenantCheck

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.camunda.bpm.engine.query.Query
asc, count, desc, list, listPage, singleResult, unlimitedList

Methods inherited from interface org.camunda.bpm.engine.impl.interceptor.Command
isRetryable

- Field Detail
  - taskId
```
protected String taskId
```
  - name
```
protected String name
```
  - nameNotEqual
```
protected String nameNotEqual
```
  - nameLike
```
protected String nameLike
```
  - nameNotLike
```
protected String nameNotLike
```
  - description
```
protected String description
```
  - descriptionLike
```
protected String descriptionLike
```
  - priority
```
protected Integer priority
```
  - minPriority
```
protected Integer minPriority
```
  - maxPriority
```
protected Integer maxPriority
```
  - assignee
```
protected String assignee
```
  - assigneeLike
```
protected String assigneeLike
```
  - assigneeIn
```
protected Set<String> assigneeIn
```
  - assigneeNotIn
```
protected Set<String> assigneeNotIn
```
  - involvedUser
```
protected String involvedUser
```
  - owner
```
protected String owner
```
  - unassigned
```
protected Boolean unassigned
```
  - assigned
```
protected Boolean assigned
```
  - noDelegationState
```
protected boolean noDelegationState
```
  - delegationState
```
protected DelegationState delegationState
```
  - candidateUser
```
protected String candidateUser
```
  - candidateGroup
```
protected String candidateGroup
```
  - candidateGroups
```
protected List<String> candidateGroups
```
  - withCandidateGroups
```
protected Boolean withCandidateGroups
```
  - withoutCandidateGroups
```
protected Boolean withoutCandidateGroups
```
  - withCandidateUsers
```
protected Boolean withCandidateUsers
```
  - withoutCandidateUsers
```
protected Boolean withoutCandidateUsers
```
  - includeAssignedTasks
```
protected Boolean includeAssignedTasks
```
  - processInstanceId
```
protected String processInstanceId
```
  - processInstanceIdIn
```
protected String[] processInstanceIdIn
```
  - executionId
```
protected String executionId
```
  - activityInstanceIdIn
```
protected String[] activityInstanceIdIn
```
  - createTime
```
protected Date createTime
```
  - createTimeBefore
```
protected Date createTimeBefore
```
  - createTimeAfter
```
protected Date createTimeAfter
```
  - key
```
protected String key
```
  - keyLike
```
protected String keyLike
```
  - taskDefinitionKeys
```
protected String[] taskDefinitionKeys
```
  - processDefinitionKey
```
protected String processDefinitionKey
```
  - processDefinitionKeys
```
protected String[] processDefinitionKeys
```
  - processDefinitionId
```
protected String processDefinitionId
```
  - processDefinitionName
```
protected String processDefinitionName
```
  - processDefinitionNameLike
```
protected String processDefinitionNameLike
```
  - processInstanceBusinessKey
```
protected String processInstanceBusinessKey
```
  - processInstanceBusinessKeys
```
protected String[] processInstanceBusinessKeys
```
  - processInstanceBusinessKeyLike
```
protected String processInstanceBusinessKeyLike
```
  - variables
```
protected List<TaskQueryVariableValue> variables
```
  - dueDate
```
protected Date dueDate
```
  - dueBefore
```
protected Date dueBefore
```
  - dueAfter
```
protected Date dueAfter
```
  - followUpDate
```
protected Date followUpDate
```
  - followUpBefore
```
protected Date followUpBefore
```
  - followUpNullAccepted
```
protected boolean followUpNullAccepted
```
  - followUpAfter
```
protected Date followUpAfter
```
  - excludeSubtasks
```
protected boolean excludeSubtasks
```
  - suspensionState
```
protected SuspensionState suspensionState
```
  - initializeFormKeys
```
protected boolean initializeFormKeys
```
  - taskNameCaseInsensitive
```
protected boolean taskNameCaseInsensitive
```
  - variableNamesIgnoreCase
```
protected Boolean variableNamesIgnoreCase
```
  - variableValuesIgnoreCase
```
protected Boolean variableValuesIgnoreCase
```
  - parentTaskId
```
protected String parentTaskId
```
  - isWithoutTenantId
```
protected boolean isWithoutTenantId
```
  - tenantIds
```
protected String[] tenantIds
```
  - caseDefinitionKey
```
protected String caseDefinitionKey
```
  - caseDefinitionId
```
protected String caseDefinitionId
```
  - caseDefinitionName
```
protected String caseDefinitionName
```
  - caseDefinitionNameLike
```
protected String caseDefinitionNameLike
```
  - caseInstanceId
```
protected String caseInstanceId
```
  - caseInstanceBusinessKey
```
protected String caseInstanceBusinessKey
```
  - caseInstanceBusinessKeyLike
```
protected String caseInstanceBusinessKeyLike
```
  - caseExecutionId
```
protected String caseExecutionId
```
  - cachedCandidateGroups
```
protected List<String> cachedCandidateGroups
```
  - cachedUserGroups
```
protected Map<String,List<String>> cachedUserGroups
```
  - queries
```
protected List<TaskQueryImpl> queries
```
  - isOrQueryActive
```
protected boolean isOrQueryActive
```
- Constructor Detail
  - TaskQueryImpl
```
public TaskQueryImpl()
```
  - TaskQueryImpl
```
public TaskQueryImpl(CommandExecutor commandExecutor)
```
- Method Detail
  - taskId
```
public TaskQueryImpl taskId(String taskId)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with the given task id (in practice, there will be maximum one of this kind)
    
    Specified by:
    
    taskId in interface TaskQuery
  - taskName
```
public TaskQueryImpl taskName(String name)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with the given name. The query will match the names of tasks in a case-insensitive way.
    
    Specified by:
    
    taskName in interface TaskQuery
  - taskNameLike
```
public TaskQueryImpl taskNameLike(String nameLike)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with a name matching the parameter. The syntax is that of SQL: for example usage: nameLike(%camunda%). The query will match the names of tasks in a case-insensitive way.
    
    Specified by:
    
    taskNameLike in interface TaskQuery
  - taskDescription
```
public TaskQueryImpl taskDescription(String description)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with the given description. The query will match the descriptions of tasks in a case-insensitive way.
    
    Specified by:
    
    taskDescription in interface TaskQuery
  - taskDescriptionLike
```
public TaskQuery taskDescriptionLike(String descriptionLike)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with a description matching the parameter . The syntax is that of SQL: for example usage: descriptionLike(%camunda%) The query will match the descriptions of tasks in a case-insensitive way.
    
    Specified by:
    
    taskDescriptionLike in interface TaskQuery
  - taskPriority
```
public TaskQuery taskPriority(Integer priority)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with the given priority.
    
    Specified by:
    
    taskPriority in interface TaskQuery
  - taskMinPriority
```
public TaskQuery taskMinPriority(Integer minPriority)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with the given priority or higher.
    
    Specified by:
    
    taskMinPriority in interface TaskQuery
  - taskMaxPriority
```
public TaskQuery taskMaxPriority(Integer maxPriority)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with the given priority or lower.
    
    Specified by:
    
    taskMaxPriority in interface TaskQuery
  - taskAssignee
```
public TaskQueryImpl taskAssignee(String assignee)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are assigned to the given user.
    
    Specified by:
    
    taskAssignee in interface TaskQuery
  - taskAssigneeExpression
```
public TaskQuery taskAssigneeExpression(String assigneeExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are assigned to the user described by the given expression.
    
    Specified by:
    
    taskAssigneeExpression in interface TaskQuery
  - taskAssigneeLike
```
public TaskQuery taskAssigneeLike(String assignee)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are matching the given user. The syntax is that of SQL: for example usage: nameLike(%camunda%)
    
    Specified by:
    
    taskAssigneeLike in interface TaskQuery
  - taskAssigneeLikeExpression
```
public TaskQuery taskAssigneeLikeExpression(String assigneeLikeExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are assigned to the user described by the given expression. The syntax is that of SQL: for example usage: taskAssigneeLikeExpression("${'%test%'}")
    
    Specified by:
    
    taskAssigneeLikeExpression in interface TaskQuery
  - taskAssigneeIn
```
public TaskQuery taskAssigneeIn(String... assignees)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are assigned to one of the given users.
    
    Specified by:
    
    taskAssigneeIn in interface TaskQuery
  - taskAssigneeNotIn
```
public TaskQuery taskAssigneeNotIn(String... assignees)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are not assigned to any of the given users.
    
    Specified by:
    
    taskAssigneeNotIn in interface TaskQuery
  - taskOwner
```
public TaskQueryImpl taskOwner(String owner)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for which the given user is the owner.
    
    Specified by:
    
    taskOwner in interface TaskQuery
  - taskOwnerExpression
```
public TaskQuery taskOwnerExpression(String ownerExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for which the described user by the given expression is the owner.
    
    Specified by:
    
    taskOwnerExpression in interface TaskQuery
  - taskUnnassigned
```
@Deprecated
public TaskQuery taskUnnassigned()
```
    Deprecated.
    
    Specified by:
    
    taskUnnassigned in interface TaskQuery
    
    See Also:
    
    #taskUnassigned}
  - taskUnassigned
```
public TaskQuery taskUnassigned()
```
    Description copied from interface: TaskQuery
    
    Only select tasks which don't have an assignee.
    
    Specified by:
    
    taskUnassigned in interface TaskQuery
  - taskAssigned
```
public TaskQuery taskAssigned()
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have an assignee.
    
    Specified by:
    
    taskAssigned in interface TaskQuery
  - taskDelegationState
```
public TaskQuery taskDelegationState(DelegationState delegationState)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with the given DelegationState.
    
    Specified by:
    
    taskDelegationState in interface TaskQuery
  - taskCandidateUser
```
public TaskQueryImpl taskCandidateUser(String candidateUser)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for which the given user or one of his groups is a candidate.
    Per default it only selects tasks which are not already assigned to a user. To also include assigned task in the result specify TaskQuery.includeAssignedTasks() in your query.
    
    Specified by:
    
    taskCandidateUser in interface TaskQuery
  - taskCandidateUserExpression
```
public TaskQuery taskCandidateUserExpression(String candidateUserExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for which the described user by the given expression is a candidate.
    Per default it only selects tasks which are not already assigned to a user. To also include assigned task in the result specify TaskQuery.includeAssignedTasks() in your query.
    
    Specified by:
    
    taskCandidateUserExpression in interface TaskQuery
  - taskInvolvedUser
```
public TaskQueryImpl taskInvolvedUser(String involvedUser)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for which there exist an IdentityLink with the given user
    
    Specified by:
    
    taskInvolvedUser in interface TaskQuery
  - taskInvolvedUserExpression
```
public TaskQuery taskInvolvedUserExpression(String involvedUserExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for which there exist an IdentityLink with the described user by the given expression
    
    Specified by:
    
    taskInvolvedUserExpression in interface TaskQuery
  - withCandidateGroups
```
public TaskQuery withCandidateGroups()
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a candidate group
    
    Specified by:
    
    withCandidateGroups in interface TaskQuery
  - withoutCandidateGroups
```
public TaskQuery withoutCandidateGroups()
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have no candidate group
    
    Specified by:
    
    withoutCandidateGroups in interface TaskQuery
  - withCandidateUsers
```
public TaskQuery withCandidateUsers()
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a candidate user
    
    Specified by:
    
    withCandidateUsers in interface TaskQuery
  - withoutCandidateUsers
```
public TaskQuery withoutCandidateUsers()
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have no candidate user
    
    Specified by:
    
    withoutCandidateUsers in interface TaskQuery
  - taskCandidateGroup
```
public TaskQueryImpl taskCandidateGroup(String candidateGroup)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for which users in the given group are candidates.
    Per default it only selects tasks which are not already assigned to a user. To also include assigned task in the result specify TaskQuery.includeAssignedTasks() in your query.
    
    Specified by:
    
    taskCandidateGroup in interface TaskQuery
  - taskCandidateGroupExpression
```
public TaskQuery taskCandidateGroupExpression(String candidateGroupExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for which users in the described group by the given expression are candidates.
    Per default it only selects tasks which are not already assigned to a user. To also include assigned task in the result specify TaskQuery.includeAssignedTasks() in your query.
    
    Specified by:
    
    taskCandidateGroupExpression in interface TaskQuery
  - taskCandidateGroupIn
```
public TaskQuery taskCandidateGroupIn(List<String> candidateGroups)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for which the 'candidateGroup' is one of the given groups.
    Per default it only selects tasks which are not already assigned to a user. To also include assigned task in the result specify TaskQuery.includeAssignedTasks() in your query.
    
    Specified by:
    
    taskCandidateGroupIn in interface TaskQuery
  - taskCandidateGroupInExpression
```
public TaskQuery taskCandidateGroupInExpression(String candidateGroupsExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for which the 'candidateGroup' is one of the described groups of the given expression.
    Per default it only selects tasks which are not already assigned to a user. To also include assigned task in the result specify TaskQuery.includeAssignedTasks() in your query.
    
    Specified by:
    
    taskCandidateGroupInExpression in interface TaskQuery
  - includeAssignedTasks
```
public TaskQuery includeAssignedTasks()
```
    Description copied from interface: TaskQuery
    
    Select both assigned and not assigned tasks for candidate user or group queries.
    By default TaskQuery.taskCandidateUser(String), TaskQuery.taskCandidateGroup(String) and TaskQuery.taskCandidateGroupIn(List) queries only select not assigned tasks.
    
    Specified by:
    
    includeAssignedTasks in interface TaskQuery
  - includeAssignedTasksInternal
```
public TaskQuery includeAssignedTasksInternal()
```
  - processInstanceId
```
public TaskQueryImpl processInstanceId(String processInstanceId)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for the given process instance id.
    
    Specified by:
    
    processInstanceId in interface TaskQuery
  - processInstanceIdIn
```
public TaskQuery processInstanceIdIn(String... processInstanceIds)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for the given process instance ids.
    
    Specified by:
    
    processInstanceIdIn in interface TaskQuery
  - processInstanceBusinessKey
```
public TaskQueryImpl processInstanceBusinessKey(String processInstanceBusinessKey)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for the given process instance business key
    
    Specified by:
    
    processInstanceBusinessKey in interface TaskQuery
  - processInstanceBusinessKeyExpression
```
public TaskQuery processInstanceBusinessKeyExpression(String processInstanceBusinessKeyExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for the given process instance business key described by the given expression
    
    Specified by:
    
    processInstanceBusinessKeyExpression in interface TaskQuery
  - processInstanceBusinessKeyIn
```
public TaskQuery processInstanceBusinessKeyIn(String... processInstanceBusinessKeys)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for any of the given the given process instance business keys.
    
    Specified by:
    
    processInstanceBusinessKeyIn in interface TaskQuery
  - processInstanceBusinessKeyLike
```
public TaskQuery processInstanceBusinessKeyLike(String processInstanceBusinessKey)
```
    Description copied from interface: TaskQuery
    
    Only select tasks matching the given process instance business key. The syntax is that of SQL: for example usage: nameLike(%camunda%)
    
    Specified by:
    
    processInstanceBusinessKeyLike in interface TaskQuery
  - processInstanceBusinessKeyLikeExpression
```
public TaskQuery processInstanceBusinessKeyLikeExpression(String processInstanceBusinessKeyLikeExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks matching the given process instance business key described by the given expression. The syntax is that of SQL: for example usage: processInstanceBusinessKeyLikeExpression("${ '%camunda%' }")
    
    Specified by:
    
    processInstanceBusinessKeyLikeExpression in interface TaskQuery
  - executionId
```
public TaskQueryImpl executionId(String executionId)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for the given execution.
    
    Specified by:
    
    executionId in interface TaskQuery
  - activityInstanceIdIn
```
public TaskQuery activityInstanceIdIn(String... activityInstanceIds)
```
    Description copied from interface: TaskQuery
    
    Only select task which have one of the activity instance ids.
    
    Specified by:
    
    activityInstanceIdIn in interface TaskQuery
  - tenantIdIn
```
public TaskQuery tenantIdIn(String... tenantIds)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with one of the given tenant ids.
    
    Specified by:
    
    tenantIdIn in interface TaskQuery
  - withoutTenantId
```
public TaskQuery withoutTenantId()
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have no tenant id.
    
    Specified by:
    
    withoutTenantId in interface TaskQuery
  - taskCreatedOn
```
public TaskQueryImpl taskCreatedOn(Date createTime)
```
    Description copied from interface: TaskQuery
    
    Only select tasks that are created on the given date.
    
    Specified by:
    
    taskCreatedOn in interface TaskQuery
  - taskCreatedOnExpression
```
public TaskQuery taskCreatedOnExpression(String createTimeExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks that are created on the described date by the given expression.
    
    Specified by:
    
    taskCreatedOnExpression in interface TaskQuery
  - taskCreatedBefore
```
public TaskQuery taskCreatedBefore(Date before)
```
    Description copied from interface: TaskQuery
    
    Only select tasks that are created before the given date.
    
    Specified by:
    
    taskCreatedBefore in interface TaskQuery
  - taskCreatedBeforeExpression
```
public TaskQuery taskCreatedBeforeExpression(String beforeExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks that are created before the described date by the given expression.
    
    Specified by:
    
    taskCreatedBeforeExpression in interface TaskQuery
  - taskCreatedAfter
```
public TaskQuery taskCreatedAfter(Date after)
```
    Description copied from interface: TaskQuery
    
    Only select tasks that are created after the given date.
    
    Specified by:
    
    taskCreatedAfter in interface TaskQuery
  - taskCreatedAfterExpression
```
public TaskQuery taskCreatedAfterExpression(String afterExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks that are created after the described date by the given expression.
    
    Specified by:
    
    taskCreatedAfterExpression in interface TaskQuery
  - taskDefinitionKey
```
public TaskQuery taskDefinitionKey(String key)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with the given taskDefinitionKey. The task definition key is the id of the userTask: <userTask id="xxx" .../>
    
    Specified by:
    
    taskDefinitionKey in interface TaskQuery
  - taskDefinitionKeyLike
```
public TaskQuery taskDefinitionKeyLike(String keyLike)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with a taskDefinitionKey that match the given parameter. The syntax is that of SQL: for example usage: taskDefinitionKeyLike("%camunda%"). The task definition key is the id of the userTask: <userTask id="xxx" .../>
    
    Specified by:
    
    taskDefinitionKeyLike in interface TaskQuery
  - taskDefinitionKeyIn
```
public TaskQuery taskDefinitionKeyIn(String... taskDefinitionKeys)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have one of the taskDefinitionKeys.
    
    Specified by:
    
    taskDefinitionKeyIn in interface TaskQuery
  - taskParentTaskId
```
public TaskQuery taskParentTaskId(String taskParentTaskId)
```
    Description copied from interface: TaskQuery
    
    Select the tasks which are sub tasks of the given parent task.
    
    Specified by:
    
    taskParentTaskId in interface TaskQuery
  - caseInstanceId
```
public TaskQuery caseInstanceId(String caseInstanceId)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for the given case instance id.
    
    Specified by:
    
    caseInstanceId in interface TaskQuery
  - caseInstanceBusinessKey
```
public TaskQuery caseInstanceBusinessKey(String caseInstanceBusinessKey)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for the given case instance business key
    
    Specified by:
    
    caseInstanceBusinessKey in interface TaskQuery
  - caseInstanceBusinessKeyLike
```
public TaskQuery caseInstanceBusinessKeyLike(String caseInstanceBusinessKeyLike)
```
    Description copied from interface: TaskQuery
    
    Only select tasks matching the given case instance business key. The syntax is that of SQL: for example usage: nameLike(%aBusinessKey%)
    
    Specified by:
    
    caseInstanceBusinessKeyLike in interface TaskQuery
  - caseExecutionId
```
public TaskQuery caseExecutionId(String caseExecutionId)
```
    Description copied from interface: TaskQuery
    
    Only select tasks for the given case execution.
    
    Specified by:
    
    caseExecutionId in interface TaskQuery
  - caseDefinitionId
```
public TaskQuery caseDefinitionId(String caseDefinitionId)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a case instance which has the given case definition id.
    
    Specified by:
    
    caseDefinitionId in interface TaskQuery
  - caseDefinitionKey
```
public TaskQuery caseDefinitionKey(String caseDefinitionKey)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a case instance which has the given case definition key.
    
    Specified by:
    
    caseDefinitionKey in interface TaskQuery
  - caseDefinitionName
```
public TaskQuery caseDefinitionName(String caseDefinitionName)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a case instance which has the given case definition name.
    
    Specified by:
    
    caseDefinitionName in interface TaskQuery
  - caseDefinitionNameLike
```
public TaskQuery caseDefinitionNameLike(String caseDefinitionNameLike)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a case instance which case definition name is like the given parameter. The syntax is that of SQL: for example usage: nameLike(%processDefinitionName%)
    
    Specified by:
    
    caseDefinitionNameLike in interface TaskQuery
  - taskVariableValueEquals
```
public TaskQuery taskVariableValueEquals(String variableName,
                                         Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a local task variable with the given name set to the given value.
    
    Specified by:
    
    taskVariableValueEquals in interface TaskQuery
  - taskVariableValueNotEquals
```
public TaskQuery taskVariableValueNotEquals(String variableName,
                                            Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a local task variable with the given name, but with a different value than the passed value. Byte-arrays and Serializable objects (which are not primitive type wrappers) are not supported.
    
    Specified by:
    
    taskVariableValueNotEquals in interface TaskQuery
  - taskVariableValueLike
```
public TaskQuery taskVariableValueLike(String variableName,
                                       String variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a local task variable with the given name matching the given value. The syntax is that of SQL: for example usage: valueLike(%value%)
    
    Specified by:
    
    taskVariableValueLike in interface TaskQuery
  - taskVariableValueGreaterThan
```
public TaskQuery taskVariableValueGreaterThan(String variableName,
                                              Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a local task variable with the given name and a value greater than the given one.
    
    Specified by:
    
    taskVariableValueGreaterThan in interface TaskQuery
  - taskVariableValueGreaterThanOrEquals
```
public TaskQuery taskVariableValueGreaterThanOrEquals(String variableName,
                                                      Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a local task variable with the given name and a value greater than or equal to the given one.
    
    Specified by:
    
    taskVariableValueGreaterThanOrEquals in interface TaskQuery
  - taskVariableValueLessThan
```
public TaskQuery taskVariableValueLessThan(String variableName,
                                           Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a local task variable with the given name and a value less than the given one.
    
    Specified by:
    
    taskVariableValueLessThan in interface TaskQuery
  - taskVariableValueLessThanOrEquals
```
public TaskQuery taskVariableValueLessThanOrEquals(String variableName,
                                                   Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a local task variable with the given name and a value less than or equal to the given one.
    
    Specified by:
    
    taskVariableValueLessThanOrEquals in interface TaskQuery
  - processVariableValueEquals
```
public TaskQuery processVariableValueEquals(String variableName,
                                            Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have are part of a process that have a variable with the given name set to the given value.
    
    Specified by:
    
    processVariableValueEquals in interface TaskQuery
  - processVariableValueNotEquals
```
public TaskQuery processVariableValueNotEquals(String variableName,
                                               Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a variable with the given name, but with a different value than the passed value. Byte-arrays and Serializable objects (which are not primitive type wrappers) are not supported.
    
    Specified by:
    
    processVariableValueNotEquals in interface TaskQuery
  - processVariableValueLike
```
public TaskQuery processVariableValueLike(String variableName,
                                          String variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a process that have a variable with the given name and matching the given value. The syntax is that of SQL: for example usage: valueLike(%value%)
    
    Specified by:
    
    processVariableValueLike in interface TaskQuery
  - processVariableValueGreaterThan
```
public TaskQuery processVariableValueGreaterThan(String variableName,
                                                 Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a process that have a variable with the given name and a value greater than the given one.
    
    Specified by:
    
    processVariableValueGreaterThan in interface TaskQuery
  - processVariableValueGreaterThanOrEquals
```
public TaskQuery processVariableValueGreaterThanOrEquals(String variableName,
                                                         Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a process that have a variable with the given name and a value greater than or equal to the given one.
    
    Specified by:
    
    processVariableValueGreaterThanOrEquals in interface TaskQuery
  - processVariableValueLessThan
```
public TaskQuery processVariableValueLessThan(String variableName,
                                              Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a process that have a variable with the given name and a value less than the given one.
    
    Specified by:
    
    processVariableValueLessThan in interface TaskQuery
  - processVariableValueLessThanOrEquals
```
public TaskQuery processVariableValueLessThanOrEquals(String variableName,
                                                      Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a process that have a variable with the given name and a value greater than or equal to the given one.
    
    Specified by:
    
    processVariableValueLessThanOrEquals in interface TaskQuery
  - caseInstanceVariableValueEquals
```
public TaskQuery caseInstanceVariableValueEquals(String variableName,
                                                 Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a case instance that have a variable with the given name set to the given value. The type of variable is determined based on the value, using types configured in ProcessEngineConfiguration#getVariableSerializers(). Byte-arrays and Serializable objects (which are not primitive type wrappers) are not supported.
    
    Specified by:
    
    caseInstanceVariableValueEquals in interface TaskQuery
  - caseInstanceVariableValueNotEquals
```
public TaskQuery caseInstanceVariableValueNotEquals(String variableName,
                                                    Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a case instance that have a variable with the given name, but with a different value than the passed value. The type of variable is determined based on the value, using types configured in ProcessEngineConfiguration#getVariableSerializers(). Byte-arrays and Serializable objects (which are not primitive type wrappers) are not supported.
    
    Specified by:
    
    caseInstanceVariableValueNotEquals in interface TaskQuery
  - caseInstanceVariableValueLike
```
public TaskQuery caseInstanceVariableValueLike(String variableName,
                                               String variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a case instance that have a variable value like the given value. This be used on string variables only.
    
    Specified by:
    
    caseInstanceVariableValueLike in interface TaskQuery
  - caseInstanceVariableValueGreaterThan
```
public TaskQuery caseInstanceVariableValueGreaterThan(String variableName,
                                                      Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a case instance that have a variable with the given name and a variable value greater than the passed value. Booleans, Byte-arrays and Serializable objects (which are not primitive type wrappers) are not supported.
    
    Specified by:
    
    caseInstanceVariableValueGreaterThan in interface TaskQuery
  - caseInstanceVariableValueGreaterThanOrEquals
```
public TaskQuery caseInstanceVariableValueGreaterThanOrEquals(String variableName,
                                                              Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a case instance that have a variable value greater than or equal to the passed value. Booleans, Byte-arrays and Serializable objects (which are not primitive type wrappers) are not supported.
    
    Specified by:
    
    caseInstanceVariableValueGreaterThanOrEquals in interface TaskQuery
  - caseInstanceVariableValueLessThan
```
public TaskQuery caseInstanceVariableValueLessThan(String variableName,
                                                   Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a case instance that have a variable value less than the passed value. Booleans, Byte-arrays and Serializable objects (which are not primitive type wrappers) are not supported.
    
    Specified by:
    
    caseInstanceVariableValueLessThan in interface TaskQuery
  - caseInstanceVariableValueLessThanOrEquals
```
public TaskQuery caseInstanceVariableValueLessThanOrEquals(String variableName,
                                                           Object variableValue)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a case instance that have a variable value less than or equal to the passed value. Booleans, Byte-arrays and Serializable objects (which are not primitive type wrappers) are not supported.
    
    Specified by:
    
    caseInstanceVariableValueLessThanOrEquals in interface TaskQuery
  - processDefinitionKey
```
public TaskQuery processDefinitionKey(String processDefinitionKey)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a process instance which has the given process definition key.
    
    Specified by:
    
    processDefinitionKey in interface TaskQuery
  - processDefinitionKeyIn
```
public TaskQuery processDefinitionKeyIn(String... processDefinitionKeys)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a process instance which has one of the given process definition keys.
    
    Specified by:
    
    processDefinitionKeyIn in interface TaskQuery
  - processDefinitionId
```
public TaskQuery processDefinitionId(String processDefinitionId)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a process instance which has the given process definition id.
    
    Specified by:
    
    processDefinitionId in interface TaskQuery
  - processDefinitionName
```
public TaskQuery processDefinitionName(String processDefinitionName)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a process instance which has the given process definition name.
    
    Specified by:
    
    processDefinitionName in interface TaskQuery
  - processDefinitionNameLike
```
public TaskQuery processDefinitionNameLike(String processDefinitionName)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are part of a process instance which process definition name is like the given parameter. The syntax is that of SQL: for example usage: nameLike(%processDefinitionName%)
    
    Specified by:
    
    processDefinitionNameLike in interface TaskQuery
  - dueDate
```
public TaskQuery dueDate(Date dueDate)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with the given due date.
    
    Specified by:
    
    dueDate in interface TaskQuery
  - dueDateExpression
```
public TaskQuery dueDateExpression(String dueDateExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with the described due date by the given expression.
    
    Specified by:
    
    dueDateExpression in interface TaskQuery
  - dueBefore
```
public TaskQuery dueBefore(Date dueBefore)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a due date before the given date.
    
    Specified by:
    
    dueBefore in interface TaskQuery
  - dueBeforeExpression
```
public TaskQuery dueBeforeExpression(String dueDate)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a due date before the described date by the given expression.
    
    Specified by:
    
    dueBeforeExpression in interface TaskQuery
  - dueAfter
```
public TaskQuery dueAfter(Date dueAfter)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a due date after the given date.
    
    Specified by:
    
    dueAfter in interface TaskQuery
  - dueAfterExpression
```
public TaskQuery dueAfterExpression(String dueDateExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a due date after the described date by the given expression.
    
    Specified by:
    
    dueAfterExpression in interface TaskQuery
  - followUpDate
```
public TaskQuery followUpDate(Date followUpDate)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with the given follow-up date.
    
    Specified by:
    
    followUpDate in interface TaskQuery
  - followUpDateExpression
```
public TaskQuery followUpDateExpression(String followUpDateExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with the described follow-up date by the given expression.
    
    Specified by:
    
    followUpDateExpression in interface TaskQuery
  - followUpBefore
```
public TaskQuery followUpBefore(Date followUpBefore)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a follow-up date before the given date.
    
    Specified by:
    
    followUpBefore in interface TaskQuery
  - followUpBeforeExpression
```
public TaskQuery followUpBeforeExpression(String followUpBeforeExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a follow-up date before the described date by the given expression.
    
    Specified by:
    
    followUpBeforeExpression in interface TaskQuery
  - followUpBeforeOrNotExistent
```
public TaskQuery followUpBeforeOrNotExistent(Date followUpDate)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have no follow-up date or a follow-up date before the given date. Serves the typical use case "give me all tasks without follow-up or follow-up date which is already due"
    
    Specified by:
    
    followUpBeforeOrNotExistent in interface TaskQuery
  - followUpBeforeOrNotExistentExpression
```
public TaskQuery followUpBeforeOrNotExistentExpression(String followUpDateExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have no follow-up date or a follow-up date before the described date by the given expression. Serves the typical use case "give me all tasks without follow-up or follow-up date which is already due"
    
    Specified by:
    
    followUpBeforeOrNotExistentExpression in interface TaskQuery
  - setFollowUpNullAccepted
```
public void setFollowUpNullAccepted(boolean followUpNullAccepted)
```
  - followUpAfter
```
public TaskQuery followUpAfter(Date followUpAfter)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a follow-up date after the given date.
    
    Specified by:
    
    followUpAfter in interface TaskQuery
  - followUpAfterExpression
```
public TaskQuery followUpAfterExpression(String followUpAfterExpression)
```
    Description copied from interface: TaskQuery
    
    Only select tasks which have a follow-up date after the described date by the given expression.
    
    Specified by:
    
    followUpAfterExpression in interface TaskQuery
  - excludeSubtasks
```
public TaskQuery excludeSubtasks()
```
    Description copied from interface: TaskQuery
    
    Only select tasks that have no parent (i.e. do not select subtasks).
    
    Specified by:
    
    excludeSubtasks in interface TaskQuery
  - active
```
public TaskQuery active()
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are active (ie. not suspended)
    
    Specified by:
    
    active in interface TaskQuery
  - suspended
```
public TaskQuery suspended()
```
    Description copied from interface: TaskQuery
    
    Only select tasks which are suspended, because its process instance was suspended.
    
    Specified by:
    
    suspended in interface TaskQuery
  - initializeFormKeys
```
public TaskQuery initializeFormKeys()
```
    Description copied from interface: TaskQuery
    
    If called, the form keys of the fetched tasks are initialized and Task.getFormKey() will return a value (in case the task has a form key).
    
    Specified by:
    
    initializeFormKeys in interface TaskQuery
    
    Returns:
    
    the query itself
  - taskNameCaseInsensitive
```
public TaskQuery taskNameCaseInsensitive()
```
  - hasExcludingConditions
```
protected boolean hasExcludingConditions()
```
    Description copied from class: AbstractQuery
    
    Whether or not the query has excluding conditions. If the query has excluding conditions, (e.g. task due date before and after are excluding), the SQL query is avoided and a default result is returned. The returned result is the same as if the SQL was executed and there were no entries.
    
    Overrides:
    
    hasExcludingConditions in class AbstractQuery<TaskQuery,Task>
    
    Returns:
    
    true if the query does have excluding conditions, false otherwise
  - getCandidateGroups
```
public List<String> getCandidateGroups()
```
  - isWithCandidateGroups
```
public Boolean isWithCandidateGroups()
```
  - isWithCandidateUsers
```
public Boolean isWithCandidateUsers()
```
  - isWithCandidateGroupsInternal
```
public Boolean isWithCandidateGroupsInternal()
```
  - isWithoutCandidateGroups
```
public Boolean isWithoutCandidateGroups()
```
  - isWithoutCandidateUsers
```
public Boolean isWithoutCandidateUsers()
```
  - isWithoutCandidateGroupsInternal
```
public Boolean isWithoutCandidateGroupsInternal()
```
  - getCandidateGroupsInternal
```
public List<String> getCandidateGroupsInternal()
```
  - getGroupsForCandidateUser
```
protected List<String> getGroupsForCandidateUser(String candidateUser)
```
  - getCachedUserGroups
```
protected Map<String,List<String>> getCachedUserGroups()
```
  - ensureOrExpressionsEvaluated
```
protected void ensureOrExpressionsEvaluated()
```
  - ensureVariablesInitialized
```
protected void ensureVariablesInitialized()
```
  - addVariable
```
public void addVariable(String name,
                        Object value,
                        QueryOperator operator,
                        boolean isTaskVariable,
                        boolean isProcessInstanceVariable)
```
  - addVariable
```
protected void addVariable(TaskQueryVariableValue taskQueryVariableValue)
```
  - orderByTaskId
```
public TaskQuery orderByTaskId()
```
    Description copied from interface: TaskQuery
    
    Order by task id (needs to be followed by Query.asc() or Query.desc()).
    
    Specified by:
    
    orderByTaskId in interface TaskQuery
  - orderByTaskName
```
public TaskQuery orderByTaskName()
```
    Description copied from interface: TaskQuery
    
    Order by task name (needs to be followed by Query.asc() or Query.desc()).
    
    Specified by:
    
    orderByTaskName in interface TaskQuery
  - orderByTaskNameCaseInsensitive
```
public TaskQuery orderByTaskNameCaseInsensitive()
```
    Description copied from interface: TaskQuery
    
    Order by task name case insensitive (needs to be followed by Query.asc() or Query.desc()).
    
    Specified by:
    
    orderByTaskNameCaseInsensitive in interface TaskQuery
  - orderByTaskDescription
```
public TaskQuery orderByTaskDescription()
```
    Description copied from interface: TaskQuery
    
    Order by description (needs to be followed by Query.asc() or Query.desc()).
    
    Specified by:
    
    orderByTaskDescription in interface TaskQuery
  - orderByTaskPriority
```
public TaskQuery orderByTaskPriority()
```
    Description copied from interface: TaskQuery
    
    Order by priority (needs to be followed by Query.asc() or Query.desc()).
    
    Specified by:
    
    orderByTaskPriority in interface TaskQuery
  - orderByProcessInstanceId
```
public TaskQuery orderByProcessInstanceId()
```
    Description copied from interface: TaskQuery
    
    Order by process instance id (needs to be followed by Query.asc() or Query.desc()).
    
    Specified by:
    
    orderByProcessInstanceId in interface TaskQuery
  - orderByCaseInstanceId
```
public TaskQuery orderByCaseInstanceId()
```
    Description copied from interface: TaskQuery
    
    Order by case instance id (needs to be followed by Query.asc() or Query.desc()).
    
    Specified by:
    
    orderByCaseInstanceId in interface TaskQuery
  - orderByExecutionId
```
public TaskQuery orderByExecutionId()
```
    Description copied from interface: TaskQuery
    
    Order by execution id (needs to be followed by Query.asc() or Query.desc()).
    
    Specified by:
    
    orderByExecutionId in interface TaskQuery
  - orderByTenantId
```
public TaskQuery orderByTenantId()
```
    Description copied from interface: TaskQuery
    
    Order by tenant id (needs to be followed by Query.asc() or Query.desc()). Note that the ordering of tasks without tenant id is database-specific.
    
    Specified by:
    
    orderByTenantId in interface TaskQuery
  - orderByCaseExecutionId
```
public TaskQuery orderByCaseExecutionId()
```
    Description copied from interface: TaskQuery
    
    Order by case execution id (needs to be followed by Query.asc() or Query.desc()).
    
    Specified by:
    
    orderByCaseExecutionId in interface TaskQuery
  - orderByTaskAssignee
```
public TaskQuery orderByTaskAssignee()
```
    Description copied from interface: TaskQuery
    
    Order by assignee (needs to be followed by Query.asc() or Query.desc()).
    
    Specified by:
    
    orderByTaskAssignee in interface TaskQuery
  - orderByTaskCreateTime
```
public TaskQuery orderByTaskCreateTime()
```
    Description copied from interface: TaskQuery
    
    Order by the time on which the tasks were created (needs to be followed by Query.asc() or Query.desc()).
    
    Specified by:
    
    orderByTaskCreateTime in interface TaskQuery
  - orderByDueDate
```
public TaskQuery orderByDueDate()
```
    Description copied from interface: TaskQuery
    
    Order by due date (needs to be followed by Query.asc() or Query.desc()).
    
    Specified by:
    
    orderByDueDate in interface TaskQuery
  - orderByFollowUpDate
```
public TaskQuery orderByFollowUpDate()
```
    Description copied from interface: TaskQuery
    
    Order by follow-up date (needs to be followed by Query.asc() or Query.desc()).
    
    Specified by:
    
    orderByFollowUpDate in interface TaskQuery
  - orderByProcessVariable
```
public TaskQuery orderByProcessVariable(String variableName,
                                        ValueType valueType)
```
    Description copied from interface: TaskQuery
    
    Order by a process instance variable value of a certain type. Calling this method multiple times specifies secondary, tertiary orderings, etc. The ordering of variables with null values is database-specific.
    
    Specified by:
    
    orderByProcessVariable in interface TaskQuery
  - orderByExecutionVariable
```
public TaskQuery orderByExecutionVariable(String variableName,
                                          ValueType valueType)
```
    Description copied from interface: TaskQuery
    
    Order by an execution variable value of a certain type. Calling this method multiple times specifies secondary, tertiary orderings, etc. The ordering of variables with null values is database-specific.
    
    Specified by:
    
    orderByExecutionVariable in interface TaskQuery
  - orderByTaskVariable
```
public TaskQuery orderByTaskVariable(String variableName,
                                     ValueType valueType)
```
    Description copied from interface: TaskQuery
    
    Order by a task variable value of a certain type. Calling this method multiple times specifies secondary, tertiary orderings, etc. The ordering of variables with null values is database-specific.
    
    Specified by:
    
    orderByTaskVariable in interface TaskQuery
  - orderByCaseExecutionVariable
```
public TaskQuery orderByCaseExecutionVariable(String variableName,
                                              ValueType valueType)
```
    Description copied from interface: TaskQuery
    
    Order by a task variable value of a certain type. Calling this method multiple times specifies secondary, tertiary orderings, etc. The ordering of variables with null values is database-specific.
    
    Specified by:
    
    orderByCaseExecutionVariable in interface TaskQuery
  - orderByCaseInstanceVariable
```
public TaskQuery orderByCaseInstanceVariable(String variableName,
                                             ValueType valueType)
```
    Description copied from interface: TaskQuery
    
    Order by a task variable value of a certain type. Calling this method multiple times specifies secondary, tertiary orderings, etc. The ordering of variables with null values is database-specific.
    
    Specified by:
    
    orderByCaseInstanceVariable in interface TaskQuery
  - executeList
```
public List<Task> executeList(CommandContext commandContext,
                              Page page)
```
    Description copied from class: AbstractQuery
    
    Executes the actual query to retrieve the list of results.
    
    Specified by:
    
    executeList in class AbstractQuery<TaskQuery,Task>
    
    page - used if the results must be paged. If null, no paging will be applied.
  - executeCount
```
public long executeCount(CommandContext commandContext)
```
    Specified by:
    
    executeCount in class AbstractQuery<TaskQuery,Task>
  - decideAuthorizationJoinType
```
protected void decideAuthorizationJoinType(CommandContext commandContext)
```
  - resetCachedCandidateGroups
```
protected void resetCachedCandidateGroups()
```
  - getName
```
public String getName()
```
  - getNameNotEqual
```
public String getNameNotEqual()
```
  - getNameLike
```
public String getNameLike()
```
  - getNameNotLike
```
public String getNameNotLike()
```
  - getAssignee
```
public String getAssignee()
```
  - getAssigneeLike
```
public String getAssigneeLike()
```
  - getAssigneeIn
```
public Set<String> getAssigneeIn()
```
  - getAssigneeNotIn
```
public Set<String> getAssigneeNotIn()
```
  - getInvolvedUser
```
public String getInvolvedUser()
```
  - getOwner
```
public String getOwner()
```
  - isAssigned
```
public Boolean isAssigned()
```
  - isAssignedInternal
```
public Boolean isAssignedInternal()
```
  - isUnassigned
```
public boolean isUnassigned()
```
  - isUnassignedInternal
```
public Boolean isUnassignedInternal()
```
  - getDelegationState
```
public DelegationState getDelegationState()
```
  - isNoDelegationState
```
public boolean isNoDelegationState()
```
  - getDelegationStateString
```
public String getDelegationStateString()
```
  - getCandidateUser
```
public String getCandidateUser()
```
  - getCandidateGroup
```
public String getCandidateGroup()
```
  - isIncludeAssignedTasks
```
public boolean isIncludeAssignedTasks()
```
  - isIncludeAssignedTasksInternal
```
public Boolean isIncludeAssignedTasksInternal()
```
  - getProcessInstanceId
```
public String getProcessInstanceId()
```
  - getProcessInstanceIdIn
```
public String[] getProcessInstanceIdIn()
```
  - getExecutionId
```
public String getExecutionId()
```
  - getActivityInstanceIdIn
```
public String[] getActivityInstanceIdIn()
```
  - getTenantIds
```
public String[] getTenantIds()
```
  - getTaskId
```
public String getTaskId()
```
  - getDescription
```
public String getDescription()
```
  - getDescriptionLike
```
public String getDescriptionLike()
```
  - getPriority
```
public Integer getPriority()
```
  - getMinPriority
```
public Integer getMinPriority()
```
  - getMaxPriority
```
public Integer getMaxPriority()
```
  - getCreateTime
```
public Date getCreateTime()
```
  - getCreateTimeBefore
```
public Date getCreateTimeBefore()
```
  - getCreateTimeAfter
```
public Date getCreateTimeAfter()
```
  - getKey
```
public String getKey()
```
  - getKeys
```
public String[] getKeys()
```
  - getKeyLike
```
public String getKeyLike()
```
  - getParentTaskId
```
public String getParentTaskId()
```
  - getVariables
```
public List<TaskQueryVariableValue> getVariables()
```
  - getProcessDefinitionKey
```
public String getProcessDefinitionKey()
```
  - getProcessDefinitionKeys
```
public String[] getProcessDefinitionKeys()
```
  - getProcessDefinitionId
```
public String getProcessDefinitionId()
```
  - getProcessDefinitionName
```
public String getProcessDefinitionName()
```
  - getProcessDefinitionNameLike
```
public String getProcessDefinitionNameLike()
```
  - getProcessInstanceBusinessKey
```
public String getProcessInstanceBusinessKey()
```
  - getProcessInstanceBusinessKeys
```
public String[] getProcessInstanceBusinessKeys()
```
  - getProcessInstanceBusinessKeyLike
```
public String getProcessInstanceBusinessKeyLike()
```
  - getDueDate
```
public Date getDueDate()
```
  - getDueBefore
```
public Date getDueBefore()
```
  - getDueAfter
```
public Date getDueAfter()
```
  - getFollowUpDate
```
public Date getFollowUpDate()
```
  - getFollowUpBefore
```
public Date getFollowUpBefore()
```
  - getFollowUpAfter
```
public Date getFollowUpAfter()
```
  - isExcludeSubtasks
```
public boolean isExcludeSubtasks()
```
  - getSuspensionState
```
public SuspensionState getSuspensionState()
```
  - getCaseInstanceId
```
public String getCaseInstanceId()
```
  - getCaseInstanceBusinessKey
```
public String getCaseInstanceBusinessKey()
```
  - getCaseInstanceBusinessKeyLike
```
public String getCaseInstanceBusinessKeyLike()
```
  - getCaseExecutionId
```
public String getCaseExecutionId()
```
  - getCaseDefinitionId
```
public String getCaseDefinitionId()
```
  - getCaseDefinitionKey
```
public String getCaseDefinitionKey()
```
  - getCaseDefinitionName
```
public String getCaseDefinitionName()
```
  - getCaseDefinitionNameLike
```
public String getCaseDefinitionNameLike()
```
  - isInitializeFormKeys
```
public boolean isInitializeFormKeys()
```
  - isTaskNameCaseInsensitive
```
public boolean isTaskNameCaseInsensitive()
```
  - isWithoutTenantId
```
public boolean isWithoutTenantId()
```
  - getTaskDefinitionKeys
```
public String[] getTaskDefinitionKeys()
```
  - getIsTenantIdSet
```
public boolean getIsTenantIdSet()
```
  - isVariableNamesIgnoreCase
```
public Boolean isVariableNamesIgnoreCase()
```
  - isVariableValuesIgnoreCase
```
public Boolean isVariableValuesIgnoreCase()
```
  - getQueries
```
public List<TaskQueryImpl> getQueries()
```
  - isOrQueryActive
```
public boolean isOrQueryActive()
```
  - addOrQuery
```
public void addOrQuery(TaskQueryImpl orQuery)
```
  - setOrQueryActive
```
public void setOrQueryActive()
```
  - extend
```
public TaskQuery extend(TaskQuery extending)
```
    Overrides:
    
    extend in class AbstractQuery<TaskQuery,Task>
  - mergeVariables
```
protected void mergeVariables(TaskQueryImpl extendedQuery,
                              TaskQueryImpl extendingQuery)
```
    Simple implementation of variable merging. Variables are only overridden if they have the same name and are in the same scope (ie are process instance, task or case execution variables).
  - isFollowUpNullAccepted
```
public boolean isFollowUpNullAccepted()
```
  - taskNameNotEqual
```
public TaskQuery taskNameNotEqual(String name)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with a name not matching the given name/ The query will match the names of tasks in a case-insensitive way.
    
    Specified by:
    
    taskNameNotEqual in interface TaskQuery
  - taskNameNotLike
```
public TaskQuery taskNameNotLike(String nameNotLike)
```
    Description copied from interface: TaskQuery
    
    Only select tasks with a name not matching the parameter. The syntax is that of SQL: for example usage: nameNotLike(%camunda%) The query will match the names of tasks in a case-insensitive way.
    
    Specified by:
    
    taskNameNotLike in interface TaskQuery
  - isQueryForProcessTasksOnly
```
public boolean isQueryForProcessTasksOnly()
```
    Returns:
    
    true if the query is not supposed to find CMMN or standalone tasks
  - or
```
public TaskQuery or()
```
    Description copied from interface: TaskQuery
    
    After calling or(), a chain of several filter criteria could follow. Each filter criterion that follows or() will be linked together with an OR expression until the OR query is terminated. To terminate the OR query right after the last filter criterion was applied, TaskQuery.endOr() must be invoked.
    
    Specified by:
    
    or in interface TaskQuery
    
    Returns:
    
    an object of the type TaskQuery on which an arbitrary amount of filter criteria could be applied. The several filter criteria will be linked together by an OR expression.
  - endOr
```
public TaskQuery endOr()
```
    Description copied from interface: TaskQuery
    
    endOr() terminates an OR query on which an arbitrary amount of filter criteria were applied. To terminate the OR query which has been started by invoking TaskQuery.or(), endOr() must be invoked. Filter criteria which are applied after calling endOr() are linked together by an AND expression.
    
    Specified by:
    
    endOr in interface TaskQuery
    
    Returns:
    
    an object of the type TaskQuery on which an arbitrary amount of filter criteria could be applied. The filter criteria will be linked together by an AND expression.
  - matchVariableNamesIgnoreCase
```
public TaskQuery matchVariableNamesIgnoreCase()
```
    Description copied from interface: TaskQuery
    
    All queries for task-, process- and case-variables will match the variable names in a case-insensitive way.
    
    Specified by:
    
    matchVariableNamesIgnoreCase in interface TaskQuery
  - matchVariableValuesIgnoreCase
```
public TaskQuery matchVariableValuesIgnoreCase()
```
    Description copied from interface: TaskQuery
    
    All queries for task-, process- and case-variables will match the variable values in a case-insensitive way.
    
    Specified by:
    
    matchVariableValuesIgnoreCase in interface TaskQuery

Class TaskQueryImpl

Nested Class Summary

Nested classes/interfaces inherited from class org.camunda.bpm.engine.impl.AbstractQuery

Field Summary

Fields inherited from class org.camunda.bpm.engine.impl.AbstractQuery

Fields inherited from class org.camunda.bpm.engine.impl.db.ListQueryParameterObject

Constructor Summary

Method Summary

Methods inherited from class org.camunda.bpm.engine.impl.AbstractQuery

Methods inherited from class org.camunda.bpm.engine.impl.db.ListQueryParameterObject

Methods inherited from class java.lang.Object

Methods inherited from interface org.camunda.bpm.engine.query.Query

Methods inherited from interface org.camunda.bpm.engine.impl.interceptor.Command

Field Detail

taskId

name

nameNotEqual

nameLike

nameNotLike

description

descriptionLike

priority

minPriority

maxPriority

assignee

assigneeLike

assigneeIn

assigneeNotIn

involvedUser

owner

unassigned

assigned

noDelegationState

delegationState

candidateUser

candidateGroup

candidateGroups

withCandidateGroups

withoutCandidateGroups

withCandidateUsers

withoutCandidateUsers

includeAssignedTasks

processInstanceId

processInstanceIdIn

executionId

activityInstanceIdIn

createTime

createTimeBefore

createTimeAfter

key

keyLike

taskDefinitionKeys

processDefinitionKey

processDefinitionKeys

processDefinitionId

processDefinitionName

processDefinitionNameLike

processInstanceBusinessKey

processInstanceBusinessKeys

processInstanceBusinessKeyLike

variables

dueDate

dueBefore

dueAfter

followUpDate

followUpBefore

followUpNullAccepted

followUpAfter

excludeSubtasks

suspensionState

initializeFormKeys

taskNameCaseInsensitive

variableNamesIgnoreCase

variableValuesIgnoreCase

parentTaskId

isWithoutTenantId

tenantIds

caseDefinitionKey

caseDefinitionId

caseDefinitionName