StatementVisitorAdapter.java

/*-
 * #%L
 * JSQLParser library
 * %%
 * Copyright (C) 2004 - 2019 JSQLParser
 * %%
 * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
 * #L%
 */
package net.sf.jsqlparser.statement;

import net.sf.jsqlparser.statement.alter.AlterRelation;
import net.sf.jsqlparser.statement.alter.AlterRule;
import net.sf.jsqlparser.statement.create.cast.CreateCast;
import net.sf.jsqlparser.statement.create.transform.CreateTransform;
import net.sf.jsqlparser.statement.create.conversion.CreateConversion;
import net.sf.jsqlparser.statement.alter.AlterConversion;
import net.sf.jsqlparser.statement.alter.AlterTablespace;
import net.sf.jsqlparser.statement.alter.AlterPolicy;
import net.sf.jsqlparser.statement.alter.AlterRoutine;
import net.sf.jsqlparser.statement.alter.AlterTrigger;
import net.sf.jsqlparser.statement.drop.DropPolicy;
import net.sf.jsqlparser.statement.drop.DropUserMapping;
import net.sf.jsqlparser.statement.create.statistics.CreateStatistics;
import net.sf.jsqlparser.statement.create.fdw.CreateForeignDataWrapper;
import net.sf.jsqlparser.statement.alter.AlterForeignDataWrapper;
import net.sf.jsqlparser.statement.create.server.CreateServer;
import net.sf.jsqlparser.statement.alter.AlterServer;
import net.sf.jsqlparser.statement.create.usermapping.CreateUserMapping;
import net.sf.jsqlparser.statement.alter.AlterUserMapping;
import net.sf.jsqlparser.statement.create.rule.CreateRule;
import net.sf.jsqlparser.statement.create.collation.CreateCollation;
import net.sf.jsqlparser.statement.notify.ListenStatement;
import net.sf.jsqlparser.statement.notify.NotifyStatement;
import net.sf.jsqlparser.statement.foreign.ForeignDataStatement;

import net.sf.jsqlparser.statement.create.accessmethod.CreateAccessMethod;

import net.sf.jsqlparser.statement.oracle.OracleBlock;
import net.sf.jsqlparser.statement.oracle.OracleAssignment;

import net.sf.jsqlparser.statement.role.CreateRole;
import net.sf.jsqlparser.statement.role.AlterRole;
import net.sf.jsqlparser.statement.role.ReassignOwned;
import net.sf.jsqlparser.statement.role.RoleOption;
import net.sf.jsqlparser.statement.grant.Revoke;
import net.sf.jsqlparser.statement.grant.AlterDefaultPrivileges;
import net.sf.jsqlparser.statement.create.type.CreateType;
import net.sf.jsqlparser.statement.alter.AlterType;
import net.sf.jsqlparser.statement.create.domain.CreateDomain;
import net.sf.jsqlparser.statement.alter.AlterDomain;
import net.sf.jsqlparser.statement.create.extension.CreateExtension;
import net.sf.jsqlparser.statement.alter.AlterExtension;
import net.sf.jsqlparser.statement.create.publication.CreatePublication;
import net.sf.jsqlparser.statement.alter.AlterPublication;
import net.sf.jsqlparser.statement.create.subscription.CreateSubscription;
import net.sf.jsqlparser.statement.alter.AlterSubscription;

