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

patch 4.0

Browse Source
This commit is contained in:
wangzelin.wzl
2022-10-24 10:34:53 +08:00
parent 4ad6e00ec3
commit 93a1074b0c
10533 changed files with 2588271 additions and 2299373 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
unittest/sql/common/CMakeLists.txt
View File

@ -1,6 +1,6 @@
ob_unittest(test_ob_sql_utils)
ob_unittest(test_ob_end_trans_callback)
ob_unittest(test_ob_diagnose_info)
ob_unittest(test_rowkey)
ob_unittest(test_base64_encode)
ob_unittest(test_urowid)
sql_unittest(test_ob_sql_utils)
sql_unittest(test_ob_diagnose_info)
sql_unittest(test_rowkey)
sql_unittest(test_base64_encode)
# ob_unittest(test_urowid)
sql_unittest(decode_urowid)

95
unittest/sql/common/decode_urowid.cpp Normal file
View File

@ -0,0 +1,95 @@
/**
* Copyright (c) 2021 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.
*/
#define USING_LOG_PREFIX SQL
#include "lib/rowid/ob_urowid.h"
#include "lib/container/ob_array.h"
#include "lib/number/ob_number_v2.h"
#include "lib/timezone/ob_timezone_info.h"
#include "lib/encode/ob_base64_encode.h"
#include "common/object/ob_object.h"
#include "share/ob_errno.h"
#include <gtest/gtest.h>
#include <cstdlib>
#include <iostream>
#include <string>
#include <cstring>
using std::cout;
using std::endl;
namespace oceanbase
{
namespace common
{
class TestAllocator: public ObIAllocator
{
public:
virtual void *alloc(const int64_t size) override
{
return std::malloc(size);
}
virtual void free(void *ptr) override
{
return std::free(ptr);
}
virtual void *alloc(const int64_t size, const ObMemAttr &/* not used */)
{
return std::malloc(size);
}
};
void decode_output(const char *rowid_str)
{
TestAllocator alloc;
ObURowIDData dec_data;
ObArray<ObObj> pk_vals;
ASSERT_EQ(OB_SUCCESS, ObURowIDData::decode2urowid(rowid_str, strlen(rowid_str), alloc, dec_data));
ASSERT_EQ(OB_SUCCESS, dec_data.get_pk_vals(pk_vals));
int pos = 0;
char final_buf[16385] = { 0 }; // max is 16384
pos += sprintf(final_buf + pos, "[");
//pos += sprintf(final_buf + pos, "dba_len:%d, ", dec_data.get_guess_dba_len());
//pos += sprintf(final_buf + pos, "version:%d, ", dec_data.get_version());
//pos += sprintf(final_buf + pos, "pk_cnt:%ld, ", pk_vals.count());
for (int i = 0; i < pk_vals.count(); ++i) {
char tmp_buf[16385] = { 0 };
(void)pk_vals.at(i).to_string(tmp_buf, 1024);
if (i != pk_vals.count() - 1) {
pos += sprintf(final_buf + pos, "%s, ", tmp_buf);
} else {
pos += sprintf(final_buf + pos, "%s", tmp_buf);
}
}
pos += sprintf(final_buf + pos, "]");
printf("%s", final_buf);
}
} // end namesapce common
} // end namespace oceanbase
int main(int argc, char **argv)
{
testing::InitGoogleTest(&argc, argv);
if(argc >= 2)
{
for (int i = 1; i < argc; i++) {
if (argv[i][0] == '*') {
oceanbase::common::decode_output(argv[i]);
}
}
}
return 0;
}

50
unittest/sql/common/test_base64_encode.cpp
View File

