OBinaryCondition (OrientDB 3.0.44 API)

java.lang.Object
- com.orientechnologies.orient.core.sql.parser.SimpleNode
- - com.orientechnologies.orient.core.sql.parser.OBooleanExpression
  - - com.orientechnologies.orient.core.sql.parser.OBinaryCondition

All Implemented Interfaces:: Node

public class OBinaryCondition
extends OBooleanExpression

Field Summary

Fields
Modifier and Type Field and Description

protected OExpression left

protected OBinaryCompareOperator operator

protected OExpression right
- Fields inherited from class com.orientechnologies.orient.core.sql.parser.OBooleanExpression
  FALSE, TRUE
- Fields inherited from class com.orientechnologies.orient.core.sql.parser.SimpleNode
  children, firstToken, id, lastToken, parent, parser, value

Fields
Modifier and Type	Field and Description
`protected OExpression`	`left`
`protected OBinaryCompareOperator`	`operator`
`protected OExpression`	`right`

Constructor Summary

Constructors
Constructor and Description

OBinaryCondition(int id)

OBinaryCondition(OrientSql p, int id)

Constructors
Constructor and Description
`OBinaryCondition(int id)`
`OBinaryCondition(OrientSql p, int id)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`allowsIndexedFunctionExecutionOnTarget(OFromClause target, OCommandContext context)` tests if current expression involves an indexed function AND that function can be used on this target
`boolean`	`canExecuteIndexedFunctionWithoutIndex(OFromClause target, OCommandContext context)` tests if current expression involves an indexed funciton AND that function can also be executed without using the index
`OBinaryCondition`	`copy()`
`void`	`deserialize(OResult fromResult)`
`boolean`	`equals(Object o)`
`long`	`estimateIndexed(OFromClause target, OCommandContext context)`
`boolean`	`evaluate(OIdentifiable currentRecord, OCommandContext ctx)`
`boolean`	`evaluate(OResult currentRecord, OCommandContext ctx)`
`Iterable<OIdentifiable>`	`executeIndexedFunction(OFromClause target, OCommandContext context)`
`boolean`	`executeIndexedFunctionAfterIndexSearch(OFromClause target, OCommandContext context)` tests if current expression involves an indexed function AND the function has also to be executed after the index search.
`void`	`extractSubQueries(SubQueryCollector collector)`
`protected List<Object>`	`getExternalCalculationConditions()`
`List<OBinaryCondition>`	`getIndexedFunctionConditions(OClass iSchemaClass, ODatabaseDocumentInternal database)`
`OExpression`	`getLeft()`
`List<String>`	`getMatchPatternInvolvedAliases()`
`protected int`	`getNumberOfExternalCalculations()`
`OBinaryCompareOperator`	`getOperator()`
`OExpression`	`getRight()`
`int`	`hashCode()`
`boolean`	`isCacheable()`
`OBinaryCondition`	`isIndexedFunctionCondition(OClass iSchemaClass, ODatabaseDocumentInternal database)`
`Object`	`jjtAccept(OrientSqlVisitor visitor, Object data)` Accept the visitor.
`boolean`	`needsAliases(Set<String> aliases)`
`boolean`	`refersToParent()`
`OBooleanExpression`	`rewriteIndexChainsAsSubqueries(OCommandContext ctx, OClass clazz)`
`OResult`	`serialize()`
`void`	`setLeft(OExpression left)`
`void`	`setOperator(OBinaryCompareOperator operator)`
`void`	`setRight(OExpression right)`
`protected boolean`	`supportsBasicCalculation()`
`void`	`toString(Map<Object,Object> params, StringBuilder builder)`
`Optional<OUpdateItem>`	`transformToUpdateItem()` returns the equivalent of current condition as an UPDATE expression with the same syntax, if possible.
`void`	`translateLuceneOperator()`

Methods inherited from class com.orientechnologies.orient.core.sql.parser.OBooleanExpression
deserializeFromOResult, encapsulateInAndBlock, flatten, isEmpty

Methods inherited from class com.orientechnologies.orient.core.sql.parser.SimpleNode
childrenAccept, dump, getDatabase, getValue, jjtAddChild, jjtClose, jjtGetChild, jjtGetFirstToken, jjtGetLastToken, jjtGetNumChildren, jjtGetParent, jjtGetValue, jjtOpen, jjtSetFirstToken, jjtSetLastToken, jjtSetParent, jjtSetValue, toString, toString

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

- Field Detail
  - left
```
protected OExpression left
```
  - operator
```
protected OBinaryCompareOperator operator
```
  - right
```
protected OExpression right
```
- Constructor Detail
  - OBinaryCondition
```
public OBinaryCondition(int id)
```
  - OBinaryCondition
```
public OBinaryCondition(OrientSql p,
                        int id)
