hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

[scn] fix failure of mittest after refresh feature scn

Browse Source
This commit is contained in:
obdev
2022-11-28 01:46:42 +00:00
committed by ob-robot
parent 49a02f3304
commit 54b64a7263
1898 changed files with 255804 additions and 280809 deletions
Download Patch File Download Diff File Expand all files Collapse all files

121
unittest/storage/blocksstable/encoding/test_micro_block_encoder.cpp
View File

@ -41,8 +41,7 @@ enum EncodeTestCase
class TestIColumnEncoder : public ::testing::Test
{
public:
TestIColumnEncoder(const bool is_multi_version_row = false)
: is_multi_version_row_(is_multi_version_row) {}
TestIColumnEncoder() {}
virtual ~TestIColumnEncoder() {}
virtual void SetUp();
virtual void TearDown() {}
@ -56,7 +55,6 @@ protected:
ObTableReadInfo read_info_;
ObArenaAllocator allocator_;
common::ObArray<share::schema::ObColDesc> col_descs_;
bool is_multi_version_row_;
};
void TestIColumnEncoder::SetUp()
@ -91,23 +89,18 @@ void TestIColumnEncoder::SetUp()
ASSERT_EQ(OB_SUCCESS, table.add_column(col));
}
ASSERT_EQ(OB_SUCCESS, row_generate_.init(table, is_multi_version_row_));
if (is_multi_version_row_) {
ASSERT_EQ(OB_SUCCESS, row_generate_.get_schema().get_multi_version_column_descs(col_descs_));
} else {
ASSERT_EQ(OB_SUCCESS, row_generate_.get_schema().get_column_ids(col_descs_));
}
ASSERT_EQ(OB_SUCCESS, row_generate_.init(table));
ASSERT_EQ(OB_SUCCESS, row_generate_.get_schema().get_column_ids(col_descs_));
ASSERT_EQ(OB_SUCCESS, read_info_.init(allocator_,
row_generate_.get_schema().get_column_count(),
row_generate_.get_schema().get_rowkey_column_num(),
lib::is_oracle_mode(),
col_descs_,
true));
col_descs_));
ctx_.micro_block_size_ = 1L << 20; // 1MB, maximum micro block size;
ctx_.macro_block_size_ = 2L << 20;
ctx_.rowkey_column_cnt_ = rowkey_cnt_;
ctx_.column_cnt_ = is_multi_version_row_ ? column_cnt_ + 2 : column_cnt_;
ctx_.column_cnt_ = column_cnt_;
ctx_.col_descs_ = &col_descs_;
ctx_.major_working_cluster_version_=cal_version(3, 1, 0, 0);
ctx_.row_store_type_ = common::ENCODING_ROW_STORE;
@ -136,89 +129,35 @@ public:
TEST_F(TestEncoderOverFlow, test_append_row_with_timestamp_and_max_estimate_limit)
{
common::ObClusterVersion::get_instance().update_cluster_version(cal_version(2, 2, 0, 75));
ObMicroBlockEncoder encoder;
ASSERT_EQ(OB_SUCCESS, encoder.init(ctx_));
ASSERT_TRUE(IS_CLUSTER_VERSION_AFTER_2274);
if (IS_CLUSTER_VERSION_AFTER_2274) {
ObMicroBlockEncoder encoder;
ASSERT_EQ(OB_SUCCESS, encoder.init(ctx_));
encoder.estimate_size_limit_ = ctx_.macro_block_size_;
encoder.estimate_size_limit_ = ctx_.macro_block_size_;
ObDatumRow row;
ASSERT_EQ(OB_SUCCESS, row.init(allocator_, column_cnt_));
int ret = OB_SUCCESS;
int row_cnt = 0;
// calculated max size 4444 for this schema
while(row_cnt < 4443) {
ASSERT_EQ(OB_SUCCESS, row_generate_.get_next_row(row));
ret = encoder.append_row(row);
row_cnt++;
}
ASSERT_EQ(OB_SUCCESS, row_generate_.get_next_row(row));
row.storage_datums_[2].len_ = 105000;
encoder.append_row(row);
LOG_INFO("Data buffer size", K(encoder.data_buffer_),
K(row_cnt), K(encoder.estimate_size_limit_), K(encoder.estimate_size_),
K(encoder.length_));
char *buf = NULL;
int64_t size = 0;
ASSERT_EQ(OB_SUCCESS, encoder.build_block(buf, size));
}
static ObObjType test_dict_large_varchar[2] = {ObIntType, ObVarcharType};
class TestDictLargeVarchar : public TestIColumnEncoder
{
public:
TestDictLargeVarchar() : TestIColumnEncoder(true)
{
rowkey_cnt_ = 1;
column_cnt_ = 2;
col_types_ = reinterpret_cast<ObObjType *>(allocator_.alloc(sizeof(ObObjType) * column_cnt_));
for (int64_t i = 0; i < column_cnt_; ++i) {
col_types_[i] = test_dict_large_varchar[i];
ObDatumRow row;
ASSERT_EQ(OB_SUCCESS, row.init(allocator_, column_cnt_));
int ret = OB_SUCCESS;
int row_cnt = 0;
// calculated max size 4444 for this schema
while(row_cnt < 4443) {
ASSERT_EQ(OB_SUCCESS, row_generate_.get_next_row(row));
ret = encoder.append_row(row);
row_cnt++;
}
ASSERT_EQ(OB_SUCCESS, row_generate_.get_next_row(row));
row.storage_datums_[2].len_ = 105000;
encoder.append_row(row);
LOG_INFO("Data buffer size", K(encoder.data_buffer_),
K(row_cnt), K(encoder.estimate_size_limit_), K(encoder.estimate_size_),
K(encoder.length_));
char *buf = NULL;
int64_t size = 0;
ASSERT_EQ(OB_SUCCESS, encoder.build_block(buf, size));
}
virtual ~TestDictLargeVarchar()
{
allocator_.free(col_types_);
}
int64_t full_column_cnt_ = 4;
};
TEST_F(TestDictLargeVarchar, test_dict_large_varchar)
{
ctx_.column_encodings_ = static_cast<int64_t *>(allocator_.alloc(sizeof(int64_t) * full_column_cnt_));
for (int64_t i = 0; i < full_column_cnt_; ++i) {
ctx_.column_encodings_[i] = ObColumnHeader::Type::DICT;
}
ObMicroBlockEncoder encoder;
ASSERT_EQ(OB_SUCCESS, encoder.init(ctx_));
ObDatumRow row;
ASSERT_EQ(OB_SUCCESS, row.init(allocator_, full_column_cnt_));
const int64_t varchar_data_size = UINT16_MAX * 2 + 1;
char *varchar_data = static_cast<char *>(allocator_.alloc(varchar_data_size));
ASSERT_TRUE(nullptr != varchar_data);
MEMSET(varchar_data, 7, varchar_data_size);
row.storage_datums_[0].set_int(1);
row.storage_datums_[3].set_string(varchar_data, varchar_data_size);
ASSERT_EQ(OB_SUCCESS, encoder.append_row(row));
char *buf = nullptr;
int64_t size = 0;
ASSERT_EQ(OB_SUCCESS, encoder.build_block(buf, size));
ObMicroBlockData micro_data(buf, size);
ObMicroBlockDecoder decoder;
ObDatumRow read_row;
ASSERT_EQ(OB_SUCCESS, read_row.init(full_column_cnt_));
ASSERT_EQ(OB_SUCCESS, decoder.init(micro_data, read_info_));
ASSERT_EQ(OB_SUCCESS, decoder.get_row(0, read_row));
STORAGE_LOG(INFO, "[Salton]", K(read_row));
ASSERT_EQ(row.storage_datums_[3].len_, read_row.storage_datums_[3].len_);
ASSERT_TRUE(ObDatum::binary_equal(row.storage_datums_[3], read_row.storage_datums_[3]));
}
class TestEncodingRowBufHolder : public ::testing::Test