Reason:
       - MV rewrite fail for my_table_mv: stale partitions refreshType=FULL

DISTRIBUTED BY HASH(`id`) BUCKETS 2048
ORDER BY (id)
REFRESH SCHEDULE EVERY(INTERVAL 2 HOUR)
PROPERTIES (
"replicated_storage" = "true",
"replication_num" = "1",
"mv_rewrite_staleness_second" = "14400",
"datacache.enable" = "true",
"enable_async_write_back" = "false",
"storage_volume" = "shared_data_volume",
"bloom_filter_columns" = "parent_id",
"warehouse" = "default_warehouse"
)
AS SELECT *
FROM iceberg.db.table;

stale partitions refreshType=FULL

SHOW MATERIALIZED VIEWS LIKE 'my_table_mv' \G

SUCCESS

FAILED

PENDING

NULL

mv_rewrite_staleness_second

"force_external_table_query_rewrite" = "true"

sql
    ALTER MATERIALIZED VIEW my_table_mv SET ("force_external_table_query_rewrite" = "true");

query_rewrite_consistency

checked

loose

sql
    ALTER MATERIALIZED VIEW my_table_mv SET ("query_rewrite_consistency" = "loose");

loose

active

ts

PARTITION BY ts

is_active

inactive

ALTER MATERIALIZED VIEW my_table_mv ACTIVE;

sql
TRACE REASON MV <your_query>;

WHERE color='red' AND size='XL' AND brand='nike'

MATCH

=

IN

ORDER BY

ORDER BY (id)

IN

id

ORDER BY

IN

id

IN

IOTime

IN

sql
    ALTER TABLE my_table SET ("bloom_filter_columns" = "id");

id

ORDER BY

IN

materialized_view_rewrite_mode = "force"

MVPlanCacheStats

DriverTotalTime

InputEmptyTime

datacache

QueryCumulativeScanTime

IN

AnalyzeTable

IN

IN

datacache

DeployWaitTime

CACHE SELECT

sql
-- Warm up the specific MV
CACHE SELECT * FROM curated_video_mv;

video_id

api_title

sql
CACHE SELECT video_id, channel_id FROM curated_video_mv;

sql
SUBMIT TASK warmup_mv_task 
SCHEDULE EVERY (INTERVAL 1 HOUR) -- Match your MV refresh frequency
AS 
CACHE SELECT * FROM curated_video_mv;

partition_duration

sql
ALTER TABLE curated_video_mv SET ("datacache.partition_duration" = "1 MONTH");

sql
    SET GLOBAL enable_mv_query_context_cache = true;

DataCacheReadBytes

RemoteReadBytes

DataCacheReadPeerBytes

CACHE SELECT

datacache.partition_duration

enable_mv_query_context_cache

ORDER BY

video_id

starrocks-cn

starrocks-cn-8

video_id IN (...)

sql
-- This moves the data from S3 to the local CN cache
CACHE SELECT * FROM curated_video_mv;

IN

sql
ALTER TABLE curated_video_mv SET ("datacache.partition_duration" = "1 MONTH");

CACHE SELECT

SET GLOBAL enable_mv_query_context_cache = true;

sql
ALTER TABLE curated_video_mv SET ("datacache.partition_duration" = "1 MONTH");

sql
ALTER TABLE curated_video_mv SET ("datacache.partition_duration" = "100 YEAR");

sql
CACHE SELECT * FROM curated_video_mv;

datacache_disk_size

SHOW BACKENDS;

DataCacheMetrics

cn.conf

datacache_disk_size

partition_duration

100 YEAR

sql
SET GLOBAL enable_mv_query_context_cache = true;

ALTER MATERIALIZED VIEW default_catalog.starrocks.my_mv SET ("datacache.partition_duration" = "100 YEAR");

session.

datacache.partition_duration

ALTER MATERIALIZED VIEW

ALTER TABLE

ALTER TABLE

