Starrocks中的 Query Profile以及explain analyze及trace命令中的区别

第7.1章:StarRocks性能调优——查询分析 阅读详情

背景

本文基于Starrocks 3.5.5
现有公司因为业务的不同,可能会更加关系单个SQL 的RT,因为如果一个SQL的RT比较大的话,影响的就是这个业务,从而影响收入,所以对于这方面我们就比较关心,
而最近在基于Starrocks做计算存储引擎的时候,遇到了一些问题。时间上超过了2秒,因此需要分析一下对应SQL的指标。
最直接的就是开启 Query Profile,比如说做一下配置:

SET enable_profile = true;
SET global big_query_profile_threshold = '1s';
SET runtime_profile_report_interval = 30;

这个在对应的UI界面(http://<fe_ip>:<fe_http_port>)就能看到Profile
当然还有ANALYZE PROFILE,explain analyze和trace命令,这里就来分析一下三者的差别, 其中以以下SQL为例:

SELECT `SCHEMA_NAME` FROM `INFORMATION_SCHEMA`.`SCHEMATA` WHERE SCHEMA_NAME = 'fin_config';

结论

  1. 开启Query Profile会得得到更多的明细信息,以及每个阶段所用的耗时,适合对该SQL的每个算子的各个指标全方位的分析
    此种方法会有BE端的信息更新过来,但是这个信息只存在内存,FE重启之后就不复存在。
  2. EXPLAIN ANALYZE 展示的是大概的查询执行计划执行信息,比如说 Summary和fragement
  3. ANALYZE PROFILE 展示的和explain analyze一样,但是指标比 explain analyze 更加丰富
  4. trace 展示的是某个局部指标,比如说 某个规则的耗时

对于每个方法所对应指标信息如下见下面的 其他

分析

开启Query Profile

通过访问http://<fe_ip>:<fe_http_port>/query_profile?query_id可以获取到对应的profile,
对应到Fe端是QueryProfileAction类接受请求:
QueryProfileAction 里有对应的 “/query_profile” Get请求

对应的Get方法response为executeGet方法:

String queryProfileStr = ProfileManager.getInstance().getProfile(queryId);
        if (queryProfileStr != null) {
            appendCopyButton(response.getContent());
            appendQueryProfile(response.getContent(), queryProfileStr);
            getPageFooter(response.getContent());
            writeResponse(request, response);

这里ProfileManager.getInstance().getProfile(queryId)会获取对应的 Profile.

runtimeProfile数据流

FrontendServiceImpl.reportExecStatus
    ||
    \/
DefaultCoordinator.updateFragmentExecStatus(params)
    ||
    \/
QueryRuntimeProfile.updateProfile(execState, params) // 这里会 runtime_profile_report_interval 判断
    ||
    \/
saveRunningProfile
    ||
    \/
ProfileManager.pushProfile(profilingPlan, profile);

这里会把 BE端 Fragment 实力的 运行指标都给返回给 FE端.

EXPLAIN ANALYZE

具体语法参考Simulate a query for Profile Analysis Using EXPLAIN ANALYZE
直接转到StarRocks.g4

queryStatement
    : (explainDesc | optimizerTrace) ? queryRelation outfile?;
...
explainDesc
    : (DESC | DESCRIBE | EXPLAIN) (LOGICAL | ANALYZE | VERBOSE | COSTS | SCHEDULER)?
    ;
...
optimizerTrace
    : TRACE (ALL | LOGS | TIMES | VALUES | REASON) identifier?
    ;

通过AstBuilder.visitQueryStatement 解析完后:

@Override
public ParseNode visitQueryStatement(StarRocksParser.QueryStatementContext context) {
    QueryRelation queryRelation = (QueryRelation) visit(context.queryRelation());
    QueryStatement queryStatement = new QueryStatement(queryRelation);
    if (context.outfile() != null) {
        queryStatement.setOutFileClause((OutFileClause) visit(context.outfile()));
    }

    if (context.explainDesc() != null) {
        queryStatement.setIsExplain(true, getExplainType(context.explainDesc()));
    }

    if (context.optimizerTrace() != null) {
        String module = "base";
        if (context.optimizerTrace().identifier() != null) {
            module = ((Identifier) visit(context.optimizerTrace().identifier())).getValue();
        }
        queryStatement.setIsTrace(getTraceMode(context.optimizerTrace()), module);
    }

    return queryStatement;
}

可以看到queryStatement.setIsExplain(true, getExplainType(context.explainDesc()))这个方法:

  public void setIsExplain(boolean isExplain, ExplainLevel explainLevel) {
        this.isExplain = isExplain;
        this.explainLevel = explainLevel;
    }

会把isExplain设置为true,
之后数据流会转到StmtExecutor.execute方法,最终会调用handleQueryStmt方法:

private void handleQueryStmt(ExecPlan execPlan) throws Exception {
        // Every time set no send flag and clean all data in buffer
        context.getMysqlChannel().reset();

        boolean isExplainAnalyze = parsedStmt.isExplain()
                && StatementBase.ExplainLevel.ANALYZE.equals(parsedStmt.getExplainLevel());
        boolean isSchedulerExplain = parsedStmt.isExplain()
                && StatementBase.ExplainLevel.SCHEDULER.equals(parsedStmt.getExplainLevel());
        boolean isOutfileQuery = (parsedStmt instanceof QueryStatement) && ((QueryStatement) parsedStmt).hasOutFileClause();
        if (isOutfileQuery) {
            Map<TableName, Table> tables = AnalyzerUtils.collectAllTable(parsedStmt);
            boolean hasTemporaryTable = tables.values().stream().anyMatch(t -> t.isTemporaryTable());
            if (hasTemporaryTable) {
                throw new SemanticException("temporary table doesn't support select outfile statement");
            }
        }
        boolean executeInFe = !isExplainAnalyze && !isSchedulerExplain && !isOutfileQuery
                && canExecuteInFe(context, execPlan.getPhysicalPlan());

        if (isExplainAnalyze) {
            context.getSessionVariable().setEnableProfile(true);
            context.getSessionVariable().setEnableAsyncProfile(false);
            context.getSessionVariable().setPipelineProfileLevel(1);
        } else if (isSchedulerExplain) {
            // Do nothing.
        } else if (parsedStmt.isExplain()) {
            String explainString = buildExplainString(execPlan, ResourceGroupClassifier.QueryType.SELECT,
                    parsedStmt.getExplainLevel());
            if (executeInFe) {
                explainString = "EXECUTE IN FE\n" + explainString;
            }
            handleExplainStmt(explainString);
            return;
        }
        ... 

        StatementBase queryStmt = parsedStmt;
        List<PlanFragment> fragments = execPlan.getFragments();
        List<ScanNode> scanNodes = execPlan.getScanNodes();
        TDescriptorTable descTable = execPlan.getDescTbl().toThrift();
        List<String> colNames = execPlan.getColNames();
        List<Expr> outputExprs = execPlan.getOutputExprs();

        if (executeInFe) {
            coord = new FeExecuteCoordinator(context, execPlan);
        } else {
            coord = getCoordinatorFactory().createQueryScheduler(context, fragments, scanNodes, descTable);
        }

        QeProcessorImpl.INSTANCE.registerQuery(context.getExecutionId(),
                new QeProcessorImpl.QueryInfo(context, originStmt.originStmt, coord));

        if (isSchedulerExplain) {
            coord.startSchedulingWithoutDeploy();
            handleExplainStmt(coord.getSchedulerExplain());
            return;
        }

        coord.exec();
        coord.setTopProfileSupplier(this::buildTopLevelProfile);
        coord.setExecPlan(execPlan);

对于 explain analyze 会进行如下配置:

 context.getSessionVariable().setEnableProfile(true);
 context.getSessionVariable().setEnableAsyncProfile(false);
 context.getSessionVariable().setPipelineProfileLevel(1);

且会走到 coord.exec();这里会有调度的部分,如以下:

 try (Timer timer = Tracers.watchScope(Tracers.Module.SCHEDULER, "Prepare")) {
            prepareExec();
        }

 try (Timer timer = Tracers.watchScope(Tracers.Module.SCHEDULER, "Deploy")) {
     deliverExecFragments(needDeploy);
 }

而在handleQueryStmt下后有finally的处理:

 else if (context.isProfileEnabled()) {
    isAsync = tryProcessProfileAsync(execPlan, i);
    if (parsedStmt.isExplain() &&
            StatementBase.ExplainLevel.ANALYZE.equals(parsedStmt.getExplainLevel())) {
        if (coord != null && coord.isShortCircuit()) {
            throw new UserException(
                    "short circuit point query doesn't suppot explain analyze stmt, " +
                            "you can set it off by using  set enable_short_circuit=false");
        }
        handleExplainStmt(ExplainAnalyzer.analyze(
                ProfilingExecPlan.buildFrom(execPlan), profile, null));
    }
 }

ExplainAnalyzer.analyze这里就是返回的Explain String

ANALYZE PROFILE

直接跳转到Starrocks.g4:

analyzeProfileStatement
    : ANALYZE PROFILE FROM string
    | ANALYZE PROFILE FROM string ',' INTEGER_VALUE (',' INTEGER_VALUE)*
    ;

之后到AstBuilder的如下方法:

@Override
public ParseNode visitAnalyzeProfileStatement(StarRocksParser.AnalyzeProfileStatementContext context) {
    StringLiteral stringLiteral = (StringLiteral) visit(context.string());
    List<Integer> planNodeIds = Lists.newArrayList();
    if (context.INTEGER_VALUE() != null) {
        planNodeIds = context.INTEGER_VALUE().stream()
                .map(ParseTree::getText)
                .map(Integer::parseInt)
                .collect(toList());
    }
    return new AnalyzeProfileStmt(stringLiteral.getStringValue(), planNodeIds, createPos(context));
}

之后再到StmtExecutor.handleAnalyzeProfileStmt方法:

private void handleAnalyzeProfileStmt() throws IOException, UserException {
        AnalyzeProfileStmt analyzeProfileStmt = (AnalyzeProfileStmt) parsedStmt;
        String queryId = analyzeProfileStmt.getQueryId();
        List<Integer> planNodeIds = analyzeProfileStmt.getPlanNodeIds();
        ProfileManager.ProfileElement profileElement = ProfileManager.getInstance().getProfileElement(queryId);
        Preconditions.checkNotNull(profileElement, "query not exists");
        // For short circuit query, 'ProfileElement#plan' is null
        if (profileElement.plan == null) {
            throw new UserException(
                    "short circuit point query doesn't suppot analyze profile stmt, " +
                            "you can set it off by using  set enable_short_circuit=false");
        }
        handleExplainStmt(ExplainAnalyzer.analyze(profileElement.plan,
                RuntimeProfileParser.parseFrom(CompressionUtils.gzipDecompressString(profileElement.profileContent)),
                planNodeIds));
    }

这里通过ProfileManager.getInstance().getProfileElement(queryId)获取到对应的profile,
之后再通过ExplainAnalyzer.analyze获取对应的explain string.

TRACE

具体语法参考query_trace_profile
和 EXPLAIN ANALYZE的逻辑一样,通过AstBuilder.visitQueryStatement 解析完后,走的是queryStatement.setIsTrace(getTraceMode(context.optimizerTrace()), module);这个逻辑:

 public void setIsTrace(Tracers.Mode mode, String module) {
        this.isExplain = true;
        this.traceMode = mode;
        this.traceModule = module;
    }

可以看到这里的isExplain为true.
而handleQueryStmt方法为:

} else if (parsedStmt.isExplain()) {
    String explainString = buildExplainString(execPlan, ResourceGroupClassifier.QueryType.SELECT,
            parsedStmt.getExplainLevel());
    if (executeInFe) {
        explainString = "EXECUTE IN FE\n" + explainString;
    }
    handleExplainStmt(explainString);
    return;
}

这里的buildExplainString方法,会根据trace的mode来进行explain String的构建。

其他

  1. 开启Query Profile 指标

| Query:
  Summary:
     - Query ID: 135d8852-62fd-11f0-b356-00163e164034
     - Start Time: 2025-07-17 18:59:13
     - End Time: 2025-07-17 18:59:14
     - Total: 268ms
     - Query Type: Query
     - Query State: Finished
     - StarRocks Version: 3.3.5-6d81f75
     - User: sr_read_write
     - Default Db
     - Sql Statement: SELECT `COLUMN_NAME`, `DATA_TYPE`, `ORDINAL_POSITION`, `COLUMN_SIZE`, `DECIMAL_DIGITS`, `IS_NULLABLE`, `COLUMN_KEY`, `COLUMN_COMMENT` FROM `information_schema`.`COLUMNS` WHERE `TABLE_SCHEMA`='lendtrade' AND `TABLE_NAME`='tr_tran_proc_db_sub';
     - Variables: parallel_fragment_exec_instance_num=8,max_parallel_scan_instance_num=-1,pipeline_dop=0,enable_adaptive_sink_dop=true,enable_runtime_adaptive_dop=false,runtime_profile_report_interval=10,resource_group=default_wg
     - NonDefaultSessionVariables: {"sql_mode_v2":{"defaultValue":32,"actualValue":2097184},"big_query_profile_threshold":{"defaultValue":"0s","actualValue":"30s"},"character_set_results":{"defaultValue":"utf8","actualValue":"NULL"},"parallel_fragment_exec_instance_num":{"defaultValue":1,"actualValue":8},"enable_adaptive_sink_dop":{"defaultValue":false,"actualValue":true},"enable_profile":{"defaultValue":false,"actualValue":true}}
     - Collect Profile Time: 2ms
     - IsProfileAsync: true
  Planner:
     - -- Parser[1] 0
     - -- Total[1] 0
     -     -- Analyzer[1] 0
     -         -- Lock[1] 0
     -         -- AnalyzeDatabase[1] 0
     -         -- AnalyzeTemporaryTable[1] 0
     -         -- AnalyzeTable[1] 0
     -     -- Transformer[1] 0
     -     -- Optimizer[1] 0
     -         -- MVPreprocess[1] 0
     -             -- MVChooseCandidates[1] 0
     -             -- MVGenerateMvPlan[1] 0
     -             -- MVValidateMv[1] 0
     -             -- MVProcessWithView[1] 0
     -         -- MVTextRewrite[1] 0
     -         -- RuleBaseOptimize[1] 0
     -         -- CostBaseOptimize[1] 0
     -         -- PhysicalRewrite[1] 0
     -         -- PlanValidate[1] 0
     -             -- InputDependenciesChecker[1] 0
     -             -- TypeChecker[1] 0
     -             -- CTEUniqueChecker[1] 0
     -             -- ColumnReuseChecker[1] 0
     -     -- ExecPlanBuild[1] 0
     - -- Pending[1] 0
     - -- Prepare[1] 0
     - -- Deploy[1] 23ms
     -     -- DeployLockInternalTime[1] 23ms
     -         -- DeploySerializeConcurrencyTime[1] 0
     -         -- DeployStageByStageTime[3] 0
     -         -- DeployWaitTime[3] 23ms
     -             -- DeployAsyncSendTime[1] 0
     - DeployDataSize: 5803
    Reason:
  Execution:
     - Topology: {"rootId":1,"nodes":[{"id":1,"name":"PROJECT","properties":{"sinkIds":[],"displayMem":false},"children":[0]},{"id":0,"name":"SCHEMA_SCAN","properties":{"displayMem":false},"children":[]}]}
     - FrontendProfileMergeTime: 732.454us
     - QueryAllocatedMemoryUsage: 1015.680 KB
     - QueryCumulativeCpuTime: 11.169ms
     - QueryCumulativeNetworkTime: 0ns
     - QueryCumulativeOperatorTime: 240.565ms
     - QueryCumulativeScanTime: 229.352ms
     - QueryDeallocatedMemoryUsage: 840.773 KB
     - QueryExecutionWallTime: 257.617ms
     - QueryPeakMemoryUsagePerNode: 485.695 KB
     - QueryPeakScheduleTime: 42.480us
     - QuerySpillBytes: 0.000 B
     - QuerySumMemoryUsage: 485.695 KB
     - ResultDeliverTime: 0ns
    Fragment 0:
       - BackendAddresses: 172.17.172.252:9060
       - InstanceIds: 135d8852-62fd-11f0-b356-00163e164035
       - BackendNum: 1
       - BackendProfileMergeTime: 541.804us
       - FragmentInstancePrepareTime: 16.399ms
         - prepare-fragment-ctx: 922ns
         - prepare-pipeline-driver: 3.447ms
         - prepare-pipeline-driver-factory: 8.697ms
         - prepare-query-ctx: 3.826us
         - prepare-runtime-state: 4.247ms
       - InitialProcessDriverCount: 0
       - InitialProcessMem: 15.307 GB
       - InstanceAllocatedMemoryUsage: 1015.680 KB
       - InstanceDeallocatedMemoryUsage: 840.773 KB
       - InstanceNum: 1
       - InstancePeakMemoryUsage: 478.039 KB
       - JITCounter: 0
       - JITTotalCostTime: 0ns
       - QueryMemoryLimit: -1.000 B
      Pipeline (id=0):
         - isGroupExecution: false
         - ActiveTime: 11.183ms
         - BlockByInputEmpty: 2
         - BlockByOutputFull: 0
         - BlockByPrecondition: 0
         - DegreeOfParallelism: 1
         - DriverPrepareTime: 3.445ms
         - DriverTotalTime: 240.546ms
         - OverheadTime: 0ns
         - PeakDriverQueueSize: 0
         - PendingTime: 229.320ms
           - InputEmptyTime: 229.323ms
             - FirstInputEmptyTime: 229.245ms
             - FollowupInputEmptyTime: 78.368us
           - OutputFullTime: 0ns
           - PendingFinishTime: 0ns
           - PreconditionBlockTime: 0ns
         - ScheduleCount: 3
         - ScheduleTime: 42.480us
         - TotalDegreeOfParallelism: 1
         - YieldByLocalWait: 0
         - YieldByPreempt: 0
         - YieldByTimeLimit: 0
        RESULT_SINK (plan_node_id=-1):
          CommonMetrics:
             - IsFinalSink
             - CloseTime: 7.404us
             - OperatorAllocatedMemoryUsage: 19.320 KB
             - OperatorDeallocatedMemoryUsage: 20.281 KB
             - OperatorPeakMemoryUsage: 0.000 B
             - OperatorTotalTime: 5.905ms
             - PrepareTime: 3.384ms
             - PullChunkNum: 0
             - PullRowNum: 0
             - PullTotalTime: 0ns
             - PushChunkNum: 1
             - PushRowNum: 38
             - PushTotalTime: 5.897ms
             - SetFinishedTime: 30ns
             - SetFinishingTime: 60ns
          UniqueMetrics:
            result sink:
               - AppendChunkTime: 5.859ms
                 - ResultRendTime: 33.463us
                 - TupleConvertTime: 5.856ms
               - NumSentRows: 38
        CHUNK_ACCUMULATE (plan_node_id=-1):
          CommonMetrics:
             - IsSubordinate
             - CloseTime: 161ns
             - OperatorTotalTime: 1.133us
             - PrepareTime: 5.921us
             - PullChunkNum: 1
             - PullRowNum: 38
             - PullTotalTime: 280ns
             - PushChunkNum: 1
             - PushRowNum: 38
             - PushTotalTime: 613ns
             - SetFinishedTime: 50ns
             - SetFinishingTime: 29ns
          UniqueMetrics:
        PROJECT (plan_node_id=1):
          CommonMetrics:
             - CloseTime: 5.650us
             - OperatorAllocatedMemoryUsage: 1.016 KB
             - OperatorDeallocatedMemoryUsage: 416.000 B
             - OperatorPeakMemoryUsage: 640.000 B
             - OperatorTotalTime: 12.503us
             - PrepareTime: 7.204us
             - PullChunkNum: 1
             - PullRowNum: 38
             - PullTotalTime: 230ns
             - PushChunkNum: 1
             - PushRowNum: 38
             - PushTotalTime: 6.351us
             - RuntimeBloomFilterNum: 0
             - RuntimeInFilterNum: 0
             - SetFinishedTime: 141ns
             - SetFinishingTime: 131ns
          UniqueMetrics:
             - CommonSubExprComputeTime: 251ns
             - ExprComputeTime: 2.494us
        CHUNK_ACCUMULATE (plan_node_id=0):
          CommonMetrics:
             - IsSubordinate
             - CloseTime: 301ns
             - OperatorTotalTime: 2.636us
             - PrepareTime: 11.191us
             - PullChunkNum: 1
             - PullRowNum: 38
             - PullTotalTime: 191ns
             - PushChunkNum: 1
             - PushRowNum: 38
             - PushTotalTime: 1.823us
             - SetFinishedTime: 161ns
             - SetFinishingTime: 160ns
          UniqueMetrics:
        SCHEMA_SCAN (plan_node_id=0):
          CommonMetrics:
             - CloseTime: 64.822us
             - OperatorAllocatedMemoryUsage: 839.242 KB
             - OperatorDeallocatedMemoryUsage: 552.344 KB
             - OperatorPeakMemoryUsage: 307.672 KB
             - OperatorTotalTime: 5.292ms
             - PrepareTime: 16.070us
             - PullChunkNum: 1
             - PullRowNum: 38
             - PullTotalTime: 5.226ms
             - PushChunkNum: 0
             - PushRowNum: 0
             - PushTotalTime: 0ns
             - SetFinishedTime: 231ns
             - SetFinishingTime: 521ns
          UniqueMetrics:
             - MorselQueueType: fixed_morsel_queue
             - ChunkBufferCapacity: 64
             - DefaultChunkBufferCapacity: 64
             - FERPC: 211.509ms
             - FillChunk: 4.506ms
             - FilterTime: 12.890ms
             - IOTaskExecTime: 229.309ms
             - IOTaskWaitTime: 42.740us
             - MorselsCount: 1
             - PeakChunkBufferMemoryUsage: 250.513 KB
             - PeakChunkBufferSize: 1
             - PeakIOTasks: 1
             - PeakScanTaskQueueSize: 0
             - PrepareChunkSourceTime: 5.204ms
             - ScanTime: 229.352ms
             - SubmitTaskCount: 2
             - SubmitTaskTime: 8.015us
             - TabletCount: 1
 |
  1. EXPLAIN ANALYZE
+-------------------------------------------------------------------------------------------------------------------------------------+
| Explain String                                                                                                                      |
+-------------------------------------------------------------------------------------------------------------------------------------+
| Summary                                                                                                                     |
|     QueryId: 6b148971-71e6-11f0-8cea-00163e39052a                                                                           |
|     Version: 3.3.5-6d81f75                                                                                                  |
|     State: Finished                                                                                                         |
|     TotalTime: 2s51ms                                                                                                       |
|         ExecutionTime: 0ns [Scan: 0ns (NaN%), Network: 0ns (NaN%), ResultDeliverTime: 0ns (NaN%), ScheduleTime: 0ns (NaN%)] |
|         CollectProfileTime: 2s1ms                                                                                           |
|         FrontendProfileMergeTime: 361.325us                                                                                 |
|     QueryPeakMemoryUsage: ?, QueryAllocatedMemoryUsage: 0.000 B                                                             |
|     Top Most Time-consuming Nodes:                                                                                          |
|         1. RESULT_SINK: 0ns (NaN%)                                                                                          |
|         2. SCHEMA_SCAN (id=0) : 0ns (NaN%)                                                                                  |
|     Top Most Memory-consuming Nodes:                                                                                        |
|     NonDefaultVariables:                                                                                                    |
|         big_query_profile_threshold: 0s -> 30s                                                                              |
|         enable_adaptive_sink_dop: false -> true                                                                             |
|         enable_async_profile: true -> false                                                                                 |
|         enable_profile: false -> true                                                                                       |
|         parallel_fragment_exec_instance_num: 1 -> 8                                                                         |
| Fragment 0                                                                                                                  |
| │   BackendNum: 1                                                                                                           |
| │   InstancePeakMemoryUsage: ?, InstanceAllocatedMemoryUsage: ?                                                             |
| │   PrepareTime: ?                                                                                                          |
| │   MissingInstanceIds: 6b148971-71e6-11f0-8cea-00163e39052b                                                                |
| └──RESULT_SINK                                                                                                              |
|    │   SinkType: MYSQL_PROTOCAL                                                                                             |
|    └──SCHEMA_SCAN (id=0)                                                                                                    |
|           Estimates: [row: 1, cpu: ?, memory: ?, network: ?, cost: 0.0]                                                     |
|           TotalTime: 0ns (NaN%) [CPUTime: ?]                                                                                |
|           OutputRows: ?                                                                                                     |
|                                                                                                                                 |
+-------------------------------------------------------------------------------------------------------------------------------------+
  1. ANALYZE PROFILE 展示的和explain analyze一样,但是指标比 explain analyze 更加丰富
+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
| Explain String                                                                                                                                            |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
| Summary                                                                                                                                           |
|     QueryId: 135d8852-62fd-11f0-b356-00163e164034                                                                                                 |
|     Version: 3.3.5-6d81f75                                                                                                                        |
|     State: Finished                                                                                                                               |
|     TotalTime: 268ms                                                                                                                              |
|         ExecutionTime: 257.617ms [Scan: 229.352ms (89.03%), Network: 0ns (0.00%), ResultDeliverTime: 0ns (0.00%), ScheduleTime: 42.480us (0.02%)] |
|         CollectProfileTime: 2ms                                                                                                                   |
|         FrontendProfileMergeTime: 732.454us                                                                                                       |
|     QueryPeakMemoryUsage: ?, QueryAllocatedMemoryUsage: 1015.680 KB                                                                               |
|     Top Most Time-consuming Nodes:                                                                                                                |
|         1. SCHEMA_SCAN (id=0) : 234.646ms (97.54%)                                                                                           |
|         2. RESULT_SINK: 5.906ms (2.46%)                                                                                                           |
|         3. PROJECT (id=1) : 12.503us (0.01%)                                                                                                      |
|     Top Most Memory-consuming Nodes:                                                                                                              |
|     NonDefaultVariables:                                                                                                                          |
|         big_query_profile_threshold: 0s -> 30s                                                                                                    |
|         character_set_results: utf8 -> NULL                                                                                                       |
|         enable_adaptive_sink_dop: false -> true                                                                                                   |
|         enable_profile: false -> true                                                                                                             |
|         parallel_fragment_exec_instance_num: 1 -> 8                                                                                               |
|         sql_mode_v2: 32 -> 2097184                                                                                                                |
| Fragment 0                                                                                                                                        |
| │   BackendNum: 1                                                                                                                                 |
| │   InstancePeakMemoryUsage: 478.038 KB, InstanceAllocatedMemoryUsage: 1015.680 KB                                                                |
| │   PrepareTime: 16.399ms                                                                                                                         |
| └──RESULT_SINK                                                                                                                                    |
|    │   TotalTime: 5.906ms (2.46%) [CPUTime: 5.906ms]                                                                                              |
|    │   OutputRows: 38                                                                                                                             |
|    │   SinkType: MYSQL_PROTOCAL                                                                                                                   |
|    └──PROJECT (id=1)                                                                                                                              |
|       │   Estimates: [row: ?, cpu: ?, memory: ?, network: ?, cost: ?]                                                                             |
|       │   TotalTime: 12.503us (0.01%) [CPUTime: 12.503us]                                                                                         |
|       │   OutputRows: 38                                                                                                                          |
|       │   Expression: [4: COLUMN_NAME, 5: ORDINAL_POSITION, 7: IS_NULLABLE, 8: DATA_TYPE, ...]                                                    |
|       └──SCHEMA_SCAN (id=0)                                                                                                                  |
|              Estimates: [row: 1, cpu: ?, memory: ?, network: ?, cost: 0.0]                                                                   |
|              TotalTime: 234.646ms (97.54%) [CPUTime: 5.294ms, ScanTime: 229.352ms]                                                           |
|              OutputRows: 38                                                                                                                  |
|              SubordinateOperators:                                                                                                           |
|                  CHUNK_ACCUMULATE                                                                                                            |
|              Detail Timers: [ScanTime = IOTaskExecTime + IOTaskWaitTime]                                                                     |
|                  FERPC: 211.509ms                                                                                                            |
|                  IOTaskExecTime: 229.309ms                                                                                                   |
|                  IOTaskWaitTime: 42.740us                                                                                                    |
|                                                                                                                                                       |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------+
  1. trace 展示的是某个局部,比如说 某个规则的耗时
MySQL [(none)]> trace times SCHEDULE SELECT `SCHEMA_NAME` FROM `INFORMATION_SCHEMA`.`SCHEMATA` WHERE SCHEMA_NAME = 'fin_config';
+--------------------------------------------------+
| Explain String                                   |
+--------------------------------------------------+
| 0ms|-- Parser[1] 0                               |
| 0ms|-- Total[1] 0                                |
| 0ms|    -- Analyzer[1] 0                         |
| 0ms|        -- Lock[1] 0                         |
| 0ms|        -- AnalyzeDatabase[1] 0              |
| 0ms|        -- AnalyzeTemporaryTable[1] 0        |
| 0ms|        -- AnalyzeTable[1] 0                 |
| 0ms|    -- Transformer[1] 0                      |
| 0ms|    -- Optimizer[1] 0                        |
| 0ms|        -- MVPreprocess[1] 0                 |
| 0ms|            -- MVChooseCandidates[1] 0       |
| 0ms|            -- MVGenerateMvPlan[1] 0         |
| 0ms|            -- MVValidateMv[1] 0             |
| 0ms|            -- MVProcessWithView[1] 0        |
| 0ms|        -- MVTextRewrite[1] 0                |
| 0ms|        -- RuleBaseOptimize[1] 0             |
| 0ms|        -- CostBaseOptimize[1] 0             |
| 1ms|        -- PhysicalRewrite[1] 0              |
| 1ms|        -- PlanValidate[1] 0                 |
| 1ms|            -- InputDependenciesChecker[1] 0 |
| 1ms|            -- TypeChecker[1] 0              |
| 1ms|            -- CTEUniqueChecker[1] 0         |
| 1ms|            -- ColumnReuseChecker[1] 0       |
| 1ms|    -- ExecPlanBuild[1] 0                    |
| Tracer Cost: 9us                                 |
+--------------------------------------------------+

MySQL [(none)]> trace times OPTIMIZER SELECT `SCHEMA_NAME` FROM `INFORMATION_SCHEMA`.`SCHEMATA` WHERE SCHEMA_NAME = 'fin_config';
+----------------------------------------------------------+
| Explain String                                           |
+----------------------------------------------------------+
| 0ms|-- Parser[1] 0                                       |
| 0ms|-- Total[1] 0                                        |
| 0ms|    -- Analyzer[1] 0                                 |
| 0ms|        -- Lock[1] 0                                 |
| 0ms|        -- AnalyzeDatabase[1] 0                      |
| 0ms|        -- AnalyzeTemporaryTable[1] 0                |
| 0ms|        -- AnalyzeTable[1] 0                         |
| 0ms|    -- Transformer[1] 0                              |
| 0ms|    -- Optimizer[1] 0                                |
| 0ms|        -- MVPreprocess[1] 0                         |
| 0ms|            -- MVChooseCandidates[1] 0               |
| 0ms|            -- MVGenerateMvPlan[1] 0                 |
| 0ms|            -- MVValidateMv[1] 0                     |
| 0ms|            -- MVProcessWithView[1] 0                |
| 0ms|        -- MVTextRewrite[1] 0                        |
| 0ms|        -- RuleBaseOptimize[1] 0                     |
| 0ms|            -- RewriteTreeTask[59] 0                 |
| 0ms|                -- PushDownPredicateProjectRule[1] 0 |
| 0ms|                -- PushDownPredicateScanRule[1] 0    |
| 0ms|                -- MergeTwoProjectRule[2] 0          |
| 0ms|                -- PruneProjectColumnsRule[2] 0      |
| 0ms|                -- PruneScanColumnRule[2] 0          |
| 0ms|                -- PruneSubfieldRule[1] 0            |
| 0ms|                -- PruneProjectRule[2] 0             |
| 0ms|                -- MergeProjectWithChildRule[1] 0    |
| 0ms|        -- CostBaseOptimize[1] 0                     |
| 0ms|            -- OptimizeGroupTask[1] 0                |
| 0ms|            -- OptimizeExpressionTask[1] 0           |
| 0ms|            -- DeriveStatsTask[1] 0                  |
| 0ms|            -- ApplyRuleTask[1] 0                    |
| 0ms|                -- SchemaScanImplementationRule[1] 0 |
| 0ms|            -- EnforceAndCostTask[1] 0               |
| 0ms|        -- PhysicalRewrite[1] 0                      |
| 1ms|        -- PlanValidate[1] 0                         |
| 1ms|            -- InputDependenciesChecker[1] 0         |
| 1ms|            -- TypeChecker[1] 0                      |
| 1ms|            -- CTEUniqueChecker[1] 0                 |
| 1ms|            -- ColumnReuseChecker[1] 0               |
| 1ms|    -- ExecPlanBuild[1] 0                            |
| Tracer Cost: 21us                                        |
+----------------------------------------------------------+

其中这里面的[1] 数字代码该规则被应用的次数,如 PhysicalRewrite[1]则表示 改规则被应用了1次。
StarRocks(四)StarRocks的使用 1、Colocate join shuffle join 和 broadcast join 中,参与 join 的两张表的数据行,若满足 join 条件,则需要将它们汇合在一个节点上,完成 join。这两种 join 方式,都无法避免节点间数据网络传输带来额外的延迟和其他开销。而 colocation join 则可避免数据网络传输开销,核心思想是将同一个 Colocation Group 中表,采用一致的分桶键、一致的副本数量和一致副本放置方式,因此如果 join 列为分桶键,则计算节... 阅读详情

相关推荐

【后台技术】StarRocks执行原理与SQL性能优化策略探索

理解StarRocks是如何进行数据读取与计算,从而进一步更好地基于StarRocks进行业务SQL的编写与优化。

Deltaverse的博客 1653

StarRocks案例3: 通过[broadcast] 优化慢SQL

但是实际情况是 table_b 居然是扫描了 5kw数据后,在于table_a 进行join,table_a 通过关联字段 与 table_b 进行join,然后再进行group by。table_a 10W 左右数据,通过where条件过滤数据后 剩下 10行数据。table_b 5亿左右数据,通过where过滤条件后 剩下 5kw 数据。table_b join后其实只剩下少量的数据,进行聚合运算,应该也不会太慢。通过explain查看了执行计划,发现了table_b 访问的行数太多了。

只是甲的博客 1399

浅谈StarRocks SQL性能检查与调优

StarRocks 作为一款高性能的分布式分析型数据库,其 SQL 性能调优需要结合其存储模型、分布式架构和查询优化器特性。以下是性能检查与调优的核心思路及实践方法: 关注点: SCAN 阶段:是否命中分区/分桶裁剪?数据扫描量是否过大? JOIN 阶段:是否触发 Colocate/Bucket Shuffle Join?是否存在数据倾斜? AGGREGATE 阶段:是否过度聚合?是否启用两阶段优化? 2. Profile 分析 查询 Profile:通过 开启,执行查询后获取详细资源消耗

Steven的博客 2162

StarRocks Analyzer 源码解析

Analyzer 是数据库实现中的重要组成模块,主要用于进行 SQL 的语义解析,承担了多个重要功能。而绝大部分的 SQL 正确性检查和语法报错逻辑,也均集中在 Analyzer 中。本文将着重介绍 StarRocks 中 Analyzer 的实现逻辑,以及如何根据 StarRocks 中的元数据信息,完成AST 的 Analyze 逻辑。

StarRocks的博客 1127

StarRocks执行计划深度解读:从EXPLAIN输出发现SQL优化机会

本文深度解读StarRocks执行计划,通过EXPLAIN输出揭示SQL性能优化机会。文章详细解析执行计划结构、节点类型与性能特征,并提供典型性能问题的解决方案,如Join效率低下和聚合操作瓶颈。结合实战案例,展示如何从执行计划中发现优化点,实现查询性能从分钟级到秒级的提升。

emacs5lisp的博客 555

StarRocks-Profile分析及优化指南

背景 我们时常遇到sql执行时间不及预期的情况,为了优化sql达到预期查询时延,我们能够做哪些优化。本文旨在分析查询profile各阶段耗时是否合理以及对应优化方式。 准备 打开profile分析上报。 使用mysqlclient连接starrocks集群, mysql -h ip -P9030 -u root -p xxx 然后输入 ##该参数开启的是session变量,若想开启全局变量可以set global is_report_success=true;一般不建议全局开启,会略微

weixin_43993184的博客 5029

StarRocks学习4-查询优化与性能调优

优化项作用常见手段或建议执行计划分析查看 SQL 执行路径查询缓存 & 物化视图减少重复计算、加速聚合查询启用缓存、创建物化视图Join 策略优化降低数据传输、提升 Join 效率并发与资源控制避免资源争抢、保障关键查询慢查询分析与索引定位瓶颈、提升过滤与扫描效率Bitmap、Bloom、物化视图、分区分桶同步 MV 实时更新、写入慢,适合小表实时场景;异步 MV 定期刷新、写入快,适合大表分析型查询。

sun657053178的博客 1672

COMSOL中的动网格

首先我们先了解几个概念 (1)网格重划分(remesh):就是在某些特定的区域进行网格的重新划分,在Maxwell软件中的直线运动区域,当运动物体运动后,这个区域进行重新划分。 (2)morph:网格不重新划分,小范围的进行网格变形,针对运动物体运动位移较小,对变形区域不进行重划分,能够提高效率。 (3)网格滑移(sliding):针对圆形运动区域,运动与非运动区域进行网格滑移,当然边界上两侧网格不共节点,该方法不需要网格重新划分,大部分软件针对圆形运动区域采用该方法,比如maxwell的band,b

midiio的博客 7868

Starrocks 关于 trace 命令的说明

本文介绍了Starrocks 3.5.5中TRACE命令的使用方式,支持TIMES/VALUES/LOGS/ALL等模式,并可指定BASE/MV/OPTIMIZER等模块。在ConnectProcessor.handleQuery中通过Tracers.init初始化指定模块,仅记录选定模块的指标信息(如OPTIMIZER模块的任务执行时间),避免保留所有模块数据导致FE内存过高引发OOM。这种设计通过模块化跟踪机制有效控制了内存使用。

monkeyboy_tech的博客 412

Labview 机器视觉(4)之 图像处理进阶 - 动态ROI与批量保存

本文深入探讨了LabVIEW机器视觉中动态ROI与批量保存两大进阶技术。动态ROI通过模式匹配或粒子分析实现检测区域的自动追踪,解决了产品位置变化带来的挑战。同时,文章详细介绍了如何设计高效的文件命名规则与异步保存机制,以实现海量图像数据的批量保存与管理,从而构建稳定、高效的工业自动化检测系统。

weixin_29234423的博客 218

FPGA控制DDR读写(AXI4总线接口)

FPGA控制DDR读写

qq_42712308的博客 1万+

记录一下 StarRocks 点查的 Profile Metrics

本文对比了Starrocks 3.5中开启和关闭点查(short circuit)功能时的查询性能差异。测试使用包含主键条件的查询语句,结果显示开启点查后查询总时间从14ms降至6ms。主要优化体现在:1)优化器仅执行RBO规则处理;2)调度步骤简化,跳过完整的PipelineDriver调度流程;3)执行时间从6.773ms缩短至857.455us,直接通过节点获取数据。点查功能通过减少优化步骤和简化执行流程显著提升了简单主键查询的性能。