@ -18,15 +18,17 @@
#include <iostream>
#include <string>
#include <cstring>
#include "share/backup/ob_archive_piece.h"
namespace oceanbase {
namespace common {
class TestBase64Encoder : public ::testing::Test {
namespace oceanbase
{
namespace common
{
class TestBase64Encoder: public ::testing::Test
{
public:
virtual void SetUp()
{}
virtual void TearDown()
{}
virtual void SetUp() {}
virtual void TearDown() {}
};
TEST_F(TestBase64Encoder, str_encode)
@ -36,19 +38,21 @@ TEST_F(TestBase64Encoder, str_encode)
int64_t encode_buf_len = ObBase64Encoder::needed_encoded_length(strlen(test_str));
ASSERT_EQ(encode_buf_len, strlen(expect_str));
char* encoded_buffer = (char*)std::malloc(encode_buf_len);
char *encoded_buffer = (char*)std::malloc(encode_buf_len);
int64_t encoded_pos = 0;
ASSERT_EQ(OB_SUCCESS,
ObBase64Encoder::encode((const uint8_t*)test_str, strlen(test_str), encoded_buffer, encode_buf_len, encoded_pos));
ASSERT_EQ(OB_SUCCESS, ObBase64Encoder::encode((const uint8_t *)test_str, strlen(test_str),
encoded_buffer, encode_buf_len, encoded_pos));
ASSERT_EQ(0, std::strncmp(encoded_buffer, expect_str, strlen(expect_str)));
int64_t decoded_buf_len = ObBase64Encoder::needed_decoded_length(encoded_pos);
uint8_t* decoded_buf = (uint8_t*)std::malloc(decoded_buf_len);
uint8_t *decoded_buf = (uint8_t *)std::malloc(decoded_buf_len);
int64_t decode_pos = 0;
ASSERT_EQ(OB_SUCCESS, ObBase64Encoder::decode(encoded_buffer, encoded_pos, decoded_buf, decoded_buf_len, decode_pos));
ASSERT_EQ(OB_SUCCESS, ObBase64Encoder::decode(encoded_buffer, encoded_pos,
decoded_buf,
decoded_buf_len, decode_pos));
ASSERT_EQ(decode_pos, strlen(test_str));
ASSERT_EQ(0, std::strncmp((char*)decoded_buf, test_str, strlen(test_str)));
ASSERT_EQ(0, std::strncmp((char *)decoded_buf, test_str, strlen(test_str)));
}
TEST_F(TestBase64Encoder, bin_encode)
@ -58,26 +62,26 @@ TEST_F(TestBase64Encoder, bin_encode)
int64_t encoded_buf_len = ObBase64Encoder::needed_encoded_length(sizeof(bin_test));
ASSERT_EQ(16, encoded_buf_len);
char* encoded_buffer = (char*)std::malloc(encoded_buf_len);
char *encoded_buffer = (char *)std::malloc(encoded_buf_len);
int64_t encoded_pos = 0;
ASSERT_EQ(
OB_SUCCESS, ObBase64Encoder::encode(bin_test, sizeof(bin_test), encoded_buffer, encoded_buf_len, encoded_pos));
ASSERT_EQ(OB_SUCCESS, ObBase64Encoder::encode(bin_test, sizeof(bin_test),
encoded_buffer, encoded_buf_len, encoded_pos));
ASSERT_EQ(0, std::strncmp(expect_str, encoded_buffer, strlen(expect_str)));
int64_t decoded_buf_len = ObBase64Encoder::needed_decoded_length(encoded_pos);
uint8_t* decoded_buffer = (uint8_t*)std::malloc(decoded_buf_len);
uint8_t *decoded_buffer = (uint8_t *)std::malloc(decoded_buf_len);
int64_t decoded_pos = 0;
ASSERT_EQ(
OB_SUCCESS, ObBase64Encoder::decode(encoded_buffer, encoded_pos, decoded_buffer, decoded_buf_len, decoded_pos));
ASSERT_EQ(OB_SUCCESS, ObBase64Encoder::decode(encoded_buffer, encoded_pos,
decoded_buffer, decoded_buf_len, decoded_pos));
ASSERT_EQ(sizeof(bin_test), decoded_pos);
ASSERT_EQ(0, std::memcmp(bin_test, decoded_buffer, decoded_pos));
}
} // namespace common
} // end namespace oceanbase
} // end oceanbase common
} // end namespace oceanbase
int main(int argc, char** argv)
int main(int argc, char **argv)
{
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
}

55
unittest/sql/common/test_ob_diagnose_info.cpp
View File

