592 lines
24 KiB
C++
592 lines
24 KiB
C++
/**
|
|
* 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_ENG
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <string.h>
|
|
#include <gtest/gtest.h>
|
|
#include "lib/hash/ob_hashmap.h"
|
|
#include "sql/engine/expr/ob_expr_add.h"
|
|
#include "sql/engine/expr/ob_expr_minus.h"
|
|
#include "sql/engine/expr/ob_expr_mul.h"
|
|
#include "sql/engine/expr/ob_expr_div.h"
|
|
#include "sql/engine/expr/ob_expr_mod.h"
|
|
#include "sql/engine/expr/ob_expr_bit_and.h"
|
|
#include "sql/engine/expr/ob_expr_bit_or.h"
|
|
#include "share/object/ob_obj_cast.h"
|
|
#include "ob_expr_test_utils.h"
|
|
#include "lib/oblog/ob_log.h"
|
|
#include "common/object/ob_object.h"
|
|
|
|
using namespace oceanbase::common;
|
|
using namespace oceanbase::sql;
|
|
using namespace oceanbase::common::hash;
|
|
|
|
class ObExprArithmaticTest : public ::testing::Test {
|
|
public:
|
|
ObExprArithmaticTest();
|
|
virtual ~ObExprArithmaticTest();
|
|
virtual void SetUp();
|
|
virtual void TearDown();
|
|
|
|
enum EXPR_TYPE { NOT_SUPPORTED, ADD, MINUS, MUL, DIV, MOD, BIT_AND, BIT_OR, EXPR_COUNT };
|
|
|
|
enum SERVER_TYPE { MYSQL, OB };
|
|
|
|
static ObArenaAllocator alloc;
|
|
static ObExprAdd add_optr;
|
|
static ObExprMinus minus_optr;
|
|
static ObExprMul mul_optr;
|
|
static ObExprDiv div_optr;
|
|
static ObExprMod mod_optr;
|
|
static ObExprBitAnd bit_and_optr;
|
|
static ObExprBitOr bit_or_optr;
|
|
|
|
static ObExprOperator* operators[EXPR_COUNT];
|
|
|
|
static int init_arithmetic_test();
|
|
static int lookup_type_from_str(SERVER_TYPE server, const char* str, int64_t len, ObObjType& type);
|
|
static int build_obj_from_str(const char* str, int64_t len, ObObjType type, ObObj& obj, ObIAllocator& buf);
|
|
static int get_expr_type_from_str(const char* str, int64_t len, EXPR_TYPE& type);
|
|
static int get_res_type_from_str(char* str, int64_t len, ObObjType& type);
|
|
static bool type_need_fuzzy_cmp(ObObjType type1, ObObjType type2);
|
|
static int truncate_number_precision(
|
|
number::ObNumber& num, number::ObNumber& num_trunc, int16_t scale, ObIAllocator& buf);
|
|
|
|
private:
|
|
// disallow copy
|
|
ObExprArithmaticTest(const ObExprArithmaticTest& other);
|
|
ObExprArithmaticTest& operator=(const ObExprArithmaticTest& other);
|
|
|
|
static bool map_inited;
|
|
static ObHashMap<ObString, ObObjType> str_to_type_map_ob_;
|
|
static ObHashMap<ObString, ObObjType> str_to_type_map_mysql_;
|
|
static ObHashMap<ObString, EXPR_TYPE> str_to_expr_type_map_;
|
|
|
|
protected:
|
|
// data members
|
|
};
|
|
|
|
bool ObExprArithmaticTest::map_inited = false;
|
|
ObHashMap<ObString, ObObjType> ObExprArithmaticTest::str_to_type_map_ob_;
|
|
ObHashMap<ObString, ObObjType> ObExprArithmaticTest::str_to_type_map_mysql_;
|
|
ObHashMap<ObString, ObExprArithmaticTest::EXPR_TYPE> ObExprArithmaticTest::str_to_expr_type_map_;
|
|
ObExprOperator* ObExprArithmaticTest::operators[EXPR_COUNT] = {NULL};
|
|
|
|
ObArenaAllocator ObExprArithmaticTest::alloc;
|
|
ObExprAdd ObExprArithmaticTest::add_optr(alloc);
|
|
ObExprMinus ObExprArithmaticTest::minus_optr(alloc);
|
|
ObExprMul ObExprArithmaticTest::mul_optr(alloc);
|
|
ObExprDiv ObExprArithmaticTest::div_optr(alloc);
|
|
ObExprMod ObExprArithmaticTest::mod_optr(alloc);
|
|
ObExprBitAnd ObExprArithmaticTest::bit_and_optr(alloc);
|
|
ObExprBitOr ObExprArithmaticTest::bit_or_optr(alloc);
|
|
|
|
int ObExprArithmaticTest::truncate_number_precision(
|
|
number::ObNumber& num, number::ObNumber& num_trunc, int16_t scale, ObIAllocator& buf)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
const static int64_t LITERAL_BUF_LEN = 256;
|
|
int64_t pos = 0;
|
|
char num_literal_buf[LITERAL_BUF_LEN];
|
|
if (OB_SUCCESS != (ret = num.format(num_literal_buf, LITERAL_BUF_LEN, pos, -1))) {
|
|
_OB_LOG(WARN, "fail format number");
|
|
} else {
|
|
if (pos < 0 || pos > LITERAL_BUF_LEN - 1) {
|
|
_OB_LOG(WARN, "number literal overflow");
|
|
} else {
|
|
num_literal_buf[pos] = 0;
|
|
}
|
|
if (OB_SUCCESS != (ret = num_trunc.from(30, scale, num_literal_buf, strlen(num_literal_buf), buf))) {
|
|
_OB_LOG(WARN, "number from str failed");
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
bool ObExprArithmaticTest::type_need_fuzzy_cmp(ObObjType type1, ObObjType type2)
|
|
{
|
|
bool bool_ret = false;
|
|
if (ObFloatType == type1 || ObFloatType == type2 || ObDoubleType == type1 || ObDoubleType == type2) {
|
|
bool_ret = true;
|
|
} else {
|
|
bool_ret = false;
|
|
}
|
|
return bool_ret;
|
|
}
|
|
|
|
int ObExprArithmaticTest::get_expr_type_from_str(const char* str, int64_t len, EXPR_TYPE& type)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (false == map_inited) {
|
|
ret = OB_NOT_INIT;
|
|
} else {
|
|
ObString str_val(0, static_cast<int32_t>(len), str);
|
|
ret = str_to_expr_type_map_.get_refactored(str_val, type);
|
|
if (OB_HASH_NOT_EXIST == ret) {
|
|
type = NOT_SUPPORTED;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObExprArithmaticTest::build_obj_from_str(
|
|
const char* str, int64_t len, ObObjType type, ObObj& obj, ObIAllocator& buf)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (0 == strncmp("null", str, len)) {
|
|
obj.set_null();
|
|
} else {
|
|
ObString str_val(0, static_cast<int32_t>(len), str);
|
|
ObObj str_obj;
|
|
str_obj.set_varchar(str_val);
|
|
ObCastCtx cast_ctx(&buf, NULL, 0, CM_NONE, CS_TYPE_INVALID, NULL);
|
|
if (OB_FAIL(ObObjCaster::to_type(type, cast_ctx, str_obj, obj))) {
|
|
_OB_LOG(ERROR, "failed to cast obj, str = %s", str);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObExprArithmaticTest::lookup_type_from_str(SERVER_TYPE server, const char* str, int64_t len, ObObjType& type)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (false == map_inited) {
|
|
ret = OB_NOT_INIT;
|
|
} else {
|
|
ObString key(0, static_cast<int32_t>(len), str);
|
|
if (MYSQL == server) {
|
|
ret = str_to_type_map_mysql_.get_refactored(key, type);
|
|
} else if (OB == server) {
|
|
ret = str_to_type_map_ob_.get_refactored(key, type);
|
|
}
|
|
if (OB_HASH_NOT_EXIST == ret) {
|
|
type = ObMaxType;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObExprArithmaticTest::init_arithmetic_test()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (!map_inited) {
|
|
|
|
operators[ADD] = &add_optr;
|
|
operators[MINUS] = &minus_optr;
|
|
operators[MUL] = &mul_optr;
|
|
operators[DIV] = &div_optr;
|
|
operators[MOD] = &mod_optr;
|
|
operators[BIT_AND] = &bit_and_optr;
|
|
operators[BIT_OR] = &bit_or_optr;
|
|
|
|
if (OB_SUCCESS != (ret = str_to_type_map_ob_.create(10, ObModIds::OB_HASH_BUCKET))) {
|
|
_OB_LOG(ERROR, "failed to allocate memory ret = %d", ret);
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_ob_.set_refactored(ObString::make_string("tinyint"), ObTinyIntType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_ob_.set_refactored(ObString::make_string("smallint"), ObSmallIntType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_ob_.set_refactored(ObString::make_string("mediumint"), ObMediumIntType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS != (ret = str_to_type_map_ob_.set_refactored(ObString::make_string("int32"), ObInt32Type))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS != (ret = str_to_type_map_ob_.set_refactored(ObString::make_string("int"), ObIntType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_ob_.set_refactored(ObString::make_string("utinyint"), ObUTinyIntType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_ob_.set_refactored(ObString::make_string("usmallint"), ObUSmallIntType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_ob_.set_refactored(ObString::make_string("umediumint"), ObUMediumIntType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_ob_.set_refactored(ObString::make_string("uint32"), ObUInt32Type))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_ob_.set_refactored(ObString::make_string("uint64"), ObUInt64Type))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS != (ret = str_to_type_map_ob_.set_refactored(ObString::make_string("float"), ObFloatType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_ob_.set_refactored(ObString::make_string("double"), ObDoubleType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_ob_.set_refactored(ObString::make_string("varchar"), ObVarcharType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS != (ret = str_to_type_map_ob_.set_refactored(ObString::make_string("char"), ObCharType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_ob_.set_refactored(ObString::make_string("number"), ObNumberType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
}
|
|
if (OB_SUCCESS == ret) {
|
|
if (OB_SUCCESS != (ret = str_to_type_map_mysql_.create(10, ObModIds::OB_HASH_BUCKET))) {
|
|
_OB_LOG(ERROR, "failed to allocate memory ret = %d", ret);
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_mysql_.set_refactored(ObString::make_string("tinyint"), ObTinyIntType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_mysql_.set_refactored(ObString::make_string("smallint"), ObSmallIntType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_mysql_.set_refactored(ObString::make_string("mediumint"), ObMediumIntType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_mysql_.set_refactored(ObString::make_string("int"), ObInt32Type))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_mysql_.set_refactored(ObString::make_string("bigint"), ObIntType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS != (ret = str_to_type_map_mysql_.set_refactored(
|
|
ObString::make_string("tinyint unsigned"), ObUTinyIntType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS != (ret = str_to_type_map_mysql_.set_refactored(
|
|
ObString::make_string("smallint unsigned"), ObUSmallIntType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS != (ret = str_to_type_map_mysql_.set_refactored(
|
|
ObString::make_string("mediumint unsigned"), ObUMediumIntType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_mysql_.set_refactored(ObString::make_string("int unsigned"), ObUInt32Type))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS != (ret = str_to_type_map_mysql_.set_refactored(
|
|
ObString::make_string("bigint unsigned"), ObUInt64Type))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_mysql_.set_refactored(ObString::make_string("float"), ObFloatType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_mysql_.set_refactored(ObString::make_string("double"), ObDoubleType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_mysql_.set_refactored(ObString::make_string("varchar"), ObVarcharType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_mysql_.set_refactored(ObString::make_string("char"), ObCharType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_mysql_.set_refactored(ObString::make_string("number"), ObNumberType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_type_map_mysql_.set_refactored(ObString::make_string("decimal"), ObNumberType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS != (ret = str_to_type_map_mysql_.set_refactored(
|
|
ObString::make_string("decimal unsigned"), ObUNumberType))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
}
|
|
}
|
|
|
|
if (OB_SUCCESS == ret) {
|
|
if (OB_SUCCESS != (ret = str_to_expr_type_map_.create(10, ObModIds::OB_HASH_BUCKET))) {
|
|
_OB_LOG(ERROR, "failed to allocate memory ret = %d", ret);
|
|
} else if (OB_SUCCESS != (ret = str_to_expr_type_map_.set_refactored(ObString::make_string("add"), ADD))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS != (ret = str_to_expr_type_map_.set_refactored(ObString::make_string("minus"), MINUS))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS != (ret = str_to_expr_type_map_.set_refactored(ObString::make_string("mul"), MUL))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS != (ret = str_to_expr_type_map_.set_refactored(ObString::make_string("div"), DIV))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS != (ret = str_to_expr_type_map_.set_refactored(ObString::make_string("mod"), MOD))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS !=
|
|
(ret = str_to_expr_type_map_.set_refactored(ObString::make_string("bit_and"), BIT_AND))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
} else if (OB_SUCCESS != (ret = str_to_expr_type_map_.set_refactored(ObString::make_string("bit_or"), BIT_OR))) {
|
|
_OB_LOG(ERROR, "failed to insert type hash");
|
|
}
|
|
}
|
|
}
|
|
if (OB_SUCCESS == ret) {
|
|
map_inited = true;
|
|
ret = OB_SUCCESS;
|
|
} else {
|
|
OB_ASSERT(false);
|
|
ret = OB_ERROR;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObExprArithmaticTest::get_res_type_from_str(char* str, int64_t len, ObObjType& type)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
char* space_pos = NULL;
|
|
char* left_brac_pos = NULL;
|
|
int64_t real_type_str_len = 0;
|
|
// normalize type name.
|
|
left_brac_pos = strchr(str, '(');
|
|
space_pos = strchr(str, ' ');
|
|
if (NULL == space_pos) { // one-part type name
|
|
if (NULL != left_brac_pos) { // have bracket
|
|
*left_brac_pos = '\0'; // truncate
|
|
real_type_str_len = static_cast<int64_t>(left_brac_pos - str);
|
|
} else {
|
|
real_type_str_len = len; // no bracket
|
|
}
|
|
} else { // two-part type name
|
|
if (NULL != left_brac_pos) { // have bracket
|
|
memmove(left_brac_pos, space_pos, strlen(space_pos) + 1); // including the '\0'
|
|
real_type_str_len = strlen(str);
|
|
} else { // no bracket
|
|
real_type_str_len = len;
|
|
}
|
|
}
|
|
// we got normalized type name, brackets are trimed
|
|
ret = lookup_type_from_str(MYSQL, str, real_type_str_len, type);
|
|
return ret;
|
|
}
|
|
|
|
ObExprArithmaticTest::ObExprArithmaticTest()
|
|
{
|
|
init_arithmetic_test();
|
|
}
|
|
|
|
ObExprArithmaticTest::~ObExprArithmaticTest()
|
|
{}
|
|
|
|
void ObExprArithmaticTest::SetUp()
|
|
{}
|
|
|
|
void ObExprArithmaticTest::TearDown()
|
|
{}
|
|
|
|
#define LINE_BUF_SIZE 1024
|
|
TEST_F(ObExprArithmaticTest, arithmatic_test)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObMalloc buf;
|
|
// here we begin
|
|
const char* test_file = "./arithmatic.test";
|
|
const char* out_file = "./arithmatic.out";
|
|
// line buffer, we need to adjust the input string so make copy
|
|
char line_buf[LINE_BUF_SIZE] = {0};
|
|
// run tests
|
|
std::ifstream if_tests(test_file);
|
|
ASSERT_TRUE(if_tests.is_open());
|
|
std::ofstream of_output(out_file);
|
|
ASSERT_TRUE(of_output.is_open());
|
|
std::string line;
|
|
|
|
int64_t column_count = 0;
|
|
int64_t case_count = 0;
|
|
int64_t failed_count = 0;
|
|
bool is_succ = false;
|
|
char* saved_strtok_pos = NULL;
|
|
char* token_start = NULL;
|
|
bool line_valid = true;
|
|
bool line_finished = false;
|
|
bool is_expect_overflow = false;
|
|
bool wrong_type = false;
|
|
EXPR_TYPE expr_type = NOT_SUPPORTED;
|
|
ObObjType opnd1_type = ObMaxType;
|
|
ObObjType opnd2_type = ObMaxType;
|
|
ObObjType res_expect_type = ObMaxType;
|
|
ObObj opnd1_obj;
|
|
ObObj opnd2_obj;
|
|
ObObj res_calc_obj;
|
|
ObObj res_obj;
|
|
ObObj res_check;
|
|
|
|
of_output << "Failed cases:" << std::endl;
|
|
// do not check ret, because we want to run all the test and see which ones fail
|
|
// also, reset ret each loop
|
|
while (std::getline(if_tests, line)) {
|
|
if (line.size() <= 0 // skip invalid/comment lines
|
|
|| '#' == line.at(0) || 'v' == line.at(0)) {
|
|
continue;
|
|
}
|
|
ret = OB_SUCCESS;
|
|
++case_count;
|
|
strncpy(line_buf, line.c_str(), LINE_BUF_SIZE);
|
|
line_buf[LINE_BUF_SIZE - 1] = '\0'; // we are safe to call strtok_r
|
|
line_valid = true;
|
|
line_finished = false;
|
|
is_expect_overflow = false;
|
|
wrong_type = false;
|
|
is_succ = false;
|
|
column_count = 0;
|
|
// start to parse a line
|
|
if (NULL == (token_start = strtok_r(line_buf, "|", &saved_strtok_pos))) {
|
|
_OB_LOG(WARN, "invalid line format found. %s", line_buf);
|
|
line_valid = false;
|
|
} else {
|
|
++column_count;
|
|
while ((column_count <= 7) && (line_valid) && (!line_finished)) {
|
|
switch (column_count) {
|
|
case 1: {
|
|
expr_type = NOT_SUPPORTED;
|
|
// strtok_r always return null terminated string, safe to call strlen
|
|
if (NOT_SUPPORTED == (ret = get_expr_type_from_str(token_start, strlen(token_start), expr_type))) {
|
|
_OB_LOG(WARN, "Not supported operator type found. %s", token_start);
|
|
line_valid = false;
|
|
}
|
|
break;
|
|
}
|
|
case 2: {
|
|
opnd1_type = ObMaxType;
|
|
if (OB_HASH_NOT_EXIST == (ret = lookup_type_from_str(OB, token_start, strlen(token_start), opnd1_type))) {
|
|
_OB_LOG(WARN, "Not supported left operand type found. %s", token_start);
|
|
line_valid = false;
|
|
}
|
|
break;
|
|
}
|
|
case 3: {
|
|
opnd2_type = ObMaxType;
|
|
if (OB_HASH_NOT_EXIST == (ret = lookup_type_from_str(OB, token_start, strlen(token_start), opnd2_type))) {
|
|
_OB_LOG(WARN, "Not supported right operand type found. %s", token_start);
|
|
line_valid = false;
|
|
}
|
|
break;
|
|
}
|
|
case 4: {
|
|
res_expect_type = ObMaxType;
|
|
if (OB_HASH_NOT_EXIST == (ret = get_res_type_from_str(token_start, strlen(token_start), res_expect_type))) {
|
|
_OB_LOG(WARN, "Not supported result type found. %s", token_start);
|
|
line_valid = false;
|
|
}
|
|
break;
|
|
}
|
|
case 5: {
|
|
if (OB_SUCCESS !=
|
|
(ret = build_obj_from_str(token_start, strlen(token_start), opnd1_type, opnd1_obj, buf))) {
|
|
_OB_LOG(WARN, "left operand format error");
|
|
line_valid = false;
|
|
}
|
|
break;
|
|
}
|
|
case 6: {
|
|
if (OB_SUCCESS !=
|
|
(ret = build_obj_from_str(token_start, strlen(token_start), opnd2_type, opnd2_obj, buf))) {
|
|
_OB_LOG(WARN, "right operand format error");
|
|
line_valid = false;
|
|
}
|
|
break;
|
|
}
|
|
case 7: {
|
|
if (!(is_expect_overflow = (0 == strncmp("overflow", token_start, strlen(token_start))))) {
|
|
if (OB_SUCCESS !=
|
|
(ret = build_obj_from_str(token_start, strlen(token_start), res_expect_type, res_obj, buf))) {
|
|
_OB_LOG(WARN, "result format error");
|
|
line_valid = false;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
_OB_LOG(WARN, "wrong column count %s", line.c_str());
|
|
line_valid = false;
|
|
break;
|
|
}
|
|
}
|
|
if (NULL == (token_start = strtok_r(NULL, "|", &saved_strtok_pos))) {
|
|
if (7 == column_count) {
|
|
line_finished = true;
|
|
} else {
|
|
_OB_LOG(WARN, "wrong column count %s", line.c_str());
|
|
line_valid = false;
|
|
}
|
|
}
|
|
++column_count;
|
|
}
|
|
}
|
|
// do specified calculation
|
|
if (OB_SUCCESS == ret && line_valid) {
|
|
if (NOT_SUPPORTED == expr_type) {
|
|
OB_ASSERT(false); // NOT_SUPPORTED should have been excluded in parsing
|
|
} else {
|
|
ObExprCtx expr_ctx(NULL, NULL, NULL, &buf);
|
|
if (OB_SUCCESS != (ret = operators[expr_type]->calc_result2(res_calc_obj, opnd1_obj, opnd2_obj, expr_ctx))) {
|
|
if (is_expect_overflow && OB_DATA_OUT_OF_RANGE == ret) {
|
|
ret = OB_SUCCESS; // overflow is what we expect, so recover
|
|
is_succ = true;
|
|
} else {
|
|
_OB_LOG(WARN, "calc failed %s", line.c_str());
|
|
is_succ = false;
|
|
}
|
|
} else { // ret is success
|
|
if (is_expect_overflow) {
|
|
is_succ = false; // we want overflow
|
|
} else { // expect is not overflow, and ret == success, do the check
|
|
// hack: truncate number scale to 4, follow mysql div default
|
|
if (OB_SUCCESS == ret && (ObNumberType == res_expect_type || ObUNumberType == res_expect_type)) {
|
|
number::ObNumber num;
|
|
number::ObNumber num_trunc;
|
|
if (ObNumberType == res_calc_obj.get_type()) {
|
|
if (OB_SUCCESS != (ret = res_calc_obj.get_number(num))) {
|
|
_OB_LOG(WARN, "get number failed");
|
|
}
|
|
} else if (ObUNumberType == res_calc_obj.get_type()) {
|
|
if (OB_SUCCESS != (ret = res_calc_obj.get_unumber(num))) {
|
|
_OB_LOG(WARN, "get unumber failed");
|
|
}
|
|
} else if (!res_calc_obj.is_null()) {
|
|
wrong_type = true;
|
|
}
|
|
|
|
if (!wrong_type) {
|
|
if (OB_SUCCESS != (truncate_number_precision(num, num_trunc, 4, buf))) {
|
|
_OB_LOG(WARN, "truncate number failed");
|
|
} else if (ObNumberType == res_calc_obj.get_type()) {
|
|
res_calc_obj.set_number(num_trunc);
|
|
} else if (ObUNumberType == res_calc_obj.get_type()) {
|
|
res_calc_obj.set_unumber(num_trunc);
|
|
}
|
|
}
|
|
}
|
|
// end hack
|
|
// type check. Only check typeclass
|
|
if (OB_SUCCESS == ret && (ob_obj_type_class(res_expect_type) != res_calc_obj.get_type_class()) &&
|
|
!res_calc_obj.is_null()) {
|
|
wrong_type = true;
|
|
}
|
|
if (OB_SUCCESS == ret && !wrong_type) {
|
|
if (type_need_fuzzy_cmp(opnd1_type, opnd2_type)) {
|
|
// res must be double type
|
|
double res = res_obj.get_double();
|
|
double res_calc = res_calc_obj.get_double();
|
|
if (0 == double_cmp_given_precision(res, res_calc, 5)) {
|
|
is_succ = true;
|
|
} else {
|
|
is_succ = false;
|
|
}
|
|
} else {
|
|
is_succ = ObObjCmpFuncs::compare_oper_nullsafe(res_obj, res_calc_obj, CS_TYPE_UTF8MB4_BIN, CO_EQ);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!is_succ) {
|
|
++failed_count;
|
|
of_output << line << std::endl << "# calculated:" << to_cstring(res_calc_obj) << std::endl;
|
|
}
|
|
}
|
|
}
|
|
of_output << "Total\t" << case_count << " cases." << std::endl;
|
|
of_output << "Failed\t" << failed_count << " cases." << std::endl;
|
|
of_output.close();
|
|
if_tests.close();
|
|
// EXPECT_TRUE(0 == failed_count);
|
|
}
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
::testing::InitGoogleTest(&argc, argv);
|
|
return RUN_ALL_TESTS();
|
|
}
|