```
- Method Detail
  - jjtAccept
```
public Object jjtAccept(OrientSqlVisitor visitor,
                        Object data)
```
    Accept the visitor.
    
    Specified by:
    
    jjtAccept in interface Node
    
    Overrides:
    
    jjtAccept in class OBooleanExpression
  - evaluate
```
public boolean evaluate(OIdentifiable currentRecord,
                        OCommandContext ctx)
```
    Specified by:
    
    evaluate in class OBooleanExpression
  - evaluate
```
public boolean evaluate(OResult currentRecord,
                        OCommandContext ctx)
```
    Specified by:
    
    evaluate in class OBooleanExpression
  - toString
```
public void toString(Map<Object,Object> params,
                     StringBuilder builder)
```
    Overrides:
    
    toString in class SimpleNode
  - supportsBasicCalculation
```
protected boolean supportsBasicCalculation()
```
    Specified by:
    
    supportsBasicCalculation in class OBooleanExpression
    
    Returns:
    
    true if this expression can be calculated in plain Java, false otherwise (eg. LUCENE operator)
  - getNumberOfExternalCalculations
```
protected int getNumberOfExternalCalculations()
```
    Specified by:
    
    getNumberOfExternalCalculations in class OBooleanExpression
    
    Returns:
    
    the number of sub-expressions that have to be calculated using an external engine (eg. LUCENE)
  - getExternalCalculationConditions
```
protected List<Object> getExternalCalculationConditions()
```
    Specified by:
    
    getExternalCalculationConditions in class OBooleanExpression
    
    Returns:
    
    the sub-expressions that have to be calculated using an external engine (eg. LUCENE)
  - isIndexedFunctionCondition
```
public OBinaryCondition isIndexedFunctionCondition(OClass iSchemaClass,
                                                   ODatabaseDocumentInternal database)
```
  - estimateIndexed
```
public long estimateIndexed(OFromClause target,
                            OCommandContext context)
```
  - executeIndexedFunction
```
public Iterable<OIdentifiable> executeIndexedFunction(OFromClause target,
                                                      OCommandContext context)
```
  - canExecuteIndexedFunctionWithoutIndex
```
public boolean canExecuteIndexedFunctionWithoutIndex(OFromClause target,
                                                     OCommandContext context)
```
    tests if current expression involves an indexed funciton AND that function can also be executed without using the index
    
    Parameters:
    
    target - the query target
    
    context - the execution context
    
    Returns:
    
    true if current expression involves an indexed function AND that function can be used on this target, false otherwise
  - allowsIndexedFunctionExecutionOnTarget
```
public boolean allowsIndexedFunctionExecutionOnTarget(OFromClause target,
                                                      OCommandContext context)
```
    tests if current expression involves an indexed function AND that function can be used on this target
    
    Parameters:
    
    target - the query target
    
    context - the execution context
    
    Returns:
    
    true if current expression involves an indexed function AND that function can be used on this target, false otherwise
  - executeIndexedFunctionAfterIndexSearch
```
public boolean executeIndexedFunctionAfterIndexSearch(OFromClause target,
                                                      OCommandContext context)
```
    tests if current expression involves an indexed function AND the function has also to be executed after the index search. In some cases, the index search is accurate, so this condition can be excluded from further evaluation. In other cases the result from the index is a superset of the expected result, so the function has to be executed anyway for further filtering
    
    Parameters:
    
    target - the query target
    
    context - the execution context
    
    Returns:
    
    true if current expression involves an indexed function AND the function has also to be executed after the index search.
  - getIndexedFunctionConditions
```
public List<OBinaryCondition> getIndexedFunctionConditions(OClass iSchemaClass,
                                                           ODatabaseDocumentInternal database)
