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

211
src/sql/parser/parse_malloc.cpp
View File

@ -18,29 +18,57 @@
#include "sql/parser/parse_define.h"
#include "sql/parser/parser_proxy_func.h"
// get memory from the thread obStringBuf, and not release untill thread quits
void* parse_malloc(const size_t nbyte, void* malloc_pool)
void *malloc_parentheses_info(const size_t nbyte, void *malloc_pool)
{
void* ptr = NULL;
size_t headlen = sizeof(int64_t);
void *ptr = NULL;
if (OB_ISNULL(malloc_pool)) {
} else if (OB_UNLIKELY(nbyte <= 0)) {
} else {
if (OB_UNLIKELY(NULL == (ptr = parser_alloc_buffer(malloc_pool, headlen + nbyte)))) {
if (OB_UNLIKELY(NULL == (ptr = parser_alloc_buffer(malloc_pool, nbyte)))) {
} else {
*(static_cast<int64_t*>(ptr)) = nbyte;
ptr = static_cast<char*>(ptr) + headlen;
MEMSET(ptr, 0, nbyte);
}
}
return ptr;
}
/* ptr must point to a memory allocated by parse_malloc.cpp */
void* parse_realloc(void* ptr, size_t nbyte, void* malloc_pool)
// get memory from the thread obStringBuf, and not release untill thread quits
void *parse_malloc(const size_t nbyte, void *malloc_pool)
{
void* new_ptr = NULL;
// need not to check nbyte
void *ptr = NULL;
size_t headlen = sizeof(int64_t);
if (OB_ISNULL(malloc_pool)) {
} else if (OB_UNLIKELY(nbyte <= 0)) {
} else {
if (OB_UNLIKELY(NULL == (ptr = parser_alloc_buffer(malloc_pool, headlen + nbyte)))) {
} else {
*(static_cast<int64_t *>(ptr)) = nbyte;
ptr = static_cast<char *>(ptr) + headlen;
MEMSET(ptr, 0, nbyte);
}
}
return ptr;
}
void *parser_alloc(void *malloc_pool, const int64_t alloc_size)
{
void *ptr = NULL;
if (OB_ISNULL(malloc_pool)) {
} else {
if (OB_UNLIKELY(NULL == (ptr = parser_alloc_buffer(malloc_pool, alloc_size)))) {
} else {
MEMSET(ptr, 0, alloc_size);
}
}
return ptr;
}
/* ptr must point to a memory allocated by parse_malloc.cpp */
void *parse_realloc(void *ptr, size_t nbyte, void *malloc_pool)
{
void *new_ptr = NULL;
//need not to check nbyte
if (OB_ISNULL(malloc_pool)) {
} else {
if (OB_UNLIKELY(NULL == ptr)) {
@ -49,24 +77,24 @@ void* parse_realloc(void* ptr, size_t nbyte, void* malloc_pool)
size_t headlen = sizeof(int64_t);
if (OB_UNLIKELY(NULL == (new_ptr = parser_alloc_buffer(malloc_pool, headlen + nbyte)))) {
} else {
int64_t obyte = *(reinterpret_cast<int64_t*>(static_cast<char*>(ptr) - headlen));
*(static_cast<int64_t*>(new_ptr)) = nbyte;
new_ptr = static_cast<char*>(new_ptr) + headlen;
int64_t obyte = *(reinterpret_cast<int64_t *>(static_cast<char *>(ptr) - headlen));
*(static_cast<int64_t *>(new_ptr)) = nbyte;
new_ptr = static_cast<char *>(new_ptr) + headlen;
MEMMOVE(new_ptr, ptr, static_cast<int64_t>(nbyte) > obyte ? obyte : nbyte);
parser_free_buffer(malloc_pool, static_cast<char*>(ptr) - headlen);
parser_free_buffer(malloc_pool, static_cast<char *>(ptr) - headlen);
}
}
}
return new_ptr;
}
char* parse_strndup(const char* str, size_t nbyte, void* malloc_pool)
char *parse_strndup(const char *str, size_t nbyte, void *malloc_pool)
{
char* new_str = NULL;
// need not to check nbyte
char *new_str = NULL;
//need not to check nbyte
if (OB_ISNULL(str)) {
} else {
if (OB_LIKELY(NULL != (new_str = static_cast<char*>(parse_malloc(nbyte + 1, malloc_pool))))) {
if (OB_LIKELY(NULL != (new_str = static_cast<char *>(parse_malloc(nbyte + 1, malloc_pool))))) {
MEMMOVE(new_str, str, nbyte);
new_str[nbyte] = '\0';
} else {
@ -75,9 +103,9 @@ char* parse_strndup(const char* str, size_t nbyte, void* malloc_pool)
return new_str;
}
char* parse_strdup(const char* str, void* malloc_pool, int64_t* out_len)
char *parse_strdup(const char *str, void *malloc_pool, int64_t *out_len)
{
char* out_str = NULL;
char *out_str = NULL;
if (OB_ISNULL(str)) {
} else if (OB_ISNULL(out_len)) {
} else {
@ -88,18 +116,20 @@ char* parse_strdup(const char* str, void* malloc_pool, int64_t* out_len)
return out_str;
}
char* parse_str_convert_utf8(
const struct ObCharsetInfo* src_cs, const char* str, void* malloc_pool, int64_t* out_len, int* extra_errno)
char *parse_str_convert_utf8(const struct ObCharsetInfo* src_cs, const char *str, void *malloc_pool, int64_t *out_len, int *extra_errno)
{
char* out_str = NULL;
if (OB_ISNULL(str) || OB_ISNULL(out_len) || OB_ISNULL(extra_errno)) {
char *out_str = NULL;
if (OB_ISNULL(str)
|| OB_ISNULL(out_len)
|| OB_ISNULL(extra_errno)) {
} else {
uint errors;
uint errors = 0;
size_t str_len = STRLEN(str);
size_t dst_len = str_len * 4;
if (OB_ISNULL(out_str = static_cast<char*>(parse_malloc(dst_len + 1, malloc_pool)))) {
if (OB_ISNULL(out_str = static_cast<char *>(parse_malloc(dst_len + 1, malloc_pool)))) {
} else {
*out_len = ob_convert(out_str, dst_len, &ob_charset_utf8mb4_general_ci, str, str_len, src_cs, &errors);
*out_len = static_cast<int64_t>(
ob_convert(out_str, dst_len, &ob_charset_utf8mb4_general_ci, str, str_len, src_cs, false, '?', &errors));
out_str[*out_len] = '\0';
if (0 != errors) {
*extra_errno = OB_PARSER_ERR_ILLEGAL_NAME;
@ -109,14 +139,14 @@ char* parse_str_convert_utf8(
return out_str;
}
char* strndup_with_prefix(const char* prefix, const char* str, size_t nbyte, void* malloc_pool)
char *strndup_with_prefix(const char *prefix, const char *str, size_t nbyte, void *malloc_pool)
{
char* new_str = NULL;
char *new_str = NULL;
size_t prefix_len = strlen(prefix);
// need not to check nbyte
//need not to check nbyte
if (OB_ISNULL(str)) {
} else {
if (OB_LIKELY(NULL != (new_str = static_cast<char*>(parse_malloc(nbyte + prefix_len, malloc_pool))))) {
if (OB_LIKELY(NULL != (new_str = static_cast<char *>(parse_malloc(nbyte + prefix_len, malloc_pool))))) {
MEMMOVE(new_str, prefix, prefix_len);
MEMMOVE(new_str + prefix_len, str, nbyte);
} else {
@ -126,16 +156,16 @@ char* strndup_with_prefix(const char* prefix, const char* str, size_t nbyte, voi
return new_str;
}
char* strndup_with_prefix_and_postfix(
const char* prefix, const char* postfix, const char* str, size_t nbyte, void* malloc_pool)
char *strndup_with_prefix_and_postfix(const char *prefix,
const char *postfix, const char* str, size_t nbyte, void *malloc_pool)
{
char* new_str = NULL;
char *new_str = NULL;
size_t prefix_len = strlen(prefix);
size_t postfix_len = strlen(postfix);
if (OB_ISNULL(str)) {
} else {
if (OB_LIKELY(
NULL != (new_str = static_cast<char*>(parse_malloc(nbyte + prefix_len + postfix_len, malloc_pool))))) {
if (OB_LIKELY(NULL != (new_str = static_cast<char *>(parse_malloc(
nbyte + prefix_len + postfix_len, malloc_pool))))) {
MEMMOVE(new_str, prefix, prefix_len);
MEMMOVE(new_str + prefix_len, str, nbyte);
MEMMOVE(new_str + prefix_len + nbyte, postfix, postfix_len);
@ -145,21 +175,120 @@ char* strndup_with_prefix_and_postfix(
return new_str;
}
void parse_free(void* ptr)
void parse_free(void *ptr)
{
UNUSED(ptr);
/* do nothing, we don't really free the memory */
}
char* cp_str_value(const char* src, const size_t nbyte, void* malloc_pool)
char *cp_str_value(const char *src, const size_t nbyte, void *malloc_pool)
{
char* new_str = NULL;
char *new_str = NULL;
if (OB_ISNULL(src)) {
} else {
if (OB_LIKELY(NULL != (new_str = static_cast<char*>(parse_malloc(nbyte, malloc_pool))))) {
if (OB_LIKELY(NULL != (new_str = static_cast<char *>(parse_malloc(nbyte, malloc_pool))))) {
MEMCPY(new_str, src, nbyte);
} else {
}
}
return new_str;
}
char *parse_strdup_with_replace_multi_byte_char(const char *str, int *connection_collation_,
void *malloc_pool, int64_t *out_len)
{
char *out_str = NULL;
if (OB_ISNULL(str) || OB_ISNULL(connection_collation_) || OB_ISNULL(out_len)) {
} else if (OB_LIKELY(NULL != (out_str = static_cast<char *>(parse_malloc(strlen(str) + 1,
malloc_pool))))) {
int64_t len = 0;
int64_t dup_len = strlen(str);
for (int64_t i = 0; i < dup_len; ++i) {
switch (*connection_collation_) {
case 28/*CS_TYPE_GBK_CHINESE_CI*/:
case 87/*CS_TYPE_GBK_BIN*/:
case 248/*CS_TYPE_GB18030_CHINESE_CI*/:
case 249/*CS_TYPE_GB18030_BIN*/: {
if (i + 1 < dup_len) {
if (str[i] == (char)0xa1 && str[i+1] == (char)0xa1) {//gbk multi byte space
out_str[len++] = ' ';
++i;
} else if (str[i] == (char)0xa3 && str[i+1] == (char)0xa8) {
//gbk multi byte left parenthesis
out_str[len++] = '(';
++i;
} else if (str[i] == (char)0xa3 && str[i+1] == (char)0xa9) {
//gbk multi byte right parenthesis
out_str[len++] = ')';
++i;
} else {
out_str[len++] = str[i];
}
} else {
out_str[len++] = str[i];
}
break;
}
case 45/*CS_TYPE_UTF8MB4_GENERAL_CI*/:
case 46/*CS_TYPE_UTF8MB4_BIN*/:
case 63/*CS_TYPE_BINARY*/:
case 224/*CS_TYPE_UTF8MB4_UNICODE_CI*/: {
if (i + 2 < dup_len) {
if (str[i] == (char)0xe3 && str[i+1] == (char)0x80 && str[i+2] == (char)0x80) {
//utf8 multi byte space
out_str[len++] = ' ';
i = i + 2;
} else if (str[i] == (char)0xef && str[i+1] == (char)0xbc && str[i+2] == (char)0x88) {
//utf8 multi byte left parenthesis
out_str[len++] = '(';
i = i + 2;
} else if (str[i] == (char)0xef && str[i+1] == (char)0xbc && str[i+2] == (char)0x89) {
//utf8 multi byte right parenthesis
out_str[len++] = ')';
i = i + 2;
} else {
out_str[len++] = str[i];
}
} else {
out_str[len++] = str[i];
}
break;
}
default:
out_str[len++] = str[i];
}
}
if (len > 0) {
out_str[len] = '\0';
*out_len = len;
}
}
return out_str;
}
bool check_real_escape(const ObCharsetInfo *cs, char *str, int64_t str_len,
int64_t *last_well_formed_len)
{
bool is_real_escape = true;
if (NULL != cs && NULL != last_well_formed_len && cs->escape_with_backslash_is_dangerous) {
char *cur_pos = str + str_len;
char *last_check_pos = str + *last_well_formed_len;
int error = 0;
size_t expected_well_formed_len = cur_pos - last_check_pos;
size_t real_well_formed_len = cs->cset->well_formed_len(
cs, last_check_pos, cur_pos, UINT64_MAX, &error);
if (error != 0) {
*cur_pos = '\\';
if (real_well_formed_len == expected_well_formed_len - 1
&& cs->cset->ismbchar(cs, cur_pos - 1, cur_pos + 1)) {
is_real_escape = false;
*last_well_formed_len = str_len + 1;
} else {
*last_well_formed_len = str_len;
}
} else {
*last_well_formed_len = str_len;
}
}
return is_real_escape;
}