sql
ALTER TABLE default_catalog.starrocks.my_mv 
SET ("datacache.partition_duration" = "100 YEAR");

sql
SHOW CREATE TABLE default_catalog.starrocks.my_mv;

"datacache.partition_duration" = "100 YEAR"

PROPERTIES

mv_rewrite_staleness_second

partition_ttl

ALTER MATERIALIZED VIEW

datacache.*

bloom_filter_columns

replication_num

ALTER TABLE

100 YEAR

sql
CACHE SELECT * FROM default_catalog.starrocks.my_mv;

CACHE SELECT

ALTER TABLE

ALTER TABLE

ALTER MATERIALIZED VIEW

ALTER MATERIALIZED VIEW

datacache.partition_duration

CREATE

DISTRIBUTED BY HASH(video_id)

PARTITION BY

datacache.partition_duration

PARTITION BY date_column

sql
-- 1. Drop the old MV
DROP MATERIALIZED VIEW curated_video_mv;

-- 2. Re-create with partitioning
CREATE MATERIALIZED VIEW curated_video_mv
PARTITION BY date_trunc('day', event_time) -- Example partition column
DISTRIBUTED BY HASH(video_id) BUCKETS 2048
REFRESH ASYNC EVERY (INTERVAL 2 HOUR)
PROPERTIES (
    "datacache.partition_duration" = "100 YEAR"
)
AS SELECT * FROM iceberg.viewiq.my_table;

ALTER MATERIALIZED VIEW curated_video_mv SET ("datacache.partition_duration" = "100 YEAR");

partition_duration

CACHE SELECT * FROM curated_video_mv;

datacache_disk_size

cn.conf

PARTITION BY

datacache.partition_duration

datacache.partition_duration

datacache.partition_duration

2024-01-01

partition_duration

CACHE SELECT

sql
CACHE SELECT * FROM default_catalog.starrocks.curated_video_mv;

sql
SET GLOBAL enable_datacache_sharing = true;

sql
SHOW BACKENDS;
-- Look at the DataCacheMetrics column

DiskUsage

datacache_disk_size

cn.conf

DISTRIBUTED BY HASH

partition_duration

CACHE SELECT

datacache.partition_duration

datacache.partition_duration

DATE

ALTER MATERIALIZED VIEW

ALTER TABLE

sql
CACHE SELECT * FROM default_catalog.starrocks.my_mv;

SHOW BACKENDS\G

DataCacheMetrics

datacache_disk_size

cn.conf

CACHE SELECT

created_at

PROPERTIES ("datacache.partition_duration" = "100 YEAR")

CACHE SELECT

CACHE SELECT

CACHE SELECT

sql
CACHE SELECT <column_name> [, ...]
FROM [<catalog_name>.][<db_name>.]<table_name> 
[WHERE <boolean_expression>]
[PROPERTIES("verbose"="true")]

*

WHERE

PROPERTIES("verbose"="true")

sql
CACHE SELECT * FROM default_catalog.starrocks.curated_video_mv;

READ_CACHE_SIZE

WRITE_CACHE_SIZE

SELECT

sql
    SUBMIT TASK warmup_video_mv
    SCHEDULE EVERY (INTERVAL 2 HOUR)
    AS CACHE SELECT * FROM starrocks.curated_video_mv;

cn.conf

be.conf

properties
datacache_eviction_policy = SLRU

partition_duration

datacache_disk_high_level

sql
-- Run this after every MV refresh
CACHE SELECT * FROM my_dimension_mv;

SHOW BACKENDS\G

DataCacheMetrics

datacache_disk_size

datacache_eviction_policy = SLRU

partition_duration

CACHE SELECT *

datacache_disk_size

CACHE SELECT

CACHE SELECT

CACHE SELECT

CACHE SELECT

CACHE SELECT *

WHERE

sql
    CACHE SELECT * FROM my_mv;

sql
    CACHE SELECT * FROM my_mv WHERE report_date = '2023-10-27';

