org.apache.tajo.plan.algebra

Class BaseAlgebraVisitor<CONTEXT,RESULT>

java.lang.Object

org.apache.tajo.plan.algebra.BaseAlgebraVisitor<CONTEXT,RESULT>

All Implemented Interfaces:

AlgebraVisitor<CONTEXT,RESULT>

Direct Known Subclasses:

ExprAnnotator, LogicalPlanner, LogicalPlanPreprocessor, PreLogicalPlanVerifier, SimpleAlgebraVisitor

public class BaseAlgebraVisitor<CONTEXT,RESULT>
extends Object
implements AlgebraVisitor<CONTEXT,RESULT>

Constructor Summary

Constructors

Constructor and Description
BaseAlgebraVisitor()

Method Summary

Methods

Modifier and Type	Method and Description
RESULT	postHook(CONTEXT ctx, Stack<Expr> stack, Expr expr, RESULT current) The posthook is called before each expression is visited.
void	preHook(CONTEXT ctx, Stack<Expr> stack, Expr expr) The prehook is called before each expression is visited.
RESULT	visit(CONTEXT ctx, Stack<Expr> stack, Expr expr) visit visits each relational operator expression recursively.
RESULT	visitAlterTable(CONTEXT ctx, Stack<Expr> stack, AlterTable expr)
RESULT	visitAlterTablespace(CONTEXT ctx, Stack<Expr> stack, AlterTablespace expr)
RESULT	visitAnd(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	visitBetween(CONTEXT ctx, Stack<Expr> stack, BetweenPredicate expr)
RESULT	visitCaseWhen(CONTEXT ctx, Stack<Expr> stack, CaseWhenPredicate expr)
RESULT	visitCastExpr(CONTEXT ctx, Stack<Expr> stack, CastExpr expr)
RESULT	visitColumnReference(CONTEXT ctx, Stack<Expr> stack, ColumnReferenceExpr expr)
RESULT	visitConcatenate(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	visitCountRowsFunction(CONTEXT ctx, Stack<Expr> stack, CountRowsFunctionExpr expr)
RESULT	visitCreateDatabase(CONTEXT ctx, Stack<Expr> stack, CreateDatabase expr)
RESULT	visitCreateTable(CONTEXT ctx, Stack<Expr> stack, CreateTable expr)
RESULT	visitDataType(CONTEXT ctx, Stack<Expr> stack, DataTypeExpr expr)
RESULT	visitDateLiteral(CONTEXT ctx, Stack<Expr> stack, DateLiteral expr)
RESULT	visitDivide(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	visitDropDatabase(CONTEXT ctx, Stack<Expr> stack, DropDatabase expr)
RESULT	visitDropTable(CONTEXT ctx, Stack<Expr> stack, DropTable expr)
RESULT	visitEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	visitExcept(CONTEXT ctx, Stack<Expr> stack, SetOperation expr)
RESULT	visitExistsPredicate(CONTEXT ctx, Stack<Expr> stack, ExistsPredicate expr)
RESULT	visitExplain(CONTEXT ctx, Stack<Expr> stack, Explain expr)
RESULT	visitFilter(CONTEXT ctx, Stack<Expr> stack, Selection expr)
RESULT	visitFunction(CONTEXT ctx, Stack<Expr> stack, FunctionExpr expr)
RESULT	visitGeneralSetFunction(CONTEXT ctx, Stack<Expr> stack, GeneralSetFunctionExpr expr)
RESULT	visitGreaterThan(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	visitGreaterThanOrEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	visitGroupBy(CONTEXT ctx, Stack<Expr> stack, Aggregation expr)
RESULT	visitHaving(CONTEXT ctx, Stack<Expr> stack, Having expr)
RESULT	visitInPredicate(CONTEXT ctx, Stack<Expr> stack, InPredicate expr)
RESULT	visitInsert(CONTEXT ctx, Stack<Expr> stack, Insert expr)
RESULT	visitIntersect(CONTEXT ctx, Stack<Expr> stack, SetOperation expr)
RESULT	visitIntervalLiteral(CONTEXT ctx, Stack<Expr> stack, IntervalLiteral expr)
RESULT	visitIsNullPredicate(CONTEXT ctx, Stack<Expr> stack, IsNullPredicate expr)
RESULT	visitJoin(CONTEXT ctx, Stack<Expr> stack, Join expr)
RESULT	visitLessThan(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	visitLessThanOrEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	visitLikePredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr)
RESULT	visitLimit(CONTEXT ctx, Stack<Expr> stack, Limit expr)
RESULT	visitLiteral(CONTEXT ctx, Stack<Expr> stack, LiteralValue expr)
RESULT	visitMinus(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	visitModular(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	visitMultiply(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	visitNot(CONTEXT ctx, Stack<Expr> stack, NotExpr expr)
RESULT	visitNotEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	visitNullLiteral(CONTEXT ctx, Stack<Expr> stack, NullLiteral expr)
RESULT	visitOr(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	visitPlus(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	visitProjection(CONTEXT ctx, Stack<Expr> stack, Projection expr)
RESULT	visitQualifiedAsterisk(CONTEXT ctx, Stack<Expr> stack, QualifiedAsteriskExpr expr)
RESULT	visitRegexpPredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr)
RESULT	visitRelation(CONTEXT ctx, Stack<Expr> stack, Relation expr)
RESULT	visitRelationList(CONTEXT ctx, Stack<Expr> stack, RelationList expr)
RESULT	visitScalarSubQuery(CONTEXT ctx, Stack<Expr> stack, ScalarSubQuery expr)
RESULT	visitSetSession(CONTEXT ctx, Stack<Expr> stack, SetSession expr)
RESULT	visitSign(CONTEXT ctx, Stack<Expr> stack, SignedExpr expr)
RESULT	visitSimilarToPredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr)
RESULT	visitSimpleTableSubQuery(CONTEXT ctx, Stack<Expr> stack, SimpleTableSubQuery expr)
RESULT	visitSort(CONTEXT ctx, Stack<Expr> stack, Sort expr)
RESULT	visitTableSubQuery(CONTEXT ctx, Stack<Expr> stack, TablePrimarySubQuery expr)
RESULT	visitTargetExpr(CONTEXT ctx, Stack<Expr> stack, NamedExpr expr)
RESULT	visitTimeLiteral(CONTEXT ctx, Stack<Expr> stack, TimeLiteral expr)
RESULT	visitTimestampLiteral(CONTEXT ctx, Stack<Expr> stack, TimestampLiteral expr)
RESULT	visitTruncateTable(CONTEXT ctx, Stack<Expr> stack, TruncateTable expr)
RESULT	visitUnion(CONTEXT ctx, Stack<Expr> stack, SetOperation expr)
RESULT	visitValueListExpr(CONTEXT ctx, Stack<Expr> stack, ValueListExpr expr)
RESULT	visitWindowFunction(CONTEXT ctx, Stack<Expr> stack, WindowFunctionExpr expr)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

BaseAlgebraVisitor

public BaseAlgebraVisitor()

Method Detail

preHook

public void preHook(CONTEXT ctx,
           Stack<Expr> stack,
           Expr expr)
             throws PlanningException

The prehook is called before each expression is visited.

Throws:

PlanningException

postHook

public RESULT postHook(CONTEXT ctx,
              Stack<Expr> stack,
              Expr expr,
              RESULT current)
                throws PlanningException

The posthook is called before each expression is visited.

Throws:

PlanningException

visit

public RESULT visit(CONTEXT ctx,
           Stack<Expr> stack,
           Expr expr)
             throws PlanningException

visit visits each relational operator expression recursively.

Parameters:

stack - The stack contains the upper operators' type.

expr - The visiting relational operator

Throws:

PlanningException

visitSetSession

public RESULT visitSetSession(CONTEXT ctx,
                     Stack<Expr> stack,
                     SetSession expr)
                       throws PlanningException

Specified by:

visitSetSession in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitProjection

public RESULT visitProjection(CONTEXT ctx,
                     Stack<Expr> stack,
                     Projection expr)
                       throws PlanningException

Specified by:

visitProjection in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitLimit

public RESULT visitLimit(CONTEXT ctx,
                Stack<Expr> stack,
                Limit expr)
                  throws PlanningException

Specified by:

visitLimit in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitSort

public RESULT visitSort(CONTEXT ctx,
               Stack<Expr> stack,
               Sort expr)
                 throws PlanningException

Specified by:

visitSort in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitHaving

public RESULT visitHaving(CONTEXT ctx,
                 Stack<Expr> stack,
                 Having expr)
                   throws PlanningException

Specified by:

visitHaving in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitGroupBy

public RESULT visitGroupBy(CONTEXT ctx,
                  Stack<Expr> stack,
                  Aggregation expr)
                    throws PlanningException

Specified by:

visitGroupBy in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitJoin

public RESULT visitJoin(CONTEXT ctx,
               Stack<Expr> stack,
               Join expr)
                 throws PlanningException

Specified by:

visitJoin in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitFilter

public RESULT visitFilter(CONTEXT ctx,
                 Stack<Expr> stack,
                 Selection expr)
                   throws PlanningException

Specified by:

visitFilter in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitUnion

public RESULT visitUnion(CONTEXT ctx,
                Stack<Expr> stack,
                SetOperation expr)
                  throws PlanningException

Specified by:

visitUnion in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitExcept

public RESULT visitExcept(CONTEXT ctx,
                 Stack<Expr> stack,
                 SetOperation expr)
                   throws PlanningException

Specified by:

visitExcept in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitIntersect

public RESULT visitIntersect(CONTEXT ctx,
                    Stack<Expr> stack,
                    SetOperation expr)
                      throws PlanningException

Specified by:

visitIntersect in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitSimpleTableSubQuery

public RESULT visitSimpleTableSubQuery(CONTEXT ctx,
                              Stack<Expr> stack,
                              SimpleTableSubQuery expr)
                                throws PlanningException

Specified by:

visitSimpleTableSubQuery in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitTableSubQuery

public RESULT visitTableSubQuery(CONTEXT ctx,
                        Stack<Expr> stack,
                        TablePrimarySubQuery expr)
                          throws PlanningException

Specified by:

visitTableSubQuery in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitRelationList

public RESULT visitRelationList(CONTEXT ctx,
                       Stack<Expr> stack,
                       RelationList expr)
                         throws PlanningException

Specified by:

visitRelationList in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitRelation

public RESULT visitRelation(CONTEXT ctx,
                   Stack<Expr> stack,
                   Relation expr)
                     throws PlanningException

Specified by:

visitRelation in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitScalarSubQuery

public RESULT visitScalarSubQuery(CONTEXT ctx,
                         Stack<Expr> stack,
                         ScalarSubQuery expr)
                           throws PlanningException

Specified by:

visitScalarSubQuery in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitExplain

public RESULT visitExplain(CONTEXT ctx,
                  Stack<Expr> stack,
                  Explain expr)
                    throws PlanningException

Specified by:

visitExplain in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitCreateDatabase

public RESULT visitCreateDatabase(CONTEXT ctx,
                         Stack<Expr> stack,
                         CreateDatabase expr)
                           throws PlanningException

Specified by:

visitCreateDatabase in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitDropDatabase

public RESULT visitDropDatabase(CONTEXT ctx,
                       Stack<Expr> stack,
                       DropDatabase expr)
                         throws PlanningException

Specified by:

visitDropDatabase in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitCreateTable

public RESULT visitCreateTable(CONTEXT ctx,
                      Stack<Expr> stack,
                      CreateTable expr)
                        throws PlanningException

Specified by:

visitCreateTable in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitDropTable

public RESULT visitDropTable(CONTEXT ctx,
                    Stack<Expr> stack,
                    DropTable expr)
                      throws PlanningException

Specified by:

visitDropTable in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitAlterTablespace

public RESULT visitAlterTablespace(CONTEXT ctx,
                          Stack<Expr> stack,
                          AlterTablespace expr)
                            throws PlanningException

Specified by:

visitAlterTablespace in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitAlterTable

public RESULT visitAlterTable(CONTEXT ctx,
                     Stack<Expr> stack,
                     AlterTable expr)
                       throws PlanningException

Specified by:

visitAlterTable in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitTruncateTable

public RESULT visitTruncateTable(CONTEXT ctx,
                        Stack<Expr> stack,
                        TruncateTable expr)
                          throws PlanningException

Specified by:

visitTruncateTable in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitInsert

public RESULT visitInsert(CONTEXT ctx,
                 Stack<Expr> stack,
                 Insert expr)
                   throws PlanningException

Specified by:

visitInsert in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitAnd

public RESULT visitAnd(CONTEXT ctx,
              Stack<Expr> stack,
              BinaryOperator expr)
                throws PlanningException

Specified by:

visitAnd in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitOr

public RESULT visitOr(CONTEXT ctx,
             Stack<Expr> stack,
             BinaryOperator expr)
               throws PlanningException

Specified by:

visitOr in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitNot

public RESULT visitNot(CONTEXT ctx,
              Stack<Expr> stack,
              NotExpr expr)
                throws PlanningException

Specified by:

visitNot in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitEquals

public RESULT visitEquals(CONTEXT ctx,
                 Stack<Expr> stack,
                 BinaryOperator expr)
                   throws PlanningException

Specified by:

visitEquals in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitNotEquals

public RESULT visitNotEquals(CONTEXT ctx,
                    Stack<Expr> stack,
                    BinaryOperator expr)
                      throws PlanningException

Specified by:

visitNotEquals in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitLessThan

public RESULT visitLessThan(CONTEXT ctx,
                   Stack<Expr> stack,
                   BinaryOperator expr)
                     throws PlanningException

Specified by:

visitLessThan in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitLessThanOrEquals

public RESULT visitLessThanOrEquals(CONTEXT ctx,
                           Stack<Expr> stack,
                           BinaryOperator expr)
                             throws PlanningException

Specified by:

visitLessThanOrEquals in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitGreaterThan

public RESULT visitGreaterThan(CONTEXT ctx,
                      Stack<Expr> stack,
                      BinaryOperator expr)
                        throws PlanningException

Specified by:

visitGreaterThan in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitGreaterThanOrEquals

public RESULT visitGreaterThanOrEquals(CONTEXT ctx,
                              Stack<Expr> stack,
                              BinaryOperator expr)
                                throws PlanningException

Specified by:

visitGreaterThanOrEquals in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitBetween

public RESULT visitBetween(CONTEXT ctx,
                  Stack<Expr> stack,
                  BetweenPredicate expr)
                    throws PlanningException

Specified by:

visitBetween in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitCaseWhen

public RESULT visitCaseWhen(CONTEXT ctx,
                   Stack<Expr> stack,
                   CaseWhenPredicate expr)
                     throws PlanningException

Specified by:

visitCaseWhen in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitIsNullPredicate

public RESULT visitIsNullPredicate(CONTEXT ctx,
                          Stack<Expr> stack,
                          IsNullPredicate expr)
                            throws PlanningException

Specified by:

visitIsNullPredicate in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitInPredicate

public RESULT visitInPredicate(CONTEXT ctx,
                      Stack<Expr> stack,
                      InPredicate expr)
                        throws PlanningException

Specified by:

visitInPredicate in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitValueListExpr

public RESULT visitValueListExpr(CONTEXT ctx,
                        Stack<Expr> stack,
                        ValueListExpr expr)
                          throws PlanningException

Specified by:

visitValueListExpr in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitExistsPredicate

public RESULT visitExistsPredicate(CONTEXT ctx,
                          Stack<Expr> stack,
                          ExistsPredicate expr)
                            throws PlanningException

Specified by:

visitExistsPredicate in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitLikePredicate

public RESULT visitLikePredicate(CONTEXT ctx,
                        Stack<Expr> stack,
                        PatternMatchPredicate expr)
                          throws PlanningException

Specified by:

visitLikePredicate in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitSimilarToPredicate

public RESULT visitSimilarToPredicate(CONTEXT ctx,
                             Stack<Expr> stack,
                             PatternMatchPredicate expr)
                               throws PlanningException

Specified by:

visitSimilarToPredicate in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitRegexpPredicate

public RESULT visitRegexpPredicate(CONTEXT ctx,
                          Stack<Expr> stack,
                          PatternMatchPredicate expr)
                            throws PlanningException

Specified by:

visitRegexpPredicate in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitConcatenate

public RESULT visitConcatenate(CONTEXT ctx,
                      Stack<Expr> stack,
                      BinaryOperator expr)
                        throws PlanningException

Specified by:

visitConcatenate in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitPlus

public RESULT visitPlus(CONTEXT ctx,
               Stack<Expr> stack,
               BinaryOperator expr)
                 throws PlanningException

Specified by:

visitPlus in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitMinus

public RESULT visitMinus(CONTEXT ctx,
                Stack<Expr> stack,
                BinaryOperator expr)
                  throws PlanningException

Specified by:

visitMinus in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitMultiply

public RESULT visitMultiply(CONTEXT ctx,
                   Stack<Expr> stack,
                   BinaryOperator expr)
                     throws PlanningException

Specified by:

visitMultiply in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitDivide

public RESULT visitDivide(CONTEXT ctx,
                 Stack<Expr> stack,
                 BinaryOperator expr)
                   throws PlanningException

Specified by:

visitDivide in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitModular

public RESULT visitModular(CONTEXT ctx,
                  Stack<Expr> stack,
                  BinaryOperator expr)
                    throws PlanningException

Specified by:

visitModular in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitSign

public RESULT visitSign(CONTEXT ctx,
               Stack<Expr> stack,
               SignedExpr expr)
                 throws PlanningException

Specified by:

visitSign in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitColumnReference

public RESULT visitColumnReference(CONTEXT ctx,
                          Stack<Expr> stack,
                          ColumnReferenceExpr expr)
                            throws PlanningException

Specified by:

visitColumnReference in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitTargetExpr

public RESULT visitTargetExpr(CONTEXT ctx,
                     Stack<Expr> stack,
                     NamedExpr expr)
                       throws PlanningException

Specified by:

visitTargetExpr in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitFunction

public RESULT visitFunction(CONTEXT ctx,
                   Stack<Expr> stack,
                   FunctionExpr expr)
                     throws PlanningException

Specified by:

visitFunction in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitQualifiedAsterisk

public RESULT visitQualifiedAsterisk(CONTEXT ctx,
                            Stack<Expr> stack,
                            QualifiedAsteriskExpr expr)
                              throws PlanningException

Specified by:

visitQualifiedAsterisk in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitCountRowsFunction

public RESULT visitCountRowsFunction(CONTEXT ctx,
                            Stack<Expr> stack,
                            CountRowsFunctionExpr expr)
                              throws PlanningException

Specified by:

visitCountRowsFunction in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitGeneralSetFunction

public RESULT visitGeneralSetFunction(CONTEXT ctx,
                             Stack<Expr> stack,
                             GeneralSetFunctionExpr expr)
                               throws PlanningException

Specified by:

visitGeneralSetFunction in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitWindowFunction

public RESULT visitWindowFunction(CONTEXT ctx,
                         Stack<Expr> stack,
                         WindowFunctionExpr expr)
                           throws PlanningException

Specified by:

visitWindowFunction in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitDataType

public RESULT visitDataType(CONTEXT ctx,
                   Stack<Expr> stack,
                   DataTypeExpr expr)
                     throws PlanningException

Specified by:

visitDataType in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitCastExpr

public RESULT visitCastExpr(CONTEXT ctx,
                   Stack<Expr> stack,
                   CastExpr expr)
                     throws PlanningException

Specified by:

visitCastExpr in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitLiteral

public RESULT visitLiteral(CONTEXT ctx,
                  Stack<Expr> stack,
                  LiteralValue expr)
                    throws PlanningException

Specified by:

visitLiteral in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitNullLiteral

public RESULT visitNullLiteral(CONTEXT ctx,
                      Stack<Expr> stack,
                      NullLiteral expr)
                        throws PlanningException

Specified by:

visitNullLiteral in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitTimestampLiteral

public RESULT visitTimestampLiteral(CONTEXT ctx,
                           Stack<Expr> stack,
                           TimestampLiteral expr)
                             throws PlanningException

Specified by:

visitTimestampLiteral in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitIntervalLiteral

public RESULT visitIntervalLiteral(CONTEXT ctx,
                          Stack<Expr> stack,
                          IntervalLiteral expr)
                            throws PlanningException

Specified by:

visitIntervalLiteral in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitTimeLiteral

public RESULT visitTimeLiteral(CONTEXT ctx,
                      Stack<Expr> stack,
                      TimeLiteral expr)
                        throws PlanningException

Specified by:

visitTimeLiteral in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException

visitDateLiteral

public RESULT visitDateLiteral(CONTEXT ctx,
                      Stack<Expr> stack,
                      DateLiteral expr)
                        throws PlanningException

Specified by:

visitDateLiteral in interface AlgebraVisitor<CONTEXT,RESULT>

Throws:

PlanningException