import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.ExpressionVisitor;
import net.sf.jsqlparser.expression.ExpressionVisitorAdapter;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.schema.Partition;
import net.sf.jsqlparser.statement.alter.Alter;
import net.sf.jsqlparser.statement.alter.AlterExpression;
import net.sf.jsqlparser.statement.alter.AlterSession;
import net.sf.jsqlparser.statement.alter.AlterEventTrigger;
import net.sf.jsqlparser.statement.alter.AlterInstance;
import net.sf.jsqlparser.statement.alter.AlterSystemStatement;
import net.sf.jsqlparser.statement.alter.RenameTableStatement;
import net.sf.jsqlparser.statement.alter.AlterUser;
import net.sf.jsqlparser.statement.alter.RenameUser;
import net.sf.jsqlparser.statement.alter.sequence.AlterSequence;
import net.sf.jsqlparser.statement.analyze.Analyze;
import net.sf.jsqlparser.statement.comment.Comment;
import net.sf.jsqlparser.statement.create.database.CreateDatabase;
import net.sf.jsqlparser.statement.create.event.AlterEvent;
import net.sf.jsqlparser.statement.create.event.CreateEvent;
import net.sf.jsqlparser.statement.create.index.CreateIndex;
import net.sf.jsqlparser.statement.create.policy.CreatePolicy;
import net.sf.jsqlparser.statement.create.schema.CreateSchema;
import net.sf.jsqlparser.statement.create.sequence.CreateSequence;
import net.sf.jsqlparser.statement.create.synonym.CreateSynonym;
import net.sf.jsqlparser.statement.create.table.CreateTable;
import net.sf.jsqlparser.statement.create.spatial.CreateSpatialReferenceSystem;
import net.sf.jsqlparser.statement.create.tablespace.CreateTablespace;
import net.sf.jsqlparser.statement.create.trigger.CreateEventTrigger;
import net.sf.jsqlparser.statement.create.trigger.CreateTrigger;
import net.sf.jsqlparser.statement.create.user.CreateUser;
import net.sf.jsqlparser.statement.create.view.AlterView;
import net.sf.jsqlparser.statement.create.view.CreateView;
import net.sf.jsqlparser.statement.delete.Delete;
import net.sf.jsqlparser.statement.delete.ParenthesedDelete;
import net.sf.jsqlparser.statement.drop.Drop;
import net.sf.jsqlparser.statement.execute.Execute;
import net.sf.jsqlparser.statement.export.Export;
import net.sf.jsqlparser.statement.grant.Grant;
import net.sf.jsqlparser.statement.imprt.Import;
import net.sf.jsqlparser.statement.insert.Insert;
import net.sf.jsqlparser.statement.insert.InsertBulk;
import net.sf.jsqlparser.statement.insert.InsertConflictAction;
import net.sf.jsqlparser.statement.insert.ParenthesedInsert;
import net.sf.jsqlparser.statement.admin.FlushStatement;
import net.sf.jsqlparser.statement.admin.KillStatement;
import net.sf.jsqlparser.statement.handler.HandlerStatement;
import net.sf.jsqlparser.statement.lock.BackupLockStatement;
import net.sf.jsqlparser.statement.lock.LockStatement;
import net.sf.jsqlparser.statement.lock.UnlockStatement;
import net.sf.jsqlparser.statement.maintenance.CheckpointStatement;
import net.sf.jsqlparser.statement.maintenance.ClusterStatement;
import net.sf.jsqlparser.statement.maintenance.VacuumStatement;
import net.sf.jsqlparser.statement.merge.Merge;
import net.sf.jsqlparser.statement.merge.MergeOperationVisitor;
import net.sf.jsqlparser.statement.merge.MergeOperationVisitorAdapter;
import net.sf.jsqlparser.statement.refresh.RefreshMaterializedViewStatement;
import net.sf.jsqlparser.statement.replication.ChangeReplicationFilterStatement;
import net.sf.jsqlparser.statement.replication.ChangeReplicationSourceStatement;
import net.sf.jsqlparser.statement.replication.ResetReplicationStatement;
import net.sf.jsqlparser.statement.replication.StartReplicaStatement;
import net.sf.jsqlparser.statement.replication.StopReplicaStatement;
import net.sf.jsqlparser.statement.reindex.Reindex;
import net.sf.jsqlparser.statement.resourcegroup.AlterResourceGroup;
import net.sf.jsqlparser.statement.resourcegroup.CreateResourceGroup;
import net.sf.jsqlparser.statement.resourcegroup.SetResourceGroup;
import net.sf.jsqlparser.statement.securitylabel.SecurityLabel;
import net.sf.jsqlparser.statement.select.FromItem;
import net.sf.jsqlparser.statement.select.FromItemVisitor;
import net.sf.jsqlparser.statement.select.FromItemVisitorAdapter;
import net.sf.jsqlparser.statement.select.PivotVisitor;
import net.sf.jsqlparser.statement.select.PivotVisitorAdapter;
import net.sf.jsqlparser.statement.select.Select;
import net.sf.jsqlparser.statement.select.SelectItemVisitor;
import net.sf.jsqlparser.statement.select.SelectItemVisitorAdapter;
import net.sf.jsqlparser.statement.select.SelectVisitor;
import net.sf.jsqlparser.statement.select.SelectVisitorAdapter;
import net.sf.jsqlparser.statement.select.WithItem;
import net.sf.jsqlparser.statement.show.MySqlShowStatement;
import net.sf.jsqlparser.statement.show.ShowCreateStatement;
import net.sf.jsqlparser.statement.show.ShowIndexStatement;
import net.sf.jsqlparser.statement.show.ShowTableStatusStatement;
import net.sf.jsqlparser.statement.show.ShowTablesStatement;
import net.sf.jsqlparser.statement.truncate.Truncate;
import net.sf.jsqlparser.statement.update.ParenthesedUpdate;
import net.sf.jsqlparser.statement.update.Update;
import net.sf.jsqlparser.statement.upsert.Upsert;

import java.util.List;
import net.sf.jsqlparser.util.TableDefinitionTraversal;
import net.sf.jsqlparser.statement.create.macro.CreateMacro;
import net.sf.jsqlparser.statement.create.extension.CreateExtensionRepository;
import net.sf.jsqlparser.statement.cursor.CloseCursorStatement;
import net.sf.jsqlparser.statement.cursor.DeclareCursorStatement;
import net.sf.jsqlparser.statement.cursor.FetchCursorStatement;
import net.sf.jsqlparser.statement.export.ExportDataStatement;
import net.sf.jsqlparser.statement.load.LoadDataStatement;
import net.sf.jsqlparser.statement.load.MySqlLoadDataStatement;

@SuppressWarnings({"PMD.UncommentedEmptyMethodBody"})
public class StatementVisitorAdapter<T> implements StatementVisitor<T> {
    private final ExpressionVisitor<T> expressionVisitor;
    private final PivotVisitor<T> pivotVisitor;
    private final SelectItemVisitor<T> selectItemVisitor;
    private final FromItemVisitor<T> fromItemVisitor;
    private final SelectVisitor<T> selectVisitor;
    private final MergeOperationVisitor<T> mergeOperationVisitor;

