tablet_sched_max_scheduling_tablets = 0

3.2.x

3.3.x

docker-compose.yml

docker run

Alive

SHOW BACKENDS

/opt/starrocks/fe/meta

/opt/starrocks/be/storage

sql
ADMIN SET FRONTEND CONFIG ("tablet_sched_max_scheduling_tablets" = "0");
ADMIN SET FRONTEND CONFIG ("tablet_sched_max_balancing_tablets" = "0");
ADMIN SET FRONTEND CONFIG ("disable_balance" = "true");
ADMIN SET FRONTEND CONFIG ("disable_colocate_balance" = "true");

sql
ADMIN SET FRONTEND CONFIG ("tablet_sched_max_scheduling_tablets" = "10000");
ADMIN SET FRONTEND CONFIG ("tablet_sched_max_balancing_tablets" = "500");
ADMIN SET FRONTEND CONFIG ("disable_balance" = "false");
ADMIN SET FRONTEND CONFIG ("disable_colocate_balance" = "false");

/metrics

starrocks_fe_query_total

promql
    irate(starrocks_fe_query_total[1m])

starrocks_fe_query_resource_group

starrocks_fe_txn_total_latency_ms_count

promql
    sum(irate(starrocks_fe_txn_total_latency_ms_count[1m])) by (type)

type

stream_load

routine_load

insert_into

starrocks_fe_query_total

starrocks_fe_txn_total_latency_ms_count

starrocks_fe_query_err

starrocks_be_load_bytes_total

starrocks_fe_txn_*

0

true

sql
ADMIN SHOW FRONTEND CONFIG LIKE "%balance%";
ADMIN SHOW FRONTEND CONFIG LIKE "%tablet_sched%";

sql
-- Allow the scheduler to schedule tablets
ADMIN SET FRONTEND CONFIG ("tablet_sched_max_scheduling_tablets" = "10000");

-- Allow the balancer to move tablets between nodes
ADMIN SET FRONTEND CONFIG ("tablet_sched_max_balancing_tablets" = "500");

-- Enable general and colocate balancing
ADMIN SET FRONTEND CONFIG ("disable_balance" = "false");
ADMIN SET FRONTEND CONFIG ("disable_colocate_balance" = "false");

TabletNum

sql
    SHOW PROC '/tablet_scheduler';

Pending

Running

Finished

TabletNum

DataUsedCapacity

UsedPct

High Warehouse

Storage

SHOW BACKENDS

disable_balance = false

tablet_sched_disable_colocate_overall_balance | true

COLOCATE_WITH

true

disable_colocate_balance

false

sql
ADMIN SET FRONTEND CONFIG ("tablet_sched_disable_colocate_overall_balance" = "false");

sql
SHOW PROC '/tablet_scheduler';

HistoryFinishedNum

sql
SHOW PROC '/colocation_group';

IsStable

false

tablet_sched_balance_load_disk_safe_threshold

0.5

tablet_sched_checker_interval_seconds = 20

tablet_sched_disable_colocate_overall_balance

false

SHOW PROC '/tablet_scheduler';

Running

Pending

report_tablet

Alive

true

report_tablet

SHOW BACKENDS

tablet_sched_disable_colocate_overall_balance

true

ADMIN SHOW FRONTEND CONFIG

true

disable_balance

false

sql
    ADMIN SET FRONTEND CONFIG ("tablet_sched_disable_colocate_overall_balance" = "false");

sql
    SHOW WAREHOUSES;

12713022

12712988

sql
    ALTER WAREHOUSE <warehouse_name> ADD BACKENDS ("10.74.0.108:9050", "10.74.0.94:9050");

sql
    SHOW PROC '/tablet_scheduler';

PendingTaskNum

0

RunningTaskNum

ErrMsg

sql
    SHOW PROC '/cluster_balance/history_tablets';

sql
    SHOW PROC '/colocation_group';

tablet_sched_disable_colocate_overall_balance

false

SHOW WAREHOUSES

tablet_sched_checker_interval_seconds

ADMIN SHOW FRONTEND CONFIG

tablet_sched_disable_colocate_overall_balance | true

COLOCATE_WITH

