BinaryPredicateBuilder (Blazebit Persistence Core API 1.0.6 API)

Type Parameters:
T - The builder type that is returned on terminal operations

All Known Subinterfaces:

LikeBuilder<T>, QuantifiableBinaryPredicateBuilder<T>
```
public interface BinaryPredicateBuilder<T>
```
The interface for binary predicate builders. The left hand side and the operator are already known to the builder and the methods of this builder terminate the building process.

Since:

1.0

Author:

Christian Beikov, Moritz Becker

Method Summary

Methods
Modifier and Type	Method and Description
`RestrictionBuilder<CaseWhenThenBuilder<CaseWhenBuilder<T>>>`	`caseWhen(String expression)` Starts a `RestrictionBuilder` to create a when expression with a single predicate in which `expression` will be on the left hand side of the predicate.
`CaseWhenAndThenBuilder<CaseWhenBuilder<T>>`	`caseWhenAnd()` Starts a `CaseWhenAndThenBuilder` for building a when expression with conjunctively connected predicates.
`SubqueryInitiator<CaseWhenThenBuilder<CaseWhenBuilder<T>>>`	`caseWhenExists()` Starts a `SubqueryInitiator` to create a when expression with a single exists predicate.
`SubqueryInitiator<CaseWhenThenBuilder<CaseWhenBuilder<T>>>`	`caseWhenNotExists()` Starts a `SubqueryInitiator` to create a when expression with a single negated exists predicate.
`CaseWhenOrThenBuilder<CaseWhenBuilder<T>>`	`caseWhenOr()` Starts a `CaseWhenOrThenBuilder` for building a when expression with disjunctively connected predicates.
`SubqueryInitiator<RestrictionBuilder<CaseWhenThenBuilder<CaseWhenBuilder<T>>>>`	`caseWhenSubquery()` Starts a `SubqueryInitiator` to create a when expression with a single predicate in which the left hand side will be a subquery.
`SubqueryInitiator<RestrictionBuilder<CaseWhenThenBuilder<CaseWhenBuilder<T>>>>`	`caseWhenSubquery(String subqueryAlias, String expression)` Starts a `SubqueryInitiator` to create a when expression with a single predicate in which the left hand side will be a subquery.
`T`	`expression(String expression)` Uses the given expression as right hand side for the binary predicate.
`SimpleCaseWhenBuilder<T>`	`simpleCase(String caseOperand)` Starts a `SimpleCaseWhenBuilder` for building a simple case when expression.
`T`	`value(Object value)` Uses the given value as right hand side for the binary predicate.

- Method Detail
  - value
```
T value(Object value)
```
    Uses the given value as right hand side for the binary predicate. Finishes the binary predicate and adds it to the parent predicate container represented by the type T.
    
    Parameters:
    value - The value to use for the right hand side of the binary predicate
    
    Returns:
    The parent predicate container builder
  - expression
```
T expression(String expression)
```
    Uses the given expression as right hand side for the binary predicate. Finishes the binary predicate and adds it to the parent predicate container represented by the type T.
    
    Parameters:
    expression - The expression to use for the right hand side of the binary predicate
    
    Returns:
    The parent predicate container builder
  - caseWhen
```
RestrictionBuilder<CaseWhenThenBuilder<CaseWhenBuilder<T>>> caseWhen(String expression)
```
    Starts a RestrictionBuilder to create a when expression with a single predicate in which expression will be on the left hand side of the predicate.
    
    Parameters:
    expression - The left hand side expression for a when predicate
    
    Returns:
    The restriction builder for the given expression
    See Also:
    More details about this method
  - caseWhenSubquery
```
SubqueryInitiator<RestrictionBuilder<CaseWhenThenBuilder<CaseWhenBuilder<T>>>> caseWhenSubquery()
```
    Starts a SubqueryInitiator to create a when expression with a single predicate in which the left hand side will be a subquery.
    When the subquery builder and the restriction builder for the right hand side are finished, the when predicate in conjunction with its then expression are added to the case when builder.
    
    Returns:
    The subquery initiator for building a subquery
    See Also:
    More details about this method
  - caseWhenSubquery
```
SubqueryInitiator<RestrictionBuilder<CaseWhenThenBuilder<CaseWhenBuilder<T>>>> caseWhenSubquery(String subqueryAlias,
                                                                                              String expression)
```
    Starts a SubqueryInitiator to create a when expression with a single predicate in which the left hand side will be a subquery.
    When the subquery builder and the restriction builder for the right hand side are finished, the when predicate in conjunction with its then expression are added to the case when builder.
    
    Parameters:
    subqueryAlias - The alias for the subquery which will be replaced by the actual subquery
    expression - The expression which will be used as left hand side of a predicate. This expression contains the subqueryAlias to define the insertion points for the subquery.
    
    Returns:
    The subquery initiator for building a subquery
    See Also:
    More details about this method
  - caseWhenExists
```
SubqueryInitiator<CaseWhenThenBuilder<CaseWhenBuilder<T>>> caseWhenExists()
```
    Starts a SubqueryInitiator to create a when expression with a single exists predicate.
    When the builder finishes, the when predicate in conjunction with its then expression are added to the case when builder.
    
    Returns:
    The subquery initiator for building a subquery
    See Also:
    More details about this method
  - caseWhenNotExists
```
SubqueryInitiator<CaseWhenThenBuilder<CaseWhenBuilder<T>>> caseWhenNotExists()
```
    Starts a SubqueryInitiator to create a when expression with a single negated exists predicate.
    When the builder finishes, the when predicate in conjunction with its then expression are added to the case when builder.
    
    Returns:
    The subquery initiator for building a subquery
    See Also:
    More details about this method
  - caseWhenAnd
```
CaseWhenAndThenBuilder<CaseWhenBuilder<T>> caseWhenAnd()
```
    Starts a CaseWhenAndThenBuilder for building a when expression with conjunctively connected predicates.
    When the builder finishes, the when predicate in conjunction with its then expression are added to the case when builder.
    
    Returns:
    The and predicate builder for the when expression
    See Also:
    More details about this method
  - caseWhenOr
```
CaseWhenOrThenBuilder<CaseWhenBuilder<T>> caseWhenOr()
```
    Starts a CaseWhenOrThenBuilder for building a when expression with disjunctively connected predicates.
    When the builder finishes, the when predicate in conjunction with its then expression are added to the case when builder.
    
    Returns:
    The or predicate builder for the when expression
    See Also:
    More details about this method
  - simpleCase
```
SimpleCaseWhenBuilder<T> simpleCase(String caseOperand)
```
    Starts a SimpleCaseWhenBuilder for building a simple case when expression.
    When the builder finishes, the when predicate in conjunction with its then expression are added to the case when builder.
    
    Parameters:
    caseOperand - The case operand
    
    Returns:
    The or predicate builder for the when expression
    See Also:
    More details about this method

Interface BinaryPredicateBuilder<T>

Method Summary

Method Detail

value

expression

caseWhen

caseWhenSubquery

caseWhenSubquery

caseWhenExists

caseWhenNotExists

caseWhenAnd

caseWhenOr

simpleCase