    /**
     * Builds a fully connected visitor graph.
     *
     * <p>
     * The sub-visitors are mutually recursive, so none of them can be handed its collaborators at
     * construction time; the cycle has to be closed afterwards through the setters. The previous
     * version skipped that step and the graph was not actually connected:
     *
     * <ul>
     * <li>{@code new ExpressionVisitorAdapter<>()} leaves its {@code selectVisitor} null, and
     * {@code ExpressionVisitorAdapter#visit(Select)} is a no-op when it is null - so every
     * sub-select in an expression ({@code WHERE id IN (SELECT ..)}, scalar subqueries, EXISTS) was
     * silently dropped;</li>
     * <li>{@code new FromItemVisitorAdapter<>()} builds its own throwaway SelectVisitorAdapter and
     * ExpressionVisitorAdapter, so subqueries in FROM were traversed by a detached chain that no
     * subclass of this adapter could observe.</li>
     * </ul>
     *
     * <p>
     * Both meant a subclass overriding a visit method never saw the nested nodes. The three setter
     * calls below fix that; {@code setStatementVisitor} additionally lets the select visitor hand a
     * data-modifying CTE body back here.
     */
    public StatementVisitorAdapter() {
        ExpressionVisitorAdapter<T> expressions = new ExpressionVisitorAdapter<>();
        FromItemVisitorAdapter<T> fromItems = new FromItemVisitorAdapter<>();

        this.expressionVisitor = expressions;
        this.pivotVisitor = new PivotVisitorAdapter<>(expressions);
        this.selectItemVisitor = new SelectItemVisitorAdapter<>(expressions);
        this.fromItemVisitor = fromItems;

        SelectVisitorAdapter<T> selects = new SelectVisitorAdapter<>(expressions, this.pivotVisitor,
                this.selectItemVisitor, fromItems);

        expressions.setSelectVisitor(selects);
        fromItems.setSelectVisitor((SelectVisitor<T>) selects).setExpressionVisitor(expressions);
        selects.setStatementVisitor(this);

        this.selectVisitor = selects;
        this.mergeOperationVisitor = new MergeOperationVisitorAdapter<>();
    }

    public StatementVisitorAdapter(ExpressionVisitor<T> expressionVisitor,
            PivotVisitor<T> pivotVisitor, SelectItemVisitor<T> selectItemVisitor,
            FromItemVisitor<T> fromItemVisitor, SelectVisitor<T> selectVisitor,
            MergeOperationVisitor<T> mergeOperationVisitor) {
        this.expressionVisitor = expressionVisitor;
        this.pivotVisitor = pivotVisitor;
        this.selectItemVisitor = selectItemVisitor;
        this.fromItemVisitor = fromItemVisitor;
        this.selectVisitor = selectVisitor;
        this.mergeOperationVisitor = mergeOperationVisitor;
        adoptAsStatementVisitor(selectVisitor);
    }

    public StatementVisitorAdapter(SelectVisitorAdapter<T> selectVisitor) {
        this.selectVisitor = selectVisitor;
        adoptAsStatementVisitor(selectVisitor);
        this.expressionVisitor = selectVisitor.getExpressionVisitor();
        this.pivotVisitor = selectVisitor.getPivotVisitor();
        this.selectItemVisitor = selectVisitor.getSelectItemVisitor();
        this.fromItemVisitor = selectVisitor.getFromItemVisitor();
        this.mergeOperationVisitor = new MergeOperationVisitorAdapter<>();
    }

    /**
     * Lets the select visitor hand a data-modifying CTE body back to this statement visitor.
     * Without it, {@code SelectVisitorAdapter#visit(WithItem)} has no way to traverse
     * {@code WITH c AS (DELETE FROM t RETURNING *) ..} and silently skips it.
     *
     * <p>
     * An explicitly configured statement visitor is never overwritten.
     */
    private void adoptAsStatementVisitor(SelectVisitor<T> visitor) {
        if (visitor instanceof SelectVisitorAdapter) {
            SelectVisitorAdapter<T> adapter = (SelectVisitorAdapter<T>) visitor;
            if (adapter.getStatementVisitor() == null) {
                adapter.setStatementVisitor(this);
            }
        }
    }

    @Override
    public <S> T visit(Comment comment, S context) {
        comment.visitRelations(table -> table.accept(fromItemVisitor, context));
        expressionVisitor.visitExpression(comment.getComment(), context);
        return null;
    }

