ShowBuildIndexCommand.java

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

package org.apache.doris.nereids.trees.plans.commands;

import org.apache.doris.analysis.LimitElement;
import org.apache.doris.analysis.RedirectStatus;
import org.apache.doris.catalog.Column;
import org.apache.doris.catalog.DatabaseIf;
import org.apache.doris.catalog.ScalarType;
import org.apache.doris.common.AnalysisException;
import org.apache.doris.common.Config;
import org.apache.doris.common.ErrorCode;
import org.apache.doris.common.ErrorReport;
import org.apache.doris.common.UserException;
import org.apache.doris.common.proc.BuildIndexProcDir;
import org.apache.doris.common.proc.ProcNodeInterface;
import org.apache.doris.common.proc.ProcService;
import org.apache.doris.common.util.OrderByPair;
import org.apache.doris.nereids.analyzer.UnboundSlot;
import org.apache.doris.nereids.properties.OrderKey;
import org.apache.doris.nereids.trees.expressions.And;
import org.apache.doris.nereids.trees.expressions.ComparisonPredicate;
import org.apache.doris.nereids.trees.expressions.CompoundPredicate;
import org.apache.doris.nereids.trees.expressions.EqualTo;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.Not;
import org.apache.doris.nereids.trees.expressions.literal.StringLikeLiteral;
import org.apache.doris.nereids.trees.plans.PlanType;
import org.apache.doris.nereids.trees.plans.visitor.PlanVisitor;
import org.apache.doris.nereids.types.DateTimeType;
import org.apache.doris.nereids.types.DateTimeV2Type;
import org.apache.doris.qe.ConnectContext;
import org.apache.doris.qe.ShowResultSet;
import org.apache.doris.qe.ShowResultSetMetaData;
import org.apache.doris.qe.StmtExecutor;

import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 * show build index command
 */
public class ShowBuildIndexCommand extends ShowCommand {
    public static final ImmutableList<String> TITLE_NAMES = new ImmutableList.Builder<String>()
            .add("JobId").add("TableName")
            .add("PartitionName").add("AlterInvertedIndexes")
            .add("CreateTime").add("FinishTime")
            .add("TransactionId").add("State")
            .add("Msg").add("Progress")
            .build();
    private static String TABLE_NAME = "tablename";
    private static String PARTITION_NAME = "partitionname";
    private static String STATE = "state";
    private static String CREATE_TIME = "createtime";
    private static String FINISH_TIME = "finishtime";
    private static final Logger LOG = LogManager.getLogger(ShowBuildIndexCommand.class);
    private String dbName;
    private final Expression wildWhere;
    private final long limit;
    private final long offset;
    private final List<OrderKey> orderKeys;
    private HashMap<String, Expression> filterMap;
    private ArrayList<OrderByPair> orderByPairs;
    private ProcNodeInterface node;

    /**
     * constructor for show build index
     */
    public ShowBuildIndexCommand(String dbName, Expression wildWhere,
                                     List<OrderKey> orderKeys, long limit, long offset) {
        super(PlanType.SHOW_BUILD_INDEX_COMMAND);
        this.dbName = dbName;
        this.wildWhere = wildWhere;
        this.orderKeys = orderKeys;
        this.limit = limit;
        this.offset = offset;
        this.filterMap = new HashMap<String, Expression>();
    }

    private void validate(ConnectContext ctx) throws UserException {
        if (Strings.isNullOrEmpty(dbName)) {
            dbName = ctx.getDatabase();
            if (Strings.isNullOrEmpty(dbName)) {
                ErrorReport.reportAnalysisException(ErrorCode.ERR_NO_DB_ERROR);
            }
        }

        analyzeSubPredicate(wildWhere);

        // then process the order by
        orderByPairs = getOrderByPairs(orderKeys, TITLE_NAMES);
    }

    private void analyzeSubPredicate(Expression subExpr) throws AnalysisException {
        if (subExpr == null) {
            return;
        }
        if (subExpr instanceof CompoundPredicate) {
            if (!(subExpr instanceof And)) {
                throw new AnalysisException("Only allow compound predicate with operator AND");
            }
            for (Expression child : subExpr.children()) {
                analyzeSubPredicate(child);
            }
            return;
        }

        boolean isNotExpr = false;
        if (subExpr instanceof Not) {
            isNotExpr = true;
            subExpr = subExpr.child(0);
            if (!(subExpr instanceof EqualTo)) {
                throw new AnalysisException("Only operator =|>=|<=|>|<|!=|like are supported.");
            }
        }

        getPredicateValue(subExpr, isNotExpr);
    }