monkeyboy_tech的博客 566

DSH-Work:一个让DeepSeek下载即用的Harness客户端

使用大模型工具时,环境配置往往比模型本身更让人头疼。DeepSeek Harness作为一类封装层,将模型调用、上下文管理、参数控制等复杂细节统一收拢,对外提供简洁操作入口。开源的DSH-Work正是这样一款Harness客户端,它通过自带运行时与保守默认配置,实现了下载即用、免配环境的目标,让使用者无需掌握Python、CUDA等专业知识即可快速连接DeepSeek云端或本地服务。对于非技术背景的用户,它降低了AI工具的使用门槛;对于开发者,它把时间从环境排错中解放出来,更专注于提示词调优与工作流设计。无

weixin_29048309的博客 340

Android Studio 的 Profile使用

这是 Android Studio 的 Profiler 工具界面,用于分析应用的性能(CPU、内存、系统活动等)。

weixin_39789947的博客 1269

华为防火墙——本地Portal认证

配置IP地址、路由、Nat策略使得内网主机可以访问公网服务器对网段不进行认证,对网段进行portal认证。

m0_49864110的博客 3258

基于OpenCV和Dlib的头部姿态估计详细教程

本文详细介绍了基于OpenCV和Dlib的头部姿态估计方法。通过分析2D人脸特征点与3D头部模型的对应关系,利用PnP(Perspective-n-Point)算法求解头部在三维空间中的姿态。文章首先阐述了坐标系统转换原理,包括世界坐标系、相机坐标系和图像坐标系的转换关系,随后深入讲解了PnP问题的数学表述及求解步骤,并提供了使用Dlib检测68个面部特征点的代码示例。最后介绍了3D通用头部模型的构建方法,包括6点和14点模型的选择,为计算机视觉中的头部姿态估计提供了完整的技术实现方案。

