273 lines
10 KiB
C++
273 lines
10 KiB
C++
/**
|
|
* Copyright (c) 2022 OceanBase
|
|
* OceanBase CE is licensed under Mulan PubL v2.
|
|
* You can use this software according to the terms and conditions of the Mulan PubL v2.
|
|
* You may obtain a copy of Mulan PubL v2 at:
|
|
* http://license.coscl.org.cn/MulanPubL-2.0
|
|
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
|
|
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
|
|
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
|
|
* See the Mulan PubL v2 for more details.
|
|
*
|
|
* This file defines test_ob_cdc_part_trans_resolver.cpp
|
|
*/
|
|
|
|
#include "gtest/gtest.h"
|
|
|
|
#include "data_dict_test_utils.h"
|
|
|
|
using namespace oceanbase;
|
|
using namespace common;
|
|
using namespace share;
|
|
using namespace share::schema;
|
|
|
|
namespace oceanbase
|
|
{
|
|
namespace datadict
|
|
{
|
|
|
|
TEST(ObDictMetaHeader, test_raw)
|
|
{
|
|
ObDictMetaHeader header(ObDictMetaType::TABLE_META);
|
|
ObDictMetaHeader header_after(ObDictMetaType::INVALID_META);
|
|
SCN scn;
|
|
|
|
header.version_ = OB_INVALID_VERSION;
|
|
header.set_snapshot_scn(scn);
|
|
header.set_storage_type(ObDictMetaStorageType::FULL);
|
|
EXPECT_FALSE(header.is_valid());
|
|
scn.convert_for_gts(get_timestamp());
|
|
header.set_snapshot_scn(scn);
|
|
header.set_dict_serialize_length(9678);
|
|
EXPECT_TRUE(header.is_valid());
|
|
|
|
const int64_t serialize_size = header.get_serialize_size();
|
|
char *buf = (char*)ob_malloc(serialize_size, "test");
|
|
int64_t pos = 0;
|
|
EXPECT_EQ(OB_SUCCESS, header.serialize(buf, serialize_size, pos));
|
|
EXPECT_EQ(serialize_size, pos);
|
|
int64_t deserialize_pos = 0;
|
|
|
|
EXPECT_EQ(OB_SUCCESS, header_after.deserialize(buf, serialize_size, deserialize_pos));
|
|
EXPECT_EQ(serialize_size, deserialize_pos);
|
|
EXPECT_TRUE(header == header_after);
|
|
|
|
// verify serialize_size is not changed after change storage_type
|
|
header.set_storage_type(ObDictMetaStorageType::MIDDLE);
|
|
EXPECT_EQ(serialize_size, header.get_serialize_size());
|
|
}
|
|
|
|
TEST(ObDictTenantMeta, test_raw)
|
|
{
|
|
ObArenaAllocator allocator;
|
|
ObArenaAllocator allocator_for_deserialize;
|
|
ObDictTenantMeta tenant_meta(&allocator);
|
|
ObDictMetaHeader header(ObDictMetaType::TENANT_META);
|
|
tenant_meta.tenant_id_ = 1001;
|
|
tenant_meta.schema_version_=100003124341;
|
|
tenant_meta.tenant_name_ = "md_tenant";
|
|
tenant_meta.tenant_status_ = ObTenantStatus::TENANT_STATUS_NORMAL;
|
|
tenant_meta.charset_type_ = ObCharsetType::CHARSET_GB18030;
|
|
tenant_meta.collation_type_ = ObCollationType::CS_TYPE_GB18030_ZH3_0900_AS_CS;
|
|
ObLSArray ls_arr;
|
|
EXPECT_EQ(OB_SUCCESS, ls_arr.push_back(ObLSID(1)));
|
|
EXPECT_EQ(OB_SUCCESS, ls_arr.push_back(ObLSID(1004)));
|
|
tenant_meta.ls_arr_.assign(ls_arr);
|
|
|
|
const int64_t serialize_size = tenant_meta.get_serialize_size();
|
|
DDLOG(INFO, "tenant_meta", K(tenant_meta), K(serialize_size));
|
|
char *buf = (char*)ob_malloc(serialize_size, "test");
|
|
int64_t pos = 0;
|
|
EXPECT_EQ(OB_SUCCESS, tenant_meta.serialize(buf, serialize_size, pos));
|
|
DDLOG(INFO, "serialize_info", K(serialize_size), K(pos));
|
|
|
|
ObDictTenantMeta tenant_meta_after(&allocator_for_deserialize);
|
|
int64_t deserialize_pos = 0;
|
|
EXPECT_EQ(OB_SUCCESS, tenant_meta_after.deserialize(header, buf, serialize_size, deserialize_pos));
|
|
DDLOG(INFO, "deserialized_meta", K(deserialize_pos), K(tenant_meta_after));
|
|
ob_free(buf);
|
|
|
|
EXPECT_EQ(serialize_size, deserialize_pos);
|
|
EXPECT_EQ(OB_INVALID_TENANT_ID, tenant_meta_after.tenant_id_);
|
|
// EXPECT_EQ(tenant_meta.tenant_id_, tenant_meta_after.tenant_id_);
|
|
EXPECT_EQ(tenant_meta.tenant_name_, tenant_meta_after.tenant_name_);
|
|
EXPECT_EQ(ls_arr[1], tenant_meta_after.ls_arr_[1]);
|
|
EXPECT_TRUE(tenant_meta == tenant_meta_after);
|
|
tenant_meta_after.ls_arr_.push_back(ObLSID(8930));
|
|
EXPECT_FALSE(tenant_meta == tenant_meta_after);
|
|
}
|
|
|
|
TEST(ObDictDatabaseMeta, test_raw)
|
|
{
|
|
ObArenaAllocator allocator;
|
|
ObArenaAllocator allocator_for_deserialize;
|
|
ObDictDatabaseMeta db_meta(&allocator);
|
|
ObDictMetaHeader header(ObDictMetaType::DATABASE_META);
|
|
db_meta.database_id_ = 1003030501;
|
|
db_meta.tenant_id_ = 23412;
|
|
db_meta.schema_version_ = 790134621334;
|
|
db_meta.database_name_ = "md_test_db";
|
|
db_meta.charset_type_ = ObCharsetType::CHARSET_UTF8MB4;
|
|
db_meta.collation_type_ = ObCollationType::CS_TYPE_UTF8MB4_UNICODE_CI;
|
|
db_meta.name_case_mode_ = ObNameCaseMode::OB_ORIGIN_AND_INSENSITIVE;
|
|
db_meta.in_recyclebin_ = true;
|
|
|
|
const int64_t serialize_size = db_meta.get_serialize_size();
|
|
DDLOG(INFO, "db_meta", K(db_meta), K(serialize_size));
|
|
char *buf = (char*)ob_malloc(serialize_size, "test");
|
|
int64_t pos = 0;
|
|
EXPECT_EQ(OB_SUCCESS, db_meta.serialize(buf, serialize_size, pos));
|
|
DDLOG(INFO, "serialize_info", K(serialize_size), K(pos));
|
|
|
|
ObDictDatabaseMeta db_meta_after(&allocator_for_deserialize);
|
|
int64_t deserialize_pos = 0;
|
|
EXPECT_EQ(OB_SUCCESS, db_meta_after.deserialize(header, buf, serialize_size, deserialize_pos));
|
|
DDLOG(INFO, "deserialized_meta", K(deserialize_pos), K(db_meta_after));
|
|
ob_free(buf);
|
|
|
|
EXPECT_EQ(serialize_size, deserialize_pos);
|
|
EXPECT_EQ(db_meta.database_id_, db_meta_after.database_id_);
|
|
EXPECT_EQ(OB_INVALID_TENANT_ID, db_meta_after.tenant_id_);
|
|
//EXPECT_EQ(db_meta.tenant_id_, db_meta_after.tenant_id_);
|
|
EXPECT_EQ(db_meta.database_name_, db_meta_after.database_name_);
|
|
EXPECT_EQ(db_meta.schema_version_, db_meta_after.schema_version_);
|
|
EXPECT_EQ(db_meta.name_case_mode_, db_meta_after.name_case_mode_);
|
|
EXPECT_EQ(db_meta.in_recyclebin_, db_meta_after.in_recyclebin_);
|
|
EXPECT_EQ(db_meta.collation_type_, db_meta_after.collation_type_);
|
|
EXPECT_TRUE(db_meta == db_meta_after);
|
|
db_meta_after.database_id_ = 4376212345;
|
|
EXPECT_FALSE(db_meta == db_meta_after);
|
|
}
|
|
|
|
TEST(ObDictColumnMeta, test_raw)
|
|
{
|
|
ObArenaAllocator allocator;
|
|
ObArenaAllocator allocator_for_deserialize;
|
|
DictTableMetaBuilder meta_builder;
|
|
ObDictColumnMeta col_meta(&allocator);
|
|
ObDictMetaHeader header(ObDictMetaType::TABLE_META);
|
|
meta_builder.build_column_meta(&col_meta);
|
|
DDLOG(INFO, "build_column_meta", K(col_meta));
|
|
|
|
const int64_t serialize_size = col_meta.get_serialize_size();
|
|
char *buf = (char*)ob_malloc(serialize_size, "test");
|
|
int64_t pos = 0;
|
|
EXPECT_EQ(OB_SUCCESS, col_meta.serialize(buf, serialize_size, pos));
|
|
DDLOG(INFO, "serialize_info", K(serialize_size), K(pos));
|
|
|
|
ObDictColumnMeta col_meta_after(&allocator_for_deserialize);
|
|
int64_t deserialize_pos = 0;
|
|
EXPECT_EQ(OB_SUCCESS, col_meta_after.deserialize(header, buf, serialize_size, deserialize_pos));
|
|
DDLOG(INFO, "deserialized_meta", K(deserialize_pos), K(col_meta_after));
|
|
ob_free(buf);
|
|
|
|
EXPECT_EQ(serialize_size, deserialize_pos);
|
|
EXPECT_EQ(col_meta.column_name_, col_meta_after.column_name_);
|
|
EXPECT_EQ(col_meta.orig_default_value_, col_meta_after.orig_default_value_);
|
|
EXPECT_TRUE(col_meta == col_meta_after);
|
|
ObObjMeta new_meta;
|
|
new_meta.set_clob();
|
|
col_meta_after.orig_default_value_.set_meta_type(new_meta);
|
|
EXPECT_FALSE(col_meta == col_meta_after);
|
|
}
|
|
|
|
TEST(ObObjMeta, test_objmeta_serialize)
|
|
{
|
|
ObObjMeta objmeta;
|
|
objmeta.set_collation_type(ObCollationType::CS_TYPE_GB18030_BIN);
|
|
objmeta.set_collation_level(ObCollationLevel::CS_LEVEL_IGNORABLE);
|
|
DDLOG(INFO, "build_objmeta", K(objmeta));
|
|
|
|
const int64_t serialize_size = objmeta.get_serialize_size();
|
|
char *buf = (char*)ob_malloc(serialize_size, "test");
|
|
int64_t pos = 0;
|
|
EXPECT_EQ(OB_SUCCESS, objmeta.serialize(buf, serialize_size, pos));
|
|
DDLOG(INFO, "serialize_info", K(serialize_size), K(pos));
|
|
|
|
ObObjMeta objmet_after;
|
|
int64_t deserialize_pos = 0;
|
|
EXPECT_EQ(OB_SUCCESS, objmet_after.deserialize(buf, serialize_size, deserialize_pos));
|
|
DDLOG(INFO, "deserialized_meta", K(deserialize_pos), K(objmet_after));
|
|
|
|
EXPECT_EQ(serialize_size, deserialize_pos);
|
|
EXPECT_TRUE(objmeta == objmet_after);
|
|
ob_free(buf);
|
|
}
|
|
|
|
TEST(ObRowkeyColumn, test_rowkey_col)
|
|
{
|
|
ObRowkeyColumn rcol;
|
|
rcol.column_id_ = 245763451346;
|
|
rcol.length_ = 431652345;
|
|
rcol.order_ = ObOrderType::DESC;
|
|
rcol.fulltext_flag_ = true;
|
|
DDLOG(INFO, "build_rowkey_column", K(rcol));
|
|
|
|
const int64_t serialize_size = rcol.get_serialize_size();
|
|
char *buf = (char*)ob_malloc(serialize_size, "test");
|
|
int64_t pos = 0;
|
|
EXPECT_EQ(OB_SUCCESS, rcol.serialize(buf, serialize_size, pos));
|
|
DDLOG(INFO, "serialize_info", K(serialize_size), K(pos));
|
|
|
|
ObRowkeyColumn rcol_after_serialize;
|
|
int64_t deserialize_pos = 0;
|
|
EXPECT_EQ(OB_SUCCESS, rcol_after_serialize.deserialize(buf, serialize_size, deserialize_pos));
|
|
DDLOG(INFO, "deserialized_meta", K(deserialize_pos), K(rcol_after_serialize));
|
|
ob_free(buf);
|
|
|
|
EXPECT_EQ(serialize_size, deserialize_pos);
|
|
}
|
|
|
|
TEST(ObDictTableMeta, test_raw)
|
|
{
|
|
ObArenaAllocator allocator_for_deserialize;
|
|
DictTableMetaBuilder meta_builder;
|
|
ObDictTableMeta *tb_meta;
|
|
ObDictMetaHeader header(ObDictMetaType::TABLE_META);
|
|
const int64_t col_count = 4000;
|
|
const int64_t rowkey_count = 57;
|
|
const int64_t index_column_count = 1235;
|
|
EXPECT_EQ(OB_SUCCESS, meta_builder.build_table_meta(tb_meta, rowkey_count, col_count, index_column_count));
|
|
EXPECT_NE(nullptr, tb_meta);
|
|
DDLOG(INFO, "build_table_meta", KPC(tb_meta));
|
|
EXPECT_EQ(rowkey_count, tb_meta->rowkey_column_count_);
|
|
EXPECT_EQ(col_count, tb_meta->column_count_);
|
|
|
|
const int64_t serialize_size = tb_meta->get_serialize_size();
|
|
char *buf = (char*)ob_malloc(serialize_size, "test");
|
|
int64_t pos = 0;
|
|
EXPECT_EQ(OB_SUCCESS, tb_meta->serialize(buf, serialize_size, pos));
|
|
DDLOG(INFO, "serialize_info", K(serialize_size), K(pos));
|
|
|
|
ObDictTableMeta tb_meta_after(&allocator_for_deserialize);
|
|
int64_t deserialize_pos = 0;
|
|
EXPECT_EQ(OB_SUCCESS, tb_meta_after.deserialize(header, buf, serialize_size, deserialize_pos));
|
|
DDLOG(INFO, "deserialized_meta", K(deserialize_pos), K(tb_meta_after));
|
|
ob_free(buf);
|
|
|
|
EXPECT_EQ(serialize_size, deserialize_pos);
|
|
EXPECT_EQ(tb_meta->table_name_, tb_meta_after.table_name_);
|
|
EXPECT_EQ(rowkey_count, tb_meta_after.rowkey_column_count_);
|
|
EXPECT_EQ(col_count, tb_meta_after.column_count_);
|
|
EXPECT_TRUE(*tb_meta == tb_meta_after);
|
|
tb_meta_after.index_column_count_ ++;
|
|
EXPECT_FALSE(*tb_meta == tb_meta_after);
|
|
}
|
|
|
|
} // namespace datadict
|
|
} // namespace oceanbase
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
// testing::FLAGS_gtest_filter = "DO_NOT_RUN";
|
|
system("rm -f test_data_dict_struct.log");
|
|
ObLogger &logger = ObLogger::get_logger();
|
|
bool not_output_obcdc_log = true;
|
|
logger.set_file_name("test_data_dict_struct.log", not_output_obcdc_log, false);
|
|
logger.set_log_level(OB_LOG_LEVEL_DEBUG);
|
|
logger.set_mod_log_levels("ALL.*:DEBUG, DATA_DICT.*:DEBUG");
|
|
logger.set_enable_async_log(false);
|
|
testing::InitGoogleTest(&argc,argv);
|
|
return RUN_ALL_TESTS();
|
|
}
|