sql
    REFRESH MATERIALIZED VIEW my_mv;

sql
    CACHE SELECT * FROM my_mv WHERE report_date = '2023-10-27';

CACHE SELECT *

WHERE

CACHE SELECT

CACHE SELECT

SUBMIT TASK

DROP TASK

sql
DROP TASK [IF EXISTS] `task_name` [FORCE];

FORCE

RENAME

DROP

SUBMIT

sql
    -- Suspend the task
    ALTER TASK my_task SUSPEND;

    -- Resume the task
    ALTER TASK my_task RESUME;

    -- Update session properties (e.g., timeout)
    ALTER TASK my_task SET ('session.query_timeout' = '3600');

sql
SELECT task_name, schedule, state 
FROM INFORMATION_SCHEMA.tasks;

sql
SHOW MATERIALIZED VIEWS;

datacache.enable

sql
    CREATE TABLE my_table (...)
    PROPERTIES (
        "datacache.enable" = "false"
    );

sql
    ALTER TABLE my_table SET ("datacache.enable" = "false");
    ALTER MATERIALIZED VIEW my_mv SET ("datacache.enable" = "false");

false

sql
    -- This prevents the session from reading or writing to the Data Cache
    SET enable_scan_datacache = false;
    SELECT * FROM external_catalog.db.table;

sql
    SELECT /_+ SET_VAR(enable_scan_datacache = false) _/ * FROM external_catalog.db.table;

datacache.partition_duration

sql
ALTER TABLE my_table SET ("datacache.partition_duration" = "1 DAY");

"datacache.enable" = "false"

SET enable_scan_datacache = false

"datacache.partition_duration"

SELECT *

SELECT *

CACHE SELECT * FROM iceberg_table

SELECT *

SELECT *

WHERE

SELECT *

ORDER BY a, b

video_id

channel_id

sql
CREATE MATERIALIZED VIEW mv_video_stats
DISTRIBUTED BY HASH(video_id)
REFRESH ASYNC EVERY (INTERVAL 1 HOUR)
ORDER BY ZORDER(video_id, channel_id) -- Interleaved sorting for both columns
AS 
SELECT 
    video_id,
    channel_id,
    categories, -- Array column
    upload_date,
    view_count
FROM iceberg_catalog.db.raw_videos;

ORDER BY

WHERE ... IN (...)

sql
ALTER MATERIALIZED VIEW mv_video_stats 
SET ("bloom_filter_columns" = "video_id, channel_id");

categories

video_id

channel_id

array_contains

sql
    SELECT * FROM mv_video_stats
    WHERE channel_id = 123
      AND array_contains(categories, 'Gaming');

sql
    CREATE MATERIALIZED VIEW mv_categories_flattened
    ORDER BY (category_name)
    AS
    SELECT
        video_id,
        unnest as category_name
    FROM mv_video_stats, unnest(categories);

video_id

channel_id

ORDER BY ZORDER(video_id, channel_id)

IN

=

SET ("bloom_filter_columns" = "video_id, channel_id")

array_contains()

SELECT *

video_id

sql
CREATE MATERIALIZED VIEW mv_category_search
PARTITION BY (upload_date) -- Match your Iceberg partition key
DISTRIBUTED BY HASH(category_name) 
ORDER BY (category_name) -- Sort by category for instant lookups
AS 
SELECT 
    video_id, 
    upload_date,
    category_name
FROM iceberg_table, unnest(categories) AS category_name;

video_id

category_name

SELECT * FROM iceberg_table WHERE array_contains(categories, 'Gaming')

mv_category_search

video_id

channel_id

sql
-- On the base table or a "primary" MV
PROPERTIES (
    "bloom_filter_columns" = "video_id, channel_id",
    "table_sort_kind" = "ZORDER",
    "order_by" = "video_id, channel_id"
);

channel_id

video_id

WHERE video_id IN (...)