FJN110的博客 334

StarRocks日志分析:日志收集与分析平台

StarRocks日志分析:日志收集与分析平台 【免费下载链接】starrocks StarRocks是一个开源的分布式数据分析引擎,用于处理大规模数据查询和分析。 - 功能:分布式数据分析;大规模数据查询;数据分析;数据仓库。 - 特点:高性能;可扩展;易于使用;支持多种数据源。 ...

gitblog_00020的博客 1232

Spring AI提示词模板应用

本文介绍了使用SpringAI提示词模板的配置方法,主要步骤包括:1)在JDK17和SpringBoot3.4.4环境下引入spring-ai-alibaba1.0.0.2依赖;2)配置application.yml文件;3)创建测试控制器类处理提示词模板(.st文件);4)通过模板变量动态生成AI回复内容。演示了如何通过@RequestParam设置默认参数,实现无需前端传参即可测试AI回复功能,最终完成了一个SpringAI提示词模板的应用Demo。

wjianwei666的专栏 196

StarRocks入门之路

StarRocks是一个高性能分布式关系型列式数据库,通过MPP执行框架,单节点每秒可处理多达100亿行数据,同时支持星型模型和雪花模型。StarRocks集群由FE和BE构成,可以使用MySQL客户端访问StarRocks集群。FE接收MySQL客户端的连接,解析并执行SQL语句,管理元数据,执行SQL DDL命令, 用Catalog记录库、表、分区,tablet副本等信息。BE管理tablet副本,tablet是table经过分区分桶形成的子表,采用列式存储。BE受FE指导,创建或删除子表。...