true

disable_balance

false

sql
ADMIN SET FRONTEND CONFIG ("tablet_sched_disable_colocate_overall_balance" = "false");

sql
    SHOW WAREHOUSES;

12713022

12712988

sql
    ALTER WAREHOUSE default_warehouse ADD BACKENDS ("10.74.0.108:9050", "10.74.0.94:9050");

tablet_sched_balance_load_disk_safe_threshold

0.5

0.5

sql
    SHOW PROC '/tablet_scheduler';

PendingTaskNum

sql
    SHOW PROC '/colocation_group';

IsStable

false

sql
    SHOW PROC '/cluster_balance/history_tablets';

tablet_sched_disable_colocate_overall_balance

false

SHOW WAREHOUSES

TabletNum

tablet_sched_disable_colocate_overall_balance | true

COLOCATE_WITH

true

disable_balance

false

sql
ADMIN SET FRONTEND CONFIG ("tablet_sched_disable_colocate_overall_balance" = "false");

tablet_sched_balance_load_disk_safe_threshold

sql
    SHOW PROC '/tablet_scheduler';

PendingTaskNum

0

HistoryFailedNum

sql
    SHOW PROC '/colocation_group';

IsStable = false

sql
    SHOW PROC '/cluster_balance/history_tablets';

ErrMsg

tablet_sched_disable_colocate_overall_balance

/tablet_scheduler

storage_medium

storage_root_path

be.conf

sql
-- For a specific table, move all its partitions to SSD
ALTER TABLE <db_name>.<table_name> MODIFY PARTITION (*) SET ("storage_medium" = "SSD");

sql
ALTER TABLE <db_name>.<table_name> SET ("default.storage_medium" = "SSD");

sql
    SHOW TABLETS FROM <table_name>;

StorageMedium

HDD

SSD

sql
    SHOW PROC '/tablet_scheduler';

ALTER DATABASE ... SET storage_medium

information_schema.tables

storage_medium_migrate_count

enable_strict_storage_medium_check

true

storage_medium

ALTER TABLE ... MODIFY PARTITION (_) SET ("storage_medium" = "SSD")

SSD

storage_medium

HDD

HDD

SSD

ALTER

sql
SHOW BACKENDS\G

StoragePath

[{"path":"/data/storage","total_capacity":...,"available_capacity":...,"is_ssd":true}]

ALTER

storage_root_path

shadow_automatic_partition

$shadow_automatic_partition

SHOW PROC

ALTER

sql
ALTER TABLE <table_name> MODIFY PARTITION (*) SET ("storage_medium" = "SSD");

(*)

sql
ALTER TABLE <table_name> SET ("default.storage_medium" = "SSD");

ALTER

$shadow_automatic_partition

default.storage_medium

MODIFY PARTITION (*)

sql
    ALTER TABLE <table_name> SET ("default.storage_medium" = "SSD");

sql
    ALTER TABLE <table_name> MODIFY PARTITION (*) SET ("storage_medium" = "SSD");

sql
    SHOW PARTITIONS FROM <table_name>;

StorageMedium

SSD

SHOW PROC

be.conf

storage_root_path

storage_medium

bash
    storage_root_path = /data1,medium:ssd;/data2,medium:ssd

sql
ALTER TABLE <table_name> SET ("default.storage_medium" = "SSD");

sql
ADMIN SET FRONTEND CONFIG ("enable_strict_storage_medium_check" = "true");

PROPERTIES("storage_medium"="SSD")

CREATE TABLE

ALTER

be.conf

"storage_medium" = "SSD"

PROPERTIES

CREATE TABLE

$shadow_automatic_partition

HDD

information_schema

1

2

$shadow_automatic_partition

sql
    ALTER TABLE ampledash_prod.`1` SET ("default.storage_medium" = "SSD");
    ALTER TABLE ampledash_prod.`2` SET ("default.storage_medium" = "SSD");

sql
    ALTER TABLE ampledash_prod.`1` MODIFY PARTITION (*) SET ("storage_medium" = "SSD");
    ALTER TABLE ampledash_prod.`2` MODIFY PARTITION (*) SET ("storage_medium" = "SSD");

