SelectVisitorAdapter.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.select;

import net.sf.jsqlparser.expression.ExpressionVisitor;
import net.sf.jsqlparser.expression.ExpressionVisitorAdapter;
import net.sf.jsqlparser.expression.Function;
import net.sf.jsqlparser.statement.OutputClause;
import net.sf.jsqlparser.statement.ParenthesedStatement;
import net.sf.jsqlparser.statement.Statement;
import net.sf.jsqlparser.statement.StatementVisitor;
import net.sf.jsqlparser.statement.piped.FromQuery;

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

    /**
     * Optional, and only needed for data-modifying CTEs - see {@link #visit(WithItem, Object)}. A
     * plain SelectVisitor cannot accept an INSERT/UPDATE/DELETE body; without this the CTE is
     * skipped rather than traversed. {@link net.sf.jsqlparser.statement.StatementVisitorAdapter}
     * sets it automatically.
     */
    private StatementVisitor<T> statementVisitor;

    public SelectVisitorAdapter() {
        this.expressionVisitor = new ExpressionVisitorAdapter<>(this);
        this.pivotVisitor = new PivotVisitorAdapter<>(this.expressionVisitor);
        this.selectItemVisitor = new SelectItemVisitorAdapter<>(this.expressionVisitor);
        this.fromItemVisitor = new FromItemVisitorAdapter<>(this, this.expressionVisitor);
    }

    public SelectVisitorAdapter(ExpressionVisitor<T> expressionVisitor,
            PivotVisitor<T> pivotVisitor, SelectItemVisitor<T> selectItemVisitor,
            FromItemVisitor<T> fromItemVisitor) {
        this.expressionVisitor = expressionVisitor;
        this.pivotVisitor = pivotVisitor;
        this.selectItemVisitor = selectItemVisitor;
        this.fromItemVisitor = fromItemVisitor;
    }

    public SelectVisitorAdapter(ExpressionVisitor<T> expressionVisitor,
            FromItemVisitor<T> fromItemVisitor) {
        this.expressionVisitor = expressionVisitor;
        this.pivotVisitor = new PivotVisitorAdapter<>();
        this.selectItemVisitor = new SelectItemVisitorAdapter<>(this.expressionVisitor);
        this.fromItemVisitor = fromItemVisitor;
    }

    public SelectVisitorAdapter(ExpressionVisitor<T> expressionVisitor) {
        this.expressionVisitor = expressionVisitor;
        this.pivotVisitor = new PivotVisitorAdapter<>();
        this.selectItemVisitor = new SelectItemVisitorAdapter<>(this.expressionVisitor);
        this.fromItemVisitor = new FromItemVisitorAdapter<>();
    }

    @Override
    public <S> T visitOutputClause(OutputClause outputClause, S context) {
        if (outputClause != null) {
            if (outputClause.getSelectItemList() != null) {
                for (SelectItem<?> selectItem : outputClause.getSelectItemList()) {
                    selectItem.accept(selectItemVisitor, context);
                }
            }
            if (outputClause.getTableVariable() != null) {
                outputClause.getTableVariable().accept(expressionVisitor, context);
            }
            if (outputClause.getOutputTable() != null) {
                outputClause.getOutputTable().accept(fromItemVisitor, context);
            }
            // @todo: check why this is a list of strings
            // if (outputClause.getColumnList()!=null) {
            // for (Column column:outputClause.getColumnList())
            // }
        }
        return null;
    }

    public ExpressionVisitor<T> getExpressionVisitor() {
        return expressionVisitor;
    }

    public PivotVisitor<T> getPivotVisitor() {
        return pivotVisitor;
    }

    public SelectItemVisitor<T> getSelectItemVisitor() {
        return selectItemVisitor;
    }

    public FromItemVisitor<T> getFromItemVisitor() {
        return fromItemVisitor;
    }

    public StatementVisitor<T> getStatementVisitor() {
        return statementVisitor;
    }

    public SelectVisitorAdapter<T> setStatementVisitor(StatementVisitor<T> statementVisitor) {
        this.statementVisitor = statementVisitor;
        return this;
    }

    @Override
    public <S> T visit(ParenthesedSelect select, S context) {
        visitWithItems(select.withItemsList, context);

        select.getSelect().accept(this, context);

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

        Pivot pivot = select.getPivot();
        if (pivot != null) {
            pivot.accept(pivotVisitor, context);
        }
        UnPivot unpivot = select.getUnPivot();
        if (unpivot != null) {
            unpivot.accept(pivotVisitor, context);
        }

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

        if (select.getOffset() != null) {
            expressionVisitor.visitExpression(select.getOffset().getOffset(), null);
        }
        if (select.getFetch() != null) {
            expressionVisitor.visitExpression(select.getFetch().getExpression(), null);
        }

        return null;
    }

    @Override
    @SuppressWarnings({"PMD.ExcessiveMethodLength"})
    public <S> T visit(PlainSelect plainSelect, S context) {
        visitWithItems(plainSelect.withItemsList, context);

        if (plainSelect.getDistinct() != null) {
            for (SelectItem<?> selectItem : plainSelect.getDistinct().getOnSelectItems()) {
                selectItem.accept(selectItemVisitor, context);
            }
        }

        if (plainSelect.getTop() != null) {
            plainSelect.getTop().getExpression().accept(expressionVisitor, context);
        }

        for (SelectItem<?> selectItem : plainSelect.getSelectItems()) {
            selectItem.accept(selectItemVisitor, context);
        }

        if (plainSelect.getMySqlSelectIntoClause() != null) {
            MySqlSelectIntoClause mySqlSelectIntoClause = plainSelect.getMySqlSelectIntoClause();
            expressionVisitor.visitExpression(mySqlSelectIntoClause.getFileName(), context);
            expressionVisitor.visitExpression(mySqlSelectIntoClause.getFieldsTerminatedBy(),
                    context);
            expressionVisitor.visitExpression(mySqlSelectIntoClause.getFieldsEnclosedBy(), context);
            expressionVisitor.visitExpression(mySqlSelectIntoClause.getFieldsEscapedBy(), context);
            expressionVisitor.visitExpression(mySqlSelectIntoClause.getLinesStartingBy(), context);
            expressionVisitor.visitExpression(mySqlSelectIntoClause.getLinesTerminatedBy(),
                    context);
        }

        fromItemVisitor.visitTables(plainSelect.getIntoTables(), context);
        fromItemVisitor.visitFromItem(plainSelect.getFromItem(), context);

        // if (plainSelect.getLateralViews() != null) {
        // //@todo: implement this
        // }

        fromItemVisitor.visitJoins(plainSelect.getJoins(), context);

        // if (plainSelect.getKsqlWindow() != null) {
        // //@todo: implement
        // }

        expressionVisitor.visitExpression(plainSelect.getPreWhere(), context);
        expressionVisitor.visitExpression(plainSelect.getWhere(), context);

        // if (plainSelect.getOracleHierarchical() != null) {
        // //@todo: implement
        // }
        //

        expressionVisitor.visitPreferringClause(plainSelect.getPreferringClause(), context);
        expressionVisitor.visit(plainSelect.getGroupBy(), context);
        expressionVisitor.visitExpression(plainSelect.getHaving(), context);
        expressionVisitor.visitExpression(plainSelect.getQualify(), context);

        // if (plainSelect.getWindowDefinitions() != null) {
        // //@todo: implement
        // }

        Pivot pivot = plainSelect.getPivot();
        if (pivot != null) {
            pivot.accept(pivotVisitor, context);
        }
        UnPivot unpivot = plainSelect.getUnPivot();
        if (unpivot != null) {
            unpivot.accept(pivotVisitor, context);
        }

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

        // if (plainSelect.getLimitBy() != null) {
        // //@todo: implement
        // }
        // if (plainSelect.getLimit() != null) {
        // //@todo: implement
        // }
        if (plainSelect.getOffset() != null) {
            expressionVisitor.visitExpression(plainSelect.getOffset().getOffset(), context);
        }
        if (plainSelect.getMySqlProcedureAnalyse() != null) {
            expressionVisitor.visitExpression(
                    plainSelect.getMySqlProcedureAnalyse().getMaxElements(), context);
            expressionVisitor.visitExpression(
                    plainSelect.getMySqlProcedureAnalyse().getMaxMemory(), context);
        }
        if (plainSelect.getFetch() != null) {
            expressionVisitor.visitExpression(plainSelect.getFetch().getExpression(), context);
        }
        // if (plainSelect.getForMode() != null) {
        // //@todo: implement
        // }

        fromItemVisitor.visitFromItem(plainSelect.getIntoTempTable(), context);
        return null;
    }

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

        fromItemVisitor.visitFromItem(pivotQuery.getFromItem(), context);
        expressionVisitor.visitExpressions(pivotQuery.getOnExpressions(), context);

        if (pivotQuery.getUsingItems() != null) {
            for (SelectItem<Function> item : pivotQuery.getUsingItems()) {
                item.accept(selectItemVisitor, context);
            }
        }

        expressionVisitor.visitExpressions(pivotQuery.getGroupByExpressions(), context);
        expressionVisitor.visitOrderBy(pivotQuery.getOrderByElements(), context);
        expressionVisitor.visitLimit(pivotQuery.getLimit(), context);

        if (pivotQuery.getOffset() != null) {
            expressionVisitor.visitExpression(pivotQuery.getOffset().getOffset(), context);
        }
        if (pivotQuery.getFetch() != null) {
            expressionVisitor.visitExpression(pivotQuery.getFetch().getExpression(), context);
        }
        return null;
    }

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

    @Override
    public <S> T visit(SetOperationList setOpList, S context) {
        for (Select select : setOpList.getSelects()) {
            select.accept(this, context);
        }
        return null;
    }

    /**
     * A CTE body is a {@link ParenthesedStatement}, which is not necessarily a SELECT: PostgreSQL
     * and others allow {@code WITH c AS (DELETE FROM t RETURNING *) SELECT * FROM c}.
     *
     * <p>
     * The previous implementation called {@code withItem.getSelect()}, an unchecked cast to
     * {@link ParenthesedSelect}, and threw {@link ClassCastException} on every data-modifying CTE
     * reached through the select path - which {@code ExpressionVisitorAdapter#visit(Select)} does
     * for any sub-select. {@code WithItem#accept(StatementVisitor)} has always dispatched correctly
     * through {@code getParenthesedStatement()}; only this path did not.
     */
    @Override
    public <S> T visit(WithItem<?> withItem, S context) {
        if (withItem.getCycleClause() != null) {
            withItem.getCycleClause().accept(expressionVisitor, context);
        }
        ParenthesedStatement body = withItem.getParenthesedStatement();

        // ParenthesedSelect is a Select and stays on the select path
        if (body instanceof Select) {
            return ((Select) body).accept(this, context);
        }

        // ParenthesedInsert / ParenthesedUpdate / ParenthesedDelete need a StatementVisitor
        if (statementVisitor != null && body instanceof Statement) {
            return ((Statement) body).accept(statementVisitor, context);
        }

        // no statement visitor available: skip the body rather than fail
        return null;
    }

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

    @Override
    public <S> T visit(LateralSubSelect lateralSubSelect, S context) {
        return lateralSubSelect.getSelect().accept(this, context);
    }

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