luo981695830的博客 7138

flash均衡磨损--实时保存设备数据

【代码】flash均衡磨损--实时保存设备数据。

Car12 480

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

StarRocks 的学习笔记

StarRocks 是一款极速全场景MPP 分析型数据库,可以“一栈式”的响应企业各类低延迟场景的查询需求。 StarRocks的愿景是能够让用户的数据分析变得更加简单和敏捷。用户无需经过复杂的预处理,就可以用StarRocks 来支持多种数据分析场景的极速分析。 StarRocks的架构简洁,采用了全面向量化引擎,并配备全新设计的 CBO 优化器,查询速度(尤其是多表关联查询)远超同类产品。

weixin_45866849的博客 7737

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

Spark DPP(动态分区裁剪)导致的DataSourceScanExec NullPointerException问题分析以及解决

背景 本文基于spark 3.1.2,且运行在yarn模式下 最近在调试 spark sql的时候遇到了空指针的问题,如下: Caused by: java.lang.NullPointerException at org.apache.spark.sql.execution.DataSourceScanExec.$init$(DataSourceScanExec.scala:57) at org.apache.spark.sql.execution.FileSourceScanExec.<in

monkeyboy_tech的博客 3万+

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

SPARK SQL中 CTE(with表达式)会影响性能么?