HDD

HDD

SSD

ALTER ... SET ("default.storage_medium" = "SSD")

sql
SELECT DB_NAME, TABLE_NAME, PARTITION_NAME, STORAGE_MEDIUM
FROM information_schema.partitions_meta
WHERE TABLE_NAME IN ('1', '2') 
  AND DB_NAME = 'ampledash_prod';

STORAGE_MEDIUM

SSD

storage_medium

$shadow_automatic_partition

ALTER

1

2

1

sql
ALTER TABLE ampledash_prod.`1` SET ("default.storage_medium" = "SSD");
ALTER TABLE ampledash_prod.`2` SET ("default.storage_medium" = "SSD");

medium:ssd

SSD

SHOW BACKENDS\G

Disks

SSD

be.conf

bash
    # Ensure your path includes ,medium:ssd
    storage_root_path = /your/data/path,medium:ssd

be.conf

default.

default.

sql
ALTER TABLE ampledash_prod.`1` SET ("storage_medium" = "SSD");

$shadow_automatic_partition

information_schema

ALTER

sql
-- Insert a dummy row for a new date
INSERT INTO ampledash_prod.`1` VALUES (...); 

-- Now check the real partition created
SHOW PARTITIONS FROM ampledash_prod.`1`;

SSD

ALTER

HDD

partitions_meta

1

SHOW BACKENDS

storage_medium

default.

starrocks_fe_tablet_num

tablet_stat_update_interval_second

SHOW BACKENDS;

TabletNum

0

Status

0

sql
    SHOW PROC '/cluster_balance/history';

SHOW BACKENDS;

Alive

true

false

ErrMsg

backend_id

bash
    curl http://<FE_IP>:<FE_HTTP_PORT>/metrics | grep starrocks_fe_tablet_num

tablet_stat_update_interval_second

SHOW BACKENDS

tablet_sched_disable_balance

false

rpc_port

heartbeat_port

DelVector

too many versions

DelVector

max_batch_interval

max_interval

INSERT

too many versions

tablet_sched_balance_load_score_threshold

< 0.1

0.1 – 0.2

(max-min)/avg

tablet_sched_num_based_balance_threshold_ratio

max_query_retry_time

replication_num = 1

max_query_retry_time

thrift_rpc_retry_times

enable_be_blacklist

be.out

query_id

max_query_retry_time

[5067] [Frontend] RPC error: [10005] failed to send brpc...

thrift_rpc_retry_times

thrift_rpc_retry_times

max_query_retry_time

sql
-- This must be set in the fe.conf or via admin command (if supported for your version)
ADMIN SET FRONTEND CONFIG ("max_query_retry_time" = "0");

bufferflush.maxbytes

bufferflush.intervalms

<http://offset.flush.interval.ms|offset.flush.interval.ms>

bufferflush.maxbytes

bufferflush.intervalms

<http://offset.flush.interval.ms|offset.flush.interval.ms>

<http://offset.flush.interval.ms|offset.flush.interval.ms> = 60000

flush()

Stream load manager flush finished - currentCacheBytes: 0

bufferflush.intervalms

bufferflush.intervalms

put()

bufferflush.intervalms

connect-distributed.properties

properties
    # Set this in the Kafka Connect WORKER config, not the connector JSON
    <http://offset.flush.interval.ms|offset.flush.interval.ms>=15000

currentCacheBytes

0

maxCacheBytes: 94371840

bufferflush.maxbytes

currentCacheBytes: 0

<http://offset.flush.interval.ms|offset.flush.interval.ms>

bufferflush.intervalms=15000

currentCacheBytes

0

currentCacheBytes: 0

ERROR

WARN

WHERE

GET /connectors/[connector_name]/status

RUNNING

connect-[connector_name]

Failed to convert record

Stream load failed

currentCacheBytes > 0

currentCacheBytes: 0

14:13:17

14:14:17

flush()

<http://offset.flush.interval.ms|offset.flush.interval.ms>

bufferflush.intervalms

currentCacheBytes: 0

DEBUG

INFO

StreamLoadManagerV2