@ -18,48 +18,51 @@ using namespace common;
#define OK(value) ASSERT_EQ(OB_SUCCESS, (value))
class ObDiagnoseInfoTest : public ::testing::Test {
public:
ObDiagnoseInfoTest();
virtual ~ObDiagnoseInfoTest();
virtual void SetUp();
virtual void TearDown();
private:
// disallow copy
ObDiagnoseInfoTest(const ObDiagnoseInfoTest& other);
ObDiagnoseInfoTest& operator=(const ObDiagnoseInfoTest& other);
protected:
// data members
class ObDiagnoseInfoTest: public ::testing::Test
{
public:
ObDiagnoseInfoTest();
virtual ~ObDiagnoseInfoTest();
virtual void SetUp();
virtual void TearDown();
private:
// disallow copy
ObDiagnoseInfoTest(const ObDiagnoseInfoTest &other);
ObDiagnoseInfoTest& operator=(const ObDiagnoseInfoTest &other);
protected:
// data members
};
ObDiagnoseInfoTest::ObDiagnoseInfoTest()
{}
{
}
ObDiagnoseInfoTest::~ObDiagnoseInfoTest()
{}
{
}
void ObDiagnoseInfoTest::SetUp()
{}
{
}
void ObDiagnoseInfoTest::TearDown()
{}
{
}
TEST_F(ObDiagnoseInfoTest, basic_test)
{
// Not supported now
// EVENT_INC(RPC_PACKET_IN);
// ASSERT_EQ(1, EVENT_GET(RPC_PACKET_IN));
// EVENT_SET(RPC_PACKET_IN, 2);
// ASSERT_EQ(2, EVENT_GET(RPC_PACKET_IN));
// EVENT_ADD(RPC_PACKET_IN, 3);
// ASSERT_EQ(5, EVENT_GET(RPC_PACKET_IN));
// EVENT_INC(RPC_PACKET_IN);
// ASSERT_EQ(1, EVENT_GET(RPC_PACKET_IN));
// EVENT_SET(RPC_PACKET_IN, 2);
// ASSERT_EQ(2, EVENT_GET(RPC_PACKET_IN));
// EVENT_ADD(RPC_PACKET_IN, 3);
// ASSERT_EQ(5, EVENT_GET(RPC_PACKET_IN));
}
int main(int argc, char** argv)
int main(int argc, char **argv)
{
::testing::InitGoogleTest(&argc, argv);
::testing::InitGoogleTest(&argc,argv);
return RUN_ALL_TESTS();
}

63
unittest/sql/common/test_ob_end_trans_callback.cpp
View File

@ -1,63 +0,0 @@
/**
* Copyright (c) 2021 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.
*/
#define USING_LOG_PREFIX SQL
#include <gtest/gtest.h>
#include "lib/utility/ob_test_util.h"
#include "share/ob_define.h"
#include "sql/ob_end_trans_callback.h"
#include "lib/allocator/ob_malloc.h"
#include "storage/transaction/ob_trans_define.h"
using namespace oceanbase::common;
using namespace oceanbase::sql;
using namespace oceanbase::transaction;
namespace test {
class ObEndTransCallbacksTest : public ::testing::Test {
public:
ObEndTransCallbacksTest()
{}
virtual ~ObEndTransCallbacksTest()
{}
virtual void SetUp()
{}
virtual void TearDown()
{}
private:
// disallow copy
ObEndTransCallbacksTest(const ObEndTransCallbacksTest& other);
ObEndTransCallbacksTest& operator=(const ObEndTransCallbacksTest& other);
private:
// data members
};
TEST_F(ObEndTransCallbacksTest, signal_wait)
{
ObAddr observer(ObAddr::IPV4, "127.0.0.1", 8080);
ObTransDesc trans_desc;
ObEndTransSyncCallback callback;
ASSERT_EQ(OB_SUCCESS, callback.init(&trans_desc, NULL));
callback.callback(OB_SUCCESS);
ASSERT_EQ(OB_SUCCESS, callback.wait());
}
} // namespace test
int main(int argc, char** argv)
{
::testing::InitGoogleTest(&argc, argv);
OB_LOGGER.set_log_level("DEBUG");
return RUN_ALL_TESTS();
}

74
unittest/sql/common/test_ob_sql_utils.cpp
View File

@ -14,28 +14,25 @@
#include <gtest/gtest.h>
#include "lib/allocator/page_arena.h"
#include "sql/ob_sql_utils.h"
namespace oceanbase {
namespace oceanbase
{
using namespace oceanbase::sql;
using namespace oceanbase::common;
namespace test {
class ObSQLUtilsTest : public ::testing::Test {
public:
ObSQLUtilsTest()
{}
virtual ~ObSQLUtilsTest()
{}
virtual void SetUp()
{}
virtual void TearDown()
{}
private:
// disallow copy
ObSQLUtilsTest(const ObSQLUtilsTest& other);
ObSQLUtilsTest& operator=(const ObSQLUtilsTest& other);
private:
// data members
namespace test
{
class ObSQLUtilsTest: public ::testing::Test
{
public:
ObSQLUtilsTest(){}
virtual ~ObSQLUtilsTest(){}
virtual void SetUp(){}
virtual void TearDown(){}
private:
// disallow copy
ObSQLUtilsTest(const ObSQLUtilsTest &other);
ObSQLUtilsTest& operator=(const ObSQLUtilsTest &other);
private:
// data members
};
TEST_F(ObSQLUtilsTest, make_field_name)
{
@ -45,60 +42,53 @@ TEST_F(ObSQLUtilsTest, make_field_name)
ASSERT_EQ(OB_INVALID_ARGUMENT, ObSQLUtils::make_field_name(NULL, 0, CS_TYPE_UTF8MB4_GENERAL_CI, NULL, name));
ASSERT_EQ(OB_SUCCESS, ObSQLUtils::make_field_name(NULL, 0, CS_TYPE_UTF8MB4_GENERAL_CI, &allocator, name));
ASSERT_TRUE(name.empty());
const char* buf1 = "adf";
const char *buf1 = "adf";
int64_t len1 = 3;
ASSERT_EQ(OB_SUCCESS, ObSQLUtils::make_field_name(buf1, len1, CS_TYPE_UTF8MB4_GENERAL_CI, &allocator, name));
ASSERT_EQ(name, ObString::make_string("adf"));
ASSERT_EQ(name.length(), 3);
buf1 = " adf";
len1 = 5;
ASSERT_EQ(OB_SUCCESS, ObSQLUtils::make_field_name(buf1, len1, CS_TYPE_UTF8MB4_GENERAL_CI, &allocator, name));
ASSERT_EQ(name, ObString::make_string("adf"));
ASSERT_EQ(name.length(), 3);
buf1 = "\t\r\naaa";
len1 = 6;
ASSERT_EQ(OB_SUCCESS, ObSQLUtils::make_field_name(buf1, len1, CS_TYPE_UTF8MB4_GENERAL_CI, &allocator, name));
ASSERT_EQ(name, ObString::make_string("aaa"));
ASSERT_EQ(name.length(), 3);
buf1 = "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"1111111111111111111111111111111111111";
buf1 = "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111";
len1 = 255;
ASSERT_EQ(OB_SUCCESS, ObSQLUtils::make_field_name(buf1, len1, CS_TYPE_UTF8MB4_GENERAL_CI, &allocator, name));
ASSERT_EQ(name, ObString::make_string(buf1));
printf("prt:%s, len:%d\n", name.ptr(), name.length());
printf("prt:%s, len:%d\n", name.ptr(), name.length());
ASSERT_EQ(name.length(), 255);
const char* buf2 = "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"1111111111111111111111111111111111111111111111111111111111111122222";
const char *buf2 = "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111122222";
int64_t len2 = 261;
ASSERT_EQ(OB_SUCCESS, ObSQLUtils::make_field_name(buf2, len2, CS_TYPE_UTF8MB4_GENERAL_CI, &allocator, name));
ASSERT_EQ(name, ObString::make_string(buf1));
ASSERT_EQ(name.length(), 255);
buf2 = "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"1111111111111111111111111111111111222222";
buf2 = "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111222222";
len2 = 272;
const char* buf3 = "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
"1111111111111111111111111111111111111111111111111111111111222";
const char *buf3 = "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111222";
ASSERT_EQ(OB_SUCCESS, ObSQLUtils::make_field_name(buf2, len2, CS_TYPE_UTF8MB4_GENERAL_CI, &allocator, name));
ASSERT_EQ(name, ObString::make_string(buf3));
ASSERT_EQ(name.length(), 255);
printf("prt:%s, len:%d\n", name.ptr(), name.length());
printf("prt:%s, len:%d\n", name.ptr(), name.length());
}
} // namespace test
} // namespace oceanbase
int main(int argc, char** argv)
}
}
int main(int argc, char **argv)
{
oceanbase::common::ObLogger::get_logger().set_log_level("DEBUG");
OB_LOGGER.set_log_level("DEBUG");
::testing::InitGoogleTest(&argc, argv);
::testing::InitGoogleTest(&argc,argv);
return RUN_ALL_TESTS();
}

26
unittest/sql/common/test_rowkey.cpp
View File

@ -15,18 +15,18 @@
#include "sql/ob_sql_init.h"
using namespace oceanbase;
// using namespace oceanbase::sql;
//using namespace oceanbase::sql;
using namespace oceanbase::sql;
using namespace oceanbase::common;
namespace test {
namespace test
{
const int64_t SER_BUF_LEN = 10001;
const int64_t ITEM_CNT = 5;
class TestRowkey : public ::testing::Test {
class TestRowkey: public ::testing::Test
{
public:
TestRowkey()
{}
~TestRowkey()
{}
TestRowkey() {}
~TestRowkey() {}
};
TEST_F(TestRowkey, test_serialize)
@ -36,27 +36,27 @@ TEST_F(TestRowkey, test_serialize)
int64_t pos = 0;
// serialize
ObObj objs[ITEM_CNT];
for (int64_t i = 0; i < ITEM_CNT; i++) {
for (int64_t i = 0; i < ITEM_CNT ; i++) {
objs[i].set_int(i);
row_key[i].assign(&objs[i], 1);
pos = 0;
ASSERT_EQ(OB_SUCCESS, row_key[i].serialize(buf[i], SER_BUF_LEN, pos));
}
// deserialize
//deserialize
ObRowkey de_row_key;
for (int i = 0; i < ITEM_CNT; ++i) {
for (int i = 0 ; i < ITEM_CNT; ++i) {
pos = 0;
ASSERT_EQ(OB_SUCCESS, de_row_key.deserialize(buf[i], SER_BUF_LEN, pos));
ASSERT_EQ(true, de_row_key == row_key[i]);
}
}
} // namespace test
}
int main(int argc, char** argv)
int main(int argc, char **argv)
{
init_sql_factories();
OB_LOGGER.set_log_level("TRACE");
::testing::InitGoogleTest(&argc, argv);
::testing::InitGoogleTest(&argc,argv);
return RUN_ALL_TESTS();
}

182
unittest/sql/common/test_urowid.cpp
View File

@ -29,24 +29,28 @@
using std::cout;
using std::endl;
namespace oceanbase {
namespace common {
class TestAllocator : public ObIAllocator {
namespace oceanbase
{
namespace common
{
class TestAllocator: public ObIAllocator
{
public:
virtual void* alloc(const int64_t size) override
virtual void *alloc(const int64_t size) override
{
return std::malloc(size);
}
virtual void free(void* ptr) override
virtual void free(void *ptr) override
{
return std::free(ptr);
}
virtual void* alloc(const int64_t size, const ObMemAttr& /* not used */)
virtual void *alloc(const int64_t size, const ObMemAttr &/* not used */)
{
return std::malloc(size);
}
};
class TestURowID {
class TestURowID
{
public:
// void SetUp() override {}
// void TearDown() override {}
@ -79,7 +83,7 @@ public:
pk_val.set_number(test_number);
ASSERT_EQ(OB_SUCCESS, pk_vals.push_back(pk_val));
const char* test_str = "hello, this is a test";
const char *test_str = "hello, this is a test";
pk_val.set_char(ObString(strlen(test_str), test_str));
ASSERT_EQ(OB_SUCCESS, pk_vals.push_back(pk_val));
@ -94,25 +98,33 @@ public:
ObTimeZoneInfo time_zone_info;
time_zone_info.set_timezone("+8:00");
ObTimeConvertCtx time_convert_ctx(&time_zone_info, ObTimeConverter::COMPAT_OLD_NLS_DATE_FORMAT, true);
ObTimeConvertCtx time_convert_ctx(&time_zone_info,
ObTimeConverter::COMPAT_OLD_NLS_DATE_FORMAT,
true);
ObOTimestampData otime_data;
ObScale scale;
ASSERT_EQ(OB_SUCCESS,
ObTimeConverter::str_to_otimestamp(
"2020-02-24 21:37:25", time_convert_ctx, ObTimestampTZType, otime_data, scale));
ASSERT_EQ(OB_SUCCESS, ObTimeConverter::str_to_otimestamp("2020-02-24 21:37:25",
time_convert_ctx,
ObTimestampTZType,
otime_data,
scale));
pk_val.set_timestamp_tz(otime_data);
ASSERT_EQ(OB_SUCCESS, pk_vals.push_back(pk_val));
ASSERT_EQ(OB_SUCCESS,
ObTimeConverter::str_to_otimestamp(
"2020-02-24 21:37:25", time_convert_ctx, ObTimestampNanoType, otime_data, scale));
ASSERT_EQ(OB_SUCCESS, ObTimeConverter::str_to_otimestamp("2020-02-24 21:37:25",
time_convert_ctx,
ObTimestampNanoType,
otime_data,
scale));
pk_val.set_timestamp_nano(otime_data);
ASSERT_EQ(OB_SUCCESS, pk_vals.push_back(pk_val));
ASSERT_EQ(OB_SUCCESS,
ObTimeConverter::str_to_otimestamp(
"2020-02-24 21:37:25", time_convert_ctx, ObTimestampNanoType, otime_data, scale));
ASSERT_EQ(OB_SUCCESS, ObTimeConverter::str_to_otimestamp("2020-02-24 21:37:25",
time_convert_ctx,
ObTimestampNanoType,
otime_data,
scale));
pk_val.set_timestamp_nano(otime_data);
ASSERT_EQ(OB_SUCCESS, pk_vals.push_back(pk_val));
@ -124,7 +136,8 @@ public:
scale = 99;
ObIntervalDSValue ds_value;
ASSERT_EQ(OB_SUCCESS, ObTimeConverter::str_to_interval_ds("000000012 11:11:11", ds_value, scale));
ASSERT_EQ(OB_SUCCESS, ObTimeConverter::str_to_interval_ds("000000012 11:11:11",
ds_value, scale));
ASSERT_EQ(OB_SUCCESS, pk_vals.push_back(pk_val));
ObURowIDData urowid_data;
@ -133,7 +146,7 @@ public:
int64_t pos = urowid_data.get_pk_content_offset();
int i = 0;
ObObj tmp_obj;
for (; pos < urowid_data.rowid_len_;) {
for(; pos < urowid_data.rowid_len_;) {
ASSERT_EQ(urowid_data.get_pk_type(pos), pk_vals.at(i).get_type());
ASSERT_EQ(OB_SUCCESS, urowid_data.get_pk_value(pk_vals.at(i).get_type(), pos, tmp_obj));
ASSERT_EQ(tmp_obj, pk_vals.at(i));
@ -144,37 +157,39 @@ public:
void set_and_get_pk()
{
#define TEST_SET_AND_GET_VAL(val, val_len) \
do { \
pk_vals.reset(); \
urowid_data.reset(); \
ObObj tmp_obj; \
int64_t urowid_version = ObURowIDData::PK_ROWID_VERSION; \
ASSERT_EQ(OB_SUCCESS, pk_vals.push_back(pk_val)); \
#define TEST_SET_AND_GET_VAL(val, val_len) \
do { \
pk_vals.reset(); \
urowid_data.reset(); \
ObObj tmp_obj; \
int64_t urowid_version = ObURowIDData::PK_ROWID_VERSION; \
ASSERT_EQ(OB_SUCCESS, pk_vals.push_back(pk_val)); \
ASSERT_EQ(OB_SUCCESS, urowid_data.set_rowid_content(pk_vals, ObURowIDData::PK_ROWID_VERSION, allocator)); \
int64_t tmp_pos = urowid_data.get_pk_content_offset(); \
ASSERT_EQ(urowid_version, urowid_data.get_version()); \
ASSERT_TRUE(urowid_data.is_valid_urowid()); \
ASSERT_EQ(val_len + 1, urowid_data.get_obj_size(val)); \
ASSERT_EQ(tmp_pos + val_len + 1, urowid_data.get_buf_len()); \
ASSERT_EQ(urowid_data.get_pk_type(tmp_pos), val.get_type()); \
ASSERT_EQ(tmp_pos, urowid_data.get_pk_content_offset() + 1); \
ASSERT_EQ(OB_SUCCESS, urowid_data.get_pk_value(val.get_type(), tmp_pos, tmp_obj)); \
ASSERT_EQ(tmp_obj, val); \
test_encode_decode(pk_vals, urowid_data); \
\
ObObj urowid_obj; \
ObURowIDData urowid2; \
urowid_obj.set_urowid(urowid_data); \
pk_vals.reset(); \
tmp_obj.reset(); \
ASSERT_EQ(OB_SUCCESS, pk_vals.push_back(urowid_obj)); \
int64_t tmp_pos = urowid_data.get_pk_content_offset(); \
ASSERT_EQ(urowid_version, urowid_data.get_version()); \
ASSERT_TRUE(urowid_data.is_valid_urowid()); \
ASSERT_EQ(val_len + 1, urowid_data.get_obj_size(val)); \
ASSERT_EQ(tmp_pos + val_len + 1, urowid_data.get_buf_len()); \
ASSERT_EQ(urowid_data.get_pk_type(tmp_pos), val.get_type()); \
ASSERT_EQ(tmp_pos, urowid_data.get_pk_content_offset() + 1); \
ASSERT_EQ(OB_SUCCESS, \
urowid_data.get_pk_value(val.get_type(), tmp_pos, tmp_obj)); \
ASSERT_EQ(tmp_obj, val); \
test_encode_decode(pk_vals, urowid_data); \
\
ObObj urowid_obj; \
ObURowIDData urowid2; \
urowid_obj.set_urowid(urowid_data); \
pk_vals.reset(); \
tmp_obj.reset(); \
ASSERT_EQ(OB_SUCCESS, pk_vals.push_back(urowid_obj)); \
ASSERT_EQ(OB_SUCCESS, urowid2.set_rowid_content(pk_vals, ObURowIDData::PK_ROWID_VERSION, allocator)); \
ASSERT_TRUE(urowid2.is_valid_urowid()); \
tmp_pos = urowid2.get_pk_content_offset(); \
ASSERT_EQ(ObURowIDType, urowid2.get_pk_type(tmp_pos)); \
ASSERT_EQ(OB_SUCCESS, urowid2.get_pk_value(urowid_obj.get_type(), tmp_pos, tmp_obj)); \
ASSERT_TRUE(urowid_data == tmp_obj.get_urowid()); \
ASSERT_TRUE(urowid2.is_valid_urowid()); \
tmp_pos = urowid2.get_pk_content_offset(); \
ASSERT_EQ(ObURowIDType, urowid2.get_pk_type(tmp_pos)); \
ASSERT_EQ(OB_SUCCESS, \
urowid2.get_pk_value(urowid_obj.get_type(), tmp_pos, tmp_obj)); \
ASSERT_TRUE(urowid_data == tmp_obj.get_urowid()); \
} while (0);
ObURowIDData urowid_data;
@ -221,7 +236,7 @@ public:
pk_val.set_number_float(test_number);
TEST_SET_AND_GET_VAL(pk_val, 4 + sizeof(uint32_t) * test_number.get_desc().len_);
const char* test_str = "hello, this is a test";
const char *test_str = "hello, this is a test";
pk_val.set_char(ObString(strlen(test_str), test_str));
TEST_SET_AND_GET_VAL(pk_val, 5 + strlen(test_str));
@ -236,25 +251,33 @@ public:
ObTimeZoneInfo time_zone_info;
time_zone_info.set_timezone("+8:00");
ObTimeConvertCtx time_convert_ctx(&time_zone_info, ObTimeConverter::COMPAT_OLD_NLS_DATE_FORMAT, true);
ObTimeConvertCtx time_convert_ctx(&time_zone_info,
ObTimeConverter::COMPAT_OLD_NLS_DATE_FORMAT,
true);
ObOTimestampData otime_data;
ObScale scale;
ASSERT_EQ(OB_SUCCESS,
ObTimeConverter::str_to_otimestamp(
"2020-02-24 21:37:25", time_convert_ctx, ObTimestampTZType, otime_data, scale));
ASSERT_EQ(OB_SUCCESS, ObTimeConverter::str_to_otimestamp("2020-02-24 21:37:25",
time_convert_ctx,
ObTimestampTZType,
otime_data,
scale));
pk_val.set_timestamp_tz(otime_data);
TEST_SET_AND_GET_VAL(pk_val, 12);
ASSERT_EQ(OB_SUCCESS,
ObTimeConverter::str_to_otimestamp(
"2020-02-24 21:37:25", time_convert_ctx, ObTimestampLTZType, otime_data, scale));
ASSERT_EQ(OB_SUCCESS, ObTimeConverter::str_to_otimestamp("2020-02-24 21:37:25",
time_convert_ctx,
ObTimestampLTZType,
otime_data,
scale));
pk_val.set_timestamp_ltz(otime_data);
TEST_SET_AND_GET_VAL(pk_val, 10);
ASSERT_EQ(OB_SUCCESS,
ObTimeConverter::str_to_otimestamp(
"2020-02-24 21:37:25", time_convert_ctx, ObTimestampNanoType, otime_data, scale));
ASSERT_EQ(OB_SUCCESS, ObTimeConverter::str_to_otimestamp("2020-02-24 21:37:25",
time_convert_ctx,
ObTimestampNanoType,
otime_data,
scale));
pk_val.set_timestamp_nano(otime_data);
TEST_SET_AND_GET_VAL(pk_val, 10);
@ -266,16 +289,17 @@ public:
scale = 99;
ObIntervalDSValue ds_value;
ASSERT_EQ(OB_SUCCESS, ObTimeConverter::str_to_interval_ds("000000012 11:11:11", ds_value, scale));
ASSERT_EQ(OB_SUCCESS, ObTimeConverter::str_to_interval_ds("000000012 11:11:11",
ds_value, scale));
pk_val.set_interval_ds(ds_value);
TEST_SET_AND_GET_VAL(pk_val, 12);
}
void test_encode_decode(ObIArray<ObObj>& pk_vals, ObURowIDData& urowid_data)
void test_encode_decode(ObIArray<ObObj> &pk_vals, ObURowIDData &urowid_data)
{
TestAllocator allocator;
const int64_t encode_buf_len = urowid_data.needed_base64_buffer_size();
char* encode_buf = (char*)allocator.alloc(encode_buf_len);
char *encode_buf = (char *)allocator.alloc(encode_buf_len);
int64_t encoded_len = 0;
ASSERT_EQ(OB_SUCCESS, urowid_data.get_base64_str(encode_buf, encode_buf_len, encoded_len));
ASSERT_EQ(encoded_len, encode_buf_len);
@ -283,12 +307,13 @@ public:
// const int64_t decode_buf_len = ObURowIDData::needed_urowid_buf_size(encoded_len);
// char *decode_buf = (char *)allocator.alloc(decode_buf_len);
ObURowIDData decode_data;
ASSERT_EQ(OB_SUCCESS, ObURowIDData::decode2urowid(encode_buf, encoded_len, allocator, decode_data));
ASSERT_EQ(OB_SUCCESS, ObURowIDData::decode2urowid(encode_buf, encoded_len,
allocator, decode_data));
ASSERT_EQ(decode_data, urowid_data);
int64_t decode_pos = decode_data.get_pk_content_offset();
int64_t i = 0;
for (; decode_pos < decode_data.rowid_len_;) {
for(; decode_pos < decode_data.rowid_len_; ) {
ObObjType obj_type = decode_data.get_pk_type(decode_pos);
ASSERT_EQ(obj_type, pk_vals.at(i).get_type());
ObObj tmp_obj;
@ -340,17 +365,15 @@ public:
}
};
TEST(TestURowID, single_urowid_test)
{
TEST(TestURowID, single_urowid_test) {
TestAllocator alloc;
const char* str = "*AAEWLlcAAABnYXJuaXNoIG51bWJlciB0ZWFyaW5nIG1hbnRsaW5nIGFjY3VzdG9tcyBleHRyZW1lcyBiYXNlbHkgY3Jhemlse"
"SBlbGRlciB0YXJkaWVzIHByZW1pc2UtCwAAAAACCkcywAAAAAAA";
// bug: https://work.aone.alibaba-inc.com/issue/31597994
const char *str = "*AAEWLlcAAABnYXJuaXNoIG51bWJlciB0ZWFyaW5nIG1hbnRsaW5nIGFjY3VzdG9tcyBleHRyZW1lcyBiYXNlbHkgY3JhemlseSBlbGRlciB0YXJkaWVzIHByZW1pc2UtCwAAAAACCkcywAAAAAAA";
ObURowIDData dec_data;
ASSERT_EQ(OB_SUCCESS, ObURowIDData::decode2urowid(str, strlen(str), alloc, dec_data));
}
TEST(TestURowID, set_and_get_pk)
{
TEST(TestURowID, set_and_get_pk) {
TestURowID urowid_test;
urowid_test.set_and_get_pk();
}
@ -359,8 +382,7 @@ void decode_output()
{
TestAllocator alloc;
// const char *str = "*AAIPAQEAwHsAAAAACgEAAAAAAAAA";
const char* str = "*AAEWLlcAAABnYXJuaXNoIG51bWJlciB0ZWFyaW5nIG1hbnRsaW5nIGFjY3VzdG9tcyBleHRyZW1lcyBiYXNlbHkgY3Jhemlse"
"SBlbGRlciB0YXJkaWVzIHByZW1pc2UtCwAAAAACCkcywAAAAAAA";
const char *str = "*AAEWLlcAAABnYXJuaXNoIG51bWJlciB0ZWFyaW5nIG1hbnRsaW5nIGFjY3VzdG9tcyBleHRyZW1lcyBiYXNlbHkgY3JhemlseSBlbGRlciB0YXJkaWVzIHByZW1pc2UtCwAAAAACCkcywAAAAAAA";
ObURowIDData dec_data;
ASSERT_EQ(OB_SUCCESS, ObURowIDData::decode2urowid(str, strlen(str), alloc, dec_data));
@ -375,24 +397,24 @@ void decode_output()
}
}
TEST(TestURowID, multi_set_and_get)
{
TEST(TestURowID, multi_set_and_get) {
TestURowID urowid_test;
urowid_test.multi_set_and_get();
}
TEST(TestURowID, cmp)
{
TEST(TestURowID, cmp) {
TestURowID urowid_test;
urowid_test.test_urowid_cmp();
}
} // namespace common
} // end namespace oceanbase
} // end namesapce common
} // end namespace oceanbase
int main(int argc, char** argv)
int main(int argc, char **argv)
{
testing::InitGoogleTest(&argc, argv);
system("rm -rf test_urowid.log");
OB_LOGGER.set_log_level("INFO");
OB_LOGGER.set_file_name("test_urowid.log", true);
oceanbase::common::decode_output();
return RUN_ALL_TESTS();
}