背景及问题 本文基于spark 3.1.2 最近在排查spark sql问题的时候,出现了一系列的(CTE)with操作,导致该任务运行不出来,而把对应的(CTE)with 替换成了临时表以后,任务很快的就能运行出来 对应的最简化的sql如下: with temp1 as ( select null as user_id ,a.sku_id ,int(sum(`可申请数量`)) `开放申请数量` from xxx.xxx `a` where pt between '20

monkeyboy_tech的博客 7321

Spark task过多导致任务运行过慢甚至超时

背景以及现象 本文基于 spark 3.1.2 设置spark.driver.memory=2g 在调试spark sql任务的时候,发现有几个任务产生了40多万个Task,而且任务长期运行不出来。 分析 运行此sql,可以得到如下的dag(我们只截取产生Task多的Stage),由此可以看到是scan的文件太大了(scan了日志文件半年的数据)。 但是为什么这种情况下会导致任务运行很缓慢甚至会超时呢? 找到driver端, 用jstat -gcutil查看一下对应的gc情况(对应的内存都是调优完后的镜像

monkeyboy_tech的博客 6799

【k8s系列5】KubernetesClientException: too old resource version 原因分析

背景 公司目前在基于k8s做调度(基于io.fabric8:kubernetes-client:4.2.0),在运行的过程中,遇到了如下问题: OkHttp WebSocket https://10.25.61.82:6443/...] DEBUG io.fabric8.kubernetes.client.dsl.internal.WatchConnectionManager - WebSocket close received. code: 1000, reason: [OkHttp WebSocket

monkeyboy_tech的博客 6040

【mlflow系列1】mlflow 的搭建使用

背景 mlflow是Databrick开源的机器学习管理平台,它很好的解藕了算法训练和算法模型服务,使得算法工程师专注于模型的训练,而不需要过多的关注于服务的, 而且在我们公司已经有十多个服务稳定运行了两年多。 搭建 mlflow的搭建主要是mlflow tracking server的搭建,tracking server主要是用于模型的元数据以及模型的数据存储 我们这次以minio作为模型数据的存储后台,mysql作为模型元数据的存储,因为这种模式能满足线上的需求,不仅仅是用于测试 minio的搭建

monkeyboy_tech的博客 5183
上一篇: Starrocks ShortCircuit短路径的调度
下一篇: Starrocks 关于 trace 命令的说明
鸿乃江边鸟
博客等级 码龄6年 3746粉丝 235原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值