array_contains

SELECT *

REFRESH ASYNC

channel_id

channel_id

array_contains

STRING

REFRESH

video_id

channel_id

sql
CREATE MATERIALIZED VIEW mv_videos_wide
PARTITION BY (upload_date)
DISTRIBUTED BY HASH(video_id) -- Or channel_id, depending on your most common join
ORDER BY ZORDER(video_id, channel_id)
PROPERTIES (
    "bloom_filter_columns" = "video_id, channel_id"
)
AS 
SELECT video_id, channel_id, categories, title, description, url, metadata...
FROM iceberg_catalog.db.raw_videos;

video_id IN (...)

channel_id IN (...)

category

video_id

sql
CREATE MATERIALIZED VIEW mv_category_index
PARTITION BY (upload_date)
DISTRIBUTED BY HASH(category_name)
ORDER BY (category_name) -- Perfect for fast equality/IN filters
AS 
SELECT 
    unnest as category_name,
    video_id,
    upload_date
FROM mv_videos_wide, unnest(categories);

sql
SELECT v.* 
FROM mv_videos_wide v
JOIN mv_category_index c ON v.video_id = c.video_id AND v.upload_date = c.upload_date
WHERE c.category_name = 'Gaming';

category_name

STRING

ARRAY

"Gaming Tech Vlog"

sql
    ALTER MATERIALIZED VIEW mv_videos_wide ADD INDEX idx_cat (categories_str) USING GIN;

sql
    SELECT * FROM mv_videos_wide WHERE categories_str MATCH 'Gaming';

ARRAY

array_intersect

ARRAY

STRING

channel_id

region_id

PARTITION BY

INSERT INTO ... SELECT

video_id

video_id

channel_id

WHERE video_id IN (...)

sql
CREATE MATERIALIZED VIEW mv_video_lookup
DISTRIBUTED BY HASH(video_id)
-- If base table is partitioned by 'category_id', include it here:
-- PARTITION BY category_id 
ORDER BY ZORDER(video_id, channel_id) -- Interleaved sorting
PROPERTIES (
    "bloom_filter_columns" = "video_id, channel_id"
)
AS 
SELECT video_id, channel_id, categories, title, ... 
FROM iceberg_catalog.db.raw_videos;

ARRAY

array_contains

video_id

sql
    CREATE MATERIALIZED VIEW mv_category_index
    DISTRIBUTED BY HASH(category_name)
    ORDER BY (category_name) -- Perfect for fast lookups
    AS
    SELECT
        unnest as category_name,
        video_id
    FROM mv_video_lookup, unnest(categories);

category_name

video_ids

sql
    SELECT v.*
    FROM mv_video_lookup v
    JOIN mv_category_index c ON v.video_id = c.video_id
    WHERE c.category_name = 'Gaming';

INSERT

ORDER BY ZORDER(video_id, channel_id)

bloom_filter_columns

unnest

BUCKETS

DISTRIBUTED BY HASH(video_id)

BUCKETS 1000

HASH(video_id)

video_id

WHERE video_id = 123

channel_id

video_id

channel_id

categories

video_id

HASH(video_id, channel_id)

video_id

WHERE

DISTRIBUTED BY HASH(video_id) BUCKETS 1000

ZORDER

ORDER BY

CREATE TABLE

CREATE MATERIALIZED VIEW

video_id

channel_id

sql
CREATE MATERIALIZED VIEW mv_videos_wide
DISTRIBUTED BY HASH(video_id) -- or HASH(channel_id)
ORDER BY (video_id, channel_id) -- Use parentheses, no ZORDER keyword
PROPERTIES (
    "bloom_filter_columns" = "video_id, channel_id"
)
AS 
SELECT video_id, channel_id, ... 
FROM base_table;

ORDER BY

channel_id

bloom_filter_columns

video_id

channel_id

