Package com.arcadedb.query.sql.parser

Class BaseIdentifier

java.lang.Object

com.arcadedb.query.sql.parser.SimpleNode

com.arcadedb.query.sql.parser.BaseIdentifier

All Implemented Interfaces:

Node

public class BaseIdentifier
extends SimpleNode

Field Summary

Fields

Modifier and Type	Field	Description
protected LevelZeroIdentifier	levelZero
protected SuffixIdentifier	suffix

Fields inherited from class com.arcadedb.query.sql.parser.SimpleNode

children, firstToken, id, lastToken, parent, parser, value

Constructor Summary

Constructors

Constructor	Description
BaseIdentifier(int id)
BaseIdentifier(Identifier identifier)
BaseIdentifier(RecordAttribute attr)
BaseIdentifier(SqlParser p, int id)

Method Summary

Modifier and Type	Method	Description
boolean	allowsIndexedFunctionExecutionOnTarget(FromClause target, CommandContext context, BinaryCompareOperator operator, Object right)	tests if current expression is an indexed function AND that function can be used on this target
void	applyRemove(ResultInternal result, CommandContext ctx)
boolean	canExecuteIndexedFunctionWithoutIndex(FromClause target, CommandContext context, BinaryCompareOperator operator, Object right)	tests if current expression is an indexed funciton AND that function can also be executed without using the index
BaseIdentifier	copy()
void	deserialize(Result fromResult)
boolean	equals(Object o)
long	estimateIndexedFunction(FromClause target, CommandContext context, BinaryCompareOperator operator, Object right)
Object	execute(Record iCurrentRecord, CommandContext ctx)
Object	execute(Result iCurrentRecord, CommandContext ctx)
Iterable<Record>	executeIndexedFunction(FromClause target, CommandContext context, BinaryCompareOperator operator, Object right)
boolean	executeIndexedFunctionAfterIndexSearch(FromClause target, CommandContext context, BinaryCompareOperator operator, Object right)	tests if current expression is an indexed function AND the function has also to be executed after the index search.
void	extractSubQueries(Identifier letAlias, SubQueryCollector collector)
void	extractSubQueries(SubQueryCollector collector)
AggregationContext	getAggregationContext(CommandContext ctx)
Expression	getExpandContent()
LevelZeroIdentifier	getLevelZero()
SuffixIdentifier	getSuffix()
int	hashCode()
boolean	isAggregate()
boolean	isBaseIdentifier()
boolean	isCacheable()
boolean	isCount()
boolean	isDefinedFor(Record currentRecord)
boolean	isDefinedFor(Result currentRecord)
boolean	isEarlyCalculated()
boolean	isExpand()
boolean	isIndexedFunctionCall()
boolean	needsAliases(Set<String> aliases)
boolean	refersToParent()
Result	serialize()
void	setLevelZero(LevelZeroIdentifier levelZero)
SimpleNode	splitForAggregation(AggregateProjectionSplit aggregateProj)
void	toString(Map<String,Object> params, StringBuilder builder)

Methods inherited from class com.arcadedb.query.sql.parser.SimpleNode

childrenAccept, dump, getValue, jjtAccept, 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

levelZero

protected LevelZeroIdentifier levelZero

suffix

protected SuffixIdentifier suffix

Constructor Detail

BaseIdentifier

public BaseIdentifier(int id)

BaseIdentifier

public BaseIdentifier(SqlParser p,
                      int id)

BaseIdentifier

public BaseIdentifier(Identifier identifier)

BaseIdentifier

public BaseIdentifier(RecordAttribute attr)

Method Detail

toString

public void toString(Map<String,Object> params,
                     StringBuilder builder)

Overrides:

toString in class SimpleNode

execute

public Object execute(Record iCurrentRecord,
                      CommandContext ctx)

execute

public Object execute(Result iCurrentRecord,
                      CommandContext ctx)

isIndexedFunctionCall

public boolean isIndexedFunctionCall()

estimateIndexedFunction

public long estimateIndexedFunction(FromClause target,
                                    CommandContext context,
                                    BinaryCompareOperator operator,
                                    Object right)

executeIndexedFunction

public Iterable<Record> executeIndexedFunction(FromClause target,
                                               CommandContext context,
                                               BinaryCompareOperator operator,
                                               Object right)

canExecuteIndexedFunctionWithoutIndex

public boolean canExecuteIndexedFunctionWithoutIndex(FromClause target,
                                                     CommandContext context,
                                                     BinaryCompareOperator operator,
                                                     Object right)

tests if current expression is an indexed funciton AND that function can also be executed without using the index

Parameters:

target - the query target

context - the execution context

operator -

right -

Returns:

true if current expression is an indexed funciton AND that function can also be executed without using the index, false otherwise

allowsIndexedFunctionExecutionOnTarget

public boolean allowsIndexedFunctionExecutionOnTarget(FromClause target,
                                                      CommandContext context,
                                                      BinaryCompareOperator operator,
                                                      Object right)

tests if current expression is an indexed function AND that function can be used on this target

Parameters:

target - the query target

context - the execution context

operator -

right -

Returns:

true if current expression involves an indexed function AND that function can be used on this target, false otherwise

executeIndexedFunctionAfterIndexSearch

public boolean executeIndexedFunctionAfterIndexSearch(FromClause target,
                                                      CommandContext context,
                                                      BinaryCompareOperator operator,
                                                      Object right)

tests if current expression is 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 is an indexed function AND the function has also to be executed after the index search.

isBaseIdentifier

public boolean isBaseIdentifier()

isExpand

public boolean isExpand()

getExpandContent

public Expression getExpandContent()

needsAliases

public boolean needsAliases(Set<String> aliases)

isAggregate

public boolean isAggregate()

isCount

public boolean isCount()

isEarlyCalculated

public boolean isEarlyCalculated()

splitForAggregation

public SimpleNode splitForAggregation(AggregateProjectionSplit aggregateProj)

getAggregationContext

public AggregationContext getAggregationContext(CommandContext ctx)

setLevelZero

public void setLevelZero(LevelZeroIdentifier levelZero)

copy

public BaseIdentifier copy()

Overrides:

copy in class SimpleNode

equals

public boolean equals(Object o)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

refersToParent

public boolean refersToParent()

getSuffix

public SuffixIdentifier getSuffix()

getLevelZero

public LevelZeroIdentifier getLevelZero()

applyRemove

public void applyRemove(ResultInternal result,
                        CommandContext ctx)

serialize

public Result serialize()

deserialize

public void deserialize(Result fromResult)

isDefinedFor

public boolean isDefinedFor(Result currentRecord)

isDefinedFor

public boolean isDefinedFor(Record currentRecord)

extractSubQueries

public void extractSubQueries(Identifier letAlias,
                              SubQueryCollector collector)

extractSubQueries

public void extractSubQueries(SubQueryCollector collector)

isCacheable

public boolean isCacheable()