diff --git a/be/src/olap/storage_engine.cpp b/be/src/olap/storage_engine.cpp index 69221cdb3125ca..4915f7ff1a277b 100644 --- a/be/src/olap/storage_engine.cpp +++ b/be/src/olap/storage_engine.cpp @@ -202,7 +202,9 @@ void StorageEngine::_update_storage_medium_type_count() { } _available_storage_medium_type_count = available_storage_medium_types.size(); - StorageEngine::instance()->tablet_manager()->update_storage_medium_type_count(_available_storage_medium_type_count); + if (_tablet_manager != nullptr) { + _tablet_manager->update_storage_medium_type_count(_available_storage_medium_type_count); + } } @@ -327,7 +329,7 @@ void StorageEngine::start_disk_stat_monitor() { it.second->health_check(); } _update_storage_medium_type_count(); - _delete_tables_on_unused_root_path(); + _delete_tablets_on_unused_root_path(); // if drop tables // notify disk_state_worker_thread and tablet_worker_thread until they received @@ -422,12 +424,15 @@ DataDir* StorageEngine::get_store(const std::string& path) { return it->second; } -void StorageEngine::_delete_tables_on_unused_root_path() { +void StorageEngine::_delete_tablets_on_unused_root_path() { vector tablet_info_vec; uint32_t unused_root_path_num = 0; uint32_t total_root_path_num = 0; std::lock_guard l(_store_lock); + if (_store_map.size() == 0) { + return; + } for (auto& it : _store_map) { total_root_path_num++; @@ -435,6 +440,7 @@ void StorageEngine::_delete_tables_on_unused_root_path() { continue; } it.second->clear_tablets(&tablet_info_vec); + ++unused_root_path_num; } if (_used_disk_not_enough(unused_root_path_num, total_root_path_num)) { @@ -473,7 +479,12 @@ OLAPStatus StorageEngine::clear() { delete FileHandler::get_fd_cache(); FileHandler::set_fd_cache(nullptr); SAFE_DELETE(_index_stream_lru_cache); - + std::lock_guard l(_store_lock); + for (auto& store_pair : _store_map) { + delete store_pair.second; + store_pair.second = nullptr; + } + _store_map.clear(); return OLAP_SUCCESS; } diff --git a/be/src/olap/storage_engine.h b/be/src/olap/storage_engine.h index 53d37bdc17ebb9..452886012614ed 100644 --- a/be/src/olap/storage_engine.h +++ b/be/src/olap/storage_engine.h @@ -211,7 +211,7 @@ class StorageEngine { const std::string& root_path, std::string* unused_flag_file); - void _delete_tables_on_unused_root_path(); + void _delete_tablets_on_unused_root_path(); void _update_storage_medium_type_count(); diff --git a/be/test/olap/CMakeLists.txt b/be/test/olap/CMakeLists.txt index 295c7e8af53cb1..717ca9835fd35a 100644 --- a/be/test/olap/CMakeLists.txt +++ b/be/test/olap/CMakeLists.txt @@ -44,3 +44,5 @@ ADD_BE_TEST(serialize_test) ADD_BE_TEST(olap_meta_test) ADD_BE_TEST(tablet_meta_manager_test) ADD_BE_TEST(rowset/rowset_meta_manager_test) +ADD_BE_TEST(rowset/rowset_meta_test) +ADD_BE_TEST(rowset/alpha_rowset_test) diff --git a/be/test/olap/delta_writer_test.cpp b/be/test/olap/delta_writer_test.cpp index 9759382374707b..c3d30eed6fbcf3 100644 --- a/be/test/olap/delta_writer_test.cpp +++ b/be/test/olap/delta_writer_test.cpp @@ -280,7 +280,7 @@ class TestDeltaWriter : public ::testing::Test { //ASSERT_EQ(OLAP_SUCCESS, remove_all_dir(config::storage_root_path)); } }; -/* + TEST_F(TestDeltaWriter, open) { TCreateTabletReq request; create_tablet_request(10003, 270068375, &request); @@ -311,7 +311,7 @@ TEST_F(TestDeltaWriter, open) { res = k_engine->tablet_manager()->drop_tablet(tablet_id, schema_hash); ASSERT_EQ(OLAP_SUCCESS, res); } -*/ + TEST_F(TestDeltaWriter, write) { TCreateTabletReq request; create_tablet_request(10004, 270068376, &request); diff --git a/be/test/olap/rowset/alpha_rowset_test.cpp b/be/test/olap/rowset/alpha_rowset_test.cpp new file mode 100644 index 00000000000000..5dbf85d541d015 --- /dev/null +++ b/be/test/olap/rowset/alpha_rowset_test.cpp @@ -0,0 +1,266 @@ +// 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 + +#include "gtest/gtest.h" +#include "gmock/gmock.h" +#include "boost/filesystem.hpp" +#include "json2pb/json_to_pb.h" +#include "util/logging.h" +#include "olap/olap_meta.h" +#include "olap/rowset/rowset_writer_context.h" +#include "olap/rowset/rowset_reader_context.h" +#include "olap/rowset/alpha_rowset.h" +#include "olap/rowset/alpha_rowset_writer.h" +#include "olap/rowset/alpha_rowset_reader.h" +#include "olap/data_dir.h" +#include "olap/storage_engine.h" + +#ifndef BE_TEST +#define BE_TEST +#endif + +using ::testing::_; +using ::testing::Return; +using ::testing::SetArgPointee; +using std::string; + +namespace doris { + +static const uint32_t MAX_PATH_LEN = 1024; + +StorageEngine* k_engine = nullptr; + +void set_up() { + config::path_gc_check = false; + char buffer[MAX_PATH_LEN]; + getcwd(buffer, MAX_PATH_LEN); + config::storage_root_path = std::string(buffer) + "/data_test"; + remove_all_dir(config::storage_root_path); + OLAPStatus res = create_dir(config::storage_root_path); + ASSERT_EQ(OLAP_SUCCESS, res); + std::vector paths; + paths.emplace_back(config::storage_root_path, -1); + std::string data_path = config::storage_root_path + "/data"; + res = create_dir(data_path); + ASSERT_EQ(OLAP_SUCCESS, res); + std::string shard_path = data_path + "/0"; + res = create_dir(shard_path); + ASSERT_EQ(OLAP_SUCCESS, res); + std::string tablet_path = shard_path + "/12345"; + res = create_dir(tablet_path); + ASSERT_EQ(OLAP_SUCCESS, res); + std::string schema_hash_path = tablet_path + "/1111"; + res = create_dir(schema_hash_path); + ASSERT_EQ(OLAP_SUCCESS, res); + + doris::EngineOptions options; + options.store_paths = paths; + doris::StorageEngine::open(options, &k_engine); +} + +void tear_down() { + delete k_engine; + k_engine = nullptr; + remove_all_dir(config::storage_root_path); + remove_all_dir(std::string(getenv("DORIS_HOME")) + UNUSED_PREFIX); +} + +void create_rowset_writer_context(TabletSchema* tablet_schema, DataDir* data_dir, + RowsetWriterContext* rowset_writer_context) { + rowset_writer_context->rowset_id = 10000; + rowset_writer_context->tablet_id = 12345; + rowset_writer_context->tablet_schema_hash = 1111; + rowset_writer_context->partition_id = 10; + rowset_writer_context->rowset_type = ALPHA_ROWSET; + rowset_writer_context->rowset_path_prefix = config::storage_root_path + "/data/0/12345/1111"; + rowset_writer_context->rowset_state = VISIBLE; + rowset_writer_context->data_dir = data_dir; + rowset_writer_context->tablet_schema = tablet_schema; + rowset_writer_context->version.first = 0; + rowset_writer_context->version.second = 1; + rowset_writer_context->version_hash = 110; +} + +void create_rowset_reader_context(TabletSchema* tablet_schema, const std::vector* return_columns, + const DeleteHandler* delete_handler, std::vector* predicates, + std::set* load_bf_columns, Conditions* conditions, RowsetReaderContext* rowset_reader_context) { + rowset_reader_context->reader_type = READER_ALTER_TABLE; + rowset_reader_context->tablet_schema = tablet_schema; + rowset_reader_context->preaggregation = false; + rowset_reader_context->return_columns = return_columns; + rowset_reader_context->delete_handler = delete_handler; + rowset_reader_context->is_using_cache = false; + rowset_reader_context->lower_bound_keys = nullptr; + rowset_reader_context->is_lower_keys_included = nullptr; + rowset_reader_context->upper_bound_keys = nullptr; + rowset_reader_context->is_upper_keys_included = nullptr; + rowset_reader_context->predicates = predicates; + rowset_reader_context->load_bf_columns = load_bf_columns; + rowset_reader_context->conditions = conditions; + rowset_reader_context->lru_cache = k_engine->index_stream_lru_cache(); +} + +void create_tablet_schema(KeysType keys_type, TabletSchema* tablet_schema) { + TabletSchemaPB tablet_schema_pb; + tablet_schema_pb.set_keys_type(keys_type); + tablet_schema_pb.set_num_short_key_columns(2); + tablet_schema_pb.set_num_rows_per_row_block(1024); + tablet_schema_pb.set_compress_kind(COMPRESS_NONE); + tablet_schema_pb.set_next_column_unique_id(4); + + ColumnPB* column_1 = tablet_schema_pb.add_column(); + column_1->set_unique_id(1); + column_1->set_name("k1"); + column_1->set_type("INT"); + column_1->set_is_key(true); + column_1->set_is_nullable(true); + column_1->set_is_bf_column(false); + + ColumnPB* column_2 = tablet_schema_pb.add_column(); + column_2->set_unique_id(2); + column_2->set_name("k2"); + column_2->set_type("VARCHAR"); + column_2->set_length(20); + column_2->set_is_key(true); + column_2->set_is_nullable(true); + column_2->set_is_bf_column(false); + + ColumnPB* column_3 = tablet_schema_pb.add_column(); + column_3->set_unique_id(3); + column_3->set_name("v1"); + column_3->set_type("INT"); + column_3->set_is_key(false); + column_3->set_is_nullable(false); + column_3->set_is_bf_column(false); + column_3->set_aggregation("SUM"); + + tablet_schema->init_from_pb(tablet_schema_pb); +} + +class AlphaRowsetTest : public testing::Test { +public: + virtual void SetUp() { + set_up(); + _data_dir = k_engine->get_store(config::storage_root_path); + ASSERT_TRUE(_data_dir != nullptr); + _alpha_rowset_writer = new(std::nothrow) AlphaRowsetWriter(); + _mem_tracker.reset(new MemTracker(-1)); + _mem_pool.reset(new MemPool(_mem_tracker.get())); + } + + virtual void TearDown() { + delete _alpha_rowset_writer; + _alpha_rowset_writer = nullptr; + tear_down(); + } + +private: + DataDir* _data_dir; + AlphaRowsetWriter* _alpha_rowset_writer; + std::unique_ptr _mem_tracker; + std::unique_ptr _mem_pool; +}; +/* +TEST_F(AlphaRowsetTest, TestAlphaRowsetWriter) { + TabletSchema tablet_schema; + create_tablet_schema(AGG_KEYS, &tablet_schema); + RowsetWriterContext rowset_writer_context; + create_rowset_writer_context(&tablet_schema, _data_dir, &rowset_writer_context); + _alpha_rowset_writer->init(rowset_writer_context); + RowCursor row; + OLAPStatus res = row.init(tablet_schema); + ASSERT_EQ(OLAP_SUCCESS, res); + + int32_t field_0 = 10; + row.set_field_content(0, reinterpret_cast(&field_0), _mem_pool.get()); + Slice field_1("well"); + row.set_field_content(1, reinterpret_cast(&field_1), _mem_pool.get()); + int32_t field_2 = 100; + row.set_field_content(2, reinterpret_cast(&field_2), _mem_pool.get()); + _alpha_rowset_writer->add_row(&row); + _alpha_rowset_writer->flush(); + RowsetSharedPtr alpha_rowset = _alpha_rowset_writer->build(); + ASSERT_TRUE(alpha_rowset != nullptr); + ASSERT_EQ(10000, alpha_rowset->rowset_id()); + ASSERT_EQ(1, alpha_rowset->num_rows()); +} +*/ +TEST_F(AlphaRowsetTest, TestAlphaRowsetReader) { + TabletSchema tablet_schema; + create_tablet_schema(AGG_KEYS, &tablet_schema); + RowsetWriterContext rowset_writer_context; + create_rowset_writer_context(&tablet_schema, _data_dir, &rowset_writer_context); + _alpha_rowset_writer->init(rowset_writer_context); + RowCursor row; + OLAPStatus res = row.init(tablet_schema); + ASSERT_EQ(OLAP_SUCCESS, res); + + int32_t field_0 = 10; + row.set_field_content(0, reinterpret_cast(&field_0), _mem_pool.get()); + Slice field_1("well"); + row.set_field_content(1, reinterpret_cast(&field_1), _mem_pool.get()); + int32_t field_2 = 100; + row.set_field_content(2, reinterpret_cast(&field_2), _mem_pool.get()); + _alpha_rowset_writer->add_row(&row); + _alpha_rowset_writer->flush(); + RowsetSharedPtr alpha_rowset = _alpha_rowset_writer->build(); + ASSERT_TRUE(alpha_rowset != nullptr); + ASSERT_EQ(10000, alpha_rowset->rowset_id()); + ASSERT_EQ(1, alpha_rowset->num_rows()); + RowsetReaderSharedPtr rowset_reader = alpha_rowset->create_reader(); + ASSERT_TRUE(rowset_reader != nullptr); + std::vector return_columns; + for (int i = 0; i < tablet_schema.num_columns(); ++i) { + return_columns.push_back(i); + } + DeleteHandler delete_handler; + DelPredicateArray predicate_array; + res = delete_handler.init(tablet_schema, predicate_array, 4); + ASSERT_EQ(OLAP_SUCCESS, res); + RowsetReaderContext rowset_reader_context; + + std::set load_bf_columns; + std::vector predicates; + Conditions conditions; + create_rowset_reader_context(&tablet_schema, &return_columns, &delete_handler, + &predicates, &load_bf_columns, &conditions, &rowset_reader_context); + res = rowset_reader->init(&rowset_reader_context); + ASSERT_EQ(OLAP_SUCCESS, res); + RowBlock* row_block = nullptr; + res = rowset_reader->next_block(&row_block); + ASSERT_EQ(OLAP_SUCCESS, res); + ASSERT_EQ(1, row_block->remaining()); +} + +} // namespace doris + +int main(int argc, char **argv) { + std::string conffile = std::string(getenv("DORIS_HOME")) + "/conf/be.conf"; + if (!doris::config::init(conffile.c_str(), false)) { + fprintf(stderr, "error read config file. \n"); + return -1; + } + doris::init_glog("be-test"); + ::testing::InitGoogleTest(&argc, argv); + int ret = RUN_ALL_TESTS(); + google::protobuf::ShutdownProtobufLibrary(); + return ret; +} diff --git a/be/test/olap/rowset/rowset_meta_test.cpp b/be/test/olap/rowset/rowset_meta_test.cpp new file mode 100644 index 00000000000000..c8bac2da5a68e4 --- /dev/null +++ b/be/test/olap/rowset/rowset_meta_test.cpp @@ -0,0 +1,183 @@ +// 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 + +#include "gtest/gtest.h" +#include "gmock/gmock.h" +#include "olap/olap_meta.h" +#include "olap/rowset/rowset_meta.h" +#include "olap/rowset/alpha_rowset_meta.h" +#include "boost/filesystem.hpp" +#include "json2pb/json_to_pb.h" + +#ifndef BE_TEST +#define BE_TEST +#endif + +using ::testing::_; +using ::testing::Return; +using ::testing::SetArgPointee; +using std::string; + +namespace doris { + +const std::string rowset_meta_path = "./be/test/olap/test_data/rowset.json"; + +class RowsetMetaTest : public testing::Test { +public: + virtual void SetUp() { + std::string meta_path = "./meta"; + ASSERT_TRUE(boost::filesystem::create_directory(meta_path)); + _meta = new(std::nothrow) OlapMeta(meta_path); + ASSERT_NE(nullptr, _meta); + OLAPStatus st = _meta->init(); + ASSERT_TRUE(st == OLAP_SUCCESS); + ASSERT_TRUE(boost::filesystem::exists("./meta")); + + std::ifstream infile(rowset_meta_path); + char buffer[1024]; + while (!infile.eof()) { + infile.getline(buffer, 1024); + _json_rowset_meta = _json_rowset_meta + buffer + "\n"; + } + _json_rowset_meta = _json_rowset_meta.substr(0, _json_rowset_meta.size() - 1); + _json_rowset_meta = _json_rowset_meta.substr(0, _json_rowset_meta.size() - 1); + } + + virtual void TearDown() { + delete _meta; + ASSERT_TRUE(boost::filesystem::remove_all("./meta")); + } + +private: + OlapMeta* _meta; + std::string _json_rowset_meta; +}; + +void do_check(RowsetMeta rowset_meta) { + ASSERT_EQ(540081, rowset_meta.rowset_id()); + ASSERT_EQ(15673, rowset_meta.tablet_id()); + ASSERT_EQ(4042, rowset_meta.txn_id()); + ASSERT_EQ(567997577, rowset_meta.tablet_schema_hash()); + ASSERT_EQ(ALPHA_ROWSET, rowset_meta.rowset_type()); + ASSERT_EQ(VISIBLE, rowset_meta.rowset_state()); + ASSERT_EQ(2, rowset_meta.start_version()); + ASSERT_EQ(2, rowset_meta.end_version()); + ASSERT_EQ(8391828013814912580, rowset_meta.version_hash()); + ASSERT_EQ(3929, rowset_meta.num_rows()); + ASSERT_EQ(84699, rowset_meta.total_disk_size()); + ASSERT_EQ(84464, rowset_meta.data_disk_size()); + ASSERT_EQ(235, rowset_meta.index_disk_size()); + ASSERT_EQ(false, rowset_meta.empty()); + ASSERT_EQ(1553765670, rowset_meta.creation_time()); +} + +TEST_F(RowsetMetaTest, TestInit) { + RowsetMeta rowset_meta; + ASSERT_TRUE(rowset_meta.init_from_json(_json_rowset_meta)); + do_check(rowset_meta); + RowsetMetaPB rowset_meta_pb; + rowset_meta.to_rowset_pb(&rowset_meta_pb); + RowsetMeta rowset_meta_2; + rowset_meta_2.init_from_pb(rowset_meta_pb); + do_check(rowset_meta_2); + std::string value = ""; + rowset_meta_pb.SerializeToString(&value); + RowsetMeta rowset_meta_3; + rowset_meta_3.init(value); + do_check(rowset_meta_3); +} + +TEST_F(RowsetMetaTest, TestInitWithInvalidData) { + RowsetMeta rowset_meta; + ASSERT_FALSE(rowset_meta.init_from_json("invalid json meta data")); + ASSERT_FALSE(rowset_meta.init("invalid pb meta data")); +} + +void do_check_for_alpha(AlphaRowsetMeta alpha_rowset_meta) { + ASSERT_EQ(540081, alpha_rowset_meta.rowset_id()); + ASSERT_EQ(15673, alpha_rowset_meta.tablet_id()); + ASSERT_EQ(4042, alpha_rowset_meta.txn_id()); + ASSERT_EQ(567997577, alpha_rowset_meta.tablet_schema_hash()); + ASSERT_EQ(ALPHA_ROWSET, alpha_rowset_meta.rowset_type()); + ASSERT_EQ(VISIBLE, alpha_rowset_meta.rowset_state()); + ASSERT_EQ(2, alpha_rowset_meta.start_version()); + ASSERT_EQ(2, alpha_rowset_meta.end_version()); + ASSERT_EQ(8391828013814912580, alpha_rowset_meta.version_hash()); + ASSERT_EQ(3929, alpha_rowset_meta.num_rows()); + ASSERT_EQ(84699, alpha_rowset_meta.total_disk_size()); + ASSERT_EQ(84464, alpha_rowset_meta.data_disk_size()); + ASSERT_EQ(235, alpha_rowset_meta.index_disk_size()); + ASSERT_EQ(false, alpha_rowset_meta.empty()); + ASSERT_EQ(1553765670, alpha_rowset_meta.creation_time()); + std::vector segment_groups; + alpha_rowset_meta.get_segment_groups(&segment_groups); + ASSERT_EQ(2, segment_groups.size()); +} + +TEST_F(RowsetMetaTest, TestAlphaRowsetMeta) { + AlphaRowsetMeta rowset_meta; + rowset_meta.init_from_json(_json_rowset_meta); + do_check_for_alpha(rowset_meta); + RowsetMetaPB rowset_meta_pb; + rowset_meta.to_rowset_pb(&rowset_meta_pb); + AlphaRowsetMeta rowset_meta_2; + rowset_meta_2.init_from_pb(rowset_meta_pb); + do_check_for_alpha(rowset_meta_2); + std::string value = ""; + rowset_meta_pb.SerializeToString(&value); + AlphaRowsetMeta rowset_meta_3; + rowset_meta_3.init(value); + do_check_for_alpha(rowset_meta_3); +} + +TEST_F(RowsetMetaTest, TestAlphaRowsetMetaAdd) { + AlphaRowsetMeta rowset_meta; + rowset_meta.init_from_json(_json_rowset_meta); + do_check_for_alpha(rowset_meta); + SegmentGroupPB new_segment_group; + new_segment_group.set_segment_group_id(88888); + new_segment_group.set_num_segments(3); + new_segment_group.set_empty(true); + new_segment_group.set_index_size(100); + new_segment_group.set_data_size(1000); + new_segment_group.set_num_rows(1000); + rowset_meta.add_segment_group(new_segment_group); + std::vector segment_groups; + rowset_meta.get_segment_groups(&segment_groups); + ASSERT_EQ(3, segment_groups.size()); +} + +TEST_F(RowsetMetaTest, TestAlphaRowsetMetaClear) { + AlphaRowsetMeta rowset_meta; + rowset_meta.init_from_json(_json_rowset_meta); + do_check_for_alpha(rowset_meta); + rowset_meta.clear_segment_group(); + std::vector segment_groups; + rowset_meta.get_segment_groups(&segment_groups); + ASSERT_EQ(0, segment_groups.size()); +} + +} // namespace doris + +int main(int argc, char **argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/be/test/olap/test_data/rowset.json b/be/test/olap/test_data/rowset.json new file mode 100644 index 00000000000000..feb0f8c9e30927 --- /dev/null +++ b/be/test/olap/test_data/rowset.json @@ -0,0 +1,22 @@ +{ + "rowset_id": 540081, + "tablet_id": 15673, + "txn_id": 4042, + "tablet_schema_hash": 567997577, + "rowset_type": "ALPHA_ROWSET", + "rowset_state": "VISIBLE", + "start_version": 2, + "end_version": 2, + "version_hash": 8391828013814912580, + "num_rows": 3929, + "total_disk_size": 84699, + "data_disk_size": 84464, + "index_disk_size": 235, + "empty": false, + "load_id": { + "hi": -5350970832824939812, + "lo": -6717994719194512122 + }, + "creation_time": 1553765670, + "extra_properties": "Cj8IABABGIkBIMKRBCj3GDItChQtOTIyMTU1MjY3MjkzMDc2NDM3MBITOTIxMzI0NDQwNTY3MzIwODI3MhgAOAAKPggBEAEYYiCuggEo4gUyLQoULTkyMDQ4NjgyNzgzOTU5NTgyOTYSEzkyMjE4NjQ3ODUyMjk2NDE3MDYYADgA" +} diff --git a/run-ut.sh b/run-ut.sh index 62f6106b097abd..0a1e9385027381 100755 --- a/run-ut.sh +++ b/run-ut.sh @@ -208,6 +208,8 @@ ${DORIS_TEST_BINARY_DIR}/olap/tablet_meta_manager_test ${DORIS_TEST_BINARY_DIR}/olap/olap_meta_test ${DORIS_TEST_BINARY_DIR}/olap/delta_writer_test ${DORIS_TEST_BINARY_DIR}/olap/olap/rowset/rowset_meta_manager_test +${DORIS_TEST_BINARY_DIR}/olap/olap/rowset/rowset_meta_test +${DORIS_TEST_BINARY_DIR}/olap/olap/rowset/alpha_rowset_test ## Running agent unittest # Prepare agent testdata