sql
-- After creating the MV, add inverted indexes
ALTER MATERIALIZED VIEW mv_videos_wide 
ADD INDEX idx_vid (video_id) USING GIN;

ALTER MATERIALIZED VIEW mv_videos_wide 
ADD INDEX idx_cid (channel_id) USING GIN;

encode_sort_key

encode_sort_key()

ORDER BY

sql
CREATE TABLE example (
    v1 INT,
    v2 VARCHAR,
    -- Generate a composite sort key
    sort_col VARBINARY(1024) AS (encode_sort_key(v1, v2))
)
ORDER BY (sort_col);

ZORDER(...)

ORDER BY (video_id, channel_id)

"bloom_filter_columns" = "video_id, channel_id"

channel_id

video_id

channel_id

video_id

ORDER BY

channel_id

video_id

min/max

(video_id, channel_id)

channel_id

video_id

channel_id

channel_id

channel_id

video_id

=

IN

channel_id

sql
ALTER MATERIALIZED VIEW mv_name SET ("bloom_filter_columns" = "channel_id");

sql
ALTER MATERIALIZED VIEW mv_name ADD INDEX idx_channel (channel_id) USING GIN;

ORDER BY

channel_id

video_id

channel_id

video_id

ORDER BY

channel_id

enable_experimental_gin

SYSTEM

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

ADMIN SET

fe.conf

fe/conf/

conf
    enable_experimental_gin = true

"imp_lib" = "builtin"

sql
        INDEX idx_name (column_name) USING GIN("imp_lib" = "builtin");

replicated_storage

false

__row

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

PRIMARY KEY

store_type

sql
CREATE MATERIALIZED VIEW mv_dimensional_data
PRIMARY KEY (id)
DISTRIBUTED BY HASH(id)
PROPERTIES (
    "store_type" = "column_with_row"
)
AS 
SELECT 
    id, 
    attr1, 
    attr2, 
    attr3, 
    ... -- project many columns
FROM base_table;

SUM(revenue)

SELECT * FROM mv WHERE id = 123

__row

_

%

GRANT

_._

db_name._

def

abc

information_schema.tables

GRANT

sql
SELECT CONCAT('GRANT SELECT ON TABLE ', table_schema, '.', table_name, " TO 'user'@'%';")
FROM information_schema.tables
WHERE table_schema = 'abc' 
  AND table_name LIKE 'def%';

GRANT

sql
GRANT SELECT ON TABLE abc.def_1, abc.def_2, abc.def_v3 TO USER 'user'@'%';

GRANT SELECT ON abc.* TO USER 'user'@'%';

abc

TABLE

GRANT SELECT ON TABLE abc.def_1 TO USER 'user'@'%';

LIKE 'def%'

lower_case_table_names

SUBMIT TASK

information_schema

tasks

sql
SELECT * FROM information_schema.tasks;

sql
    SELECT * FROM information_schema.tasks WHERE task_name = 'your_task_name';

sql
    SELECT definition FROM information_schema.tasks WHERE task_name = 'your_task_name';

task_runs

sql
SELECT * FROM information_schema.task_runs;

sql
    SELECT task_name, status, create_time, finish_time, error_message
    FROM information_schema.task_runs
    WHERE task_name = 'your_task_name'
    ORDER BY create_time DESC;

information_schema.tasks

information_schema.task_runs

DROP TASK <task_name>;

ALTER TASK <task_name> SET SCHEDULE EVERY (INTERVAL 1 DAY);

INSERT INTO TABLE task_runs (task_name) VALUES ('your_task_name');

SUBMIT TASK

date

month(date)

date_trunc

PARTITION BY

month

month(date_col)

PARTITION BY date_trunc('month', date_col)

iceberg_catalog.db.orders

month(order_date)

sql
CREATE MATERIALIZED VIEW mv_monthly_orders
PARTITION BY date_trunc('month', order_date)
REFRESH ASYNC
AS 
SELECT 
    order_date,
    order_id,
    amount
