From 908f7536e112b52cca04b13ef584e8fd00ba483d Mon Sep 17 00:00:00 2001 From: garenshi Date: Fri, 25 Apr 2025 10:14:15 +0800 Subject: [PATCH 1/4] [Feature](MTMV) add mv dependence system table --- be/src/exec/schema_scanner.cpp | 3 + .../schema_mv_dependence_scanner.cpp | 140 ++++++++++++++++++ .../schema_mv_dependence_scanner.h | 56 +++++++ .../doris/analysis/SchemaTableType.java | 4 +- .../org/apache/doris/catalog/SchemaTable.java | 10 ++ .../org/apache/doris/mtmv/BaseTableInfo.java | 16 ++ .../tablefunction/MetadataGenerator.java | 50 +++++++ gensrc/thrift/Descriptors.thrift | 3 +- gensrc/thrift/FrontendService.thrift | 1 + 9 files changed, 281 insertions(+), 2 deletions(-) create mode 100644 be/src/exec/schema_scanner/schema_mv_dependence_scanner.cpp create mode 100644 be/src/exec/schema_scanner/schema_mv_dependence_scanner.h diff --git a/be/src/exec/schema_scanner.cpp b/be/src/exec/schema_scanner.cpp index 0940eadb4951fd..bd55c1bcfa3704 100644 --- a/be/src/exec/schema_scanner.cpp +++ b/be/src/exec/schema_scanner.cpp @@ -37,6 +37,7 @@ #include "exec/schema_scanner/schema_file_cache_statistics.h" #include "exec/schema_scanner/schema_files_scanner.h" #include "exec/schema_scanner/schema_metadata_name_ids_scanner.h" +#include "exec/schema_scanner/schema_mv_dependence_scanner.h" #include "exec/schema_scanner/schema_partitions_scanner.h" #include "exec/schema_scanner/schema_processlist_scanner.h" #include "exec/schema_scanner/schema_profiling_scanner.h" @@ -231,6 +232,8 @@ std::unique_ptr SchemaScanner::create(TSchemaTableType::type type return SchemaBackendKerberosTicketCacheScanner::create_unique(); case TSchemaTableType::SCH_ROUTINE_LOAD_JOBS: return SchemaRoutineLoadJobScanner::create_unique(); + case TSchemaTableType::SCH_MV_DEPENDENCE: + return SchemaMvDependenceScanner::create_unique(); default: return SchemaDummyScanner::create_unique(); break; diff --git a/be/src/exec/schema_scanner/schema_mv_dependence_scanner.cpp b/be/src/exec/schema_scanner/schema_mv_dependence_scanner.cpp new file mode 100644 index 00000000000000..68a398f0cc8019 --- /dev/null +++ b/be/src/exec/schema_scanner/schema_mv_dependence_scanner.cpp @@ -0,0 +1,140 @@ +// 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. + +#include + +#include + +#include "exec/schema_scanner/schema_mv_dependence_scanner.h" +#include "exec/schema_scanner/schema_helper.h" +#include "runtime/client_cache.h" +#include "runtime/exec_env.h" +#include "runtime/runtime_state.h" +#include "util/thrift_rpc_helper.h" +#include "vec/common/string_ref.h" +#include "vec/core/block.h" +#include "vec/data_types/data_type_factory.hpp" + +namespace doris { + +std::vector SchemaMvDependenceScanner::_s_mv_dependence_columns = { + {"SRC_CATALOG", TYPE_VARCHAR, sizeof(StringRef), false}, + {"SRC_DATABASE", TYPE_VARCHAR, sizeof(StringRef), false}, + {"SRC_TABLE", TYPE_VARCHAR, sizeof(StringRef), false}, + {"FROM_CATALOG", TYPE_VARCHAR, sizeof(StringRef), false}, + {"FROM_DATABASE", TYPE_VARCHAR, sizeof(StringRef), false}, + {"FROM_TABLE", TYPE_VARCHAR, sizeof(StringRef), false}, + {"FROM_TABLE_TYPE", TYPE_VARCHAR, sizeof(StringRef), false} +}; + +SchemaMvDependenceScanner::SchemaMvDependenceScanner() + : SchemaScanner(_s_mv_dependence_columns, TSchemaTableType::SCH_MV_DEPENDENCE) {} + +SchemaMvDependenceScanner::~SchemaMvDependenceScanner() = default; + +Status SchemaMvDependenceScanner::start(RuntimeState* state) { + _block_rows_limit = state->batch_size(); + _rpc_timeout = state->execution_timeout() * 1000; + return Status::OK(); +} + +Status SchemaMvDependenceScanner::_get_mv_dependence_block_from_fe() { + TNetworkAddress master_addr = ExecEnv::GetInstance()->master_info()->network_address; + + TSchemaTableRequestParams schema_table_request_params; + for (int i = 0; i < _s_mv_dependence_columns.size(); i++) { + schema_table_request_params.__isset.columns_name = true; + schema_table_request_params.columns_name.emplace_back(_s_mv_dependence_columns[i].name); + } + schema_table_request_params.__set_current_user_ident(*_param->common_param->current_user_ident); + + TFetchSchemaTableDataRequest request; + request.__set_schema_table_name(TSchemaTableName::MV_DEPENDENCE); + request.__set_schema_table_params(schema_table_request_params); + + TFetchSchemaTableDataResult result; + + RETURN_IF_ERROR(ThriftRpcHelper::rpc( + master_addr.hostname, master_addr.port, + [&request, &result](FrontendServiceConnection& client) { + client->fetchSchemaTableData(result, request); + }, + _rpc_timeout)); + + Status status(Status::create(result.status)); + if (!status.ok()) { + LOG(WARNING) << "fetch transactions from FE failed, errmsg=" << status; + return status; + } + std::vector result_data = result.data_batch; + + _mv_dependence_block = vectorized::Block::create_unique(); + for (int i = 0; i < _s_mv_dependence_columns.size(); ++i) { + TypeDescriptor descriptor(_s_mv_dependence_columns[i].type); + auto data_type = vectorized::DataTypeFactory::instance().create_data_type(descriptor, true); + _mv_dependence_block->insert(vectorized::ColumnWithTypeAndName( + data_type->create_column(), data_type, _s_mv_dependence_columns[i].name)); + } + + _mv_dependence_block->reserve(_block_rows_limit); + + if (result_data.size() > 0) { + auto col_size = result_data[0].column_value.size(); + if (col_size != _s_mv_dependence_columns.size()) { + return Status::InternalError("transactions schema is not match for FE and BE"); + } + } + + for (int i = 0; i < result_data.size(); i++) { + TRow row = result_data[i]; + for (int j = 0; j < _s_mv_dependence_columns.size(); j++) { + RETURN_IF_ERROR(insert_block_column(row.column_value[j], j, _mv_dependence_block.get(), + _s_mv_dependence_columns[j].type)); + } + } + return Status::OK(); +} + +Status SchemaMvDependenceScanner::get_next_block_internal(vectorized::Block* block, bool* eos) { + if (!_is_init) { + return Status::InternalError("Used before initialized."); + } + + if (nullptr == block || nullptr == eos) { + return Status::InternalError("input pointer is nullptr."); + } + + if (_mv_dependence_block == nullptr) { + RETURN_IF_ERROR(_get_mv_dependence_block_from_fe()); + _total_rows = (int)_mv_dependence_block->rows(); + } + + if (_row_idx == _total_rows) { + *eos = true; + return Status::OK(); + } + + int current_batch_rows = std::min(_block_rows_limit, _total_rows - _row_idx); + vectorized::MutableBlock mblock = vectorized::MutableBlock::build_mutable_block(block); + RETURN_IF_ERROR(mblock.add_rows(_mv_dependence_block.get(), _row_idx, current_batch_rows)); + _row_idx += current_batch_rows; + + *eos = _row_idx == _total_rows; + return Status::OK(); +} + +} // namespace doris diff --git a/be/src/exec/schema_scanner/schema_mv_dependence_scanner.h b/be/src/exec/schema_scanner/schema_mv_dependence_scanner.h new file mode 100644 index 00000000000000..84e885cf8a3fc9 --- /dev/null +++ b/be/src/exec/schema_scanner/schema_mv_dependence_scanner.h @@ -0,0 +1,56 @@ +// 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. + +#pragma once + +#include +#include + +#include "common/status.h" +#include "exec/schema_scanner.h" + +namespace doris { + +class RuntimeState; + +namespace vectorized { +class Block; +} + +class SchemaMvDependenceScanner : public SchemaScanner { + ENABLE_FACTORY_CREATOR(SchemaMvDependenceScanner); + +public: + SchemaMvDependenceScanner(); + ~SchemaMvDependenceScanner() override; + + Status start(RuntimeState* state) override; + Status get_next_block_internal(vectorized::Block* block, bool* eos) override; + + static std::vector _s_mv_dependence_columns; + +private: + Status _get_mv_dependence_block_from_fe(); + + int _block_rows_limit = 4096; + int _row_idx = 0; + int _total_rows = 0; + std::unique_ptr _mv_dependence_block = nullptr; + int _rpc_timeout = 3000; +}; + +} // namespace doris diff --git a/fe/fe-core/src/main/java/org/apache/doris/analysis/SchemaTableType.java b/fe/fe-core/src/main/java/org/apache/doris/analysis/SchemaTableType.java index 7bb9e44412a272..8c5fbb2e7facfb 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/analysis/SchemaTableType.java +++ b/fe/fe-core/src/main/java/org/apache/doris/analysis/SchemaTableType.java @@ -92,7 +92,9 @@ public enum SchemaTableType { SCH_BACKEND_KERBEROS_TICKET_CACHE("BACKEND_KERBEROS_TICKET_CACHE", "BACKEND_KERBEROS_TICKET_CACHE", TSchemaTableType.SCH_BACKEND_KERBEROS_TICKET_CACHE), SCH_ROUTINE_LOAD_JOBS("ROUTINE_LOAD_JOBS", "ROUTINE_LOAD_JOBS", - TSchemaTableType.SCH_ROUTINE_LOAD_JOBS); + TSchemaTableType.SCH_ROUTINE_LOAD_JOBS), + SCH_MV_DEPENDENCE("MV_DEPENDENCE", "MV_DEPENDENCE", + TSchemaTableType.SCH_MV_DEPENDENCE); private static final String dbName = "INFORMATION_SCHEMA"; private static SelectList fullSelectLists; diff --git a/fe/fe-core/src/main/java/org/apache/doris/catalog/SchemaTable.java b/fe/fe-core/src/main/java/org/apache/doris/catalog/SchemaTable.java index 13c44f2fed81b0..6d453ada526048 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/catalog/SchemaTable.java +++ b/fe/fe-core/src/main/java/org/apache/doris/catalog/SchemaTable.java @@ -621,6 +621,16 @@ public class SchemaTable extends Table { .column("IS_ABNORMAL_PAUSE", ScalarType.createType(PrimitiveType.BOOLEAN)) .build()) ) + .put("mv_dependence", + new SchemaTable(SystemIdGenerator.getNextId(), "mv_dependence", TableType.SCHEMA, + builder().column("SRC_CATALOG", ScalarType.createVarchar(NAME_CHAR_LEN)) + .column("SRC_DATABASE", ScalarType.createVarchar(NAME_CHAR_LEN)) + .column("SRC_TABLE", ScalarType.createVarchar(NAME_CHAR_LEN)) + .column("FROM_CATALOG", ScalarType.createVarchar(NAME_CHAR_LEN)) + .column("FROM_DATABASE", ScalarType.createVarchar(NAME_CHAR_LEN)) + .column("FROM_TABLE", ScalarType.createVarchar(NAME_CHAR_LEN)) + .column("FROM_TABLE_TYPE", ScalarType.createVarchar(NAME_CHAR_LEN)) + .build())) .build(); private boolean fetchAllFe = false; diff --git a/fe/fe-core/src/main/java/org/apache/doris/mtmv/BaseTableInfo.java b/fe/fe-core/src/main/java/org/apache/doris/mtmv/BaseTableInfo.java index 625fe7d91870ef..208a9357cd2f41 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/mtmv/BaseTableInfo.java +++ b/fe/fe-core/src/main/java/org/apache/doris/mtmv/BaseTableInfo.java @@ -18,6 +18,7 @@ package org.apache.doris.mtmv; import org.apache.doris.catalog.DatabaseIf; +import org.apache.doris.catalog.Env; import org.apache.doris.catalog.OlapTable; import org.apache.doris.catalog.TableIf; import org.apache.doris.common.AnalysisException; @@ -33,6 +34,7 @@ import org.apache.logging.log4j.Logger; import java.util.List; +import java.util.Optional; public class BaseTableInfo { private static final Logger LOG = LogManager.getLogger(BaseTableInfo.class); @@ -122,6 +124,20 @@ public boolean isInternalTable() { } } + public String getType() { + CatalogIf catalog = Env.getCurrentEnv().getCatalogMgr().getCatalog(ctlName); + if (catalog != null) { + Optional db = catalog.getDb(dbName); + if (db.isPresent()) { + Optional table = db.get().getTable(tableName); + if (table.isPresent()) { + return table.get().getType().name(); + } + } + } + return "UNKNOWN"; + } + public boolean isValid() { return ctlName != null && dbName != null && tableName != null; } diff --git a/fe/fe-core/src/main/java/org/apache/doris/tablefunction/MetadataGenerator.java b/fe/fe-core/src/main/java/org/apache/doris/tablefunction/MetadataGenerator.java index 4e7cd6b5116822..ea913ca9031521 100644 --- a/fe/fe-core/src/main/java/org/apache/doris/tablefunction/MetadataGenerator.java +++ b/fe/fe-core/src/main/java/org/apache/doris/tablefunction/MetadataGenerator.java @@ -64,7 +64,9 @@ import org.apache.doris.job.common.JobType; import org.apache.doris.job.extensions.mtmv.MTMVJob; import org.apache.doris.job.task.AbstractTask; +import org.apache.doris.mtmv.BaseTableInfo; import org.apache.doris.mtmv.MTMVPartitionUtil; +import org.apache.doris.mtmv.MTMVRelation; import org.apache.doris.mtmv.MTMVStatus; import org.apache.doris.mysql.privilege.PrivPredicate; import org.apache.doris.plsql.metastore.PlsqlManager; @@ -121,6 +123,7 @@ import java.util.Collection; import java.util.List; import java.util.Map; +import java.util.Set; import java.util.concurrent.TimeUnit; public class MetadataGenerator { @@ -144,6 +147,8 @@ public class MetadataGenerator { private static final ImmutableMap PARTITIONS_COLUMN_TO_INDEX; + private static final ImmutableMap MV_DEPENDENCE_COLUMN_TO_INDEX; + static { ImmutableMap.Builder activeQueriesbuilder = new ImmutableMap.Builder(); List activeQueriesColList = SchemaTable.TABLE_MAP.get("active_queries").getFullSchema(); @@ -205,6 +210,13 @@ public class MetadataGenerator { partitionsBuilder.put(partitionsColList.get(i).getName().toLowerCase(), i); } PARTITIONS_COLUMN_TO_INDEX = partitionsBuilder.build(); + + ImmutableMap.Builder mvDependenceBuilder = new ImmutableMap.Builder(); + List mvDependenceBuilderColList = SchemaTable.TABLE_MAP.get("mv_dependence").getFullSchema(); + for (int i = 0; i < mvDependenceBuilderColList.size(); i++) { + mvDependenceBuilder.put(mvDependenceBuilderColList.get(i).getName().toLowerCase(), i); + } + MV_DEPENDENCE_COLUMN_TO_INDEX = mvDependenceBuilder.build(); } public static TFetchSchemaTableDataResult getMetadataTable(TFetchSchemaTableDataRequest request) throws TException { @@ -314,6 +326,10 @@ public static TFetchSchemaTableDataResult getSchemaTableData(TFetchSchemaTableDa result = partitionsMetadataResult(schemaTableParams); columnIndex = PARTITIONS_COLUMN_TO_INDEX; break; + case MV_DEPENDENCE: + result = mvDependenceMetadataResult(schemaTableParams); + columnIndex = MV_DEPENDENCE_COLUMN_TO_INDEX; + break; default: return errorResult("invalid schema table name."); } @@ -639,6 +655,40 @@ private static TFetchSchemaTableDataResult workloadGroupsMetadataResult(TSchemaT return result; } + private static TFetchSchemaTableDataResult mvDependenceMetadataResult(TSchemaTableRequestParams params) { + if (!params.isSetCurrentUserIdent()) { + return errorResult("current user ident is not set."); + } + Collection> allDbs = Env.getCurrentEnv().getInternalCatalog().getAllDbs(); + TFetchSchemaTableDataResult result = new TFetchSchemaTableDataResult(); + List dataBatch = Lists.newArrayList(); + for (DatabaseIf db : allDbs) { + List tables = db.getTables(); + String dbName = db.getFullName(); + for (TableIf table : tables) { + if (table instanceof MTMV) { + String tableName = table.getName(); + MTMVRelation relation = ((MTMV) table).getRelation(); + Set tablesOneLevel = relation.getBaseTablesOneLevel(); + for (BaseTableInfo info : tablesOneLevel) { + TRow trow = new TRow(); + trow.addToColumnValue(new TCell().setStringVal("internal")); + trow.addToColumnValue(new TCell().setStringVal(dbName)); + trow.addToColumnValue(new TCell().setStringVal(tableName)); + trow.addToColumnValue(new TCell().setStringVal(info.getCtlName())); + trow.addToColumnValue(new TCell().setStringVal(info.getDbName())); + trow.addToColumnValue(new TCell().setStringVal(info.getTableName())); + trow.addToColumnValue(new TCell().setStringVal(info.getType())); + dataBatch.add(trow); + } + } + } + } + result.setDataBatch(dataBatch); + result.setStatus(new TStatus(TStatusCode.OK)); + return result; + } + private static TFetchSchemaTableDataResult workloadSchedPolicyMetadataResult(TSchemaTableRequestParams params) { if (!params.isSetCurrentUserIdent()) { return errorResult("current user ident is not set."); diff --git a/gensrc/thrift/Descriptors.thrift b/gensrc/thrift/Descriptors.thrift index 3a50a36c28d729..647050f9a6ac01 100644 --- a/gensrc/thrift/Descriptors.thrift +++ b/gensrc/thrift/Descriptors.thrift @@ -140,7 +140,8 @@ enum TSchemaTableType { SCH_FILE_CACHE_STATISTICS = 51, SCH_CATALOG_META_CACHE_STATISTICS = 52, SCH_BACKEND_KERBEROS_TICKET_CACHE = 53, - SCH_ROUTINE_LOAD_JOBS = 54; + SCH_ROUTINE_LOAD_JOBS = 54, + SCH_MV_DEPENDENCE = 55; } enum THdfsCompression { diff --git a/gensrc/thrift/FrontendService.thrift b/gensrc/thrift/FrontendService.thrift index 9e6cddba329664..4907987241673b 100644 --- a/gensrc/thrift/FrontendService.thrift +++ b/gensrc/thrift/FrontendService.thrift @@ -822,6 +822,7 @@ enum TSchemaTableName { TABLE_PROPERTIES = 8, CATALOG_META_CACHE_STATS = 9, PARTITIONS = 10, + MV_DEPENDENCE = 11, } struct TMetadataTableRequestParams { From 5f132fe9ed8282b79cf1486a49a885e9338d9c11 Mon Sep 17 00:00:00 2001 From: garenshi Date: Fri, 25 Apr 2025 10:20:04 +0800 Subject: [PATCH 2/4] 1 --- be/src/exec/schema_scanner/schema_mv_dependence_scanner.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/be/src/exec/schema_scanner/schema_mv_dependence_scanner.cpp b/be/src/exec/schema_scanner/schema_mv_dependence_scanner.cpp index 68a398f0cc8019..b9d96ff0c1bb92 100644 --- a/be/src/exec/schema_scanner/schema_mv_dependence_scanner.cpp +++ b/be/src/exec/schema_scanner/schema_mv_dependence_scanner.cpp @@ -53,7 +53,7 @@ Status SchemaMvDependenceScanner::start(RuntimeState* state) { } Status SchemaMvDependenceScanner::_get_mv_dependence_block_from_fe() { - TNetworkAddress master_addr = ExecEnv::GetInstance()->master_info()->network_address; + TNetworkAddress master_addr = ExecEnv::GetInstance()->cluster_info()->master_fe_addr; TSchemaTableRequestParams schema_table_request_params; for (int i = 0; i < _s_mv_dependence_columns.size(); i++) { From d3c06d78c2417b49ae6f6600f61dba939dd148e5 Mon Sep 17 00:00:00 2001 From: garenshi Date: Fri, 25 Apr 2025 14:23:11 +0800 Subject: [PATCH 3/4] 1 --- .../schema_table/test_mv_dependence.out | 7 ++ .../schema_table/test_mv_dependence.groovy | 98 +++++++++++++++++++ 2 files changed, 105 insertions(+) create mode 100644 regression-test/data/query_p0/schema_table/test_mv_dependence.out create mode 100644 regression-test/suites/query_p0/schema_table/test_mv_dependence.groovy diff --git a/regression-test/data/query_p0/schema_table/test_mv_dependence.out b/regression-test/data/query_p0/schema_table/test_mv_dependence.out new file mode 100644 index 00000000000000..bc7fa5c78caaf2 --- /dev/null +++ b/regression-test/data/query_p0/schema_table/test_mv_dependence.out @@ -0,0 +1,7 @@ +-- This file is automatically generated. You should know what you did if you want to edit this +-- !sql -- +internal test_mv_dependence_db mv_a internal test stu OLAP +internal test_mv_dependence_db mv_b internal test mv_a MATERIALIZED_VIEW +internal test_mv_dependence_db mv_c internal test stu OLAP +internal test_mv_dependence_db mv_c internal test grade OLAP + diff --git a/regression-test/suites/query_p0/schema_table/test_mv_dependence.groovy b/regression-test/suites/query_p0/schema_table/test_mv_dependence.groovy new file mode 100644 index 00000000000000..18e64590ff09cc --- /dev/null +++ b/regression-test/suites/query_p0/schema_table/test_mv_dependence.groovy @@ -0,0 +1,98 @@ +// 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. + +suite("test_mv_dependence") { + + sql "DROP DATABASE IF EXISTS test_mv_dependence_db" + sql "CREATE DATABASE test_mv_dependence_db" + sql "USE test_mv_dependence_db" + + sql "DROP TABLE IF EXISTS stu" + sql "DROP TABLE IF EXISTS grade" + sql "DROP MATERIALIZED VIEW IF EXISTS mv_a" + sql "DROP MATERIALIZED VIEW IF EXISTS mv_b" + sql "DROP MATERIALIZED VIEW IF EXISTS mv_c" + sql "DROP TABLE IF EXISTS stu" + sql "DROP TABLE IF EXISTS grade" + sql "DROP MATERIALIZED VIEW IF EXISTS mv_a" + sql "DROP MATERIALIZED VIEW IF EXISTS mv_b" + sql "DROP MATERIALIZED VIEW IF EXISTS mv_c" + + sql """ + CREATE TABLE `stu` ( + `sid` int NULL, + `sname` varchar(32) NULL + ) ENGINE=OLAP + DUPLICATE KEY(`sid`) + DISTRIBUTED BY HASH(`sid`) BUCKETS 1 + PROPERTIES ( + "replication_allocation" = "tag.location.default: 1" + ); + """ + + sql """ + CREATE TABLE `grade` ( + `sid` int NULL, + `cid` int NULL, + `score` int NULL + ) ENGINE=OLAP + DUPLICATE KEY(`sid`) + DISTRIBUTED BY HASH(`sid`) BUCKETS 1 + PROPERTIES ( + "replication_allocation" = "tag.location.default: 1" + ); + """ + + sql """ + CREATE MATERIALIZED VIEW mv_a + (sid,sname) + BUILD IMMEDIATE REFRESH COMPLETE ON COMMIT + DUPLICATE KEY(`sid`, `sname`) + DISTRIBUTED BY HASH(`sid`) BUCKETS 1 + PROPERTIES ( + "replication_allocation" = "tag.location.default: 1" + ) + AS select `internal`.`test`.`stu`.`sid`, `internal`.`test`.`stu`.`sname` from `internal`.`test`.`stu` limit 1 + """ + + sql """ + CREATE MATERIALIZED VIEW mv_b + (sid,sname) + BUILD IMMEDIATE REFRESH COMPLETE ON COMMIT + DUPLICATE KEY(`sid`, `sname`) + DISTRIBUTED BY HASH(`sid`) BUCKETS 1 + PROPERTIES ( + "replication_allocation" = "tag.location.default: 1" + ) + AS select `internal`.`test`.`mv_a`.`sid`, `internal`.`test`.`mv_a`.`sname` from `internal`.`test`.`mv_a` + """ + + sql """ + CREATE MATERIALIZED VIEW mv_c + (sid,cid,score) + BUILD IMMEDIATE REFRESH COMPLETE ON COMMIT + DUPLICATE KEY(`sid`, `cid`, `score`) + DISTRIBUTED BY HASH(`sid`) BUCKETS 1 + PROPERTIES ( + "replication_allocation" = "tag.location.default: 1" + ) + AS select `internal`.`test`.`stu`.`sid`,`internal`.`test`.`grade`.`cid`,`internal`.`test`.`grade`.`score` from `internal`.`test`.`stu` join `internal`.`test`.`grade` on `internal`.`test`.`stu`.`sid` = `internal`.`test`.`grade`.`sid` + """ + + qt_sql "select * from information_schema.mv_dependence where src_database = 'test_mv_dependence_db' order by src_catalog,src_database,src_table" +} + From a000ceac66f2e0e027d15cf31ecd664ade250e81 Mon Sep 17 00:00:00 2001 From: garenshi Date: Fri, 25 Apr 2025 19:44:27 +0800 Subject: [PATCH 4/4] 1 --- .../suites/query_p0/schema_table/test_mv_dependence.groovy | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/regression-test/suites/query_p0/schema_table/test_mv_dependence.groovy b/regression-test/suites/query_p0/schema_table/test_mv_dependence.groovy index 18e64590ff09cc..5333d49744072d 100644 --- a/regression-test/suites/query_p0/schema_table/test_mv_dependence.groovy +++ b/regression-test/suites/query_p0/schema_table/test_mv_dependence.groovy @@ -66,7 +66,7 @@ suite("test_mv_dependence") { PROPERTIES ( "replication_allocation" = "tag.location.default: 1" ) - AS select `internal`.`test`.`stu`.`sid`, `internal`.`test`.`stu`.`sname` from `internal`.`test`.`stu` limit 1 + AS select `stu`.`sid`, `stu`.`sname` from `stu` limit 1 """ sql """ @@ -78,7 +78,7 @@ suite("test_mv_dependence") { PROPERTIES ( "replication_allocation" = "tag.location.default: 1" ) - AS select `internal`.`test`.`mv_a`.`sid`, `internal`.`test`.`mv_a`.`sname` from `internal`.`test`.`mv_a` + AS select `mv_a`.`sid`, `mv_a`.`sname` from `mv_a` """ sql """ @@ -90,7 +90,7 @@ suite("test_mv_dependence") { PROPERTIES ( "replication_allocation" = "tag.location.default: 1" ) - AS select `internal`.`test`.`stu`.`sid`,`internal`.`test`.`grade`.`cid`,`internal`.`test`.`grade`.`score` from `internal`.`test`.`stu` join `internal`.`test`.`grade` on `internal`.`test`.`stu`.`sid` = `internal`.`test`.`grade`.`sid` + AS select `stu`.`sid`, `grade`.`cid`, `grade`.`score` from `stu` join `grade` on `stu`.`sid` = `grade`.`sid` """ qt_sql "select * from information_schema.mv_dependence where src_database = 'test_mv_dependence_db' order by src_catalog,src_database,src_table"