sql
SELECT label, status, create_time, load_bytes 
FROM information_schema.loads 
WHERE table_name = 'your_table_name' 
ORDER BY create_time DESC 
LIMIT 20;

create_time

create_time

bufferflush.intervalms

sink.properties

"bufferflush.intervalms": "15000"

"sink.properties.bufferflush.intervalms": "15000"

put()

starrocks-kafka-connector

currentCacheBytes: 0

information_schema.loads

currentCacheBytes: 0

bufferflush.intervalms

information_schema.loads

sql
SELECT 
    label, 
    status, 
    create_time,
    TIMESTAMPDIFF(SECOND, LAG(create_time) OVER (ORDER BY create_time), create_time) AS seconds_since_last_load,
    sink_rows,
    scan_bytes
FROM information_schema.loads 
WHERE table_name = 'your_table_name' 
  AND type = 'STREAM'
ORDER BY create_time DESC 
LIMIT 20;

seconds_since_last_load

kafka.connect:type=connector-task-metrics,connector="{connector}",task="{task}"

offset-commit-success-percentage

batch-size-avg

starrocks_be_stream_load_sink_pull_data_count

INFO

DEBUG

log4j.properties

properties
    log4j.logger.com.starrocks.connector.kafka=DEBUG

DEBUG

StreamLoadManagerV2

StreamLoader

currentCacheBytes: 0

<http://offset.flush.interval.ms|offset.flush.interval.ms>

Stream load manager flush finished - currentCacheBytes: 0

STATE

status

information_schema.loads

sql
SELECT 
    LABEL, 
    STATE, 
    CREATE_TIME,
    TIMESTAMPDIFF(SECOND, LAG(CREATE_TIME) OVER (ORDER BY CREATE_TIME), CREATE_TIME) AS seconds_since_last_load,
    SINK_ROWS,
    SCAN_BYTES
FROM information_schema.loads 
WHERE TABLE_NAME = 'your_table_name' 
  AND TYPE = 'STREAM'
ORDER BY CREATE_TIME DESC 
LIMIT 20;

stream_loads

sql
SELECT 
    LABEL, 
    STATE, 
    FROM_UNIXTIME(CREATE_TIME_MS / 1000) AS create_time,
    (CREATE_TIME_MS - LAG(CREATE_TIME_MS) OVER (ORDER BY CREATE_TIME_MS)) / 1000 AS seconds_since_last_load,
    NUM_ROWS_NORMAL AS sink_rows
FROM information_schema.stream_loads 
WHERE TABLE_NAME = 'your_table_name'
ORDER BY CREATE_TIME_MS DESC 
LIMIT 20;

seconds_since_last_load

bufferflush.intervalms

<http://be.INFO|be.INFO>

label

Stream load

starrocks_be_stream_load_put_data_bytes

information_schema.loads

WHERE

sql
    SELECT * FROM information_schema.loads
    WHERE TABLE_NAME = 'your_table'
      AND CREATE_TIME > NOW() - INTERVAL 5 MINUTE
    ORDER BY CREATE_TIME DESC;

SHOW LOAD

information_schema

SHOW LOAD

sql
    SHOW LOAD FROM your_database_name WHERE Label LIKE "starrocks-kafka-connector%" ORDER BY CreateTime DESC LIMIT 10;

fe.log

fe.gc.log

information_schema.loads

[]

information_schema.loads

sql
ADMIN SET FRONTEND CONFIG ("max_query_retry_time" = "10");

bufferflush.intervalms

30000

bufferflush.maxbytes

information_schema

SHOW LOAD

information_schema.loads

SHOW LOAD

sql
SHOW LOAD FROM your_db WHERE Label LIKE "your_label%" ORDER BY CreateTime DESC LIMIT 10;

fe.gc.log

fe.log

fe.conf

-Xmx8g

-Xmx16g

max_query_retry_time

0

1

2

0

5

10

0

sql
-- To give the query more chances to succeed despite background loads:
ADMIN SET FRONTEND CONFIG ("max_query_retry_time" = "10");

bufferflush.intervalms

bufferflush.intervalms

1000

5000

10000

bufferflush.maxbytes

67108864

<http://offset.flush.interval.ms|offset.flush.interval.ms>