FROM iceberg_catalog.db.orders;

order_date

SELECT

DATE

DATETIME

date_trunc

year(col)

date_trunc('year', col)

month(col)

date_trunc('month', col)

day(col)

date_trunc('day', col)

hour(col)

date_trunc('hour', col)

enable_datacache_sharing = true

DataCacheReadPeerBytes

IOTimeRemote

CompressedBytesReadRemote

sql
    -- Enable on FE
    ADMIN SET FRONTEND CONFIG ("enable_trace_historical_node" = "true");
    -- Enable for the session or globally
    SET GLOBAL enable_datacache_sharing = true;

CACHE SELECT

pipeline_dop

pipeline_dop

pipeline_dop

sql
    -- For short, high-frequency queries, 1, 2, or 4 is often optimal.
    SET GLOBAL pipeline_dop = 2;

concurrency_limit

sql
    ALTER RESOURCE GROUP your_app_group WITH (
        "concurrency_limit" = "20" -- Adjust based on your core count and testing
    );
    -- Ensure the queue is enabled
    SET GLOBAL enable_group_level_query_queue = true;

PendingTimeMs

fe.audit.log

cpu_weight

exclusive_cpu_cores

cpu_weight

sql
    -- Remove exclusive cores and set weight instead (e.g., 60 vs 40)
    ALTER RESOURCE GROUP your_app_group WITH (
        "exclusive_cpu_cores" = "0",
        "cpu_weight" = "60"
    );

sql
    ALTER RESOURCE GROUP your_app_group WITH (
        "big_query_cpu_second_limit" = "10", -- Kill query if it uses > 10s of CPU on a single BE
        "big_query_mem_limit" = "2147483648" -- 2GB limit per query on a BE
    );

pipeline_dop

SHOW PROC '/backends';

NumRunningQueries

CpuUsedPct

Warehouse default_warehouse is not available

default_warehouse

sql
    SHOW COMPUTE NODES;
    -- or if using multiple warehouses
    SHOW WAREHOUSES;

Running

cn.out

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

default_warehouse

sql
    ALTER SYSTEM ADD COMPUTE NODE "host:port";

sql
    ALTER WAREHOUSE default_warehouse RESUME;

heartbeat_service_port

9050

brpc_port

8060

Failed to send heartbeat

RPC call failed

fe.log

SET WAREHOUSE = ...

SELECT current_warehouse();

default_warehouse

SHOW BACKENDS;

SHOW COMPUTE NODES;

Alive

false

fe.log

WarehouseManager

USAGE

app_user

default_warehouse

root

admin

sql
-- Replace 'app_user' with your actual application username
GRANT USAGE ON WAREHOUSE default_warehouse TO USER 'app_user'@'%';

root

sql
SET GLOBAL activate_all_roles_on_login = TRUE;

sql
ALTER USER 'app_user'@'%' DEFAULT ROLE 'your_app_role';

sql
SELECT current_warehouse(); -- Should return 'default_warehouse'
SELECT current_role();      -- See which roles are actually active for the app
SHOW GRANTS;                -- Verify the user has USAGE on the warehouse

SELECT current_warehouse()

current_warehouse()

SELECT

sql
SHOW COMPUTE NODES;
-- If you are not using Shared-Data architecture, use:
SHOW BACKENDS;

Alive

false

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

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

sql
SHOW WAREHOUSES;

default_warehouse

default_warehouse

sql
    ALTER WAREHOUSE default_warehouse RESUME;

sql
    GRANT USAGE ON WAREHOUSE default_warehouse TO USER 'your_app_user'@'%';

fe.log

RPC failed

Master find no backend

8060

9050

ps aux | grep starrocks

SHOW COMPUTE NODES

Alive: true

USAGE

SELECT current_warehouse()

default_warehouse

USAGE

USAGE

current_warehouse()

SELECT