```
    Overrides:
    
    getIndexedFunctionConditions in class OBooleanExpression
  - needsAliases
```
public boolean needsAliases(Set<String> aliases)
```
    Specified by:
    
    needsAliases in class OBooleanExpression
  - copy
```
public OBinaryCondition copy()
```
    Specified by:
    
    copy in class OBooleanExpression
  - extractSubQueries
```
public void extractSubQueries(SubQueryCollector collector)
```
    Specified by:
    
    extractSubQueries in class OBooleanExpression
  - refersToParent
```
public boolean refersToParent()
```
    Specified by:
    
    refersToParent in class OBooleanExpression
  - transformToUpdateItem
```
public Optional<OUpdateItem> transformToUpdateItem()
```
    Description copied from class: OBooleanExpression
    
    returns the equivalent of current condition as an UPDATE expression with the same syntax, if possible.
    Eg. name = 3 can be considered a condition or an assignment. This method transforms the condition in an assignment. This is used mainly for UPSERT operations.
    
    Overrides:
    
    transformToUpdateItem in class OBooleanExpression
    
    Returns:
    
    the equivalent of current condition as an UPDATE expression with the same syntax, if possible.
  - getLeft
```
public OExpression getLeft()
```
  - getOperator
```
public OBinaryCompareOperator getOperator()
```
  - getRight
```
public OExpression getRight()
```
  - setLeft
```
public void setLeft(OExpression left)
```
  - setOperator
```
public void setOperator(OBinaryCompareOperator operator)
```
  - setRight
```
public void setRight(OExpression right)
```
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - getMatchPatternInvolvedAliases
```
public List<String> getMatchPatternInvolvedAliases()
```
    Specified by:
    
    getMatchPatternInvolvedAliases in class OBooleanExpression
  - translateLuceneOperator
```
public void translateLuceneOperator()
```
    Overrides:
    
    translateLuceneOperator in class OBooleanExpression
  - serialize
```
public OResult serialize()
```
    Overrides:
    
    serialize in class OBooleanExpression
  - deserialize
```
public void deserialize(OResult fromResult)
```
    Overrides:
    
    deserialize in class OBooleanExpression
  - isCacheable
```
public boolean isCacheable()
```
    Specified by:
    
    isCacheable in class OBooleanExpression
  - rewriteIndexChainsAsSubqueries
```
public OBooleanExpression rewriteIndexChainsAsSubqueries(OCommandContext ctx,
                                                         OClass clazz)
```
    Overrides:
    
    rewriteIndexChainsAsSubqueries in class OBooleanExpression

Class OBinaryCondition

Field Summary

Fields inherited from class com.orientechnologies.orient.core.sql.parser.OBooleanExpression

Fields inherited from class com.orientechnologies.orient.core.sql.parser.SimpleNode

Constructor Summary

Method Summary

Methods inherited from class com.orientechnologies.orient.core.sql.parser.OBooleanExpression

Methods inherited from class com.orientechnologies.orient.core.sql.parser.SimpleNode

Methods inherited from class java.lang.Object

Field Detail

left

operator

right

Constructor Detail

OBinaryCondition

OBinaryCondition

Method Detail

jjtAccept

evaluate

evaluate

toString

supportsBasicCalculation

getNumberOfExternalCalculations

getExternalCalculationConditions

isIndexedFunctionCondition

estimateIndexed

executeIndexedFunction

canExecuteIndexedFunctionWithoutIndex

allowsIndexedFunctionExecutionOnTarget

executeIndexedFunctionAfterIndexSearch

getIndexedFunctionConditions

needsAliases

copy

extractSubQueries

refersToParent

transformToUpdateItem

getLeft

getOperator

getRight

setLeft

setOperator

setRight

equals

hashCode

getMatchPatternInvolvedAliases

translateLuceneOperator

serialize

deserialize

isCacheable

rewriteIndexChainsAsSubqueries