    @Override
    public <S> T visit(StartTransaction statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(ReleaseSavepointStatement statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(SetTransactionStatement statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(SetConstraintsStatement statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(PrepareTransactionStatement statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(XaStatement statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(CreateResourceGroup statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(AlterResourceGroup statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(SetResourceGroup statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(PluginStatement statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(Commit commit, S context) {

        return null;
    }

    @Override
    public <S> T visit(Select select, S context) {
        return select.accept(selectVisitor, context);
    }

    @Override
    public <S> T visit(Delete delete, S context) {
        visitWithItems(delete.getWithItemsList(), context);
        fromItemVisitor.visitTables(delete.getTables(), context);
        selectVisitor.visitOutputClause(delete.getOutputClause(), context);
        fromItemVisitor.visitFromItem(delete.getTable(), context);
        fromItemVisitor.visitJoins(delete.getJoins(), context);
        // USING may name subqueries, so visit the items rather than getUsingList()'s tables
        if (delete.getUsingFromItemList() != null) {
            for (FromItem usingFromItem : delete.getUsingFromItemList()) {
                fromItemVisitor.visitFromItem(usingFromItem, context);
            }
        }
        fromItemVisitor.visitJoins(delete.getUsingJoins(), context);
        expressionVisitor.visitExpression(delete.getWhere(), context);

        expressionVisitor.visitPreferringClause(delete.getPreferringClause(), context);

        expressionVisitor.visitOrderBy(delete.getOrderByElements(), context);

        expressionVisitor.visitLimit(delete.getLimit(), context);

        // was missing, unlike visit(Insert) and visit(Update):
        // DELETE FROM t RETURNING f(x) left f(x) untraversed
        visitReturningClause(delete.getReturningClause(), context);

        return null;
    }

    private <S> void visitWithItems(List<WithItem<?>> withItemsList, S context) {
        if (withItemsList != null) {
            for (WithItem<?> item : withItemsList) {
                item.accept(this, context);
            }
        }
    }

    @Override
    public <S> T visit(ParenthesedDelete delete, S context) {
        delete.getDelete().accept(this, context);
        return null;
    }

    @Override
    public <S> T visit(SessionStatement sessionStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(Update update, S context) {
        visitWithItems(update.getWithItemsList(), context);
        fromItemVisitor.visitFromItem(update.getTable(), context);
        fromItemVisitor.visitJoins(update.getStartJoins(), context);
        expressionVisitor.visitUpdateSets(update.getUpdateSets(), context);
        selectVisitor.visitOutputClause(update.getOutputClause(), context);
        fromItemVisitor.visitFromItem(update.getFromItem(), context);
        fromItemVisitor.visitJoins(update.getJoins(), context);
        expressionVisitor.visitExpression(update.getWhere(), context);
        expressionVisitor.visitPreferringClause(update.getPreferringClause(), context);
        expressionVisitor.visitOrderBy(update.getOrderByElements(), context);
        expressionVisitor.visitLimit(update.getLimit(), context);
        visitReturningClause(update.getReturningClause(), context);
        return null;
    }

    @Override
    public <S> T visit(ParenthesedUpdate update, S context) {
        return update.getUpdate().accept(this, context);
    }

    @Override
    public <S> T visit(Insert insert, S context) {
        visitWithItems(insert.getWithItemsList(), context);

        insert.getTable().accept(fromItemVisitor, context);

        if (insert.getColumns() != null) {
            for (Column column : insert.getColumns()) {
                column.accept(expressionVisitor, context);
            }
        }

        if (insert.getPartitions() != null) {
            for (Partition partition : insert.getPartitions()) {
                partition.getColumn().accept(expressionVisitor, context);
                if (partition.getValue() != null) {
                    partition.getValue().accept(expressionVisitor, context);
                }
            }
        }

        selectVisitor.visitOutputClause(insert.getOutputClause(), context);

        if (insert.getSelect() != null) {
            insert.getSelect().accept(selectVisitor, context);
        }

        expressionVisitor.visitUpdateSets(insert.getSetUpdateSets(), context);

        expressionVisitor.visitUpdateSets(insert.getDuplicateUpdateSets(), context);

        final InsertConflictAction conflictAction = insert.getConflictAction();
        if (conflictAction != null) {
            expressionVisitor.visitExpression(conflictAction.getWhereExpression(), context);
            expressionVisitor.visitUpdateSets(conflictAction.getUpdateSets(), context);
        }

        if (insert.getConflictTarget() != null) {
            insert.getConflictTarget().accept(expressionVisitor, context);
        }
        visitReturningClause(insert.getReturningClause(), context);
        return null;
    }

    private <S> T visitReturningClause(ReturningClause returningClause, S context) {
        if (returningClause != null) {
            returningClause.forEach(selectItem -> selectItem.accept(selectItemVisitor, context));
            // @todo: verify why this is a list of strings and not columns
        }
        return null;
    }

    @Override
    public <S> T visit(InsertBulk statement, S context) {
        fromItemVisitor.visitFromItem(statement.getTable(), context);
        statement.visitExpressions(expression -> expression.accept(expressionVisitor, context));
        return null;
    }

    @Override
    public <S> T visit(ParenthesedInsert insert, S context) {
        insert.getInsert().accept(this, context);
        return null;
    }

    @Override
    public <S> T visit(Drop drop, S context) {
        drop.visitTables(table -> fromItemVisitor.visitFromItem(table, context));

        return null;
    }

    @Override
    public <S> T visit(ReassignOwned statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(Truncate truncate, S context) {
        return truncate.getTable().accept(fromItemVisitor, context);
    }

    @Override
    public <S> T visit(CreateIndex createIndex, S context) {
        TableDefinitionTraversal.visit(createIndex,
                expression -> expression.accept(expressionVisitor, context),
                table -> table.accept(fromItemVisitor, context));
        return null;
    }

    @Override
    public <S> T visit(CreateSchema createSchema, S context) {
        createSchema.getStatements().forEach(element -> element.accept(this, context));
        return null;
    }

    @Override
    public <S> T visit(CreateDatabase createDatabase, S context) {
        return null;
    }

    @Override
    public <S> T visit(CreateUser createUser, S context) {
        return null;
    }

    @Override
    public <S> T visit(AlterUser alterUser, S context) {
        return null;
    }

    @Override
    public <S> T visit(RenameUser renameUser, S context) {
        return null;
    }

    @Override
    public <S> T visit(SetRoleStatement setRole, S context) {
        return null;
    }

    @Override
    public <S> T visit(SetDefaultRoleStatement setDefaultRole, S context) {
        return null;
    }

    @Override
    public <S> T visit(SetPasswordStatement setPassword, S context) {
        return null;
    }

    @Override
    public <S> T visit(CreateEvent createEvent, S context) {
        return null;
    }

    @Override
    public <S> T visit(CreateTable createTable, S context) {
        TableDefinitionTraversal.visit(createTable,
                expression -> expression.accept(expressionVisitor, context),
                table -> table.accept(fromItemVisitor, context));
        if (createTable.getSelect() != null) {
            createTable.getSelect().accept(selectVisitor, context);
        }
        return createTable.getTable().accept(fromItemVisitor, context);
    }

    @Override
    public <S> T visit(CreateTrigger createTrigger, S context) {
        createTrigger.visit(t -> t.accept(fromItemVisitor, context),
                e -> e.accept(expressionVisitor, context));
        if (createTrigger.getBody() != null) {
            createTrigger.getBody().accept(this, context);
        }
        return null;
    }

    @Override
    public <S> T visit(CreateEventTrigger statement, S context) {
        statement.visitExpressions(expression -> expression.accept(expressionVisitor, context));
        return null;
    }

    @Override
    public <S> T visit(AlterEventTrigger statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(Reindex statement, S context) {
        if (statement.getTable() != null) {
            statement.getTable().accept(fromItemVisitor, context);
        }
        return null;
    }

    @Override
    public <S> T visit(SecurityLabel statement, S context) {
        statement.visitRelations(table -> table.accept(fromItemVisitor, context));
        expressionVisitor.visitExpression(statement.getLabel(), context);
        return null;
    }

    @Override
    public <S> T visit(CreateView createView, S context) {
        createView.getView().accept(fromItemVisitor, context);
        if (createView.getSelect() != null) {
            createView.getSelect().accept(selectVisitor, context);
        }
        return null;
    }

    @Override
    public <S> T visit(Alter alter, S context) {
        alter.getTable().accept(fromItemVisitor, context);
        for (AlterExpression action : alter.getAlterExpressions()) {
            TableDefinitionTraversal.visit(action,
                    expression -> expression.accept(expressionVisitor, context),
                    table -> table.accept(fromItemVisitor, context));
        }
        return null;
    }

    @Override
    public <S> T visit(AlterEvent alterEvent, S context) {
        return null;
    }

    @Override
    public <S> T visit(Statements statements, S context) {
        for (Statement statement : statements) {
            statement.accept(this, context);
        }
        return null;
    }

    @Override
    public <S> T visit(Execute execute, S context) {
        expressionVisitor.visitExpression(execute.getExprList(), context);
        expressionVisitor.visitExpression(execute.getUsingVariables(), context);
        return null;
    }

    @Override
    public <S> T visit(DoStatement statement, S context) {
        statement.visitExpressions(expression -> expression.accept(expressionVisitor, context));
        return null;
    }

    @Override
    public <S> T visit(LockStatement lock, S context) {

        return null;
    }

    @Override
    public <S> T visit(UnlockStatement unlock, S context) {
        return null;
    }

    @Override
    public <S> T visit(BackupLockStatement backupLock, S context) {
        return null;
    }

    @Override
    public <S> T visit(ChangeReplicationSourceStatement changeReplicationSource, S context) {
        return null;
    }

    @Override
    public <S> T visit(ChangeReplicationFilterStatement changeReplicationFilter, S context) {
        return null;
    }

    @Override
    public <S> T visit(StartReplicaStatement startReplica, S context) {
        return null;
    }

    @Override
    public <S> T visit(StopReplicaStatement stopReplica, S context) {
        return null;
    }

    @Override
    public <S> T visit(ResetReplicationStatement resetReplication, S context) {
        return null;
    }

    @Override
    public <S> T visit(DeclareCursorStatement declareCursor, S context) {
        if (declareCursor.getQuery() != null) {
            declareCursor.getQuery().accept(selectVisitor, context);
        }
        return null;
    }

    @Override
    public <S> T visit(FetchCursorStatement fetchCursor, S context) {
        return null;
    }

    @Override
    public <S> T visit(CloseCursorStatement closeCursor, S context) {
        return null;
    }

    @Override
    public <S> T visit(CreatePolicy createPolicy, S context) {
        fromItemVisitor.visitFromItem(createPolicy.getTable(), context);
        expressionVisitor.visitExpression(createPolicy.getUsingExpression(), context);
        expressionVisitor.visitExpression(createPolicy.getWithCheckExpression(), context);

        return null;
    }

    @Override
    public <S> T visit(SetStatement set, S context) {
        for (int i = 0; i < set.getCount(); i++) {
            if (set.getExpressions(i) != null) {
                for (Expression expression : set.getExpressions(i)) {
                    expressionVisitor.visitExpression(expression, context);
                }
            }
        }
        return null;
    }

    @Override
    public <S> T visit(ResetStatement reset, S context) {

        return null;
    }

    @Override
    public <S> T visit(Merge merge, S context) {
        visitWithItems(merge.getWithItemsList(), context);
        fromItemVisitor.visitFromItem(merge.getTable(), context);
        fromItemVisitor.visitFromItem(merge.getFromItem(), context);
        expressionVisitor.visitExpression(merge.getOnCondition(), context);
        mergeOperationVisitor.visit(merge.getOperations(), context);
        selectVisitor.visitOutputClause(merge.getOutputClause(), context);
        visitReturningClause(merge.getReturningClause(), context);
        return null;
    }

    @Override
    public <S> T visit(AlterView alterView, S context) {
        return null;
    }

    @Override
    public <S> T visit(Upsert upsert, S context) {
        return null;
    }

    @Override
    public <S> T visit(SetIdentityInsertStatement statement, S context) {
        return statement.getTable().accept(fromItemVisitor, context);
    }

    @Override
    public <S> T visit(UseStatement use, S context) {
        return null;
    }

    @Override
    public <S> T visit(Block block, S context) {
        return null;
    }

    @Override
    public <S> T visit(DescribeStatement describe, S context) {
        return null;
    }

    @Override
    public <S> T visit(ExplainStatement explainStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(ShowStatement showStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(ShowColumnsStatement showColumnsStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(ShowIndexStatement showIndexStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(ShowTablesStatement showTables, S context) {
        return null;
    }

    @Override
    public <S> T visit(ShowTableStatusStatement showTableStatus, S context) {
        return null;
    }

    @Override
    public <S> T visit(ShowCreateStatement showCreate, S context) {
        return null;
    }

    @Override
    public <S> T visit(MySqlShowStatement mySqlShow, S context) {
        return null;
    }

    @Override
    public <S> T visit(DeclareStatement declareStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(Grant grant, S context) {
        grant.getClause().visit(t -> t.accept(fromItemVisitor, context),
                e -> e.accept(expressionVisitor, context));
        return null;
    }

    @Override
    public <S> T visit(CreateSequence createSequence, S context) {
        if (createSequence.getSequence().getOwnership() != null
                && createSequence.getSequence().getOwnership().getColumn() != null) {
            createSequence.getSequence().getOwnership().getColumn().accept(expressionVisitor,
                    context);
        }
        return null;
    }

    @Override
    public <S> T visit(AlterSequence alterSequence, S context) {
        if (alterSequence.getSequence().getOwnership() != null
                && alterSequence.getSequence().getOwnership().getColumn() != null) {
            alterSequence.getSequence().getOwnership().getColumn().accept(expressionVisitor,
                    context);
        }
        return null;
    }

    @Override
    public <S> T visit(CreateFunctionalStatement createFunctionalStatement, S context) {
        if (createFunctionalStatement.getReturnType() != null
                && createFunctionalStatement.getReturnType().getTableElements() != null) {
            createFunctionalStatement.getReturnType().getTableElements()
                    .forEach(element -> TableDefinitionTraversal.visit(element,
                            expression -> expression.accept(expressionVisitor, context),
                            table -> table.accept(fromItemVisitor, context)));
        }
        return null;
    }

    @Override
    public <S> T visit(CreateSynonym createSynonym, S context) {
        return null;
    }

    @Override
    public <S> T visit(Analyze analyze, S context) {

        return null;
    }

    @Override
    public <S> T visit(TableMaintenanceStatement statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(FlushStatement flush, S context) {
        return null;
    }

    @Override
    public <S> T visit(KillStatement kill, S context) {
        expressionVisitor.visitExpression(kill.getProcesslistId(), context);
        return null;
    }

    @Override
    public <S> T visit(HandlerStatement handler, S context) {
        expressionVisitor.visitExpression(handler.getKeyValues(), context);
        expressionVisitor.visitExpression(handler.getWhere(), context);
        return null;
    }

    @Override
    public <S> T visit(VacuumStatement vacuum, S context) {
        return null;
    }

    @Override
    public <S> T visit(ClusterStatement cluster, S context) {
        return null;
    }

    @Override
    public <S> T visit(CheckpointStatement checkpoint, S context) {
        return null;
    }

    @Override
    public <S> T visit(SavepointStatement savepointStatement, S context) {
        // @todo: do something usefully here
        return null;
    }

    @Override
    public <S> T visit(RollbackStatement rollbackStatement, S context) {
        // @todo: do something usefully here
        return null;
    }

    @Override
    public <S> T visit(AlterSession alterSession, S context) {
        // @todo: do something usefully here
        return null;
    }

    @Override
    public <S> T visit(IfElseStatement ifElseStatement, S context) {
        ifElseStatement.getIfStatement().accept(this, context);
        if (ifElseStatement.getElseStatement() != null) {
            ifElseStatement.getElseStatement().accept(this, context);
        }
        return null;
    }

    @Override
    public <S> T visit(RenameTableStatement renameTableStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(PragmaStatement pragmaStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(AssertStatement assertStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(ExtensionStatement extensionStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(ExportDataStatement exportDataStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(AttachStatement attachStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(DetachStatement detachStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(ConnectStatement connectStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(DisconnectStatement disconnectStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(PrepareStatement prepareStatement, S context) {
        expressionVisitor.visitExpression(prepareStatement.getSource(), context);
        return null;
    }

    @Override
    public <S> T visit(DeallocateStatement deallocateStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(CopyStatement copyStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(CreateMacro createMacro, S context) {
        return null;
    }

    @Override
    public <S> T visit(CreateExtensionRepository createExtensionRepository, S context) {
        return null;
    }

    @Override
    public <S> T visit(LoadDataStatement loadDataStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(MySqlLoadDataStatement loadData, S context) {
        fromItemVisitor.visitFromItem(loadData.getTable(), context);
        expressionVisitor.visitExpressions(loadData.getColumns(), context);
        expressionVisitor.visitUpdateSets(loadData.getUpdateSets(), context);
        return null;
    }

    @Override
    public <S> T visit(PurgeStatement purgeStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(AlterSystemStatement alterSystemStatement, S context) {
        return null;
    }

    @Override
    public <S> T visit(UnsupportedStatement unsupportedStatement, S context) {

        return null;
    }

    @Override
    public <S> T visit(RefreshMaterializedViewStatement materializedView, S context) {
        return null;
    }

    @Override
    public <S> T visit(Import imprt, S context) {
        return null;
    }

    @Override
    public <S> T visit(Export export, S context) {
        return null;
    }

    @Override
    public <S> T visit(CreateRole statement, S context) {
        for (RoleOption option : statement.getOptions()) {
            if (option.getValue() != null) {
                option.getValue().accept(expressionVisitor, context);
            }
        }
        return null;
    }

    @Override
    public <S> T visit(AlterRole statement, S context) {
        for (RoleOption option : statement.getOptions()) {
            if (option.getValue() != null) {
                option.getValue().accept(expressionVisitor, context);
            }
        }
        if (statement.getValues() != null) {
            statement.getValues().forEach(e -> e.accept(expressionVisitor, context));
        }
        return null;
    }

    @Override
    public <S> T visit(Revoke statement, S context) {
        statement.getClause().visit(t -> t.accept(fromItemVisitor, context),
                e -> e.accept(expressionVisitor, context));
        return null;
    }

    @Override
    public <S> T visit(AlterDefaultPrivileges statement, S context) {
        if (statement.getGrant() != null) {
            statement.getGrant().accept(this, context);
        }
        if (statement.getRevoke() != null) {
            statement.getRevoke().accept(this, context);
        }
        return null;
    }

    @Override
    public <S> T visit(CreateType statement, S context) {

        return null;
    }

    @Override
    public <S> T visit(AlterType statement, S context) {

        return null;
    }

    @Override
    public <S> T visit(CreateDomain statement, S context) {
        if (statement.getDefaultExpression() != null) {
            statement.getDefaultExpression().accept(expressionVisitor, context);
        }
        statement.getConstraints().forEach(constraint -> {
            if (constraint.getExpression() != null) {
                constraint.getExpression().accept(expressionVisitor, context);
            }
        });
        return null;
    }

    @Override
    public <S> T visit(AlterDomain statement, S context) {
        if (statement.getDefaultExpression() != null) {
            statement.getDefaultExpression().accept(expressionVisitor, context);
        }
        if (statement.getConstraint() != null
                && statement.getConstraint().getExpression() != null) {
            statement.getConstraint().getExpression().accept(expressionVisitor, context);
        }
        return null;
    }

    @Override
    public <S> T visit(CreateExtension statement, S context) {

        return null;
    }

    @Override
    public <S> T visit(AlterExtension statement, S context) {
        if (statement.getMember() != null && statement.getMember().isTable()) {
            new Table(statement.getMember().getName())
                    .accept(fromItemVisitor, context);
        }
        return null;
    }

    @Override
    public <S> T visit(CreatePublication statement, S context) {
        statement.getTargets().forEach(target -> target.visit(
                table -> table.accept(fromItemVisitor, context),
                expression -> expression.accept(expressionVisitor, context)));
        statement.getOptions().forEach(option -> {
            if (option.getValue() != null) {
                option.getValue().accept(expressionVisitor, context);
            }
        });
        return null;
    }

    @Override
    public <S> T visit(AlterPublication statement, S context) {
        statement.getTargets().forEach(target -> target.visit(
                table -> table.accept(fromItemVisitor, context),
                expression -> expression.accept(expressionVisitor, context)));
        statement.getOptions().forEach(option -> {
            if (option.getValue() != null) {
                option.getValue().accept(expressionVisitor, context);
            }
        });
        return null;
    }

    @Override
    public <S> T visit(CreateSubscription statement, S context) {
        if (statement.getConnection() != null) {
            statement.getConnection().accept(expressionVisitor, context);
        }
        statement.getOptions().forEach(option -> {
            if (option.getValue() != null) {
                option.getValue().accept(expressionVisitor, context);
            }
        });
        return null;
    }

    @Override
    public <S> T visit(AlterSubscription statement, S context) {
        if (statement.getConnection() != null) {
            statement.getConnection().accept(expressionVisitor, context);
        }
        statement.getOptions().forEach(option -> {
            if (option.getValue() != null) {
                option.getValue().accept(expressionVisitor, context);
            }
        });
        return null;
    }

    @Override
    public <S> T visit(OracleBlock block, S context) {
        block.visitChildren(expression -> expression.accept(expressionVisitor, context),
                statement -> statement.accept(this, context));
        return null;
    }

    @Override
    public <S> T visit(OracleAssignment assignment, S context) {
        assignment.getTarget().accept(expressionVisitor, context);
        assignment.getValue().accept(expressionVisitor, context);
        return null;
    }


    @Override
    public <S> T visit(CreateAccessMethod statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(AlterRelation statement, S context) {
        if (statement.getObjectType() != AlterRelation.ObjectType.INDEX) {
            fromItemVisitor.visitFromItem(statement.getRelation(), context);
        }
        statement.getActions().forEach(action -> {
            action.visitExpressions(expression -> expression.accept(expressionVisitor, context));
            action.visitTables(table -> table.accept(fromItemVisitor, context));
        });
        return null;
    }

    @Override
    public <S> T visit(CreateTablespace statement, S context) {
        statement.visitExpressions(expression -> expression.accept(expressionVisitor, context));
        return null;
    }

    @Override
    public <S> T visit(CreateSpatialReferenceSystem statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(AlterInstance statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(AlterTablespace statement, S context) {
        statement.visitExpressions(expression -> expression.accept(expressionVisitor, context));
        return null;
    }

    @Override
    public <S> T visit(AlterPolicy statement, S context) {
        fromItemVisitor.visitFromItem(statement.getTable(), context);
        if (statement.getNewName() == null) {
            statement.getOptions()
                    .visitExpressions(expression -> expression.accept(expressionVisitor, context));
        }
        return null;
    }

    @Override
    public <S> T visit(DropPolicy statement, S context) {
        fromItemVisitor.visitFromItem(statement.getTable(), context);
        return null;
    }

    @Override
    public <S> T visit(CreateStatistics statement, S context) {
        fromItemVisitor.visitFromItem(statement.getTable(), context);
        expressionVisitor.visitExpression(statement.getExpressions(), context);
        return null;
    }

    private <S> T visitForeignDataStatement(ForeignDataStatement statement, S context) {
        statement.visitExpressions(expression -> expression.accept(expressionVisitor, context));
        return null;
    }

    @Override
    public <S> T visit(CreateForeignDataWrapper statement, S context) {
        return visitForeignDataStatement(statement, context);
    }

    @Override
    public <S> T visit(AlterForeignDataWrapper statement, S context) {
        return visitForeignDataStatement(statement, context);
    }

    @Override
    public <S> T visit(CreateServer statement, S context) {
        return visitForeignDataStatement(statement, context);
    }

    @Override
    public <S> T visit(AlterServer statement, S context) {
        return visitForeignDataStatement(statement, context);
    }

    @Override
    public <S> T visit(CreateUserMapping statement, S context) {
        return visitForeignDataStatement(statement, context);
    }

    @Override
    public <S> T visit(AlterUserMapping statement, S context) {
        return visitForeignDataStatement(statement, context);
    }

    @Override
    public <S> T visit(DropUserMapping statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(CreateRule statement, S context) {
        statement.visitTables(table -> table.accept(fromItemVisitor, context));
        statement.visitExpressions(expression -> expression.accept(expressionVisitor, context));
        statement.getActions().forEach(action -> action.accept(this, context));
        return null;
    }

    @Override
    public <S> T visit(NotifyStatement statement, S context) {
        statement.visitExpressions(expression -> expression.accept(expressionVisitor, context));
        return null;
    }

    @Override
    public <S> T visit(ListenStatement listen, S context) {
        return null;
    }

    @Override
    public <S> T visit(DiscardStatement discard, S context) {
        return null;
    }

    @Override
    public <S> T visit(CreateCollation statement, S context) {
        statement.visitExpressions(expression -> expression.accept(expressionVisitor, context));
        return null;
    }

    @Override
    public <S> T visit(AlterRoutine statement, S context) {
        statement.visitExpressions(expression -> expression.accept(expressionVisitor, context));
        return null;
    }

    @Override
    public <S> T visit(AlterTrigger statement, S context) {
        fromItemVisitor.visitFromItem(statement.getTable(), context);
        return null;
    }


    @Override
    public <S> T visit(AlterRule statement, S context) {
        fromItemVisitor.visitFromItem(statement.getTable(), context);
        return null;
    }

    @Override
    public <S> T visit(CreateCast statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(CreateTransform statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(CreateConversion statement, S context) {
        return null;
    }

    @Override
    public <S> T visit(AlterConversion statement, S context) {
        return null;
    }
}