sql
    -- Grant usage if not already present
    GRANT USAGE ON WAREHOUSE default_warehouse TO USER 'your_app_user'@'%';

    -- Ensure roles are automatically activated for the application session
    SET GLOBAL activate_all_roles_on_login = TRUE;

SUSPENDED

root

SHOW WAREHOUSES;

sql
    GRANT ALTER ON WAREHOUSE default_warehouse TO USER 'your_app_user'@'%';

warehouse

default_warehouse

Default_Warehouse

jdbc:mysql://<host>:<port>/default_catalog.<db_name>

default_warehouse

SHOW RESOURCE GROUPS;

user

host

sql
SELECT current_user();
SELECT current_role();
SHOW GRANTS;
SHOW COMPUTE NODES; -- See if 'Alive' is true from the App's perspective

SHOW COMPUTE NODES

Alive: false

SELECT

SELECT

your_db

your_user

SELECT

sql
-- Ensure you are in the correct catalog context
SET CATALOG default_catalog;

-- Revoke SELECT on all MVs in the specific database
REVOKE SELECT ON ALL MATERIALIZED VIEWS IN DATABASE your_db FROM USER 'your_user'@'%';

your_user

your_db

enable_materialized_view_rewrite

sql
-- Disable MV rewrite for this user permanently
ALTER USER 'your_user'@'%' SET PROPERTIES ('session.enable_materialized_view_rewrite' = 'false');

EXPLAIN

sql
EXPLAIN SELECT ... FROM base_table;

base_table

materialized_view_name

ADMIN

SELECT

ALL DATABASES

SELECT

sql
-- You must be in the correct catalog context
SET CATALOG default_catalog;

REVOKE SELECT ON ALL MATERIALIZED VIEWS IN DATABASE <db_name> FROM USER 'user_identity';

sql
-- Revoke from specific MVs by listing them
REVOKE SELECT ON MATERIALIZED VIEW <mv_name1>, <mv_name2> IN DATABASE <db_name> FROM USER 'user_identity';

-- Or use the fully qualified name
REVOKE SELECT ON MATERIALIZED VIEW <db_name>.<mv_name> FROM USER 'user_identity';

SELECT

SELECT

SET CATALOG default_catalog;

'user_identity'

'username'@'host'

'report_user'@'%'

sql
SHOW GRANTS FOR 'user_identity';

GRANT

ALL MATERIALIZED VIEWS

catalog.database

SET CATALOG

sql
-- 1. Switch to the catalog
SET CATALOG default_catalog;

-- 2. Run the GRANT command using only the database name
GRANT SELECT ON ALL MATERIALIZED VIEWS IN DATABASE starrocks TO USER 'user'@'%';

GRANT

IN DATABASE <db_name>

SET CATALOG

'user'@'%'

CREATE USER

db.mv_name

ALL ... IN DATABASE

r8gd

r8g

EXPLAIN ANALYZE

DataCacheReadBytes

DataCacheWriteBytes

DataCacheReadTimer

bash
curl http://<BE_IP>:<BE_HTTP_PORT>/api/datacache/stat

block_cache_hit_rate

block_cache_read_disk_bytes

block_cache_write_fail_count

fslib cache hit ratio

r8gd.4xlarge

r8g.4xlarge

r8gd.4xlarge

r8gd

r8gd

r8g

r8gd

r8gd

r8g

CACHE SELECT

storage_root_path

cn.conf

be.conf

storage_root_path

${STARROCKS_HOME}/storage

r8gd

/data/cache

storage_root_path = /data/cache

starlet_cache/

r8gd

storage_root_path

d

r8g

sql
SELECT * FROM information_schema.be_configs WHERE NAME = 'storage_root_path';

df -h <path>

storage_root_path

starlet_cache/

datacache/

/mnt/nvme/storage

/mnt/ebs/storage

r8gd

starlet_star_cache_disk_size_percent

df -h

properties
-- Optimized for r8gd
storage_root_path = /mnt/nvme/storage