properties
# Enable merging multiple small loads into one transaction
sink.properties.enable_merge_commit = true
# Wait up to 5 seconds to group loads together
sink.properties.merge_commit_interval_ms = 5000

information_schema.loads

information_schema.loads

WHERE CREATE_TIME > ...

SHOW LOAD

information_schema

-Xmx

bufferflush.intervalms

5000

30000

enable_merge_commit

true

max_query_retry_time

10

SHOW DATA

information_schema.partitions_meta

DATA_SIZE

sql
SELECT 
    DB_NAME, 
    SUM(DATA_SIZE) / 1024 / 1024 / 1024 AS size_gb_logical
FROM information_schema.partitions_meta
WHERE DB_NAME = 'your_database_name'
GROUP BY DB_NAME;

SHOW PARTITIONS

sql
SHOW PARTITIONS FROM your_table_name;

SHOW DATA

SHOW DATA

SHOW DATA

BACKUP

SHOW DATA

information_schema.partitions_meta

SHOW BACKUP

DATA_SIZE

STORAGE_SIZE

partitions_meta

for (int i = 0; i < Config.max_query_retry_time; ++i) {
            if (!isSchemaValid) {
                planStartTime = OptimisticVersion.generate();
                reAnalyzeStmt(queryStmt, session, plannerMetaLocker);

0

isSchemaValid

false

for (int i = 0; i < Config.max_query_retry_time; ++i)

0

0 < 0

1

i=0

2

0

1

0

0

2

0

1

10

sql
-- Increase retries to handle high-frequency commits
ADMIN SET FRONTEND CONFIG ("max_query_retry_time" = "10");

public static ExecPlan createQueryPlanWithReTry(QueryStatement queryStmt,
                                                    ConnectContext session,
                                                    TResultSinkType resultSinkType,
                                                    PlannerMetaLocker plannerMetaLocker,
                                                    long planStartTime) {
        QueryRelation query = queryStmt.getQueryRelation();
        List<String> colNames = query.getColumnOutputNames();

        // 1. Build Logical plan
        ColumnRefFactory columnRefFactory = new ColumnRefFactory();
        boolean isSchemaValid = true;

        int sourceTablesCount = collectSourceTablesCount(session, queryStmt);

        // TODO: double check relatedMvs for OlapTable
        // only collect once to save the original olapTable info
        // the original olapTable in queryStmt had been replaced with the copied olapTable
        Set<OlapTable> olapTables = collectOriginalOlapTables(session, queryStmt);
        for (int i = 0; i < Config.max_query_retry_time; ++i) {
            if (!isSchemaValid) {
                planStartTime = OptimisticVersion.generate();
                reAnalyzeStmt(queryStmt, session, plannerMetaLocker);
                colNames = queryStmt.getQueryRelation().getColumnOutputNames();
                isSchemaValid = true;
            }

            try {
                LogicalPlan logicalPlan;
                MVTransformerContext mvTransformerContext = MVTransformerContext.of(session, true);
                try (Timer ignored = Tracers.watchScope("Transformer")) {
                    // get a logicalPlan without inlining views
                    TransformerContext transformerContext =
                            new TransformerContext(columnRefFactory, session, mvTransformerContext);
                    logicalPlan = new RelationTransformer(transformerContext).transformWithSelectLimit(query);
                }

                boolean isShortCircuit =
                        ShortCircuitPlanner.checkSupportShortCircuitRead(logicalPlan.getRoot(), session);
                OptExpression optimizedPlan;
                try (Timer ignored = Tracers.watchScope("Optimizer")) {
                    OptimizerContext optimizerContext = OptimizerFactory.initContext(session, columnRefFactory);
                    // 2. Optimize logical plan and build physical plan
                    // FIXME: refactor this into Optimizer.optimize() method.
                    // set query tables into OptimizeContext so can be added for mv rewrite
                    if (Config.skip_whole_phase_lock_mv_limit >= 0) {
                        optimizerContext.setQueryTables(olapTables);
                    }

                    if (isShortCircuit) {
                        optimizerContext.setOptimizerOptions(OptimizerOptions.newShortCircuitOpt());
                    }
                    optimizerContext.setMvTransformerContext(mvTransformerContext);
                    optimizerContext.setStatement(queryStmt);
                    optimizerContext.setSourceTablesCount(sourceTablesCount);

                    Optimizer optimizer = OptimizerFactory.create(optimizerContext);
                    optimizedPlan = optimizer.optimize(logicalPlan.getRoot(), new PhysicalPropertySet(),
                            new ColumnRefSet(logicalPlan.getOutputColumn()));
                }

                try (Timer ignored = Tracers.watchScope("ExecPlanBuild")) {
                    // 3. Build fragment exec plan
                    // SingleNodeExecPlan is set in TableQueryPlanAction to generate a single-node Plan,
                    // currently only used in Spark/Flink Connector
                    // Because the connector sends only simple queries, it only needs to remove the output fragment
                    ExecPlan plan = PlanFragmentBuilder.createPhysicalPlan(
                            optimizedPlan, session, logicalPlan.getOutputColumn(), columnRefFactory, colNames,
                            resultSinkType,
                            !session.getSessionVariable().isSingleNodeExecPlan(), isShortCircuit);
                    isSchemaValid = checkOlapTableSchemaValid(olapTables, planStartTime);
                    if (isSchemaValid) {
                        plan.setLogicalPlan(logicalPlan);
                        plan.setColumnRefFactory(columnRefFactory);
                        return plan;
                    }
                }
            } catch (RuntimeException exception) {
                isSchemaValid = checkOlapTableSchemaValid(olapTables, planStartTime);
                if (isSchemaValid) {
                    throw exception;
                }
            }
        }
        List<String> updatedTables = Lists.newArrayList();
        for (OlapTable olapTable : olapTables) {
            if (!OptimisticVersion.validateTableUpdate(olapTable, planStartTime)) {
                updatedTables.add(olapTable.getName());
            }
        }

        throw new StarRocksPlannerException(ErrorType.INTERNAL_ERROR,
                "schema of %s had been updated frequently during the plan generation", updatedTables);
    }

    private static boolean checkOlapTableSchemaValid(Set<OlapTable> olapTables, long planStartTime) {
        return olapTables.stream().allMatch(t -> OptimisticVersion.validateTableUpdate(t, planStartTime));
    }

    public static Set<OlapTable> collectOriginalOlapTables(ConnectContext session, StatementBase queryStmt) {
        Set<OlapTable> olapTables = Sets.newHashSet();
        PlannerMetaLocker locker = new PlannerMetaLocker(session, queryStmt);
        try {
            // Need lock to avoid olap table metas ConcurrentModificationException
            lock(locker);
            AnalyzerUtils.copyOlapTable(queryStmt, olapTables);
            return olapTables;
        } finally {
            unLock(locker);
        }
    }

max_query_retry_time

max_query_retry_time

0

for (int i = 0; i < 0; ++i)

updatedTables

schema of [] had been updated

max_query_retry_time

1

i = 0

checkOlapTableSchemaValid

isSchemaValid

false

max_query_retry_time

2

isSchemaValid

false

!isSchemaValid

reAnalyzeStmt

max_query_retry_time

2

sql
-- Set this in your FE config (fe.conf) or via admin command
ADMIN SET FRONTEND CONFIG ("max_query_retry_time" = "10");

Config value == Total attempts

query_timeout

SET GLOBAL

root

sql
-- Example: Set global query timeout to 1 hour (3600 seconds)
SET GLOBAL query_timeout = 3600;

sql
ALTER USER 'username' SET PROPERTIES ('session.query_timeout' = '600');

query_timeout

INSERT

UPDATE

DELETE

CTAS

sql
-- Set global insert/write timeout
SET GLOBAL insert_timeout = 3600;

sql
-- Check current session value
SHOW VARIABLES LIKE 'query_timeout';

-- Check global value
SHOW GLOBAL VARIABLES LIKE 'query_timeout';

query_timeout

fe.conf

query_timeout

fe.conf

max_query_retry_time

ADMIN SHOW FRONTEND CONFIG

query_timeout

enable_spill

SHOW VARIABLES

fe.conf

SET GLOBAL

fe.conf

SET GLOBAL query_timeout = 3600;

query_timeout

INSERT

SET GLOBAL query_timeout = <seconds>;

query_timeout

mysql-default_query_timeout

30000

SET query_timeout = 60

SET query_timeout = 600;

SET GLOBAL query_timeout = 600;

SET @variable = 1

query_timeout

query_timeout

wait_timeout

sql_mode

mysql-session_track_variables

mysql-default_query_timeout

mysql-default_query_timeout

SET GLOBAL query_timeout

SET GLOBAL

query_timeout

testOnBorrow=true

COM_PING

starrocks_fe_request_total

starrocks_fe_query_total

idleTimeout

maxLifetime

request_total

fe.log

Connection refused

Access denied

COM_FIELD_LIST

COM_TABLE_STATISTICS

SELECT * FROM...

fe/log/fe.audit.log

SET

SHOW

bash
    netstat -n | grep :9030 | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -nr

mysql-ping_interval_server_msec

mysql-ping_timeout_server

mysql-ping_interval_server_msec

mysql-monitor_enabled

mysql-monitor_ping_interval

fe_request_total

max_user_connections

fe_query_total

fe.log

Access denied

Too many connections

testOnBorrow=true

COM_PING

mysql_query_rules

netstat -anp | grep :9030 | awk '{print $5}' | cut -d: -f1 | sort | uniq -c

tcpdump

Login Request

COM_PING

bash
    tcpdump -i any port 9030 -X -s 0 -c 100

select

show

mysql-ping_interval_server_msec

scanner_thread_pool_thread_num

scanner_thread_pool_thread_num

48

sql
-- Modify on a specific BE
ALTER SYSTEM MODIFY CONFIG ("scanner_thread_pool_thread_num" = "64");

pipeline_connector_scan_thread_num_per_cpu

run_mode = shared_data

ALTER SYSTEM ADD BACKEND "IP:PORT";

ALTER SYSTEM ADD COMPUTE NODE "IP:PORT";

sql
-- Allow the cluster to prefer CN nodes for compute tasks
SET GLOBAL prefer_compute_node = true;
SET GLOBAL use_compute_nodes = -1; -- Use all available CNs

bi_user

rg1

SELECT

INSERT

financial_db

cpu_weight

exclusive_cpu_cores

20%

sql
CREATE RESOURCE GROUP analytics_rg
TO (user='alice', role='analyst')
WITH (
    "cpu_weight" = "10",
    "mem_limit" = "30%",
    "concurrency_limit" = "10"
);

SET GLOBAL enable_pipeline_engine = true;

user

role

db

query_type

SELECT

INSERT

source_ip

plan_cpu_cost_range

(0, 1000]

plan_mem_cost_range

sql
CREATE RESOURCE GROUP analytic_team
TO 
    (user='alice', role='analyst'), -- Classifier 1
    (db='reporting_db', query_type in ('select')) -- Classifier 2
WITH (
    "cpu_weight" = "10",
    "mem_limit" = "20%"
);

sql
SET resource_group = 'high_priority_rg';

default_wg

default_mv_wg

ResourceGroup

fe.audit.log

EXPLAIN VERBOSE <your_query>;

Resource Group

OlapScanNode

EXCHANGE

SET computation_fragment_scheduling_policy = 'all_nodes';

compute_nodes_only

SHOW PROC '/frontends';

Role

fe.audit.log

bash
    # Find queries with high CPU cost on this node
    grep "QueryId" fe.audit.log | awk -F'|' '{print $1, $6}' | sort -nk2 | tail -n 20

CpuCostNs

fe.out

jstat -gcutil <pid> 1000

FGC

GCT

jstack -l <pid> > high_cpu_jstack.txt

RUNNABLE

com.starrocks.sql.optimizer

com.starrocks.catalog

org.apache.hadoop

SHOW PROC '/frontends';

jstat -gcutil <pid> 2000 10

CpuCostNs

fe.audit.log

top -Hp <pid>

jstack <pid>

checkpoint_only_on_leader = false

fe.conf

PREPARE

COMMITTED

VISIBLE