    private void getPredicateValue(Expression subExpr, boolean isNotExpr) throws AnalysisException {
        if (!(subExpr instanceof ComparisonPredicate)) {
            throw new AnalysisException("The operator =|>=|<=|>|<|!= are supported.");
        }

        ComparisonPredicate binaryPredicate = (ComparisonPredicate) subExpr;
        if (!(subExpr.child(0) instanceof UnboundSlot)) {
            throw new AnalysisException("Only support column = xxx syntax.");
        }
        String leftKey = ((UnboundSlot) subExpr.child(0)).getName().toLowerCase();
        if (leftKey.equalsIgnoreCase(TABLE_NAME)
                || leftKey.equalsIgnoreCase(STATE)
                || leftKey.equalsIgnoreCase(PARTITION_NAME)) {
            if (!(subExpr.child(1) instanceof StringLikeLiteral) || !(binaryPredicate instanceof EqualTo)) {
                throw new AnalysisException("Where clause : TableName = \"table1\" or "
                        + "State = \"FINISHED|CANCELLED|RUNNING|PENDING|WAITING_TXN\"");
            }
        } else if (leftKey.equalsIgnoreCase(CREATE_TIME) || leftKey.equalsIgnoreCase(FINISH_TIME)) {
            if (!(subExpr.child(1) instanceof StringLikeLiteral)) {
                throw new AnalysisException("Where clause : CreateTime/FinishTime =|>=|<=|>|<|!= "
                        + "\"2019-12-02|2019-12-02 14:54:00\"");
            }
            Expression left = subExpr.child(0);
            Expression right = subExpr.child(1).castTo(Config.enable_date_conversion
                    ? DateTimeV2Type.MAX : DateTimeType.INSTANCE);
            subExpr = subExpr.withChildren(left, right);
        } else {
            throw new AnalysisException(
                    "The columns of TableName/PartitionName/CreateTime/FinishTime/State are supported.");
        }
        filterMap.put(leftKey.toLowerCase(), isNotExpr ? new Not(subExpr) : subExpr);
    }

    private void analyze(ConnectContext ctx) throws UserException {
        DatabaseIf db = ctx.getCurrentCatalog().getDbOrAnalysisException(dbName);
        // build proc path
        StringBuilder sb = new StringBuilder();
        sb.append("/jobs/");
        sb.append(db.getId());
        sb.append("/build_index");

        if (LOG.isDebugEnabled()) {
            LOG.debug("process SHOW PROC '{}';", sb.toString());
        }
        // create show proc stmt
        // '/jobs/db_name/build_index/
        node = ProcService.getInstance().open(sb.toString());
        if (node == null) {
            throw new AnalysisException("Failed to show build index");
        }
    }

    @VisibleForTesting
    protected ShowResultSet handleShowBuildIndex(ConnectContext ctx, StmtExecutor executor) throws Exception {
        // first validate the where
        validate(ctx);

        // then analyze
        analyze(ctx);

        Preconditions.checkNotNull(node);
        LimitElement limitElement = null;
        if (limit > 0) {
            limitElement = new LimitElement(offset == -1L ? 0 : offset, limit);
        }

        List<List<String>> rows = ((BuildIndexProcDir) node).fetchResultByFilterExpression(
                filterMap, orderByPairs, limitElement).getRows();
        return new ShowResultSet(getMetaData(), rows);
    }

    @Override
    public ShowResultSet doRun(ConnectContext ctx, StmtExecutor executor) throws Exception {
        return handleShowBuildIndex(ctx, executor);
    }

    @Override
    public ShowResultSetMetaData getMetaData() {
        ShowResultSetMetaData.Builder builder = ShowResultSetMetaData.builder();
        for (String title : TITLE_NAMES) {
            builder.addColumn(new Column(title, ScalarType.createVarchar(128)));
        }
        return builder.build();
    }

    @Override
    public RedirectStatus toRedirectStatus() {
        if (ConnectContext.get().getSessionVariable().getForwardToMaster()) {
            return RedirectStatus.FORWARD_NO_SYNC;
        } else {
            return RedirectStatus.NO_FORWARD;
        }
    }

    @Override
    public <R, C> R accept(PlanVisitor<R, C> visitor, C context) {
        return visitor.visitShowBuildIndexCommand(this, context);
    }
}