diff --git a/CMakeLists.txt b/CMakeLists.txt index 540863a8b..6c9cfaec3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -29,6 +29,7 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON) add_subdirectory(deps/easy) add_subdirectory(deps/oblib) add_subdirectory(src) +add_subdirectory(tools) include(CMakeDependentOption) # OB_BUILD_RPM => include tools and build them. diff --git a/src/share/gen_errno.pl b/src/share/gen_errno.pl index 50e14aa3b..6a811c919 100755 --- a/src/share/gen_errno.pl +++ b/src/share/gen_errno.pl @@ -20,16 +20,38 @@ my $def_ora_errno=600; my $def_ora_errmsg="\"internal error code, arguments: %d, %s\""; my $print_def_ora_errmsg="\"%s-%05d: internal error code, arguments: %d, %s\""; my $print_ora_errmsg="\"%s-%05d: %s\""; +my $print_error_cause="\"Internal Error\""; +my $print_error_solution="\"Contact OceanBase Support\""; + while(<$fh>) { my $error_msg; my $sqlstate; my $error_code; - if (/^DEFINE_ERROR\(([^,]+),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*("[^"]*")/) { + if (/^DEFINE_ERROR\(([^,]+),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*("[^"]*")/) { + ++$error_count; + #print "\"$1\", $1, $2, $3, $4, $5, $6, $7\n"; + my $tmp_ora_errmsg=sprintf($print_def_ora_errmsg, "ORA", $def_ora_errno, $2, substr($5, 1, length($5) - 2)); + $map{$1} = [$2, $3, $4, $5, $5, "$1", $def_ora_errno, $tmp_ora_errmsg, $tmp_ora_errmsg, $6, $7]; + $last_errno = $2 if ($2 < $last_errno); + $error_code = $2; + $sqlstate = $4; + $error_msg = $5; + } elsif (/^DEFINE_ERROR\(([^,]+),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*("[^"]*")/) { ++$error_count; #print "\"$1\", $1, $2, $3, $4, $5\n"; my $tmp_ora_errmsg=sprintf($print_def_ora_errmsg, "ORA", $def_ora_errno, $2, substr($5, 1, length($5) - 2)); - $map{$1} = [$2, $3, $4, $5, $5, "$1", $def_ora_errno, $tmp_ora_errmsg, $tmp_ora_errmsg]; + $map{$1} = [$2, $3, $4, $5, $5, "$1", $def_ora_errno, $tmp_ora_errmsg, $tmp_ora_errmsg, $print_error_cause, $print_error_solution]; + $last_errno = $2 if ($2 < $last_errno); + $error_code = $2; + $sqlstate = $4; + $error_msg = $5; + } elsif (/^DEFINE_ERROR_EXT\(([^,]+),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*("[^"]*")/) { + ++$error_count; + #print "\"$1\", $1, $2, $3, $4, $5, $6, $7, $8\n"; + my $tmp_ora_errmsg=sprintf($print_def_ora_errmsg, "ORA", $def_ora_errno, $2, substr($5, 1, length($5) - 2)); + my $tmp_ora_user_errmsg=sprintf($print_def_ora_errmsg, "ORA", $def_ora_errno, $2, substr($6, 1, length($6) - 2)); + $map{$1} = [$2, $3, $4, $5, $6, "$1", $def_ora_errno, $tmp_ora_errmsg, $tmp_ora_user_errmsg, $7, $8]; $last_errno = $2 if ($2 < $last_errno); $error_code = $2; $sqlstate = $4; @@ -39,7 +61,16 @@ while(<$fh>) { #print "\"$1\", $1, $2, $3, $4, $5, $6\n"; my $tmp_ora_errmsg=sprintf($print_def_ora_errmsg, "ORA", $def_ora_errno, $2, substr($5, 1, length($5) - 2)); my $tmp_ora_user_errmsg=sprintf($print_def_ora_errmsg, "ORA", $def_ora_errno, $2, substr($6, 1, length($6) - 2)); - $map{$1} = [$2, $3, $4, $5, $6, "$1", $def_ora_errno, $tmp_ora_errmsg, $tmp_ora_user_errmsg]; + $map{$1} = [$2, $3, $4, $5, $6, "$1", $def_ora_errno, $tmp_ora_errmsg, $tmp_ora_user_errmsg, $print_error_cause, $print_error_solution]; + $last_errno = $2 if ($2 < $last_errno); + $error_code = $2; + $sqlstate = $4; + $error_msg = $5; + } elsif (/^DEFINE_ORACLE_ERROR\(([^,]+),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*("[^"]*")\s*,\s*([^,]*),\s*("[^"]*")/) { + ++$error_count; + #print "\"$1\", $1, $2, $3, $4, $5, $6, $7, $8, $9\n"; + my $tmp_ora_errmsg=sprintf($print_ora_errmsg, "ORA", $6, substr($7, 1, length($7) - 2)); + $map{$1} = [$2, $3, $4, $5, $5, "$1", $6, $tmp_ora_errmsg, $tmp_ora_errmsg, $8, $9]; $last_errno = $2 if ($2 < $last_errno); $error_code = $2; $sqlstate = $4; @@ -49,7 +80,17 @@ while(<$fh>) { #print "\"$1\", $1, $2, $3, $4, $5, $6, $7\n"; #print "\"$1\", $6, $7\n"; my $tmp_ora_errmsg=sprintf($print_ora_errmsg, "ORA", $6, substr($7, 1, length($7) - 2)); - $map{$1} = [$2, $3, $4, $5, $5, "$1", $6, $tmp_ora_errmsg, $tmp_ora_errmsg]; + $map{$1} = [$2, $3, $4, $5, $5, "$1", $6, $tmp_ora_errmsg, $tmp_ora_errmsg, $print_error_cause, $print_error_solution]; + $last_errno = $2 if ($2 < $last_errno); + $error_code = $2; + $sqlstate = $4; + $error_msg = $5; + } elsif (/^DEFINE_ORACLE_ERROR_EXT\(([^,]+),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*("[^"]*")\s*,\s*("[^"]*")\s*,\s*([^,]*),\s*("[^"]*")\s*,\s*("[^"]*")/) { + ++$error_count; + #print "\"$1\", $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11\n"; + my $tmp_ora_errmsg=sprintf($print_ora_errmsg, "ORA", $7, substr($8, 1, length($8) - 2)); + my $tmp_ora_user_errmsg=sprintf($print_ora_errmsg, "ORA", $7, substr($9, 1, length($9) - 2)); + $map{$1} = [$2, $3, $4, $5, $6, "$1", $7, $tmp_ora_errmsg, $tmp_ora_user_errmsg, $10, $11]; $last_errno = $2 if ($2 < $last_errno); $error_code = $2; $sqlstate = $4; @@ -60,20 +101,36 @@ while(<$fh>) { #print "\"$1\", $7, $8, $9\n"; my $tmp_ora_errmsg=sprintf($print_ora_errmsg, "ORA", $7, substr($8, 1, length($8) - 2)); my $tmp_ora_user_errmsg=sprintf($print_ora_errmsg, "ORA", $7, substr($9, 1, length($9) - 2)); - $map{$1} = [$2, $3, $4, $5, $6, "$1", $7, $tmp_ora_errmsg, $tmp_ora_user_errmsg]; + $map{$1} = [$2, $3, $4, $5, $6, "$1", $7, $tmp_ora_errmsg, $tmp_ora_user_errmsg, $print_error_cause, $print_error_solution]; + $last_errno = $2 if ($2 < $last_errno); + $error_code = $2; + $sqlstate = $4; + $error_msg = $5; + } elsif (/^DEFINE_PLS_ERROR\(([^,]+),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*("[^"]*")\s*,\s*([^,]*),\s*("[^"]*")/) { + ++$error_count; + #print "\"$1\", $1, $2, $3, $4, $5, $6, $7, $8, $9\n"; + my $tmp_ora_errmsg=sprintf($print_ora_errmsg, "PLS", $6, substr($7, 1, length($7) - 2)); + $map{$1} = [$2, $3, $4, $5, $5, "$1", $6, $tmp_ora_errmsg, $tmp_ora_errmsg, $8, $9]; $last_errno = $2 if ($2 < $last_errno); $error_code = $2; $sqlstate = $4; $error_msg = $5; - } elsif (/^DEFINE_OTHER_MSG_FMT\(([^,]+),\s*([^,]*),\s*("[^"]*")\s*,\s*("[^"]*")/) { - #print "\"$1\", $1, $2, $3, $4\n"; - $other_map{$1} = [$2, $3, $4]; } elsif (/^DEFINE_PLS_ERROR\(([^,]+),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*("[^"]*")\s*,\s*([^,]*),\s*("[^"]*")/) { ++$error_count; #print "\"$1\", $1, $2, $3, $4, $5, $6, $7\n"; #print "\"$1\", $6, $7\n"; my $tmp_ora_errmsg=sprintf($print_ora_errmsg, "PLS", $6, substr($7, 1, length($7) - 2)); - $map{$1} = [$2, $3, $4, $5, $5, "$1", $6, $tmp_ora_errmsg, $tmp_ora_errmsg]; + $map{$1} = [$2, $3, $4, $5, $5, "$1", $6, $tmp_ora_errmsg, $tmp_ora_errmsg, $print_error_cause, $print_error_solution]; + $last_errno = $2 if ($2 < $last_errno); + $error_code = $2; + $sqlstate = $4; + $error_msg = $5; + } elsif (/^DEFINE_PLS_ERROR_EXT\(([^,]+),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*("[^"]*")\s*,\s*("[^"]*")\s*,\s*([^,]*),\s*("[^"]*")\s*,\s*("[^"]*")/) { + ++$error_count; + #print "\"$1\", $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11\n"; + my $tmp_ora_errmsg=sprintf($print_ora_errmsg, "PLS", $7, substr($8, 1, length($8) - 2)); + my $tmp_ora_user_errmsg=sprintf($print_ora_errmsg, "PLS", $7, substr($9, 1, length($9) - 2)); + $map{$1} = [$2, $3, $4, $5, $6, "$1", $7, $tmp_ora_errmsg, $tmp_ora_user_errmsg, $10, $11]; $last_errno = $2 if ($2 < $last_errno); $error_code = $2; $sqlstate = $4; @@ -84,18 +141,21 @@ while(<$fh>) { #print "\"$1\", $7, $8, $9\n"; my $tmp_ora_errmsg=sprintf($print_ora_errmsg, "PLS", $7, substr($8, 1, length($8) - 2)); my $tmp_ora_user_errmsg=sprintf($print_ora_errmsg, "PLS", $7, substr($9, 1, length($9) - 2)); - $map{$1} = [$2, $3, $4, $5, $6, "$1", $7, $tmp_ora_errmsg, $tmp_ora_user_errmsg]; + $map{$1} = [$2, $3, $4, $5, $6, "$1", $7, $tmp_ora_errmsg, $tmp_ora_user_errmsg, $print_error_cause, $print_error_solution]; $last_errno = $2 if ($2 < $last_errno); $error_code = $2; $sqlstate = $4; $error_msg = $5; + } elsif (/^DEFINE_OTHER_MSG_FMT\(([^,]+),\s*([^,]*),\s*("[^"]*")\s*,\s*("[^"]*")/) { + #print "\"$1\", $1, $2, $3, $4\n"; + $other_map{$1} = [$2, $3, $4]; } elsif (/^DEFINE_ORACLE_ERROR_V2_EXT\(([^,]+),\s*([^,]*),\s*([^,]*),\s*([^,]*),\s*("[^"]*")\s*,\s*("[^"]*")\s*,\s*([^,]*),\s*("[^"]*")\s*,\s*("[^"]*")/) { ++$error_count; #print "\"$1\", $1, $2, $3, $4, $5, $6, $7, $8, $9\n"; #print "\"$1\", $7, $8, $9\n"; my $tmp_ora_errmsg=sprintf("\"%s\"", substr($8, 1, length($8) - 2)); my $tmp_ora_user_errmsg=sprintf("\"%s\"", substr($9, 1, length($9) - 2)); - $map{$1} = [$2, $3, $4, $5, $6, "$1", $7, $tmp_ora_errmsg, $tmp_ora_user_errmsg]; + $map{$1} = [$2, $3, $4, $5, $6, "$1", $7, $tmp_ora_errmsg, $tmp_ora_user_errmsg, $print_error_cause, $print_error_solution]; $last_errno = $2 if ($2 < $last_errno); $error_code = $2; $sqlstate = $4; @@ -149,11 +209,8 @@ print $fh_header '/** #include "share/mysql_errno.h" #include "lib/ob_errno.h" -namespace oceanbase -{ -namespace common -{ -using namespace ::oblib; +namespace oceanbase { +namespace common { '; print $fh_header " constexpr int OB_LAST_ERROR_CODE = $last_errno; @@ -203,6 +260,9 @@ constexpr int OB_ERR_SQL_END = -5999; print $fh_header ' const char *ob_error_name(const int oberr); + const char* ob_error_cause(const int oberr); + const char* ob_error_solution(const int oberr); + int ob_mysql_errno(const int oberr); int ob_mysql_errno_with_check(const int oberr); const char *ob_sqlstate(const int oberr); @@ -218,7 +278,6 @@ constexpr int OB_ERR_SQL_END = -5999; const char *ob_errpkt_strerror(const int oberr, const bool is_oracle_mode); const char *ob_errpkt_str_user_error(const int oberr, const bool is_oracle_mode); - } // end namespace common } // end namespace oceanbase @@ -238,13 +297,24 @@ print $fh_cpp '/** * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. * See the Mulan PubL v2 for more details. */ + // DO NOT EDIT. This file is automatically generated from `ob_errno.def\'. #include "ob_errno.h" +#ifndef __ERROR_CODE_PARSER_ #include "ob_define.h" +#else +#define OB_LIKELY +#define OB_UNLIKELY +#define NULL 0 +#include +#endif using namespace oceanbase::common; static const char *ERROR_NAME[OB_MAX_ERROR_CODE]; +static const char *ERROR_CAUSE[OB_MAX_ERROR_CODE]; +static const char *ERROR_SOLUTION[OB_MAX_ERROR_CODE]; + static int MYSQL_ERRNO[OB_MAX_ERROR_CODE]; static const char *SQLSTATE[OB_MAX_ERROR_CODE]; static const char *STR_ERROR[OB_MAX_ERROR_CODE]; @@ -259,6 +329,9 @@ static struct ObStrErrorInit ObStrErrorInit() { memset(ERROR_NAME, 0, sizeof(ERROR_NAME)); + memset(ERROR_CAUSE, 0, sizeof(ERROR_CAUSE)); + memset(ERROR_SOLUTION, 0, sizeof(ERROR_SOLUTION)); + memset(MYSQL_ERRNO, 0, sizeof(MYSQL_ERRNO)); memset(SQLSTATE, 0, sizeof(SQLSTATE)); memset(STR_ERROR, 0, sizeof(STR_ERROR)); @@ -272,6 +345,8 @@ static struct ObStrErrorInit for my $oberr (@errors) { if (0 > $map{$oberr}->[0]) { print $fh_cpp " ERROR_NAME[-$oberr] = \"$map{$oberr}->[5]\";\n"; + print $fh_cpp " ERROR_CAUSE[-$oberr] = $map{$oberr}->[9];\n"; + print $fh_cpp " ERROR_SOLUTION[-$oberr] = $map{$oberr}->[10];\n"; print $fh_cpp " MYSQL_ERRNO[-$oberr] = $map{$oberr}->[1];\n"; print $fh_cpp " SQLSTATE[-$oberr] = $map{$oberr}->[2];\n"; print $fh_cpp " STR_ERROR[-$oberr] = $map{$oberr}->[3];\n"; @@ -286,132 +361,158 @@ static struct ObStrErrorInit } } local_init; -namespace oceanbase +namespace oceanbase { +namespace common { +const char *ob_error_name(const int err) { -namespace common -{ - const char *ob_error_name(const int err) - { - const char *ret = "Unknown error"; - if (OB_UNLIKELY(0 == err)) { - ret = "OB_SUCCESS"; - } else if (OB_LIKELY(0 > err && err > -OB_MAX_ERROR_CODE)) { - ret = ERROR_NAME[-err]; - if (OB_UNLIKELY(NULL == ret || \'\0\' == ret[0])) - { - ret = "Unknown Error"; - } + const char *ret = "Unknown error"; + if (OB_UNLIKELY(0 == err)) { + ret = "OB_SUCCESS"; + } else if (OB_LIKELY(0 > err && err > -OB_MAX_ERROR_CODE)) { + ret = ERROR_NAME[-err]; + if (OB_UNLIKELY(NULL == ret || \'\0\' == ret[0])) + { + ret = "Unknown Error"; } - return ret; } + return ret; +} +const char *ob_error_cause(const int err) +{ + const char *ret = "Internal Error"; + if (OB_UNLIKELY(0 == err)) { + ret = "Not an Error"; + } else if (OB_LIKELY(0 > err && err > -OB_MAX_ERROR_CODE)) { + ret = ERROR_CAUSE[-err]; + if (OB_UNLIKELY(NULL == ret || \'\0\' == ret[0])) + { + ret = "Internal Error"; + } + } + return ret; +} +const char *ob_error_solution(const int err) +{ + const char *ret = "Contact OceanBase Support"; + if (OB_UNLIKELY(0 == err)) { + ret = "Contact OceanBase Support"; + } else if (OB_LIKELY(0 > err && err > -OB_MAX_ERROR_CODE)) { + ret = ERROR_SOLUTION[-err]; + if (OB_UNLIKELY(NULL == ret || \'\0\' == ret[0])) + { + ret = "Contact OceanBase Support"; + } + } + return ret; +} - const char *ob_strerror(const int err) - { - const char *ret = "Unknown error"; - if (OB_LIKELY(0 >= err && err > -OB_MAX_ERROR_CODE)) { - ret = STR_ERROR[-err]; - if (OB_UNLIKELY(NULL == ret || \'\0\' == ret[0])) - { - ret = "Unknown Error"; - } +const char *ob_strerror(const int err) +{ + const char *ret = "Unknown error"; + if (OB_LIKELY(0 >= err && err > -OB_MAX_ERROR_CODE)) { + ret = STR_ERROR[-err]; + if (OB_UNLIKELY(NULL == ret || \'\0\' == ret[0])) + { + ret = "Unknown Error"; } - return ret; } - const char *ob_str_user_error(const int err) - { - const char *ret = NULL; - if (OB_LIKELY(0 >= err && err > -OB_MAX_ERROR_CODE)) { - ret = STR_USER_ERROR[-err]; - if (OB_UNLIKELY(NULL == ret || \'\0\' == ret[0])) { - ret = NULL; - } + return ret; +} +const char *ob_str_user_error(const int err) +{ + const char *ret = NULL; + if (OB_LIKELY(0 >= err && err > -OB_MAX_ERROR_CODE)) { + ret = STR_USER_ERROR[-err]; + if (OB_UNLIKELY(NULL == ret || \'\0\' == ret[0])) { + ret = NULL; } - return ret; } - const char *ob_sqlstate(const int err) - { - const char *ret = "HY000"; - if (OB_LIKELY(0 >= err && err > -OB_MAX_ERROR_CODE)) { - ret = SQLSTATE[-err]; - if (OB_UNLIKELY(NULL == ret || \'\0\' == ret[0])) { - ret = "HY000"; - } + return ret; +} +const char *ob_sqlstate(const int err) +{ + const char *ret = "HY000"; + if (OB_LIKELY(0 >= err && err > -OB_MAX_ERROR_CODE)) { + ret = SQLSTATE[-err]; + if (OB_UNLIKELY(NULL == ret || \'\0\' == ret[0])) { + ret = "HY000"; } - return ret; } - int ob_mysql_errno(const int err) - { - int ret = -1; - if (OB_LIKELY(0 >= err && err > -OB_MAX_ERROR_CODE)) { - ret = MYSQL_ERRNO[-err]; + return ret; +} +int ob_mysql_errno(const int err) +{ + int ret = -1; + if (OB_LIKELY(0 >= err && err > -OB_MAX_ERROR_CODE)) { + ret = MYSQL_ERRNO[-err]; + } + return ret; +} +int ob_mysql_errno_with_check(const int err) +{ + int ret = ob_mysql_errno(err); + if (ret < 0) { + ret = -err; + } + return ret; +} +const char *ob_oracle_strerror(const int err) +{ + const char *ret = "Unknown error"; + if (OB_LIKELY(0 >= err && err > -OB_MAX_ERROR_CODE)) { + ret = ORACLE_STR_ERROR[-err]; + if (OB_UNLIKELY(NULL == ret || \'\0\' == ret[0])) + { + ret = "Unknown Error"; } - return ret; } - int ob_mysql_errno_with_check(const int err) - { - int ret = ob_mysql_errno(err); - if (ret < 0) { - ret = -err; + return ret; +} +const char *ob_oracle_str_user_error(const int err) +{ + const char *ret = NULL; + if (OB_LIKELY(0 >= err && err > -OB_MAX_ERROR_CODE)) { + ret = ORACLE_STR_USER_ERROR[-err]; + if (OB_UNLIKELY(NULL == ret || \'\0\' == ret[0])) { + ret = NULL; } - return ret; } - const char *ob_oracle_strerror(const int err) - { - const char *ret = "Unknown error"; - if (OB_LIKELY(0 >= err && err > -OB_MAX_ERROR_CODE)) { - ret = ORACLE_STR_ERROR[-err]; - if (OB_UNLIKELY(NULL == ret || \'\0\' == ret[0])) - { - ret = "Unknown Error"; - } - } - return ret; + return ret; +} +int ob_oracle_errno(const int err) +{ + int ret = -1; + if (OB_ERR_PROXY_REROUTE == err) { + // Oracle Mode and MySQL mode should return same errcode for reroute sql + // thus we make the specialization here + ret = -1; + } else if (err >= OB_MIN_RAISE_APPLICATION_ERROR && err <= OB_MAX_RAISE_APPLICATION_ERROR) { + ret = err; // PL/SQL Raise Application Error + } else if (OB_LIKELY(0 >= err && err > -OB_MAX_ERROR_CODE)) { + ret = ORACLE_ERRNO[-err]; } - const char *ob_oracle_str_user_error(const int err) - { - const char *ret = NULL; - if (OB_LIKELY(0 >= err && err > -OB_MAX_ERROR_CODE)) { - ret = ORACLE_STR_USER_ERROR[-err]; - if (OB_UNLIKELY(NULL == ret || \'\0\' == ret[0])) { - ret = NULL; - } - } - return ret; - } - int ob_oracle_errno(const int err) - { - int ret = -1; - if (OB_ERR_PROXY_REROUTE == err) { - // Oracle Mode and MySQL mode should return same errcode for reroute sql - // thus we make the specialization here - ret = -1; - } else if (err >= OB_MIN_RAISE_APPLICATION_ERROR && err <= OB_MAX_RAISE_APPLICATION_ERROR) { - ret = err; // PL/SQL Raise Application Error - } else if (OB_LIKELY(0 >= err && err > -OB_MAX_ERROR_CODE)) { - ret = ORACLE_ERRNO[-err]; - } - return ret; - } - int ob_oracle_errno_with_check(const int err) - { - int ret = ob_oracle_errno(err); - if (ret < 0) { - ret = -err; - } - return ret; - } - int ob_errpkt_errno(const int err, const bool is_oracle_mode) - { - return (is_oracle_mode ? ob_oracle_errno_with_check(err) : ob_mysql_errno_with_check(err)); - } - const char *ob_errpkt_strerror(const int err, const bool is_oracle_mode) - { - return (is_oracle_mode ? ob_oracle_strerror(err) : ob_strerror(err)); - } - const char *ob_errpkt_str_user_error(const int err, const bool is_oracle_mode) - { - return (is_oracle_mode ? ob_oracle_str_user_error(err) : ob_str_user_error(err)); + return ret; +} +int ob_oracle_errno_with_check(const int err) +{ + int ret = ob_oracle_errno(err); + if (ret < 0) { + ret = -err; } + return ret; +} +int ob_errpkt_errno(const int err, const bool is_oracle_mode) +{ + return (is_oracle_mode ? ob_oracle_errno_with_check(err) : ob_mysql_errno_with_check(err)); +} +const char *ob_errpkt_strerror(const int err, const bool is_oracle_mode) +{ + return (is_oracle_mode ? ob_oracle_strerror(err) : ob_strerror(err)); +} +const char *ob_errpkt_str_user_error(const int err, const bool is_oracle_mode) +{ + return (is_oracle_mode ? ob_oracle_str_user_error(err) : ob_str_user_error(err)); +} } // end namespace common } // end namespace oceanbase diff --git a/src/share/ob_errno.cpp b/src/share/ob_errno.cpp index 8b4b00cc1..ed3f79e57 100644 --- a/src/share/ob_errno.cpp +++ b/src/share/ob_errno.cpp @@ -10,11 +10,23 @@ * See the Mulan PubL v2 for more details. */ +// DO NOT EDIT. This file is automatically generated from `ob_errno.def'. + #include "ob_errno.h" +#ifndef __ERROR_CODE_PARSER_ #include "ob_define.h" +#else +#define OB_LIKELY +#define OB_UNLIKELY +#define NULL 0 +#include +#endif using namespace oceanbase::common; static const char* ERROR_NAME[OB_MAX_ERROR_CODE]; +static const char* ERROR_CAUSE[OB_MAX_ERROR_CODE]; +static const char* ERROR_SOLUTION[OB_MAX_ERROR_CODE]; + static int MYSQL_ERRNO[OB_MAX_ERROR_CODE]; static const char* SQLSTATE[OB_MAX_ERROR_CODE]; static const char* STR_ERROR[OB_MAX_ERROR_CODE]; @@ -28,6 +40,9 @@ static struct ObStrErrorInit { ObStrErrorInit() { memset(ERROR_NAME, 0, sizeof(ERROR_NAME)); + memset(ERROR_CAUSE, 0, sizeof(ERROR_CAUSE)); + memset(ERROR_SOLUTION, 0, sizeof(ERROR_SOLUTION)); + memset(MYSQL_ERRNO, 0, sizeof(MYSQL_ERRNO)); memset(SQLSTATE, 0, sizeof(SQLSTATE)); memset(STR_ERROR, 0, sizeof(STR_ERROR)); @@ -38,6 +53,8 @@ static struct ObStrErrorInit { memset(ORACLE_STR_USER_ERROR, 0, sizeof(ORACLE_STR_USER_ERROR)); ERROR_NAME[-OB_ERROR] = "OB_ERROR"; + ERROR_CAUSE[-OB_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERROR] = -1; SQLSTATE[-OB_ERROR] = "HY000"; STR_ERROR[-OB_ERROR] = "Common error"; @@ -46,6 +63,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERROR] = "ORA-00600: internal error code, arguments: -4000, Common error"; ORACLE_STR_USER_ERROR[-OB_ERROR] = "ORA-00600: internal error code, arguments: -4000, Common error"; ERROR_NAME[-OB_OBJ_TYPE_ERROR] = "OB_OBJ_TYPE_ERROR"; + ERROR_CAUSE[-OB_OBJ_TYPE_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_OBJ_TYPE_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OBJ_TYPE_ERROR] = -1; SQLSTATE[-OB_OBJ_TYPE_ERROR] = "HY004"; STR_ERROR[-OB_OBJ_TYPE_ERROR] = "Object type error"; @@ -54,6 +73,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_OBJ_TYPE_ERROR] = "ORA-00600: internal error code, arguments: -4001, Object type error"; ORACLE_STR_USER_ERROR[-OB_OBJ_TYPE_ERROR] = "ORA-00600: internal error code, arguments: -4001, Object type error"; ERROR_NAME[-OB_INVALID_ARGUMENT] = "OB_INVALID_ARGUMENT"; + ERROR_CAUSE[-OB_INVALID_ARGUMENT] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_ARGUMENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_ARGUMENT] = ER_WRONG_ARGUMENTS; SQLSTATE[-OB_INVALID_ARGUMENT] = "HY000"; STR_ERROR[-OB_INVALID_ARGUMENT] = "Invalid argument"; @@ -63,6 +84,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_ARGUMENT] = "ORA-00600: internal error code, arguments: -4002, Incorrect arguments to %s"; ERROR_NAME[-OB_ARRAY_OUT_OF_RANGE] = "OB_ARRAY_OUT_OF_RANGE"; + ERROR_CAUSE[-OB_ARRAY_OUT_OF_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ARRAY_OUT_OF_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ARRAY_OUT_OF_RANGE] = -1; SQLSTATE[-OB_ARRAY_OUT_OF_RANGE] = "42000"; STR_ERROR[-OB_ARRAY_OUT_OF_RANGE] = "Array index out of range"; @@ -73,6 +96,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ARRAY_OUT_OF_RANGE] = "ORA-00600: internal error code, arguments: -4003, Array index out of range"; ERROR_NAME[-OB_SERVER_LISTEN_ERROR] = "OB_SERVER_LISTEN_ERROR"; + ERROR_CAUSE[-OB_SERVER_LISTEN_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_SERVER_LISTEN_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SERVER_LISTEN_ERROR] = -1; SQLSTATE[-OB_SERVER_LISTEN_ERROR] = "08S01"; STR_ERROR[-OB_SERVER_LISTEN_ERROR] = "Failed to listen to the port"; @@ -83,6 +108,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SERVER_LISTEN_ERROR] = "ORA-00600: internal error code, arguments: -4004, Failed to listen to the port"; ERROR_NAME[-OB_INIT_TWICE] = "OB_INIT_TWICE"; + ERROR_CAUSE[-OB_INIT_TWICE] = "Internal Error"; + ERROR_SOLUTION[-OB_INIT_TWICE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INIT_TWICE] = -1; SQLSTATE[-OB_INIT_TWICE] = "HY000"; STR_ERROR[-OB_INIT_TWICE] = "The object is initialized twice"; @@ -93,6 +120,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INIT_TWICE] = "ORA-00600: internal error code, arguments: -4005, The object is initialized twice"; ERROR_NAME[-OB_NOT_INIT] = "OB_NOT_INIT"; + ERROR_CAUSE[-OB_NOT_INIT] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_INIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_INIT] = -1; SQLSTATE[-OB_NOT_INIT] = "HY000"; STR_ERROR[-OB_NOT_INIT] = "The object is not initialized"; @@ -102,6 +131,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NOT_INIT] = "ORA-00600: internal error code, arguments: -4006, The object is not initialized"; ERROR_NAME[-OB_NOT_SUPPORTED] = "OB_NOT_SUPPORTED"; + ERROR_CAUSE[-OB_NOT_SUPPORTED] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_SUPPORTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_SUPPORTED] = ER_NOT_SUPPORTED_YET; SQLSTATE[-OB_NOT_SUPPORTED] = "0A000"; STR_ERROR[-OB_NOT_SUPPORTED] = "Not supported feature or function"; @@ -111,6 +142,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -4007, Not supported feature or function"; ORACLE_STR_USER_ERROR[-OB_NOT_SUPPORTED] = "ORA-00600: internal error code, arguments: -4007, %s not supported"; ERROR_NAME[-OB_ITER_END] = "OB_ITER_END"; + ERROR_CAUSE[-OB_ITER_END] = "Internal Error"; + ERROR_SOLUTION[-OB_ITER_END] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ITER_END] = -1; SQLSTATE[-OB_ITER_END] = "HY000"; STR_ERROR[-OB_ITER_END] = "End of iteration"; @@ -119,6 +152,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ITER_END] = "ORA-00600: internal error code, arguments: -4008, End of iteration"; ORACLE_STR_USER_ERROR[-OB_ITER_END] = "ORA-00600: internal error code, arguments: -4008, End of iteration"; ERROR_NAME[-OB_IO_ERROR] = "OB_IO_ERROR"; + ERROR_CAUSE[-OB_IO_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_IO_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_IO_ERROR] = -1; SQLSTATE[-OB_IO_ERROR] = "58030"; STR_ERROR[-OB_IO_ERROR] = "IO error"; @@ -127,6 +162,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_IO_ERROR] = "ORA-00600: internal error code, arguments: -4009, IO error"; ORACLE_STR_USER_ERROR[-OB_IO_ERROR] = "ORA-00600: internal error code, arguments: -4009, IO error"; ERROR_NAME[-OB_ERROR_FUNC_VERSION] = "OB_ERROR_FUNC_VERSION"; + ERROR_CAUSE[-OB_ERROR_FUNC_VERSION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERROR_FUNC_VERSION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERROR_FUNC_VERSION] = -1; SQLSTATE[-OB_ERROR_FUNC_VERSION] = "HY000"; STR_ERROR[-OB_ERROR_FUNC_VERSION] = "Wrong RPC command version"; @@ -137,6 +174,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERROR_FUNC_VERSION] = "ORA-00600: internal error code, arguments: -4010, Wrong RPC command version"; ERROR_NAME[-OB_PACKET_NOT_SENT] = "OB_PACKET_NOT_SENT"; + ERROR_CAUSE[-OB_PACKET_NOT_SENT] = "Internal Error"; + ERROR_SOLUTION[-OB_PACKET_NOT_SENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PACKET_NOT_SENT] = -1; SQLSTATE[-OB_PACKET_NOT_SENT] = "HY000"; STR_ERROR[-OB_PACKET_NOT_SENT] = "Can not send packet"; @@ -146,6 +185,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PACKET_NOT_SENT] = "ORA-00600: internal error code, arguments: -4011, Can not send packet"; ERROR_NAME[-OB_TIMEOUT] = "OB_TIMEOUT"; + ERROR_CAUSE[-OB_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TIMEOUT] = -1; SQLSTATE[-OB_TIMEOUT] = "HY000"; STR_ERROR[-OB_TIMEOUT] = "Timeout"; @@ -154,6 +195,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TIMEOUT] = "ORA-00600: internal error code, arguments: -4012, Timeout"; ORACLE_STR_USER_ERROR[-OB_TIMEOUT] = "ORA-00600: internal error code, arguments: -4012, Timeout"; ERROR_NAME[-OB_ALLOCATE_MEMORY_FAILED] = "OB_ALLOCATE_MEMORY_FAILED"; + ERROR_CAUSE[-OB_ALLOCATE_MEMORY_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_ALLOCATE_MEMORY_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ALLOCATE_MEMORY_FAILED] = -1; SQLSTATE[-OB_ALLOCATE_MEMORY_FAILED] = "HY001"; STR_ERROR[-OB_ALLOCATE_MEMORY_FAILED] = "No memory or reach tenant memory limit"; @@ -164,6 +207,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ALLOCATE_MEMORY_FAILED] = "ORA-00600: internal error code, arguments: -4013, No memory or reach tenant memory limit"; ERROR_NAME[-OB_INNER_STAT_ERROR] = "OB_INNER_STAT_ERROR"; + ERROR_CAUSE[-OB_INNER_STAT_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_INNER_STAT_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INNER_STAT_ERROR] = -1; SQLSTATE[-OB_INNER_STAT_ERROR] = "HY000"; STR_ERROR[-OB_INNER_STAT_ERROR] = "Inner state error"; @@ -172,6 +217,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_INNER_STAT_ERROR] = "ORA-00600: internal error code, arguments: -4014, Inner state error"; ORACLE_STR_USER_ERROR[-OB_INNER_STAT_ERROR] = "ORA-00600: internal error code, arguments: -4014, Inner state error"; ERROR_NAME[-OB_ERR_SYS] = "OB_ERR_SYS"; + ERROR_CAUSE[-OB_ERR_SYS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SYS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SYS] = -1; SQLSTATE[-OB_ERR_SYS] = "HY000"; STR_ERROR[-OB_ERR_SYS] = "System error"; @@ -180,6 +227,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SYS] = "ORA-00600: internal error code, arguments: -4015, System error"; ORACLE_STR_USER_ERROR[-OB_ERR_SYS] = "ORA-00600: internal error code, arguments: -4015, System error"; ERROR_NAME[-OB_ERR_UNEXPECTED] = "OB_ERR_UNEXPECTED"; + ERROR_CAUSE[-OB_ERR_UNEXPECTED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UNEXPECTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UNEXPECTED] = -1; SQLSTATE[-OB_ERR_UNEXPECTED] = "HY000"; STR_ERROR[-OB_ERR_UNEXPECTED] = "Internal error"; @@ -188,6 +237,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_UNEXPECTED] = "ORA-00600: internal error code, arguments: -4016, Internal error"; ORACLE_STR_USER_ERROR[-OB_ERR_UNEXPECTED] = "ORA-00600: internal error code, arguments: -4016, %s"; ERROR_NAME[-OB_ENTRY_EXIST] = "OB_ENTRY_EXIST"; + ERROR_CAUSE[-OB_ENTRY_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ENTRY_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ENTRY_EXIST] = -1; SQLSTATE[-OB_ENTRY_EXIST] = "HY000"; STR_ERROR[-OB_ENTRY_EXIST] = "Entry already exist"; @@ -196,6 +247,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ENTRY_EXIST] = "ORA-00600: internal error code, arguments: -4017, Entry already exist"; ORACLE_STR_USER_ERROR[-OB_ENTRY_EXIST] = "ORA-00600: internal error code, arguments: -4017, %s"; ERROR_NAME[-OB_ENTRY_NOT_EXIST] = "OB_ENTRY_NOT_EXIST"; + ERROR_CAUSE[-OB_ENTRY_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ENTRY_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ENTRY_NOT_EXIST] = -1; SQLSTATE[-OB_ENTRY_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ENTRY_NOT_EXIST] = "Entry not exist"; @@ -204,6 +257,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ENTRY_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4018, Entry not exist"; ORACLE_STR_USER_ERROR[-OB_ENTRY_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4018, %s"; ERROR_NAME[-OB_SIZE_OVERFLOW] = "OB_SIZE_OVERFLOW"; + ERROR_CAUSE[-OB_SIZE_OVERFLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_SIZE_OVERFLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SIZE_OVERFLOW] = -1; SQLSTATE[-OB_SIZE_OVERFLOW] = "HY000"; STR_ERROR[-OB_SIZE_OVERFLOW] = "Size overflow"; @@ -212,6 +267,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_SIZE_OVERFLOW] = "ORA-00600: internal error code, arguments: -4019, Size overflow"; ORACLE_STR_USER_ERROR[-OB_SIZE_OVERFLOW] = "ORA-00600: internal error code, arguments: -4019, Size overflow"; ERROR_NAME[-OB_REF_NUM_NOT_ZERO] = "OB_REF_NUM_NOT_ZERO"; + ERROR_CAUSE[-OB_REF_NUM_NOT_ZERO] = "Internal Error"; + ERROR_SOLUTION[-OB_REF_NUM_NOT_ZERO] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_REF_NUM_NOT_ZERO] = -1; SQLSTATE[-OB_REF_NUM_NOT_ZERO] = "HY000"; STR_ERROR[-OB_REF_NUM_NOT_ZERO] = "Reference count is not zero"; @@ -222,6 +279,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_REF_NUM_NOT_ZERO] = "ORA-00600: internal error code, arguments: -4020, Reference count is not zero"; ERROR_NAME[-OB_CONFLICT_VALUE] = "OB_CONFLICT_VALUE"; + ERROR_CAUSE[-OB_CONFLICT_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_CONFLICT_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CONFLICT_VALUE] = -1; SQLSTATE[-OB_CONFLICT_VALUE] = "HY000"; STR_ERROR[-OB_CONFLICT_VALUE] = "Conflict value"; @@ -230,6 +289,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_CONFLICT_VALUE] = "ORA-00600: internal error code, arguments: -4021, Conflict value"; ORACLE_STR_USER_ERROR[-OB_CONFLICT_VALUE] = "ORA-00600: internal error code, arguments: -4021, Conflict value"; ERROR_NAME[-OB_ITEM_NOT_SETTED] = "OB_ITEM_NOT_SETTED"; + ERROR_CAUSE[-OB_ITEM_NOT_SETTED] = "Internal Error"; + ERROR_SOLUTION[-OB_ITEM_NOT_SETTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ITEM_NOT_SETTED] = -1; SQLSTATE[-OB_ITEM_NOT_SETTED] = "HY000"; STR_ERROR[-OB_ITEM_NOT_SETTED] = "Item not set"; @@ -238,6 +299,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ITEM_NOT_SETTED] = "ORA-00600: internal error code, arguments: -4022, Item not set"; ORACLE_STR_USER_ERROR[-OB_ITEM_NOT_SETTED] = "ORA-00600: internal error code, arguments: -4022, Item not set"; ERROR_NAME[-OB_EAGAIN] = "OB_EAGAIN"; + ERROR_CAUSE[-OB_EAGAIN] = "Internal Error"; + ERROR_SOLUTION[-OB_EAGAIN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_EAGAIN] = -1; SQLSTATE[-OB_EAGAIN] = "HY000"; STR_ERROR[-OB_EAGAIN] = "Try again"; @@ -246,6 +309,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_EAGAIN] = "ORA-00600: internal error code, arguments: -4023, Try again"; ORACLE_STR_USER_ERROR[-OB_EAGAIN] = "ORA-00600: internal error code, arguments: -4023, Try again"; ERROR_NAME[-OB_BUF_NOT_ENOUGH] = "OB_BUF_NOT_ENOUGH"; + ERROR_CAUSE[-OB_BUF_NOT_ENOUGH] = "Internal Error"; + ERROR_SOLUTION[-OB_BUF_NOT_ENOUGH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BUF_NOT_ENOUGH] = -1; SQLSTATE[-OB_BUF_NOT_ENOUGH] = "HY000"; STR_ERROR[-OB_BUF_NOT_ENOUGH] = "Buffer not enough"; @@ -254,6 +319,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_BUF_NOT_ENOUGH] = "ORA-00600: internal error code, arguments: -4024, Buffer not enough"; ORACLE_STR_USER_ERROR[-OB_BUF_NOT_ENOUGH] = "ORA-00600: internal error code, arguments: -4024, Buffer not enough"; ERROR_NAME[-OB_PARTIAL_FAILED] = "OB_PARTIAL_FAILED"; + ERROR_CAUSE[-OB_PARTIAL_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_PARTIAL_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PARTIAL_FAILED] = -1; SQLSTATE[-OB_PARTIAL_FAILED] = "HY000"; STR_ERROR[-OB_PARTIAL_FAILED] = "Partial failed"; @@ -262,6 +329,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_PARTIAL_FAILED] = "ORA-00600: internal error code, arguments: -4025, Partial failed"; ORACLE_STR_USER_ERROR[-OB_PARTIAL_FAILED] = "ORA-00600: internal error code, arguments: -4025, Partial failed"; ERROR_NAME[-OB_READ_NOTHING] = "OB_READ_NOTHING"; + ERROR_CAUSE[-OB_READ_NOTHING] = "Internal Error"; + ERROR_SOLUTION[-OB_READ_NOTHING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_READ_NOTHING] = -1; SQLSTATE[-OB_READ_NOTHING] = "02000"; STR_ERROR[-OB_READ_NOTHING] = "Nothing to read"; @@ -270,6 +339,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_READ_NOTHING] = "ORA-01403: no data found"; ORACLE_STR_USER_ERROR[-OB_READ_NOTHING] = "ORA-01403: no data found"; ERROR_NAME[-OB_FILE_NOT_EXIST] = "OB_FILE_NOT_EXIST"; + ERROR_CAUSE[-OB_FILE_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_FILE_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_FILE_NOT_EXIST] = ER_FILE_NOT_FOUND; SQLSTATE[-OB_FILE_NOT_EXIST] = "HY000"; STR_ERROR[-OB_FILE_NOT_EXIST] = "File not exist"; @@ -278,6 +349,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_FILE_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4027, File not exist"; ORACLE_STR_USER_ERROR[-OB_FILE_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4027, File not exist"; ERROR_NAME[-OB_DISCONTINUOUS_LOG] = "OB_DISCONTINUOUS_LOG"; + ERROR_CAUSE[-OB_DISCONTINUOUS_LOG] = "Internal Error"; + ERROR_SOLUTION[-OB_DISCONTINUOUS_LOG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DISCONTINUOUS_LOG] = -1; SQLSTATE[-OB_DISCONTINUOUS_LOG] = "HY000"; STR_ERROR[-OB_DISCONTINUOUS_LOG] = "Log entry not continuous"; @@ -288,6 +361,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DISCONTINUOUS_LOG] = "ORA-00600: internal error code, arguments: -4028, Log entry not continuous"; ERROR_NAME[-OB_SCHEMA_ERROR] = "OB_SCHEMA_ERROR"; + ERROR_CAUSE[-OB_SCHEMA_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_SCHEMA_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SCHEMA_ERROR] = -1; SQLSTATE[-OB_SCHEMA_ERROR] = "HY000"; STR_ERROR[-OB_SCHEMA_ERROR] = "Schema error"; @@ -296,6 +371,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_SCHEMA_ERROR] = "ORA-00600: internal error code, arguments: -4029, Schema error"; ORACLE_STR_USER_ERROR[-OB_SCHEMA_ERROR] = "ORA-00600: internal error code, arguments: -4029, Schema error"; ERROR_NAME[-OB_TENANT_OUT_OF_MEM] = "OB_TENANT_OUT_OF_MEM"; + ERROR_CAUSE[-OB_TENANT_OUT_OF_MEM] = "Internal Error"; + ERROR_SOLUTION[-OB_TENANT_OUT_OF_MEM] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TENANT_OUT_OF_MEM] = -1; SQLSTATE[-OB_TENANT_OUT_OF_MEM] = "HY000"; STR_ERROR[-OB_TENANT_OUT_OF_MEM] = "Over tenant memory limits"; @@ -306,6 +383,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TENANT_OUT_OF_MEM] = "ORA-00600: internal error code, arguments: -4030, Over tenant memory limits"; ERROR_NAME[-OB_UNKNOWN_OBJ] = "OB_UNKNOWN_OBJ"; + ERROR_CAUSE[-OB_UNKNOWN_OBJ] = "Internal Error"; + ERROR_SOLUTION[-OB_UNKNOWN_OBJ] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_UNKNOWN_OBJ] = -1; SQLSTATE[-OB_UNKNOWN_OBJ] = "HY004"; STR_ERROR[-OB_UNKNOWN_OBJ] = "Unknown object"; @@ -314,6 +393,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_UNKNOWN_OBJ] = "ORA-00600: internal error code, arguments: -4031, Unknown object"; ORACLE_STR_USER_ERROR[-OB_UNKNOWN_OBJ] = "ORA-00600: internal error code, arguments: -4031, Unknown object"; ERROR_NAME[-OB_NO_MONITOR_DATA] = "OB_NO_MONITOR_DATA"; + ERROR_CAUSE[-OB_NO_MONITOR_DATA] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_MONITOR_DATA] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_MONITOR_DATA] = -1; SQLSTATE[-OB_NO_MONITOR_DATA] = "02000"; STR_ERROR[-OB_NO_MONITOR_DATA] = "No monitor data"; @@ -322,6 +403,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NO_MONITOR_DATA] = "ORA-00600: internal error code, arguments: -4032, No monitor data"; ORACLE_STR_USER_ERROR[-OB_NO_MONITOR_DATA] = "ORA-00600: internal error code, arguments: -4032, No monitor data"; ERROR_NAME[-OB_SERIALIZE_ERROR] = "OB_SERIALIZE_ERROR"; + ERROR_CAUSE[-OB_SERIALIZE_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_SERIALIZE_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SERIALIZE_ERROR] = -1; SQLSTATE[-OB_SERIALIZE_ERROR] = "HY000"; STR_ERROR[-OB_SERIALIZE_ERROR] = "Serialize error"; @@ -330,6 +413,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_SERIALIZE_ERROR] = "ORA-00600: internal error code, arguments: -4033, Serialize error"; ORACLE_STR_USER_ERROR[-OB_SERIALIZE_ERROR] = "ORA-00600: internal error code, arguments: -4033, Serialize error"; ERROR_NAME[-OB_DESERIALIZE_ERROR] = "OB_DESERIALIZE_ERROR"; + ERROR_CAUSE[-OB_DESERIALIZE_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_DESERIALIZE_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DESERIALIZE_ERROR] = -1; SQLSTATE[-OB_DESERIALIZE_ERROR] = "HY000"; STR_ERROR[-OB_DESERIALIZE_ERROR] = "Deserialize error"; @@ -339,6 +424,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DESERIALIZE_ERROR] = "ORA-00600: internal error code, arguments: -4034, Deserialize error"; ERROR_NAME[-OB_AIO_TIMEOUT] = "OB_AIO_TIMEOUT"; + ERROR_CAUSE[-OB_AIO_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_AIO_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_AIO_TIMEOUT] = -1; SQLSTATE[-OB_AIO_TIMEOUT] = "HY000"; STR_ERROR[-OB_AIO_TIMEOUT] = "Asynchronous IO error"; @@ -347,6 +434,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_AIO_TIMEOUT] = "ORA-00600: internal error code, arguments: -4035, Asynchronous IO error"; ORACLE_STR_USER_ERROR[-OB_AIO_TIMEOUT] = "ORA-00600: internal error code, arguments: -4035, Asynchronous IO error"; ERROR_NAME[-OB_NEED_RETRY] = "OB_NEED_RETRY"; + ERROR_CAUSE[-OB_NEED_RETRY] = "Internal Error"; + ERROR_SOLUTION[-OB_NEED_RETRY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NEED_RETRY] = -1; SQLSTATE[-OB_NEED_RETRY] = "HY000"; STR_ERROR[-OB_NEED_RETRY] = "Need retry"; @@ -355,6 +444,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NEED_RETRY] = "ORA-00600: internal error code, arguments: -4036, Need retry"; ORACLE_STR_USER_ERROR[-OB_NEED_RETRY] = "ORA-00600: internal error code, arguments: -4036, Need retry"; ERROR_NAME[-OB_TOO_MANY_SSTABLE] = "OB_TOO_MANY_SSTABLE"; + ERROR_CAUSE[-OB_TOO_MANY_SSTABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_TOO_MANY_SSTABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TOO_MANY_SSTABLE] = -1; SQLSTATE[-OB_TOO_MANY_SSTABLE] = "HY000"; STR_ERROR[-OB_TOO_MANY_SSTABLE] = "Too many sstable"; @@ -363,6 +454,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TOO_MANY_SSTABLE] = "ORA-00600: internal error code, arguments: -4037, Too many sstable"; ORACLE_STR_USER_ERROR[-OB_TOO_MANY_SSTABLE] = "ORA-00600: internal error code, arguments: -4037, Too many sstable"; ERROR_NAME[-OB_NOT_MASTER] = "OB_NOT_MASTER"; + ERROR_CAUSE[-OB_NOT_MASTER] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_MASTER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_MASTER] = -1; SQLSTATE[-OB_NOT_MASTER] = "HY000"; STR_ERROR[-OB_NOT_MASTER] = "The observer or zone is not the master"; @@ -373,6 +466,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NOT_MASTER] = "ORA-00600: internal error code, arguments: -4038, The observer or zone is not the master"; ERROR_NAME[-OB_KILLED_BY_THROTTLING] = "OB_KILLED_BY_THROTTLING"; + ERROR_CAUSE[-OB_KILLED_BY_THROTTLING] = "Internal Error"; + ERROR_SOLUTION[-OB_KILLED_BY_THROTTLING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_KILLED_BY_THROTTLING] = -1; SQLSTATE[-OB_KILLED_BY_THROTTLING] = "HY000"; STR_ERROR[-OB_KILLED_BY_THROTTLING] = "Request has killed by sql throttle"; @@ -383,6 +478,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_KILLED_BY_THROTTLING] = "ORA-00600: internal error code, arguments: -4039, Request has killed by sql throttle"; ERROR_NAME[-OB_DECRYPT_FAILED] = "OB_DECRYPT_FAILED"; + ERROR_CAUSE[-OB_DECRYPT_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_DECRYPT_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DECRYPT_FAILED] = -1; SQLSTATE[-OB_DECRYPT_FAILED] = "HY000"; STR_ERROR[-OB_DECRYPT_FAILED] = "Decrypt error"; @@ -391,6 +488,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_DECRYPT_FAILED] = "ORA-00600: internal error code, arguments: -4041, Decrypt error"; ORACLE_STR_USER_ERROR[-OB_DECRYPT_FAILED] = "ORA-00600: internal error code, arguments: -4041, Decrypt error"; ERROR_NAME[-OB_USER_NOT_EXIST] = "OB_USER_NOT_EXIST"; + ERROR_CAUSE[-OB_USER_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_USER_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_USER_NOT_EXIST] = ER_PASSWORD_NO_MATCH; SQLSTATE[-OB_USER_NOT_EXIST] = "42000"; STR_ERROR[-OB_USER_NOT_EXIST] = "Can not find any matching row in the user table"; @@ -399,6 +498,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_USER_NOT_EXIST] = "ORA-01918: user does not exist"; ORACLE_STR_USER_ERROR[-OB_USER_NOT_EXIST] = "ORA-01918: user '%.*s' does not exist"; ERROR_NAME[-OB_PASSWORD_WRONG] = "OB_PASSWORD_WRONG"; + ERROR_CAUSE[-OB_PASSWORD_WRONG] = "Internal Error"; + ERROR_SOLUTION[-OB_PASSWORD_WRONG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PASSWORD_WRONG] = ER_ACCESS_DENIED_ERROR; SQLSTATE[-OB_PASSWORD_WRONG] = "42000"; STR_ERROR[-OB_PASSWORD_WRONG] = "Access denied for user"; @@ -408,6 +509,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PASSWORD_WRONG] = "ORA-00600: internal error code, arguments: -4043, Access denied for user '%.*s'@'%.*s' (using password: %s)"; ERROR_NAME[-OB_SKEY_VERSION_WRONG] = "OB_SKEY_VERSION_WRONG"; + ERROR_CAUSE[-OB_SKEY_VERSION_WRONG] = "Internal Error"; + ERROR_SOLUTION[-OB_SKEY_VERSION_WRONG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SKEY_VERSION_WRONG] = -1; SQLSTATE[-OB_SKEY_VERSION_WRONG] = "HY000"; STR_ERROR[-OB_SKEY_VERSION_WRONG] = "Wrong skey version"; @@ -417,6 +520,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SKEY_VERSION_WRONG] = "ORA-00600: internal error code, arguments: -4044, Wrong skey version"; ERROR_NAME[-OB_NOT_REGISTERED] = "OB_NOT_REGISTERED"; + ERROR_CAUSE[-OB_NOT_REGISTERED] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_REGISTERED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_REGISTERED] = -1; SQLSTATE[-OB_NOT_REGISTERED] = "HY000"; STR_ERROR[-OB_NOT_REGISTERED] = "Not registered"; @@ -425,6 +530,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NOT_REGISTERED] = "ORA-00600: internal error code, arguments: -4048, Not registered"; ORACLE_STR_USER_ERROR[-OB_NOT_REGISTERED] = "ORA-00600: internal error code, arguments: -4048, Not registered"; ERROR_NAME[-OB_WAITQUEUE_TIMEOUT] = "OB_WAITQUEUE_TIMEOUT"; + ERROR_CAUSE[-OB_WAITQUEUE_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_WAITQUEUE_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WAITQUEUE_TIMEOUT] = 4012; SQLSTATE[-OB_WAITQUEUE_TIMEOUT] = "HY000"; STR_ERROR[-OB_WAITQUEUE_TIMEOUT] = "Task timeout and not executed"; @@ -435,6 +542,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_WAITQUEUE_TIMEOUT] = "ORA-00600: internal error code, arguments: -4049, Task timeout and not executed"; ERROR_NAME[-OB_NOT_THE_OBJECT] = "OB_NOT_THE_OBJECT"; + ERROR_CAUSE[-OB_NOT_THE_OBJECT] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_THE_OBJECT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_THE_OBJECT] = -1; SQLSTATE[-OB_NOT_THE_OBJECT] = "HY000"; STR_ERROR[-OB_NOT_THE_OBJECT] = "Not the object"; @@ -443,6 +552,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NOT_THE_OBJECT] = "ORA-00600: internal error code, arguments: -4050, Not the object"; ORACLE_STR_USER_ERROR[-OB_NOT_THE_OBJECT] = "ORA-00600: internal error code, arguments: -4050, Not the object"; ERROR_NAME[-OB_ALREADY_REGISTERED] = "OB_ALREADY_REGISTERED"; + ERROR_CAUSE[-OB_ALREADY_REGISTERED] = "Internal Error"; + ERROR_SOLUTION[-OB_ALREADY_REGISTERED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ALREADY_REGISTERED] = -1; SQLSTATE[-OB_ALREADY_REGISTERED] = "HY000"; STR_ERROR[-OB_ALREADY_REGISTERED] = "Already registered"; @@ -452,6 +563,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ALREADY_REGISTERED] = "ORA-00600: internal error code, arguments: -4051, Already registered"; ERROR_NAME[-OB_LAST_LOG_RUINNED] = "OB_LAST_LOG_RUINNED"; + ERROR_CAUSE[-OB_LAST_LOG_RUINNED] = "Internal Error"; + ERROR_SOLUTION[-OB_LAST_LOG_RUINNED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LAST_LOG_RUINNED] = -1; SQLSTATE[-OB_LAST_LOG_RUINNED] = "HY000"; STR_ERROR[-OB_LAST_LOG_RUINNED] = "Corrupted log entry"; @@ -461,6 +574,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LAST_LOG_RUINNED] = "ORA-00600: internal error code, arguments: -4052, Corrupted log entry"; ERROR_NAME[-OB_NO_CS_SELECTED] = "OB_NO_CS_SELECTED"; + ERROR_CAUSE[-OB_NO_CS_SELECTED] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_CS_SELECTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_CS_SELECTED] = -1; SQLSTATE[-OB_NO_CS_SELECTED] = "HY000"; STR_ERROR[-OB_NO_CS_SELECTED] = "No ChunkServer selected"; @@ -470,6 +585,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NO_CS_SELECTED] = "ORA-00600: internal error code, arguments: -4053, No ChunkServer selected"; ERROR_NAME[-OB_NO_TABLETS_CREATED] = "OB_NO_TABLETS_CREATED"; + ERROR_CAUSE[-OB_NO_TABLETS_CREATED] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_TABLETS_CREATED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_TABLETS_CREATED] = -1; SQLSTATE[-OB_NO_TABLETS_CREATED] = "HY000"; STR_ERROR[-OB_NO_TABLETS_CREATED] = "No tablets created"; @@ -479,6 +596,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NO_TABLETS_CREATED] = "ORA-00600: internal error code, arguments: -4054, No tablets created"; ERROR_NAME[-OB_INVALID_ERROR] = "OB_INVALID_ERROR"; + ERROR_CAUSE[-OB_INVALID_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_ERROR] = -1; SQLSTATE[-OB_INVALID_ERROR] = "HY000"; STR_ERROR[-OB_INVALID_ERROR] = "Invalid entry"; @@ -487,6 +606,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_INVALID_ERROR] = "ORA-00600: internal error code, arguments: -4055, Invalid entry"; ORACLE_STR_USER_ERROR[-OB_INVALID_ERROR] = "ORA-00600: internal error code, arguments: -4055, Invalid entry"; ERROR_NAME[-OB_DECIMAL_OVERFLOW_WARN] = "OB_DECIMAL_OVERFLOW_WARN"; + ERROR_CAUSE[-OB_DECIMAL_OVERFLOW_WARN] = "Internal Error"; + ERROR_SOLUTION[-OB_DECIMAL_OVERFLOW_WARN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DECIMAL_OVERFLOW_WARN] = -1; SQLSTATE[-OB_DECIMAL_OVERFLOW_WARN] = "HY000"; STR_ERROR[-OB_DECIMAL_OVERFLOW_WARN] = "Decimal overflow warning"; @@ -497,6 +618,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DECIMAL_OVERFLOW_WARN] = "ORA-00600: internal error code, arguments: -4057, Decimal overflow warning"; ERROR_NAME[-OB_DECIMAL_UNLEGAL_ERROR] = "OB_DECIMAL_UNLEGAL_ERROR"; + ERROR_CAUSE[-OB_DECIMAL_UNLEGAL_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_DECIMAL_UNLEGAL_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DECIMAL_UNLEGAL_ERROR] = -1; SQLSTATE[-OB_DECIMAL_UNLEGAL_ERROR] = "HY000"; STR_ERROR[-OB_DECIMAL_UNLEGAL_ERROR] = "Decimal overflow error"; @@ -507,6 +630,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DECIMAL_UNLEGAL_ERROR] = "ORA-00600: internal error code, arguments: -4058, Decimal overflow error"; ERROR_NAME[-OB_OBJ_DIVIDE_ERROR] = "OB_OBJ_DIVIDE_ERROR"; + ERROR_CAUSE[-OB_OBJ_DIVIDE_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_OBJ_DIVIDE_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OBJ_DIVIDE_ERROR] = -1; SQLSTATE[-OB_OBJ_DIVIDE_ERROR] = "HY000"; STR_ERROR[-OB_OBJ_DIVIDE_ERROR] = "Divide error"; @@ -515,6 +640,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_OBJ_DIVIDE_ERROR] = "ORA-00600: internal error code, arguments: -4060, Divide error"; ORACLE_STR_USER_ERROR[-OB_OBJ_DIVIDE_ERROR] = "ORA-00600: internal error code, arguments: -4060, Divide error"; ERROR_NAME[-OB_NOT_A_DECIMAL] = "OB_NOT_A_DECIMAL"; + ERROR_CAUSE[-OB_NOT_A_DECIMAL] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_A_DECIMAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_A_DECIMAL] = -1; SQLSTATE[-OB_NOT_A_DECIMAL] = "HY000"; STR_ERROR[-OB_NOT_A_DECIMAL] = "Not a decimal"; @@ -523,6 +650,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NOT_A_DECIMAL] = "ORA-00600: internal error code, arguments: -4061, Not a decimal"; ORACLE_STR_USER_ERROR[-OB_NOT_A_DECIMAL] = "ORA-00600: internal error code, arguments: -4061, Not a decimal"; ERROR_NAME[-OB_DECIMAL_PRECISION_NOT_EQUAL] = "OB_DECIMAL_PRECISION_NOT_EQUAL"; + ERROR_CAUSE[-OB_DECIMAL_PRECISION_NOT_EQUAL] = "Internal Error"; + ERROR_SOLUTION[-OB_DECIMAL_PRECISION_NOT_EQUAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DECIMAL_PRECISION_NOT_EQUAL] = -1; SQLSTATE[-OB_DECIMAL_PRECISION_NOT_EQUAL] = "HY104"; STR_ERROR[-OB_DECIMAL_PRECISION_NOT_EQUAL] = "Decimal precision error"; @@ -533,6 +662,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DECIMAL_PRECISION_NOT_EQUAL] = "ORA-00600: internal error code, arguments: -4062, Decimal precision error"; ERROR_NAME[-OB_EMPTY_RANGE] = "OB_EMPTY_RANGE"; + ERROR_CAUSE[-OB_EMPTY_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_EMPTY_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_EMPTY_RANGE] = -1; SQLSTATE[-OB_EMPTY_RANGE] = "HY000"; STR_ERROR[-OB_EMPTY_RANGE] = "Empty range"; @@ -541,6 +672,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_EMPTY_RANGE] = "ORA-00600: internal error code, arguments: -4063, Empty range"; ORACLE_STR_USER_ERROR[-OB_EMPTY_RANGE] = "ORA-00600: internal error code, arguments: -4063, Empty range"; ERROR_NAME[-OB_SESSION_KILLED] = "OB_SESSION_KILLED"; + ERROR_CAUSE[-OB_SESSION_KILLED] = "Internal Error"; + ERROR_SOLUTION[-OB_SESSION_KILLED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SESSION_KILLED] = -1; SQLSTATE[-OB_SESSION_KILLED] = "HY000"; STR_ERROR[-OB_SESSION_KILLED] = "Session killed"; @@ -549,6 +682,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_SESSION_KILLED] = "ORA-00600: internal error code, arguments: -4064, Session killed"; ORACLE_STR_USER_ERROR[-OB_SESSION_KILLED] = "ORA-00600: internal error code, arguments: -4064, Session killed"; ERROR_NAME[-OB_LOG_NOT_SYNC] = "OB_LOG_NOT_SYNC"; + ERROR_CAUSE[-OB_LOG_NOT_SYNC] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_NOT_SYNC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_NOT_SYNC] = -1; SQLSTATE[-OB_LOG_NOT_SYNC] = "HY000"; STR_ERROR[-OB_LOG_NOT_SYNC] = "Log not sync"; @@ -557,6 +692,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_LOG_NOT_SYNC] = "ORA-00600: internal error code, arguments: -4065, Log not sync"; ORACLE_STR_USER_ERROR[-OB_LOG_NOT_SYNC] = "ORA-00600: internal error code, arguments: -4065, Log not sync"; ERROR_NAME[-OB_DIR_NOT_EXIST] = "OB_DIR_NOT_EXIST"; + ERROR_CAUSE[-OB_DIR_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_DIR_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DIR_NOT_EXIST] = ER_CANT_READ_DIR; SQLSTATE[-OB_DIR_NOT_EXIST] = "HY000"; STR_ERROR[-OB_DIR_NOT_EXIST] = "Directory not exist"; @@ -565,6 +702,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_DIR_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4066, Directory not exist"; ORACLE_STR_USER_ERROR[-OB_DIR_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4066, Directory not exist"; ERROR_NAME[-OB_SESSION_NOT_FOUND] = "OB_SESSION_NOT_FOUND"; + ERROR_CAUSE[-OB_SESSION_NOT_FOUND] = "Internal Error"; + ERROR_SOLUTION[-OB_SESSION_NOT_FOUND] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SESSION_NOT_FOUND] = 4012; SQLSTATE[-OB_SESSION_NOT_FOUND] = "HY000"; STR_ERROR[-OB_SESSION_NOT_FOUND] = "RPC session not found"; @@ -574,6 +713,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SESSION_NOT_FOUND] = "ORA-00600: internal error code, arguments: -4067, RPC session not found"; ERROR_NAME[-OB_INVALID_LOG] = "OB_INVALID_LOG"; + ERROR_CAUSE[-OB_INVALID_LOG] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_LOG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_LOG] = -1; SQLSTATE[-OB_INVALID_LOG] = "HY000"; STR_ERROR[-OB_INVALID_LOG] = "Invalid log"; @@ -582,6 +723,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_INVALID_LOG] = "ORA-00600: internal error code, arguments: -4068, Invalid log"; ORACLE_STR_USER_ERROR[-OB_INVALID_LOG] = "ORA-00600: internal error code, arguments: -4068, Invalid log"; ERROR_NAME[-OB_INVALID_DATA] = "OB_INVALID_DATA"; + ERROR_CAUSE[-OB_INVALID_DATA] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_DATA] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_DATA] = -1; SQLSTATE[-OB_INVALID_DATA] = "HY000"; STR_ERROR[-OB_INVALID_DATA] = "Invalid data"; @@ -590,6 +733,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_INVALID_DATA] = "ORA-00600: internal error code, arguments: -4070, Invalid data"; ORACLE_STR_USER_ERROR[-OB_INVALID_DATA] = "ORA-00600: internal error code, arguments: -4070, Invalid data"; ERROR_NAME[-OB_ALREADY_DONE] = "OB_ALREADY_DONE"; + ERROR_CAUSE[-OB_ALREADY_DONE] = "Internal Error"; + ERROR_SOLUTION[-OB_ALREADY_DONE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ALREADY_DONE] = -1; SQLSTATE[-OB_ALREADY_DONE] = "HY000"; STR_ERROR[-OB_ALREADY_DONE] = "Already done"; @@ -598,6 +743,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ALREADY_DONE] = "ORA-00600: internal error code, arguments: -4071, Already done"; ORACLE_STR_USER_ERROR[-OB_ALREADY_DONE] = "ORA-00600: internal error code, arguments: -4071, Already done"; ERROR_NAME[-OB_CANCELED] = "OB_CANCELED"; + ERROR_CAUSE[-OB_CANCELED] = "Internal Error"; + ERROR_SOLUTION[-OB_CANCELED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANCELED] = -1; SQLSTATE[-OB_CANCELED] = "HY000"; STR_ERROR[-OB_CANCELED] = "Operation canceled"; @@ -606,6 +753,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_CANCELED] = "ORA-00600: internal error code, arguments: -4072, Operation canceled"; ORACLE_STR_USER_ERROR[-OB_CANCELED] = "ORA-00600: internal error code, arguments: -4072, Operation canceled"; ERROR_NAME[-OB_LOG_SRC_CHANGED] = "OB_LOG_SRC_CHANGED"; + ERROR_CAUSE[-OB_LOG_SRC_CHANGED] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_SRC_CHANGED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_SRC_CHANGED] = -1; SQLSTATE[-OB_LOG_SRC_CHANGED] = "HY000"; STR_ERROR[-OB_LOG_SRC_CHANGED] = "Log source changed"; @@ -614,6 +763,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_LOG_SRC_CHANGED] = "ORA-00600: internal error code, arguments: -4073, Log source changed"; ORACLE_STR_USER_ERROR[-OB_LOG_SRC_CHANGED] = "ORA-00600: internal error code, arguments: -4073, Log source changed"; ERROR_NAME[-OB_LOG_NOT_ALIGN] = "OB_LOG_NOT_ALIGN"; + ERROR_CAUSE[-OB_LOG_NOT_ALIGN] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_NOT_ALIGN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_NOT_ALIGN] = -1; SQLSTATE[-OB_LOG_NOT_ALIGN] = "HY000"; STR_ERROR[-OB_LOG_NOT_ALIGN] = "Log not aligned"; @@ -622,6 +773,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_LOG_NOT_ALIGN] = "ORA-00600: internal error code, arguments: -4074, Log not aligned"; ORACLE_STR_USER_ERROR[-OB_LOG_NOT_ALIGN] = "ORA-00600: internal error code, arguments: -4074, Log not aligned"; ERROR_NAME[-OB_LOG_MISSING] = "OB_LOG_MISSING"; + ERROR_CAUSE[-OB_LOG_MISSING] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_MISSING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_MISSING] = -1; SQLSTATE[-OB_LOG_MISSING] = "HY000"; STR_ERROR[-OB_LOG_MISSING] = "Log entry missed"; @@ -630,6 +783,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_LOG_MISSING] = "ORA-00600: internal error code, arguments: -4075, Log entry missed"; ORACLE_STR_USER_ERROR[-OB_LOG_MISSING] = "ORA-00600: internal error code, arguments: -4075, Log entry missed"; ERROR_NAME[-OB_NEED_WAIT] = "OB_NEED_WAIT"; + ERROR_CAUSE[-OB_NEED_WAIT] = "Internal Error"; + ERROR_SOLUTION[-OB_NEED_WAIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NEED_WAIT] = -1; SQLSTATE[-OB_NEED_WAIT] = "HY000"; STR_ERROR[-OB_NEED_WAIT] = "Need wait"; @@ -638,6 +793,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NEED_WAIT] = "ORA-00600: internal error code, arguments: -4076, Need wait"; ORACLE_STR_USER_ERROR[-OB_NEED_WAIT] = "ORA-00600: internal error code, arguments: -4076, Need wait"; ERROR_NAME[-OB_NOT_IMPLEMENT] = "OB_NOT_IMPLEMENT"; + ERROR_CAUSE[-OB_NOT_IMPLEMENT] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_IMPLEMENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_IMPLEMENT] = -1; SQLSTATE[-OB_NOT_IMPLEMENT] = "0A000"; STR_ERROR[-OB_NOT_IMPLEMENT] = "Not implemented feature"; @@ -647,6 +804,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NOT_IMPLEMENT] = "ORA-00600: internal error code, arguments: -4077, Not implemented feature"; ERROR_NAME[-OB_DIVISION_BY_ZERO] = "OB_DIVISION_BY_ZERO"; + ERROR_CAUSE[-OB_DIVISION_BY_ZERO] = "Internal Error"; + ERROR_SOLUTION[-OB_DIVISION_BY_ZERO] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DIVISION_BY_ZERO] = ER_DIVISION_BY_ZERO; SQLSTATE[-OB_DIVISION_BY_ZERO] = "42000"; STR_ERROR[-OB_DIVISION_BY_ZERO] = "Divided by zero"; @@ -655,6 +814,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_DIVISION_BY_ZERO] = "ORA-00600: internal error code, arguments: -4078, Divided by zero"; ORACLE_STR_USER_ERROR[-OB_DIVISION_BY_ZERO] = "ORA-00600: internal error code, arguments: -4078, Divided by zero"; ERROR_NAME[-OB_EXCEED_MEM_LIMIT] = "OB_EXCEED_MEM_LIMIT"; + ERROR_CAUSE[-OB_EXCEED_MEM_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_EXCEED_MEM_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_EXCEED_MEM_LIMIT] = -1; SQLSTATE[-OB_EXCEED_MEM_LIMIT] = "HY013"; STR_ERROR[-OB_EXCEED_MEM_LIMIT] = "exceed memory limit"; @@ -664,6 +825,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_EXCEED_MEM_LIMIT] = "ORA-00600: internal error code, arguments: -4080, exceed memory limit"; ERROR_NAME[-OB_RESULT_UNKNOWN] = "OB_RESULT_UNKNOWN"; + ERROR_CAUSE[-OB_RESULT_UNKNOWN] = "Internal Error"; + ERROR_SOLUTION[-OB_RESULT_UNKNOWN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RESULT_UNKNOWN] = -1; SQLSTATE[-OB_RESULT_UNKNOWN] = "HY000"; STR_ERROR[-OB_RESULT_UNKNOWN] = "Unknown result"; @@ -672,6 +835,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_RESULT_UNKNOWN] = "ORA-00600: internal error code, arguments: -4081, Unknown result"; ORACLE_STR_USER_ERROR[-OB_RESULT_UNKNOWN] = "ORA-00600: internal error code, arguments: -4081, Unknown result"; ERROR_NAME[-OB_NO_RESULT] = "OB_NO_RESULT"; + ERROR_CAUSE[-OB_NO_RESULT] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_RESULT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_RESULT] = -1; SQLSTATE[-OB_NO_RESULT] = "02000"; STR_ERROR[-OB_NO_RESULT] = "No result"; @@ -680,6 +845,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NO_RESULT] = "ORA-00600: internal error code, arguments: -4084, No result"; ORACLE_STR_USER_ERROR[-OB_NO_RESULT] = "ORA-00600: internal error code, arguments: -4084, No result"; ERROR_NAME[-OB_QUEUE_OVERFLOW] = "OB_QUEUE_OVERFLOW"; + ERROR_CAUSE[-OB_QUEUE_OVERFLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_QUEUE_OVERFLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_QUEUE_OVERFLOW] = -1; SQLSTATE[-OB_QUEUE_OVERFLOW] = "HY000"; STR_ERROR[-OB_QUEUE_OVERFLOW] = "Queue overflow"; @@ -688,6 +855,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_QUEUE_OVERFLOW] = "ORA-00600: internal error code, arguments: -4085, Queue overflow"; ORACLE_STR_USER_ERROR[-OB_QUEUE_OVERFLOW] = "ORA-00600: internal error code, arguments: -4085, Queue overflow"; ERROR_NAME[-OB_LOG_ID_RANGE_NOT_CONTINUOUS] = "OB_LOG_ID_RANGE_NOT_CONTINUOUS"; + ERROR_CAUSE[-OB_LOG_ID_RANGE_NOT_CONTINUOUS] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_ID_RANGE_NOT_CONTINUOUS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_ID_RANGE_NOT_CONTINUOUS] = -1; SQLSTATE[-OB_LOG_ID_RANGE_NOT_CONTINUOUS] = "HY000"; STR_ERROR[-OB_LOG_ID_RANGE_NOT_CONTINUOUS] = "Table log_id range no continuous"; @@ -698,6 +867,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LOG_ID_RANGE_NOT_CONTINUOUS] = "ORA-00600: internal error code, arguments: -4090, Table log_id range no continuous"; ERROR_NAME[-OB_TERM_LAGGED] = "OB_TERM_LAGGED"; + ERROR_CAUSE[-OB_TERM_LAGGED] = "Internal Error"; + ERROR_SOLUTION[-OB_TERM_LAGGED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TERM_LAGGED] = -1; SQLSTATE[-OB_TERM_LAGGED] = "HY000"; STR_ERROR[-OB_TERM_LAGGED] = "Term lagged"; @@ -706,6 +877,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TERM_LAGGED] = "ORA-00600: internal error code, arguments: -4097, Term lagged"; ORACLE_STR_USER_ERROR[-OB_TERM_LAGGED] = "ORA-00600: internal error code, arguments: -4097, Term lagged"; ERROR_NAME[-OB_TERM_NOT_MATCH] = "OB_TERM_NOT_MATCH"; + ERROR_CAUSE[-OB_TERM_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_TERM_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TERM_NOT_MATCH] = -1; SQLSTATE[-OB_TERM_NOT_MATCH] = "HY000"; STR_ERROR[-OB_TERM_NOT_MATCH] = "Term not match"; @@ -714,6 +887,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TERM_NOT_MATCH] = "ORA-00600: internal error code, arguments: -4098, Term not match"; ORACLE_STR_USER_ERROR[-OB_TERM_NOT_MATCH] = "ORA-00600: internal error code, arguments: -4098, Term not match"; ERROR_NAME[-OB_START_LOG_CURSOR_INVALID] = "OB_START_LOG_CURSOR_INVALID"; + ERROR_CAUSE[-OB_START_LOG_CURSOR_INVALID] = "Internal Error"; + ERROR_SOLUTION[-OB_START_LOG_CURSOR_INVALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_START_LOG_CURSOR_INVALID] = -1; SQLSTATE[-OB_START_LOG_CURSOR_INVALID] = "HY000"; STR_ERROR[-OB_START_LOG_CURSOR_INVALID] = "Invalid log cursor"; @@ -724,6 +899,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_START_LOG_CURSOR_INVALID] = "ORA-00600: internal error code, arguments: -4099, Invalid log cursor"; ERROR_NAME[-OB_LOCK_NOT_MATCH] = "OB_LOCK_NOT_MATCH"; + ERROR_CAUSE[-OB_LOCK_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_LOCK_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOCK_NOT_MATCH] = -1; SQLSTATE[-OB_LOCK_NOT_MATCH] = "HY000"; STR_ERROR[-OB_LOCK_NOT_MATCH] = "Lock not match"; @@ -732,6 +909,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_LOCK_NOT_MATCH] = "ORA-00600: internal error code, arguments: -4100, Lock not match"; ORACLE_STR_USER_ERROR[-OB_LOCK_NOT_MATCH] = "ORA-00600: internal error code, arguments: -4100, Lock not match"; ERROR_NAME[-OB_DEAD_LOCK] = "OB_DEAD_LOCK"; + ERROR_CAUSE[-OB_DEAD_LOCK] = "Internal Error"; + ERROR_SOLUTION[-OB_DEAD_LOCK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DEAD_LOCK] = ER_LOCK_DEADLOCK; SQLSTATE[-OB_DEAD_LOCK] = "HY000"; STR_ERROR[-OB_DEAD_LOCK] = "Deadlock"; @@ -740,6 +919,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_DEAD_LOCK] = "ORA-00060: deadlock detected while waiting for resource"; ORACLE_STR_USER_ERROR[-OB_DEAD_LOCK] = "ORA-00060: deadlock detected while waiting for resource"; ERROR_NAME[-OB_PARTIAL_LOG] = "OB_PARTIAL_LOG"; + ERROR_CAUSE[-OB_PARTIAL_LOG] = "Internal Error"; + ERROR_SOLUTION[-OB_PARTIAL_LOG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PARTIAL_LOG] = -1; SQLSTATE[-OB_PARTIAL_LOG] = "HY000"; STR_ERROR[-OB_PARTIAL_LOG] = "Incomplete log entry"; @@ -748,6 +929,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_PARTIAL_LOG] = "ORA-00600: internal error code, arguments: -4102, Incomplete log entry"; ORACLE_STR_USER_ERROR[-OB_PARTIAL_LOG] = "ORA-00600: internal error code, arguments: -4102, Incomplete log entry"; ERROR_NAME[-OB_CHECKSUM_ERROR] = "OB_CHECKSUM_ERROR"; + ERROR_CAUSE[-OB_CHECKSUM_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_CHECKSUM_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CHECKSUM_ERROR] = -1; SQLSTATE[-OB_CHECKSUM_ERROR] = "42000"; STR_ERROR[-OB_CHECKSUM_ERROR] = "Data checksum error"; @@ -756,6 +939,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_CHECKSUM_ERROR] = "ORA-00600: internal error code, arguments: -4103, Data checksum error"; ORACLE_STR_USER_ERROR[-OB_CHECKSUM_ERROR] = "ORA-00600: internal error code, arguments: -4103, Data checksum error"; ERROR_NAME[-OB_INIT_FAIL] = "OB_INIT_FAIL"; + ERROR_CAUSE[-OB_INIT_FAIL] = "Internal Error"; + ERROR_SOLUTION[-OB_INIT_FAIL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INIT_FAIL] = -1; SQLSTATE[-OB_INIT_FAIL] = "HY000"; STR_ERROR[-OB_INIT_FAIL] = "Initialize error"; @@ -764,6 +949,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_INIT_FAIL] = "ORA-00600: internal error code, arguments: -4104, Initialize error"; ORACLE_STR_USER_ERROR[-OB_INIT_FAIL] = "ORA-00600: internal error code, arguments: -4104, Initialize error"; ERROR_NAME[-OB_ROWKEY_ORDER_ERROR] = "OB_ROWKEY_ORDER_ERROR"; + ERROR_CAUSE[-OB_ROWKEY_ORDER_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ROWKEY_ORDER_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ROWKEY_ORDER_ERROR] = -1; SQLSTATE[-OB_ROWKEY_ORDER_ERROR] = "HY000"; STR_ERROR[-OB_ROWKEY_ORDER_ERROR] = "Rowkey order error"; @@ -773,6 +960,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ROWKEY_ORDER_ERROR] = "ORA-00600: internal error code, arguments: -4105, Rowkey order error"; ERROR_NAME[-OB_NOT_ENOUGH_STORE] = "OB_NOT_ENOUGH_STORE"; + ERROR_CAUSE[-OB_NOT_ENOUGH_STORE] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_ENOUGH_STORE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_ENOUGH_STORE] = -1; SQLSTATE[-OB_NOT_ENOUGH_STORE] = "HY000"; STR_ERROR[-OB_NOT_ENOUGH_STORE] = "not enough commitlog store"; @@ -783,6 +972,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NOT_ENOUGH_STORE] = "ORA-00600: internal error code, arguments: -4106, not enough commitlog store"; ERROR_NAME[-OB_BLOCK_SWITCHED] = "OB_BLOCK_SWITCHED"; + ERROR_CAUSE[-OB_BLOCK_SWITCHED] = "Internal Error"; + ERROR_SOLUTION[-OB_BLOCK_SWITCHED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BLOCK_SWITCHED] = -1; SQLSTATE[-OB_BLOCK_SWITCHED] = "HY000"; STR_ERROR[-OB_BLOCK_SWITCHED] = "block switched when fill commitlog"; @@ -793,6 +984,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_BLOCK_SWITCHED] = "ORA-00600: internal error code, arguments: -4107, block switched when fill commitlog"; ERROR_NAME[-OB_PHYSIC_CHECKSUM_ERROR] = "OB_PHYSIC_CHECKSUM_ERROR"; + ERROR_CAUSE[-OB_PHYSIC_CHECKSUM_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_PHYSIC_CHECKSUM_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PHYSIC_CHECKSUM_ERROR] = -1; SQLSTATE[-OB_PHYSIC_CHECKSUM_ERROR] = "42000"; STR_ERROR[-OB_PHYSIC_CHECKSUM_ERROR] = "Physic data checksum error"; @@ -803,6 +996,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PHYSIC_CHECKSUM_ERROR] = "ORA-00600: internal error code, arguments: -4108, Physic data checksum error"; ERROR_NAME[-OB_STATE_NOT_MATCH] = "OB_STATE_NOT_MATCH"; + ERROR_CAUSE[-OB_STATE_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_STATE_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_STATE_NOT_MATCH] = -1; SQLSTATE[-OB_STATE_NOT_MATCH] = "HY000"; STR_ERROR[-OB_STATE_NOT_MATCH] = "Server state or role not the same as expected"; @@ -813,6 +1008,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_STATE_NOT_MATCH] = "ORA-00600: internal error code, arguments: -4109, Server state or role not the same as expected"; ERROR_NAME[-OB_READ_ZERO_LOG] = "OB_READ_ZERO_LOG"; + ERROR_CAUSE[-OB_READ_ZERO_LOG] = "Internal Error"; + ERROR_SOLUTION[-OB_READ_ZERO_LOG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_READ_ZERO_LOG] = -1; SQLSTATE[-OB_READ_ZERO_LOG] = "HY000"; STR_ERROR[-OB_READ_ZERO_LOG] = "Read zero log"; @@ -821,6 +1018,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_READ_ZERO_LOG] = "ORA-00600: internal error code, arguments: -4110, Read zero log"; ORACLE_STR_USER_ERROR[-OB_READ_ZERO_LOG] = "ORA-00600: internal error code, arguments: -4110, Read zero log"; ERROR_NAME[-OB_BLOCK_NEED_FREEZE] = "OB_BLOCK_NEED_FREEZE"; + ERROR_CAUSE[-OB_BLOCK_NEED_FREEZE] = "Internal Error"; + ERROR_SOLUTION[-OB_BLOCK_NEED_FREEZE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BLOCK_NEED_FREEZE] = -1; SQLSTATE[-OB_BLOCK_NEED_FREEZE] = "HY000"; STR_ERROR[-OB_BLOCK_NEED_FREEZE] = "block need freeze"; @@ -830,6 +1029,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_BLOCK_NEED_FREEZE] = "ORA-00600: internal error code, arguments: -4111, block need freeze"; ERROR_NAME[-OB_BLOCK_FROZEN] = "OB_BLOCK_FROZEN"; + ERROR_CAUSE[-OB_BLOCK_FROZEN] = "Internal Error"; + ERROR_SOLUTION[-OB_BLOCK_FROZEN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BLOCK_FROZEN] = -1; SQLSTATE[-OB_BLOCK_FROZEN] = "HY000"; STR_ERROR[-OB_BLOCK_FROZEN] = "block frozen"; @@ -838,6 +1039,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_BLOCK_FROZEN] = "ORA-00600: internal error code, arguments: -4112, block frozen"; ORACLE_STR_USER_ERROR[-OB_BLOCK_FROZEN] = "ORA-00600: internal error code, arguments: -4112, block frozen"; ERROR_NAME[-OB_IN_FATAL_STATE] = "OB_IN_FATAL_STATE"; + ERROR_CAUSE[-OB_IN_FATAL_STATE] = "Internal Error"; + ERROR_SOLUTION[-OB_IN_FATAL_STATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_IN_FATAL_STATE] = -1; SQLSTATE[-OB_IN_FATAL_STATE] = "HY000"; STR_ERROR[-OB_IN_FATAL_STATE] = "In FATAL state"; @@ -846,6 +1049,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_IN_FATAL_STATE] = "ORA-00600: internal error code, arguments: -4113, In FATAL state"; ORACLE_STR_USER_ERROR[-OB_IN_FATAL_STATE] = "ORA-00600: internal error code, arguments: -4113, In FATAL state"; ERROR_NAME[-OB_IN_STOP_STATE] = "OB_IN_STOP_STATE"; + ERROR_CAUSE[-OB_IN_STOP_STATE] = "Internal Error"; + ERROR_SOLUTION[-OB_IN_STOP_STATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_IN_STOP_STATE] = -1; SQLSTATE[-OB_IN_STOP_STATE] = "08S01"; STR_ERROR[-OB_IN_STOP_STATE] = "In STOP state"; @@ -854,6 +1059,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_IN_STOP_STATE] = "ORA-00600: internal error code, arguments: -4114, In STOP state"; ORACLE_STR_USER_ERROR[-OB_IN_STOP_STATE] = "ORA-00600: internal error code, arguments: -4114, In STOP state"; ERROR_NAME[-OB_UPS_MASTER_EXISTS] = "OB_UPS_MASTER_EXISTS"; + ERROR_CAUSE[-OB_UPS_MASTER_EXISTS] = "Internal Error"; + ERROR_SOLUTION[-OB_UPS_MASTER_EXISTS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_UPS_MASTER_EXISTS] = -1; SQLSTATE[-OB_UPS_MASTER_EXISTS] = "HY000"; STR_ERROR[-OB_UPS_MASTER_EXISTS] = "Master UpdateServer already exists"; @@ -864,6 +1071,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_UPS_MASTER_EXISTS] = "ORA-00600: internal error code, arguments: -4115, Master UpdateServer already exists"; ERROR_NAME[-OB_LOG_NOT_CLEAR] = "OB_LOG_NOT_CLEAR"; + ERROR_CAUSE[-OB_LOG_NOT_CLEAR] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_NOT_CLEAR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_NOT_CLEAR] = -1; SQLSTATE[-OB_LOG_NOT_CLEAR] = "42000"; STR_ERROR[-OB_LOG_NOT_CLEAR] = "Log not clear"; @@ -872,6 +1081,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_LOG_NOT_CLEAR] = "ORA-00600: internal error code, arguments: -4116, Log not clear"; ORACLE_STR_USER_ERROR[-OB_LOG_NOT_CLEAR] = "ORA-00600: internal error code, arguments: -4116, Log not clear"; ERROR_NAME[-OB_FILE_ALREADY_EXIST] = "OB_FILE_ALREADY_EXIST"; + ERROR_CAUSE[-OB_FILE_ALREADY_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_FILE_ALREADY_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_FILE_ALREADY_EXIST] = ER_FILE_EXISTS_ERROR; SQLSTATE[-OB_FILE_ALREADY_EXIST] = "58000"; STR_ERROR[-OB_FILE_ALREADY_EXIST] = "File already exist"; @@ -881,6 +1092,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_FILE_ALREADY_EXIST] = "ORA-00600: internal error code, arguments: -4117, File already exist"; ERROR_NAME[-OB_UNKNOWN_PACKET] = "OB_UNKNOWN_PACKET"; + ERROR_CAUSE[-OB_UNKNOWN_PACKET] = "Internal Error"; + ERROR_SOLUTION[-OB_UNKNOWN_PACKET] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_UNKNOWN_PACKET] = ER_UNKNOWN_COM_ERROR; SQLSTATE[-OB_UNKNOWN_PACKET] = "HY001"; STR_ERROR[-OB_UNKNOWN_PACKET] = "Unknown packet"; @@ -889,6 +1102,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_UNKNOWN_PACKET] = "ORA-00600: internal error code, arguments: -4118, Unknown packet"; ORACLE_STR_USER_ERROR[-OB_UNKNOWN_PACKET] = "ORA-00600: internal error code, arguments: -4118, Unknown packet"; ERROR_NAME[-OB_RPC_PACKET_TOO_LONG] = "OB_RPC_PACKET_TOO_LONG"; + ERROR_CAUSE[-OB_RPC_PACKET_TOO_LONG] = "Internal Error"; + ERROR_SOLUTION[-OB_RPC_PACKET_TOO_LONG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RPC_PACKET_TOO_LONG] = -1; SQLSTATE[-OB_RPC_PACKET_TOO_LONG] = "08000"; STR_ERROR[-OB_RPC_PACKET_TOO_LONG] = "RPC packet to send too long"; @@ -899,6 +1114,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RPC_PACKET_TOO_LONG] = "ORA-00600: internal error code, arguments: -4119, RPC packet to send too long"; ERROR_NAME[-OB_LOG_TOO_LARGE] = "OB_LOG_TOO_LARGE"; + ERROR_CAUSE[-OB_LOG_TOO_LARGE] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_TOO_LARGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_TOO_LARGE] = -1; SQLSTATE[-OB_LOG_TOO_LARGE] = "HY000"; STR_ERROR[-OB_LOG_TOO_LARGE] = "Log too large"; @@ -907,6 +1124,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_LOG_TOO_LARGE] = "ORA-00600: internal error code, arguments: -4120, Log too large"; ORACLE_STR_USER_ERROR[-OB_LOG_TOO_LARGE] = "ORA-00600: internal error code, arguments: -4120, Log too large"; ERROR_NAME[-OB_RPC_SEND_ERROR] = "OB_RPC_SEND_ERROR"; + ERROR_CAUSE[-OB_RPC_SEND_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_RPC_SEND_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RPC_SEND_ERROR] = 4012; SQLSTATE[-OB_RPC_SEND_ERROR] = "HY000"; STR_ERROR[-OB_RPC_SEND_ERROR] = "RPC send error"; @@ -915,6 +1134,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_RPC_SEND_ERROR] = "ORA-00600: internal error code, arguments: -4121, RPC send error"; ORACLE_STR_USER_ERROR[-OB_RPC_SEND_ERROR] = "ORA-00600: internal error code, arguments: -4121, RPC send error"; ERROR_NAME[-OB_RPC_POST_ERROR] = "OB_RPC_POST_ERROR"; + ERROR_CAUSE[-OB_RPC_POST_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_RPC_POST_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RPC_POST_ERROR] = 4012; SQLSTATE[-OB_RPC_POST_ERROR] = "HY000"; STR_ERROR[-OB_RPC_POST_ERROR] = "RPC post error"; @@ -923,6 +1144,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_RPC_POST_ERROR] = "ORA-00600: internal error code, arguments: -4122, RPC post error"; ORACLE_STR_USER_ERROR[-OB_RPC_POST_ERROR] = "ORA-00600: internal error code, arguments: -4122, RPC post error"; ERROR_NAME[-OB_LIBEASY_ERROR] = "OB_LIBEASY_ERROR"; + ERROR_CAUSE[-OB_LIBEASY_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_LIBEASY_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LIBEASY_ERROR] = -1; SQLSTATE[-OB_LIBEASY_ERROR] = "08000"; STR_ERROR[-OB_LIBEASY_ERROR] = "Libeasy error"; @@ -931,6 +1154,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_LIBEASY_ERROR] = "ORA-00600: internal error code, arguments: -4123, Libeasy error"; ORACLE_STR_USER_ERROR[-OB_LIBEASY_ERROR] = "ORA-00600: internal error code, arguments: -4123, Libeasy error"; ERROR_NAME[-OB_CONNECT_ERROR] = "OB_CONNECT_ERROR"; + ERROR_CAUSE[-OB_CONNECT_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_CONNECT_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CONNECT_ERROR] = -1; SQLSTATE[-OB_CONNECT_ERROR] = "HY000"; STR_ERROR[-OB_CONNECT_ERROR] = "Connect error"; @@ -939,6 +1164,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_CONNECT_ERROR] = "ORA-00600: internal error code, arguments: -4124, Connect error"; ORACLE_STR_USER_ERROR[-OB_CONNECT_ERROR] = "ORA-00600: internal error code, arguments: -4124, Connect error"; ERROR_NAME[-OB_NOT_FREE] = "OB_NOT_FREE"; + ERROR_CAUSE[-OB_NOT_FREE] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_FREE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_FREE] = -1; SQLSTATE[-OB_NOT_FREE] = "HY000"; STR_ERROR[-OB_NOT_FREE] = "Not free"; @@ -947,6 +1174,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NOT_FREE] = "ORA-00600: internal error code, arguments: -4125, Not free"; ORACLE_STR_USER_ERROR[-OB_NOT_FREE] = "ORA-00600: internal error code, arguments: -4125, Not free"; ERROR_NAME[-OB_INIT_SQL_CONTEXT_ERROR] = "OB_INIT_SQL_CONTEXT_ERROR"; + ERROR_CAUSE[-OB_INIT_SQL_CONTEXT_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_INIT_SQL_CONTEXT_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INIT_SQL_CONTEXT_ERROR] = -1; SQLSTATE[-OB_INIT_SQL_CONTEXT_ERROR] = "HY000"; STR_ERROR[-OB_INIT_SQL_CONTEXT_ERROR] = "Init SQL context error"; @@ -957,6 +1186,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INIT_SQL_CONTEXT_ERROR] = "ORA-00600: internal error code, arguments: -4126, Init SQL context error"; ERROR_NAME[-OB_SKIP_INVALID_ROW] = "OB_SKIP_INVALID_ROW"; + ERROR_CAUSE[-OB_SKIP_INVALID_ROW] = "Internal Error"; + ERROR_SOLUTION[-OB_SKIP_INVALID_ROW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SKIP_INVALID_ROW] = -1; SQLSTATE[-OB_SKIP_INVALID_ROW] = "42000"; STR_ERROR[-OB_SKIP_INVALID_ROW] = "Skip invalid row"; @@ -965,6 +1196,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_SKIP_INVALID_ROW] = "ORA-00600: internal error code, arguments: -4127, Skip invalid row"; ORACLE_STR_USER_ERROR[-OB_SKIP_INVALID_ROW] = "ORA-00600: internal error code, arguments: -4127, Skip invalid row"; ERROR_NAME[-OB_RPC_PACKET_INVALID] = "OB_RPC_PACKET_INVALID"; + ERROR_CAUSE[-OB_RPC_PACKET_INVALID] = "Internal Error"; + ERROR_SOLUTION[-OB_RPC_PACKET_INVALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RPC_PACKET_INVALID] = -1; SQLSTATE[-OB_RPC_PACKET_INVALID] = "HY000"; STR_ERROR[-OB_RPC_PACKET_INVALID] = "RPC packet is invalid"; @@ -975,6 +1208,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RPC_PACKET_INVALID] = "ORA-00600: internal error code, arguments: -4128, RPC packet is invalid"; ERROR_NAME[-OB_NO_TABLET] = "OB_NO_TABLET"; + ERROR_CAUSE[-OB_NO_TABLET] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_TABLET] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_TABLET] = -1; SQLSTATE[-OB_NO_TABLET] = "HY000"; STR_ERROR[-OB_NO_TABLET] = "No tablets"; @@ -983,6 +1218,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NO_TABLET] = "ORA-00600: internal error code, arguments: -4133, No tablets"; ORACLE_STR_USER_ERROR[-OB_NO_TABLET] = "ORA-00600: internal error code, arguments: -4133, No tablets"; ERROR_NAME[-OB_SNAPSHOT_DISCARDED] = "OB_SNAPSHOT_DISCARDED"; + ERROR_CAUSE[-OB_SNAPSHOT_DISCARDED] = "Internal Error"; + ERROR_SOLUTION[-OB_SNAPSHOT_DISCARDED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SNAPSHOT_DISCARDED] = -1; SQLSTATE[-OB_SNAPSHOT_DISCARDED] = "HY000"; STR_ERROR[-OB_SNAPSHOT_DISCARDED] = "Request to read too old versioned data"; @@ -991,6 +1228,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_SNAPSHOT_DISCARDED] = "ORA-01555: snapshot too old"; ORACLE_STR_USER_ERROR[-OB_SNAPSHOT_DISCARDED] = "ORA-01555: snapshot too old"; ERROR_NAME[-OB_DATA_NOT_UPTODATE] = "OB_DATA_NOT_UPTODATE"; + ERROR_CAUSE[-OB_DATA_NOT_UPTODATE] = "Internal Error"; + ERROR_SOLUTION[-OB_DATA_NOT_UPTODATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DATA_NOT_UPTODATE] = -1; SQLSTATE[-OB_DATA_NOT_UPTODATE] = "HY000"; STR_ERROR[-OB_DATA_NOT_UPTODATE] = "State is stale"; @@ -999,6 +1238,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_DATA_NOT_UPTODATE] = "ORA-00600: internal error code, arguments: -4139, State is stale"; ORACLE_STR_USER_ERROR[-OB_DATA_NOT_UPTODATE] = "ORA-00600: internal error code, arguments: -4139, State is stale"; ERROR_NAME[-OB_ROW_MODIFIED] = "OB_ROW_MODIFIED"; + ERROR_CAUSE[-OB_ROW_MODIFIED] = "Internal Error"; + ERROR_SOLUTION[-OB_ROW_MODIFIED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ROW_MODIFIED] = -1; SQLSTATE[-OB_ROW_MODIFIED] = "HY000"; STR_ERROR[-OB_ROW_MODIFIED] = "Row modified"; @@ -1007,6 +1248,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ROW_MODIFIED] = "ORA-00600: internal error code, arguments: -4142, Row modified"; ORACLE_STR_USER_ERROR[-OB_ROW_MODIFIED] = "ORA-00600: internal error code, arguments: -4142, Row modified"; ERROR_NAME[-OB_VERSION_NOT_MATCH] = "OB_VERSION_NOT_MATCH"; + ERROR_CAUSE[-OB_VERSION_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_VERSION_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_VERSION_NOT_MATCH] = -1; SQLSTATE[-OB_VERSION_NOT_MATCH] = "42000"; STR_ERROR[-OB_VERSION_NOT_MATCH] = "Version not match"; @@ -1016,6 +1259,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_VERSION_NOT_MATCH] = "ORA-00600: internal error code, arguments: -4143, Version not match"; ERROR_NAME[-OB_BAD_ADDRESS] = "OB_BAD_ADDRESS"; + ERROR_CAUSE[-OB_BAD_ADDRESS] = "Internal Error"; + ERROR_SOLUTION[-OB_BAD_ADDRESS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BAD_ADDRESS] = -1; SQLSTATE[-OB_BAD_ADDRESS] = "42000"; STR_ERROR[-OB_BAD_ADDRESS] = "Bad address"; @@ -1024,6 +1269,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_BAD_ADDRESS] = "ORA-00600: internal error code, arguments: -4144, Bad address"; ORACLE_STR_USER_ERROR[-OB_BAD_ADDRESS] = "ORA-00600: internal error code, arguments: -4144, Bad address"; ERROR_NAME[-OB_ENQUEUE_FAILED] = "OB_ENQUEUE_FAILED"; + ERROR_CAUSE[-OB_ENQUEUE_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_ENQUEUE_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ENQUEUE_FAILED] = -1; SQLSTATE[-OB_ENQUEUE_FAILED] = "HY000"; STR_ERROR[-OB_ENQUEUE_FAILED] = "Enqueue error"; @@ -1032,6 +1279,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ENQUEUE_FAILED] = "ORA-00600: internal error code, arguments: -4146, Enqueue error"; ORACLE_STR_USER_ERROR[-OB_ENQUEUE_FAILED] = "ORA-00600: internal error code, arguments: -4146, Enqueue error"; ERROR_NAME[-OB_INVALID_CONFIG] = "OB_INVALID_CONFIG"; + ERROR_CAUSE[-OB_INVALID_CONFIG] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_CONFIG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_CONFIG] = -1; SQLSTATE[-OB_INVALID_CONFIG] = "HY000"; STR_ERROR[-OB_INVALID_CONFIG] = "Invalid config"; @@ -1040,6 +1289,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_INVALID_CONFIG] = "ORA-00600: internal error code, arguments: -4147, Invalid config"; ORACLE_STR_USER_ERROR[-OB_INVALID_CONFIG] = "ORA-00600: internal error code, arguments: -4147, %s"; ERROR_NAME[-OB_STMT_EXPIRED] = "OB_STMT_EXPIRED"; + ERROR_CAUSE[-OB_STMT_EXPIRED] = "Internal Error"; + ERROR_SOLUTION[-OB_STMT_EXPIRED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_STMT_EXPIRED] = -1; SQLSTATE[-OB_STMT_EXPIRED] = "HY000"; STR_ERROR[-OB_STMT_EXPIRED] = "Expired statement"; @@ -1048,6 +1299,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_STMT_EXPIRED] = "ORA-00600: internal error code, arguments: -4149, Expired statement"; ORACLE_STR_USER_ERROR[-OB_STMT_EXPIRED] = "ORA-00600: internal error code, arguments: -4149, Expired statement"; ERROR_NAME[-OB_ERR_MIN_VALUE] = "OB_ERR_MIN_VALUE"; + ERROR_CAUSE[-OB_ERR_MIN_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MIN_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MIN_VALUE] = -1; SQLSTATE[-OB_ERR_MIN_VALUE] = "42000"; STR_ERROR[-OB_ERR_MIN_VALUE] = "Min value"; @@ -1056,6 +1309,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_MIN_VALUE] = "ORA-00600: internal error code, arguments: -4150, Min value"; ORACLE_STR_USER_ERROR[-OB_ERR_MIN_VALUE] = "ORA-00600: internal error code, arguments: -4150, Min value"; ERROR_NAME[-OB_ERR_MAX_VALUE] = "OB_ERR_MAX_VALUE"; + ERROR_CAUSE[-OB_ERR_MAX_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MAX_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MAX_VALUE] = -1; SQLSTATE[-OB_ERR_MAX_VALUE] = "42000"; STR_ERROR[-OB_ERR_MAX_VALUE] = "Max value"; @@ -1064,6 +1319,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_MAX_VALUE] = "ORA-00600: internal error code, arguments: -4151, Max value"; ORACLE_STR_USER_ERROR[-OB_ERR_MAX_VALUE] = "ORA-00600: internal error code, arguments: -4151, Max value"; ERROR_NAME[-OB_ERR_NULL_VALUE] = "OB_ERR_NULL_VALUE"; + ERROR_CAUSE[-OB_ERR_NULL_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NULL_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NULL_VALUE] = -1; SQLSTATE[-OB_ERR_NULL_VALUE] = "42000"; STR_ERROR[-OB_ERR_NULL_VALUE] = "Null value"; @@ -1072,6 +1329,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_NULL_VALUE] = "ORA-00600: internal error code, arguments: -4152, Null value"; ORACLE_STR_USER_ERROR[-OB_ERR_NULL_VALUE] = "ORA-00600: internal error code, arguments: -4152, %s"; ERROR_NAME[-OB_RESOURCE_OUT] = "OB_RESOURCE_OUT"; + ERROR_CAUSE[-OB_RESOURCE_OUT] = "Internal Error"; + ERROR_SOLUTION[-OB_RESOURCE_OUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RESOURCE_OUT] = ER_OUT_OF_RESOURCES; SQLSTATE[-OB_RESOURCE_OUT] = "53000"; STR_ERROR[-OB_RESOURCE_OUT] = "Out of resource"; @@ -1080,6 +1339,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_RESOURCE_OUT] = "ORA-00600: internal error code, arguments: -4153, Out of resource"; ORACLE_STR_USER_ERROR[-OB_RESOURCE_OUT] = "ORA-00600: internal error code, arguments: -4153, Out of resource"; ERROR_NAME[-OB_ERR_SQL_CLIENT] = "OB_ERR_SQL_CLIENT"; + ERROR_CAUSE[-OB_ERR_SQL_CLIENT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SQL_CLIENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SQL_CLIENT] = -1; SQLSTATE[-OB_ERR_SQL_CLIENT] = "HY000"; STR_ERROR[-OB_ERR_SQL_CLIENT] = "Internal SQL client error"; @@ -1090,6 +1351,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SQL_CLIENT] = "ORA-00600: internal error code, arguments: -4154, Internal SQL client error"; ERROR_NAME[-OB_META_TABLE_WITHOUT_USE_TABLE] = "OB_META_TABLE_WITHOUT_USE_TABLE"; + ERROR_CAUSE[-OB_META_TABLE_WITHOUT_USE_TABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_META_TABLE_WITHOUT_USE_TABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_META_TABLE_WITHOUT_USE_TABLE] = -1; SQLSTATE[-OB_META_TABLE_WITHOUT_USE_TABLE] = "HY000"; STR_ERROR[-OB_META_TABLE_WITHOUT_USE_TABLE] = "Meta table without use table"; @@ -1100,6 +1363,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_META_TABLE_WITHOUT_USE_TABLE] = "ORA-00600: internal error code, arguments: -4155, Meta table without use table"; ERROR_NAME[-OB_DISCARD_PACKET] = "OB_DISCARD_PACKET"; + ERROR_CAUSE[-OB_DISCARD_PACKET] = "Internal Error"; + ERROR_SOLUTION[-OB_DISCARD_PACKET] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DISCARD_PACKET] = -1; SQLSTATE[-OB_DISCARD_PACKET] = "HY000"; STR_ERROR[-OB_DISCARD_PACKET] = "Discard packet"; @@ -1108,6 +1373,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_DISCARD_PACKET] = "ORA-00600: internal error code, arguments: -4156, Discard packet"; ORACLE_STR_USER_ERROR[-OB_DISCARD_PACKET] = "ORA-00600: internal error code, arguments: -4156, Discard packet"; ERROR_NAME[-OB_OPERATE_OVERFLOW] = "OB_OPERATE_OVERFLOW"; + ERROR_CAUSE[-OB_OPERATE_OVERFLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_OPERATE_OVERFLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OPERATE_OVERFLOW] = ER_DATA_OUT_OF_RANGE; SQLSTATE[-OB_OPERATE_OVERFLOW] = "22003"; STR_ERROR[-OB_OPERATE_OVERFLOW] = "value is out of range"; @@ -1116,6 +1383,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_OPERATE_OVERFLOW] = "ORA-25137: Data value out of range"; ORACLE_STR_USER_ERROR[-OB_OPERATE_OVERFLOW] = "ORA-25137: Data value %s out of range in '%s'"; ERROR_NAME[-OB_INVALID_DATE_FORMAT] = "OB_INVALID_DATE_FORMAT"; + ERROR_CAUSE[-OB_INVALID_DATE_FORMAT] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_DATE_FORMAT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_DATE_FORMAT] = ER_TRUNCATED_WRONG_VALUE; SQLSTATE[-OB_INVALID_DATE_FORMAT] = "22007"; STR_ERROR[-OB_INVALID_DATE_FORMAT] = "Incorrect value"; @@ -1125,6 +1394,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_DATE_FORMAT] = "ORA-01821: date format not recognized, %s=%d must between %d and %d"; ERROR_NAME[-OB_POOL_REGISTERED_FAILED] = "OB_POOL_REGISTERED_FAILED"; + ERROR_CAUSE[-OB_POOL_REGISTERED_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_POOL_REGISTERED_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_POOL_REGISTERED_FAILED] = -1; SQLSTATE[-OB_POOL_REGISTERED_FAILED] = "HY000"; STR_ERROR[-OB_POOL_REGISTERED_FAILED] = "register pool failed"; @@ -1135,6 +1406,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_POOL_REGISTERED_FAILED] = "ORA-00600: internal error code, arguments: -4159, register pool failed"; ERROR_NAME[-OB_POOL_UNREGISTERED_FAILED] = "OB_POOL_UNREGISTERED_FAILED"; + ERROR_CAUSE[-OB_POOL_UNREGISTERED_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_POOL_UNREGISTERED_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_POOL_UNREGISTERED_FAILED] = -1; SQLSTATE[-OB_POOL_UNREGISTERED_FAILED] = "HY000"; STR_ERROR[-OB_POOL_UNREGISTERED_FAILED] = "unregister pool failed"; @@ -1145,6 +1418,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_POOL_UNREGISTERED_FAILED] = "ORA-00600: internal error code, arguments: -4160, unregister pool failed"; ERROR_NAME[-OB_INVALID_ARGUMENT_NUM] = "OB_INVALID_ARGUMENT_NUM"; + ERROR_CAUSE[-OB_INVALID_ARGUMENT_NUM] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_ARGUMENT_NUM] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_ARGUMENT_NUM] = -1; SQLSTATE[-OB_INVALID_ARGUMENT_NUM] = "42000"; STR_ERROR[-OB_INVALID_ARGUMENT_NUM] = "Invalid argument num"; @@ -1155,6 +1430,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_ARGUMENT_NUM] = "ORA-00600: internal error code, arguments: -4161, Invalid argument num"; ERROR_NAME[-OB_LEASE_NOT_ENOUGH] = "OB_LEASE_NOT_ENOUGH"; + ERROR_CAUSE[-OB_LEASE_NOT_ENOUGH] = "Internal Error"; + ERROR_SOLUTION[-OB_LEASE_NOT_ENOUGH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LEASE_NOT_ENOUGH] = -1; SQLSTATE[-OB_LEASE_NOT_ENOUGH] = "HY000"; STR_ERROR[-OB_LEASE_NOT_ENOUGH] = "reserved lease not enough"; @@ -1165,6 +1442,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LEASE_NOT_ENOUGH] = "ORA-00600: internal error code, arguments: -4162, reserved lease not enough"; ERROR_NAME[-OB_LEASE_NOT_MATCH] = "OB_LEASE_NOT_MATCH"; + ERROR_CAUSE[-OB_LEASE_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_LEASE_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LEASE_NOT_MATCH] = -1; SQLSTATE[-OB_LEASE_NOT_MATCH] = "HY000"; STR_ERROR[-OB_LEASE_NOT_MATCH] = "ups lease not match with rs"; @@ -1175,6 +1454,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LEASE_NOT_MATCH] = "ORA-00600: internal error code, arguments: -4163, ups lease not match with rs"; ERROR_NAME[-OB_UPS_SWITCH_NOT_HAPPEN] = "OB_UPS_SWITCH_NOT_HAPPEN"; + ERROR_CAUSE[-OB_UPS_SWITCH_NOT_HAPPEN] = "Internal Error"; + ERROR_SOLUTION[-OB_UPS_SWITCH_NOT_HAPPEN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_UPS_SWITCH_NOT_HAPPEN] = -1; SQLSTATE[-OB_UPS_SWITCH_NOT_HAPPEN] = "HY000"; STR_ERROR[-OB_UPS_SWITCH_NOT_HAPPEN] = "ups switch not happen"; @@ -1185,6 +1466,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_UPS_SWITCH_NOT_HAPPEN] = "ORA-00600: internal error code, arguments: -4164, ups switch not happen"; ERROR_NAME[-OB_EMPTY_RESULT] = "OB_EMPTY_RESULT"; + ERROR_CAUSE[-OB_EMPTY_RESULT] = "Internal Error"; + ERROR_SOLUTION[-OB_EMPTY_RESULT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_EMPTY_RESULT] = -1; SQLSTATE[-OB_EMPTY_RESULT] = "HY000"; STR_ERROR[-OB_EMPTY_RESULT] = "Empty result"; @@ -1193,6 +1476,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_EMPTY_RESULT] = "ORA-00600: internal error code, arguments: -4165, Empty result"; ORACLE_STR_USER_ERROR[-OB_EMPTY_RESULT] = "ORA-00600: internal error code, arguments: -4165, Empty result"; ERROR_NAME[-OB_CACHE_NOT_HIT] = "OB_CACHE_NOT_HIT"; + ERROR_CAUSE[-OB_CACHE_NOT_HIT] = "Internal Error"; + ERROR_SOLUTION[-OB_CACHE_NOT_HIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CACHE_NOT_HIT] = -1; SQLSTATE[-OB_CACHE_NOT_HIT] = "HY000"; STR_ERROR[-OB_CACHE_NOT_HIT] = "Cache not hit"; @@ -1201,6 +1486,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_CACHE_NOT_HIT] = "ORA-00600: internal error code, arguments: -4166, Cache not hit"; ORACLE_STR_USER_ERROR[-OB_CACHE_NOT_HIT] = "ORA-00600: internal error code, arguments: -4166, Cache not hit"; ERROR_NAME[-OB_NESTED_LOOP_NOT_SUPPORT] = "OB_NESTED_LOOP_NOT_SUPPORT"; + ERROR_CAUSE[-OB_NESTED_LOOP_NOT_SUPPORT] = "Internal Error"; + ERROR_SOLUTION[-OB_NESTED_LOOP_NOT_SUPPORT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NESTED_LOOP_NOT_SUPPORT] = -1; SQLSTATE[-OB_NESTED_LOOP_NOT_SUPPORT] = "HY000"; STR_ERROR[-OB_NESTED_LOOP_NOT_SUPPORT] = "Nested loop not support"; @@ -1211,6 +1498,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NESTED_LOOP_NOT_SUPPORT] = "ORA-00600: internal error code, arguments: -4167, Nested loop not support"; ERROR_NAME[-OB_LOG_INVALID_MOD_ID] = "OB_LOG_INVALID_MOD_ID"; + ERROR_CAUSE[-OB_LOG_INVALID_MOD_ID] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_INVALID_MOD_ID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_INVALID_MOD_ID] = -1; SQLSTATE[-OB_LOG_INVALID_MOD_ID] = "HY000"; STR_ERROR[-OB_LOG_INVALID_MOD_ID] = "Invalid log module id"; @@ -1221,6 +1510,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LOG_INVALID_MOD_ID] = "ORA-00600: internal error code, arguments: -4168, Invalid log module id"; ERROR_NAME[-OB_LOG_MODULE_UNKNOWN] = "OB_LOG_MODULE_UNKNOWN"; + ERROR_CAUSE[-OB_LOG_MODULE_UNKNOWN] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_MODULE_UNKNOWN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_MODULE_UNKNOWN] = -1; SQLSTATE[-OB_LOG_MODULE_UNKNOWN] = "HY000"; STR_ERROR[-OB_LOG_MODULE_UNKNOWN] = "Unknown module name"; @@ -1232,6 +1523,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -4169, Unknown module name. Invalid Setting:'%.*s'. " "Syntax:parMod.subMod:level, parMod.subMod:level"; ERROR_NAME[-OB_LOG_LEVEL_INVALID] = "OB_LOG_LEVEL_INVALID"; + ERROR_CAUSE[-OB_LOG_LEVEL_INVALID] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_LEVEL_INVALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_LEVEL_INVALID] = -1; SQLSTATE[-OB_LOG_LEVEL_INVALID] = "HY000"; STR_ERROR[-OB_LOG_LEVEL_INVALID] = "Invalid level"; @@ -1243,6 +1536,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -4170, Invalid level. Invalid setting:'%.*s'. " "Syntax:parMod.subMod:level, parMod.subMod:level"; ERROR_NAME[-OB_LOG_PARSER_SYNTAX_ERR] = "OB_LOG_PARSER_SYNTAX_ERR"; + ERROR_CAUSE[-OB_LOG_PARSER_SYNTAX_ERR] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_PARSER_SYNTAX_ERR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_PARSER_SYNTAX_ERR] = -1; SQLSTATE[-OB_LOG_PARSER_SYNTAX_ERR] = "HY000"; STR_ERROR[-OB_LOG_PARSER_SYNTAX_ERR] = "Syntax to set log_level error"; @@ -1255,6 +1550,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -4171, Syntax to set log_level error. Invalid setting:'%.*s'. " "Syntax:parMod.subMod:level, parMod.subMod:level"; ERROR_NAME[-OB_INDEX_OUT_OF_RANGE] = "OB_INDEX_OUT_OF_RANGE"; + ERROR_CAUSE[-OB_INDEX_OUT_OF_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_INDEX_OUT_OF_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INDEX_OUT_OF_RANGE] = -1; SQLSTATE[-OB_INDEX_OUT_OF_RANGE] = "HY000"; STR_ERROR[-OB_INDEX_OUT_OF_RANGE] = "Index out of range"; @@ -1264,6 +1561,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INDEX_OUT_OF_RANGE] = "ORA-00600: internal error code, arguments: -4172, Index out of range"; ERROR_NAME[-OB_INT_UNDERFLOW] = "OB_INT_UNDERFLOW"; + ERROR_CAUSE[-OB_INT_UNDERFLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_INT_UNDERFLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INT_UNDERFLOW] = -1; SQLSTATE[-OB_INT_UNDERFLOW] = "HY000"; STR_ERROR[-OB_INT_UNDERFLOW] = "Int underflow"; @@ -1272,6 +1571,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_INT_UNDERFLOW] = "ORA-00600: internal error code, arguments: -4173, Int underflow"; ORACLE_STR_USER_ERROR[-OB_INT_UNDERFLOW] = "ORA-00600: internal error code, arguments: -4173, Int underflow"; ERROR_NAME[-OB_UNKNOWN_CONNECTION] = "OB_UNKNOWN_CONNECTION"; + ERROR_CAUSE[-OB_UNKNOWN_CONNECTION] = "Internal Error"; + ERROR_SOLUTION[-OB_UNKNOWN_CONNECTION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_UNKNOWN_CONNECTION] = ER_NO_SUCH_THREAD; SQLSTATE[-OB_UNKNOWN_CONNECTION] = "HY000"; STR_ERROR[-OB_UNKNOWN_CONNECTION] = "Unknown thread id"; @@ -1281,6 +1582,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_UNKNOWN_CONNECTION] = "ORA-00600: internal error code, arguments: -4174, Unknown thread id: %lu"; ERROR_NAME[-OB_ERROR_OUT_OF_RANGE] = "OB_ERROR_OUT_OF_RANGE"; + ERROR_CAUSE[-OB_ERROR_OUT_OF_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERROR_OUT_OF_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERROR_OUT_OF_RANGE] = -1; SQLSTATE[-OB_ERROR_OUT_OF_RANGE] = "42000"; STR_ERROR[-OB_ERROR_OUT_OF_RANGE] = "Out of range"; @@ -1289,6 +1592,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERROR_OUT_OF_RANGE] = "ORA-00600: internal error code, arguments: -4175, Out of range"; ORACLE_STR_USER_ERROR[-OB_ERROR_OUT_OF_RANGE] = "ORA-00600: internal error code, arguments: -4175, Out of range"; ERROR_NAME[-OB_CACHE_SHRINK_FAILED] = "OB_CACHE_SHRINK_FAILED"; + ERROR_CAUSE[-OB_CACHE_SHRINK_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_CACHE_SHRINK_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CACHE_SHRINK_FAILED] = -1; SQLSTATE[-OB_CACHE_SHRINK_FAILED] = "HY001"; STR_ERROR[-OB_CACHE_SHRINK_FAILED] = "shrink cache failed, no available cache"; @@ -1299,6 +1604,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CACHE_SHRINK_FAILED] = "ORA-00600: internal error code, arguments: -4176, shrink cache failed, no available cache"; ERROR_NAME[-OB_OLD_SCHEMA_VERSION] = "OB_OLD_SCHEMA_VERSION"; + ERROR_CAUSE[-OB_OLD_SCHEMA_VERSION] = "Internal Error"; + ERROR_SOLUTION[-OB_OLD_SCHEMA_VERSION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OLD_SCHEMA_VERSION] = -1; SQLSTATE[-OB_OLD_SCHEMA_VERSION] = "42000"; STR_ERROR[-OB_OLD_SCHEMA_VERSION] = "Schema version too old"; @@ -1309,6 +1616,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_OLD_SCHEMA_VERSION] = "ORA-00600: internal error code, arguments: -4177, Schema version too old"; ERROR_NAME[-OB_RELEASE_SCHEMA_ERROR] = "OB_RELEASE_SCHEMA_ERROR"; + ERROR_CAUSE[-OB_RELEASE_SCHEMA_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_RELEASE_SCHEMA_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RELEASE_SCHEMA_ERROR] = -1; SQLSTATE[-OB_RELEASE_SCHEMA_ERROR] = "HY000"; STR_ERROR[-OB_RELEASE_SCHEMA_ERROR] = "Release schema error"; @@ -1319,6 +1628,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RELEASE_SCHEMA_ERROR] = "ORA-00600: internal error code, arguments: -4178, Release schema error"; ERROR_NAME[-OB_OP_NOT_ALLOW] = "OB_OP_NOT_ALLOW"; + ERROR_CAUSE[-OB_OP_NOT_ALLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_OP_NOT_ALLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OP_NOT_ALLOW] = -1; SQLSTATE[-OB_OP_NOT_ALLOW] = "HY000"; STR_ERROR[-OB_OP_NOT_ALLOW] = "Operation not allowed now"; @@ -1327,6 +1638,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_OP_NOT_ALLOW] = "ORA-00600: internal error code, arguments: -4179, Operation not allowed now"; ORACLE_STR_USER_ERROR[-OB_OP_NOT_ALLOW] = "ORA-00600: internal error code, arguments: -4179, %s not allowed"; ERROR_NAME[-OB_NO_EMPTY_ENTRY] = "OB_NO_EMPTY_ENTRY"; + ERROR_CAUSE[-OB_NO_EMPTY_ENTRY] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_EMPTY_ENTRY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_EMPTY_ENTRY] = -1; SQLSTATE[-OB_NO_EMPTY_ENTRY] = "HY000"; STR_ERROR[-OB_NO_EMPTY_ENTRY] = "No empty entry"; @@ -1335,6 +1648,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NO_EMPTY_ENTRY] = "ORA-00600: internal error code, arguments: -4180, No empty entry"; ORACLE_STR_USER_ERROR[-OB_NO_EMPTY_ENTRY] = "ORA-00600: internal error code, arguments: -4180, No empty entry"; ERROR_NAME[-OB_ERR_ALREADY_EXISTS] = "OB_ERR_ALREADY_EXISTS"; + ERROR_CAUSE[-OB_ERR_ALREADY_EXISTS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ALREADY_EXISTS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ALREADY_EXISTS] = -1; SQLSTATE[-OB_ERR_ALREADY_EXISTS] = "42S01"; STR_ERROR[-OB_ERR_ALREADY_EXISTS] = "Already exist"; @@ -1343,6 +1658,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_ALREADY_EXISTS] = "ORA-00600: internal error code, arguments: -4181, Already exist"; ORACLE_STR_USER_ERROR[-OB_ERR_ALREADY_EXISTS] = "ORA-00600: internal error code, arguments: -4181, Already exist"; ERROR_NAME[-OB_SEARCH_NOT_FOUND] = "OB_SEARCH_NOT_FOUND"; + ERROR_CAUSE[-OB_SEARCH_NOT_FOUND] = "Internal Error"; + ERROR_SOLUTION[-OB_SEARCH_NOT_FOUND] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SEARCH_NOT_FOUND] = -1; SQLSTATE[-OB_SEARCH_NOT_FOUND] = "HY000"; STR_ERROR[-OB_SEARCH_NOT_FOUND] = "Value not found"; @@ -1351,6 +1668,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_SEARCH_NOT_FOUND] = "ORA-00600: internal error code, arguments: -4182, Value not found"; ORACLE_STR_USER_ERROR[-OB_SEARCH_NOT_FOUND] = "ORA-00600: internal error code, arguments: -4182, Value not found"; ERROR_NAME[-OB_BEYOND_THE_RANGE] = "OB_BEYOND_THE_RANGE"; + ERROR_CAUSE[-OB_BEYOND_THE_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_BEYOND_THE_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BEYOND_THE_RANGE] = -1; SQLSTATE[-OB_BEYOND_THE_RANGE] = "HY000"; STR_ERROR[-OB_BEYOND_THE_RANGE] = "Key out of range"; @@ -1359,6 +1678,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_BEYOND_THE_RANGE] = "ORA-00600: internal error code, arguments: -4183, Key out of range"; ORACLE_STR_USER_ERROR[-OB_BEYOND_THE_RANGE] = "ORA-00600: internal error code, arguments: -4183, Key out of range"; ERROR_NAME[-OB_CS_OUTOF_DISK_SPACE] = "OB_CS_OUTOF_DISK_SPACE"; + ERROR_CAUSE[-OB_CS_OUTOF_DISK_SPACE] = "Internal Error"; + ERROR_SOLUTION[-OB_CS_OUTOF_DISK_SPACE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CS_OUTOF_DISK_SPACE] = -1; SQLSTATE[-OB_CS_OUTOF_DISK_SPACE] = "53100"; STR_ERROR[-OB_CS_OUTOF_DISK_SPACE] = "ChunkServer out of disk space"; @@ -1369,6 +1690,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CS_OUTOF_DISK_SPACE] = "ORA-00600: internal error code, arguments: -4184, ChunkServer out of disk space"; ERROR_NAME[-OB_COLUMN_GROUP_NOT_FOUND] = "OB_COLUMN_GROUP_NOT_FOUND"; + ERROR_CAUSE[-OB_COLUMN_GROUP_NOT_FOUND] = "Internal Error"; + ERROR_SOLUTION[-OB_COLUMN_GROUP_NOT_FOUND] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_COLUMN_GROUP_NOT_FOUND] = -1; SQLSTATE[-OB_COLUMN_GROUP_NOT_FOUND] = "HY000"; STR_ERROR[-OB_COLUMN_GROUP_NOT_FOUND] = "Column group not found"; @@ -1379,6 +1702,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_COLUMN_GROUP_NOT_FOUND] = "ORA-00600: internal error code, arguments: -4185, Column group not found"; ERROR_NAME[-OB_CS_COMPRESS_LIB_ERROR] = "OB_CS_COMPRESS_LIB_ERROR"; + ERROR_CAUSE[-OB_CS_COMPRESS_LIB_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_CS_COMPRESS_LIB_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CS_COMPRESS_LIB_ERROR] = -1; SQLSTATE[-OB_CS_COMPRESS_LIB_ERROR] = "HY000"; STR_ERROR[-OB_CS_COMPRESS_LIB_ERROR] = "ChunkServer failed to get compress library"; @@ -1389,6 +1714,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CS_COMPRESS_LIB_ERROR] = "ORA-00600: internal error code, arguments: -4186, ChunkServer failed to get compress library"; ERROR_NAME[-OB_ITEM_NOT_MATCH] = "OB_ITEM_NOT_MATCH"; + ERROR_CAUSE[-OB_ITEM_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_ITEM_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ITEM_NOT_MATCH] = -1; SQLSTATE[-OB_ITEM_NOT_MATCH] = "HY000"; STR_ERROR[-OB_ITEM_NOT_MATCH] = "Item not match"; @@ -1397,6 +1724,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ITEM_NOT_MATCH] = "ORA-00600: internal error code, arguments: -4187, Item not match"; ORACLE_STR_USER_ERROR[-OB_ITEM_NOT_MATCH] = "ORA-00600: internal error code, arguments: -4187, Item not match"; ERROR_NAME[-OB_SCHEDULER_TASK_CNT_MISMATCH] = "OB_SCHEDULER_TASK_CNT_MISMATCH"; + ERROR_CAUSE[-OB_SCHEDULER_TASK_CNT_MISMATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_SCHEDULER_TASK_CNT_MISMATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SCHEDULER_TASK_CNT_MISMATCH] = -1; SQLSTATE[-OB_SCHEDULER_TASK_CNT_MISMATCH] = "HY000"; STR_ERROR[-OB_SCHEDULER_TASK_CNT_MISMATCH] = "Running task cnt and unfinished task cnt not consistent"; @@ -1407,6 +1736,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SCHEDULER_TASK_CNT_MISMATCH] = "ORA-00600: internal error code, arguments: -4188, Running task cnt and unfinished task cnt not consistent"; ERROR_NAME[-OB_INVALID_MACRO_BLOCK_TYPE] = "OB_INVALID_MACRO_BLOCK_TYPE"; + ERROR_CAUSE[-OB_INVALID_MACRO_BLOCK_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_MACRO_BLOCK_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_MACRO_BLOCK_TYPE] = -1; SQLSTATE[-OB_INVALID_MACRO_BLOCK_TYPE] = "HY000"; STR_ERROR[-OB_INVALID_MACRO_BLOCK_TYPE] = "the macro block type does not exist"; @@ -1417,6 +1748,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_MACRO_BLOCK_TYPE] = "ORA-00600: internal error code, arguments: -4189, the macro block type does not exist"; ERROR_NAME[-OB_INVALID_DATE_FORMAT_END] = "OB_INVALID_DATE_FORMAT_END"; + ERROR_CAUSE[-OB_INVALID_DATE_FORMAT_END] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_DATE_FORMAT_END] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_DATE_FORMAT_END] = ER_TRUNCATED_WRONG_VALUE; SQLSTATE[-OB_INVALID_DATE_FORMAT_END] = "22007"; STR_ERROR[-OB_INVALID_DATE_FORMAT_END] = "Incorrect value"; @@ -1427,6 +1760,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_DATE_FORMAT_END] = "ORA-01830: date format picture ends before converting entire input string"; ERROR_NAME[-OB_PG_IS_REMOVED] = "OB_PG_IS_REMOVED"; + ERROR_CAUSE[-OB_PG_IS_REMOVED] = "Internal Error"; + ERROR_SOLUTION[-OB_PG_IS_REMOVED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PG_IS_REMOVED] = -1; SQLSTATE[-OB_PG_IS_REMOVED] = "HY000"; STR_ERROR[-OB_PG_IS_REMOVED] = "partition group is removed"; @@ -1437,6 +1772,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PG_IS_REMOVED] = "ORA-00600: internal error code, arguments: -4191, partition group is removed"; ERROR_NAME[-OB_HASH_EXIST] = "OB_HASH_EXIST"; + ERROR_CAUSE[-OB_HASH_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_HASH_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_HASH_EXIST] = -1; SQLSTATE[-OB_HASH_EXIST] = "HY000"; STR_ERROR[-OB_HASH_EXIST] = "hash map/set entry exist"; @@ -1445,6 +1782,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_HASH_EXIST] = "ORA-00600: internal error code, arguments: -4200, hash map/set entry exist"; ORACLE_STR_USER_ERROR[-OB_HASH_EXIST] = "ORA-00600: internal error code, arguments: -4200, %s"; ERROR_NAME[-OB_HASH_NOT_EXIST] = "OB_HASH_NOT_EXIST"; + ERROR_CAUSE[-OB_HASH_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_HASH_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_HASH_NOT_EXIST] = -1; SQLSTATE[-OB_HASH_NOT_EXIST] = "HY000"; STR_ERROR[-OB_HASH_NOT_EXIST] = "hash map/set entry not exist"; @@ -1454,6 +1793,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -4201, hash map/set entry not exist"; ORACLE_STR_USER_ERROR[-OB_HASH_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4201, %s"; ERROR_NAME[-OB_HASH_GET_TIMEOUT] = "OB_HASH_GET_TIMEOUT"; + ERROR_CAUSE[-OB_HASH_GET_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_HASH_GET_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_HASH_GET_TIMEOUT] = -1; SQLSTATE[-OB_HASH_GET_TIMEOUT] = "HY000"; STR_ERROR[-OB_HASH_GET_TIMEOUT] = "hash map/set get timeout"; @@ -1464,6 +1805,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_HASH_GET_TIMEOUT] = "ORA-00600: internal error code, arguments: -4204, hash map/set get timeout"; ERROR_NAME[-OB_HASH_PLACEMENT_RETRY] = "OB_HASH_PLACEMENT_RETRY"; + ERROR_CAUSE[-OB_HASH_PLACEMENT_RETRY] = "Internal Error"; + ERROR_SOLUTION[-OB_HASH_PLACEMENT_RETRY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_HASH_PLACEMENT_RETRY] = -1; SQLSTATE[-OB_HASH_PLACEMENT_RETRY] = "HY000"; STR_ERROR[-OB_HASH_PLACEMENT_RETRY] = "hash map/set retry"; @@ -1473,6 +1816,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_HASH_PLACEMENT_RETRY] = "ORA-00600: internal error code, arguments: -4205, hash map/set retry"; ERROR_NAME[-OB_HASH_FULL] = "OB_HASH_FULL"; + ERROR_CAUSE[-OB_HASH_FULL] = "Internal Error"; + ERROR_SOLUTION[-OB_HASH_FULL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_HASH_FULL] = -1; SQLSTATE[-OB_HASH_FULL] = "HY000"; STR_ERROR[-OB_HASH_FULL] = "hash map/set full"; @@ -1481,6 +1826,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_HASH_FULL] = "ORA-00600: internal error code, arguments: -4206, hash map/set full"; ORACLE_STR_USER_ERROR[-OB_HASH_FULL] = "ORA-00600: internal error code, arguments: -4206, hash map/set full"; ERROR_NAME[-OB_PACKET_PROCESSED] = "OB_PACKET_PROCESSED"; + ERROR_CAUSE[-OB_PACKET_PROCESSED] = "Internal Error"; + ERROR_SOLUTION[-OB_PACKET_PROCESSED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PACKET_PROCESSED] = -1; SQLSTATE[-OB_PACKET_PROCESSED] = "HY000"; STR_ERROR[-OB_PACKET_PROCESSED] = "packet processed"; @@ -1489,6 +1836,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_PACKET_PROCESSED] = "ORA-00600: internal error code, arguments: -4207, packet processed"; ORACLE_STR_USER_ERROR[-OB_PACKET_PROCESSED] = "ORA-00600: internal error code, arguments: -4207, packet processed"; ERROR_NAME[-OB_WAIT_NEXT_TIMEOUT] = "OB_WAIT_NEXT_TIMEOUT"; + ERROR_CAUSE[-OB_WAIT_NEXT_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_WAIT_NEXT_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WAIT_NEXT_TIMEOUT] = -1; SQLSTATE[-OB_WAIT_NEXT_TIMEOUT] = "HY000"; STR_ERROR[-OB_WAIT_NEXT_TIMEOUT] = "wait next packet timeout"; @@ -1499,6 +1848,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_WAIT_NEXT_TIMEOUT] = "ORA-00600: internal error code, arguments: -4208, wait next packet timeout"; ERROR_NAME[-OB_LEADER_NOT_EXIST] = "OB_LEADER_NOT_EXIST"; + ERROR_CAUSE[-OB_LEADER_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_LEADER_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LEADER_NOT_EXIST] = -1; SQLSTATE[-OB_LEADER_NOT_EXIST] = "HY000"; STR_ERROR[-OB_LEADER_NOT_EXIST] = "partition has not leader"; @@ -1509,6 +1860,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LEADER_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4209, partition has not leader"; ERROR_NAME[-OB_PREPARE_MAJOR_FREEZE_FAILED] = "OB_PREPARE_MAJOR_FREEZE_FAILED"; + ERROR_CAUSE[-OB_PREPARE_MAJOR_FREEZE_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_PREPARE_MAJOR_FREEZE_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PREPARE_MAJOR_FREEZE_FAILED] = -1; SQLSTATE[-OB_PREPARE_MAJOR_FREEZE_FAILED] = "HY000"; STR_ERROR[-OB_PREPARE_MAJOR_FREEZE_FAILED] = "prepare major freeze failed"; @@ -1519,6 +1872,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PREPARE_MAJOR_FREEZE_FAILED] = "ORA-00600: internal error code, arguments: -4210, prepare major freeze failed"; ERROR_NAME[-OB_COMMIT_MAJOR_FREEZE_FAILED] = "OB_COMMIT_MAJOR_FREEZE_FAILED"; + ERROR_CAUSE[-OB_COMMIT_MAJOR_FREEZE_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_COMMIT_MAJOR_FREEZE_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_COMMIT_MAJOR_FREEZE_FAILED] = -1; SQLSTATE[-OB_COMMIT_MAJOR_FREEZE_FAILED] = "HY000"; STR_ERROR[-OB_COMMIT_MAJOR_FREEZE_FAILED] = "commit major freeze failed"; @@ -1529,6 +1884,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_COMMIT_MAJOR_FREEZE_FAILED] = "ORA-00600: internal error code, arguments: -4211, commit major freeze failed"; ERROR_NAME[-OB_ABORT_MAJOR_FREEZE_FAILED] = "OB_ABORT_MAJOR_FREEZE_FAILED"; + ERROR_CAUSE[-OB_ABORT_MAJOR_FREEZE_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_ABORT_MAJOR_FREEZE_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ABORT_MAJOR_FREEZE_FAILED] = -1; SQLSTATE[-OB_ABORT_MAJOR_FREEZE_FAILED] = "HY000"; STR_ERROR[-OB_ABORT_MAJOR_FREEZE_FAILED] = "abort major freeze failed"; @@ -1539,6 +1896,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ABORT_MAJOR_FREEZE_FAILED] = "ORA-00600: internal error code, arguments: -4212, abort major freeze failed"; ERROR_NAME[-OB_MAJOR_FREEZE_NOT_FINISHED] = "OB_MAJOR_FREEZE_NOT_FINISHED"; + ERROR_CAUSE[-OB_MAJOR_FREEZE_NOT_FINISHED] = "Internal Error"; + ERROR_SOLUTION[-OB_MAJOR_FREEZE_NOT_FINISHED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_MAJOR_FREEZE_NOT_FINISHED] = -1; SQLSTATE[-OB_MAJOR_FREEZE_NOT_FINISHED] = "HY000"; STR_ERROR[-OB_MAJOR_FREEZE_NOT_FINISHED] = "last major freeze not finish"; @@ -1549,6 +1908,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_MAJOR_FREEZE_NOT_FINISHED] = "ORA-00600: internal error code, arguments: -4213, last major freeze not finish"; ERROR_NAME[-OB_PARTITION_NOT_LEADER] = "OB_PARTITION_NOT_LEADER"; + ERROR_CAUSE[-OB_PARTITION_NOT_LEADER] = "Internal Error"; + ERROR_SOLUTION[-OB_PARTITION_NOT_LEADER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PARTITION_NOT_LEADER] = -1; SQLSTATE[-OB_PARTITION_NOT_LEADER] = "HY000"; STR_ERROR[-OB_PARTITION_NOT_LEADER] = "partition is not leader partition"; @@ -1559,6 +1920,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PARTITION_NOT_LEADER] = "ORA-00600: internal error code, arguments: -4214, partition is not leader partition"; ERROR_NAME[-OB_WAIT_MAJOR_FREEZE_RESPONSE_TIMEOUT] = "OB_WAIT_MAJOR_FREEZE_RESPONSE_TIMEOUT"; + ERROR_CAUSE[-OB_WAIT_MAJOR_FREEZE_RESPONSE_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_WAIT_MAJOR_FREEZE_RESPONSE_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WAIT_MAJOR_FREEZE_RESPONSE_TIMEOUT] = -1; SQLSTATE[-OB_WAIT_MAJOR_FREEZE_RESPONSE_TIMEOUT] = "HY000"; STR_ERROR[-OB_WAIT_MAJOR_FREEZE_RESPONSE_TIMEOUT] = "wait major freeze response timeout"; @@ -1569,6 +1932,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_WAIT_MAJOR_FREEZE_RESPONSE_TIMEOUT] = "ORA-00600: internal error code, arguments: -4215, wait major freeze response timeout"; ERROR_NAME[-OB_CURL_ERROR] = "OB_CURL_ERROR"; + ERROR_CAUSE[-OB_CURL_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_CURL_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CURL_ERROR] = -1; SQLSTATE[-OB_CURL_ERROR] = "HY000"; STR_ERROR[-OB_CURL_ERROR] = "curl error"; @@ -1577,6 +1942,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_CURL_ERROR] = "ORA-00600: internal error code, arguments: -4216, curl error"; ORACLE_STR_USER_ERROR[-OB_CURL_ERROR] = "ORA-00600: internal error code, arguments: -4216, curl error"; ERROR_NAME[-OB_MAJOR_FREEZE_NOT_ALLOW] = "OB_MAJOR_FREEZE_NOT_ALLOW"; + ERROR_CAUSE[-OB_MAJOR_FREEZE_NOT_ALLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_MAJOR_FREEZE_NOT_ALLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_MAJOR_FREEZE_NOT_ALLOW] = -1; SQLSTATE[-OB_MAJOR_FREEZE_NOT_ALLOW] = "HY000"; STR_ERROR[-OB_MAJOR_FREEZE_NOT_ALLOW] = "Major freeze not allowed now"; @@ -1586,6 +1953,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -4217, Major freeze not allowed now"; ORACLE_STR_USER_ERROR[-OB_MAJOR_FREEZE_NOT_ALLOW] = "ORA-00600: internal error code, arguments: -4217, %s"; ERROR_NAME[-OB_PREPARE_FREEZE_FAILED] = "OB_PREPARE_FREEZE_FAILED"; + ERROR_CAUSE[-OB_PREPARE_FREEZE_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_PREPARE_FREEZE_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PREPARE_FREEZE_FAILED] = -1; SQLSTATE[-OB_PREPARE_FREEZE_FAILED] = "HY000"; STR_ERROR[-OB_PREPARE_FREEZE_FAILED] = "prepare freeze failed"; @@ -1596,6 +1965,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PREPARE_FREEZE_FAILED] = "ORA-00600: internal error code, arguments: -4218, prepare freeze failed"; ERROR_NAME[-OB_INVALID_DATE_VALUE] = "OB_INVALID_DATE_VALUE"; + ERROR_CAUSE[-OB_INVALID_DATE_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_DATE_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_DATE_VALUE] = ER_TRUNCATED_WRONG_VALUE; SQLSTATE[-OB_INVALID_DATE_VALUE] = "22007"; STR_ERROR[-OB_INVALID_DATE_VALUE] = "Incorrect value"; @@ -1605,6 +1976,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_DATE_VALUE] = "ORA-01861: literal does not match format string: '%s' for column '%s'"; ERROR_NAME[-OB_INACTIVE_SQL_CLIENT] = "OB_INACTIVE_SQL_CLIENT"; + ERROR_CAUSE[-OB_INACTIVE_SQL_CLIENT] = "Internal Error"; + ERROR_SOLUTION[-OB_INACTIVE_SQL_CLIENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INACTIVE_SQL_CLIENT] = -1; SQLSTATE[-OB_INACTIVE_SQL_CLIENT] = "HY000"; STR_ERROR[-OB_INACTIVE_SQL_CLIENT] = "Inactive sql client, only read allowed"; @@ -1615,6 +1988,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INACTIVE_SQL_CLIENT] = "ORA-00600: internal error code, arguments: -4220, Inactive sql client, only read allowed"; ERROR_NAME[-OB_INACTIVE_RPC_PROXY] = "OB_INACTIVE_RPC_PROXY"; + ERROR_CAUSE[-OB_INACTIVE_RPC_PROXY] = "Internal Error"; + ERROR_SOLUTION[-OB_INACTIVE_RPC_PROXY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INACTIVE_RPC_PROXY] = -1; SQLSTATE[-OB_INACTIVE_RPC_PROXY] = "HY000"; STR_ERROR[-OB_INACTIVE_RPC_PROXY] = "Inactive rpc proxy, can not send RPC request"; @@ -1625,6 +2000,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INACTIVE_RPC_PROXY] = "ORA-00600: internal error code, arguments: -4221, Inactive rpc proxy, can not send RPC request"; ERROR_NAME[-OB_INTERVAL_WITH_MONTH] = "OB_INTERVAL_WITH_MONTH"; + ERROR_CAUSE[-OB_INTERVAL_WITH_MONTH] = "Internal Error"; + ERROR_SOLUTION[-OB_INTERVAL_WITH_MONTH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INTERVAL_WITH_MONTH] = -1; SQLSTATE[-OB_INTERVAL_WITH_MONTH] = "42000"; STR_ERROR[-OB_INTERVAL_WITH_MONTH] = "Interval with year or month can not be converted to microseconds"; @@ -1635,6 +2012,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INTERVAL_WITH_MONTH] = "ORA-00600: internal error code, arguments: -4222, Interval with " "year or month can not be converted to microseconds"; ERROR_NAME[-OB_TOO_MANY_DATETIME_PARTS] = "OB_TOO_MANY_DATETIME_PARTS"; + ERROR_CAUSE[-OB_TOO_MANY_DATETIME_PARTS] = "Internal Error"; + ERROR_SOLUTION[-OB_TOO_MANY_DATETIME_PARTS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TOO_MANY_DATETIME_PARTS] = -1; SQLSTATE[-OB_TOO_MANY_DATETIME_PARTS] = "42000"; STR_ERROR[-OB_TOO_MANY_DATETIME_PARTS] = "Interval has too many datetime parts"; @@ -1645,6 +2024,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TOO_MANY_DATETIME_PARTS] = "ORA-00600: internal error code, arguments: -4223, Interval has too many datetime parts"; ERROR_NAME[-OB_DATA_OUT_OF_RANGE] = "OB_DATA_OUT_OF_RANGE"; + ERROR_CAUSE[-OB_DATA_OUT_OF_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_DATA_OUT_OF_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DATA_OUT_OF_RANGE] = ER_WARN_DATA_OUT_OF_RANGE; SQLSTATE[-OB_DATA_OUT_OF_RANGE] = "22003"; STR_ERROR[-OB_DATA_OUT_OF_RANGE] = "Out of range value for column"; @@ -1655,6 +2036,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DATA_OUT_OF_RANGE] = "ORA-01438: value larger than specified precision allowed for this column '%.*s' at row %ld"; ERROR_NAME[-OB_PARTITION_NOT_EXIST] = "OB_PARTITION_NOT_EXIST"; + ERROR_CAUSE[-OB_PARTITION_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_PARTITION_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PARTITION_NOT_EXIST] = -1; SQLSTATE[-OB_PARTITION_NOT_EXIST] = "HY000"; STR_ERROR[-OB_PARTITION_NOT_EXIST] = "Partition entry not exists"; @@ -1665,6 +2048,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PARTITION_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4225, Partition entry not exists"; ERROR_NAME[-OB_ERR_TRUNCATED_WRONG_VALUE_FOR_FIELD] = "OB_ERR_TRUNCATED_WRONG_VALUE_FOR_FIELD"; + ERROR_CAUSE[-OB_ERR_TRUNCATED_WRONG_VALUE_FOR_FIELD] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TRUNCATED_WRONG_VALUE_FOR_FIELD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TRUNCATED_WRONG_VALUE_FOR_FIELD] = ER_TRUNCATED_WRONG_VALUE_FOR_FIELD; SQLSTATE[-OB_ERR_TRUNCATED_WRONG_VALUE_FOR_FIELD] = "HY000"; STR_ERROR[-OB_ERR_TRUNCATED_WRONG_VALUE_FOR_FIELD] = "Incorrect integer value"; @@ -1675,6 +2060,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TRUNCATED_WRONG_VALUE_FOR_FIELD] = "ORA-00600: internal error code, arguments: -4226, Incorrect integer value: '%.*s'"; ERROR_NAME[-OB_ERR_NO_DEFAULT_FOR_FIELD] = "OB_ERR_NO_DEFAULT_FOR_FIELD"; + ERROR_CAUSE[-OB_ERR_NO_DEFAULT_FOR_FIELD] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_DEFAULT_FOR_FIELD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_DEFAULT_FOR_FIELD] = ER_NO_DEFAULT_FOR_FIELD; SQLSTATE[-OB_ERR_NO_DEFAULT_FOR_FIELD] = "HY000"; STR_ERROR[-OB_ERR_NO_DEFAULT_FOR_FIELD] = "Field doesn't have a default value"; @@ -1685,6 +2072,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NO_DEFAULT_FOR_FIELD] = "ORA-00600: internal error code, arguments: -4227, Field \'%s\' doesn't have a default value"; ERROR_NAME[-OB_ERR_FIELD_SPECIFIED_TWICE] = "OB_ERR_FIELD_SPECIFIED_TWICE"; + ERROR_CAUSE[-OB_ERR_FIELD_SPECIFIED_TWICE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_FIELD_SPECIFIED_TWICE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_FIELD_SPECIFIED_TWICE] = ER_FIELD_SPECIFIED_TWICE; SQLSTATE[-OB_ERR_FIELD_SPECIFIED_TWICE] = "42000"; STR_ERROR[-OB_ERR_FIELD_SPECIFIED_TWICE] = "Column specified twice"; @@ -1693,6 +2082,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_FIELD_SPECIFIED_TWICE] = "ORA-00957: duplicate column name"; ORACLE_STR_USER_ERROR[-OB_ERR_FIELD_SPECIFIED_TWICE] = "ORA-00957: duplicate column name \'%s\'"; ERROR_NAME[-OB_ERR_TOO_LONG_TABLE_COMMENT] = "OB_ERR_TOO_LONG_TABLE_COMMENT"; + ERROR_CAUSE[-OB_ERR_TOO_LONG_TABLE_COMMENT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_LONG_TABLE_COMMENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_LONG_TABLE_COMMENT] = ER_TOO_LONG_TABLE_COMMENT; SQLSTATE[-OB_ERR_TOO_LONG_TABLE_COMMENT] = "HY000"; STR_ERROR[-OB_ERR_TOO_LONG_TABLE_COMMENT] = "Comment for table is too long"; @@ -1703,6 +2094,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TOO_LONG_TABLE_COMMENT] = "ORA-00600: internal error code, arguments: -4229, Comment for table is too long (max = %ld)"; ERROR_NAME[-OB_ERR_TOO_LONG_FIELD_COMMENT] = "OB_ERR_TOO_LONG_FIELD_COMMENT"; + ERROR_CAUSE[-OB_ERR_TOO_LONG_FIELD_COMMENT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_LONG_FIELD_COMMENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_LONG_FIELD_COMMENT] = ER_TOO_LONG_FIELD_COMMENT; SQLSTATE[-OB_ERR_TOO_LONG_FIELD_COMMENT] = "HY000"; STR_ERROR[-OB_ERR_TOO_LONG_FIELD_COMMENT] = "Comment for field is too long"; @@ -1713,6 +2106,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TOO_LONG_FIELD_COMMENT] = "ORA-00600: internal error code, arguments: -4230, Comment for field is too long (max = %ld)"; ERROR_NAME[-OB_ERR_TOO_LONG_INDEX_COMMENT] = "OB_ERR_TOO_LONG_INDEX_COMMENT"; + ERROR_CAUSE[-OB_ERR_TOO_LONG_INDEX_COMMENT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_LONG_INDEX_COMMENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_LONG_INDEX_COMMENT] = ER_TOO_LONG_INDEX_COMMENT; SQLSTATE[-OB_ERR_TOO_LONG_INDEX_COMMENT] = "HY000"; STR_ERROR[-OB_ERR_TOO_LONG_INDEX_COMMENT] = "Comment for index is too long"; @@ -1723,6 +2118,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TOO_LONG_INDEX_COMMENT] = "ORA-00600: internal error code, arguments: -4231, Comment for index is too long (max = %ld)"; ERROR_NAME[-OB_NOT_FOLLOWER] = "OB_NOT_FOLLOWER"; + ERROR_CAUSE[-OB_NOT_FOLLOWER] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_FOLLOWER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_FOLLOWER] = -1; SQLSTATE[-OB_NOT_FOLLOWER] = "HY000"; STR_ERROR[-OB_NOT_FOLLOWER] = "The observer or zone is not a follower"; @@ -1733,6 +2130,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NOT_FOLLOWER] = "ORA-00600: internal error code, arguments: -4232, The observer or zone is not a follower"; ERROR_NAME[-OB_ERR_OUT_OF_LOWER_BOUND] = "OB_ERR_OUT_OF_LOWER_BOUND"; + ERROR_CAUSE[-OB_ERR_OUT_OF_LOWER_BOUND] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OUT_OF_LOWER_BOUND] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OUT_OF_LOWER_BOUND] = -1; SQLSTATE[-OB_ERR_OUT_OF_LOWER_BOUND] = "HY000"; STR_ERROR[-OB_ERR_OUT_OF_LOWER_BOUND] = "smaller than container lower bound"; @@ -1743,6 +2142,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_OUT_OF_LOWER_BOUND] = "ORA-00600: internal error code, arguments: -4233, smaller than container lower bound"; ERROR_NAME[-OB_ERR_OUT_OF_UPPER_BOUND] = "OB_ERR_OUT_OF_UPPER_BOUND"; + ERROR_CAUSE[-OB_ERR_OUT_OF_UPPER_BOUND] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OUT_OF_UPPER_BOUND] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OUT_OF_UPPER_BOUND] = -1; SQLSTATE[-OB_ERR_OUT_OF_UPPER_BOUND] = "HY000"; STR_ERROR[-OB_ERR_OUT_OF_UPPER_BOUND] = "bigger than container upper bound"; @@ -1753,6 +2154,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_OUT_OF_UPPER_BOUND] = "ORA-00600: internal error code, arguments: -4234, bigger than container upper bound"; ERROR_NAME[-OB_BAD_NULL_ERROR] = "OB_BAD_NULL_ERROR"; + ERROR_CAUSE[-OB_BAD_NULL_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_BAD_NULL_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BAD_NULL_ERROR] = ER_BAD_NULL_ERROR; SQLSTATE[-OB_BAD_NULL_ERROR] = "23000"; STR_ERROR[-OB_BAD_NULL_ERROR] = "Column cannot be null"; @@ -1761,6 +2164,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_BAD_NULL_ERROR] = "ORA-01400: cannot insert NULL"; ORACLE_STR_USER_ERROR[-OB_BAD_NULL_ERROR] = "ORA-01400: cannot insert NULL into '(%.*s)'"; ERROR_NAME[-OB_OBCONFIG_RETURN_ERROR] = "OB_OBCONFIG_RETURN_ERROR"; + ERROR_CAUSE[-OB_OBCONFIG_RETURN_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_OBCONFIG_RETURN_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OBCONFIG_RETURN_ERROR] = -1; SQLSTATE[-OB_OBCONFIG_RETURN_ERROR] = "HY000"; STR_ERROR[-OB_OBCONFIG_RETURN_ERROR] = "ObConfig return error code"; @@ -1771,6 +2176,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_OBCONFIG_RETURN_ERROR] = "ORA-00600: internal error code, arguments: -4236, ObConfig return error code"; ERROR_NAME[-OB_OBCONFIG_APPNAME_MISMATCH] = "OB_OBCONFIG_APPNAME_MISMATCH"; + ERROR_CAUSE[-OB_OBCONFIG_APPNAME_MISMATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_OBCONFIG_APPNAME_MISMATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OBCONFIG_APPNAME_MISMATCH] = -1; SQLSTATE[-OB_OBCONFIG_APPNAME_MISMATCH] = "HY000"; STR_ERROR[-OB_OBCONFIG_APPNAME_MISMATCH] = "Appname mismatch with obconfig result"; @@ -1781,6 +2188,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_OBCONFIG_APPNAME_MISMATCH] = "ORA-00600: internal error code, arguments: -4237, Appname mismatch with obconfig result"; ERROR_NAME[-OB_ERR_VIEW_SELECT_DERIVED] = "OB_ERR_VIEW_SELECT_DERIVED"; + ERROR_CAUSE[-OB_ERR_VIEW_SELECT_DERIVED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_VIEW_SELECT_DERIVED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_VIEW_SELECT_DERIVED] = ER_VIEW_SELECT_DERIVED; SQLSTATE[-OB_ERR_VIEW_SELECT_DERIVED] = "HY000"; STR_ERROR[-OB_ERR_VIEW_SELECT_DERIVED] = "View's SELECT contains a subquery in the FROM clause"; @@ -1791,6 +2200,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_VIEW_SELECT_DERIVED] = "ORA-00600: internal error code, arguments: -4238, View's SELECT contains a subquery in the FROM clause"; ERROR_NAME[-OB_CANT_MJ_PATH] = "OB_CANT_MJ_PATH"; + ERROR_CAUSE[-OB_CANT_MJ_PATH] = "Internal Error"; + ERROR_SOLUTION[-OB_CANT_MJ_PATH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANT_MJ_PATH] = -1; SQLSTATE[-OB_CANT_MJ_PATH] = "HY000"; STR_ERROR[-OB_CANT_MJ_PATH] = "Can not use merge-join to join the tables without join conditions"; @@ -1801,6 +2212,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CANT_MJ_PATH] = "ORA-00600: internal error code, arguments: -4239, Can not use " "merge-join to join the tables without join conditions"; ERROR_NAME[-OB_ERR_NO_JOIN_ORDER_GENERATED] = "OB_ERR_NO_JOIN_ORDER_GENERATED"; + ERROR_CAUSE[-OB_ERR_NO_JOIN_ORDER_GENERATED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_JOIN_ORDER_GENERATED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_JOIN_ORDER_GENERATED] = -1; SQLSTATE[-OB_ERR_NO_JOIN_ORDER_GENERATED] = "HY000"; STR_ERROR[-OB_ERR_NO_JOIN_ORDER_GENERATED] = "No join order generated"; @@ -1811,6 +2224,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NO_JOIN_ORDER_GENERATED] = "ORA-00600: internal error code, arguments: -4240, No join order generated"; ERROR_NAME[-OB_ERR_NO_PATH_GENERATED] = "OB_ERR_NO_PATH_GENERATED"; + ERROR_CAUSE[-OB_ERR_NO_PATH_GENERATED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_PATH_GENERATED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_PATH_GENERATED] = -1; SQLSTATE[-OB_ERR_NO_PATH_GENERATED] = "HY000"; STR_ERROR[-OB_ERR_NO_PATH_GENERATED] = "No join path generated"; @@ -1821,6 +2236,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NO_PATH_GENERATED] = "ORA-00600: internal error code, arguments: -4241, No join path generated"; ERROR_NAME[-OB_ERR_WAIT_REMOTE_SCHEMA_REFRESH] = "OB_ERR_WAIT_REMOTE_SCHEMA_REFRESH"; + ERROR_CAUSE[-OB_ERR_WAIT_REMOTE_SCHEMA_REFRESH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WAIT_REMOTE_SCHEMA_REFRESH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WAIT_REMOTE_SCHEMA_REFRESH] = -1; SQLSTATE[-OB_ERR_WAIT_REMOTE_SCHEMA_REFRESH] = "HY000"; STR_ERROR[-OB_ERR_WAIT_REMOTE_SCHEMA_REFRESH] = "Schema error"; @@ -1831,6 +2248,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WAIT_REMOTE_SCHEMA_REFRESH] = "ORA-00600: internal error code, arguments: -4242, Schema error"; ERROR_NAME[-OB_FILE_NOT_OPENED] = "OB_FILE_NOT_OPENED"; + ERROR_CAUSE[-OB_FILE_NOT_OPENED] = "Internal Error"; + ERROR_SOLUTION[-OB_FILE_NOT_OPENED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_FILE_NOT_OPENED] = -1; SQLSTATE[-OB_FILE_NOT_OPENED] = "HY000"; STR_ERROR[-OB_FILE_NOT_OPENED] = "file not opened"; @@ -1839,6 +2258,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_FILE_NOT_OPENED] = "ORA-00600: internal error code, arguments: -4243, file not opened"; ORACLE_STR_USER_ERROR[-OB_FILE_NOT_OPENED] = "ORA-00600: internal error code, arguments: -4243, file not opened"; ERROR_NAME[-OB_TIMER_TASK_HAS_SCHEDULED] = "OB_TIMER_TASK_HAS_SCHEDULED"; + ERROR_CAUSE[-OB_TIMER_TASK_HAS_SCHEDULED] = "Internal Error"; + ERROR_SOLUTION[-OB_TIMER_TASK_HAS_SCHEDULED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TIMER_TASK_HAS_SCHEDULED] = -1; SQLSTATE[-OB_TIMER_TASK_HAS_SCHEDULED] = "HY000"; STR_ERROR[-OB_TIMER_TASK_HAS_SCHEDULED] = "Timer task has been scheduled"; @@ -1849,6 +2270,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TIMER_TASK_HAS_SCHEDULED] = "ORA-00600: internal error code, arguments: -4244, Timer task has been scheduled"; ERROR_NAME[-OB_TIMER_TASK_HAS_NOT_SCHEDULED] = "OB_TIMER_TASK_HAS_NOT_SCHEDULED"; + ERROR_CAUSE[-OB_TIMER_TASK_HAS_NOT_SCHEDULED] = "Internal Error"; + ERROR_SOLUTION[-OB_TIMER_TASK_HAS_NOT_SCHEDULED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TIMER_TASK_HAS_NOT_SCHEDULED] = -1; SQLSTATE[-OB_TIMER_TASK_HAS_NOT_SCHEDULED] = "HY000"; STR_ERROR[-OB_TIMER_TASK_HAS_NOT_SCHEDULED] = "Timer task has not been scheduled"; @@ -1859,6 +2282,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TIMER_TASK_HAS_NOT_SCHEDULED] = "ORA-00600: internal error code, arguments: -4245, Timer task has not been scheduled"; ERROR_NAME[-OB_PARSE_DEBUG_SYNC_ERROR] = "OB_PARSE_DEBUG_SYNC_ERROR"; + ERROR_CAUSE[-OB_PARSE_DEBUG_SYNC_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_PARSE_DEBUG_SYNC_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PARSE_DEBUG_SYNC_ERROR] = -1; SQLSTATE[-OB_PARSE_DEBUG_SYNC_ERROR] = "HY000"; STR_ERROR[-OB_PARSE_DEBUG_SYNC_ERROR] = "parse debug sync string error"; @@ -1869,6 +2294,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PARSE_DEBUG_SYNC_ERROR] = "ORA-00600: internal error code, arguments: -4246, parse debug sync string error"; ERROR_NAME[-OB_UNKNOWN_DEBUG_SYNC_POINT] = "OB_UNKNOWN_DEBUG_SYNC_POINT"; + ERROR_CAUSE[-OB_UNKNOWN_DEBUG_SYNC_POINT] = "Internal Error"; + ERROR_SOLUTION[-OB_UNKNOWN_DEBUG_SYNC_POINT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_UNKNOWN_DEBUG_SYNC_POINT] = -1; SQLSTATE[-OB_UNKNOWN_DEBUG_SYNC_POINT] = "HY000"; STR_ERROR[-OB_UNKNOWN_DEBUG_SYNC_POINT] = "unknown debug sync point"; @@ -1879,6 +2306,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_UNKNOWN_DEBUG_SYNC_POINT] = "ORA-00600: internal error code, arguments: -4247, unknown debug sync point"; ERROR_NAME[-OB_ERR_INTERRUPTED] = "OB_ERR_INTERRUPTED"; + ERROR_CAUSE[-OB_ERR_INTERRUPTED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INTERRUPTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INTERRUPTED] = -1; SQLSTATE[-OB_ERR_INTERRUPTED] = "HY000"; STR_ERROR[-OB_ERR_INTERRUPTED] = "task is interrupted while running"; @@ -1889,6 +2318,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INTERRUPTED] = "ORA-00600: internal error code, arguments: -4248, task is interrupted while running"; ERROR_NAME[-OB_ERR_DATA_TRUNCATED] = "OB_ERR_DATA_TRUNCATED"; + ERROR_CAUSE[-OB_ERR_DATA_TRUNCATED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DATA_TRUNCATED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DATA_TRUNCATED] = WARN_DATA_TRUNCATED; SQLSTATE[-OB_ERR_DATA_TRUNCATED] = "01000"; STR_ERROR[-OB_ERR_DATA_TRUNCATED] = "Data truncated for argument"; @@ -1899,6 +2330,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DATA_TRUNCATED] = "ORA-00600: internal error code, arguments: -4249, Data truncated for column '%.*s' at row %ld"; ERROR_NAME[-OB_NOT_RUNNING] = "OB_NOT_RUNNING"; + ERROR_CAUSE[-OB_NOT_RUNNING] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_RUNNING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_RUNNING] = -1; SQLSTATE[-OB_NOT_RUNNING] = "HY000"; STR_ERROR[-OB_NOT_RUNNING] = "module is not running"; @@ -1907,6 +2340,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NOT_RUNNING] = "ORA-00600: internal error code, arguments: -4250, module is not running"; ORACLE_STR_USER_ERROR[-OB_NOT_RUNNING] = "ORA-00600: internal error code, arguments: -4250, module is not running"; ERROR_NAME[-OB_INVALID_PARTITION] = "OB_INVALID_PARTITION"; + ERROR_CAUSE[-OB_INVALID_PARTITION] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_PARTITION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_PARTITION] = -1; SQLSTATE[-OB_INVALID_PARTITION] = "HY000"; STR_ERROR[-OB_INVALID_PARTITION] = "partition not valid"; @@ -1916,6 +2351,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_PARTITION] = "ORA-00600: internal error code, arguments: -4251, partition not valid"; ERROR_NAME[-OB_ERR_TIMEOUT_TRUNCATED] = "OB_ERR_TIMEOUT_TRUNCATED"; + ERROR_CAUSE[-OB_ERR_TIMEOUT_TRUNCATED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TIMEOUT_TRUNCATED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TIMEOUT_TRUNCATED] = WARN_DATA_TRUNCATED; SQLSTATE[-OB_ERR_TIMEOUT_TRUNCATED] = "01000"; STR_ERROR[-OB_ERR_TIMEOUT_TRUNCATED] = "Timeout value truncated to 102 years"; @@ -1926,6 +2363,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TIMEOUT_TRUNCATED] = "ORA-00600: internal error code, arguments: -4252, Timeout value truncated to 102 years"; ERROR_NAME[-OB_ERR_TOO_LONG_TENANT_COMMENT] = "OB_ERR_TOO_LONG_TENANT_COMMENT"; + ERROR_CAUSE[-OB_ERR_TOO_LONG_TENANT_COMMENT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_LONG_TENANT_COMMENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_LONG_TENANT_COMMENT] = -1; SQLSTATE[-OB_ERR_TOO_LONG_TENANT_COMMENT] = "HY000"; STR_ERROR[-OB_ERR_TOO_LONG_TENANT_COMMENT] = "Comment for tenant is too long"; @@ -1936,6 +2375,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TOO_LONG_TENANT_COMMENT] = "ORA-00600: internal error code, arguments: -4253, Comment for tenant is too long (max = %ld)"; ERROR_NAME[-OB_ERR_NET_PACKET_TOO_LARGE] = "OB_ERR_NET_PACKET_TOO_LARGE"; + ERROR_CAUSE[-OB_ERR_NET_PACKET_TOO_LARGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NET_PACKET_TOO_LARGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NET_PACKET_TOO_LARGE] = ER_NET_PACKET_TOO_LARGE; SQLSTATE[-OB_ERR_NET_PACKET_TOO_LARGE] = "08S01"; STR_ERROR[-OB_ERR_NET_PACKET_TOO_LARGE] = "Got a packet bigger than \'max_allowed_packet\' bytes"; @@ -1946,6 +2387,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NET_PACKET_TOO_LARGE] = "ORA-00600: internal error code, arguments: -4254, Got a packet bigger than \'max_allowed_packet\' bytes"; ERROR_NAME[-OB_TRACE_DESC_NOT_EXIST] = "OB_TRACE_DESC_NOT_EXIST"; + ERROR_CAUSE[-OB_TRACE_DESC_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_TRACE_DESC_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRACE_DESC_NOT_EXIST] = -1; SQLSTATE[-OB_TRACE_DESC_NOT_EXIST] = "HY000"; STR_ERROR[-OB_TRACE_DESC_NOT_EXIST] = "trace log title or key not exist describle"; @@ -1956,6 +2399,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRACE_DESC_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4255, trace log title or key not exist describle"; ERROR_NAME[-OB_ERR_NO_DEFAULT] = "OB_ERR_NO_DEFAULT"; + ERROR_CAUSE[-OB_ERR_NO_DEFAULT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_DEFAULT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_DEFAULT] = ER_NO_DEFAULT; SQLSTATE[-OB_ERR_NO_DEFAULT] = "42000"; STR_ERROR[-OB_ERR_NO_DEFAULT] = "Variable doesn't have a default value"; @@ -1966,6 +2411,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NO_DEFAULT] = "ORA-00600: internal error code, arguments: -4256, Variable '%.*s' doesn't have a default value"; ERROR_NAME[-OB_ERR_COMPRESS_DECOMPRESS_DATA] = "OB_ERR_COMPRESS_DECOMPRESS_DATA"; + ERROR_CAUSE[-OB_ERR_COMPRESS_DECOMPRESS_DATA] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_COMPRESS_DECOMPRESS_DATA] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_COMPRESS_DECOMPRESS_DATA] = -1; SQLSTATE[-OB_ERR_COMPRESS_DECOMPRESS_DATA] = "HY000"; STR_ERROR[-OB_ERR_COMPRESS_DECOMPRESS_DATA] = "compress data or decompress data failed"; @@ -1976,6 +2423,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_COMPRESS_DECOMPRESS_DATA] = "ORA-00600: internal error code, arguments: -4257, compress data or decompress data failed"; ERROR_NAME[-OB_ERR_INCORRECT_STRING_VALUE] = "OB_ERR_INCORRECT_STRING_VALUE"; + ERROR_CAUSE[-OB_ERR_INCORRECT_STRING_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INCORRECT_STRING_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INCORRECT_STRING_VALUE] = ER_TRUNCATED_WRONG_VALUE_FOR_FIELD; SQLSTATE[-OB_ERR_INCORRECT_STRING_VALUE] = "HY000"; STR_ERROR[-OB_ERR_INCORRECT_STRING_VALUE] = "Incorrect string value"; @@ -1986,6 +2435,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INCORRECT_STRING_VALUE] = "ORA-00600: internal error code, arguments: -4258, Incorrect string value for column '%.*s' at row %ld"; ERROR_NAME[-OB_ERR_DISTRIBUTED_NOT_SUPPORTED] = "OB_ERR_DISTRIBUTED_NOT_SUPPORTED"; + ERROR_CAUSE[-OB_ERR_DISTRIBUTED_NOT_SUPPORTED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DISTRIBUTED_NOT_SUPPORTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DISTRIBUTED_NOT_SUPPORTED] = ER_NOT_SUPPORTED_YET; SQLSTATE[-OB_ERR_DISTRIBUTED_NOT_SUPPORTED] = "0A000"; STR_ERROR[-OB_ERR_DISTRIBUTED_NOT_SUPPORTED] = "Not supported feature or function"; @@ -1996,6 +2447,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DISTRIBUTED_NOT_SUPPORTED] = "ORA-00600: internal error code, arguments: -4259, %s not supported"; ERROR_NAME[-OB_IS_CHANGING_LEADER] = "OB_IS_CHANGING_LEADER"; + ERROR_CAUSE[-OB_IS_CHANGING_LEADER] = "Internal Error"; + ERROR_SOLUTION[-OB_IS_CHANGING_LEADER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_IS_CHANGING_LEADER] = -1; SQLSTATE[-OB_IS_CHANGING_LEADER] = "HY000"; STR_ERROR[-OB_IS_CHANGING_LEADER] = "the partition is changing leader"; @@ -2006,6 +2459,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_IS_CHANGING_LEADER] = "ORA-00600: internal error code, arguments: -4260, the partition is changing leader"; ERROR_NAME[-OB_DATETIME_FUNCTION_OVERFLOW] = "OB_DATETIME_FUNCTION_OVERFLOW"; + ERROR_CAUSE[-OB_DATETIME_FUNCTION_OVERFLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_DATETIME_FUNCTION_OVERFLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DATETIME_FUNCTION_OVERFLOW] = ER_DATETIME_FUNCTION_OVERFLOW; SQLSTATE[-OB_DATETIME_FUNCTION_OVERFLOW] = "22008"; STR_ERROR[-OB_DATETIME_FUNCTION_OVERFLOW] = "Datetime overflow"; @@ -2016,6 +2471,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DATETIME_FUNCTION_OVERFLOW] = "ORA-00600: internal error code, arguments: -4261, Datetime overflow"; ERROR_NAME[-OB_ERR_DOUBLE_TRUNCATED] = "OB_ERR_DOUBLE_TRUNCATED"; + ERROR_CAUSE[-OB_ERR_DOUBLE_TRUNCATED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DOUBLE_TRUNCATED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DOUBLE_TRUNCATED] = ER_TRUNCATED_WRONG_VALUE; SQLSTATE[-OB_ERR_DOUBLE_TRUNCATED] = "01000"; STR_ERROR[-OB_ERR_DOUBLE_TRUNCATED] = "Truncated incorrect DOUBLE value"; @@ -2024,6 +2481,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DOUBLE_TRUNCATED] = "ORA-01722: invalid number"; ORACLE_STR_USER_ERROR[-OB_ERR_DOUBLE_TRUNCATED] = "ORA-01722: invalid number: '%.*s'"; ERROR_NAME[-OB_MINOR_FREEZE_NOT_ALLOW] = "OB_MINOR_FREEZE_NOT_ALLOW"; + ERROR_CAUSE[-OB_MINOR_FREEZE_NOT_ALLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_MINOR_FREEZE_NOT_ALLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_MINOR_FREEZE_NOT_ALLOW] = -1; SQLSTATE[-OB_MINOR_FREEZE_NOT_ALLOW] = "HY000"; STR_ERROR[-OB_MINOR_FREEZE_NOT_ALLOW] = "Minor freeze not allowed now"; @@ -2033,6 +2492,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -4263, Minor freeze not allowed now"; ORACLE_STR_USER_ERROR[-OB_MINOR_FREEZE_NOT_ALLOW] = "ORA-00600: internal error code, arguments: -4263, %s"; ERROR_NAME[-OB_LOG_OUTOF_DISK_SPACE] = "OB_LOG_OUTOF_DISK_SPACE"; + ERROR_CAUSE[-OB_LOG_OUTOF_DISK_SPACE] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_OUTOF_DISK_SPACE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_OUTOF_DISK_SPACE] = -1; SQLSTATE[-OB_LOG_OUTOF_DISK_SPACE] = "HY000"; STR_ERROR[-OB_LOG_OUTOF_DISK_SPACE] = "Log out of disk space"; @@ -2043,6 +2504,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LOG_OUTOF_DISK_SPACE] = "ORA-00600: internal error code, arguments: -4264, Log out of disk space"; ERROR_NAME[-OB_RPC_CONNECT_ERROR] = "OB_RPC_CONNECT_ERROR"; + ERROR_CAUSE[-OB_RPC_CONNECT_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_RPC_CONNECT_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RPC_CONNECT_ERROR] = -1; SQLSTATE[-OB_RPC_CONNECT_ERROR] = "HY000"; STR_ERROR[-OB_RPC_CONNECT_ERROR] = "Rpc connect error"; @@ -2052,6 +2515,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RPC_CONNECT_ERROR] = "ORA-00600: internal error code, arguments: -4265, Rpc connect error"; ERROR_NAME[-OB_MINOR_MERGE_NOT_ALLOW] = "OB_MINOR_MERGE_NOT_ALLOW"; + ERROR_CAUSE[-OB_MINOR_MERGE_NOT_ALLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_MINOR_MERGE_NOT_ALLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_MINOR_MERGE_NOT_ALLOW] = -1; SQLSTATE[-OB_MINOR_MERGE_NOT_ALLOW] = "HY000"; STR_ERROR[-OB_MINOR_MERGE_NOT_ALLOW] = "minor merge not allow"; @@ -2062,6 +2527,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_MINOR_MERGE_NOT_ALLOW] = "ORA-00600: internal error code, arguments: -4266, minor merge not allow"; ERROR_NAME[-OB_CACHE_INVALID] = "OB_CACHE_INVALID"; + ERROR_CAUSE[-OB_CACHE_INVALID] = "Internal Error"; + ERROR_SOLUTION[-OB_CACHE_INVALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CACHE_INVALID] = -1; SQLSTATE[-OB_CACHE_INVALID] = "HY000"; STR_ERROR[-OB_CACHE_INVALID] = "Cache invalid"; @@ -2070,6 +2537,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_CACHE_INVALID] = "ORA-00600: internal error code, arguments: -4267, Cache invalid"; ORACLE_STR_USER_ERROR[-OB_CACHE_INVALID] = "ORA-00600: internal error code, arguments: -4267, Cache invalid"; ERROR_NAME[-OB_REACH_SERVER_DATA_COPY_IN_CONCURRENCY_LIMIT] = "OB_REACH_SERVER_DATA_COPY_IN_CONCURRENCY_LIMIT"; + ERROR_CAUSE[-OB_REACH_SERVER_DATA_COPY_IN_CONCURRENCY_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_REACH_SERVER_DATA_COPY_IN_CONCURRENCY_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_REACH_SERVER_DATA_COPY_IN_CONCURRENCY_LIMIT] = -1; SQLSTATE[-OB_REACH_SERVER_DATA_COPY_IN_CONCURRENCY_LIMIT] = "HY000"; STR_ERROR[-OB_REACH_SERVER_DATA_COPY_IN_CONCURRENCY_LIMIT] = "reach server data copy in concurrency"; @@ -2080,6 +2549,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_REACH_SERVER_DATA_COPY_IN_CONCURRENCY_LIMIT] = "ORA-00600: internal error code, arguments: -4268, reach server data copy in concurrency"; ERROR_NAME[-OB_WORKING_PARTITION_EXIST] = "OB_WORKING_PARTITION_EXIST"; + ERROR_CAUSE[-OB_WORKING_PARTITION_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_WORKING_PARTITION_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WORKING_PARTITION_EXIST] = -1; SQLSTATE[-OB_WORKING_PARTITION_EXIST] = "HY000"; STR_ERROR[-OB_WORKING_PARTITION_EXIST] = "Working partition entry already exists"; @@ -2090,6 +2561,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_WORKING_PARTITION_EXIST] = "ORA-00600: internal error code, arguments: -4269, Working partition entry already exists"; ERROR_NAME[-OB_WORKING_PARTITION_NOT_EXIST] = "OB_WORKING_PARTITION_NOT_EXIST"; + ERROR_CAUSE[-OB_WORKING_PARTITION_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_WORKING_PARTITION_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WORKING_PARTITION_NOT_EXIST] = -1; SQLSTATE[-OB_WORKING_PARTITION_NOT_EXIST] = "HY000"; STR_ERROR[-OB_WORKING_PARTITION_NOT_EXIST] = "Working partition entry does not exists"; @@ -2100,6 +2573,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_WORKING_PARTITION_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4270, Working partition entry does not exists"; ERROR_NAME[-OB_LIBEASY_REACH_MEM_LIMIT] = "OB_LIBEASY_REACH_MEM_LIMIT"; + ERROR_CAUSE[-OB_LIBEASY_REACH_MEM_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_LIBEASY_REACH_MEM_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LIBEASY_REACH_MEM_LIMIT] = -1; SQLSTATE[-OB_LIBEASY_REACH_MEM_LIMIT] = "HY000"; STR_ERROR[-OB_LIBEASY_REACH_MEM_LIMIT] = "LIBEASY reach memory limit"; @@ -2110,6 +2585,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LIBEASY_REACH_MEM_LIMIT] = "ORA-00600: internal error code, arguments: -4271, LIBEASY reach memory limit"; ERROR_NAME[-OB_CACHE_FREE_BLOCK_NOT_ENOUGH] = "OB_CACHE_FREE_BLOCK_NOT_ENOUGH"; + ERROR_CAUSE[-OB_CACHE_FREE_BLOCK_NOT_ENOUGH] = "Internal Error"; + ERROR_SOLUTION[-OB_CACHE_FREE_BLOCK_NOT_ENOUGH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CACHE_FREE_BLOCK_NOT_ENOUGH] = -1; SQLSTATE[-OB_CACHE_FREE_BLOCK_NOT_ENOUGH] = "HY000"; STR_ERROR[-OB_CACHE_FREE_BLOCK_NOT_ENOUGH] = "free memblock in cache is not enough"; @@ -2120,6 +2597,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CACHE_FREE_BLOCK_NOT_ENOUGH] = "ORA-00600: internal error code, arguments: -4273, free memblock in cache is not enough"; ERROR_NAME[-OB_SYNC_WASH_MB_TIMEOUT] = "OB_SYNC_WASH_MB_TIMEOUT"; + ERROR_CAUSE[-OB_SYNC_WASH_MB_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_SYNC_WASH_MB_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SYNC_WASH_MB_TIMEOUT] = -1; SQLSTATE[-OB_SYNC_WASH_MB_TIMEOUT] = "HY000"; STR_ERROR[-OB_SYNC_WASH_MB_TIMEOUT] = "sync wash memblock timeout"; @@ -2130,6 +2609,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SYNC_WASH_MB_TIMEOUT] = "ORA-00600: internal error code, arguments: -4274, sync wash memblock timeout"; ERROR_NAME[-OB_NOT_ALLOW_MIGRATE_IN] = "OB_NOT_ALLOW_MIGRATE_IN"; + ERROR_CAUSE[-OB_NOT_ALLOW_MIGRATE_IN] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_ALLOW_MIGRATE_IN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_ALLOW_MIGRATE_IN] = -1; SQLSTATE[-OB_NOT_ALLOW_MIGRATE_IN] = "HY000"; STR_ERROR[-OB_NOT_ALLOW_MIGRATE_IN] = "not allow migrate in"; @@ -2140,6 +2621,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NOT_ALLOW_MIGRATE_IN] = "ORA-00600: internal error code, arguments: -4275, not allow migrate in"; ERROR_NAME[-OB_SCHEDULER_TASK_CNT_MISTACH] = "OB_SCHEDULER_TASK_CNT_MISTACH"; + ERROR_CAUSE[-OB_SCHEDULER_TASK_CNT_MISTACH] = "Internal Error"; + ERROR_SOLUTION[-OB_SCHEDULER_TASK_CNT_MISTACH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SCHEDULER_TASK_CNT_MISTACH] = -1; SQLSTATE[-OB_SCHEDULER_TASK_CNT_MISTACH] = "HY000"; STR_ERROR[-OB_SCHEDULER_TASK_CNT_MISTACH] = "Scheduler task cnt does not match"; @@ -2150,6 +2633,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SCHEDULER_TASK_CNT_MISTACH] = "ORA-00600: internal error code, arguments: -4276, Scheduler task cnt does not match"; ERROR_NAME[-OB_MISS_ARGUMENT] = "OB_MISS_ARGUMENT"; + ERROR_CAUSE[-OB_MISS_ARGUMENT] = "Internal Error"; + ERROR_SOLUTION[-OB_MISS_ARGUMENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_MISS_ARGUMENT] = ER_WRONG_ARGUMENTS; SQLSTATE[-OB_MISS_ARGUMENT] = "HY000"; STR_ERROR[-OB_MISS_ARGUMENT] = "Miss argument"; @@ -2158,6 +2643,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_MISS_ARGUMENT] = "ORA-00600: internal error code, arguments: -4277, Miss argument"; ORACLE_STR_USER_ERROR[-OB_MISS_ARGUMENT] = "ORA-00600: internal error code, arguments: -4277, Miss argument for %s"; ERROR_NAME[-OB_LAST_LOG_NOT_COMPLETE] = "OB_LAST_LOG_NOT_COMPLETE"; + ERROR_CAUSE[-OB_LAST_LOG_NOT_COMPLETE] = "Internal Error"; + ERROR_SOLUTION[-OB_LAST_LOG_NOT_COMPLETE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LAST_LOG_NOT_COMPLETE] = -1; SQLSTATE[-OB_LAST_LOG_NOT_COMPLETE] = "HY000"; STR_ERROR[-OB_LAST_LOG_NOT_COMPLETE] = "last log is not complete"; @@ -2168,6 +2655,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LAST_LOG_NOT_COMPLETE] = "ORA-00600: internal error code, arguments: -4278, last log is not complete"; ERROR_NAME[-OB_TABLE_IS_DELETED] = "OB_TABLE_IS_DELETED"; + ERROR_CAUSE[-OB_TABLE_IS_DELETED] = "Internal Error"; + ERROR_SOLUTION[-OB_TABLE_IS_DELETED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TABLE_IS_DELETED] = -1; SQLSTATE[-OB_TABLE_IS_DELETED] = "HY000"; STR_ERROR[-OB_TABLE_IS_DELETED] = "table is deleted"; @@ -2176,6 +2665,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TABLE_IS_DELETED] = "ORA-00600: internal error code, arguments: -4279, table is deleted"; ORACLE_STR_USER_ERROR[-OB_TABLE_IS_DELETED] = "ORA-00600: internal error code, arguments: -4279, table is deleted"; ERROR_NAME[-OB_VERSION_RANGE_NOT_CONTINUES] = "OB_VERSION_RANGE_NOT_CONTINUES"; + ERROR_CAUSE[-OB_VERSION_RANGE_NOT_CONTINUES] = "Internal Error"; + ERROR_SOLUTION[-OB_VERSION_RANGE_NOT_CONTINUES] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_VERSION_RANGE_NOT_CONTINUES] = -1; SQLSTATE[-OB_VERSION_RANGE_NOT_CONTINUES] = "HY000"; STR_ERROR[-OB_VERSION_RANGE_NOT_CONTINUES] = "version range not continues"; @@ -2186,6 +2677,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_VERSION_RANGE_NOT_CONTINUES] = "ORA-00600: internal error code, arguments: -4280, version range not continues"; ERROR_NAME[-OB_INVALID_IO_BUFFER] = "OB_INVALID_IO_BUFFER"; + ERROR_CAUSE[-OB_INVALID_IO_BUFFER] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_IO_BUFFER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_IO_BUFFER] = -1; SQLSTATE[-OB_INVALID_IO_BUFFER] = "HY000"; STR_ERROR[-OB_INVALID_IO_BUFFER] = "io buffer is invalid"; @@ -2195,6 +2688,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_IO_BUFFER] = "ORA-00600: internal error code, arguments: -4281, io buffer is invalid"; ERROR_NAME[-OB_PARTITION_IS_REMOVED] = "OB_PARTITION_IS_REMOVED"; + ERROR_CAUSE[-OB_PARTITION_IS_REMOVED] = "Internal Error"; + ERROR_SOLUTION[-OB_PARTITION_IS_REMOVED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PARTITION_IS_REMOVED] = -1; SQLSTATE[-OB_PARTITION_IS_REMOVED] = "HY000"; STR_ERROR[-OB_PARTITION_IS_REMOVED] = "partition is removed"; @@ -2205,6 +2700,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PARTITION_IS_REMOVED] = "ORA-00600: internal error code, arguments: -4282, partition is removed"; ERROR_NAME[-OB_GTS_NOT_READY] = "OB_GTS_NOT_READY"; + ERROR_CAUSE[-OB_GTS_NOT_READY] = "Internal Error"; + ERROR_SOLUTION[-OB_GTS_NOT_READY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_GTS_NOT_READY] = -1; SQLSTATE[-OB_GTS_NOT_READY] = "HY000"; STR_ERROR[-OB_GTS_NOT_READY] = "gts is not ready"; @@ -2213,6 +2710,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_GTS_NOT_READY] = "ORA-00600: internal error code, arguments: -4283, gts is not ready"; ORACLE_STR_USER_ERROR[-OB_GTS_NOT_READY] = "ORA-00600: internal error code, arguments: -4283, gts is not ready"; ERROR_NAME[-OB_MAJOR_SSTABLE_NOT_EXIST] = "OB_MAJOR_SSTABLE_NOT_EXIST"; + ERROR_CAUSE[-OB_MAJOR_SSTABLE_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_MAJOR_SSTABLE_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_MAJOR_SSTABLE_NOT_EXIST] = -1; SQLSTATE[-OB_MAJOR_SSTABLE_NOT_EXIST] = "HY000"; STR_ERROR[-OB_MAJOR_SSTABLE_NOT_EXIST] = "major sstable not exist"; @@ -2223,6 +2722,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_MAJOR_SSTABLE_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4284, major sstable not exist"; ERROR_NAME[-OB_VERSION_RANGE_DISCARDED] = "OB_VERSION_RANGE_DISCARDED"; + ERROR_CAUSE[-OB_VERSION_RANGE_DISCARDED] = "Internal Error"; + ERROR_SOLUTION[-OB_VERSION_RANGE_DISCARDED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_VERSION_RANGE_DISCARDED] = -1; SQLSTATE[-OB_VERSION_RANGE_DISCARDED] = "HY000"; STR_ERROR[-OB_VERSION_RANGE_DISCARDED] = "Request to read too old version range data"; @@ -2233,6 +2734,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_VERSION_RANGE_DISCARDED] = "ORA-00600: internal error code, arguments: -4285, Request to read too old version range data"; ERROR_NAME[-OB_MAJOR_SSTABLE_HAS_MERGED] = "OB_MAJOR_SSTABLE_HAS_MERGED"; + ERROR_CAUSE[-OB_MAJOR_SSTABLE_HAS_MERGED] = "Internal Error"; + ERROR_SOLUTION[-OB_MAJOR_SSTABLE_HAS_MERGED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_MAJOR_SSTABLE_HAS_MERGED] = -1; SQLSTATE[-OB_MAJOR_SSTABLE_HAS_MERGED] = "HY000"; STR_ERROR[-OB_MAJOR_SSTABLE_HAS_MERGED] = "major sstable may has been merged"; @@ -2243,6 +2746,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_MAJOR_SSTABLE_HAS_MERGED] = "ORA-00600: internal error code, arguments: -4286, major sstable may has been merged"; ERROR_NAME[-OB_MINOR_SSTABLE_RANGE_CROSS] = "OB_MINOR_SSTABLE_RANGE_CROSS"; + ERROR_CAUSE[-OB_MINOR_SSTABLE_RANGE_CROSS] = "Internal Error"; + ERROR_SOLUTION[-OB_MINOR_SSTABLE_RANGE_CROSS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_MINOR_SSTABLE_RANGE_CROSS] = -1; SQLSTATE[-OB_MINOR_SSTABLE_RANGE_CROSS] = "HY000"; STR_ERROR[-OB_MINOR_SSTABLE_RANGE_CROSS] = "minor sstable version range cross"; @@ -2253,6 +2758,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_MINOR_SSTABLE_RANGE_CROSS] = "ORA-00600: internal error code, arguments: -4287, minor sstable version range cross"; ERROR_NAME[-OB_MEMTABLE_CANNOT_MINOR_MERGE] = "OB_MEMTABLE_CANNOT_MINOR_MERGE"; + ERROR_CAUSE[-OB_MEMTABLE_CANNOT_MINOR_MERGE] = "Internal Error"; + ERROR_SOLUTION[-OB_MEMTABLE_CANNOT_MINOR_MERGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_MEMTABLE_CANNOT_MINOR_MERGE] = -1; SQLSTATE[-OB_MEMTABLE_CANNOT_MINOR_MERGE] = "HY000"; STR_ERROR[-OB_MEMTABLE_CANNOT_MINOR_MERGE] = "memtable cannot minor merge"; @@ -2263,6 +2770,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_MEMTABLE_CANNOT_MINOR_MERGE] = "ORA-00600: internal error code, arguments: -4288, memtable cannot minor merge"; ERROR_NAME[-OB_TASK_EXIST] = "OB_TASK_EXIST"; + ERROR_CAUSE[-OB_TASK_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_TASK_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TASK_EXIST] = -1; SQLSTATE[-OB_TASK_EXIST] = "HY000"; STR_ERROR[-OB_TASK_EXIST] = "task exist"; @@ -2271,6 +2780,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TASK_EXIST] = "ORA-00600: internal error code, arguments: -4289, task exist"; ORACLE_STR_USER_ERROR[-OB_TASK_EXIST] = "ORA-00600: internal error code, arguments: -4289, task exist"; ERROR_NAME[-OB_ALLOCATE_DISK_SPACE_FAILED] = "OB_ALLOCATE_DISK_SPACE_FAILED"; + ERROR_CAUSE[-OB_ALLOCATE_DISK_SPACE_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_ALLOCATE_DISK_SPACE_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ALLOCATE_DISK_SPACE_FAILED] = -1; SQLSTATE[-OB_ALLOCATE_DISK_SPACE_FAILED] = "HY000"; STR_ERROR[-OB_ALLOCATE_DISK_SPACE_FAILED] = "cannot allocate disk space"; @@ -2281,6 +2792,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ALLOCATE_DISK_SPACE_FAILED] = "ORA-00600: internal error code, arguments: -4290, cannot allocate disk space"; ERROR_NAME[-OB_CANT_FIND_UDF] = "OB_CANT_FIND_UDF"; + ERROR_CAUSE[-OB_CANT_FIND_UDF] = "Internal Error"; + ERROR_SOLUTION[-OB_CANT_FIND_UDF] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANT_FIND_UDF] = ER_CANT_FIND_UDF; SQLSTATE[-OB_CANT_FIND_UDF] = "HY000"; STR_ERROR[-OB_CANT_FIND_UDF] = "Can't load function"; @@ -2290,6 +2803,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CANT_FIND_UDF] = "ORA-00600: internal error code, arguments: -4291, Can not load function %s"; ERROR_NAME[-OB_CANT_INITIALIZE_UDF] = "OB_CANT_INITIALIZE_UDF"; + ERROR_CAUSE[-OB_CANT_INITIALIZE_UDF] = "Internal Error"; + ERROR_SOLUTION[-OB_CANT_INITIALIZE_UDF] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANT_INITIALIZE_UDF] = ER_CANT_INITIALIZE_UDF; SQLSTATE[-OB_CANT_INITIALIZE_UDF] = "HY000"; STR_ERROR[-OB_CANT_INITIALIZE_UDF] = "Can't initialize function"; @@ -2300,6 +2815,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CANT_INITIALIZE_UDF] = "ORA-00600: internal error code, arguments: -4292, Can not initialize function '%.*s'"; ERROR_NAME[-OB_UDF_NO_PATHS] = "OB_UDF_NO_PATHS"; + ERROR_CAUSE[-OB_UDF_NO_PATHS] = "Internal Error"; + ERROR_SOLUTION[-OB_UDF_NO_PATHS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_UDF_NO_PATHS] = ER_UDF_NO_PATHS; SQLSTATE[-OB_UDF_NO_PATHS] = "HY000"; STR_ERROR[-OB_UDF_NO_PATHS] = "No paths allowed for shared library"; @@ -2310,6 +2827,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_UDF_NO_PATHS] = "ORA-00600: internal error code, arguments: -4293, No paths allowed for shared library"; ERROR_NAME[-OB_UDF_EXISTS] = "OB_UDF_EXISTS"; + ERROR_CAUSE[-OB_UDF_EXISTS] = "Internal Error"; + ERROR_SOLUTION[-OB_UDF_EXISTS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_UDF_EXISTS] = ER_UDF_EXISTS; SQLSTATE[-OB_UDF_EXISTS] = "HY000"; STR_ERROR[-OB_UDF_EXISTS] = "Function already exists"; @@ -2319,6 +2838,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_UDF_EXISTS] = "ORA-00600: internal error code, arguments: -4294, Function %.*s already exists"; ERROR_NAME[-OB_CANT_OPEN_LIBRARY] = "OB_CANT_OPEN_LIBRARY"; + ERROR_CAUSE[-OB_CANT_OPEN_LIBRARY] = "Internal Error"; + ERROR_SOLUTION[-OB_CANT_OPEN_LIBRARY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANT_OPEN_LIBRARY] = ER_CANT_OPEN_LIBRARY; SQLSTATE[-OB_CANT_OPEN_LIBRARY] = "HY000"; STR_ERROR[-OB_CANT_OPEN_LIBRARY] = "Can't open shared library"; @@ -2329,6 +2850,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CANT_OPEN_LIBRARY] = "ORA-00600: internal error code, arguments: -4295, Can not open shared library '%.*s'"; ERROR_NAME[-OB_CANT_FIND_DL_ENTRY] = "OB_CANT_FIND_DL_ENTRY"; + ERROR_CAUSE[-OB_CANT_FIND_DL_ENTRY] = "Internal Error"; + ERROR_SOLUTION[-OB_CANT_FIND_DL_ENTRY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANT_FIND_DL_ENTRY] = ER_CANT_FIND_DL_ENTRY; SQLSTATE[-OB_CANT_FIND_DL_ENTRY] = "HY000"; STR_ERROR[-OB_CANT_FIND_DL_ENTRY] = "Can't find symbol"; @@ -2338,6 +2861,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CANT_FIND_DL_ENTRY] = "ORA-00600: internal error code, arguments: -4296, Can't find symbol %.*s in library"; ERROR_NAME[-OB_OBJECT_NAME_EXIST] = "OB_OBJECT_NAME_EXIST"; + ERROR_CAUSE[-OB_OBJECT_NAME_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_OBJECT_NAME_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OBJECT_NAME_EXIST] = -1; SQLSTATE[-OB_OBJECT_NAME_EXIST] = "HY000"; STR_ERROR[-OB_OBJECT_NAME_EXIST] = "name is already used by an existing object"; @@ -2348,6 +2873,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_OBJECT_NAME_EXIST] = "ORA-00600: internal error code, arguments: -4297, name is already used by an existing object"; ERROR_NAME[-OB_OBJECT_NAME_NOT_EXIST] = "OB_OBJECT_NAME_NOT_EXIST"; + ERROR_CAUSE[-OB_OBJECT_NAME_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_OBJECT_NAME_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OBJECT_NAME_NOT_EXIST] = -1; SQLSTATE[-OB_OBJECT_NAME_NOT_EXIST] = "HY000"; STR_ERROR[-OB_OBJECT_NAME_NOT_EXIST] = "object does not exist"; @@ -2356,6 +2883,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_OBJECT_NAME_NOT_EXIST] = "ORA-02289: object does not exist"; ORACLE_STR_USER_ERROR[-OB_OBJECT_NAME_NOT_EXIST] = "ORA-02289: %s does not exist"; ERROR_NAME[-OB_ERR_DUP_ARGUMENT] = "OB_ERR_DUP_ARGUMENT"; + ERROR_CAUSE[-OB_ERR_DUP_ARGUMENT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DUP_ARGUMENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DUP_ARGUMENT] = ER_DUP_ARGUMENT; SQLSTATE[-OB_ERR_DUP_ARGUMENT] = "HY000"; STR_ERROR[-OB_ERR_DUP_ARGUMENT] = "Option used twice in statement"; @@ -2366,6 +2895,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DUP_ARGUMENT] = "ORA-00600: internal error code, arguments: -4299, Option '%s' used twice in statement"; ERROR_NAME[-OB_ERR_INVALID_SEQUENCE_NAME] = "OB_ERR_INVALID_SEQUENCE_NAME"; + ERROR_CAUSE[-OB_ERR_INVALID_SEQUENCE_NAME] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_SEQUENCE_NAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_SEQUENCE_NAME] = -1; SQLSTATE[-OB_ERR_INVALID_SEQUENCE_NAME] = "HY000"; STR_ERROR[-OB_ERR_INVALID_SEQUENCE_NAME] = "invalid sequence name"; @@ -2374,6 +2905,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_SEQUENCE_NAME] = "ORA-02277: invalid sequence name"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_SEQUENCE_NAME] = "ORA-02277: invalid sequence name"; ERROR_NAME[-OB_ERR_DUP_MAXVALUE_SPEC] = "OB_ERR_DUP_MAXVALUE_SPEC"; + ERROR_CAUSE[-OB_ERR_DUP_MAXVALUE_SPEC] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DUP_MAXVALUE_SPEC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DUP_MAXVALUE_SPEC] = -1; SQLSTATE[-OB_ERR_DUP_MAXVALUE_SPEC] = "HY000"; STR_ERROR[-OB_ERR_DUP_MAXVALUE_SPEC] = "duplicate MAXVALUE/NOMAXVALUE specifications"; @@ -2382,6 +2915,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DUP_MAXVALUE_SPEC] = "ORA-02278: duplicate MAXVALUE/NOMAXVALUE specifications"; ORACLE_STR_USER_ERROR[-OB_ERR_DUP_MAXVALUE_SPEC] = "ORA-02278: duplicate MAXVALUE/NOMAXVALUE specifications"; ERROR_NAME[-OB_ERR_DUP_MINVALUE_SPEC] = "OB_ERR_DUP_MINVALUE_SPEC"; + ERROR_CAUSE[-OB_ERR_DUP_MINVALUE_SPEC] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DUP_MINVALUE_SPEC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DUP_MINVALUE_SPEC] = -1; SQLSTATE[-OB_ERR_DUP_MINVALUE_SPEC] = "HY000"; STR_ERROR[-OB_ERR_DUP_MINVALUE_SPEC] = "duplicate MINVALUE/NOMINVALUE specifications"; @@ -2390,6 +2925,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DUP_MINVALUE_SPEC] = "ORA-02279: duplicate MINVALUE/NOMINVALUE specifications"; ORACLE_STR_USER_ERROR[-OB_ERR_DUP_MINVALUE_SPEC] = "ORA-02279: duplicate MINVALUE/NOMINVALUE specifications"; ERROR_NAME[-OB_ERR_DUP_CYCLE_SPEC] = "OB_ERR_DUP_CYCLE_SPEC"; + ERROR_CAUSE[-OB_ERR_DUP_CYCLE_SPEC] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DUP_CYCLE_SPEC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DUP_CYCLE_SPEC] = -1; SQLSTATE[-OB_ERR_DUP_CYCLE_SPEC] = "HY000"; STR_ERROR[-OB_ERR_DUP_CYCLE_SPEC] = "duplicate CYCLE/NOCYCLE specifications"; @@ -2398,6 +2935,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DUP_CYCLE_SPEC] = "ORA-02280: duplicate CYCLE/NOCYCLE specifications"; ORACLE_STR_USER_ERROR[-OB_ERR_DUP_CYCLE_SPEC] = "ORA-02280: duplicate CYCLE/NOCYCLE specifications"; ERROR_NAME[-OB_ERR_DUP_CACHE_SPEC] = "OB_ERR_DUP_CACHE_SPEC"; + ERROR_CAUSE[-OB_ERR_DUP_CACHE_SPEC] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DUP_CACHE_SPEC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DUP_CACHE_SPEC] = -1; SQLSTATE[-OB_ERR_DUP_CACHE_SPEC] = "HY000"; STR_ERROR[-OB_ERR_DUP_CACHE_SPEC] = "duplicate CACHE/NOCACHE specifications"; @@ -2406,6 +2945,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DUP_CACHE_SPEC] = "ORA-02281: duplicate CACHE/NOCACHE specifications"; ORACLE_STR_USER_ERROR[-OB_ERR_DUP_CACHE_SPEC] = "ORA-02281: duplicate CACHE/NOCACHE specifications"; ERROR_NAME[-OB_ERR_DUP_ORDER_SPEC] = "OB_ERR_DUP_ORDER_SPEC"; + ERROR_CAUSE[-OB_ERR_DUP_ORDER_SPEC] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DUP_ORDER_SPEC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DUP_ORDER_SPEC] = -1; SQLSTATE[-OB_ERR_DUP_ORDER_SPEC] = "HY000"; STR_ERROR[-OB_ERR_DUP_ORDER_SPEC] = "duplicate ORDER/NOORDER specifications"; @@ -2414,6 +2955,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DUP_ORDER_SPEC] = "ORA-02282: duplicate ORDER/NOORDER specifications"; ORACLE_STR_USER_ERROR[-OB_ERR_DUP_ORDER_SPEC] = "ORA-02282: duplicate ORDER/NOORDER specifications"; ERROR_NAME[-OB_ERR_CONFL_MAXVALUE_SPEC] = "OB_ERR_CONFL_MAXVALUE_SPEC"; + ERROR_CAUSE[-OB_ERR_CONFL_MAXVALUE_SPEC] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CONFL_MAXVALUE_SPEC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CONFL_MAXVALUE_SPEC] = -1; SQLSTATE[-OB_ERR_CONFL_MAXVALUE_SPEC] = "HY000"; STR_ERROR[-OB_ERR_CONFL_MAXVALUE_SPEC] = "conflicting MAXVALUE/NOMAXVALUE specifications"; @@ -2422,6 +2965,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CONFL_MAXVALUE_SPEC] = "ORA-02278: conflicting MAXVALUE/NOMAXVALUE specifications"; ORACLE_STR_USER_ERROR[-OB_ERR_CONFL_MAXVALUE_SPEC] = "ORA-02278: conflicting MAXVALUE/NOMAXVALUE specifications"; ERROR_NAME[-OB_ERR_CONFL_MINVALUE_SPEC] = "OB_ERR_CONFL_MINVALUE_SPEC"; + ERROR_CAUSE[-OB_ERR_CONFL_MINVALUE_SPEC] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CONFL_MINVALUE_SPEC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CONFL_MINVALUE_SPEC] = -1; SQLSTATE[-OB_ERR_CONFL_MINVALUE_SPEC] = "HY000"; STR_ERROR[-OB_ERR_CONFL_MINVALUE_SPEC] = "conflicting MINVALUE/NOMINVALUE specifications"; @@ -2430,6 +2975,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CONFL_MINVALUE_SPEC] = "ORA-02279: conflicting MINVALUE/NOMINVALUE specifications"; ORACLE_STR_USER_ERROR[-OB_ERR_CONFL_MINVALUE_SPEC] = "ORA-02279: conflicting MINVALUE/NOMINVALUE specifications"; ERROR_NAME[-OB_ERR_CONFL_CYCLE_SPEC] = "OB_ERR_CONFL_CYCLE_SPEC"; + ERROR_CAUSE[-OB_ERR_CONFL_CYCLE_SPEC] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CONFL_CYCLE_SPEC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CONFL_CYCLE_SPEC] = -1; SQLSTATE[-OB_ERR_CONFL_CYCLE_SPEC] = "HY000"; STR_ERROR[-OB_ERR_CONFL_CYCLE_SPEC] = "conflicting CYCLE/NOCYCLE specifications"; @@ -2438,6 +2985,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CONFL_CYCLE_SPEC] = "ORA-02280: conflicting CYCLE/NOCYCLE specifications"; ORACLE_STR_USER_ERROR[-OB_ERR_CONFL_CYCLE_SPEC] = "ORA-02280: conflicting CYCLE/NOCYCLE specifications"; ERROR_NAME[-OB_ERR_CONFL_CACHE_SPEC] = "OB_ERR_CONFL_CACHE_SPEC"; + ERROR_CAUSE[-OB_ERR_CONFL_CACHE_SPEC] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CONFL_CACHE_SPEC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CONFL_CACHE_SPEC] = -1; SQLSTATE[-OB_ERR_CONFL_CACHE_SPEC] = "HY000"; STR_ERROR[-OB_ERR_CONFL_CACHE_SPEC] = "conflicting CACHE/NOCACHE specifications"; @@ -2446,6 +2995,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CONFL_CACHE_SPEC] = "ORA-02281: conflicting CACHE/NOCACHE specifications"; ORACLE_STR_USER_ERROR[-OB_ERR_CONFL_CACHE_SPEC] = "ORA-02281: conflicting CACHE/NOCACHE specifications"; ERROR_NAME[-OB_ERR_CONFL_ORDER_SPEC] = "OB_ERR_CONFL_ORDER_SPEC"; + ERROR_CAUSE[-OB_ERR_CONFL_ORDER_SPEC] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CONFL_ORDER_SPEC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CONFL_ORDER_SPEC] = -1; SQLSTATE[-OB_ERR_CONFL_ORDER_SPEC] = "HY000"; STR_ERROR[-OB_ERR_CONFL_ORDER_SPEC] = "conflicting ORDER/NOORDER specifications"; @@ -2454,6 +3005,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CONFL_ORDER_SPEC] = "ORA-02282: conflicting ORDER/NOORDER specifications"; ORACLE_STR_USER_ERROR[-OB_ERR_CONFL_ORDER_SPEC] = "ORA-02282: conflicting ORDER/NOORDER specifications"; ERROR_NAME[-OB_ERR_ALTER_START_SEQ_NUMBER_NOT_ALLOWED] = "OB_ERR_ALTER_START_SEQ_NUMBER_NOT_ALLOWED"; + ERROR_CAUSE[-OB_ERR_ALTER_START_SEQ_NUMBER_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ALTER_START_SEQ_NUMBER_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ALTER_START_SEQ_NUMBER_NOT_ALLOWED] = -1; SQLSTATE[-OB_ERR_ALTER_START_SEQ_NUMBER_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_ERR_ALTER_START_SEQ_NUMBER_NOT_ALLOWED] = "cannot alter starting sequence number"; @@ -2463,6 +3016,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ALTER_START_SEQ_NUMBER_NOT_ALLOWED] = "ORA-02283: cannot alter starting sequence number"; ERROR_NAME[-OB_ERR_DUP_INCREMENT_BY_SPEC] = "OB_ERR_DUP_INCREMENT_BY_SPEC"; + ERROR_CAUSE[-OB_ERR_DUP_INCREMENT_BY_SPEC] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DUP_INCREMENT_BY_SPEC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DUP_INCREMENT_BY_SPEC] = -1; SQLSTATE[-OB_ERR_DUP_INCREMENT_BY_SPEC] = "HY000"; STR_ERROR[-OB_ERR_DUP_INCREMENT_BY_SPEC] = "duplicate INCREMENT BY specifications"; @@ -2471,6 +3026,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DUP_INCREMENT_BY_SPEC] = "ORA-02284: duplicate INCREMENT BY specifications"; ORACLE_STR_USER_ERROR[-OB_ERR_DUP_INCREMENT_BY_SPEC] = "ORA-02284: duplicate INCREMENT BY specifications"; ERROR_NAME[-OB_ERR_DUP_START_WITH_SPEC] = "OB_ERR_DUP_START_WITH_SPEC"; + ERROR_CAUSE[-OB_ERR_DUP_START_WITH_SPEC] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DUP_START_WITH_SPEC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DUP_START_WITH_SPEC] = -1; SQLSTATE[-OB_ERR_DUP_START_WITH_SPEC] = "HY000"; STR_ERROR[-OB_ERR_DUP_START_WITH_SPEC] = "duplicate START WITH specifications"; @@ -2479,6 +3036,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DUP_START_WITH_SPEC] = "ORA-02285: duplicate START WITH specifications"; ORACLE_STR_USER_ERROR[-OB_ERR_DUP_START_WITH_SPEC] = "ORA-02285: duplicate START WITH specifications"; ERROR_NAME[-OB_ERR_REQUIRE_ALTER_SEQ_OPTION] = "OB_ERR_REQUIRE_ALTER_SEQ_OPTION"; + ERROR_CAUSE[-OB_ERR_REQUIRE_ALTER_SEQ_OPTION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REQUIRE_ALTER_SEQ_OPTION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REQUIRE_ALTER_SEQ_OPTION] = -1; SQLSTATE[-OB_ERR_REQUIRE_ALTER_SEQ_OPTION] = "HY000"; STR_ERROR[-OB_ERR_REQUIRE_ALTER_SEQ_OPTION] = "no options specified for ALTER SEQUENCE"; @@ -2487,6 +3046,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_REQUIRE_ALTER_SEQ_OPTION] = "ORA-02286: no options specified for ALTER SEQUENCE"; ORACLE_STR_USER_ERROR[-OB_ERR_REQUIRE_ALTER_SEQ_OPTION] = "ORA-02286: no options specified for ALTER SEQUENCE"; ERROR_NAME[-OB_ERR_SEQ_NOT_ALLOWED_HERE] = "OB_ERR_SEQ_NOT_ALLOWED_HERE"; + ERROR_CAUSE[-OB_ERR_SEQ_NOT_ALLOWED_HERE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SEQ_NOT_ALLOWED_HERE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SEQ_NOT_ALLOWED_HERE] = -1; SQLSTATE[-OB_ERR_SEQ_NOT_ALLOWED_HERE] = "HY000"; STR_ERROR[-OB_ERR_SEQ_NOT_ALLOWED_HERE] = "sequence number not allowed here"; @@ -2495,6 +3056,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SEQ_NOT_ALLOWED_HERE] = "ORA-02287: sequence number not allowed here"; ORACLE_STR_USER_ERROR[-OB_ERR_SEQ_NOT_ALLOWED_HERE] = "ORA-02287: sequence number not allowed here"; ERROR_NAME[-OB_ERR_SEQ_NOT_EXIST] = "OB_ERR_SEQ_NOT_EXIST"; + ERROR_CAUSE[-OB_ERR_SEQ_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SEQ_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SEQ_NOT_EXIST] = -1; SQLSTATE[-OB_ERR_SEQ_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_SEQ_NOT_EXIST] = "sequence does not exist"; @@ -2503,6 +3066,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SEQ_NOT_EXIST] = "ORA-02289: sequence does not exist"; ORACLE_STR_USER_ERROR[-OB_ERR_SEQ_NOT_EXIST] = "ORA-02289: sequence does not exist"; ERROR_NAME[-OB_ERR_SEQ_OPTION_MUST_BE_INTEGER] = "OB_ERR_SEQ_OPTION_MUST_BE_INTEGER"; + ERROR_CAUSE[-OB_ERR_SEQ_OPTION_MUST_BE_INTEGER] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SEQ_OPTION_MUST_BE_INTEGER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SEQ_OPTION_MUST_BE_INTEGER] = -1; SQLSTATE[-OB_ERR_SEQ_OPTION_MUST_BE_INTEGER] = "HY000"; STR_ERROR[-OB_ERR_SEQ_OPTION_MUST_BE_INTEGER] = "sequence parameter must be an integer"; @@ -2511,6 +3076,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SEQ_OPTION_MUST_BE_INTEGER] = "ORA-04001: sequence parameter must be an integer"; ORACLE_STR_USER_ERROR[-OB_ERR_SEQ_OPTION_MUST_BE_INTEGER] = "ORA-04001: sequence parameter %s must be an integer"; ERROR_NAME[-OB_ERR_SEQ_INCREMENT_CAN_NOT_BE_ZERO] = "OB_ERR_SEQ_INCREMENT_CAN_NOT_BE_ZERO"; + ERROR_CAUSE[-OB_ERR_SEQ_INCREMENT_CAN_NOT_BE_ZERO] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SEQ_INCREMENT_CAN_NOT_BE_ZERO] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SEQ_INCREMENT_CAN_NOT_BE_ZERO] = -1; SQLSTATE[-OB_ERR_SEQ_INCREMENT_CAN_NOT_BE_ZERO] = "HY000"; STR_ERROR[-OB_ERR_SEQ_INCREMENT_CAN_NOT_BE_ZERO] = "INCREMENT must be a nonzero integer"; @@ -2519,6 +3086,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SEQ_INCREMENT_CAN_NOT_BE_ZERO] = "ORA-04002: INCREMENT must be a nonzero integer"; ORACLE_STR_USER_ERROR[-OB_ERR_SEQ_INCREMENT_CAN_NOT_BE_ZERO] = "ORA-04002: INCREMENT must be a nonzero integer"; ERROR_NAME[-OB_ERR_SEQ_OPTION_EXCEED_RANGE] = "OB_ERR_SEQ_OPTION_EXCEED_RANGE"; + ERROR_CAUSE[-OB_ERR_SEQ_OPTION_EXCEED_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SEQ_OPTION_EXCEED_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SEQ_OPTION_EXCEED_RANGE] = -1; SQLSTATE[-OB_ERR_SEQ_OPTION_EXCEED_RANGE] = "HY000"; STR_ERROR[-OB_ERR_SEQ_OPTION_EXCEED_RANGE] = "sequence parameter exceeds maximum size allowed"; @@ -2528,6 +3097,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SEQ_OPTION_EXCEED_RANGE] = "ORA-04003: sequence parameter exceeds maximum size allowed"; ERROR_NAME[-OB_ERR_MINVALUE_LARGER_THAN_MAXVALUE] = "OB_ERR_MINVALUE_LARGER_THAN_MAXVALUE"; + ERROR_CAUSE[-OB_ERR_MINVALUE_LARGER_THAN_MAXVALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MINVALUE_LARGER_THAN_MAXVALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MINVALUE_LARGER_THAN_MAXVALUE] = -1; SQLSTATE[-OB_ERR_MINVALUE_LARGER_THAN_MAXVALUE] = "HY000"; STR_ERROR[-OB_ERR_MINVALUE_LARGER_THAN_MAXVALUE] = "MINVALUE must be less than MAXVALUE"; @@ -2536,6 +3107,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_MINVALUE_LARGER_THAN_MAXVALUE] = "ORA-04004: MINVALUE must be less than MAXVALUE"; ORACLE_STR_USER_ERROR[-OB_ERR_MINVALUE_LARGER_THAN_MAXVALUE] = "ORA-04004: MINVALUE must be less than MAXVALUE"; ERROR_NAME[-OB_ERR_SEQ_INCREMENT_TOO_LARGE] = "OB_ERR_SEQ_INCREMENT_TOO_LARGE"; + ERROR_CAUSE[-OB_ERR_SEQ_INCREMENT_TOO_LARGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SEQ_INCREMENT_TOO_LARGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SEQ_INCREMENT_TOO_LARGE] = -1; SQLSTATE[-OB_ERR_SEQ_INCREMENT_TOO_LARGE] = "HY000"; STR_ERROR[-OB_ERR_SEQ_INCREMENT_TOO_LARGE] = "INCREMENT must be less than MAXVALUE minus MINVALUE"; @@ -2546,6 +3119,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SEQ_INCREMENT_TOO_LARGE] = "ORA-04005: INCREMENT must be less than MAXVALUE minus MINVALUE"; ERROR_NAME[-OB_ERR_START_WITH_LESS_THAN_MINVALUE] = "OB_ERR_START_WITH_LESS_THAN_MINVALUE"; + ERROR_CAUSE[-OB_ERR_START_WITH_LESS_THAN_MINVALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_START_WITH_LESS_THAN_MINVALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_START_WITH_LESS_THAN_MINVALUE] = -1; SQLSTATE[-OB_ERR_START_WITH_LESS_THAN_MINVALUE] = "HY000"; STR_ERROR[-OB_ERR_START_WITH_LESS_THAN_MINVALUE] = "START WITH cannot be less than MINVALUE"; @@ -2554,6 +3129,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_START_WITH_LESS_THAN_MINVALUE] = "ORA-04006: START WITH cannot be less than MINVALUE"; ORACLE_STR_USER_ERROR[-OB_ERR_START_WITH_LESS_THAN_MINVALUE] = "ORA-04006: START WITH cannot be less than MINVALUE"; ERROR_NAME[-OB_ERR_MINVALUE_EXCEED_CURRVAL] = "OB_ERR_MINVALUE_EXCEED_CURRVAL"; + ERROR_CAUSE[-OB_ERR_MINVALUE_EXCEED_CURRVAL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MINVALUE_EXCEED_CURRVAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MINVALUE_EXCEED_CURRVAL] = -1; SQLSTATE[-OB_ERR_MINVALUE_EXCEED_CURRVAL] = "HY000"; STR_ERROR[-OB_ERR_MINVALUE_EXCEED_CURRVAL] = "MINVALUE cannot be made to exceed the current value"; @@ -2564,6 +3141,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MINVALUE_EXCEED_CURRVAL] = "ORA-04007: MINVALUE cannot be made to exceed the current value"; ERROR_NAME[-OB_ERR_START_WITH_EXCEED_MAXVALUE] = "OB_ERR_START_WITH_EXCEED_MAXVALUE"; + ERROR_CAUSE[-OB_ERR_START_WITH_EXCEED_MAXVALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_START_WITH_EXCEED_MAXVALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_START_WITH_EXCEED_MAXVALUE] = -1; SQLSTATE[-OB_ERR_START_WITH_EXCEED_MAXVALUE] = "HY000"; STR_ERROR[-OB_ERR_START_WITH_EXCEED_MAXVALUE] = "START WITH cannot be more than MAXVALUE"; @@ -2572,6 +3151,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_START_WITH_EXCEED_MAXVALUE] = "ORA-04008: START WITH cannot be more than MAXVALUE"; ORACLE_STR_USER_ERROR[-OB_ERR_START_WITH_EXCEED_MAXVALUE] = "ORA-04008: START WITH cannot be more than MAXVALUE"; ERROR_NAME[-OB_ERR_MAXVALUE_EXCEED_CURRVAL] = "OB_ERR_MAXVALUE_EXCEED_CURRVAL"; + ERROR_CAUSE[-OB_ERR_MAXVALUE_EXCEED_CURRVAL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MAXVALUE_EXCEED_CURRVAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MAXVALUE_EXCEED_CURRVAL] = -1; SQLSTATE[-OB_ERR_MAXVALUE_EXCEED_CURRVAL] = "HY000"; STR_ERROR[-OB_ERR_MAXVALUE_EXCEED_CURRVAL] = "MAXVALUE cannot be made to be less than the current value"; @@ -2582,6 +3163,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MAXVALUE_EXCEED_CURRVAL] = "ORA-04009: MAXVALUE cannot be made to be less than the current value"; ERROR_NAME[-OB_ERR_SEQ_CACHE_TOO_SMALL] = "OB_ERR_SEQ_CACHE_TOO_SMALL"; + ERROR_CAUSE[-OB_ERR_SEQ_CACHE_TOO_SMALL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SEQ_CACHE_TOO_SMALL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SEQ_CACHE_TOO_SMALL] = -1; SQLSTATE[-OB_ERR_SEQ_CACHE_TOO_SMALL] = "HY000"; STR_ERROR[-OB_ERR_SEQ_CACHE_TOO_SMALL] = "the number of values to CACHE must be greater than 1"; @@ -2591,6 +3174,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SEQ_CACHE_TOO_SMALL] = "ORA-04010: the number of values to CACHE must be greater than 1"; ERROR_NAME[-OB_ERR_SEQ_OPTION_OUT_OF_RANGE] = "OB_ERR_SEQ_OPTION_OUT_OF_RANGE"; + ERROR_CAUSE[-OB_ERR_SEQ_OPTION_OUT_OF_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SEQ_OPTION_OUT_OF_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SEQ_OPTION_OUT_OF_RANGE] = -1; SQLSTATE[-OB_ERR_SEQ_OPTION_OUT_OF_RANGE] = "HY000"; STR_ERROR[-OB_ERR_SEQ_OPTION_OUT_OF_RANGE] = "sequence option value out of range"; @@ -2599,6 +3184,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SEQ_OPTION_OUT_OF_RANGE] = "ORA-04011: sequence option value out of range"; ORACLE_STR_USER_ERROR[-OB_ERR_SEQ_OPTION_OUT_OF_RANGE] = "ORA-04011: sequence option value out of range"; ERROR_NAME[-OB_ERR_SEQ_CACHE_TOO_LARGE] = "OB_ERR_SEQ_CACHE_TOO_LARGE"; + ERROR_CAUSE[-OB_ERR_SEQ_CACHE_TOO_LARGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SEQ_CACHE_TOO_LARGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SEQ_CACHE_TOO_LARGE] = -1; SQLSTATE[-OB_ERR_SEQ_CACHE_TOO_LARGE] = "HY000"; STR_ERROR[-OB_ERR_SEQ_CACHE_TOO_LARGE] = "number to CACHE must be less than one cycle"; @@ -2607,6 +3194,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SEQ_CACHE_TOO_LARGE] = "ORA-04013: number to CACHE must be less than one cycle"; ORACLE_STR_USER_ERROR[-OB_ERR_SEQ_CACHE_TOO_LARGE] = "ORA-04013: number to CACHE must be less than one cycle"; ERROR_NAME[-OB_ERR_SEQ_REQUIRE_MINVALUE] = "OB_ERR_SEQ_REQUIRE_MINVALUE"; + ERROR_CAUSE[-OB_ERR_SEQ_REQUIRE_MINVALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SEQ_REQUIRE_MINVALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SEQ_REQUIRE_MINVALUE] = -1; SQLSTATE[-OB_ERR_SEQ_REQUIRE_MINVALUE] = "HY000"; STR_ERROR[-OB_ERR_SEQ_REQUIRE_MINVALUE] = "descending sequences that CYCLE must specify MINVALUE"; @@ -2616,6 +3205,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SEQ_REQUIRE_MINVALUE] = "ORA-04014: descending sequences that CYCLE must specify MINVALUE"; ERROR_NAME[-OB_ERR_SEQ_REQUIRE_MAXVALUE] = "OB_ERR_SEQ_REQUIRE_MAXVALUE"; + ERROR_CAUSE[-OB_ERR_SEQ_REQUIRE_MAXVALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SEQ_REQUIRE_MAXVALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SEQ_REQUIRE_MAXVALUE] = -1; SQLSTATE[-OB_ERR_SEQ_REQUIRE_MAXVALUE] = "HY000"; STR_ERROR[-OB_ERR_SEQ_REQUIRE_MAXVALUE] = "ascending sequences that CYCLE must specify MAXVALUE"; @@ -2625,6 +3216,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SEQ_REQUIRE_MAXVALUE] = "ORA-04015: ascending sequences that CYCLE must specify MAXVALUE"; ERROR_NAME[-OB_ERR_SEQ_NO_LONGER_EXIST] = "OB_ERR_SEQ_NO_LONGER_EXIST"; + ERROR_CAUSE[-OB_ERR_SEQ_NO_LONGER_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SEQ_NO_LONGER_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SEQ_NO_LONGER_EXIST] = -1; SQLSTATE[-OB_ERR_SEQ_NO_LONGER_EXIST] = "HY000"; STR_ERROR[-OB_ERR_SEQ_NO_LONGER_EXIST] = "sequence no longer exists"; @@ -2633,6 +3226,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SEQ_NO_LONGER_EXIST] = "ORA-04015: sequence no longer exists"; ORACLE_STR_USER_ERROR[-OB_ERR_SEQ_NO_LONGER_EXIST] = "ORA-04015: sequence %s no longer exists"; ERROR_NAME[-OB_ERR_SEQ_VALUE_EXCEED_LIMIT] = "OB_ERR_SEQ_VALUE_EXCEED_LIMIT"; + ERROR_CAUSE[-OB_ERR_SEQ_VALUE_EXCEED_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SEQ_VALUE_EXCEED_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SEQ_VALUE_EXCEED_LIMIT] = -1; SQLSTATE[-OB_ERR_SEQ_VALUE_EXCEED_LIMIT] = "HY000"; STR_ERROR[-OB_ERR_SEQ_VALUE_EXCEED_LIMIT] = "sequence exceeds limit and cannot be instantiated"; @@ -2641,6 +3236,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SEQ_VALUE_EXCEED_LIMIT] = "ORA-08004: sequence exceeds limit and cannot be instantiated"; ORACLE_STR_USER_ERROR[-OB_ERR_SEQ_VALUE_EXCEED_LIMIT] = "ORA-08004: sequence exceeds %s and cannot be instantiated"; ERROR_NAME[-OB_ERR_DIVISOR_IS_ZERO] = "OB_ERR_DIVISOR_IS_ZERO"; + ERROR_CAUSE[-OB_ERR_DIVISOR_IS_ZERO] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DIVISOR_IS_ZERO] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DIVISOR_IS_ZERO] = -1; SQLSTATE[-OB_ERR_DIVISOR_IS_ZERO] = "HY000"; STR_ERROR[-OB_ERR_DIVISOR_IS_ZERO] = "divisor is equal to zero"; @@ -2649,6 +3246,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DIVISOR_IS_ZERO] = "ORA-01476: divisor is equal to zero"; ORACLE_STR_USER_ERROR[-OB_ERR_DIVISOR_IS_ZERO] = "ORA-01476: divisor is equal to zero"; ERROR_NAME[-OB_ERR_AES_IV_LENGTH] = "OB_ERR_AES_IV_LENGTH"; + ERROR_CAUSE[-OB_ERR_AES_IV_LENGTH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_AES_IV_LENGTH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_AES_IV_LENGTH] = ER_AES_INVALID_IV; SQLSTATE[-OB_ERR_AES_IV_LENGTH] = "HY000"; STR_ERROR[-OB_ERR_AES_IV_LENGTH] = @@ -2663,6 +3262,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -4336, The initialization vector supplied to aes_encrypt is too " "short. Must be at least 16 bytes long"; ERROR_NAME[-OB_STORE_DIR_ERROR] = "OB_STORE_DIR_ERROR"; + ERROR_CAUSE[-OB_STORE_DIR_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_STORE_DIR_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_STORE_DIR_ERROR] = -1; SQLSTATE[-OB_STORE_DIR_ERROR] = "HY000"; STR_ERROR[-OB_STORE_DIR_ERROR] = "store directory structure error"; @@ -2673,6 +3274,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_STORE_DIR_ERROR] = "ORA-00600: internal error code, arguments: -4337, store directory structure error"; ERROR_NAME[-OB_OPEN_TWICE] = "OB_OPEN_TWICE"; + ERROR_CAUSE[-OB_OPEN_TWICE] = "Internal Error"; + ERROR_SOLUTION[-OB_OPEN_TWICE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OPEN_TWICE] = -1; SQLSTATE[-OB_OPEN_TWICE] = "HY000"; STR_ERROR[-OB_OPEN_TWICE] = "open twice"; @@ -2681,6 +3284,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_OPEN_TWICE] = "ORA-00600: internal error code, arguments: -4338, open twice"; ORACLE_STR_USER_ERROR[-OB_OPEN_TWICE] = "ORA-00600: internal error code, arguments: -4338, open twice"; ERROR_NAME[-OB_RAID_SUPER_BLOCK_NOT_MATCH] = "OB_RAID_SUPER_BLOCK_NOT_MATCH"; + ERROR_CAUSE[-OB_RAID_SUPER_BLOCK_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_RAID_SUPER_BLOCK_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RAID_SUPER_BLOCK_NOT_MATCH] = -1; SQLSTATE[-OB_RAID_SUPER_BLOCK_NOT_MATCH] = "HY000"; STR_ERROR[-OB_RAID_SUPER_BLOCK_NOT_MATCH] = "raid super block not match"; @@ -2691,6 +3296,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RAID_SUPER_BLOCK_NOT_MATCH] = "ORA-00600: internal error code, arguments: -4339, raid super block not match"; ERROR_NAME[-OB_NOT_OPEN] = "OB_NOT_OPEN"; + ERROR_CAUSE[-OB_NOT_OPEN] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_OPEN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_OPEN] = -1; SQLSTATE[-OB_NOT_OPEN] = "HY000"; STR_ERROR[-OB_NOT_OPEN] = "not opened"; @@ -2699,6 +3306,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NOT_OPEN] = "ORA-00600: internal error code, arguments: -4340, not opened"; ORACLE_STR_USER_ERROR[-OB_NOT_OPEN] = "ORA-00600: internal error code, arguments: -4340, not opened"; ERROR_NAME[-OB_NOT_IN_SERVICE] = "OB_NOT_IN_SERVICE"; + ERROR_CAUSE[-OB_NOT_IN_SERVICE] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_IN_SERVICE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_IN_SERVICE] = -1; SQLSTATE[-OB_NOT_IN_SERVICE] = "HY000"; STR_ERROR[-OB_NOT_IN_SERVICE] = "target module is not in service"; @@ -2709,6 +3318,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NOT_IN_SERVICE] = "ORA-00600: internal error code, arguments: -4341, target module is not in service"; ERROR_NAME[-OB_RAID_DISK_NOT_NORMAL] = "OB_RAID_DISK_NOT_NORMAL"; + ERROR_CAUSE[-OB_RAID_DISK_NOT_NORMAL] = "Internal Error"; + ERROR_SOLUTION[-OB_RAID_DISK_NOT_NORMAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RAID_DISK_NOT_NORMAL] = -1; SQLSTATE[-OB_RAID_DISK_NOT_NORMAL] = "HY000"; STR_ERROR[-OB_RAID_DISK_NOT_NORMAL] = "raid disk not in normal status"; @@ -2719,6 +3330,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RAID_DISK_NOT_NORMAL] = "ORA-00600: internal error code, arguments: -4342, raid disk not in normal status"; ERROR_NAME[-OB_TENANT_SCHEMA_NOT_FULL] = "OB_TENANT_SCHEMA_NOT_FULL"; + ERROR_CAUSE[-OB_TENANT_SCHEMA_NOT_FULL] = "Internal Error"; + ERROR_SOLUTION[-OB_TENANT_SCHEMA_NOT_FULL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TENANT_SCHEMA_NOT_FULL] = -1; SQLSTATE[-OB_TENANT_SCHEMA_NOT_FULL] = "HY000"; STR_ERROR[-OB_TENANT_SCHEMA_NOT_FULL] = "tenant schema is not full"; @@ -2729,6 +3342,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TENANT_SCHEMA_NOT_FULL] = "ORA-00600: internal error code, arguments: -4343, tenant schema is not full"; ERROR_NAME[-OB_INVALID_QUERY_TIMESTAMP] = "OB_INVALID_QUERY_TIMESTAMP"; + ERROR_CAUSE[-OB_INVALID_QUERY_TIMESTAMP] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_QUERY_TIMESTAMP] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_QUERY_TIMESTAMP] = -1; SQLSTATE[-OB_INVALID_QUERY_TIMESTAMP] = "HY000"; STR_ERROR[-OB_INVALID_QUERY_TIMESTAMP] = "invalid timestamp"; @@ -2737,6 +3352,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_INVALID_QUERY_TIMESTAMP] = "ORA-08186: invalid timestamp"; ORACLE_STR_USER_ERROR[-OB_INVALID_QUERY_TIMESTAMP] = "ORA-08186: invalid timestamp"; ERROR_NAME[-OB_DIR_NOT_EMPTY] = "OB_DIR_NOT_EMPTY"; + ERROR_CAUSE[-OB_DIR_NOT_EMPTY] = "Internal Error"; + ERROR_SOLUTION[-OB_DIR_NOT_EMPTY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DIR_NOT_EMPTY] = -1; SQLSTATE[-OB_DIR_NOT_EMPTY] = "HY000"; STR_ERROR[-OB_DIR_NOT_EMPTY] = "dir not empty"; @@ -2745,6 +3362,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_DIR_NOT_EMPTY] = "ORA-00600: internal error code, arguments: -4345, dir not empty"; ORACLE_STR_USER_ERROR[-OB_DIR_NOT_EMPTY] = "ORA-00600: internal error code, arguments: -4345, dir not empty"; ERROR_NAME[-OB_SCHEMA_NOT_UPTODATE] = "OB_SCHEMA_NOT_UPTODATE"; + ERROR_CAUSE[-OB_SCHEMA_NOT_UPTODATE] = "Internal Error"; + ERROR_SOLUTION[-OB_SCHEMA_NOT_UPTODATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SCHEMA_NOT_UPTODATE] = -1; SQLSTATE[-OB_SCHEMA_NOT_UPTODATE] = "HY000"; STR_ERROR[-OB_SCHEMA_NOT_UPTODATE] = "schema is not up to date for read"; @@ -2755,6 +3374,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SCHEMA_NOT_UPTODATE] = "ORA-00600: internal error code, arguments: -4346, schema is not up to date for read"; ERROR_NAME[-OB_ROLE_NOT_EXIST] = "OB_ROLE_NOT_EXIST"; + ERROR_CAUSE[-OB_ROLE_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ROLE_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ROLE_NOT_EXIST] = -1; SQLSTATE[-OB_ROLE_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ROLE_NOT_EXIST] = "role does not exist"; @@ -2763,6 +3384,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ROLE_NOT_EXIST] = "ORA-01919: role does not exist"; ORACLE_STR_USER_ERROR[-OB_ROLE_NOT_EXIST] = "ORA-01919: role '%.*s' does not exist"; ERROR_NAME[-OB_ROLE_EXIST] = "OB_ROLE_EXIST"; + ERROR_CAUSE[-OB_ROLE_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ROLE_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ROLE_EXIST] = -1; SQLSTATE[-OB_ROLE_EXIST] = "HY000"; STR_ERROR[-OB_ROLE_EXIST] = "role exists"; @@ -2771,6 +3394,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ROLE_EXIST] = "ORA-01921: role name conflicts with another user or role name"; ORACLE_STR_USER_ERROR[-OB_ROLE_EXIST] = "ORA-01921: role name '%.*s' conflicts with another user or role name"; ERROR_NAME[-OB_PRIV_DUP] = "OB_PRIV_DUP"; + ERROR_CAUSE[-OB_PRIV_DUP] = "Internal Error"; + ERROR_SOLUTION[-OB_PRIV_DUP] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PRIV_DUP] = -1; SQLSTATE[-OB_PRIV_DUP] = "HY000"; STR_ERROR[-OB_PRIV_DUP] = "duplicate privilege listed"; @@ -2779,6 +3404,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_PRIV_DUP] = "ORA-01711: duplicate privilege listed"; ORACLE_STR_USER_ERROR[-OB_PRIV_DUP] = "ORA-01711: duplicate privilege listed"; ERROR_NAME[-OB_KEYSTORE_EXIST] = "OB_KEYSTORE_EXIST"; + ERROR_CAUSE[-OB_KEYSTORE_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_KEYSTORE_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_KEYSTORE_EXIST] = -1; SQLSTATE[-OB_KEYSTORE_EXIST] = "HY000"; STR_ERROR[-OB_KEYSTORE_EXIST] = "the keystore already exists and each tenant can only have at most one"; @@ -2789,6 +3416,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_KEYSTORE_EXIST] = "ORA-00600: internal error code, arguments: -4350, the keystore " "already exists and each tenant can only have at most one"; ERROR_NAME[-OB_KEYSTORE_NOT_EXIST] = "OB_KEYSTORE_NOT_EXIST"; + ERROR_CAUSE[-OB_KEYSTORE_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_KEYSTORE_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_KEYSTORE_NOT_EXIST] = -1; SQLSTATE[-OB_KEYSTORE_NOT_EXIST] = "HY000"; STR_ERROR[-OB_KEYSTORE_NOT_EXIST] = "the keystore is not exist"; @@ -2799,6 +3428,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_KEYSTORE_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4351, the keystore is not exist"; ERROR_NAME[-OB_KEYSTORE_WRONG_PASSWORD] = "OB_KEYSTORE_WRONG_PASSWORD"; + ERROR_CAUSE[-OB_KEYSTORE_WRONG_PASSWORD] = "Internal Error"; + ERROR_SOLUTION[-OB_KEYSTORE_WRONG_PASSWORD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_KEYSTORE_WRONG_PASSWORD] = -1; SQLSTATE[-OB_KEYSTORE_WRONG_PASSWORD] = "HY000"; STR_ERROR[-OB_KEYSTORE_WRONG_PASSWORD] = "the password is wrong for keystore"; @@ -2809,6 +3440,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_KEYSTORE_WRONG_PASSWORD] = "ORA-00600: internal error code, arguments: -4352, the password is wrong for keystore"; ERROR_NAME[-OB_TABLESPACE_EXIST] = "OB_TABLESPACE_EXIST"; + ERROR_CAUSE[-OB_TABLESPACE_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_TABLESPACE_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TABLESPACE_EXIST] = -1; SQLSTATE[-OB_TABLESPACE_EXIST] = "HY000"; STR_ERROR[-OB_TABLESPACE_EXIST] = "tablespace already exists"; @@ -2817,6 +3450,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TABLESPACE_EXIST] = "ORA-01543: tablespace already exists"; ORACLE_STR_USER_ERROR[-OB_TABLESPACE_EXIST] = "ORA-01543: tablespace '%.*s' already exists"; ERROR_NAME[-OB_TABLESPACE_NOT_EXIST] = "OB_TABLESPACE_NOT_EXIST"; + ERROR_CAUSE[-OB_TABLESPACE_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_TABLESPACE_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TABLESPACE_NOT_EXIST] = -1; SQLSTATE[-OB_TABLESPACE_NOT_EXIST] = "HY000"; STR_ERROR[-OB_TABLESPACE_NOT_EXIST] = "tablespace does not exist"; @@ -2825,6 +3460,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TABLESPACE_NOT_EXIST] = "ORA-00959: tablespace does not exist"; ORACLE_STR_USER_ERROR[-OB_TABLESPACE_NOT_EXIST] = "ORA-00959: tablespace '%.*s' does not exist"; ERROR_NAME[-OB_TABLESPACE_DELETE_NOT_EMPTY] = "OB_TABLESPACE_DELETE_NOT_EMPTY"; + ERROR_CAUSE[-OB_TABLESPACE_DELETE_NOT_EMPTY] = "Internal Error"; + ERROR_SOLUTION[-OB_TABLESPACE_DELETE_NOT_EMPTY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TABLESPACE_DELETE_NOT_EMPTY] = -1; SQLSTATE[-OB_TABLESPACE_DELETE_NOT_EMPTY] = "HY000"; STR_ERROR[-OB_TABLESPACE_DELETE_NOT_EMPTY] = "cannot delete a tablespace which is not empty"; @@ -2835,6 +3472,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TABLESPACE_DELETE_NOT_EMPTY] = "ORA-00600: internal error code, arguments: -4355, cannot delete a tablespace which is not empty"; ERROR_NAME[-OB_FLOAT_PRECISION_OUT_RANGE] = "OB_FLOAT_PRECISION_OUT_RANGE"; + ERROR_CAUSE[-OB_FLOAT_PRECISION_OUT_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_FLOAT_PRECISION_OUT_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_FLOAT_PRECISION_OUT_RANGE] = -1; SQLSTATE[-OB_FLOAT_PRECISION_OUT_RANGE] = "HY000"; STR_ERROR[-OB_FLOAT_PRECISION_OUT_RANGE] = "floating point precision is out of range (1 to 126)"; @@ -2844,6 +3483,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_FLOAT_PRECISION_OUT_RANGE] = "ORA-01724: floating point precision is out of range (1 to 126)"; ERROR_NAME[-OB_NUMERIC_PRECISION_OUT_RANGE] = "OB_NUMERIC_PRECISION_OUT_RANGE"; + ERROR_CAUSE[-OB_NUMERIC_PRECISION_OUT_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_NUMERIC_PRECISION_OUT_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NUMERIC_PRECISION_OUT_RANGE] = -1; SQLSTATE[-OB_NUMERIC_PRECISION_OUT_RANGE] = "HY000"; STR_ERROR[-OB_NUMERIC_PRECISION_OUT_RANGE] = "numeric precision specifier is out of range (1 to 38)"; @@ -2854,6 +3495,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NUMERIC_PRECISION_OUT_RANGE] = "ORA-01727: numeric precision specifier is out of range (1 to 38)"; ERROR_NAME[-OB_NUMERIC_SCALE_OUT_RANGE] = "OB_NUMERIC_SCALE_OUT_RANGE"; + ERROR_CAUSE[-OB_NUMERIC_SCALE_OUT_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_NUMERIC_SCALE_OUT_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NUMERIC_SCALE_OUT_RANGE] = -1; SQLSTATE[-OB_NUMERIC_SCALE_OUT_RANGE] = "HY000"; STR_ERROR[-OB_NUMERIC_SCALE_OUT_RANGE] = "numeric scale specifier is out of range (-84 to 127)"; @@ -2863,6 +3506,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NUMERIC_SCALE_OUT_RANGE] = "ORA-01728: numeric scale specifier is out of range (-84 to 127)"; ERROR_NAME[-OB_KEYSTORE_NOT_OPEN] = "OB_KEYSTORE_NOT_OPEN"; + ERROR_CAUSE[-OB_KEYSTORE_NOT_OPEN] = "Internal Error"; + ERROR_SOLUTION[-OB_KEYSTORE_NOT_OPEN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_KEYSTORE_NOT_OPEN] = -1; SQLSTATE[-OB_KEYSTORE_NOT_OPEN] = "HY000"; STR_ERROR[-OB_KEYSTORE_NOT_OPEN] = "the keystore is not open"; @@ -2873,6 +3518,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_KEYSTORE_NOT_OPEN] = "ORA-00600: internal error code, arguments: -4359, the keystore is not open"; ERROR_NAME[-OB_KEYSTORE_OPEN_NO_MASTER_KEY] = "OB_KEYSTORE_OPEN_NO_MASTER_KEY"; + ERROR_CAUSE[-OB_KEYSTORE_OPEN_NO_MASTER_KEY] = "Internal Error"; + ERROR_SOLUTION[-OB_KEYSTORE_OPEN_NO_MASTER_KEY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_KEYSTORE_OPEN_NO_MASTER_KEY] = -1; SQLSTATE[-OB_KEYSTORE_OPEN_NO_MASTER_KEY] = "HY000"; STR_ERROR[-OB_KEYSTORE_OPEN_NO_MASTER_KEY] = "the keystore opened with dont have a master key"; @@ -2883,6 +3530,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_KEYSTORE_OPEN_NO_MASTER_KEY] = "ORA-00600: internal error code, arguments: -4360, the keystore opened with dont have a master key"; ERROR_NAME[-OB_SLOG_REACH_MAX_CONCURRENCY] = "OB_SLOG_REACH_MAX_CONCURRENCY"; + ERROR_CAUSE[-OB_SLOG_REACH_MAX_CONCURRENCY] = "Internal Error"; + ERROR_SOLUTION[-OB_SLOG_REACH_MAX_CONCURRENCY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SLOG_REACH_MAX_CONCURRENCY] = -1; SQLSTATE[-OB_SLOG_REACH_MAX_CONCURRENCY] = "HY000"; STR_ERROR[-OB_SLOG_REACH_MAX_CONCURRENCY] = "slog active transaction entries reach maximum"; @@ -2893,6 +3542,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SLOG_REACH_MAX_CONCURRENCY] = "ORA-00600: internal error code, arguments: -4361, slog active transaction entries reach maximum"; ERROR_NAME[-OB_ERR_NOT_VALID_PASSWORD] = "OB_ERR_NOT_VALID_PASSWORD"; + ERROR_CAUSE[-OB_ERR_NOT_VALID_PASSWORD] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NOT_VALID_PASSWORD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NOT_VALID_PASSWORD] = ER_NOT_VALID_PASSWORD; SQLSTATE[-OB_ERR_NOT_VALID_PASSWORD] = "HY000"; STR_ERROR[-OB_ERR_NOT_VALID_PASSWORD] = "Your password does not satisfy the current policy requirements"; @@ -2903,6 +3554,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NOT_VALID_PASSWORD] = "ORA-00600: internal error code, arguments: -4365, Your " "password does not satisfy the current policy requirements"; ERROR_NAME[-OB_ERR_MUST_CHANGE_PASSWORD] = "OB_ERR_MUST_CHANGE_PASSWORD"; + ERROR_CAUSE[-OB_ERR_MUST_CHANGE_PASSWORD] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MUST_CHANGE_PASSWORD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MUST_CHANGE_PASSWORD] = ER_MUST_CHANGE_PASSWORD; SQLSTATE[-OB_ERR_MUST_CHANGE_PASSWORD] = "HY000"; STR_ERROR[-OB_ERR_MUST_CHANGE_PASSWORD] = @@ -2913,6 +3566,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_MUST_CHANGE_PASSWORD] = "ORA-28001: the password has expired"; ORACLE_STR_USER_ERROR[-OB_ERR_MUST_CHANGE_PASSWORD] = "ORA-28001: the password has expired"; ERROR_NAME[-OB_OVERSIZE_NEED_RETRY] = "OB_OVERSIZE_NEED_RETRY"; + ERROR_CAUSE[-OB_OVERSIZE_NEED_RETRY] = "Internal Error"; + ERROR_SOLUTION[-OB_OVERSIZE_NEED_RETRY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OVERSIZE_NEED_RETRY] = ER_OVERSIZE_NEED_RETRY; SQLSTATE[-OB_OVERSIZE_NEED_RETRY] = "HY000"; STR_ERROR[-OB_OVERSIZE_NEED_RETRY] = "The data more than 64M(rpc limit), split into smaller task and retry"; @@ -2923,6 +3578,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_OVERSIZE_NEED_RETRY] = "ORA-00600: internal error code, arguments: -4367, The data more " "than 64M(rpc limit), split into smaller task and retry"; ERROR_NAME[-OB_OBCONFIG_CLUSTER_NOT_EXIST] = "OB_OBCONFIG_CLUSTER_NOT_EXIST"; + ERROR_CAUSE[-OB_OBCONFIG_CLUSTER_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_OBCONFIG_CLUSTER_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OBCONFIG_CLUSTER_NOT_EXIST] = -1; SQLSTATE[-OB_OBCONFIG_CLUSTER_NOT_EXIST] = "HY000"; STR_ERROR[-OB_OBCONFIG_CLUSTER_NOT_EXIST] = "cluster not exists"; @@ -2933,6 +3590,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_OBCONFIG_CLUSTER_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4368, cluster not exists"; ERROR_NAME[-OB_ERR_VALUE_LARGER_THAN_ALLOWED] = "OB_ERR_VALUE_LARGER_THAN_ALLOWED"; + ERROR_CAUSE[-OB_ERR_VALUE_LARGER_THAN_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_VALUE_LARGER_THAN_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_VALUE_LARGER_THAN_ALLOWED] = -1; SQLSTATE[-OB_ERR_VALUE_LARGER_THAN_ALLOWED] = "HY000"; STR_ERROR[-OB_ERR_VALUE_LARGER_THAN_ALLOWED] = "value larger than specified precision allowed for this column"; @@ -2943,6 +3602,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_VALUE_LARGER_THAN_ALLOWED] = "ORA-01438: value larger than specified precision allowed for this column"; ERROR_NAME[-OB_DISK_ERROR] = "OB_DISK_ERROR"; + ERROR_CAUSE[-OB_DISK_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_DISK_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DISK_ERROR] = -1; SQLSTATE[-OB_DISK_ERROR] = "HY000"; STR_ERROR[-OB_DISK_ERROR] = "observer has disk error"; @@ -2951,6 +3612,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_DISK_ERROR] = "ORA-00600: internal error code, arguments: -4375, observer has disk error"; ORACLE_STR_USER_ERROR[-OB_DISK_ERROR] = "ORA-00600: internal error code, arguments: -4375, observer has disk error"; ERROR_NAME[-OB_UNIMPLEMENTED_FEATURE] = "OB_UNIMPLEMENTED_FEATURE"; + ERROR_CAUSE[-OB_UNIMPLEMENTED_FEATURE] = "Internal Error"; + ERROR_SOLUTION[-OB_UNIMPLEMENTED_FEATURE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_UNIMPLEMENTED_FEATURE] = -1; SQLSTATE[-OB_UNIMPLEMENTED_FEATURE] = "HY000"; STR_ERROR[-OB_UNIMPLEMENTED_FEATURE] = "unimplemented feature"; @@ -2959,6 +3622,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_UNIMPLEMENTED_FEATURE] = "ORA-03001: unimplemented feature"; ORACLE_STR_USER_ERROR[-OB_UNIMPLEMENTED_FEATURE] = "ORA-03001: unimplemented feature"; ERROR_NAME[-OB_IMPORT_NOT_IN_SERVER] = "OB_IMPORT_NOT_IN_SERVER"; + ERROR_CAUSE[-OB_IMPORT_NOT_IN_SERVER] = "Internal Error"; + ERROR_SOLUTION[-OB_IMPORT_NOT_IN_SERVER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_IMPORT_NOT_IN_SERVER] = -1; SQLSTATE[-OB_IMPORT_NOT_IN_SERVER] = "HY000"; STR_ERROR[-OB_IMPORT_NOT_IN_SERVER] = "Import not in service"; @@ -2969,6 +3634,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_IMPORT_NOT_IN_SERVER] = "ORA-00600: internal error code, arguments: -4505, Import not in service"; ERROR_NAME[-OB_CONVERT_ERROR] = "OB_CONVERT_ERROR"; + ERROR_CAUSE[-OB_CONVERT_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_CONVERT_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CONVERT_ERROR] = -1; SQLSTATE[-OB_CONVERT_ERROR] = "42000"; STR_ERROR[-OB_CONVERT_ERROR] = "Convert error"; @@ -2977,6 +3644,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_CONVERT_ERROR] = "ORA-00600: internal error code, arguments: -4507, Convert error"; ORACLE_STR_USER_ERROR[-OB_CONVERT_ERROR] = "ORA-00600: internal error code, arguments: -4507, Convert error"; ERROR_NAME[-OB_BYPASS_TIMEOUT] = "OB_BYPASS_TIMEOUT"; + ERROR_CAUSE[-OB_BYPASS_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_BYPASS_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BYPASS_TIMEOUT] = -1; SQLSTATE[-OB_BYPASS_TIMEOUT] = "HY000"; STR_ERROR[-OB_BYPASS_TIMEOUT] = "Bypass timeout"; @@ -2985,6 +3654,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_BYPASS_TIMEOUT] = "ORA-00600: internal error code, arguments: -4510, Bypass timeout"; ORACLE_STR_USER_ERROR[-OB_BYPASS_TIMEOUT] = "ORA-00600: internal error code, arguments: -4510, Bypass timeout"; ERROR_NAME[-OB_RS_STATE_NOT_ALLOW] = "OB_RS_STATE_NOT_ALLOW"; + ERROR_CAUSE[-OB_RS_STATE_NOT_ALLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_RS_STATE_NOT_ALLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RS_STATE_NOT_ALLOW] = -1; SQLSTATE[-OB_RS_STATE_NOT_ALLOW] = "HY000"; STR_ERROR[-OB_RS_STATE_NOT_ALLOW] = "RootServer state error"; @@ -2995,6 +3666,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RS_STATE_NOT_ALLOW] = "ORA-00600: internal error code, arguments: -4512, RootServer state error"; ERROR_NAME[-OB_NO_REPLICA_VALID] = "OB_NO_REPLICA_VALID"; + ERROR_CAUSE[-OB_NO_REPLICA_VALID] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_REPLICA_VALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_REPLICA_VALID] = -1; SQLSTATE[-OB_NO_REPLICA_VALID] = "HY000"; STR_ERROR[-OB_NO_REPLICA_VALID] = "No replica is valid"; @@ -3004,6 +3677,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NO_REPLICA_VALID] = "ORA-00600: internal error code, arguments: -4515, No replica is valid"; ERROR_NAME[-OB_NO_NEED_UPDATE] = "OB_NO_NEED_UPDATE"; + ERROR_CAUSE[-OB_NO_NEED_UPDATE] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_NEED_UPDATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_NEED_UPDATE] = -1; SQLSTATE[-OB_NO_NEED_UPDATE] = "HY000"; STR_ERROR[-OB_NO_NEED_UPDATE] = "No need to update"; @@ -3012,6 +3687,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NO_NEED_UPDATE] = "ORA-00600: internal error code, arguments: -4517, No need to update"; ORACLE_STR_USER_ERROR[-OB_NO_NEED_UPDATE] = "ORA-00600: internal error code, arguments: -4517, No need to update"; ERROR_NAME[-OB_CACHE_TIMEOUT] = "OB_CACHE_TIMEOUT"; + ERROR_CAUSE[-OB_CACHE_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_CACHE_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CACHE_TIMEOUT] = -1; SQLSTATE[-OB_CACHE_TIMEOUT] = "HY000"; STR_ERROR[-OB_CACHE_TIMEOUT] = "Cache timeout"; @@ -3020,6 +3697,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_CACHE_TIMEOUT] = "ORA-00600: internal error code, arguments: -4518, Cache timeout"; ORACLE_STR_USER_ERROR[-OB_CACHE_TIMEOUT] = "ORA-00600: internal error code, arguments: -4518, Cache timeout"; ERROR_NAME[-OB_ITER_STOP] = "OB_ITER_STOP"; + ERROR_CAUSE[-OB_ITER_STOP] = "Internal Error"; + ERROR_SOLUTION[-OB_ITER_STOP] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ITER_STOP] = -1; SQLSTATE[-OB_ITER_STOP] = "HY000"; STR_ERROR[-OB_ITER_STOP] = "Iteration was stopped"; @@ -3028,6 +3707,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ITER_STOP] = "ORA-00600: internal error code, arguments: -4519, Iteration was stopped"; ORACLE_STR_USER_ERROR[-OB_ITER_STOP] = "ORA-00600: internal error code, arguments: -4519, Iteration was stopped"; ERROR_NAME[-OB_ZONE_ALREADY_MASTER] = "OB_ZONE_ALREADY_MASTER"; + ERROR_CAUSE[-OB_ZONE_ALREADY_MASTER] = "Internal Error"; + ERROR_SOLUTION[-OB_ZONE_ALREADY_MASTER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ZONE_ALREADY_MASTER] = -1; SQLSTATE[-OB_ZONE_ALREADY_MASTER] = "HY000"; STR_ERROR[-OB_ZONE_ALREADY_MASTER] = "The zone is the master already"; @@ -3038,6 +3719,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ZONE_ALREADY_MASTER] = "ORA-00600: internal error code, arguments: -4523, The zone is the master already"; ERROR_NAME[-OB_IP_PORT_IS_NOT_SLAVE_ZONE] = "OB_IP_PORT_IS_NOT_SLAVE_ZONE"; + ERROR_CAUSE[-OB_IP_PORT_IS_NOT_SLAVE_ZONE] = "Internal Error"; + ERROR_SOLUTION[-OB_IP_PORT_IS_NOT_SLAVE_ZONE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_IP_PORT_IS_NOT_SLAVE_ZONE] = -1; SQLSTATE[-OB_IP_PORT_IS_NOT_SLAVE_ZONE] = "HY000"; STR_ERROR[-OB_IP_PORT_IS_NOT_SLAVE_ZONE] = "Not slave zone"; @@ -3048,6 +3731,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_IP_PORT_IS_NOT_SLAVE_ZONE] = "ORA-00600: internal error code, arguments: -4524, Not slave zone"; ERROR_NAME[-OB_ZONE_IS_NOT_SLAVE] = "OB_ZONE_IS_NOT_SLAVE"; + ERROR_CAUSE[-OB_ZONE_IS_NOT_SLAVE] = "Internal Error"; + ERROR_SOLUTION[-OB_ZONE_IS_NOT_SLAVE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ZONE_IS_NOT_SLAVE] = -1; SQLSTATE[-OB_ZONE_IS_NOT_SLAVE] = "HY000"; STR_ERROR[-OB_ZONE_IS_NOT_SLAVE] = "Not slave zone"; @@ -3056,6 +3741,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ZONE_IS_NOT_SLAVE] = "ORA-00600: internal error code, arguments: -4525, Not slave zone"; ORACLE_STR_USER_ERROR[-OB_ZONE_IS_NOT_SLAVE] = "ORA-00600: internal error code, arguments: -4525, Not slave zone"; ERROR_NAME[-OB_ZONE_IS_NOT_MASTER] = "OB_ZONE_IS_NOT_MASTER"; + ERROR_CAUSE[-OB_ZONE_IS_NOT_MASTER] = "Internal Error"; + ERROR_SOLUTION[-OB_ZONE_IS_NOT_MASTER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ZONE_IS_NOT_MASTER] = -1; SQLSTATE[-OB_ZONE_IS_NOT_MASTER] = "HY000"; STR_ERROR[-OB_ZONE_IS_NOT_MASTER] = "Not master zone"; @@ -3064,6 +3751,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ZONE_IS_NOT_MASTER] = "ORA-00600: internal error code, arguments: -4526, Not master zone"; ORACLE_STR_USER_ERROR[-OB_ZONE_IS_NOT_MASTER] = "ORA-00600: internal error code, arguments: -4526, Not master zone"; ERROR_NAME[-OB_CONFIG_NOT_SYNC] = "OB_CONFIG_NOT_SYNC"; + ERROR_CAUSE[-OB_CONFIG_NOT_SYNC] = "Internal Error"; + ERROR_SOLUTION[-OB_CONFIG_NOT_SYNC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CONFIG_NOT_SYNC] = -1; SQLSTATE[-OB_CONFIG_NOT_SYNC] = "F0000"; STR_ERROR[-OB_CONFIG_NOT_SYNC] = "Configuration not sync"; @@ -3073,6 +3762,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CONFIG_NOT_SYNC] = "ORA-00600: internal error code, arguments: -4527, Configuration not sync"; ERROR_NAME[-OB_IP_PORT_IS_NOT_ZONE] = "OB_IP_PORT_IS_NOT_ZONE"; + ERROR_CAUSE[-OB_IP_PORT_IS_NOT_ZONE] = "Internal Error"; + ERROR_SOLUTION[-OB_IP_PORT_IS_NOT_ZONE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_IP_PORT_IS_NOT_ZONE] = -1; SQLSTATE[-OB_IP_PORT_IS_NOT_ZONE] = "42000"; STR_ERROR[-OB_IP_PORT_IS_NOT_ZONE] = "Not a zone address"; @@ -3082,6 +3773,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_IP_PORT_IS_NOT_ZONE] = "ORA-00600: internal error code, arguments: -4528, Not a zone address"; ERROR_NAME[-OB_MASTER_ZONE_NOT_EXIST] = "OB_MASTER_ZONE_NOT_EXIST"; + ERROR_CAUSE[-OB_MASTER_ZONE_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_MASTER_ZONE_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_MASTER_ZONE_NOT_EXIST] = -1; SQLSTATE[-OB_MASTER_ZONE_NOT_EXIST] = "HY000"; STR_ERROR[-OB_MASTER_ZONE_NOT_EXIST] = "Master zone not exist"; @@ -3092,6 +3785,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_MASTER_ZONE_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4529, Master zone not exist"; ERROR_NAME[-OB_ZONE_INFO_NOT_EXIST] = "OB_ZONE_INFO_NOT_EXIST"; + ERROR_CAUSE[-OB_ZONE_INFO_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ZONE_INFO_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ZONE_INFO_NOT_EXIST] = -1; SQLSTATE[-OB_ZONE_INFO_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ZONE_INFO_NOT_EXIST] = "Zone info not exist"; @@ -3101,6 +3796,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ZONE_INFO_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4530, Zone info \'%s\' not exist"; ERROR_NAME[-OB_GET_ZONE_MASTER_UPS_FAILED] = "OB_GET_ZONE_MASTER_UPS_FAILED"; + ERROR_CAUSE[-OB_GET_ZONE_MASTER_UPS_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_GET_ZONE_MASTER_UPS_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_GET_ZONE_MASTER_UPS_FAILED] = -1; SQLSTATE[-OB_GET_ZONE_MASTER_UPS_FAILED] = "HY000"; STR_ERROR[-OB_GET_ZONE_MASTER_UPS_FAILED] = "Failed to get master UpdateServer"; @@ -3111,6 +3808,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_GET_ZONE_MASTER_UPS_FAILED] = "ORA-00600: internal error code, arguments: -4531, Failed to get master UpdateServer"; ERROR_NAME[-OB_MULTIPLE_MASTER_ZONES_EXIST] = "OB_MULTIPLE_MASTER_ZONES_EXIST"; + ERROR_CAUSE[-OB_MULTIPLE_MASTER_ZONES_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_MULTIPLE_MASTER_ZONES_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_MULTIPLE_MASTER_ZONES_EXIST] = -1; SQLSTATE[-OB_MULTIPLE_MASTER_ZONES_EXIST] = "HY000"; STR_ERROR[-OB_MULTIPLE_MASTER_ZONES_EXIST] = "Multiple master zones"; @@ -3121,6 +3820,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_MULTIPLE_MASTER_ZONES_EXIST] = "ORA-00600: internal error code, arguments: -4532, Multiple master zones"; ERROR_NAME[-OB_INDEXING_ZONE_INVALID] = "OB_INDEXING_ZONE_INVALID"; + ERROR_CAUSE[-OB_INDEXING_ZONE_INVALID] = "Internal Error"; + ERROR_SOLUTION[-OB_INDEXING_ZONE_INVALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INDEXING_ZONE_INVALID] = -1; SQLSTATE[-OB_INDEXING_ZONE_INVALID] = "HY000"; STR_ERROR[-OB_INDEXING_ZONE_INVALID] = "indexing zone is not exist anymore or not active"; @@ -3131,6 +3832,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INDEXING_ZONE_INVALID] = "ORA-00600: internal error code, arguments: -4533, indexing zone is not exist anymore or not active"; ERROR_NAME[-OB_ROOT_TABLE_RANGE_NOT_EXIST] = "OB_ROOT_TABLE_RANGE_NOT_EXIST"; + ERROR_CAUSE[-OB_ROOT_TABLE_RANGE_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ROOT_TABLE_RANGE_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ROOT_TABLE_RANGE_NOT_EXIST] = -1; SQLSTATE[-OB_ROOT_TABLE_RANGE_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ROOT_TABLE_RANGE_NOT_EXIST] = "Tablet range not exist"; @@ -3141,6 +3844,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ROOT_TABLE_RANGE_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4537, Tablet range not exist"; ERROR_NAME[-OB_ROOT_MIGRATE_CONCURRENCY_FULL] = "OB_ROOT_MIGRATE_CONCURRENCY_FULL"; + ERROR_CAUSE[-OB_ROOT_MIGRATE_CONCURRENCY_FULL] = "Internal Error"; + ERROR_SOLUTION[-OB_ROOT_MIGRATE_CONCURRENCY_FULL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ROOT_MIGRATE_CONCURRENCY_FULL] = -1; SQLSTATE[-OB_ROOT_MIGRATE_CONCURRENCY_FULL] = "HY000"; STR_ERROR[-OB_ROOT_MIGRATE_CONCURRENCY_FULL] = "Migrate concurrency full"; @@ -3151,6 +3856,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ROOT_MIGRATE_CONCURRENCY_FULL] = "ORA-00600: internal error code, arguments: -4538, Migrate concurrency full"; ERROR_NAME[-OB_ROOT_MIGRATE_INFO_NOT_FOUND] = "OB_ROOT_MIGRATE_INFO_NOT_FOUND"; + ERROR_CAUSE[-OB_ROOT_MIGRATE_INFO_NOT_FOUND] = "Internal Error"; + ERROR_SOLUTION[-OB_ROOT_MIGRATE_INFO_NOT_FOUND] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ROOT_MIGRATE_INFO_NOT_FOUND] = -1; SQLSTATE[-OB_ROOT_MIGRATE_INFO_NOT_FOUND] = "HY000"; STR_ERROR[-OB_ROOT_MIGRATE_INFO_NOT_FOUND] = "Migrate info not found"; @@ -3161,6 +3868,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ROOT_MIGRATE_INFO_NOT_FOUND] = "ORA-00600: internal error code, arguments: -4539, Migrate info not found"; ERROR_NAME[-OB_NOT_DATA_LOAD_TABLE] = "OB_NOT_DATA_LOAD_TABLE"; + ERROR_CAUSE[-OB_NOT_DATA_LOAD_TABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_DATA_LOAD_TABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_DATA_LOAD_TABLE] = -1; SQLSTATE[-OB_NOT_DATA_LOAD_TABLE] = "HY000"; STR_ERROR[-OB_NOT_DATA_LOAD_TABLE] = "No data to load"; @@ -3170,6 +3879,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NOT_DATA_LOAD_TABLE] = "ORA-00600: internal error code, arguments: -4540, No data to load"; ERROR_NAME[-OB_DATA_LOAD_TABLE_DUPLICATED] = "OB_DATA_LOAD_TABLE_DUPLICATED"; + ERROR_CAUSE[-OB_DATA_LOAD_TABLE_DUPLICATED] = "Internal Error"; + ERROR_SOLUTION[-OB_DATA_LOAD_TABLE_DUPLICATED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DATA_LOAD_TABLE_DUPLICATED] = -1; SQLSTATE[-OB_DATA_LOAD_TABLE_DUPLICATED] = "HY000"; STR_ERROR[-OB_DATA_LOAD_TABLE_DUPLICATED] = "Duplicated table data to load"; @@ -3180,6 +3891,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DATA_LOAD_TABLE_DUPLICATED] = "ORA-00600: internal error code, arguments: -4541, Duplicated table data to load"; ERROR_NAME[-OB_ROOT_TABLE_ID_EXIST] = "OB_ROOT_TABLE_ID_EXIST"; + ERROR_CAUSE[-OB_ROOT_TABLE_ID_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ROOT_TABLE_ID_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ROOT_TABLE_ID_EXIST] = -1; SQLSTATE[-OB_ROOT_TABLE_ID_EXIST] = "HY000"; STR_ERROR[-OB_ROOT_TABLE_ID_EXIST] = "Table ID exist"; @@ -3188,6 +3901,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ROOT_TABLE_ID_EXIST] = "ORA-00600: internal error code, arguments: -4542, Table ID exist"; ORACLE_STR_USER_ERROR[-OB_ROOT_TABLE_ID_EXIST] = "ORA-00600: internal error code, arguments: -4542, Table ID exist"; ERROR_NAME[-OB_INDEX_TIMEOUT] = "OB_INDEX_TIMEOUT"; + ERROR_CAUSE[-OB_INDEX_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_INDEX_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INDEX_TIMEOUT] = -1; SQLSTATE[-OB_INDEX_TIMEOUT] = "HY000"; STR_ERROR[-OB_INDEX_TIMEOUT] = "Building index timeout"; @@ -3197,6 +3912,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INDEX_TIMEOUT] = "ORA-00600: internal error code, arguments: -4543, Building index timeout"; ERROR_NAME[-OB_ROOT_NOT_INTEGRATED] = "OB_ROOT_NOT_INTEGRATED"; + ERROR_CAUSE[-OB_ROOT_NOT_INTEGRATED] = "Internal Error"; + ERROR_SOLUTION[-OB_ROOT_NOT_INTEGRATED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ROOT_NOT_INTEGRATED] = -1; SQLSTATE[-OB_ROOT_NOT_INTEGRATED] = "42000"; STR_ERROR[-OB_ROOT_NOT_INTEGRATED] = "Root not integrated"; @@ -3206,6 +3923,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ROOT_NOT_INTEGRATED] = "ORA-00600: internal error code, arguments: -4544, Root not integrated"; ERROR_NAME[-OB_INDEX_INELIGIBLE] = "OB_INDEX_INELIGIBLE"; + ERROR_CAUSE[-OB_INDEX_INELIGIBLE] = "Internal Error"; + ERROR_SOLUTION[-OB_INDEX_INELIGIBLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INDEX_INELIGIBLE] = -1; SQLSTATE[-OB_INDEX_INELIGIBLE] = "HY000"; STR_ERROR[-OB_INDEX_INELIGIBLE] = "index data not unique"; @@ -3215,6 +3934,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INDEX_INELIGIBLE] = "ORA-00600: internal error code, arguments: -4545, index data not unique"; ERROR_NAME[-OB_REBALANCE_EXEC_TIMEOUT] = "OB_REBALANCE_EXEC_TIMEOUT"; + ERROR_CAUSE[-OB_REBALANCE_EXEC_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_REBALANCE_EXEC_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_REBALANCE_EXEC_TIMEOUT] = -1; SQLSTATE[-OB_REBALANCE_EXEC_TIMEOUT] = "HY000"; STR_ERROR[-OB_REBALANCE_EXEC_TIMEOUT] = "execute replication or migration task timeout"; @@ -3225,6 +3946,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_REBALANCE_EXEC_TIMEOUT] = "ORA-00600: internal error code, arguments: -4546, execute replication or migration task timeout"; ERROR_NAME[-OB_MERGE_NOT_STARTED] = "OB_MERGE_NOT_STARTED"; + ERROR_CAUSE[-OB_MERGE_NOT_STARTED] = "Internal Error"; + ERROR_SOLUTION[-OB_MERGE_NOT_STARTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_MERGE_NOT_STARTED] = -1; SQLSTATE[-OB_MERGE_NOT_STARTED] = "HY000"; STR_ERROR[-OB_MERGE_NOT_STARTED] = "global merge not started"; @@ -3235,6 +3958,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_MERGE_NOT_STARTED] = "ORA-00600: internal error code, arguments: -4547, global merge not started"; ERROR_NAME[-OB_MERGE_ALREADY_STARTED] = "OB_MERGE_ALREADY_STARTED"; + ERROR_CAUSE[-OB_MERGE_ALREADY_STARTED] = "Internal Error"; + ERROR_SOLUTION[-OB_MERGE_ALREADY_STARTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_MERGE_ALREADY_STARTED] = -1; SQLSTATE[-OB_MERGE_ALREADY_STARTED] = "HY000"; STR_ERROR[-OB_MERGE_ALREADY_STARTED] = "merge already started"; @@ -3245,6 +3970,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_MERGE_ALREADY_STARTED] = "ORA-00600: internal error code, arguments: -4548, merge already started"; ERROR_NAME[-OB_ROOTSERVICE_EXIST] = "OB_ROOTSERVICE_EXIST"; + ERROR_CAUSE[-OB_ROOTSERVICE_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ROOTSERVICE_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ROOTSERVICE_EXIST] = -1; SQLSTATE[-OB_ROOTSERVICE_EXIST] = "HY000"; STR_ERROR[-OB_ROOTSERVICE_EXIST] = "rootservice already exist"; @@ -3255,6 +3982,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ROOTSERVICE_EXIST] = "ORA-00600: internal error code, arguments: -4549, rootservice already exist"; ERROR_NAME[-OB_RS_SHUTDOWN] = "OB_RS_SHUTDOWN"; + ERROR_CAUSE[-OB_RS_SHUTDOWN] = "Internal Error"; + ERROR_SOLUTION[-OB_RS_SHUTDOWN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RS_SHUTDOWN] = -1; SQLSTATE[-OB_RS_SHUTDOWN] = "HY000"; STR_ERROR[-OB_RS_SHUTDOWN] = "rootservice is shutdown"; @@ -3264,6 +3993,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RS_SHUTDOWN] = "ORA-00600: internal error code, arguments: -4550, rootservice is shutdown"; ERROR_NAME[-OB_SERVER_MIGRATE_IN_DENIED] = "OB_SERVER_MIGRATE_IN_DENIED"; + ERROR_CAUSE[-OB_SERVER_MIGRATE_IN_DENIED] = "Internal Error"; + ERROR_SOLUTION[-OB_SERVER_MIGRATE_IN_DENIED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SERVER_MIGRATE_IN_DENIED] = -1; SQLSTATE[-OB_SERVER_MIGRATE_IN_DENIED] = "HY000"; STR_ERROR[-OB_SERVER_MIGRATE_IN_DENIED] = "server migrate in denied"; @@ -3274,6 +4005,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SERVER_MIGRATE_IN_DENIED] = "ORA-00600: internal error code, arguments: -4551, server migrate in denied"; ERROR_NAME[-OB_REBALANCE_TASK_CANT_EXEC] = "OB_REBALANCE_TASK_CANT_EXEC"; + ERROR_CAUSE[-OB_REBALANCE_TASK_CANT_EXEC] = "Internal Error"; + ERROR_SOLUTION[-OB_REBALANCE_TASK_CANT_EXEC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_REBALANCE_TASK_CANT_EXEC] = -1; SQLSTATE[-OB_REBALANCE_TASK_CANT_EXEC] = "HY000"; STR_ERROR[-OB_REBALANCE_TASK_CANT_EXEC] = "rebalance task can not executing now"; @@ -3284,6 +4017,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_REBALANCE_TASK_CANT_EXEC] = "ORA-00600: internal error code, arguments: -4552, rebalance task can not executing now"; ERROR_NAME[-OB_PARTITION_CNT_REACH_ROOTSERVER_LIMIT] = "OB_PARTITION_CNT_REACH_ROOTSERVER_LIMIT"; + ERROR_CAUSE[-OB_PARTITION_CNT_REACH_ROOTSERVER_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_PARTITION_CNT_REACH_ROOTSERVER_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PARTITION_CNT_REACH_ROOTSERVER_LIMIT] = -1; SQLSTATE[-OB_PARTITION_CNT_REACH_ROOTSERVER_LIMIT] = "HY000"; STR_ERROR[-OB_PARTITION_CNT_REACH_ROOTSERVER_LIMIT] = "rootserver can not hold more partition"; @@ -3294,6 +4029,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PARTITION_CNT_REACH_ROOTSERVER_LIMIT] = "ORA-00600: internal error code, arguments: -4553, rootserver can not hold more partition"; ERROR_NAME[-OB_REBALANCE_TASK_NOT_IN_PROGRESS] = "OB_REBALANCE_TASK_NOT_IN_PROGRESS"; + ERROR_CAUSE[-OB_REBALANCE_TASK_NOT_IN_PROGRESS] = "Internal Error"; + ERROR_SOLUTION[-OB_REBALANCE_TASK_NOT_IN_PROGRESS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_REBALANCE_TASK_NOT_IN_PROGRESS] = -1; SQLSTATE[-OB_REBALANCE_TASK_NOT_IN_PROGRESS] = "HY000"; STR_ERROR[-OB_REBALANCE_TASK_NOT_IN_PROGRESS] = "rebalance task not in progress on observer"; @@ -3304,6 +4041,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_REBALANCE_TASK_NOT_IN_PROGRESS] = "ORA-00600: internal error code, arguments: -4554, rebalance task not in progress on observer"; ERROR_NAME[-OB_DATA_SOURCE_NOT_EXIST] = "OB_DATA_SOURCE_NOT_EXIST"; + ERROR_CAUSE[-OB_DATA_SOURCE_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_DATA_SOURCE_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DATA_SOURCE_NOT_EXIST] = -1; SQLSTATE[-OB_DATA_SOURCE_NOT_EXIST] = "HY000"; STR_ERROR[-OB_DATA_SOURCE_NOT_EXIST] = "Data source not exist"; @@ -3314,6 +4053,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DATA_SOURCE_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4600, Data source not exist"; ERROR_NAME[-OB_DATA_SOURCE_TABLE_NOT_EXIST] = "OB_DATA_SOURCE_TABLE_NOT_EXIST"; + ERROR_CAUSE[-OB_DATA_SOURCE_TABLE_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_DATA_SOURCE_TABLE_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DATA_SOURCE_TABLE_NOT_EXIST] = -1; SQLSTATE[-OB_DATA_SOURCE_TABLE_NOT_EXIST] = "HY000"; STR_ERROR[-OB_DATA_SOURCE_TABLE_NOT_EXIST] = "Data source table not exist"; @@ -3324,6 +4065,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DATA_SOURCE_TABLE_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4601, Data source table not exist"; ERROR_NAME[-OB_DATA_SOURCE_RANGE_NOT_EXIST] = "OB_DATA_SOURCE_RANGE_NOT_EXIST"; + ERROR_CAUSE[-OB_DATA_SOURCE_RANGE_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_DATA_SOURCE_RANGE_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DATA_SOURCE_RANGE_NOT_EXIST] = -1; SQLSTATE[-OB_DATA_SOURCE_RANGE_NOT_EXIST] = "HY000"; STR_ERROR[-OB_DATA_SOURCE_RANGE_NOT_EXIST] = "Data source range not exist"; @@ -3334,6 +4077,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DATA_SOURCE_RANGE_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4602, Data source range not exist"; ERROR_NAME[-OB_DATA_SOURCE_DATA_NOT_EXIST] = "OB_DATA_SOURCE_DATA_NOT_EXIST"; + ERROR_CAUSE[-OB_DATA_SOURCE_DATA_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_DATA_SOURCE_DATA_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DATA_SOURCE_DATA_NOT_EXIST] = -1; SQLSTATE[-OB_DATA_SOURCE_DATA_NOT_EXIST] = "HY000"; STR_ERROR[-OB_DATA_SOURCE_DATA_NOT_EXIST] = "Data source data not exist"; @@ -3344,6 +4089,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DATA_SOURCE_DATA_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4603, Data source data not exist"; ERROR_NAME[-OB_DATA_SOURCE_SYS_ERROR] = "OB_DATA_SOURCE_SYS_ERROR"; + ERROR_CAUSE[-OB_DATA_SOURCE_SYS_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_DATA_SOURCE_SYS_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DATA_SOURCE_SYS_ERROR] = -1; SQLSTATE[-OB_DATA_SOURCE_SYS_ERROR] = "HY000"; STR_ERROR[-OB_DATA_SOURCE_SYS_ERROR] = "Data source sys error"; @@ -3354,6 +4101,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DATA_SOURCE_SYS_ERROR] = "ORA-00600: internal error code, arguments: -4604, Data source sys error"; ERROR_NAME[-OB_DATA_SOURCE_TIMEOUT] = "OB_DATA_SOURCE_TIMEOUT"; + ERROR_CAUSE[-OB_DATA_SOURCE_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_DATA_SOURCE_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DATA_SOURCE_TIMEOUT] = -1; SQLSTATE[-OB_DATA_SOURCE_TIMEOUT] = "HY000"; STR_ERROR[-OB_DATA_SOURCE_TIMEOUT] = "Data source timeout"; @@ -3363,6 +4112,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DATA_SOURCE_TIMEOUT] = "ORA-00600: internal error code, arguments: -4605, Data source timeout"; ERROR_NAME[-OB_DATA_SOURCE_CONCURRENCY_FULL] = "OB_DATA_SOURCE_CONCURRENCY_FULL"; + ERROR_CAUSE[-OB_DATA_SOURCE_CONCURRENCY_FULL] = "Internal Error"; + ERROR_SOLUTION[-OB_DATA_SOURCE_CONCURRENCY_FULL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DATA_SOURCE_CONCURRENCY_FULL] = -1; SQLSTATE[-OB_DATA_SOURCE_CONCURRENCY_FULL] = "53000"; STR_ERROR[-OB_DATA_SOURCE_CONCURRENCY_FULL] = "Data source concurrency full"; @@ -3373,6 +4124,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DATA_SOURCE_CONCURRENCY_FULL] = "ORA-00600: internal error code, arguments: -4606, Data source concurrency full"; ERROR_NAME[-OB_DATA_SOURCE_WRONG_URI_FORMAT] = "OB_DATA_SOURCE_WRONG_URI_FORMAT"; + ERROR_CAUSE[-OB_DATA_SOURCE_WRONG_URI_FORMAT] = "Internal Error"; + ERROR_SOLUTION[-OB_DATA_SOURCE_WRONG_URI_FORMAT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DATA_SOURCE_WRONG_URI_FORMAT] = -1; SQLSTATE[-OB_DATA_SOURCE_WRONG_URI_FORMAT] = "42000"; STR_ERROR[-OB_DATA_SOURCE_WRONG_URI_FORMAT] = "Data source wrong URI format"; @@ -3383,6 +4136,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DATA_SOURCE_WRONG_URI_FORMAT] = "ORA-00600: internal error code, arguments: -4607, Data source wrong URI format"; ERROR_NAME[-OB_SSTABLE_VERSION_UNEQUAL] = "OB_SSTABLE_VERSION_UNEQUAL"; + ERROR_CAUSE[-OB_SSTABLE_VERSION_UNEQUAL] = "Internal Error"; + ERROR_SOLUTION[-OB_SSTABLE_VERSION_UNEQUAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SSTABLE_VERSION_UNEQUAL] = -1; SQLSTATE[-OB_SSTABLE_VERSION_UNEQUAL] = "42000"; STR_ERROR[-OB_SSTABLE_VERSION_UNEQUAL] = "SSTable version not equal"; @@ -3393,6 +4148,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SSTABLE_VERSION_UNEQUAL] = "ORA-00600: internal error code, arguments: -4608, SSTable version not equal"; ERROR_NAME[-OB_UPS_RENEW_LEASE_NOT_ALLOWED] = "OB_UPS_RENEW_LEASE_NOT_ALLOWED"; + ERROR_CAUSE[-OB_UPS_RENEW_LEASE_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_UPS_RENEW_LEASE_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_UPS_RENEW_LEASE_NOT_ALLOWED] = -1; SQLSTATE[-OB_UPS_RENEW_LEASE_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_UPS_RENEW_LEASE_NOT_ALLOWED] = "ups should not renew its lease"; @@ -3403,6 +4160,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_UPS_RENEW_LEASE_NOT_ALLOWED] = "ORA-00600: internal error code, arguments: -4609, ups should not renew its lease"; ERROR_NAME[-OB_UPS_COUNT_OVER_LIMIT] = "OB_UPS_COUNT_OVER_LIMIT"; + ERROR_CAUSE[-OB_UPS_COUNT_OVER_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_UPS_COUNT_OVER_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_UPS_COUNT_OVER_LIMIT] = -1; SQLSTATE[-OB_UPS_COUNT_OVER_LIMIT] = "HY000"; STR_ERROR[-OB_UPS_COUNT_OVER_LIMIT] = "ups count over limit"; @@ -3413,6 +4172,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_UPS_COUNT_OVER_LIMIT] = "ORA-00600: internal error code, arguments: -4610, ups count over limit"; ERROR_NAME[-OB_NO_UPS_MAJORITY] = "OB_NO_UPS_MAJORITY"; + ERROR_CAUSE[-OB_NO_UPS_MAJORITY] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_UPS_MAJORITY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_UPS_MAJORITY] = -1; SQLSTATE[-OB_NO_UPS_MAJORITY] = "HY000"; STR_ERROR[-OB_NO_UPS_MAJORITY] = "ups not form a majority"; @@ -3422,6 +4183,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NO_UPS_MAJORITY] = "ORA-00600: internal error code, arguments: -4611, ups not form a majority"; ERROR_NAME[-OB_INDEX_COUNT_REACH_THE_LIMIT] = "OB_INDEX_COUNT_REACH_THE_LIMIT"; + ERROR_CAUSE[-OB_INDEX_COUNT_REACH_THE_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_INDEX_COUNT_REACH_THE_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INDEX_COUNT_REACH_THE_LIMIT] = -1; SQLSTATE[-OB_INDEX_COUNT_REACH_THE_LIMIT] = "HY000"; STR_ERROR[-OB_INDEX_COUNT_REACH_THE_LIMIT] = "created index tables count has reach the limit:128"; @@ -3432,6 +4195,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INDEX_COUNT_REACH_THE_LIMIT] = "ORA-00600: internal error code, arguments: -4613, created index tables count has reach the limit:128"; ERROR_NAME[-OB_TASK_EXPIRED] = "OB_TASK_EXPIRED"; + ERROR_CAUSE[-OB_TASK_EXPIRED] = "Internal Error"; + ERROR_SOLUTION[-OB_TASK_EXPIRED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TASK_EXPIRED] = -1; SQLSTATE[-OB_TASK_EXPIRED] = "HY000"; STR_ERROR[-OB_TASK_EXPIRED] = "task expired"; @@ -3440,6 +4205,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TASK_EXPIRED] = "ORA-00600: internal error code, arguments: -4614, task expired"; ORACLE_STR_USER_ERROR[-OB_TASK_EXPIRED] = "ORA-00600: internal error code, arguments: -4614, task expired"; ERROR_NAME[-OB_TABLEGROUP_NOT_EMPTY] = "OB_TABLEGROUP_NOT_EMPTY"; + ERROR_CAUSE[-OB_TABLEGROUP_NOT_EMPTY] = "Internal Error"; + ERROR_SOLUTION[-OB_TABLEGROUP_NOT_EMPTY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TABLEGROUP_NOT_EMPTY] = -1; SQLSTATE[-OB_TABLEGROUP_NOT_EMPTY] = "HY000"; STR_ERROR[-OB_TABLEGROUP_NOT_EMPTY] = "tablegroup is not empty"; @@ -3450,6 +4217,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TABLEGROUP_NOT_EMPTY] = "ORA-00600: internal error code, arguments: -4615, tablegroup is not empty"; ERROR_NAME[-OB_INVALID_SERVER_STATUS] = "OB_INVALID_SERVER_STATUS"; + ERROR_CAUSE[-OB_INVALID_SERVER_STATUS] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_SERVER_STATUS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_SERVER_STATUS] = -1; SQLSTATE[-OB_INVALID_SERVER_STATUS] = "HY000"; STR_ERROR[-OB_INVALID_SERVER_STATUS] = "server status is not valid"; @@ -3460,6 +4229,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_SERVER_STATUS] = "ORA-00600: internal error code, arguments: -4620, server status is not valid"; ERROR_NAME[-OB_WAIT_ELEC_LEADER_TIMEOUT] = "OB_WAIT_ELEC_LEADER_TIMEOUT"; + ERROR_CAUSE[-OB_WAIT_ELEC_LEADER_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_WAIT_ELEC_LEADER_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WAIT_ELEC_LEADER_TIMEOUT] = -1; SQLSTATE[-OB_WAIT_ELEC_LEADER_TIMEOUT] = "HY000"; STR_ERROR[-OB_WAIT_ELEC_LEADER_TIMEOUT] = "wait elect partition leader timeout"; @@ -3470,6 +4241,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_WAIT_ELEC_LEADER_TIMEOUT] = "ORA-00600: internal error code, arguments: -4621, wait elect partition leader timeout"; ERROR_NAME[-OB_WAIT_ALL_RS_ONLINE_TIMEOUT] = "OB_WAIT_ALL_RS_ONLINE_TIMEOUT"; + ERROR_CAUSE[-OB_WAIT_ALL_RS_ONLINE_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_WAIT_ALL_RS_ONLINE_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WAIT_ALL_RS_ONLINE_TIMEOUT] = -1; SQLSTATE[-OB_WAIT_ALL_RS_ONLINE_TIMEOUT] = "HY000"; STR_ERROR[-OB_WAIT_ALL_RS_ONLINE_TIMEOUT] = "wait all rs online timeout"; @@ -3480,6 +4253,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_WAIT_ALL_RS_ONLINE_TIMEOUT] = "ORA-00600: internal error code, arguments: -4622, wait all rs online timeout"; ERROR_NAME[-OB_ALL_REPLICAS_ON_MERGE_ZONE] = "OB_ALL_REPLICAS_ON_MERGE_ZONE"; + ERROR_CAUSE[-OB_ALL_REPLICAS_ON_MERGE_ZONE] = "Internal Error"; + ERROR_SOLUTION[-OB_ALL_REPLICAS_ON_MERGE_ZONE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ALL_REPLICAS_ON_MERGE_ZONE] = -1; SQLSTATE[-OB_ALL_REPLICAS_ON_MERGE_ZONE] = "HY000"; STR_ERROR[-OB_ALL_REPLICAS_ON_MERGE_ZONE] = "all replicas of partition group are on zones to merge"; @@ -3490,6 +4265,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ALL_REPLICAS_ON_MERGE_ZONE] = "ORA-00600: internal error code, arguments: -4623, all replicas of partition group are on zones to merge"; ERROR_NAME[-OB_MACHINE_RESOURCE_NOT_ENOUGH] = "OB_MACHINE_RESOURCE_NOT_ENOUGH"; + ERROR_CAUSE[-OB_MACHINE_RESOURCE_NOT_ENOUGH] = "Internal Error"; + ERROR_SOLUTION[-OB_MACHINE_RESOURCE_NOT_ENOUGH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_MACHINE_RESOURCE_NOT_ENOUGH] = -1; SQLSTATE[-OB_MACHINE_RESOURCE_NOT_ENOUGH] = "HY000"; STR_ERROR[-OB_MACHINE_RESOURCE_NOT_ENOUGH] = "machine resource is not enough to hold a new unit"; @@ -3500,6 +4277,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_MACHINE_RESOURCE_NOT_ENOUGH] = "ORA-00600: internal error code, arguments: -4624, machine resource \'%s\' is not enough to hold a new unit"; ERROR_NAME[-OB_NOT_SERVER_CAN_HOLD_SOFTLY] = "OB_NOT_SERVER_CAN_HOLD_SOFTLY"; + ERROR_CAUSE[-OB_NOT_SERVER_CAN_HOLD_SOFTLY] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_SERVER_CAN_HOLD_SOFTLY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_SERVER_CAN_HOLD_SOFTLY] = -1; SQLSTATE[-OB_NOT_SERVER_CAN_HOLD_SOFTLY] = "HY000"; STR_ERROR[-OB_NOT_SERVER_CAN_HOLD_SOFTLY] = "not server can hole the unit and not over soft limit"; @@ -3510,6 +4289,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NOT_SERVER_CAN_HOLD_SOFTLY] = "ORA-00600: internal error code, arguments: -4625, not server can hole the unit and not over soft limit"; ERROR_NAME[-OB_RESOURCE_POOL_ALREADY_GRANTED] = "OB_RESOURCE_POOL_ALREADY_GRANTED"; + ERROR_CAUSE[-OB_RESOURCE_POOL_ALREADY_GRANTED] = "Internal Error"; + ERROR_SOLUTION[-OB_RESOURCE_POOL_ALREADY_GRANTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RESOURCE_POOL_ALREADY_GRANTED] = -1; SQLSTATE[-OB_RESOURCE_POOL_ALREADY_GRANTED] = "HY000"; STR_ERROR[-OB_RESOURCE_POOL_ALREADY_GRANTED] = "resource pool has already been granted to a tenant"; @@ -3520,6 +4301,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RESOURCE_POOL_ALREADY_GRANTED] = "ORA-00600: internal error code, arguments: -4626, resource pool \'%s\' has already been granted to a tenant"; ERROR_NAME[-OB_SERVER_ALREADY_DELETED] = "OB_SERVER_ALREADY_DELETED"; + ERROR_CAUSE[-OB_SERVER_ALREADY_DELETED] = "Internal Error"; + ERROR_SOLUTION[-OB_SERVER_ALREADY_DELETED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SERVER_ALREADY_DELETED] = -1; SQLSTATE[-OB_SERVER_ALREADY_DELETED] = "HY000"; STR_ERROR[-OB_SERVER_ALREADY_DELETED] = "server has already been deleted"; @@ -3530,6 +4313,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SERVER_ALREADY_DELETED] = "ORA-00600: internal error code, arguments: -4628, server has already been deleted"; ERROR_NAME[-OB_SERVER_NOT_DELETING] = "OB_SERVER_NOT_DELETING"; + ERROR_CAUSE[-OB_SERVER_NOT_DELETING] = "Internal Error"; + ERROR_SOLUTION[-OB_SERVER_NOT_DELETING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SERVER_NOT_DELETING] = -1; SQLSTATE[-OB_SERVER_NOT_DELETING] = "HY000"; STR_ERROR[-OB_SERVER_NOT_DELETING] = "server is not in deleting status"; @@ -3540,6 +4325,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SERVER_NOT_DELETING] = "ORA-00600: internal error code, arguments: -4629, server is not in deleting status"; ERROR_NAME[-OB_SERVER_NOT_IN_WHITE_LIST] = "OB_SERVER_NOT_IN_WHITE_LIST"; + ERROR_CAUSE[-OB_SERVER_NOT_IN_WHITE_LIST] = "Internal Error"; + ERROR_SOLUTION[-OB_SERVER_NOT_IN_WHITE_LIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SERVER_NOT_IN_WHITE_LIST] = -1; SQLSTATE[-OB_SERVER_NOT_IN_WHITE_LIST] = "HY000"; STR_ERROR[-OB_SERVER_NOT_IN_WHITE_LIST] = "server not in server white list"; @@ -3550,6 +4337,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SERVER_NOT_IN_WHITE_LIST] = "ORA-00600: internal error code, arguments: -4630, server not in server white list"; ERROR_NAME[-OB_SERVER_ZONE_NOT_MATCH] = "OB_SERVER_ZONE_NOT_MATCH"; + ERROR_CAUSE[-OB_SERVER_ZONE_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_SERVER_ZONE_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SERVER_ZONE_NOT_MATCH] = -1; SQLSTATE[-OB_SERVER_ZONE_NOT_MATCH] = "HY000"; STR_ERROR[-OB_SERVER_ZONE_NOT_MATCH] = "server zone not match"; @@ -3560,6 +4349,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SERVER_ZONE_NOT_MATCH] = "ORA-00600: internal error code, arguments: -4631, server zone not match"; ERROR_NAME[-OB_OVER_ZONE_NUM_LIMIT] = "OB_OVER_ZONE_NUM_LIMIT"; + ERROR_CAUSE[-OB_OVER_ZONE_NUM_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_OVER_ZONE_NUM_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OVER_ZONE_NUM_LIMIT] = -1; SQLSTATE[-OB_OVER_ZONE_NUM_LIMIT] = "HY000"; STR_ERROR[-OB_OVER_ZONE_NUM_LIMIT] = "zone num has reach max zone num"; @@ -3570,6 +4361,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_OVER_ZONE_NUM_LIMIT] = "ORA-00600: internal error code, arguments: -4632, zone num has reach max zone num"; ERROR_NAME[-OB_ZONE_STATUS_NOT_MATCH] = "OB_ZONE_STATUS_NOT_MATCH"; + ERROR_CAUSE[-OB_ZONE_STATUS_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_ZONE_STATUS_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ZONE_STATUS_NOT_MATCH] = -1; SQLSTATE[-OB_ZONE_STATUS_NOT_MATCH] = "HY000"; STR_ERROR[-OB_ZONE_STATUS_NOT_MATCH] = "zone status not match"; @@ -3580,6 +4373,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ZONE_STATUS_NOT_MATCH] = "ORA-00600: internal error code, arguments: -4633, zone status not match"; ERROR_NAME[-OB_RESOURCE_UNIT_IS_REFERENCED] = "OB_RESOURCE_UNIT_IS_REFERENCED"; + ERROR_CAUSE[-OB_RESOURCE_UNIT_IS_REFERENCED] = "Internal Error"; + ERROR_SOLUTION[-OB_RESOURCE_UNIT_IS_REFERENCED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RESOURCE_UNIT_IS_REFERENCED] = -1; SQLSTATE[-OB_RESOURCE_UNIT_IS_REFERENCED] = "HY000"; STR_ERROR[-OB_RESOURCE_UNIT_IS_REFERENCED] = "resource unit is referenced by resource pool"; @@ -3590,6 +4385,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RESOURCE_UNIT_IS_REFERENCED] = "ORA-00600: internal error code, arguments: -4634, resource unit \'%s\' is referenced by some resource pool"; ERROR_NAME[-OB_DIFFERENT_PRIMARY_ZONE] = "OB_DIFFERENT_PRIMARY_ZONE"; + ERROR_CAUSE[-OB_DIFFERENT_PRIMARY_ZONE] = "Internal Error"; + ERROR_SOLUTION[-OB_DIFFERENT_PRIMARY_ZONE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DIFFERENT_PRIMARY_ZONE] = -1; SQLSTATE[-OB_DIFFERENT_PRIMARY_ZONE] = "HY000"; STR_ERROR[-OB_DIFFERENT_PRIMARY_ZONE] = "table schema primary zone different with other table in sampe tablegroup"; @@ -3602,6 +4399,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -4636, table schema primary zone different with other table in " "sampe tablegroup"; ERROR_NAME[-OB_SERVER_NOT_ACTIVE] = "OB_SERVER_NOT_ACTIVE"; + ERROR_CAUSE[-OB_SERVER_NOT_ACTIVE] = "Internal Error"; + ERROR_SOLUTION[-OB_SERVER_NOT_ACTIVE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SERVER_NOT_ACTIVE] = -1; SQLSTATE[-OB_SERVER_NOT_ACTIVE] = "HY000"; STR_ERROR[-OB_SERVER_NOT_ACTIVE] = "server is not active"; @@ -3611,6 +4410,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SERVER_NOT_ACTIVE] = "ORA-00600: internal error code, arguments: -4637, server is not active"; ERROR_NAME[-OB_RS_NOT_MASTER] = "OB_RS_NOT_MASTER"; + ERROR_CAUSE[-OB_RS_NOT_MASTER] = "Internal Error"; + ERROR_SOLUTION[-OB_RS_NOT_MASTER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RS_NOT_MASTER] = -1; SQLSTATE[-OB_RS_NOT_MASTER] = "HY000"; STR_ERROR[-OB_RS_NOT_MASTER] = "The RootServer is not the master"; @@ -3621,6 +4422,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RS_NOT_MASTER] = "ORA-00600: internal error code, arguments: -4638, The RootServer is not the master"; ERROR_NAME[-OB_CANDIDATE_LIST_ERROR] = "OB_CANDIDATE_LIST_ERROR"; + ERROR_CAUSE[-OB_CANDIDATE_LIST_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_CANDIDATE_LIST_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANDIDATE_LIST_ERROR] = -1; SQLSTATE[-OB_CANDIDATE_LIST_ERROR] = "HY000"; STR_ERROR[-OB_CANDIDATE_LIST_ERROR] = "The candidate list is invalid"; @@ -3631,6 +4434,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CANDIDATE_LIST_ERROR] = "ORA-00600: internal error code, arguments: -4639, The candidate list is invalid"; ERROR_NAME[-OB_PARTITION_ZONE_DUPLICATED] = "OB_PARTITION_ZONE_DUPLICATED"; + ERROR_CAUSE[-OB_PARTITION_ZONE_DUPLICATED] = "Internal Error"; + ERROR_SOLUTION[-OB_PARTITION_ZONE_DUPLICATED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PARTITION_ZONE_DUPLICATED] = -1; SQLSTATE[-OB_PARTITION_ZONE_DUPLICATED] = "HY000"; STR_ERROR[-OB_PARTITION_ZONE_DUPLICATED] = "The chosen partition servers belong to same zone."; @@ -3641,6 +4446,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PARTITION_ZONE_DUPLICATED] = "ORA-00600: internal error code, arguments: -4640, The chosen partition servers belong to same zone."; ERROR_NAME[-OB_ZONE_DUPLICATED] = "OB_ZONE_DUPLICATED"; + ERROR_CAUSE[-OB_ZONE_DUPLICATED] = "Internal Error"; + ERROR_SOLUTION[-OB_ZONE_DUPLICATED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ZONE_DUPLICATED] = -1; SQLSTATE[-OB_ZONE_DUPLICATED] = "HY000"; STR_ERROR[-OB_ZONE_DUPLICATED] = "Duplicated zone in zone list"; @@ -3651,6 +4458,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ZONE_DUPLICATED] = "ORA-00600: internal error code, arguments: -4641, Duplicated zone \'%s\' in zone list %s"; ERROR_NAME[-OB_NOT_ALL_ZONE_ACTIVE] = "OB_NOT_ALL_ZONE_ACTIVE"; + ERROR_CAUSE[-OB_NOT_ALL_ZONE_ACTIVE] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_ALL_ZONE_ACTIVE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_ALL_ZONE_ACTIVE] = -1; SQLSTATE[-OB_NOT_ALL_ZONE_ACTIVE] = "HY000"; STR_ERROR[-OB_NOT_ALL_ZONE_ACTIVE] = "Not all zone in zone list are active"; @@ -3661,6 +4470,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NOT_ALL_ZONE_ACTIVE] = "ORA-00600: internal error code, arguments: -4642, Not all zone in zone list are active"; ERROR_NAME[-OB_PRIMARY_ZONE_NOT_IN_ZONE_LIST] = "OB_PRIMARY_ZONE_NOT_IN_ZONE_LIST"; + ERROR_CAUSE[-OB_PRIMARY_ZONE_NOT_IN_ZONE_LIST] = "Internal Error"; + ERROR_SOLUTION[-OB_PRIMARY_ZONE_NOT_IN_ZONE_LIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PRIMARY_ZONE_NOT_IN_ZONE_LIST] = -1; SQLSTATE[-OB_PRIMARY_ZONE_NOT_IN_ZONE_LIST] = "HY000"; STR_ERROR[-OB_PRIMARY_ZONE_NOT_IN_ZONE_LIST] = "primary zone not in zone list"; @@ -3671,6 +4482,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PRIMARY_ZONE_NOT_IN_ZONE_LIST] = "ORA-00600: internal error code, arguments: -4643, primary zone \'%s\' not in zone list %s"; ERROR_NAME[-OB_REPLICA_NUM_NOT_MATCH] = "OB_REPLICA_NUM_NOT_MATCH"; + ERROR_CAUSE[-OB_REPLICA_NUM_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_REPLICA_NUM_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_REPLICA_NUM_NOT_MATCH] = -1; SQLSTATE[-OB_REPLICA_NUM_NOT_MATCH] = "HY000"; STR_ERROR[-OB_REPLICA_NUM_NOT_MATCH] = "replica num not same with zone count"; @@ -3681,6 +4494,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_REPLICA_NUM_NOT_MATCH] = "ORA-00600: internal error code, arguments: -4644, replica num not same with zone count"; ERROR_NAME[-OB_ZONE_LIST_POOL_LIST_NOT_MATCH] = "OB_ZONE_LIST_POOL_LIST_NOT_MATCH"; + ERROR_CAUSE[-OB_ZONE_LIST_POOL_LIST_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_ZONE_LIST_POOL_LIST_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ZONE_LIST_POOL_LIST_NOT_MATCH] = -1; SQLSTATE[-OB_ZONE_LIST_POOL_LIST_NOT_MATCH] = "HY000"; STR_ERROR[-OB_ZONE_LIST_POOL_LIST_NOT_MATCH] = "zone list not a subset of resource pool list"; @@ -3691,6 +4506,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ZONE_LIST_POOL_LIST_NOT_MATCH] = "ORA-00600: internal error code, arguments: -4645, zone list %s not a subset of resource pool zone list %s"; ERROR_NAME[-OB_INVALID_TENANT_NAME] = "OB_INVALID_TENANT_NAME"; + ERROR_CAUSE[-OB_INVALID_TENANT_NAME] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_TENANT_NAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_TENANT_NAME] = -1; SQLSTATE[-OB_INVALID_TENANT_NAME] = "HY000"; STR_ERROR[-OB_INVALID_TENANT_NAME] = "tenant name is too long"; @@ -3701,6 +4518,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_TENANT_NAME] = "ORA-00600: internal error code, arguments: -4646, tenant name \'%s\' over max_tenant_name_length %ld"; ERROR_NAME[-OB_EMPTY_RESOURCE_POOL_LIST] = "OB_EMPTY_RESOURCE_POOL_LIST"; + ERROR_CAUSE[-OB_EMPTY_RESOURCE_POOL_LIST] = "Internal Error"; + ERROR_SOLUTION[-OB_EMPTY_RESOURCE_POOL_LIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_EMPTY_RESOURCE_POOL_LIST] = -1; SQLSTATE[-OB_EMPTY_RESOURCE_POOL_LIST] = "HY000"; STR_ERROR[-OB_EMPTY_RESOURCE_POOL_LIST] = "resource pool list is empty"; @@ -3711,6 +4530,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_EMPTY_RESOURCE_POOL_LIST] = "ORA-00600: internal error code, arguments: -4647, resource pool list is empty"; ERROR_NAME[-OB_RESOURCE_UNIT_NOT_EXIST] = "OB_RESOURCE_UNIT_NOT_EXIST"; + ERROR_CAUSE[-OB_RESOURCE_UNIT_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_RESOURCE_UNIT_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RESOURCE_UNIT_NOT_EXIST] = -1; SQLSTATE[-OB_RESOURCE_UNIT_NOT_EXIST] = "HY000"; STR_ERROR[-OB_RESOURCE_UNIT_NOT_EXIST] = "resource unit not exist"; @@ -3721,6 +4542,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RESOURCE_UNIT_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4648, resource unit \'%s\' not exist"; ERROR_NAME[-OB_RESOURCE_UNIT_EXIST] = "OB_RESOURCE_UNIT_EXIST"; + ERROR_CAUSE[-OB_RESOURCE_UNIT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_RESOURCE_UNIT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RESOURCE_UNIT_EXIST] = -1; SQLSTATE[-OB_RESOURCE_UNIT_EXIST] = "HY000"; STR_ERROR[-OB_RESOURCE_UNIT_EXIST] = "resource unit already exist"; @@ -3731,6 +4554,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RESOURCE_UNIT_EXIST] = "ORA-00600: internal error code, arguments: -4649, resource unit \'%s\' already exist"; ERROR_NAME[-OB_RESOURCE_POOL_NOT_EXIST] = "OB_RESOURCE_POOL_NOT_EXIST"; + ERROR_CAUSE[-OB_RESOURCE_POOL_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_RESOURCE_POOL_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RESOURCE_POOL_NOT_EXIST] = -1; SQLSTATE[-OB_RESOURCE_POOL_NOT_EXIST] = "HY000"; STR_ERROR[-OB_RESOURCE_POOL_NOT_EXIST] = "resource pool not exist"; @@ -3741,6 +4566,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RESOURCE_POOL_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4650, resource pool \'%s\' not exist"; ERROR_NAME[-OB_RESOURCE_POOL_EXIST] = "OB_RESOURCE_POOL_EXIST"; + ERROR_CAUSE[-OB_RESOURCE_POOL_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_RESOURCE_POOL_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RESOURCE_POOL_EXIST] = -1; SQLSTATE[-OB_RESOURCE_POOL_EXIST] = "HY000"; STR_ERROR[-OB_RESOURCE_POOL_EXIST] = "resource pool already exist"; @@ -3751,6 +4578,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RESOURCE_POOL_EXIST] = "ORA-00600: internal error code, arguments: -4651, resource pool \'%s\' exist"; ERROR_NAME[-OB_WAIT_LEADER_SWITCH_TIMEOUT] = "OB_WAIT_LEADER_SWITCH_TIMEOUT"; + ERROR_CAUSE[-OB_WAIT_LEADER_SWITCH_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_WAIT_LEADER_SWITCH_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WAIT_LEADER_SWITCH_TIMEOUT] = -1; SQLSTATE[-OB_WAIT_LEADER_SWITCH_TIMEOUT] = "HY000"; STR_ERROR[-OB_WAIT_LEADER_SWITCH_TIMEOUT] = "wait leader switch timeout"; @@ -3761,6 +4590,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_WAIT_LEADER_SWITCH_TIMEOUT] = "ORA-00600: internal error code, arguments: -4652, wait leader switch timeout"; ERROR_NAME[-OB_LOCATION_NOT_EXIST] = "OB_LOCATION_NOT_EXIST"; + ERROR_CAUSE[-OB_LOCATION_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_LOCATION_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOCATION_NOT_EXIST] = -1; SQLSTATE[-OB_LOCATION_NOT_EXIST] = "HY000"; STR_ERROR[-OB_LOCATION_NOT_EXIST] = "location not exist"; @@ -3770,6 +4601,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LOCATION_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4653, location not exist"; ERROR_NAME[-OB_LOCATION_LEADER_NOT_EXIST] = "OB_LOCATION_LEADER_NOT_EXIST"; + ERROR_CAUSE[-OB_LOCATION_LEADER_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_LOCATION_LEADER_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOCATION_LEADER_NOT_EXIST] = -1; SQLSTATE[-OB_LOCATION_LEADER_NOT_EXIST] = "HY000"; STR_ERROR[-OB_LOCATION_LEADER_NOT_EXIST] = "location leader not exist"; @@ -3780,6 +4613,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LOCATION_LEADER_NOT_EXIST] = "ORA-00600: internal error code, arguments: -4654, location leader not exist"; ERROR_NAME[-OB_ZONE_NOT_ACTIVE] = "OB_ZONE_NOT_ACTIVE"; + ERROR_CAUSE[-OB_ZONE_NOT_ACTIVE] = "Internal Error"; + ERROR_SOLUTION[-OB_ZONE_NOT_ACTIVE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ZONE_NOT_ACTIVE] = -1; SQLSTATE[-OB_ZONE_NOT_ACTIVE] = "HY000"; STR_ERROR[-OB_ZONE_NOT_ACTIVE] = "zone not active"; @@ -3788,6 +4623,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ZONE_NOT_ACTIVE] = "ORA-00600: internal error code, arguments: -4655, zone not active"; ORACLE_STR_USER_ERROR[-OB_ZONE_NOT_ACTIVE] = "ORA-00600: internal error code, arguments: -4655, zone not active"; ERROR_NAME[-OB_UNIT_NUM_OVER_SERVER_COUNT] = "OB_UNIT_NUM_OVER_SERVER_COUNT"; + ERROR_CAUSE[-OB_UNIT_NUM_OVER_SERVER_COUNT] = "Internal Error"; + ERROR_SOLUTION[-OB_UNIT_NUM_OVER_SERVER_COUNT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_UNIT_NUM_OVER_SERVER_COUNT] = -1; SQLSTATE[-OB_UNIT_NUM_OVER_SERVER_COUNT] = "HY000"; STR_ERROR[-OB_UNIT_NUM_OVER_SERVER_COUNT] = "resource pool unit num is bigger than zone server count"; @@ -3798,6 +4635,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_UNIT_NUM_OVER_SERVER_COUNT] = "ORA-00600: internal error code, arguments: -4656, resource pool unit num is bigger than zone server count"; ERROR_NAME[-OB_POOL_SERVER_INTERSECT] = "OB_POOL_SERVER_INTERSECT"; + ERROR_CAUSE[-OB_POOL_SERVER_INTERSECT] = "Internal Error"; + ERROR_SOLUTION[-OB_POOL_SERVER_INTERSECT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_POOL_SERVER_INTERSECT] = -1; SQLSTATE[-OB_POOL_SERVER_INTERSECT] = "HY000"; STR_ERROR[-OB_POOL_SERVER_INTERSECT] = "resource pool list unit server intersect"; @@ -3808,6 +4647,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_POOL_SERVER_INTERSECT] = "ORA-00600: internal error code, arguments: -4657, resource pool list %s unit servers intersect"; ERROR_NAME[-OB_NOT_SINGLE_RESOURCE_POOL] = "OB_NOT_SINGLE_RESOURCE_POOL"; + ERROR_CAUSE[-OB_NOT_SINGLE_RESOURCE_POOL] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_SINGLE_RESOURCE_POOL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_SINGLE_RESOURCE_POOL] = -1; SQLSTATE[-OB_NOT_SINGLE_RESOURCE_POOL] = "HY000"; STR_ERROR[-OB_NOT_SINGLE_RESOURCE_POOL] = "create tenant only support single resource pool now"; @@ -3820,6 +4661,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -4658, create tenant only support single resource pool now, but " "pool list is %s"; ERROR_NAME[-OB_INVALID_RESOURCE_UNIT] = "OB_INVALID_RESOURCE_UNIT"; + ERROR_CAUSE[-OB_INVALID_RESOURCE_UNIT] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_RESOURCE_UNIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_RESOURCE_UNIT] = -1; SQLSTATE[-OB_INVALID_RESOURCE_UNIT] = "HY000"; STR_ERROR[-OB_INVALID_RESOURCE_UNIT] = "invalid resource unit"; @@ -3830,6 +4673,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_RESOURCE_UNIT] = "ORA-00600: internal error code, arguments: -4659, invalid resource unit, %s\'s min value is %s"; ERROR_NAME[-OB_STOP_SERVER_IN_MULTIPLE_ZONES] = "OB_STOP_SERVER_IN_MULTIPLE_ZONES"; + ERROR_CAUSE[-OB_STOP_SERVER_IN_MULTIPLE_ZONES] = "Internal Error"; + ERROR_SOLUTION[-OB_STOP_SERVER_IN_MULTIPLE_ZONES] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_STOP_SERVER_IN_MULTIPLE_ZONES] = -1; SQLSTATE[-OB_STOP_SERVER_IN_MULTIPLE_ZONES] = "HY000"; STR_ERROR[-OB_STOP_SERVER_IN_MULTIPLE_ZONES] = "Can not stop server in multiple zones"; @@ -3839,6 +4684,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -4660, Can not stop server in multiple zones"; ORACLE_STR_USER_ERROR[-OB_STOP_SERVER_IN_MULTIPLE_ZONES] = "ORA-00600: internal error code, arguments: -4660, %s"; ERROR_NAME[-OB_SESSION_ENTRY_EXIST] = "OB_SESSION_ENTRY_EXIST"; + ERROR_CAUSE[-OB_SESSION_ENTRY_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_SESSION_ENTRY_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SESSION_ENTRY_EXIST] = -1; SQLSTATE[-OB_SESSION_ENTRY_EXIST] = "HY000"; STR_ERROR[-OB_SESSION_ENTRY_EXIST] = "Session already exist"; @@ -3849,6 +4696,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SESSION_ENTRY_EXIST] = "ORA-00600: internal error code, arguments: -4661, Session already exist"; ERROR_NAME[-OB_GOT_SIGNAL_ABORTING] = "OB_GOT_SIGNAL_ABORTING"; + ERROR_CAUSE[-OB_GOT_SIGNAL_ABORTING] = "Internal Error"; + ERROR_SOLUTION[-OB_GOT_SIGNAL_ABORTING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_GOT_SIGNAL_ABORTING] = ER_GOT_SIGNAL; SQLSTATE[-OB_GOT_SIGNAL_ABORTING] = "01000"; STR_ERROR[-OB_GOT_SIGNAL_ABORTING] = "Got signal. Aborting!"; @@ -3859,6 +4708,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_GOT_SIGNAL_ABORTING] = "ORA-00600: internal error code, arguments: -4662, %s: Got signal %d. Aborting!"; ERROR_NAME[-OB_SERVER_NOT_ALIVE] = "OB_SERVER_NOT_ALIVE"; + ERROR_CAUSE[-OB_SERVER_NOT_ALIVE] = "Internal Error"; + ERROR_SOLUTION[-OB_SERVER_NOT_ALIVE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SERVER_NOT_ALIVE] = -1; SQLSTATE[-OB_SERVER_NOT_ALIVE] = "HY000"; STR_ERROR[-OB_SERVER_NOT_ALIVE] = "server is not alive"; @@ -3868,6 +4719,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SERVER_NOT_ALIVE] = "ORA-00600: internal error code, arguments: -4663, server is not alive"; ERROR_NAME[-OB_GET_LOCATION_TIME_OUT] = "OB_GET_LOCATION_TIME_OUT"; + ERROR_CAUSE[-OB_GET_LOCATION_TIME_OUT] = "Internal Error"; + ERROR_SOLUTION[-OB_GET_LOCATION_TIME_OUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_GET_LOCATION_TIME_OUT] = 4012; SQLSTATE[-OB_GET_LOCATION_TIME_OUT] = "HY000"; STR_ERROR[-OB_GET_LOCATION_TIME_OUT] = "Timeout"; @@ -3876,6 +4729,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_GET_LOCATION_TIME_OUT] = "ORA-00600: internal error code, arguments: -4664, Timeout"; ORACLE_STR_USER_ERROR[-OB_GET_LOCATION_TIME_OUT] = "ORA-00600: internal error code, arguments: -4664, Timeout"; ERROR_NAME[-OB_UNIT_IS_MIGRATING] = "OB_UNIT_IS_MIGRATING"; + ERROR_CAUSE[-OB_UNIT_IS_MIGRATING] = "Internal Error"; + ERROR_SOLUTION[-OB_UNIT_IS_MIGRATING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_UNIT_IS_MIGRATING] = -1; SQLSTATE[-OB_UNIT_IS_MIGRATING] = "HY000"; STR_ERROR[-OB_UNIT_IS_MIGRATING] = "Unit is migrating, can not migrate again"; @@ -3886,6 +4741,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_UNIT_IS_MIGRATING] = "ORA-00600: internal error code, arguments: -4665, Unit is migrating, can not migrate again"; ERROR_NAME[-OB_CLUSTER_NO_MATCH] = "OB_CLUSTER_NO_MATCH"; + ERROR_CAUSE[-OB_CLUSTER_NO_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_CLUSTER_NO_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CLUSTER_NO_MATCH] = -1; SQLSTATE[-OB_CLUSTER_NO_MATCH] = "HY000"; STR_ERROR[-OB_CLUSTER_NO_MATCH] = "cluster name does not match"; @@ -3896,6 +4753,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CLUSTER_NO_MATCH] = "ORA-00600: internal error code, arguments: -4666, cluster name does not match to \'%s\'"; ERROR_NAME[-OB_CHECK_ZONE_MERGE_ORDER] = "OB_CHECK_ZONE_MERGE_ORDER"; + ERROR_CAUSE[-OB_CHECK_ZONE_MERGE_ORDER] = "Internal Error"; + ERROR_SOLUTION[-OB_CHECK_ZONE_MERGE_ORDER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CHECK_ZONE_MERGE_ORDER] = -1; SQLSTATE[-OB_CHECK_ZONE_MERGE_ORDER] = "HY000"; STR_ERROR[-OB_CHECK_ZONE_MERGE_ORDER] = @@ -3910,6 +4769,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -4667, Please check new zone in zone_merge_order. You can show " "parameters like 'zone_merge_order'"; ERROR_NAME[-OB_ERR_ZONE_NOT_EMPTY] = "OB_ERR_ZONE_NOT_EMPTY"; + ERROR_CAUSE[-OB_ERR_ZONE_NOT_EMPTY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ZONE_NOT_EMPTY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ZONE_NOT_EMPTY] = -1; SQLSTATE[-OB_ERR_ZONE_NOT_EMPTY] = "HY000"; STR_ERROR[-OB_ERR_ZONE_NOT_EMPTY] = "zone not empty"; @@ -3921,6 +4782,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -4668, The zone is not empty and can not be deleted. You should " "delete the servers of the zone. There are %ld servers alive and %ld not alive."; ERROR_NAME[-OB_DIFFERENT_LOCALITY] = "OB_DIFFERENT_LOCALITY"; + ERROR_CAUSE[-OB_DIFFERENT_LOCALITY] = "Internal Error"; + ERROR_SOLUTION[-OB_DIFFERENT_LOCALITY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DIFFERENT_LOCALITY] = -1; SQLSTATE[-OB_DIFFERENT_LOCALITY] = "HY000"; STR_ERROR[-OB_DIFFERENT_LOCALITY] = "locality not match, check it"; @@ -3931,6 +4794,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DIFFERENT_LOCALITY] = "ORA-00600: internal error code, arguments: -4669, locality not match, check it"; ERROR_NAME[-OB_EMPTY_LOCALITY] = "OB_EMPTY_LOCALITY"; + ERROR_CAUSE[-OB_EMPTY_LOCALITY] = "Internal Error"; + ERROR_SOLUTION[-OB_EMPTY_LOCALITY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_EMPTY_LOCALITY] = -1; SQLSTATE[-OB_EMPTY_LOCALITY] = "HY000"; STR_ERROR[-OB_EMPTY_LOCALITY] = "locality is empty"; @@ -3939,6 +4804,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_EMPTY_LOCALITY] = "ORA-00600: internal error code, arguments: -4670, locality is empty"; ORACLE_STR_USER_ERROR[-OB_EMPTY_LOCALITY] = "ORA-00600: internal error code, arguments: -4670, locality is empty"; ERROR_NAME[-OB_FULL_REPLICA_NUM_NOT_ENOUGH] = "OB_FULL_REPLICA_NUM_NOT_ENOUGH"; + ERROR_CAUSE[-OB_FULL_REPLICA_NUM_NOT_ENOUGH] = "Internal Error"; + ERROR_SOLUTION[-OB_FULL_REPLICA_NUM_NOT_ENOUGH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_FULL_REPLICA_NUM_NOT_ENOUGH] = -1; SQLSTATE[-OB_FULL_REPLICA_NUM_NOT_ENOUGH] = "HY000"; STR_ERROR[-OB_FULL_REPLICA_NUM_NOT_ENOUGH] = "full replica num not enough"; @@ -3949,6 +4816,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_FULL_REPLICA_NUM_NOT_ENOUGH] = "ORA-00600: internal error code, arguments: -4671, full replica num not enough"; ERROR_NAME[-OB_REPLICA_NUM_NOT_ENOUGH] = "OB_REPLICA_NUM_NOT_ENOUGH"; + ERROR_CAUSE[-OB_REPLICA_NUM_NOT_ENOUGH] = "Internal Error"; + ERROR_SOLUTION[-OB_REPLICA_NUM_NOT_ENOUGH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_REPLICA_NUM_NOT_ENOUGH] = -1; SQLSTATE[-OB_REPLICA_NUM_NOT_ENOUGH] = "HY000"; STR_ERROR[-OB_REPLICA_NUM_NOT_ENOUGH] = "replica num not enough"; @@ -3959,6 +4828,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_REPLICA_NUM_NOT_ENOUGH] = "ORA-00600: internal error code, arguments: -4672, replica num not enough"; ERROR_NAME[-OB_DATA_SOURCE_NOT_VALID] = "OB_DATA_SOURCE_NOT_VALID"; + ERROR_CAUSE[-OB_DATA_SOURCE_NOT_VALID] = "Internal Error"; + ERROR_SOLUTION[-OB_DATA_SOURCE_NOT_VALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DATA_SOURCE_NOT_VALID] = -1; SQLSTATE[-OB_DATA_SOURCE_NOT_VALID] = "HY000"; STR_ERROR[-OB_DATA_SOURCE_NOT_VALID] = "Data source not valid"; @@ -3969,6 +4840,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DATA_SOURCE_NOT_VALID] = "ORA-00600: internal error code, arguments: -4673, Data source not valid"; ERROR_NAME[-OB_RUN_JOB_NOT_SUCCESS] = "OB_RUN_JOB_NOT_SUCCESS"; + ERROR_CAUSE[-OB_RUN_JOB_NOT_SUCCESS] = "Internal Error"; + ERROR_SOLUTION[-OB_RUN_JOB_NOT_SUCCESS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RUN_JOB_NOT_SUCCESS] = -1; SQLSTATE[-OB_RUN_JOB_NOT_SUCCESS] = "HY000"; STR_ERROR[-OB_RUN_JOB_NOT_SUCCESS] = "run job not success yet"; @@ -3979,6 +4852,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RUN_JOB_NOT_SUCCESS] = "ORA-00600: internal error code, arguments: -4674, run job not success yet"; ERROR_NAME[-OB_NO_NEED_REBUILD] = "OB_NO_NEED_REBUILD"; + ERROR_CAUSE[-OB_NO_NEED_REBUILD] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_NEED_REBUILD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_NEED_REBUILD] = -1; SQLSTATE[-OB_NO_NEED_REBUILD] = "HY000"; STR_ERROR[-OB_NO_NEED_REBUILD] = "no need to rebuild"; @@ -3987,6 +4862,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NO_NEED_REBUILD] = "ORA-00600: internal error code, arguments: -4675, no need to rebuild"; ORACLE_STR_USER_ERROR[-OB_NO_NEED_REBUILD] = "ORA-00600: internal error code, arguments: -4675, no need to rebuild"; ERROR_NAME[-OB_NEED_REMOVE_UNNEED_TABLE] = "OB_NEED_REMOVE_UNNEED_TABLE"; + ERROR_CAUSE[-OB_NEED_REMOVE_UNNEED_TABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_NEED_REMOVE_UNNEED_TABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NEED_REMOVE_UNNEED_TABLE] = -1; SQLSTATE[-OB_NEED_REMOVE_UNNEED_TABLE] = "HY000"; STR_ERROR[-OB_NEED_REMOVE_UNNEED_TABLE] = "need remove unneed table"; @@ -3997,6 +4874,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NEED_REMOVE_UNNEED_TABLE] = "ORA-00600: internal error code, arguments: -4676, need remove unneed table"; ERROR_NAME[-OB_NO_NEED_MERGE] = "OB_NO_NEED_MERGE"; + ERROR_CAUSE[-OB_NO_NEED_MERGE] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_NEED_MERGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_NEED_MERGE] = -1; SQLSTATE[-OB_NO_NEED_MERGE] = "HY000"; STR_ERROR[-OB_NO_NEED_MERGE] = "no need to merge"; @@ -4005,6 +4884,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NO_NEED_MERGE] = "ORA-00600: internal error code, arguments: -4677, no need to merge"; ORACLE_STR_USER_ERROR[-OB_NO_NEED_MERGE] = "ORA-00600: internal error code, arguments: -4677, no need to merge"; ERROR_NAME[-OB_CONFLICT_OPTION] = "OB_CONFLICT_OPTION"; + ERROR_CAUSE[-OB_CONFLICT_OPTION] = "Internal Error"; + ERROR_SOLUTION[-OB_CONFLICT_OPTION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CONFLICT_OPTION] = -1; SQLSTATE[-OB_CONFLICT_OPTION] = "HY000"; STR_ERROR[-OB_CONFLICT_OPTION] = "conflicting specifications"; @@ -4015,6 +4896,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CONFLICT_OPTION] = "ORA-00600: internal error code, arguments: -4678, conflicting %.*s specifications"; ERROR_NAME[-OB_DUPLICATE_OPTION] = "OB_DUPLICATE_OPTION"; + ERROR_CAUSE[-OB_DUPLICATE_OPTION] = "Internal Error"; + ERROR_SOLUTION[-OB_DUPLICATE_OPTION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DUPLICATE_OPTION] = -1; SQLSTATE[-OB_DUPLICATE_OPTION] = "HY000"; STR_ERROR[-OB_DUPLICATE_OPTION] = "duplicate specifications"; @@ -4025,6 +4908,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DUPLICATE_OPTION] = "ORA-00600: internal error code, arguments: -4679, duplicate %.*s specifications"; ERROR_NAME[-OB_INVALID_OPTION] = "OB_INVALID_OPTION"; + ERROR_CAUSE[-OB_INVALID_OPTION] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_OPTION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_OPTION] = -1; SQLSTATE[-OB_INVALID_OPTION] = "HY000"; STR_ERROR[-OB_INVALID_OPTION] = "invalid specifications"; @@ -4033,6 +4918,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_INVALID_OPTION] = "ORA-00600: internal error code, arguments: -4680, invalid specifications"; ORACLE_STR_USER_ERROR[-OB_INVALID_OPTION] = "ORA-00600: internal error code, arguments: -4680, %s"; ERROR_NAME[-OB_RPC_NEED_RECONNECT] = "OB_RPC_NEED_RECONNECT"; + ERROR_CAUSE[-OB_RPC_NEED_RECONNECT] = "Internal Error"; + ERROR_SOLUTION[-OB_RPC_NEED_RECONNECT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RPC_NEED_RECONNECT] = -1; SQLSTATE[-OB_RPC_NEED_RECONNECT] = "HY000"; STR_ERROR[-OB_RPC_NEED_RECONNECT] = "rpc need reconnect"; @@ -4041,6 +4928,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_RPC_NEED_RECONNECT] = "ORA-00600: internal error code, arguments: -4681, rpc need reconnect"; ORACLE_STR_USER_ERROR[-OB_RPC_NEED_RECONNECT] = "ORA-00600: internal error code, arguments: -4681, %s"; ERROR_NAME[-OB_CANNOT_COPY_MAJOR_SSTABLE] = "OB_CANNOT_COPY_MAJOR_SSTABLE"; + ERROR_CAUSE[-OB_CANNOT_COPY_MAJOR_SSTABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_CANNOT_COPY_MAJOR_SSTABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANNOT_COPY_MAJOR_SSTABLE] = -1; SQLSTATE[-OB_CANNOT_COPY_MAJOR_SSTABLE] = "HY000"; STR_ERROR[-OB_CANNOT_COPY_MAJOR_SSTABLE] = "cannot copy major sstable now"; @@ -4051,6 +4940,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CANNOT_COPY_MAJOR_SSTABLE] = "ORA-00600: internal error code, arguments: -4682, cannot copy major sstable now"; ERROR_NAME[-OB_SRC_DO_NOT_ALLOWED_MIGRATE] = "OB_SRC_DO_NOT_ALLOWED_MIGRATE"; + ERROR_CAUSE[-OB_SRC_DO_NOT_ALLOWED_MIGRATE] = "Internal Error"; + ERROR_SOLUTION[-OB_SRC_DO_NOT_ALLOWED_MIGRATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SRC_DO_NOT_ALLOWED_MIGRATE] = -1; SQLSTATE[-OB_SRC_DO_NOT_ALLOWED_MIGRATE] = "HY000"; STR_ERROR[-OB_SRC_DO_NOT_ALLOWED_MIGRATE] = "src do not allowed migrate"; @@ -4061,6 +4952,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SRC_DO_NOT_ALLOWED_MIGRATE] = "ORA-00600: internal error code, arguments: -4683, src do not allowed migrate"; ERROR_NAME[-OB_TOO_MANY_TENANT_PARTITIONS_ERROR] = "OB_TOO_MANY_TENANT_PARTITIONS_ERROR"; + ERROR_CAUSE[-OB_TOO_MANY_TENANT_PARTITIONS_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_TOO_MANY_TENANT_PARTITIONS_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TOO_MANY_TENANT_PARTITIONS_ERROR] = -1; SQLSTATE[-OB_TOO_MANY_TENANT_PARTITIONS_ERROR] = "HY000"; STR_ERROR[-OB_TOO_MANY_TENANT_PARTITIONS_ERROR] = "Too many partitions were defined for this tenant"; @@ -4071,6 +4964,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TOO_MANY_TENANT_PARTITIONS_ERROR] = "ORA-00600: internal error code, arguments: -4684, Too many partitions were defined for this tenant"; ERROR_NAME[-OB_ACTIVE_MEMTBALE_NOT_EXSIT] = "OB_ACTIVE_MEMTBALE_NOT_EXSIT"; + ERROR_CAUSE[-OB_ACTIVE_MEMTBALE_NOT_EXSIT] = "Internal Error"; + ERROR_SOLUTION[-OB_ACTIVE_MEMTBALE_NOT_EXSIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ACTIVE_MEMTBALE_NOT_EXSIT] = -1; SQLSTATE[-OB_ACTIVE_MEMTBALE_NOT_EXSIT] = "HY000"; STR_ERROR[-OB_ACTIVE_MEMTBALE_NOT_EXSIT] = "active memtable not exist"; @@ -4081,6 +4976,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ACTIVE_MEMTBALE_NOT_EXSIT] = "ORA-00600: internal error code, arguments: -4685, active memtable not exist"; ERROR_NAME[-OB_USE_DUP_FOLLOW_AFTER_DML] = "OB_USE_DUP_FOLLOW_AFTER_DML"; + ERROR_CAUSE[-OB_USE_DUP_FOLLOW_AFTER_DML] = "Internal Error"; + ERROR_SOLUTION[-OB_USE_DUP_FOLLOW_AFTER_DML] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_USE_DUP_FOLLOW_AFTER_DML] = -1; SQLSTATE[-OB_USE_DUP_FOLLOW_AFTER_DML] = "HY000"; STR_ERROR[-OB_USE_DUP_FOLLOW_AFTER_DML] = "Should use leader replica for duplicate table after DML operator"; @@ -4091,6 +4988,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_USE_DUP_FOLLOW_AFTER_DML] = "ORA-00600: internal error code, arguments: -4686, Should " "use leader replica for duplicate table after DML operator"; ERROR_NAME[-OB_NO_DISK_NEED_REBUILD] = "OB_NO_DISK_NEED_REBUILD"; + ERROR_CAUSE[-OB_NO_DISK_NEED_REBUILD] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_DISK_NEED_REBUILD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_DISK_NEED_REBUILD] = -1; SQLSTATE[-OB_NO_DISK_NEED_REBUILD] = "HY000"; STR_ERROR[-OB_NO_DISK_NEED_REBUILD] = "no disk need rebuild"; @@ -4101,6 +5000,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NO_DISK_NEED_REBUILD] = "ORA-00600: internal error code, arguments: -4687, no disk need rebuild"; ERROR_NAME[-OB_STANDBY_WEAK_READ_ONLY] = "OB_STANDBY_WEAK_READ_ONLY"; + ERROR_CAUSE[-OB_STANDBY_WEAK_READ_ONLY] = "Internal Error"; + ERROR_SOLUTION[-OB_STANDBY_WEAK_READ_ONLY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_STANDBY_WEAK_READ_ONLY] = -1; SQLSTATE[-OB_STANDBY_WEAK_READ_ONLY] = "HY000"; STR_ERROR[-OB_STANDBY_WEAK_READ_ONLY] = "standby cluster support weak read only"; @@ -4109,6 +5010,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_STANDBY_WEAK_READ_ONLY] = "ORA-16003: standby cluster support weak read only"; ORACLE_STR_USER_ERROR[-OB_STANDBY_WEAK_READ_ONLY] = "ORA-16003: standby cluster support weak read only"; ERROR_NAME[-OB_INVALD_WEB_SERVICE_CONTENT] = "OB_INVALD_WEB_SERVICE_CONTENT"; + ERROR_CAUSE[-OB_INVALD_WEB_SERVICE_CONTENT] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALD_WEB_SERVICE_CONTENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALD_WEB_SERVICE_CONTENT] = -1; SQLSTATE[-OB_INVALD_WEB_SERVICE_CONTENT] = "HY000"; STR_ERROR[-OB_INVALD_WEB_SERVICE_CONTENT] = "web service content not valid"; @@ -4119,6 +5022,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALD_WEB_SERVICE_CONTENT] = "ORA-00600: internal error code, arguments: -4689, web service content not valid"; ERROR_NAME[-OB_PRIMARY_CLUSTER_EXIST] = "OB_PRIMARY_CLUSTER_EXIST"; + ERROR_CAUSE[-OB_PRIMARY_CLUSTER_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_PRIMARY_CLUSTER_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PRIMARY_CLUSTER_EXIST] = -1; SQLSTATE[-OB_PRIMARY_CLUSTER_EXIST] = "HY000"; STR_ERROR[-OB_PRIMARY_CLUSTER_EXIST] = "other primary cluster already exist, can not start as primary"; @@ -4129,6 +5034,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PRIMARY_CLUSTER_EXIST] = "ORA-00600: internal error code, arguments: -4690, other " "primary cluster already exist, can not start as primary"; ERROR_NAME[-OB_ARRAY_BINDING_SWITCH_ITERATOR] = "OB_ARRAY_BINDING_SWITCH_ITERATOR"; + ERROR_CAUSE[-OB_ARRAY_BINDING_SWITCH_ITERATOR] = "Internal Error"; + ERROR_SOLUTION[-OB_ARRAY_BINDING_SWITCH_ITERATOR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ARRAY_BINDING_SWITCH_ITERATOR] = -1; SQLSTATE[-OB_ARRAY_BINDING_SWITCH_ITERATOR] = "HY000"; STR_ERROR[-OB_ARRAY_BINDING_SWITCH_ITERATOR] = "array binding needs to switch iterator"; @@ -4139,6 +5046,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ARRAY_BINDING_SWITCH_ITERATOR] = "ORA-00600: internal error code, arguments: -4691, array binding needs to switch iterator"; ERROR_NAME[-OB_ERR_STANDBY_CLUSTER_NOT_EMPTY] = "OB_ERR_STANDBY_CLUSTER_NOT_EMPTY"; + ERROR_CAUSE[-OB_ERR_STANDBY_CLUSTER_NOT_EMPTY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_STANDBY_CLUSTER_NOT_EMPTY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_STANDBY_CLUSTER_NOT_EMPTY] = -1; SQLSTATE[-OB_ERR_STANDBY_CLUSTER_NOT_EMPTY] = "HY000"; STR_ERROR[-OB_ERR_STANDBY_CLUSTER_NOT_EMPTY] = "standby cluster not empty"; @@ -4149,6 +5058,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_STANDBY_CLUSTER_NOT_EMPTY] = "ORA-00600: internal error code, arguments: -4692, standby cluster not empty"; ERROR_NAME[-OB_NOT_PRIMARY_CLUSTER] = "OB_NOT_PRIMARY_CLUSTER"; + ERROR_CAUSE[-OB_NOT_PRIMARY_CLUSTER] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_PRIMARY_CLUSTER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_PRIMARY_CLUSTER] = -1; SQLSTATE[-OB_NOT_PRIMARY_CLUSTER] = "HY000"; STR_ERROR[-OB_NOT_PRIMARY_CLUSTER] = "not primary cluster"; @@ -4158,6 +5069,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NOT_PRIMARY_CLUSTER] = "ORA-00600: internal error code, arguments: -4693, not primary cluster"; ERROR_NAME[-OB_ERR_CHECK_DROP_COLUMN_FAILED] = "OB_ERR_CHECK_DROP_COLUMN_FAILED"; + ERROR_CAUSE[-OB_ERR_CHECK_DROP_COLUMN_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CHECK_DROP_COLUMN_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CHECK_DROP_COLUMN_FAILED] = -1; SQLSTATE[-OB_ERR_CHECK_DROP_COLUMN_FAILED] = "HY000"; STR_ERROR[-OB_ERR_CHECK_DROP_COLUMN_FAILED] = "check drop column failed"; @@ -4168,6 +5081,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CHECK_DROP_COLUMN_FAILED] = "ORA-00600: internal error code, arguments: -4694, check drop column failed"; ERROR_NAME[-OB_NOT_STANDBY_CLUSTER] = "OB_NOT_STANDBY_CLUSTER"; + ERROR_CAUSE[-OB_NOT_STANDBY_CLUSTER] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_STANDBY_CLUSTER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_STANDBY_CLUSTER] = -1; SQLSTATE[-OB_NOT_STANDBY_CLUSTER] = "HY000"; STR_ERROR[-OB_NOT_STANDBY_CLUSTER] = "not standby cluster"; @@ -4177,6 +5092,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NOT_STANDBY_CLUSTER] = "ORA-00600: internal error code, arguments: -4695, not standby cluster"; ERROR_NAME[-OB_CLUSTER_VERSION_NOT_COMPATIBLE] = "OB_CLUSTER_VERSION_NOT_COMPATIBLE"; + ERROR_CAUSE[-OB_CLUSTER_VERSION_NOT_COMPATIBLE] = "Internal Error"; + ERROR_SOLUTION[-OB_CLUSTER_VERSION_NOT_COMPATIBLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CLUSTER_VERSION_NOT_COMPATIBLE] = -1; SQLSTATE[-OB_CLUSTER_VERSION_NOT_COMPATIBLE] = "HY000"; STR_ERROR[-OB_CLUSTER_VERSION_NOT_COMPATIBLE] = "cluster version not compatible"; @@ -4187,6 +5104,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CLUSTER_VERSION_NOT_COMPATIBLE] = "ORA-00600: internal error code, arguments: -4696, cluster version not compatible"; ERROR_NAME[-OB_WAIT_TRANS_TABLE_MERGE_TIMEOUT] = "OB_WAIT_TRANS_TABLE_MERGE_TIMEOUT"; + ERROR_CAUSE[-OB_WAIT_TRANS_TABLE_MERGE_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_WAIT_TRANS_TABLE_MERGE_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WAIT_TRANS_TABLE_MERGE_TIMEOUT] = -1; SQLSTATE[-OB_WAIT_TRANS_TABLE_MERGE_TIMEOUT] = "HY000"; STR_ERROR[-OB_WAIT_TRANS_TABLE_MERGE_TIMEOUT] = "wait trans table merge finish timeout"; @@ -4197,6 +5116,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_WAIT_TRANS_TABLE_MERGE_TIMEOUT] = "ORA-00600: internal error code, arguments: -4697, wait trans table merge finish timeout"; ERROR_NAME[-OB_SKIP_RENEW_LOCATION_BY_RPC] = "OB_SKIP_RENEW_LOCATION_BY_RPC"; + ERROR_CAUSE[-OB_SKIP_RENEW_LOCATION_BY_RPC] = "Internal Error"; + ERROR_SOLUTION[-OB_SKIP_RENEW_LOCATION_BY_RPC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SKIP_RENEW_LOCATION_BY_RPC] = -1; SQLSTATE[-OB_SKIP_RENEW_LOCATION_BY_RPC] = "HY000"; STR_ERROR[-OB_SKIP_RENEW_LOCATION_BY_RPC] = "skip renew location by rpc"; @@ -4207,6 +5128,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SKIP_RENEW_LOCATION_BY_RPC] = "ORA-00600: internal error code, arguments: -4698, skip renew location by rpc"; ERROR_NAME[-OB_RENEW_LOCATION_BY_RPC_FAILED] = "OB_RENEW_LOCATION_BY_RPC_FAILED"; + ERROR_CAUSE[-OB_RENEW_LOCATION_BY_RPC_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_RENEW_LOCATION_BY_RPC_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RENEW_LOCATION_BY_RPC_FAILED] = -1; SQLSTATE[-OB_RENEW_LOCATION_BY_RPC_FAILED] = "HY000"; STR_ERROR[-OB_RENEW_LOCATION_BY_RPC_FAILED] = "renew location by rpc failed"; @@ -4217,6 +5140,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RENEW_LOCATION_BY_RPC_FAILED] = "ORA-00600: internal error code, arguments: -4699, renew location by rpc failed"; ERROR_NAME[-OB_CLUSTER_ID_NO_MATCH] = "OB_CLUSTER_ID_NO_MATCH"; + ERROR_CAUSE[-OB_CLUSTER_ID_NO_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_CLUSTER_ID_NO_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CLUSTER_ID_NO_MATCH] = -1; SQLSTATE[-OB_CLUSTER_ID_NO_MATCH] = "HY000"; STR_ERROR[-OB_CLUSTER_ID_NO_MATCH] = "cluster id does not match"; @@ -4227,6 +5152,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CLUSTER_ID_NO_MATCH] = "ORA-00600: internal error code, arguments: -4700, cluster id does not match"; ERROR_NAME[-OB_ERR_PARAM_INVALID] = "OB_ERR_PARAM_INVALID"; + ERROR_CAUSE[-OB_ERR_PARAM_INVALID] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARAM_INVALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARAM_INVALID] = -1; SQLSTATE[-OB_ERR_PARAM_INVALID] = "HY000"; STR_ERROR[-OB_ERR_PARAM_INVALID] = "parameter cannot be modified because specified value is invalid"; @@ -4237,6 +5164,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PARAM_INVALID] = "ORA-02097: parameter cannot be modified because specified value is invalid"; ERROR_NAME[-OB_ERR_RES_OBJ_ALREADY_EXIST] = "OB_ERR_RES_OBJ_ALREADY_EXIST"; + ERROR_CAUSE[-OB_ERR_RES_OBJ_ALREADY_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_RES_OBJ_ALREADY_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_RES_OBJ_ALREADY_EXIST] = -1; SQLSTATE[-OB_ERR_RES_OBJ_ALREADY_EXIST] = "HY000"; STR_ERROR[-OB_ERR_RES_OBJ_ALREADY_EXIST] = "resource object already exists"; @@ -4245,6 +5174,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_RES_OBJ_ALREADY_EXIST] = "ORA-29357: resource object already exists"; ORACLE_STR_USER_ERROR[-OB_ERR_RES_OBJ_ALREADY_EXIST] = "ORA-29357: %s %.*s already exists"; ERROR_NAME[-OB_ERR_RES_PLAN_NOT_EXIST] = "OB_ERR_RES_PLAN_NOT_EXIST"; + ERROR_CAUSE[-OB_ERR_RES_PLAN_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_RES_PLAN_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_RES_PLAN_NOT_EXIST] = -1; SQLSTATE[-OB_ERR_RES_PLAN_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_RES_PLAN_NOT_EXIST] = "resource plan does not exist"; @@ -4253,6 +5184,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_RES_PLAN_NOT_EXIST] = "ORA-29358: resource plan does not exist"; ORACLE_STR_USER_ERROR[-OB_ERR_RES_PLAN_NOT_EXIST] = "ORA-29358: resource plan %.*s does not exist"; ERROR_NAME[-OB_ERR_PERCENTAGE_OUT_OF_RANGE] = "OB_ERR_PERCENTAGE_OUT_OF_RANGE"; + ERROR_CAUSE[-OB_ERR_PERCENTAGE_OUT_OF_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PERCENTAGE_OUT_OF_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PERCENTAGE_OUT_OF_RANGE] = -1; SQLSTATE[-OB_ERR_PERCENTAGE_OUT_OF_RANGE] = "HY000"; STR_ERROR[-OB_ERR_PERCENTAGE_OUT_OF_RANGE] = "value is outside valid range of 0 to 100"; @@ -4262,6 +5195,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PERCENTAGE_OUT_OF_RANGE] = "ORA-29361: value %ld for %s is outside valid range of 0 to 100"; ERROR_NAME[-OB_ERR_PLAN_DIRECTIVE_NOT_EXIST] = "OB_ERR_PLAN_DIRECTIVE_NOT_EXIST"; + ERROR_CAUSE[-OB_ERR_PLAN_DIRECTIVE_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PLAN_DIRECTIVE_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PLAN_DIRECTIVE_NOT_EXIST] = -1; SQLSTATE[-OB_ERR_PLAN_DIRECTIVE_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_PLAN_DIRECTIVE_NOT_EXIST] = "plan directive does not exist"; @@ -4270,6 +5205,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_PLAN_DIRECTIVE_NOT_EXIST] = "ORA-29362: plan directive does not exist"; ORACLE_STR_USER_ERROR[-OB_ERR_PLAN_DIRECTIVE_NOT_EXIST] = "ORA-29362: plan directive %.*s, %.*s does not exist"; ERROR_NAME[-OB_ERR_PLAN_DIRECTIVE_ALREADY_EXIST] = "OB_ERR_PLAN_DIRECTIVE_ALREADY_EXIST"; + ERROR_CAUSE[-OB_ERR_PLAN_DIRECTIVE_ALREADY_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PLAN_DIRECTIVE_ALREADY_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PLAN_DIRECTIVE_ALREADY_EXIST] = -1; SQLSTATE[-OB_ERR_PLAN_DIRECTIVE_ALREADY_EXIST] = "HY000"; STR_ERROR[-OB_ERR_PLAN_DIRECTIVE_ALREADY_EXIST] = "plan directive already exists"; @@ -4278,6 +5215,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_PLAN_DIRECTIVE_ALREADY_EXIST] = "ORA-29364: plan directive already exists"; ORACLE_STR_USER_ERROR[-OB_ERR_PLAN_DIRECTIVE_ALREADY_EXIST] = "ORA-29364: plan directive %.*s, %.*s already exists"; ERROR_NAME[-OB_ERR_INVALID_PLAN_DIRECTIVE_NAME] = "OB_ERR_INVALID_PLAN_DIRECTIVE_NAME"; + ERROR_CAUSE[-OB_ERR_INVALID_PLAN_DIRECTIVE_NAME] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_PLAN_DIRECTIVE_NAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_PLAN_DIRECTIVE_NAME] = -1; SQLSTATE[-OB_ERR_INVALID_PLAN_DIRECTIVE_NAME] = "HY000"; STR_ERROR[-OB_ERR_INVALID_PLAN_DIRECTIVE_NAME] = "plan directive name not supported."; @@ -4286,6 +5225,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_PLAN_DIRECTIVE_NAME] = "ORA-29366: plan directive name not supported."; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_PLAN_DIRECTIVE_NAME] = "ORA-29366: plan directive name '%.*s' not supported."; ERROR_NAME[-OB_FAILOVER_NOT_ALLOW] = "OB_FAILOVER_NOT_ALLOW"; + ERROR_CAUSE[-OB_FAILOVER_NOT_ALLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_FAILOVER_NOT_ALLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_FAILOVER_NOT_ALLOW] = -1; SQLSTATE[-OB_FAILOVER_NOT_ALLOW] = "HY000"; STR_ERROR[-OB_FAILOVER_NOT_ALLOW] = "Failover is not allowed"; @@ -4295,6 +5236,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -4708, Failover is not allowed"; ORACLE_STR_USER_ERROR[-OB_FAILOVER_NOT_ALLOW] = "ORA-00600: internal error code, arguments: -4708, %s"; ERROR_NAME[-OB_ADD_CLUSTER_NOT_ALLOWED] = "OB_ADD_CLUSTER_NOT_ALLOWED"; + ERROR_CAUSE[-OB_ADD_CLUSTER_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_ADD_CLUSTER_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ADD_CLUSTER_NOT_ALLOWED] = -1; SQLSTATE[-OB_ADD_CLUSTER_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_ADD_CLUSTER_NOT_ALLOWED] = "Add cluster not allowed."; @@ -4305,6 +5248,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ADD_CLUSTER_NOT_ALLOWED] = "ORA-00600: internal error code, arguments: -4709, Add cluster not allowed. Actions: %s"; ERROR_NAME[-OB_ERR_CONSUMER_GROUP_NOT_EXIST] = "OB_ERR_CONSUMER_GROUP_NOT_EXIST"; + ERROR_CAUSE[-OB_ERR_CONSUMER_GROUP_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CONSUMER_GROUP_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CONSUMER_GROUP_NOT_EXIST] = -1; SQLSTATE[-OB_ERR_CONSUMER_GROUP_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_CONSUMER_GROUP_NOT_EXIST] = "consumer group does not exist"; @@ -4313,6 +5258,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CONSUMER_GROUP_NOT_EXIST] = "ORA-29368: consumer group does not exist"; ORACLE_STR_USER_ERROR[-OB_ERR_CONSUMER_GROUP_NOT_EXIST] = "ORA-29368: consumer group %.*s does not exist"; ERROR_NAME[-OB_CLUSTER_NOT_ACCESSIBLE] = "OB_CLUSTER_NOT_ACCESSIBLE"; + ERROR_CAUSE[-OB_CLUSTER_NOT_ACCESSIBLE] = "Internal Error"; + ERROR_SOLUTION[-OB_CLUSTER_NOT_ACCESSIBLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CLUSTER_NOT_ACCESSIBLE] = -1; SQLSTATE[-OB_CLUSTER_NOT_ACCESSIBLE] = "HY000"; STR_ERROR[-OB_CLUSTER_NOT_ACCESSIBLE] = "cluster is not accessible"; @@ -4323,6 +5270,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CLUSTER_NOT_ACCESSIBLE] = "ORA-00600: internal error code, arguments: -4711, cluster is not accessible, cluster_id: %ld"; ERROR_NAME[-OB_TENANT_RESOURCE_UNIT_EXIST] = "OB_TENANT_RESOURCE_UNIT_EXIST"; + ERROR_CAUSE[-OB_TENANT_RESOURCE_UNIT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_TENANT_RESOURCE_UNIT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TENANT_RESOURCE_UNIT_EXIST] = -1; SQLSTATE[-OB_TENANT_RESOURCE_UNIT_EXIST] = "HY000"; STR_ERROR[-OB_TENANT_RESOURCE_UNIT_EXIST] = "tenant already has resource unit configured"; @@ -4351,6 +5300,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_ATLER_TABLE_ILLEGAL_FK] = "ORA-02266: unique/primary keys in table referenced by enabled foreign keys"; ORACLE_STR_USER_ERROR[-OB_ERR_ATLER_TABLE_ILLEGAL_FK] = "ORA-02266: unique/primary keys in table referenced by enabled foreign keys"; ERROR_NAME[-OB_ERR_PARSER_INIT] = "OB_ERR_PARSER_INIT"; + ERROR_CAUSE[-OB_ERR_PARSER_INIT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARSER_INIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARSER_INIT] = ER_PARSE_ERROR; SQLSTATE[-OB_ERR_PARSER_INIT] = "0B000"; STR_ERROR[-OB_ERR_PARSER_INIT] = "Failed to init SQL parser"; @@ -4361,6 +5312,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PARSER_INIT] = "ORA-00600: internal error code, arguments: -5000, Failed to init SQL parser"; ERROR_NAME[-OB_ERR_PARSE_SQL] = "OB_ERR_PARSE_SQL"; + ERROR_CAUSE[-OB_ERR_PARSE_SQL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARSE_SQL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARSE_SQL] = ER_PARSE_ERROR; SQLSTATE[-OB_ERR_PARSE_SQL] = "42000"; STR_ERROR[-OB_ERR_PARSE_SQL] = "Parse error"; @@ -4369,6 +5322,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_PARSE_SQL] = "ORA-00900: invalid SQL statement"; ORACLE_STR_USER_ERROR[-OB_ERR_PARSE_SQL] = "ORA-00900: %s near \'%.*s\' at line %d"; ERROR_NAME[-OB_ERR_RESOLVE_SQL] = "OB_ERR_RESOLVE_SQL"; + ERROR_CAUSE[-OB_ERR_RESOLVE_SQL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_RESOLVE_SQL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_RESOLVE_SQL] = -1; SQLSTATE[-OB_ERR_RESOLVE_SQL] = "HY000"; STR_ERROR[-OB_ERR_RESOLVE_SQL] = "Resolve error"; @@ -4377,6 +5332,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_RESOLVE_SQL] = "ORA-00600: internal error code, arguments: -5002, Resolve error"; ORACLE_STR_USER_ERROR[-OB_ERR_RESOLVE_SQL] = "ORA-00600: internal error code, arguments: -5002, Resolve error"; ERROR_NAME[-OB_ERR_GEN_PLAN] = "OB_ERR_GEN_PLAN"; + ERROR_CAUSE[-OB_ERR_GEN_PLAN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_GEN_PLAN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_GEN_PLAN] = -1; SQLSTATE[-OB_ERR_GEN_PLAN] = "HY000"; STR_ERROR[-OB_ERR_GEN_PLAN] = "Generate plan error"; @@ -4385,6 +5342,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_GEN_PLAN] = "ORA-00600: internal error code, arguments: -5003, Generate plan error"; ORACLE_STR_USER_ERROR[-OB_ERR_GEN_PLAN] = "ORA-00600: internal error code, arguments: -5003, Generate plan error"; ERROR_NAME[-OB_ERR_PARSER_SYNTAX] = "OB_ERR_PARSER_SYNTAX"; + ERROR_CAUSE[-OB_ERR_PARSER_SYNTAX] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARSER_SYNTAX] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARSER_SYNTAX] = ER_SYNTAX_ERROR; SQLSTATE[-OB_ERR_PARSER_SYNTAX] = "42000"; STR_ERROR[-OB_ERR_PARSER_SYNTAX] = "You have an error in your SQL syntax; check the manual that corresponds to " @@ -4398,6 +5357,8 @@ static struct ObStrErrorInit { "ORA-00900: You have an error in your SQL syntax; check the manual that corresponds to your OceanBase version " "for the right syntax to use"; ERROR_NAME[-OB_ERR_COLUMN_SIZE] = "OB_ERR_COLUMN_SIZE"; + ERROR_CAUSE[-OB_ERR_COLUMN_SIZE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_COLUMN_SIZE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_COLUMN_SIZE] = ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT; SQLSTATE[-OB_ERR_COLUMN_SIZE] = "21000"; STR_ERROR[-OB_ERR_COLUMN_SIZE] = "The used SELECT statements have a different number of columns"; @@ -4408,6 +5369,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_COLUMN_SIZE] = "ORA-00600: internal error code, arguments: -5007, The used SELECT " "statements have a different number of columns"; ERROR_NAME[-OB_ERR_COLUMN_DUPLICATE] = "OB_ERR_COLUMN_DUPLICATE"; + ERROR_CAUSE[-OB_ERR_COLUMN_DUPLICATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_COLUMN_DUPLICATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_COLUMN_DUPLICATE] = ER_DUP_FIELDNAME; SQLSTATE[-OB_ERR_COLUMN_DUPLICATE] = "42S21"; STR_ERROR[-OB_ERR_COLUMN_DUPLICATE] = "Duplicate column name"; @@ -4418,6 +5381,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_COLUMN_DUPLICATE] = "ORA-00600: internal error code, arguments: -5008, Duplicate column name '%.*s'"; ERROR_NAME[-OB_ERR_OPERATOR_UNKNOWN] = "OB_ERR_OPERATOR_UNKNOWN"; + ERROR_CAUSE[-OB_ERR_OPERATOR_UNKNOWN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OPERATOR_UNKNOWN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OPERATOR_UNKNOWN] = -1; SQLSTATE[-OB_ERR_OPERATOR_UNKNOWN] = "21000"; STR_ERROR[-OB_ERR_OPERATOR_UNKNOWN] = "Unknown operator"; @@ -4427,6 +5392,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_OPERATOR_UNKNOWN] = "ORA-00600: internal error code, arguments: -5010, Unknown operator"; ERROR_NAME[-OB_ERR_STAR_DUPLICATE] = "OB_ERR_STAR_DUPLICATE"; + ERROR_CAUSE[-OB_ERR_STAR_DUPLICATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_STAR_DUPLICATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_STAR_DUPLICATE] = -1; SQLSTATE[-OB_ERR_STAR_DUPLICATE] = "42000"; STR_ERROR[-OB_ERR_STAR_DUPLICATE] = "Duplicated star"; @@ -4435,6 +5402,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_STAR_DUPLICATE] = "ORA-00600: internal error code, arguments: -5011, Duplicated star"; ORACLE_STR_USER_ERROR[-OB_ERR_STAR_DUPLICATE] = "ORA-00600: internal error code, arguments: -5011, Duplicated star"; ERROR_NAME[-OB_ERR_ILLEGAL_ID] = "OB_ERR_ILLEGAL_ID"; + ERROR_CAUSE[-OB_ERR_ILLEGAL_ID] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ILLEGAL_ID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ILLEGAL_ID] = -1; SQLSTATE[-OB_ERR_ILLEGAL_ID] = "HY000"; STR_ERROR[-OB_ERR_ILLEGAL_ID] = "Illegal ID"; @@ -4443,6 +5412,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_ILLEGAL_ID] = "ORA-00600: internal error code, arguments: -5012, Illegal ID"; ORACLE_STR_USER_ERROR[-OB_ERR_ILLEGAL_ID] = "ORA-00600: internal error code, arguments: -5012, %s"; ERROR_NAME[-OB_ERR_ILLEGAL_VALUE] = "OB_ERR_ILLEGAL_VALUE"; + ERROR_CAUSE[-OB_ERR_ILLEGAL_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ILLEGAL_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ILLEGAL_VALUE] = -1; SQLSTATE[-OB_ERR_ILLEGAL_VALUE] = "HY000"; STR_ERROR[-OB_ERR_ILLEGAL_VALUE] = "Illegal value"; @@ -4451,6 +5422,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_ILLEGAL_VALUE] = "ORA-00600: internal error code, arguments: -5014, Illegal value"; ORACLE_STR_USER_ERROR[-OB_ERR_ILLEGAL_VALUE] = "ORA-00600: internal error code, arguments: -5014, Illegal value"; ERROR_NAME[-OB_ERR_COLUMN_AMBIGUOUS] = "OB_ERR_COLUMN_AMBIGUOUS"; + ERROR_CAUSE[-OB_ERR_COLUMN_AMBIGUOUS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_COLUMN_AMBIGUOUS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_COLUMN_AMBIGUOUS] = ER_AMBIGUOUS_FIELD_TERM; SQLSTATE[-OB_ERR_COLUMN_AMBIGUOUS] = "42000"; STR_ERROR[-OB_ERR_COLUMN_AMBIGUOUS] = "Ambiguous column"; @@ -4460,6 +5433,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_COLUMN_AMBIGUOUS] = "ORA-00600: internal error code, arguments: -5015, Ambiguous column"; ERROR_NAME[-OB_ERR_LOGICAL_PLAN_FAILD] = "OB_ERR_LOGICAL_PLAN_FAILD"; + ERROR_CAUSE[-OB_ERR_LOGICAL_PLAN_FAILD] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_LOGICAL_PLAN_FAILD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_LOGICAL_PLAN_FAILD] = -1; SQLSTATE[-OB_ERR_LOGICAL_PLAN_FAILD] = "HY000"; STR_ERROR[-OB_ERR_LOGICAL_PLAN_FAILD] = "Generate logical plan error"; @@ -4470,6 +5445,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_LOGICAL_PLAN_FAILD] = "ORA-00600: internal error code, arguments: -5016, Generate logical plan error"; ERROR_NAME[-OB_ERR_SCHEMA_UNSET] = "OB_ERR_SCHEMA_UNSET"; + ERROR_CAUSE[-OB_ERR_SCHEMA_UNSET] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SCHEMA_UNSET] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SCHEMA_UNSET] = -1; SQLSTATE[-OB_ERR_SCHEMA_UNSET] = "HY000"; STR_ERROR[-OB_ERR_SCHEMA_UNSET] = "Schema not set"; @@ -4478,6 +5455,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SCHEMA_UNSET] = "ORA-00600: internal error code, arguments: -5017, Schema not set"; ORACLE_STR_USER_ERROR[-OB_ERR_SCHEMA_UNSET] = "ORA-00600: internal error code, arguments: -5017, Schema not set"; ERROR_NAME[-OB_ERR_ILLEGAL_NAME] = "OB_ERR_ILLEGAL_NAME"; + ERROR_CAUSE[-OB_ERR_ILLEGAL_NAME] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ILLEGAL_NAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ILLEGAL_NAME] = -1; SQLSTATE[-OB_ERR_ILLEGAL_NAME] = "42000"; STR_ERROR[-OB_ERR_ILLEGAL_NAME] = "Illegal name"; @@ -4486,6 +5465,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_ILLEGAL_NAME] = "ORA-00600: internal error code, arguments: -5018, Illegal name"; ORACLE_STR_USER_ERROR[-OB_ERR_ILLEGAL_NAME] = "ORA-00600: internal error code, arguments: -5018, Illegal name"; ERROR_NAME[-OB_TABLE_NOT_EXIST] = "OB_TABLE_NOT_EXIST"; + ERROR_CAUSE[-OB_TABLE_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_TABLE_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TABLE_NOT_EXIST] = ER_NO_SUCH_TABLE; SQLSTATE[-OB_TABLE_NOT_EXIST] = "42S02"; STR_ERROR[-OB_TABLE_NOT_EXIST] = "Table doesn\'t exist"; @@ -4494,6 +5475,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TABLE_NOT_EXIST] = "ORA-00942: table or view does not exist"; ORACLE_STR_USER_ERROR[-OB_TABLE_NOT_EXIST] = "ORA-00942: table or view \'%s.%s\' does not exist"; ERROR_NAME[-OB_ERR_TABLE_EXIST] = "OB_ERR_TABLE_EXIST"; + ERROR_CAUSE[-OB_ERR_TABLE_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TABLE_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TABLE_EXIST] = ER_TABLE_EXISTS_ERROR; SQLSTATE[-OB_ERR_TABLE_EXIST] = "42S01"; STR_ERROR[-OB_ERR_TABLE_EXIST] = "Table already exists"; @@ -4503,6 +5486,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TABLE_EXIST] = "ORA-00600: internal error code, arguments: -5020, Table '%.*s' already exists"; ERROR_NAME[-OB_ERR_EXPR_UNKNOWN] = "OB_ERR_EXPR_UNKNOWN"; + ERROR_CAUSE[-OB_ERR_EXPR_UNKNOWN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_EXPR_UNKNOWN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_EXPR_UNKNOWN] = -1; SQLSTATE[-OB_ERR_EXPR_UNKNOWN] = "42000"; STR_ERROR[-OB_ERR_EXPR_UNKNOWN] = "Unknown expression"; @@ -4512,6 +5497,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_EXPR_UNKNOWN] = "ORA-00600: internal error code, arguments: -5022, Unknown expression"; ERROR_NAME[-OB_ERR_ILLEGAL_TYPE] = "OB_ERR_ILLEGAL_TYPE"; + ERROR_CAUSE[-OB_ERR_ILLEGAL_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ILLEGAL_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ILLEGAL_TYPE] = -1; SQLSTATE[-OB_ERR_ILLEGAL_TYPE] = "S1004"; STR_ERROR[-OB_ERR_ILLEGAL_TYPE] = "Illegal type"; @@ -4523,6 +5510,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5023, unsupport MySQL type %d. Maybe you should use " "java.sql.Timestamp instead of java.util.Date."; ERROR_NAME[-OB_ERR_PRIMARY_KEY_DUPLICATE] = "OB_ERR_PRIMARY_KEY_DUPLICATE"; + ERROR_CAUSE[-OB_ERR_PRIMARY_KEY_DUPLICATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PRIMARY_KEY_DUPLICATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PRIMARY_KEY_DUPLICATE] = ER_DUP_ENTRY; SQLSTATE[-OB_ERR_PRIMARY_KEY_DUPLICATE] = "23000"; STR_ERROR[-OB_ERR_PRIMARY_KEY_DUPLICATE] = "Duplicated primary key"; @@ -4532,6 +5521,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PRIMARY_KEY_DUPLICATE] = "ORA-00001: unique constraint \'%s\' for key \'%.*s\' violated"; ERROR_NAME[-OB_ERR_KEY_NAME_DUPLICATE] = "OB_ERR_KEY_NAME_DUPLICATE"; + ERROR_CAUSE[-OB_ERR_KEY_NAME_DUPLICATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_KEY_NAME_DUPLICATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_KEY_NAME_DUPLICATE] = ER_DUP_KEYNAME; SQLSTATE[-OB_ERR_KEY_NAME_DUPLICATE] = "42000"; STR_ERROR[-OB_ERR_KEY_NAME_DUPLICATE] = "Duplicated key name"; @@ -4542,6 +5533,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_KEY_NAME_DUPLICATE] = "ORA-00600: internal error code, arguments: -5025, Duplicate key name \'%.*s\'"; ERROR_NAME[-OB_ERR_CREATETIME_DUPLICATE] = "OB_ERR_CREATETIME_DUPLICATE"; + ERROR_CAUSE[-OB_ERR_CREATETIME_DUPLICATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CREATETIME_DUPLICATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CREATETIME_DUPLICATE] = -1; SQLSTATE[-OB_ERR_CREATETIME_DUPLICATE] = "42000"; STR_ERROR[-OB_ERR_CREATETIME_DUPLICATE] = "Duplicated createtime"; @@ -4552,6 +5545,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CREATETIME_DUPLICATE] = "ORA-00600: internal error code, arguments: -5026, Duplicated createtime"; ERROR_NAME[-OB_ERR_MODIFYTIME_DUPLICATE] = "OB_ERR_MODIFYTIME_DUPLICATE"; + ERROR_CAUSE[-OB_ERR_MODIFYTIME_DUPLICATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MODIFYTIME_DUPLICATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MODIFYTIME_DUPLICATE] = -1; SQLSTATE[-OB_ERR_MODIFYTIME_DUPLICATE] = "42000"; STR_ERROR[-OB_ERR_MODIFYTIME_DUPLICATE] = "Duplicated modifytime"; @@ -4562,6 +5557,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MODIFYTIME_DUPLICATE] = "ORA-00600: internal error code, arguments: -5027, Duplicated modifytime"; ERROR_NAME[-OB_ERR_ILLEGAL_INDEX] = "OB_ERR_ILLEGAL_INDEX"; + ERROR_CAUSE[-OB_ERR_ILLEGAL_INDEX] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ILLEGAL_INDEX] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ILLEGAL_INDEX] = ER_NO_SUCH_INDEX; SQLSTATE[-OB_ERR_ILLEGAL_INDEX] = "42S12"; STR_ERROR[-OB_ERR_ILLEGAL_INDEX] = "Illegal index"; @@ -4570,6 +5567,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_ILLEGAL_INDEX] = "ORA-00600: internal error code, arguments: -5028, Illegal index"; ORACLE_STR_USER_ERROR[-OB_ERR_ILLEGAL_INDEX] = "ORA-00600: internal error code, arguments: -5028, Illegal index"; ERROR_NAME[-OB_ERR_INVALID_SCHEMA] = "OB_ERR_INVALID_SCHEMA"; + ERROR_CAUSE[-OB_ERR_INVALID_SCHEMA] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_SCHEMA] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_SCHEMA] = -1; SQLSTATE[-OB_ERR_INVALID_SCHEMA] = "HY000"; STR_ERROR[-OB_ERR_INVALID_SCHEMA] = "Invalid schema"; @@ -4578,6 +5577,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_SCHEMA] = "ORA-00600: internal error code, arguments: -5029, Invalid schema"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_SCHEMA] = "ORA-00600: internal error code, arguments: -5029, Invalid schema"; ERROR_NAME[-OB_ERR_INSERT_NULL_ROWKEY] = "OB_ERR_INSERT_NULL_ROWKEY"; + ERROR_CAUSE[-OB_ERR_INSERT_NULL_ROWKEY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INSERT_NULL_ROWKEY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INSERT_NULL_ROWKEY] = ER_PRIMARY_CANT_HAVE_NULL; SQLSTATE[-OB_ERR_INSERT_NULL_ROWKEY] = "42000"; STR_ERROR[-OB_ERR_INSERT_NULL_ROWKEY] = "Insert null rowkey"; @@ -4586,6 +5587,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INSERT_NULL_ROWKEY] = "ORA-01400: cannot insert NULL into"; ORACLE_STR_USER_ERROR[-OB_ERR_INSERT_NULL_ROWKEY] = "ORA-01400: cannot insert NULL into (%.*s)"; ERROR_NAME[-OB_ERR_COLUMN_NOT_FOUND] = "OB_ERR_COLUMN_NOT_FOUND"; + ERROR_CAUSE[-OB_ERR_COLUMN_NOT_FOUND] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_COLUMN_NOT_FOUND] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_COLUMN_NOT_FOUND] = -1; SQLSTATE[-OB_ERR_COLUMN_NOT_FOUND] = "HY000"; STR_ERROR[-OB_ERR_COLUMN_NOT_FOUND] = "Column not found"; @@ -4595,6 +5598,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_COLUMN_NOT_FOUND] = "ORA-00600: internal error code, arguments: -5031, Column not found"; ERROR_NAME[-OB_ERR_DELETE_NULL_ROWKEY] = "OB_ERR_DELETE_NULL_ROWKEY"; + ERROR_CAUSE[-OB_ERR_DELETE_NULL_ROWKEY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DELETE_NULL_ROWKEY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DELETE_NULL_ROWKEY] = -1; SQLSTATE[-OB_ERR_DELETE_NULL_ROWKEY] = "23000"; STR_ERROR[-OB_ERR_DELETE_NULL_ROWKEY] = "Delete null rowkey"; @@ -4605,6 +5610,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DELETE_NULL_ROWKEY] = "ORA-00600: internal error code, arguments: -5032, Delete null rowkey"; ERROR_NAME[-OB_ERR_USER_EMPTY] = "OB_ERR_USER_EMPTY"; + ERROR_CAUSE[-OB_ERR_USER_EMPTY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_USER_EMPTY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_USER_EMPTY] = -1; SQLSTATE[-OB_ERR_USER_EMPTY] = "01007"; STR_ERROR[-OB_ERR_USER_EMPTY] = "No user"; @@ -4613,6 +5620,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_USER_EMPTY] = "ORA-00600: internal error code, arguments: -5034, No user"; ORACLE_STR_USER_ERROR[-OB_ERR_USER_EMPTY] = "ORA-00600: internal error code, arguments: -5034, No user"; ERROR_NAME[-OB_ERR_USER_NOT_EXIST] = "OB_ERR_USER_NOT_EXIST"; + ERROR_CAUSE[-OB_ERR_USER_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_USER_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_USER_NOT_EXIST] = ER_NO_SUCH_USER; SQLSTATE[-OB_ERR_USER_NOT_EXIST] = "01007"; STR_ERROR[-OB_ERR_USER_NOT_EXIST] = "User not exist"; @@ -4621,6 +5630,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_USER_NOT_EXIST] = "ORA-00600: internal error code, arguments: -5035, User not exist"; ORACLE_STR_USER_ERROR[-OB_ERR_USER_NOT_EXIST] = "ORA-00600: internal error code, arguments: -5035, User not exist"; ERROR_NAME[-OB_ERR_NO_PRIVILEGE] = "OB_ERR_NO_PRIVILEGE"; + ERROR_CAUSE[-OB_ERR_NO_PRIVILEGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_PRIVILEGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_PRIVILEGE] = ER_SPECIFIC_ACCESS_DENIED_ERROR; SQLSTATE[-OB_ERR_NO_PRIVILEGE] = "42501"; STR_ERROR[-OB_ERR_NO_PRIVILEGE] = "Access denied"; @@ -4631,6 +5642,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NO_PRIVILEGE] = "ORA-00600: internal error code, arguments: -5036, Access denied; " "you need (at least one of) the %s privilege(s) for this operation"; ERROR_NAME[-OB_ERR_NO_AVAILABLE_PRIVILEGE_ENTRY] = "OB_ERR_NO_AVAILABLE_PRIVILEGE_ENTRY"; + ERROR_CAUSE[-OB_ERR_NO_AVAILABLE_PRIVILEGE_ENTRY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_AVAILABLE_PRIVILEGE_ENTRY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_AVAILABLE_PRIVILEGE_ENTRY] = -1; SQLSTATE[-OB_ERR_NO_AVAILABLE_PRIVILEGE_ENTRY] = "HY000"; STR_ERROR[-OB_ERR_NO_AVAILABLE_PRIVILEGE_ENTRY] = "No privilege entry"; @@ -4641,6 +5654,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NO_AVAILABLE_PRIVILEGE_ENTRY] = "ORA-00600: internal error code, arguments: -5037, No privilege entry"; ERROR_NAME[-OB_ERR_WRONG_PASSWORD] = "OB_ERR_WRONG_PASSWORD"; + ERROR_CAUSE[-OB_ERR_WRONG_PASSWORD] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_PASSWORD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_PASSWORD] = ER_PASSWORD_NO_MATCH; SQLSTATE[-OB_ERR_WRONG_PASSWORD] = "42000"; STR_ERROR[-OB_ERR_WRONG_PASSWORD] = "Incorrect password"; @@ -4650,6 +5665,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WRONG_PASSWORD] = "ORA-00600: internal error code, arguments: -5038, Incorrect password"; ERROR_NAME[-OB_ERR_USER_IS_LOCKED] = "OB_ERR_USER_IS_LOCKED"; + ERROR_CAUSE[-OB_ERR_USER_IS_LOCKED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_USER_IS_LOCKED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_USER_IS_LOCKED] = ER_ACCOUNT_HAS_BEEN_LOCKED; SQLSTATE[-OB_ERR_USER_IS_LOCKED] = "HY000"; STR_ERROR[-OB_ERR_USER_IS_LOCKED] = "User locked"; @@ -4658,6 +5675,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_USER_IS_LOCKED] = "ORA-00600: internal error code, arguments: -5039, User locked"; ORACLE_STR_USER_ERROR[-OB_ERR_USER_IS_LOCKED] = "ORA-00600: internal error code, arguments: -5039, User locked"; ERROR_NAME[-OB_ERR_UPDATE_ROWKEY_COLUMN] = "OB_ERR_UPDATE_ROWKEY_COLUMN"; + ERROR_CAUSE[-OB_ERR_UPDATE_ROWKEY_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UPDATE_ROWKEY_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UPDATE_ROWKEY_COLUMN] = -1; SQLSTATE[-OB_ERR_UPDATE_ROWKEY_COLUMN] = "42000"; STR_ERROR[-OB_ERR_UPDATE_ROWKEY_COLUMN] = "Can not update rowkey column"; @@ -4668,6 +5687,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UPDATE_ROWKEY_COLUMN] = "ORA-00600: internal error code, arguments: -5040, Can not update rowkey column"; ERROR_NAME[-OB_ERR_UPDATE_JOIN_COLUMN] = "OB_ERR_UPDATE_JOIN_COLUMN"; + ERROR_CAUSE[-OB_ERR_UPDATE_JOIN_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UPDATE_JOIN_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UPDATE_JOIN_COLUMN] = -1; SQLSTATE[-OB_ERR_UPDATE_JOIN_COLUMN] = "42000"; STR_ERROR[-OB_ERR_UPDATE_JOIN_COLUMN] = "Can not update join column"; @@ -4678,6 +5699,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UPDATE_JOIN_COLUMN] = "ORA-00600: internal error code, arguments: -5041, Can not update join column"; ERROR_NAME[-OB_ERR_INVALID_COLUMN_NUM] = "OB_ERR_INVALID_COLUMN_NUM"; + ERROR_CAUSE[-OB_ERR_INVALID_COLUMN_NUM] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_COLUMN_NUM] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_COLUMN_NUM] = ER_OPERAND_COLUMNS; SQLSTATE[-OB_ERR_INVALID_COLUMN_NUM] = "21000"; STR_ERROR[-OB_ERR_INVALID_COLUMN_NUM] = "Invalid column number"; @@ -4688,6 +5711,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_COLUMN_NUM] = "ORA-00600: internal error code, arguments: -5042, Operand should contain %ld column(s)"; ERROR_NAME[-OB_ERR_PREPARE_STMT_NOT_FOUND] = "OB_ERR_PREPARE_STMT_NOT_FOUND"; + ERROR_CAUSE[-OB_ERR_PREPARE_STMT_NOT_FOUND] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PREPARE_STMT_NOT_FOUND] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PREPARE_STMT_NOT_FOUND] = ER_UNKNOWN_STMT_HANDLER; SQLSTATE[-OB_ERR_PREPARE_STMT_NOT_FOUND] = "HY007"; STR_ERROR[-OB_ERR_PREPARE_STMT_NOT_FOUND] = "Unknown prepared statement"; @@ -4698,6 +5723,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PREPARE_STMT_NOT_FOUND] = "ORA-00600: internal error code, arguments: -5043, statement not prepared, stmt_id=%u"; ERROR_NAME[-OB_ERR_SYS_VARIABLE_UNKNOWN] = "OB_ERR_SYS_VARIABLE_UNKNOWN"; + ERROR_CAUSE[-OB_ERR_SYS_VARIABLE_UNKNOWN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SYS_VARIABLE_UNKNOWN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SYS_VARIABLE_UNKNOWN] = ER_UNKNOWN_SYSTEM_VARIABLE; SQLSTATE[-OB_ERR_SYS_VARIABLE_UNKNOWN] = "HY000"; STR_ERROR[-OB_ERR_SYS_VARIABLE_UNKNOWN] = "Unknown system variable"; @@ -4708,6 +5735,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SYS_VARIABLE_UNKNOWN] = "ORA-00600: internal error code, arguments: -5044, Unknown system variable '%.*s'"; ERROR_NAME[-OB_ERR_OLDER_PRIVILEGE_VERSION] = "OB_ERR_OLDER_PRIVILEGE_VERSION"; + ERROR_CAUSE[-OB_ERR_OLDER_PRIVILEGE_VERSION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OLDER_PRIVILEGE_VERSION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OLDER_PRIVILEGE_VERSION] = -1; SQLSTATE[-OB_ERR_OLDER_PRIVILEGE_VERSION] = "HY000"; STR_ERROR[-OB_ERR_OLDER_PRIVILEGE_VERSION] = "Older privilege version"; @@ -4718,6 +5747,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_OLDER_PRIVILEGE_VERSION] = "ORA-00600: internal error code, arguments: -5046, Older privilege version"; ERROR_NAME[-OB_ERR_LACK_OF_ROWKEY_COL] = "OB_ERR_LACK_OF_ROWKEY_COL"; + ERROR_CAUSE[-OB_ERR_LACK_OF_ROWKEY_COL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_LACK_OF_ROWKEY_COL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_LACK_OF_ROWKEY_COL] = ER_REQUIRES_PRIMARY_KEY; SQLSTATE[-OB_ERR_LACK_OF_ROWKEY_COL] = "42000"; STR_ERROR[-OB_ERR_LACK_OF_ROWKEY_COL] = "No rowkey column specified"; @@ -4728,6 +5759,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_LACK_OF_ROWKEY_COL] = "ORA-00600: internal error code, arguments: -5047, Primary key column(s) not specified in the WHERE clause"; ERROR_NAME[-OB_ERR_USER_EXIST] = "OB_ERR_USER_EXIST"; + ERROR_CAUSE[-OB_ERR_USER_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_USER_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_USER_EXIST] = -1; SQLSTATE[-OB_ERR_USER_EXIST] = "42710"; STR_ERROR[-OB_ERR_USER_EXIST] = "User exists"; @@ -4736,6 +5769,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_USER_EXIST] = "ORA-01920: user name conflicts with another user or role name"; ORACLE_STR_USER_ERROR[-OB_ERR_USER_EXIST] = "ORA-01920: user name conflicts with another user or role name"; ERROR_NAME[-OB_ERR_PASSWORD_EMPTY] = "OB_ERR_PASSWORD_EMPTY"; + ERROR_CAUSE[-OB_ERR_PASSWORD_EMPTY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PASSWORD_EMPTY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PASSWORD_EMPTY] = -1; SQLSTATE[-OB_ERR_PASSWORD_EMPTY] = "HY000"; STR_ERROR[-OB_ERR_PASSWORD_EMPTY] = "Empty password"; @@ -4744,6 +5779,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_PASSWORD_EMPTY] = "ORA-00600: internal error code, arguments: -5051, Empty password"; ORACLE_STR_USER_ERROR[-OB_ERR_PASSWORD_EMPTY] = "ORA-00600: internal error code, arguments: -5051, Empty password"; ERROR_NAME[-OB_ERR_GRANT_PRIVILEGES_TO_CREATE_TABLE] = "OB_ERR_GRANT_PRIVILEGES_TO_CREATE_TABLE"; + ERROR_CAUSE[-OB_ERR_GRANT_PRIVILEGES_TO_CREATE_TABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_GRANT_PRIVILEGES_TO_CREATE_TABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_GRANT_PRIVILEGES_TO_CREATE_TABLE] = -1; SQLSTATE[-OB_ERR_GRANT_PRIVILEGES_TO_CREATE_TABLE] = "42000"; STR_ERROR[-OB_ERR_GRANT_PRIVILEGES_TO_CREATE_TABLE] = "Failed to grant privelege"; @@ -4754,6 +5791,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_GRANT_PRIVILEGES_TO_CREATE_TABLE] = "ORA-00600: internal error code, arguments: -5052, Failed to grant privelege"; ERROR_NAME[-OB_ERR_WRONG_DYNAMIC_PARAM] = "OB_ERR_WRONG_DYNAMIC_PARAM"; + ERROR_CAUSE[-OB_ERR_WRONG_DYNAMIC_PARAM] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_DYNAMIC_PARAM] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_DYNAMIC_PARAM] = -1; SQLSTATE[-OB_ERR_WRONG_DYNAMIC_PARAM] = "HY093"; STR_ERROR[-OB_ERR_WRONG_DYNAMIC_PARAM] = "Wrong dynamic parameters"; @@ -4765,6 +5804,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WRONG_DYNAMIC_PARAM] = "ORA-00600: internal error code, arguments: -5053, Incorrect " "arguments number to EXECUTE, need %ld arguments but give %ld"; ERROR_NAME[-OB_ERR_PARAM_SIZE] = "OB_ERR_PARAM_SIZE"; + ERROR_CAUSE[-OB_ERR_PARAM_SIZE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARAM_SIZE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARAM_SIZE] = ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT; SQLSTATE[-OB_ERR_PARAM_SIZE] = "42000"; STR_ERROR[-OB_ERR_PARAM_SIZE] = "Incorrect parameter count"; @@ -4774,6 +5815,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PARAM_SIZE] = "ORA-00909: invalid number of arguments in the call to native function '%.*s'"; ERROR_NAME[-OB_ERR_FUNCTION_UNKNOWN] = "OB_ERR_FUNCTION_UNKNOWN"; + ERROR_CAUSE[-OB_ERR_FUNCTION_UNKNOWN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_FUNCTION_UNKNOWN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_FUNCTION_UNKNOWN] = ER_SP_DOES_NOT_EXIST; SQLSTATE[-OB_ERR_FUNCTION_UNKNOWN] = "42000"; STR_ERROR[-OB_ERR_FUNCTION_UNKNOWN] = "FUNCTION does not exist"; @@ -4784,6 +5827,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_FUNCTION_UNKNOWN] = "ORA-00600: internal error code, arguments: -5055, FUNCTION %.*s does not exist"; ERROR_NAME[-OB_ERR_CREAT_MODIFY_TIME_COLUMN] = "OB_ERR_CREAT_MODIFY_TIME_COLUMN"; + ERROR_CAUSE[-OB_ERR_CREAT_MODIFY_TIME_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CREAT_MODIFY_TIME_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CREAT_MODIFY_TIME_COLUMN] = -1; SQLSTATE[-OB_ERR_CREAT_MODIFY_TIME_COLUMN] = "23000"; STR_ERROR[-OB_ERR_CREAT_MODIFY_TIME_COLUMN] = "CreateTime or ModifyTime column cannot be modified"; @@ -4794,6 +5839,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CREAT_MODIFY_TIME_COLUMN] = "ORA-00600: internal error code, arguments: -5056, CreateTime or ModifyTime column cannot be modified"; ERROR_NAME[-OB_ERR_MODIFY_PRIMARY_KEY] = "OB_ERR_MODIFY_PRIMARY_KEY"; + ERROR_CAUSE[-OB_ERR_MODIFY_PRIMARY_KEY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MODIFY_PRIMARY_KEY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MODIFY_PRIMARY_KEY] = -1; SQLSTATE[-OB_ERR_MODIFY_PRIMARY_KEY] = "23000"; STR_ERROR[-OB_ERR_MODIFY_PRIMARY_KEY] = "Primary key cannot be modified"; @@ -4804,6 +5851,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MODIFY_PRIMARY_KEY] = "ORA-00600: internal error code, arguments: -5057, Primary key cannot be modified"; ERROR_NAME[-OB_ERR_PARAM_DUPLICATE] = "OB_ERR_PARAM_DUPLICATE"; + ERROR_CAUSE[-OB_ERR_PARAM_DUPLICATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARAM_DUPLICATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARAM_DUPLICATE] = -1; SQLSTATE[-OB_ERR_PARAM_DUPLICATE] = "42000"; STR_ERROR[-OB_ERR_PARAM_DUPLICATE] = "Duplicated parameters"; @@ -4814,6 +5863,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PARAM_DUPLICATE] = "ORA-00600: internal error code, arguments: -5058, Duplicated parameters"; ERROR_NAME[-OB_ERR_TOO_MANY_SESSIONS] = "OB_ERR_TOO_MANY_SESSIONS"; + ERROR_CAUSE[-OB_ERR_TOO_MANY_SESSIONS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_MANY_SESSIONS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_MANY_SESSIONS] = ER_TOO_MANY_USER_CONNECTIONS; SQLSTATE[-OB_ERR_TOO_MANY_SESSIONS] = "42000"; STR_ERROR[-OB_ERR_TOO_MANY_SESSIONS] = "Too many sessions"; @@ -4823,6 +5874,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TOO_MANY_SESSIONS] = "ORA-00600: internal error code, arguments: -5059, Too many sessions"; ERROR_NAME[-OB_ERR_TOO_MANY_PS] = "OB_ERR_TOO_MANY_PS"; + ERROR_CAUSE[-OB_ERR_TOO_MANY_PS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_MANY_PS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_MANY_PS] = -1; SQLSTATE[-OB_ERR_TOO_MANY_PS] = "54023"; STR_ERROR[-OB_ERR_TOO_MANY_PS] = "Too many prepared statements"; @@ -4833,6 +5886,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TOO_MANY_PS] = "ORA-00600: internal error code, arguments: -5061, Too many prepared statements"; ERROR_NAME[-OB_ERR_HINT_UNKNOWN] = "OB_ERR_HINT_UNKNOWN"; + ERROR_CAUSE[-OB_ERR_HINT_UNKNOWN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_HINT_UNKNOWN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_HINT_UNKNOWN] = -1; SQLSTATE[-OB_ERR_HINT_UNKNOWN] = "42000"; STR_ERROR[-OB_ERR_HINT_UNKNOWN] = "Unknown hint"; @@ -4841,6 +5896,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_HINT_UNKNOWN] = "ORA-00600: internal error code, arguments: -5063, Unknown hint"; ORACLE_STR_USER_ERROR[-OB_ERR_HINT_UNKNOWN] = "ORA-00600: internal error code, arguments: -5063, Unknown hint"; ERROR_NAME[-OB_ERR_WHEN_UNSATISFIED] = "OB_ERR_WHEN_UNSATISFIED"; + ERROR_CAUSE[-OB_ERR_WHEN_UNSATISFIED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WHEN_UNSATISFIED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WHEN_UNSATISFIED] = -1; SQLSTATE[-OB_ERR_WHEN_UNSATISFIED] = "23000"; STR_ERROR[-OB_ERR_WHEN_UNSATISFIED] = "When condition not satisfied"; @@ -4851,6 +5908,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WHEN_UNSATISFIED] = "ORA-00600: internal error code, arguments: -5064, When condition not satisfied"; ERROR_NAME[-OB_ERR_QUERY_INTERRUPTED] = "OB_ERR_QUERY_INTERRUPTED"; + ERROR_CAUSE[-OB_ERR_QUERY_INTERRUPTED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_QUERY_INTERRUPTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_QUERY_INTERRUPTED] = ER_QUERY_INTERRUPTED; SQLSTATE[-OB_ERR_QUERY_INTERRUPTED] = "70100"; STR_ERROR[-OB_ERR_QUERY_INTERRUPTED] = "Query execution was interrupted"; @@ -4861,6 +5920,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_QUERY_INTERRUPTED] = "ORA-00600: internal error code, arguments: -5065, Query execution was interrupted"; ERROR_NAME[-OB_ERR_SESSION_INTERRUPTED] = "OB_ERR_SESSION_INTERRUPTED"; + ERROR_CAUSE[-OB_ERR_SESSION_INTERRUPTED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SESSION_INTERRUPTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SESSION_INTERRUPTED] = -1; SQLSTATE[-OB_ERR_SESSION_INTERRUPTED] = "HY000"; STR_ERROR[-OB_ERR_SESSION_INTERRUPTED] = "Session interrupted"; @@ -4870,6 +5931,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SESSION_INTERRUPTED] = "ORA-01092: OceanBase instance terminated. Disconnection forced"; ERROR_NAME[-OB_ERR_UNKNOWN_SESSION_ID] = "OB_ERR_UNKNOWN_SESSION_ID"; + ERROR_CAUSE[-OB_ERR_UNKNOWN_SESSION_ID] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UNKNOWN_SESSION_ID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UNKNOWN_SESSION_ID] = -1; SQLSTATE[-OB_ERR_UNKNOWN_SESSION_ID] = "HY000"; STR_ERROR[-OB_ERR_UNKNOWN_SESSION_ID] = "Unknown session ID"; @@ -4880,6 +5943,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UNKNOWN_SESSION_ID] = "ORA-00600: internal error code, arguments: -5067, Unknown session ID"; ERROR_NAME[-OB_ERR_PROTOCOL_NOT_RECOGNIZE] = "OB_ERR_PROTOCOL_NOT_RECOGNIZE"; + ERROR_CAUSE[-OB_ERR_PROTOCOL_NOT_RECOGNIZE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PROTOCOL_NOT_RECOGNIZE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PROTOCOL_NOT_RECOGNIZE] = -1; SQLSTATE[-OB_ERR_PROTOCOL_NOT_RECOGNIZE] = "HY000"; STR_ERROR[-OB_ERR_PROTOCOL_NOT_RECOGNIZE] = "Incorrect protocol"; @@ -4890,6 +5955,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PROTOCOL_NOT_RECOGNIZE] = "ORA-00600: internal error code, arguments: -5068, Incorrect protocol"; ERROR_NAME[-OB_ERR_WRITE_AUTH_ERROR] = "OB_ERR_WRITE_AUTH_ERROR"; + ERROR_CAUSE[-OB_ERR_WRITE_AUTH_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRITE_AUTH_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRITE_AUTH_ERROR] = -1; SQLSTATE[-OB_ERR_WRITE_AUTH_ERROR] = "HY000"; STR_ERROR[-OB_ERR_WRITE_AUTH_ERROR] = "Write auth packet error"; @@ -4900,6 +5967,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WRITE_AUTH_ERROR] = "ORA-00600: internal error code, arguments: -5069, Write auth packet error"; ERROR_NAME[-OB_ERR_PARSE_JOIN_INFO] = "OB_ERR_PARSE_JOIN_INFO"; + ERROR_CAUSE[-OB_ERR_PARSE_JOIN_INFO] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARSE_JOIN_INFO] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARSE_JOIN_INFO] = -1; SQLSTATE[-OB_ERR_PARSE_JOIN_INFO] = "42000"; STR_ERROR[-OB_ERR_PARSE_JOIN_INFO] = "Wrong join info"; @@ -4909,6 +5978,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PARSE_JOIN_INFO] = "ORA-00600: internal error code, arguments: -5070, Wrong join info"; ERROR_NAME[-OB_ERR_ALTER_INDEX_COLUMN] = "OB_ERR_ALTER_INDEX_COLUMN"; + ERROR_CAUSE[-OB_ERR_ALTER_INDEX_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ALTER_INDEX_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ALTER_INDEX_COLUMN] = -1; SQLSTATE[-OB_ERR_ALTER_INDEX_COLUMN] = "42000"; STR_ERROR[-OB_ERR_ALTER_INDEX_COLUMN] = "Cannot alter index column"; @@ -4919,6 +5990,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ALTER_INDEX_COLUMN] = "ORA-00600: internal error code, arguments: -5071, Cannot alter index column"; ERROR_NAME[-OB_ERR_MODIFY_INDEX_TABLE] = "OB_ERR_MODIFY_INDEX_TABLE"; + ERROR_CAUSE[-OB_ERR_MODIFY_INDEX_TABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MODIFY_INDEX_TABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MODIFY_INDEX_TABLE] = -1; SQLSTATE[-OB_ERR_MODIFY_INDEX_TABLE] = "42000"; STR_ERROR[-OB_ERR_MODIFY_INDEX_TABLE] = "Cannot modify index table"; @@ -4929,6 +6002,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MODIFY_INDEX_TABLE] = "ORA-00600: internal error code, arguments: -5072, Cannot modify index table"; ERROR_NAME[-OB_ERR_INDEX_UNAVAILABLE] = "OB_ERR_INDEX_UNAVAILABLE"; + ERROR_CAUSE[-OB_ERR_INDEX_UNAVAILABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INDEX_UNAVAILABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INDEX_UNAVAILABLE] = ER_NO_SUCH_INDEX; SQLSTATE[-OB_ERR_INDEX_UNAVAILABLE] = "42000"; STR_ERROR[-OB_ERR_INDEX_UNAVAILABLE] = "Index unavailable"; @@ -4938,6 +6013,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INDEX_UNAVAILABLE] = "ORA-00600: internal error code, arguments: -5073, Index unavailable"; ERROR_NAME[-OB_ERR_NOP_VALUE] = "OB_ERR_NOP_VALUE"; + ERROR_CAUSE[-OB_ERR_NOP_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NOP_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NOP_VALUE] = -1; SQLSTATE[-OB_ERR_NOP_VALUE] = "23000"; STR_ERROR[-OB_ERR_NOP_VALUE] = "NOP cannot be used here"; @@ -4947,6 +6024,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NOP_VALUE] = "ORA-00600: internal error code, arguments: -5074, NOP cannot be used here"; ERROR_NAME[-OB_ERR_PS_TOO_MANY_PARAM] = "OB_ERR_PS_TOO_MANY_PARAM"; + ERROR_CAUSE[-OB_ERR_PS_TOO_MANY_PARAM] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PS_TOO_MANY_PARAM] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PS_TOO_MANY_PARAM] = ER_PS_MANY_PARAM; SQLSTATE[-OB_ERR_PS_TOO_MANY_PARAM] = "54000"; STR_ERROR[-OB_ERR_PS_TOO_MANY_PARAM] = "Prepared statement contains too many placeholders"; @@ -4957,6 +6036,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PS_TOO_MANY_PARAM] = "ORA-00600: internal error code, arguments: -5080, Prepared statement contains too many placeholders"; ERROR_NAME[-OB_ERR_READ_ONLY] = "OB_ERR_READ_ONLY"; + ERROR_CAUSE[-OB_ERR_READ_ONLY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_READ_ONLY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_READ_ONLY] = -1; SQLSTATE[-OB_ERR_READ_ONLY] = "25000"; STR_ERROR[-OB_ERR_READ_ONLY] = "The server is read only now"; @@ -4967,6 +6048,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_READ_ONLY] = "ORA-00600: internal error code, arguments: -5081, The server is read only now"; ERROR_NAME[-OB_ERR_INVALID_TYPE_FOR_OP] = "OB_ERR_INVALID_TYPE_FOR_OP"; + ERROR_CAUSE[-OB_ERR_INVALID_TYPE_FOR_OP] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_TYPE_FOR_OP] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_TYPE_FOR_OP] = -1; SQLSTATE[-OB_ERR_INVALID_TYPE_FOR_OP] = "22000"; STR_ERROR[-OB_ERR_INVALID_TYPE_FOR_OP] = "Invalid data type for the operation"; @@ -4976,6 +6059,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_TYPE_FOR_OP] = "ORA-00932: inconsistent datatypes: left_type=%s right_type=%s"; ERROR_NAME[-OB_ERR_CAST_VARCHAR_TO_BOOL] = "OB_ERR_CAST_VARCHAR_TO_BOOL"; + ERROR_CAUSE[-OB_ERR_CAST_VARCHAR_TO_BOOL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CAST_VARCHAR_TO_BOOL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CAST_VARCHAR_TO_BOOL] = -1; SQLSTATE[-OB_ERR_CAST_VARCHAR_TO_BOOL] = "22000"; STR_ERROR[-OB_ERR_CAST_VARCHAR_TO_BOOL] = "Can not cast varchar value to bool type"; @@ -4986,6 +6071,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CAST_VARCHAR_TO_BOOL] = "ORA-00600: internal error code, arguments: -5084, Can not cast varchar value to bool type"; ERROR_NAME[-OB_ERR_CAST_VARCHAR_TO_NUMBER] = "OB_ERR_CAST_VARCHAR_TO_NUMBER"; + ERROR_CAUSE[-OB_ERR_CAST_VARCHAR_TO_NUMBER] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CAST_VARCHAR_TO_NUMBER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CAST_VARCHAR_TO_NUMBER] = -1; SQLSTATE[-OB_ERR_CAST_VARCHAR_TO_NUMBER] = "22000"; STR_ERROR[-OB_ERR_CAST_VARCHAR_TO_NUMBER] = "Not a number Can not cast varchar value to number type"; @@ -4994,6 +6081,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CAST_VARCHAR_TO_NUMBER] = "ORA-01722: invalid number"; ORACLE_STR_USER_ERROR[-OB_ERR_CAST_VARCHAR_TO_NUMBER] = "ORA-01722: invalid number"; ERROR_NAME[-OB_ERR_CAST_VARCHAR_TO_TIME] = "OB_ERR_CAST_VARCHAR_TO_TIME"; + ERROR_CAUSE[-OB_ERR_CAST_VARCHAR_TO_TIME] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CAST_VARCHAR_TO_TIME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CAST_VARCHAR_TO_TIME] = -1; SQLSTATE[-OB_ERR_CAST_VARCHAR_TO_TIME] = "22000"; STR_ERROR[-OB_ERR_CAST_VARCHAR_TO_TIME] = "Not timestamp Can not cast varchar value to timestamp type"; @@ -5004,6 +6093,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CAST_VARCHAR_TO_TIME] = "ORA-00600: internal error code, arguments: -5086, Not timestamp Can not cast varchar value to timestamp type"; ERROR_NAME[-OB_ERR_CAST_NUMBER_OVERFLOW] = "OB_ERR_CAST_NUMBER_OVERFLOW"; + ERROR_CAUSE[-OB_ERR_CAST_NUMBER_OVERFLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CAST_NUMBER_OVERFLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CAST_NUMBER_OVERFLOW] = -1; SQLSTATE[-OB_ERR_CAST_NUMBER_OVERFLOW] = "22000"; STR_ERROR[-OB_ERR_CAST_NUMBER_OVERFLOW] = "Result value was out of range when cast to number"; @@ -5014,6 +6105,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CAST_NUMBER_OVERFLOW] = "ORA-00600: internal error code, arguments: -5087, Result value was out of range when cast to number"; ERROR_NAME[-OB_INTEGER_PRECISION_OVERFLOW] = "OB_INTEGER_PRECISION_OVERFLOW"; + ERROR_CAUSE[-OB_INTEGER_PRECISION_OVERFLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_INTEGER_PRECISION_OVERFLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INTEGER_PRECISION_OVERFLOW] = ER_WARN_DATA_OUT_OF_RANGE; SQLSTATE[-OB_INTEGER_PRECISION_OVERFLOW] = "22003"; STR_ERROR[-OB_INTEGER_PRECISION_OVERFLOW] = "Result value was out of range when casting varchar to number"; @@ -5024,6 +6117,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INTEGER_PRECISION_OVERFLOW] = "ORA-01426: numeric overflow, value larger than specified precision(%ld,%ld) allowed for this column"; ERROR_NAME[-OB_DECIMAL_PRECISION_OVERFLOW] = "OB_DECIMAL_PRECISION_OVERFLOW"; + ERROR_CAUSE[-OB_DECIMAL_PRECISION_OVERFLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_DECIMAL_PRECISION_OVERFLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DECIMAL_PRECISION_OVERFLOW] = ER_WARN_DATA_OUT_OF_RANGE; SQLSTATE[-OB_DECIMAL_PRECISION_OVERFLOW] = "22003"; STR_ERROR[-OB_DECIMAL_PRECISION_OVERFLOW] = "Result value was out of range when casting varchar to number"; @@ -5034,6 +6129,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DECIMAL_PRECISION_OVERFLOW] = "ORA-01426: numeric overflow, value(%s) larger than specified precision(%ld,%ld) allowed for this column"; ERROR_NAME[-OB_SCHEMA_NUMBER_PRECISION_OVERFLOW] = "OB_SCHEMA_NUMBER_PRECISION_OVERFLOW"; + ERROR_CAUSE[-OB_SCHEMA_NUMBER_PRECISION_OVERFLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_SCHEMA_NUMBER_PRECISION_OVERFLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SCHEMA_NUMBER_PRECISION_OVERFLOW] = -1; SQLSTATE[-OB_SCHEMA_NUMBER_PRECISION_OVERFLOW] = "22000"; STR_ERROR[-OB_SCHEMA_NUMBER_PRECISION_OVERFLOW] = "Precision was out of range"; @@ -5044,6 +6141,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SCHEMA_NUMBER_PRECISION_OVERFLOW] = "ORA-00600: internal error code, arguments: -5090, Precision was out of range"; ERROR_NAME[-OB_SCHEMA_NUMBER_SCALE_OVERFLOW] = "OB_SCHEMA_NUMBER_SCALE_OVERFLOW"; + ERROR_CAUSE[-OB_SCHEMA_NUMBER_SCALE_OVERFLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_SCHEMA_NUMBER_SCALE_OVERFLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SCHEMA_NUMBER_SCALE_OVERFLOW] = -1; SQLSTATE[-OB_SCHEMA_NUMBER_SCALE_OVERFLOW] = "22000"; STR_ERROR[-OB_SCHEMA_NUMBER_SCALE_OVERFLOW] = "Scale value was out of range"; @@ -5054,6 +6153,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SCHEMA_NUMBER_SCALE_OVERFLOW] = "ORA-00600: internal error code, arguments: -5091, Scale value was out of range"; ERROR_NAME[-OB_ERR_INDEX_UNKNOWN] = "OB_ERR_INDEX_UNKNOWN"; + ERROR_CAUSE[-OB_ERR_INDEX_UNKNOWN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INDEX_UNKNOWN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INDEX_UNKNOWN] = -1; SQLSTATE[-OB_ERR_INDEX_UNKNOWN] = "42000"; STR_ERROR[-OB_ERR_INDEX_UNKNOWN] = "Unknown index"; @@ -5062,6 +6163,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INDEX_UNKNOWN] = "ORA-00600: internal error code, arguments: -5092, Unknown index"; ORACLE_STR_USER_ERROR[-OB_ERR_INDEX_UNKNOWN] = "ORA-00600: internal error code, arguments: -5092, Unknown index"; ERROR_NAME[-OB_NUMERIC_OVERFLOW] = "OB_NUMERIC_OVERFLOW"; + ERROR_CAUSE[-OB_NUMERIC_OVERFLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_NUMERIC_OVERFLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NUMERIC_OVERFLOW] = ER_WARN_DATA_OUT_OF_RANGE; SQLSTATE[-OB_NUMERIC_OVERFLOW] = "22003"; STR_ERROR[-OB_NUMERIC_OVERFLOW] = "Result value was out of range when casting varchar to number"; @@ -5070,6 +6173,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NUMERIC_OVERFLOW] = "ORA-01426: numeric overflow"; ORACLE_STR_USER_ERROR[-OB_NUMERIC_OVERFLOW] = "ORA-01426: numeric overflow"; ERROR_NAME[-OB_ERR_TOO_MANY_JOIN_TABLES] = "OB_ERR_TOO_MANY_JOIN_TABLES"; + ERROR_CAUSE[-OB_ERR_TOO_MANY_JOIN_TABLES] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_MANY_JOIN_TABLES] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_MANY_JOIN_TABLES] = -1; SQLSTATE[-OB_ERR_TOO_MANY_JOIN_TABLES] = "HY000"; STR_ERROR[-OB_ERR_TOO_MANY_JOIN_TABLES] = "too many joined tables"; @@ -5080,6 +6185,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TOO_MANY_JOIN_TABLES] = "ORA-00600: internal error code, arguments: -5094, too many joined tables"; ERROR_NAME[-OB_ERR_VARCHAR_TOO_LONG] = "OB_ERR_VARCHAR_TOO_LONG"; + ERROR_CAUSE[-OB_ERR_VARCHAR_TOO_LONG] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_VARCHAR_TOO_LONG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_VARCHAR_TOO_LONG] = -1; SQLSTATE[-OB_ERR_VARCHAR_TOO_LONG] = "22001"; STR_ERROR[-OB_ERR_VARCHAR_TOO_LONG] = "Varchar value is too long for the column"; @@ -5090,6 +6197,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_VARCHAR_TOO_LONG] = "ORA-00600: internal error code, arguments: -5098, Data too long(%d>%ld) for column '%s'"; ERROR_NAME[-OB_ERR_SYS_CONFIG_UNKNOWN] = "OB_ERR_SYS_CONFIG_UNKNOWN"; + ERROR_CAUSE[-OB_ERR_SYS_CONFIG_UNKNOWN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SYS_CONFIG_UNKNOWN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SYS_CONFIG_UNKNOWN] = -1; SQLSTATE[-OB_ERR_SYS_CONFIG_UNKNOWN] = "42000"; STR_ERROR[-OB_ERR_SYS_CONFIG_UNKNOWN] = "System config unknown"; @@ -5100,6 +6209,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SYS_CONFIG_UNKNOWN] = "ORA-00600: internal error code, arguments: -5099, System config unknown"; ERROR_NAME[-OB_ERR_LOCAL_VARIABLE] = "OB_ERR_LOCAL_VARIABLE"; + ERROR_CAUSE[-OB_ERR_LOCAL_VARIABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_LOCAL_VARIABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_LOCAL_VARIABLE] = ER_LOCAL_VARIABLE; SQLSTATE[-OB_ERR_LOCAL_VARIABLE] = "HY000"; STR_ERROR[-OB_ERR_LOCAL_VARIABLE] = "Local variable"; @@ -5110,6 +6221,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_LOCAL_VARIABLE] = "ORA-00600: internal error code, arguments: -5100, Variable " "\'%.*s\' is a SESSION variable and can't be used with SET GLOBAL"; ERROR_NAME[-OB_ERR_GLOBAL_VARIABLE] = "OB_ERR_GLOBAL_VARIABLE"; + ERROR_CAUSE[-OB_ERR_GLOBAL_VARIABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_GLOBAL_VARIABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_GLOBAL_VARIABLE] = ER_GLOBAL_VARIABLE; SQLSTATE[-OB_ERR_GLOBAL_VARIABLE] = "HY000"; STR_ERROR[-OB_ERR_GLOBAL_VARIABLE] = "Global variable"; @@ -5120,6 +6233,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_GLOBAL_VARIABLE] = "ORA-00600: internal error code, arguments: -5101, Variable " "\'%.*s\' is a GLOBAL variable and should be set with SET GLOBAL"; ERROR_NAME[-OB_ERR_VARIABLE_IS_READONLY] = "OB_ERR_VARIABLE_IS_READONLY"; + ERROR_CAUSE[-OB_ERR_VARIABLE_IS_READONLY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_VARIABLE_IS_READONLY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_VARIABLE_IS_READONLY] = ER_VARIABLE_IS_READONLY; SQLSTATE[-OB_ERR_VARIABLE_IS_READONLY] = "HY000"; STR_ERROR[-OB_ERR_VARIABLE_IS_READONLY] = "variable is read only"; @@ -5132,6 +6247,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5102, %.*s variable '%.*s' is read-only. Use SET %.*s to assign " "the value"; ERROR_NAME[-OB_ERR_INCORRECT_GLOBAL_LOCAL_VAR] = "OB_ERR_INCORRECT_GLOBAL_LOCAL_VAR"; + ERROR_CAUSE[-OB_ERR_INCORRECT_GLOBAL_LOCAL_VAR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INCORRECT_GLOBAL_LOCAL_VAR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INCORRECT_GLOBAL_LOCAL_VAR] = ER_INCORRECT_GLOBAL_LOCAL_VAR; SQLSTATE[-OB_ERR_INCORRECT_GLOBAL_LOCAL_VAR] = "HY000"; STR_ERROR[-OB_ERR_INCORRECT_GLOBAL_LOCAL_VAR] = "incorrect global or local variable"; @@ -5142,6 +6259,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INCORRECT_GLOBAL_LOCAL_VAR] = "ORA-00600: internal error code, arguments: -5103, Variable '%.*s' is a %.*s variable"; ERROR_NAME[-OB_ERR_EXPIRE_INFO_TOO_LONG] = "OB_ERR_EXPIRE_INFO_TOO_LONG"; + ERROR_CAUSE[-OB_ERR_EXPIRE_INFO_TOO_LONG] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_EXPIRE_INFO_TOO_LONG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_EXPIRE_INFO_TOO_LONG] = -1; SQLSTATE[-OB_ERR_EXPIRE_INFO_TOO_LONG] = "42000"; STR_ERROR[-OB_ERR_EXPIRE_INFO_TOO_LONG] = "Expire expression too long"; @@ -5153,6 +6272,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5104, length(%d) of expire_info is larger than the max " "allowed(%ld)"; ERROR_NAME[-OB_ERR_EXPIRE_COND_TOO_LONG] = "OB_ERR_EXPIRE_COND_TOO_LONG"; + ERROR_CAUSE[-OB_ERR_EXPIRE_COND_TOO_LONG] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_EXPIRE_COND_TOO_LONG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_EXPIRE_COND_TOO_LONG] = -1; SQLSTATE[-OB_ERR_EXPIRE_COND_TOO_LONG] = "42000"; STR_ERROR[-OB_ERR_EXPIRE_COND_TOO_LONG] = "Expire condition too long"; @@ -5165,6 +6286,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5105, total length(%ld) of expire_info and its expression is " "larger than the max allowed(%ld)"; ERROR_NAME[-OB_INVALID_ARGUMENT_FOR_EXTRACT] = "OB_INVALID_ARGUMENT_FOR_EXTRACT"; + ERROR_CAUSE[-OB_INVALID_ARGUMENT_FOR_EXTRACT] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_ARGUMENT_FOR_EXTRACT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_ARGUMENT_FOR_EXTRACT] = -1; SQLSTATE[-OB_INVALID_ARGUMENT_FOR_EXTRACT] = "42000"; STR_ERROR[-OB_INVALID_ARGUMENT_FOR_EXTRACT] = "Invalid argument for extract()"; @@ -5175,6 +6298,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_ARGUMENT_FOR_EXTRACT] = "ORA-00600: internal error code, arguments: -5106, EXTRACT() expected timestamp or a string as date argument"; ERROR_NAME[-OB_INVALID_ARGUMENT_FOR_IS] = "OB_INVALID_ARGUMENT_FOR_IS"; + ERROR_CAUSE[-OB_INVALID_ARGUMENT_FOR_IS] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_ARGUMENT_FOR_IS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_ARGUMENT_FOR_IS] = -1; SQLSTATE[-OB_INVALID_ARGUMENT_FOR_IS] = "42000"; STR_ERROR[-OB_INVALID_ARGUMENT_FOR_IS] = "Invalid argument for IS operator"; @@ -5185,6 +6310,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_ARGUMENT_FOR_IS] = "ORA-00600: internal error code, arguments: -5107, Invalid operand type for IS operator, lval=%s"; ERROR_NAME[-OB_INVALID_ARGUMENT_FOR_LENGTH] = "OB_INVALID_ARGUMENT_FOR_LENGTH"; + ERROR_CAUSE[-OB_INVALID_ARGUMENT_FOR_LENGTH] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_ARGUMENT_FOR_LENGTH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_ARGUMENT_FOR_LENGTH] = -1; SQLSTATE[-OB_INVALID_ARGUMENT_FOR_LENGTH] = "42000"; STR_ERROR[-OB_INVALID_ARGUMENT_FOR_LENGTH] = "Invalid argument for length()"; @@ -5195,6 +6322,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_ARGUMENT_FOR_LENGTH] = "ORA-00600: internal error code, arguments: -5108, function LENGTH() expected a varchar argument"; ERROR_NAME[-OB_INVALID_ARGUMENT_FOR_SUBSTR] = "OB_INVALID_ARGUMENT_FOR_SUBSTR"; + ERROR_CAUSE[-OB_INVALID_ARGUMENT_FOR_SUBSTR] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_ARGUMENT_FOR_SUBSTR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_ARGUMENT_FOR_SUBSTR] = -1; SQLSTATE[-OB_INVALID_ARGUMENT_FOR_SUBSTR] = "42000"; STR_ERROR[-OB_INVALID_ARGUMENT_FOR_SUBSTR] = "Invalid argument for substr()"; @@ -5205,6 +6334,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_ARGUMENT_FOR_SUBSTR] = "ORA-00600: internal error code, arguments: -5109, invalid input format. ret=%d text=%s start=%s length=%s"; ERROR_NAME[-OB_INVALID_ARGUMENT_FOR_TIME_TO_USEC] = "OB_INVALID_ARGUMENT_FOR_TIME_TO_USEC"; + ERROR_CAUSE[-OB_INVALID_ARGUMENT_FOR_TIME_TO_USEC] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_ARGUMENT_FOR_TIME_TO_USEC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_ARGUMENT_FOR_TIME_TO_USEC] = -1; SQLSTATE[-OB_INVALID_ARGUMENT_FOR_TIME_TO_USEC] = "42000"; STR_ERROR[-OB_INVALID_ARGUMENT_FOR_TIME_TO_USEC] = "Invalid argument for time_to_usec()"; @@ -5217,6 +6348,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5110, TIME_TO_USEC() expected timestamp or a string as date " "argument"; ERROR_NAME[-OB_INVALID_ARGUMENT_FOR_USEC_TO_TIME] = "OB_INVALID_ARGUMENT_FOR_USEC_TO_TIME"; + ERROR_CAUSE[-OB_INVALID_ARGUMENT_FOR_USEC_TO_TIME] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_ARGUMENT_FOR_USEC_TO_TIME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_ARGUMENT_FOR_USEC_TO_TIME] = -1; SQLSTATE[-OB_INVALID_ARGUMENT_FOR_USEC_TO_TIME] = "42000"; STR_ERROR[-OB_INVALID_ARGUMENT_FOR_USEC_TO_TIME] = "Invalid argument for usec_to_time()"; @@ -5227,6 +6360,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_ARGUMENT_FOR_USEC_TO_TIME] = "ORA-00600: internal error code, arguments: -5111, USEC_TO_TIME expected a interger number as usec argument"; ERROR_NAME[-OB_ERR_USER_VARIABLE_UNKNOWN] = "OB_ERR_USER_VARIABLE_UNKNOWN"; + ERROR_CAUSE[-OB_ERR_USER_VARIABLE_UNKNOWN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_USER_VARIABLE_UNKNOWN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_USER_VARIABLE_UNKNOWN] = -1; SQLSTATE[-OB_ERR_USER_VARIABLE_UNKNOWN] = "42P01"; STR_ERROR[-OB_ERR_USER_VARIABLE_UNKNOWN] = "Unknown user variable"; @@ -5237,6 +6372,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_USER_VARIABLE_UNKNOWN] = "ORA-00600: internal error code, arguments: -5112, Variable %.*s does not exists"; ERROR_NAME[-OB_ILLEGAL_USAGE_OF_MERGING_FROZEN_TIME] = "OB_ILLEGAL_USAGE_OF_MERGING_FROZEN_TIME"; + ERROR_CAUSE[-OB_ILLEGAL_USAGE_OF_MERGING_FROZEN_TIME] = "Internal Error"; + ERROR_SOLUTION[-OB_ILLEGAL_USAGE_OF_MERGING_FROZEN_TIME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ILLEGAL_USAGE_OF_MERGING_FROZEN_TIME] = -1; SQLSTATE[-OB_ILLEGAL_USAGE_OF_MERGING_FROZEN_TIME] = "42000"; STR_ERROR[-OB_ILLEGAL_USAGE_OF_MERGING_FROZEN_TIME] = "Illegal usage of merging_frozen_time()"; @@ -5249,6 +6386,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5113, MERGING_FROZEN_TIME() system function only be used in daily " "merging."; ERROR_NAME[-OB_INVALID_NUMERIC] = "OB_INVALID_NUMERIC"; + ERROR_CAUSE[-OB_INVALID_NUMERIC] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_NUMERIC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_NUMERIC] = -1; SQLSTATE[-OB_INVALID_NUMERIC] = "42000"; STR_ERROR[-OB_INVALID_NUMERIC] = "Invalid numeric"; @@ -5257,6 +6396,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_INVALID_NUMERIC] = "ORA-01722: invalid number"; ORACLE_STR_USER_ERROR[-OB_INVALID_NUMERIC] = "ORA-01722: invalid number char '%c'"; ERROR_NAME[-OB_ERR_REGEXP_ERROR] = "OB_ERR_REGEXP_ERROR"; + ERROR_CAUSE[-OB_ERR_REGEXP_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_ERROR] = ER_REGEXP_ERROR; SQLSTATE[-OB_ERR_REGEXP_ERROR] = "42000"; STR_ERROR[-OB_ERR_REGEXP_ERROR] = "Got error 'empty (sub)expression' from regexp"; @@ -5267,6 +6408,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_ERROR] = "ORA-00600: internal error code, arguments: -5115, Got error 'empty (sub)expression' from regexp"; ERROR_NAME[-OB_SQL_LOG_OP_SETCHILD_OVERFLOW] = "OB_SQL_LOG_OP_SETCHILD_OVERFLOW"; + ERROR_CAUSE[-OB_SQL_LOG_OP_SETCHILD_OVERFLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_SQL_LOG_OP_SETCHILD_OVERFLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SQL_LOG_OP_SETCHILD_OVERFLOW] = -1; SQLSTATE[-OB_SQL_LOG_OP_SETCHILD_OVERFLOW] = "HY000"; STR_ERROR[-OB_SQL_LOG_OP_SETCHILD_OVERFLOW] = "Logical operator child index overflow"; @@ -5277,6 +6420,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SQL_LOG_OP_SETCHILD_OVERFLOW] = "ORA-00600: internal error code, arguments: -5116, Logical operator child index overflow"; ERROR_NAME[-OB_SQL_EXPLAIN_FAILED] = "OB_SQL_EXPLAIN_FAILED"; + ERROR_CAUSE[-OB_SQL_EXPLAIN_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_SQL_EXPLAIN_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SQL_EXPLAIN_FAILED] = -1; SQLSTATE[-OB_SQL_EXPLAIN_FAILED] = "HY000"; STR_ERROR[-OB_SQL_EXPLAIN_FAILED] = "fail to explain plan"; @@ -5286,6 +6431,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SQL_EXPLAIN_FAILED] = "ORA-00600: internal error code, arguments: -5117, fail to explain plan"; ERROR_NAME[-OB_SQL_OPT_COPY_OP_FAILED] = "OB_SQL_OPT_COPY_OP_FAILED"; + ERROR_CAUSE[-OB_SQL_OPT_COPY_OP_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_SQL_OPT_COPY_OP_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SQL_OPT_COPY_OP_FAILED] = -1; SQLSTATE[-OB_SQL_OPT_COPY_OP_FAILED] = "HY000"; STR_ERROR[-OB_SQL_OPT_COPY_OP_FAILED] = "fail to copy logical operator"; @@ -5296,6 +6443,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SQL_OPT_COPY_OP_FAILED] = "ORA-00600: internal error code, arguments: -5118, fail to copy logical operator"; ERROR_NAME[-OB_SQL_OPT_GEN_PLAN_FALIED] = "OB_SQL_OPT_GEN_PLAN_FALIED"; + ERROR_CAUSE[-OB_SQL_OPT_GEN_PLAN_FALIED] = "Internal Error"; + ERROR_SOLUTION[-OB_SQL_OPT_GEN_PLAN_FALIED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SQL_OPT_GEN_PLAN_FALIED] = -1; SQLSTATE[-OB_SQL_OPT_GEN_PLAN_FALIED] = "HY000"; STR_ERROR[-OB_SQL_OPT_GEN_PLAN_FALIED] = "fail to generate plan"; @@ -5306,6 +6455,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SQL_OPT_GEN_PLAN_FALIED] = "ORA-00600: internal error code, arguments: -5119, fail to generate plan"; ERROR_NAME[-OB_SQL_OPT_CREATE_RAWEXPR_FAILED] = "OB_SQL_OPT_CREATE_RAWEXPR_FAILED"; + ERROR_CAUSE[-OB_SQL_OPT_CREATE_RAWEXPR_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_SQL_OPT_CREATE_RAWEXPR_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SQL_OPT_CREATE_RAWEXPR_FAILED] = -1; SQLSTATE[-OB_SQL_OPT_CREATE_RAWEXPR_FAILED] = "HY000"; STR_ERROR[-OB_SQL_OPT_CREATE_RAWEXPR_FAILED] = "fail to create raw expr"; @@ -5316,6 +6467,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SQL_OPT_CREATE_RAWEXPR_FAILED] = "ORA-00600: internal error code, arguments: -5120, fail to create raw expr"; ERROR_NAME[-OB_SQL_OPT_JOIN_ORDER_FAILED] = "OB_SQL_OPT_JOIN_ORDER_FAILED"; + ERROR_CAUSE[-OB_SQL_OPT_JOIN_ORDER_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_SQL_OPT_JOIN_ORDER_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SQL_OPT_JOIN_ORDER_FAILED] = -1; SQLSTATE[-OB_SQL_OPT_JOIN_ORDER_FAILED] = "HY000"; STR_ERROR[-OB_SQL_OPT_JOIN_ORDER_FAILED] = "fail to generate join order"; @@ -5326,6 +6479,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SQL_OPT_JOIN_ORDER_FAILED] = "ORA-00600: internal error code, arguments: -5121, fail to generate join order"; ERROR_NAME[-OB_SQL_OPT_ERROR] = "OB_SQL_OPT_ERROR"; + ERROR_CAUSE[-OB_SQL_OPT_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_SQL_OPT_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SQL_OPT_ERROR] = -1; SQLSTATE[-OB_SQL_OPT_ERROR] = "HY000"; STR_ERROR[-OB_SQL_OPT_ERROR] = "optimizer general error"; @@ -5335,6 +6490,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SQL_OPT_ERROR] = "ORA-00600: internal error code, arguments: -5122, optimizer general error"; ERROR_NAME[-OB_SQL_RESOLVER_NO_MEMORY] = "OB_SQL_RESOLVER_NO_MEMORY"; + ERROR_CAUSE[-OB_SQL_RESOLVER_NO_MEMORY] = "Internal Error"; + ERROR_SOLUTION[-OB_SQL_RESOLVER_NO_MEMORY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SQL_RESOLVER_NO_MEMORY] = -1; SQLSTATE[-OB_SQL_RESOLVER_NO_MEMORY] = "HY000"; STR_ERROR[-OB_SQL_RESOLVER_NO_MEMORY] = "sql resolver no memory"; @@ -5345,6 +6502,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SQL_RESOLVER_NO_MEMORY] = "ORA-00600: internal error code, arguments: -5130, sql resolver no memory"; ERROR_NAME[-OB_SQL_DML_ONLY] = "OB_SQL_DML_ONLY"; + ERROR_CAUSE[-OB_SQL_DML_ONLY] = "Internal Error"; + ERROR_SOLUTION[-OB_SQL_DML_ONLY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SQL_DML_ONLY] = -1; SQLSTATE[-OB_SQL_DML_ONLY] = "HY000"; STR_ERROR[-OB_SQL_DML_ONLY] = "plan cache support dml only"; @@ -5355,6 +6514,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SQL_DML_ONLY] = "ORA-00600: internal error code, arguments: -5131, plan cache support dml only"; ERROR_NAME[-OB_ERR_NO_GRANT] = "OB_ERR_NO_GRANT"; + ERROR_CAUSE[-OB_ERR_NO_GRANT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_GRANT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_GRANT] = -1; SQLSTATE[-OB_ERR_NO_GRANT] = "42000"; STR_ERROR[-OB_ERR_NO_GRANT] = "No such grant defined"; @@ -5363,6 +6524,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_NO_GRANT] = "ORA-00600: internal error code, arguments: -5133, No such grant defined"; ORACLE_STR_USER_ERROR[-OB_ERR_NO_GRANT] = "ORA-00600: internal error code, arguments: -5133, No such grant defined"; ERROR_NAME[-OB_ERR_NO_DB_SELECTED] = "OB_ERR_NO_DB_SELECTED"; + ERROR_CAUSE[-OB_ERR_NO_DB_SELECTED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_DB_SELECTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_DB_SELECTED] = ER_NO_DB_ERROR; SQLSTATE[-OB_ERR_NO_DB_SELECTED] = "3D000"; STR_ERROR[-OB_ERR_NO_DB_SELECTED] = "No database selected"; @@ -5372,6 +6535,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NO_DB_SELECTED] = "ORA-00600: internal error code, arguments: -5134, No database selected"; ERROR_NAME[-OB_SQL_PC_OVERFLOW] = "OB_SQL_PC_OVERFLOW"; + ERROR_CAUSE[-OB_SQL_PC_OVERFLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_SQL_PC_OVERFLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SQL_PC_OVERFLOW] = -1; SQLSTATE[-OB_SQL_PC_OVERFLOW] = "HY000"; STR_ERROR[-OB_SQL_PC_OVERFLOW] = "plan cache is overflow"; @@ -5381,6 +6546,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SQL_PC_OVERFLOW] = "ORA-00600: internal error code, arguments: -5135, plan cache is overflow"; ERROR_NAME[-OB_SQL_PC_PLAN_DUPLICATE] = "OB_SQL_PC_PLAN_DUPLICATE"; + ERROR_CAUSE[-OB_SQL_PC_PLAN_DUPLICATE] = "Internal Error"; + ERROR_SOLUTION[-OB_SQL_PC_PLAN_DUPLICATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SQL_PC_PLAN_DUPLICATE] = -1; SQLSTATE[-OB_SQL_PC_PLAN_DUPLICATE] = "HY000"; STR_ERROR[-OB_SQL_PC_PLAN_DUPLICATE] = "plan exists in plan cache already"; @@ -5391,6 +6558,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SQL_PC_PLAN_DUPLICATE] = "ORA-00600: internal error code, arguments: -5136, plan exists in plan cache already"; ERROR_NAME[-OB_SQL_PC_PLAN_EXPIRE] = "OB_SQL_PC_PLAN_EXPIRE"; + ERROR_CAUSE[-OB_SQL_PC_PLAN_EXPIRE] = "Internal Error"; + ERROR_SOLUTION[-OB_SQL_PC_PLAN_EXPIRE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SQL_PC_PLAN_EXPIRE] = -1; SQLSTATE[-OB_SQL_PC_PLAN_EXPIRE] = "HY000"; STR_ERROR[-OB_SQL_PC_PLAN_EXPIRE] = "plan is expired"; @@ -5399,6 +6568,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_SQL_PC_PLAN_EXPIRE] = "ORA-00600: internal error code, arguments: -5137, plan is expired"; ORACLE_STR_USER_ERROR[-OB_SQL_PC_PLAN_EXPIRE] = "ORA-00600: internal error code, arguments: -5137, plan is expired"; ERROR_NAME[-OB_SQL_PC_NOT_EXIST] = "OB_SQL_PC_NOT_EXIST"; + ERROR_CAUSE[-OB_SQL_PC_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_SQL_PC_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SQL_PC_NOT_EXIST] = -1; SQLSTATE[-OB_SQL_PC_NOT_EXIST] = "HY000"; STR_ERROR[-OB_SQL_PC_NOT_EXIST] = "no plan exist"; @@ -5407,6 +6578,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_SQL_PC_NOT_EXIST] = "ORA-00600: internal error code, arguments: -5138, no plan exist"; ORACLE_STR_USER_ERROR[-OB_SQL_PC_NOT_EXIST] = "ORA-00600: internal error code, arguments: -5138, no plan exist"; ERROR_NAME[-OB_SQL_PARAMS_LIMIT] = "OB_SQL_PARAMS_LIMIT"; + ERROR_CAUSE[-OB_SQL_PARAMS_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_SQL_PARAMS_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SQL_PARAMS_LIMIT] = -1; SQLSTATE[-OB_SQL_PARAMS_LIMIT] = "HY000"; STR_ERROR[-OB_SQL_PARAMS_LIMIT] = "too many params, plan cache not support"; @@ -5417,6 +6590,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SQL_PARAMS_LIMIT] = "ORA-00600: internal error code, arguments: -5139, too many params, plan cache not support"; ERROR_NAME[-OB_SQL_PC_PLAN_SIZE_LIMIT] = "OB_SQL_PC_PLAN_SIZE_LIMIT"; + ERROR_CAUSE[-OB_SQL_PC_PLAN_SIZE_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_SQL_PC_PLAN_SIZE_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SQL_PC_PLAN_SIZE_LIMIT] = -1; SQLSTATE[-OB_SQL_PC_PLAN_SIZE_LIMIT] = "HY000"; STR_ERROR[-OB_SQL_PC_PLAN_SIZE_LIMIT] = "plan is too big to add to plan cache"; @@ -5427,6 +6602,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SQL_PC_PLAN_SIZE_LIMIT] = "ORA-00600: internal error code, arguments: -5140, plan is too big to add to plan cache"; ERROR_NAME[-OB_ERR_UNKNOWN_CHARSET] = "OB_ERR_UNKNOWN_CHARSET"; + ERROR_CAUSE[-OB_ERR_UNKNOWN_CHARSET] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UNKNOWN_CHARSET] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UNKNOWN_CHARSET] = ER_UNKNOWN_CHARACTER_SET; SQLSTATE[-OB_ERR_UNKNOWN_CHARSET] = "42000"; STR_ERROR[-OB_ERR_UNKNOWN_CHARSET] = "Unknown character set"; @@ -5437,6 +6614,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UNKNOWN_CHARSET] = "ORA-00600: internal error code, arguments: -5142, Unknown character set: '%.*s'"; ERROR_NAME[-OB_ERR_UNKNOWN_COLLATION] = "OB_ERR_UNKNOWN_COLLATION"; + ERROR_CAUSE[-OB_ERR_UNKNOWN_COLLATION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UNKNOWN_COLLATION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UNKNOWN_COLLATION] = ER_UNKNOWN_COLLATION; SQLSTATE[-OB_ERR_UNKNOWN_COLLATION] = "HY000"; STR_ERROR[-OB_ERR_UNKNOWN_COLLATION] = "Unknown collation"; @@ -5446,6 +6625,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UNKNOWN_COLLATION] = "ORA-00600: internal error code, arguments: -5143, Unknown collation: '%.*s'"; ERROR_NAME[-OB_ERR_COLLATION_MISMATCH] = "OB_ERR_COLLATION_MISMATCH"; + ERROR_CAUSE[-OB_ERR_COLLATION_MISMATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_COLLATION_MISMATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_COLLATION_MISMATCH] = ER_COLLATION_CHARSET_MISMATCH; SQLSTATE[-OB_ERR_COLLATION_MISMATCH] = "42000"; STR_ERROR[-OB_ERR_COLLATION_MISMATCH] = "The collation is not valid for the character set"; @@ -5455,6 +6636,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_COLLATION_MISMATCH] = "ORA-12704: COLLATION '%.*s' is not valid for CHARACTER SET '%.*s'"; ERROR_NAME[-OB_ERR_WRONG_VALUE_FOR_VAR] = "OB_ERR_WRONG_VALUE_FOR_VAR"; + ERROR_CAUSE[-OB_ERR_WRONG_VALUE_FOR_VAR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_VALUE_FOR_VAR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_VALUE_FOR_VAR] = ER_WRONG_VALUE_FOR_VAR; SQLSTATE[-OB_ERR_WRONG_VALUE_FOR_VAR] = "42000"; STR_ERROR[-OB_ERR_WRONG_VALUE_FOR_VAR] = "Variable can't be set to the value"; @@ -5465,6 +6648,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WRONG_VALUE_FOR_VAR] = "ORA-00600: internal error code, arguments: -5145, Variable \'%.*s\' can't be set to the value of \'%.*s\'"; ERROR_NAME[-OB_UNKNOWN_PARTITION] = "OB_UNKNOWN_PARTITION"; + ERROR_CAUSE[-OB_UNKNOWN_PARTITION] = "Internal Error"; + ERROR_SOLUTION[-OB_UNKNOWN_PARTITION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_UNKNOWN_PARTITION] = ER_UNKNOWN_PARTITION; SQLSTATE[-OB_UNKNOWN_PARTITION] = "HY000"; STR_ERROR[-OB_UNKNOWN_PARTITION] = "Unknown partition"; @@ -5474,6 +6659,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_UNKNOWN_PARTITION] = "ORA-02149: Specified partition does not exist '%.*s' in table '%.*s'"; ERROR_NAME[-OB_PARTITION_NOT_MATCH] = "OB_PARTITION_NOT_MATCH"; + ERROR_CAUSE[-OB_PARTITION_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_PARTITION_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PARTITION_NOT_MATCH] = ER_ROW_DOES_NOT_MATCH_GIVEN_PARTITION_SET; SQLSTATE[-OB_PARTITION_NOT_MATCH] = "HY000"; STR_ERROR[-OB_PARTITION_NOT_MATCH] = "Found a row not matching the given partition set"; @@ -5484,6 +6671,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PARTITION_NOT_MATCH] = "ORA-00600: internal error code, arguments: -5147, Found a row not matching the given partition set"; ERROR_NAME[-OB_ER_PASSWD_LENGTH] = "OB_ER_PASSWD_LENGTH"; + ERROR_CAUSE[-OB_ER_PASSWD_LENGTH] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_PASSWD_LENGTH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_PASSWD_LENGTH] = -1; SQLSTATE[-OB_ER_PASSWD_LENGTH] = "HY000"; STR_ERROR[-OB_ER_PASSWD_LENGTH] = " Password hash should be a 40-digit hexadecimal number"; @@ -5494,6 +6683,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_PASSWD_LENGTH] = "ORA-00600: internal error code, arguments: -5148, Password hash should be a 40-digit hexadecimal number"; ERROR_NAME[-OB_ERR_INSERT_INNER_JOIN_COLUMN] = "OB_ERR_INSERT_INNER_JOIN_COLUMN"; + ERROR_CAUSE[-OB_ERR_INSERT_INNER_JOIN_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INSERT_INNER_JOIN_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INSERT_INNER_JOIN_COLUMN] = -1; SQLSTATE[-OB_ERR_INSERT_INNER_JOIN_COLUMN] = "07000"; STR_ERROR[-OB_ERR_INSERT_INNER_JOIN_COLUMN] = "Insert inner join column error"; @@ -5504,6 +6695,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INSERT_INNER_JOIN_COLUMN] = "ORA-00600: internal error code, arguments: -5149, Insert inner join column error"; ERROR_NAME[-OB_TENANT_NOT_IN_SERVER] = "OB_TENANT_NOT_IN_SERVER"; + ERROR_CAUSE[-OB_TENANT_NOT_IN_SERVER] = "Internal Error"; + ERROR_SOLUTION[-OB_TENANT_NOT_IN_SERVER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TENANT_NOT_IN_SERVER] = -1; SQLSTATE[-OB_TENANT_NOT_IN_SERVER] = "HY000"; STR_ERROR[-OB_TENANT_NOT_IN_SERVER] = "Tenant not in this server"; @@ -5514,6 +6707,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TENANT_NOT_IN_SERVER] = "ORA-00600: internal error code, arguments: -5150, Tenant not in this server"; ERROR_NAME[-OB_TABLEGROUP_NOT_EXIST] = "OB_TABLEGROUP_NOT_EXIST"; + ERROR_CAUSE[-OB_TABLEGROUP_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_TABLEGROUP_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TABLEGROUP_NOT_EXIST] = -1; SQLSTATE[-OB_TABLEGROUP_NOT_EXIST] = "42P01"; STR_ERROR[-OB_TABLEGROUP_NOT_EXIST] = "tablegroup not exist"; @@ -5524,6 +6719,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TABLEGROUP_NOT_EXIST] = "ORA-00600: internal error code, arguments: -5151, tablegroup not exist"; ERROR_NAME[-OB_SUBQUERY_TOO_MANY_ROW] = "OB_SUBQUERY_TOO_MANY_ROW"; + ERROR_CAUSE[-OB_SUBQUERY_TOO_MANY_ROW] = "Internal Error"; + ERROR_SOLUTION[-OB_SUBQUERY_TOO_MANY_ROW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SUBQUERY_TOO_MANY_ROW] = ER_SUBQUERY_NO_1_ROW; SQLSTATE[-OB_SUBQUERY_TOO_MANY_ROW] = "21000"; STR_ERROR[-OB_SUBQUERY_TOO_MANY_ROW] = "Subquery returns more than 1 row"; @@ -5532,6 +6729,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_SUBQUERY_TOO_MANY_ROW] = "ORA-01427: single-row subquery returns more than one row"; ORACLE_STR_USER_ERROR[-OB_SUBQUERY_TOO_MANY_ROW] = "ORA-01427: single-row subquery returns more than one row"; ERROR_NAME[-OB_ERR_BAD_DATABASE] = "OB_ERR_BAD_DATABASE"; + ERROR_CAUSE[-OB_ERR_BAD_DATABASE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_BAD_DATABASE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_BAD_DATABASE] = ER_BAD_DB_ERROR; SQLSTATE[-OB_ERR_BAD_DATABASE] = "42000"; STR_ERROR[-OB_ERR_BAD_DATABASE] = "Unknown database"; @@ -5541,6 +6740,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_BAD_DATABASE] = "ORA-00600: internal error code, arguments: -5154, Unknown database '%.*s'"; ERROR_NAME[-OB_CANNOT_USER] = "OB_CANNOT_USER"; + ERROR_CAUSE[-OB_CANNOT_USER] = "Internal Error"; + ERROR_SOLUTION[-OB_CANNOT_USER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANNOT_USER] = ER_CANNOT_USER; SQLSTATE[-OB_CANNOT_USER] = "HY000"; STR_ERROR[-OB_CANNOT_USER] = "User operation failed"; @@ -5550,6 +6751,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CANNOT_USER] = "ORA-00600: internal error code, arguments: -5155, Operation %.*s failed for %.*s"; ERROR_NAME[-OB_TENANT_EXIST] = "OB_TENANT_EXIST"; + ERROR_CAUSE[-OB_TENANT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_TENANT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TENANT_EXIST] = -1; SQLSTATE[-OB_TENANT_EXIST] = "HY000"; STR_ERROR[-OB_TENANT_EXIST] = "tenant already exist"; @@ -5559,6 +6762,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TENANT_EXIST] = "ORA-00600: internal error code, arguments: -5156, tenant \'%s\' already exist"; ERROR_NAME[-OB_TENANT_NOT_EXIST] = "OB_TENANT_NOT_EXIST"; + ERROR_CAUSE[-OB_TENANT_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_TENANT_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TENANT_NOT_EXIST] = -1; SQLSTATE[-OB_TENANT_NOT_EXIST] = "HY000"; STR_ERROR[-OB_TENANT_NOT_EXIST] = "Unknown tenant"; @@ -5568,6 +6773,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TENANT_NOT_EXIST] = "ORA-00600: internal error code, arguments: -5157, Unknown tenant '%.*s'"; ERROR_NAME[-OB_DATABASE_EXIST] = "OB_DATABASE_EXIST"; + ERROR_CAUSE[-OB_DATABASE_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_DATABASE_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DATABASE_EXIST] = ER_DB_CREATE_EXISTS; SQLSTATE[-OB_DATABASE_EXIST] = "HY000"; STR_ERROR[-OB_DATABASE_EXIST] = "Can't create database;database exists"; @@ -5578,6 +6785,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DATABASE_EXIST] = "ORA-00600: internal error code, arguments: -5158, Can't create database '%.*s'; database exists"; ERROR_NAME[-OB_TABLEGROUP_EXIST] = "OB_TABLEGROUP_EXIST"; + ERROR_CAUSE[-OB_TABLEGROUP_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_TABLEGROUP_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TABLEGROUP_EXIST] = -1; SQLSTATE[-OB_TABLEGROUP_EXIST] = "HY000"; STR_ERROR[-OB_TABLEGROUP_EXIST] = "tablegroup already exist"; @@ -5588,6 +6797,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TABLEGROUP_EXIST] = "ORA-00600: internal error code, arguments: -5159, tablegroup already exist"; ERROR_NAME[-OB_ERR_INVALID_TENANT_NAME] = "OB_ERR_INVALID_TENANT_NAME"; + ERROR_CAUSE[-OB_ERR_INVALID_TENANT_NAME] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_TENANT_NAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_TENANT_NAME] = -1; SQLSTATE[-OB_ERR_INVALID_TENANT_NAME] = "HY000"; STR_ERROR[-OB_ERR_INVALID_TENANT_NAME] = "invalid tenant name specified in connection string"; @@ -5598,6 +6809,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_TENANT_NAME] = "ORA-00600: internal error code, arguments: -5160, invalid tenant name specified in connection string"; ERROR_NAME[-OB_EMPTY_TENANT] = "OB_EMPTY_TENANT"; + ERROR_CAUSE[-OB_EMPTY_TENANT] = "Internal Error"; + ERROR_SOLUTION[-OB_EMPTY_TENANT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_EMPTY_TENANT] = -1; SQLSTATE[-OB_EMPTY_TENANT] = "HY000"; STR_ERROR[-OB_EMPTY_TENANT] = "tenant is empty"; @@ -5606,6 +6819,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_EMPTY_TENANT] = "ORA-00600: internal error code, arguments: -5161, tenant is empty"; ORACLE_STR_USER_ERROR[-OB_EMPTY_TENANT] = "ORA-00600: internal error code, arguments: -5161, tenant is empty"; ERROR_NAME[-OB_WRONG_DB_NAME] = "OB_WRONG_DB_NAME"; + ERROR_CAUSE[-OB_WRONG_DB_NAME] = "Internal Error"; + ERROR_SOLUTION[-OB_WRONG_DB_NAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WRONG_DB_NAME] = ER_WRONG_DB_NAME; SQLSTATE[-OB_WRONG_DB_NAME] = "42000"; STR_ERROR[-OB_WRONG_DB_NAME] = "Incorrect database name"; @@ -5615,6 +6830,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_WRONG_DB_NAME] = "ORA-00600: internal error code, arguments: -5162, Incorrect database name '%.*s'"; ERROR_NAME[-OB_WRONG_TABLE_NAME] = "OB_WRONG_TABLE_NAME"; + ERROR_CAUSE[-OB_WRONG_TABLE_NAME] = "Internal Error"; + ERROR_SOLUTION[-OB_WRONG_TABLE_NAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WRONG_TABLE_NAME] = ER_WRONG_TABLE_NAME; SQLSTATE[-OB_WRONG_TABLE_NAME] = "42000"; STR_ERROR[-OB_WRONG_TABLE_NAME] = "Incorrect table name"; @@ -5623,6 +6840,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_WRONG_TABLE_NAME] = "ORA-00903: invalid table name"; ORACLE_STR_USER_ERROR[-OB_WRONG_TABLE_NAME] = "ORA-00903: invalid table name '%.*s'"; ERROR_NAME[-OB_WRONG_COLUMN_NAME] = "OB_WRONG_COLUMN_NAME"; + ERROR_CAUSE[-OB_WRONG_COLUMN_NAME] = "Internal Error"; + ERROR_SOLUTION[-OB_WRONG_COLUMN_NAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WRONG_COLUMN_NAME] = ER_WRONG_COLUMN_NAME; SQLSTATE[-OB_WRONG_COLUMN_NAME] = "42000"; STR_ERROR[-OB_WRONG_COLUMN_NAME] = "Incorrect column name"; @@ -5631,6 +6850,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_WRONG_COLUMN_NAME] = "ORA-00904: invalid identifier"; ORACLE_STR_USER_ERROR[-OB_WRONG_COLUMN_NAME] = "ORA-00904: invalid identifier '%.*s'"; ERROR_NAME[-OB_ERR_COLUMN_SPEC] = "OB_ERR_COLUMN_SPEC"; + ERROR_CAUSE[-OB_ERR_COLUMN_SPEC] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_COLUMN_SPEC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_COLUMN_SPEC] = ER_WRONG_FIELD_SPEC; SQLSTATE[-OB_ERR_COLUMN_SPEC] = "42000"; STR_ERROR[-OB_ERR_COLUMN_SPEC] = "Incorrect column specifier"; @@ -5641,6 +6862,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_COLUMN_SPEC] = "ORA-00600: internal error code, arguments: -5165, Incorrect column specifier for column '%.*s'"; ERROR_NAME[-OB_ERR_DB_DROP_EXISTS] = "OB_ERR_DB_DROP_EXISTS"; + ERROR_CAUSE[-OB_ERR_DB_DROP_EXISTS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DB_DROP_EXISTS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DB_DROP_EXISTS] = ER_DB_DROP_EXISTS; SQLSTATE[-OB_ERR_DB_DROP_EXISTS] = "HY000"; STR_ERROR[-OB_ERR_DB_DROP_EXISTS] = "Can't drop database;database doesn't exist"; @@ -5651,6 +6874,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DB_DROP_EXISTS] = "ORA-00600: internal error code, arguments: -5166, Can't drop database '%.*s'; database doesn't exist"; ERROR_NAME[-OB_ERR_DATA_TOO_LONG] = "OB_ERR_DATA_TOO_LONG"; + ERROR_CAUSE[-OB_ERR_DATA_TOO_LONG] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DATA_TOO_LONG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DATA_TOO_LONG] = ER_DATA_TOO_LONG; SQLSTATE[-OB_ERR_DATA_TOO_LONG] = "22001"; STR_ERROR[-OB_ERR_DATA_TOO_LONG] = "Data too long for column"; @@ -5659,6 +6884,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DATA_TOO_LONG] = "ORA-12899: value too large for column"; ORACLE_STR_USER_ERROR[-OB_ERR_DATA_TOO_LONG] = "ORA-12899: value too large for column '%.*s' at row %ld"; ERROR_NAME[-OB_ERR_WRONG_VALUE_COUNT_ON_ROW] = "OB_ERR_WRONG_VALUE_COUNT_ON_ROW"; + ERROR_CAUSE[-OB_ERR_WRONG_VALUE_COUNT_ON_ROW] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_VALUE_COUNT_ON_ROW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_VALUE_COUNT_ON_ROW] = ER_WRONG_VALUE_COUNT_ON_ROW; SQLSTATE[-OB_ERR_WRONG_VALUE_COUNT_ON_ROW] = "21S01"; STR_ERROR[-OB_ERR_WRONG_VALUE_COUNT_ON_ROW] = "column count does not match value count"; @@ -5669,6 +6896,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WRONG_VALUE_COUNT_ON_ROW] = "ORA-00600: internal error code, arguments: -5168, column count does not match value count at row '%d'"; ERROR_NAME[-OB_ERR_CREATE_USER_WITH_GRANT] = "OB_ERR_CREATE_USER_WITH_GRANT"; + ERROR_CAUSE[-OB_ERR_CREATE_USER_WITH_GRANT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CREATE_USER_WITH_GRANT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CREATE_USER_WITH_GRANT] = ER_CANT_CREATE_USER_WITH_GRANT; SQLSTATE[-OB_ERR_CREATE_USER_WITH_GRANT] = "42000"; STR_ERROR[-OB_ERR_CREATE_USER_WITH_GRANT] = "You are not allowed to create a user with GRANT"; @@ -5679,6 +6908,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CREATE_USER_WITH_GRANT] = "ORA-00600: internal error code, arguments: -5169, You are not allowed to create a user with GRANT"; ERROR_NAME[-OB_ERR_NO_DB_PRIVILEGE] = "OB_ERR_NO_DB_PRIVILEGE"; + ERROR_CAUSE[-OB_ERR_NO_DB_PRIVILEGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_DB_PRIVILEGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_DB_PRIVILEGE] = ER_DBACCESS_DENIED_ERROR; SQLSTATE[-OB_ERR_NO_DB_PRIVILEGE] = "42000"; STR_ERROR[-OB_ERR_NO_DB_PRIVILEGE] = "Access denied for user to database"; @@ -5689,6 +6920,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NO_DB_PRIVILEGE] = "ORA-00600: internal error code, arguments: -5170, Access denied for user '%.*s'@'%.*s' to database '%.*s'"; ERROR_NAME[-OB_ERR_NO_TABLE_PRIVILEGE] = "OB_ERR_NO_TABLE_PRIVILEGE"; + ERROR_CAUSE[-OB_ERR_NO_TABLE_PRIVILEGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_TABLE_PRIVILEGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_TABLE_PRIVILEGE] = ER_TABLEACCESS_DENIED_ERROR; SQLSTATE[-OB_ERR_NO_TABLE_PRIVILEGE] = "42000"; STR_ERROR[-OB_ERR_NO_TABLE_PRIVILEGE] = "Command denied to user for table"; @@ -5699,6 +6932,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NO_TABLE_PRIVILEGE] = "ORA-00600: internal error code, arguments: -5171, %.*s command denied to user '%.*s'@'%.*s' for table '%.*s'"; ERROR_NAME[-OB_INVALID_ON_UPDATE] = "OB_INVALID_ON_UPDATE"; + ERROR_CAUSE[-OB_INVALID_ON_UPDATE] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_ON_UPDATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_ON_UPDATE] = ER_INVALID_ON_UPDATE; SQLSTATE[-OB_INVALID_ON_UPDATE] = "HY000"; STR_ERROR[-OB_INVALID_ON_UPDATE] = "Invalid ON UPDATE clause"; @@ -5709,6 +6944,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_ON_UPDATE] = "ORA-00600: internal error code, arguments: -5172, Invalid ON UPDATE clause for \'%s\' column"; ERROR_NAME[-OB_INVALID_DEFAULT] = "OB_INVALID_DEFAULT"; + ERROR_CAUSE[-OB_INVALID_DEFAULT] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_DEFAULT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_DEFAULT] = ER_INVALID_DEFAULT; SQLSTATE[-OB_INVALID_DEFAULT] = "42000"; STR_ERROR[-OB_INVALID_DEFAULT] = "Invalid default value"; @@ -5718,6 +6955,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_DEFAULT] = "ORA-00600: internal error code, arguments: -5173, Invalid default value for \'%.*s\'"; ERROR_NAME[-OB_ERR_UPDATE_TABLE_USED] = "OB_ERR_UPDATE_TABLE_USED"; + ERROR_CAUSE[-OB_ERR_UPDATE_TABLE_USED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UPDATE_TABLE_USED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UPDATE_TABLE_USED] = ER_UPDATE_TABLE_USED; SQLSTATE[-OB_ERR_UPDATE_TABLE_USED] = "HY000"; STR_ERROR[-OB_ERR_UPDATE_TABLE_USED] = "Update table used"; @@ -5727,6 +6966,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UPDATE_TABLE_USED] = "ORA-00600: internal error code, arguments: -5174, You can\'t " "specify target table \'%s\' for update in FROM clause"; ERROR_NAME[-OB_ERR_COULUMN_VALUE_NOT_MATCH] = "OB_ERR_COULUMN_VALUE_NOT_MATCH"; + ERROR_CAUSE[-OB_ERR_COULUMN_VALUE_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_COULUMN_VALUE_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_COULUMN_VALUE_NOT_MATCH] = ER_WRONG_VALUE_COUNT_ON_ROW; SQLSTATE[-OB_ERR_COULUMN_VALUE_NOT_MATCH] = "21S01"; STR_ERROR[-OB_ERR_COULUMN_VALUE_NOT_MATCH] = "Column count doesn\'t match value count"; @@ -5737,6 +6978,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_COULUMN_VALUE_NOT_MATCH] = "ORA-00600: internal error code, arguments: -5175, Column count doesn\'t match value count at row %ld"; ERROR_NAME[-OB_ERR_INVALID_GROUP_FUNC_USE] = "OB_ERR_INVALID_GROUP_FUNC_USE"; + ERROR_CAUSE[-OB_ERR_INVALID_GROUP_FUNC_USE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_GROUP_FUNC_USE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_GROUP_FUNC_USE] = ER_INVALID_GROUP_FUNC_USE; SQLSTATE[-OB_ERR_INVALID_GROUP_FUNC_USE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_GROUP_FUNC_USE] = "Invalid use of group function"; @@ -5747,6 +6990,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_GROUP_FUNC_USE] = "ORA-00600: internal error code, arguments: -5176, Invalid use of group function"; ERROR_NAME[-OB_CANT_AGGREGATE_2COLLATIONS] = "OB_CANT_AGGREGATE_2COLLATIONS"; + ERROR_CAUSE[-OB_CANT_AGGREGATE_2COLLATIONS] = "Internal Error"; + ERROR_SOLUTION[-OB_CANT_AGGREGATE_2COLLATIONS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANT_AGGREGATE_2COLLATIONS] = ER_CANT_AGGREGATE_2COLLATIONS; SQLSTATE[-OB_CANT_AGGREGATE_2COLLATIONS] = "HY000"; STR_ERROR[-OB_CANT_AGGREGATE_2COLLATIONS] = "Illegal mix of collations"; @@ -5757,6 +7002,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CANT_AGGREGATE_2COLLATIONS] = "ORA-00600: internal error code, arguments: -5177, Illegal mix of collations"; ERROR_NAME[-OB_ERR_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD] = "OB_ERR_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD"; + ERROR_CAUSE[-OB_ERR_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD] = ER_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD; SQLSTATE[-OB_ERR_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD] = "HY000"; STR_ERROR[-OB_ERR_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD] = @@ -5771,6 +7018,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5178, Field \'%.*s\' is of a not allowed type for this type of " "partitioning"; ERROR_NAME[-OB_ERR_TOO_LONG_IDENT] = "OB_ERR_TOO_LONG_IDENT"; + ERROR_CAUSE[-OB_ERR_TOO_LONG_IDENT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_LONG_IDENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_LONG_IDENT] = ER_TOO_LONG_IDENT; SQLSTATE[-OB_ERR_TOO_LONG_IDENT] = "42000"; STR_ERROR[-OB_ERR_TOO_LONG_IDENT] = "Identifier name is too long"; @@ -5779,6 +7028,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_TOO_LONG_IDENT] = "ORA-00972: identifier is too long"; ORACLE_STR_USER_ERROR[-OB_ERR_TOO_LONG_IDENT] = "ORA-00972: identifier \'%.*s\' is too long"; ERROR_NAME[-OB_ERR_WRONG_TYPE_FOR_VAR] = "OB_ERR_WRONG_TYPE_FOR_VAR"; + ERROR_CAUSE[-OB_ERR_WRONG_TYPE_FOR_VAR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_TYPE_FOR_VAR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_TYPE_FOR_VAR] = ER_WRONG_TYPE_FOR_VAR; SQLSTATE[-OB_ERR_WRONG_TYPE_FOR_VAR] = "42000"; STR_ERROR[-OB_ERR_WRONG_TYPE_FOR_VAR] = "Incorrect argument type to variable"; @@ -5789,6 +7040,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WRONG_TYPE_FOR_VAR] = "ORA-00600: internal error code, arguments: -5180, Incorrect argument type to variable '%.*s'"; ERROR_NAME[-OB_WRONG_USER_NAME_LENGTH] = "OB_WRONG_USER_NAME_LENGTH"; + ERROR_CAUSE[-OB_WRONG_USER_NAME_LENGTH] = "Internal Error"; + ERROR_SOLUTION[-OB_WRONG_USER_NAME_LENGTH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WRONG_USER_NAME_LENGTH] = ER_WRONG_STRING_LENGTH; SQLSTATE[-OB_WRONG_USER_NAME_LENGTH] = "HY000"; STR_ERROR[-OB_WRONG_USER_NAME_LENGTH] = "String is too long for user_name (should be no longer than 16)"; @@ -5801,6 +7054,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5181, String '%.*s' is too long for user name (should be no " "longer than 16)"; ERROR_NAME[-OB_ERR_PRIV_USAGE] = "OB_ERR_PRIV_USAGE"; + ERROR_CAUSE[-OB_ERR_PRIV_USAGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PRIV_USAGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PRIV_USAGE] = ER_WRONG_USAGE; SQLSTATE[-OB_ERR_PRIV_USAGE] = "HY000"; STR_ERROR[-OB_ERR_PRIV_USAGE] = "Incorrect usage of DB GRANT and GLOBAL PRIVILEGES"; @@ -5811,6 +7066,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PRIV_USAGE] = "ORA-00600: internal error code, arguments: -5182, Incorrect usage of DB GRANT and GLOBAL PRIVILEGES"; ERROR_NAME[-OB_ILLEGAL_GRANT_FOR_TABLE] = "OB_ILLEGAL_GRANT_FOR_TABLE"; + ERROR_CAUSE[-OB_ILLEGAL_GRANT_FOR_TABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ILLEGAL_GRANT_FOR_TABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ILLEGAL_GRANT_FOR_TABLE] = ER_ILLEGAL_GRANT_FOR_TABLE; SQLSTATE[-OB_ILLEGAL_GRANT_FOR_TABLE] = "42000"; STR_ERROR[-OB_ILLEGAL_GRANT_FOR_TABLE] = @@ -5825,6 +7082,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5183, Illegal GRANT/REVOKE command; please consult the manual to " "see which privileges can be used"; ERROR_NAME[-OB_ERR_REACH_AUTOINC_MAX] = "OB_ERR_REACH_AUTOINC_MAX"; + ERROR_CAUSE[-OB_ERR_REACH_AUTOINC_MAX] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REACH_AUTOINC_MAX] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REACH_AUTOINC_MAX] = ER_AUTOINC_READ_FAILED; SQLSTATE[-OB_ERR_REACH_AUTOINC_MAX] = "HY000"; STR_ERROR[-OB_ERR_REACH_AUTOINC_MAX] = "Failed to read auto-increment value from storage engine"; @@ -5835,6 +7094,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_REACH_AUTOINC_MAX] = "ORA-00600: internal error code, arguments: -5184, Failed to read auto-increment value from storage engine"; ERROR_NAME[-OB_ERR_NO_TABLES_USED] = "OB_ERR_NO_TABLES_USED"; + ERROR_CAUSE[-OB_ERR_NO_TABLES_USED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_TABLES_USED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_TABLES_USED] = ER_NO_TABLES_USED; SQLSTATE[-OB_ERR_NO_TABLES_USED] = "HY000"; STR_ERROR[-OB_ERR_NO_TABLES_USED] = "No tables used"; @@ -5843,6 +7104,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_NO_TABLES_USED] = "ORA-00600: internal error code, arguments: -5185, No tables used"; ORACLE_STR_USER_ERROR[-OB_ERR_NO_TABLES_USED] = "ORA-00600: internal error code, arguments: -5185, No tables used"; ERROR_NAME[-OB_CANT_REMOVE_ALL_FIELDS] = "OB_CANT_REMOVE_ALL_FIELDS"; + ERROR_CAUSE[-OB_CANT_REMOVE_ALL_FIELDS] = "Internal Error"; + ERROR_SOLUTION[-OB_CANT_REMOVE_ALL_FIELDS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANT_REMOVE_ALL_FIELDS] = ER_CANT_REMOVE_ALL_FIELDS; SQLSTATE[-OB_CANT_REMOVE_ALL_FIELDS] = "42000"; STR_ERROR[-OB_CANT_REMOVE_ALL_FIELDS] = "You can't delete all columns with ALTER TABLE; use DROP TABLE instead"; @@ -5854,6 +7117,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CANT_REMOVE_ALL_FIELDS] = "ORA-00600: internal error code, arguments: -5187, You can't " "delete all columns with ALTER TABLE; use DROP TABLE instead"; ERROR_NAME[-OB_TOO_MANY_PARTITIONS_ERROR] = "OB_TOO_MANY_PARTITIONS_ERROR"; + ERROR_CAUSE[-OB_TOO_MANY_PARTITIONS_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_TOO_MANY_PARTITIONS_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TOO_MANY_PARTITIONS_ERROR] = ER_TOO_MANY_PARTITIONS_ERROR; SQLSTATE[-OB_TOO_MANY_PARTITIONS_ERROR] = "HY000"; STR_ERROR[-OB_TOO_MANY_PARTITIONS_ERROR] = "Too many partitions (including subpartitions) were defined"; @@ -5864,6 +7129,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TOO_MANY_PARTITIONS_ERROR] = "ORA-00600: internal error code, arguments: -5188, Too many partitions (including subpartitions) were defined"; ERROR_NAME[-OB_NO_PARTS_ERROR] = "OB_NO_PARTS_ERROR"; + ERROR_CAUSE[-OB_NO_PARTS_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_PARTS_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_PARTS_ERROR] = ER_NO_PARTS_ERROR; SQLSTATE[-OB_NO_PARTS_ERROR] = "HY000"; STR_ERROR[-OB_NO_PARTS_ERROR] = "Number of partitions = 0 is not an allowed value"; @@ -5874,6 +7141,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NO_PARTS_ERROR] = "ORA-00600: internal error code, arguments: -5189, Number of partitions = 0 is not an allowed value"; ERROR_NAME[-OB_WRONG_SUB_KEY] = "OB_WRONG_SUB_KEY"; + ERROR_CAUSE[-OB_WRONG_SUB_KEY] = "Internal Error"; + ERROR_SOLUTION[-OB_WRONG_SUB_KEY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WRONG_SUB_KEY] = ER_WRONG_SUB_KEY; SQLSTATE[-OB_WRONG_SUB_KEY] = "HY000"; STR_ERROR[-OB_WRONG_SUB_KEY] = "Incorrect prefix key; the used key part isn't a string, the used length is longer " @@ -5889,6 +7158,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5190, Incorrect prefix key; the used key part isn't a string, the " "used length is longer than the key part, or the storage engine doesn't support unique prefix keys"; ERROR_NAME[-OB_KEY_PART_0] = "OB_KEY_PART_0"; + ERROR_CAUSE[-OB_KEY_PART_0] = "Internal Error"; + ERROR_SOLUTION[-OB_KEY_PART_0] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_KEY_PART_0] = ER_KEY_PART_0; SQLSTATE[-OB_KEY_PART_0] = "HY000"; STR_ERROR[-OB_KEY_PART_0] = "Key part length cannot be 0"; @@ -5898,6 +7169,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_KEY_PART_0] = "ORA-00600: internal error code, arguments: -5191, Key part \'%.*s\' length cannot be 0"; ERROR_NAME[-OB_ERR_UNKNOWN_TIME_ZONE] = "OB_ERR_UNKNOWN_TIME_ZONE"; + ERROR_CAUSE[-OB_ERR_UNKNOWN_TIME_ZONE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UNKNOWN_TIME_ZONE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UNKNOWN_TIME_ZONE] = ER_UNKNOWN_TIME_ZONE; SQLSTATE[-OB_ERR_UNKNOWN_TIME_ZONE] = "HY000"; STR_ERROR[-OB_ERR_UNKNOWN_TIME_ZONE] = "Unknown or incorrect time zone"; @@ -5906,6 +7179,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_UNKNOWN_TIME_ZONE] = "ORA-01882: timezone region string not found"; ORACLE_STR_USER_ERROR[-OB_ERR_UNKNOWN_TIME_ZONE] = "ORA-01882: timezone region \'%.*s\' not found"; ERROR_NAME[-OB_ERR_WRONG_AUTO_KEY] = "OB_ERR_WRONG_AUTO_KEY"; + ERROR_CAUSE[-OB_ERR_WRONG_AUTO_KEY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_AUTO_KEY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_AUTO_KEY] = ER_WRONG_AUTO_KEY; SQLSTATE[-OB_ERR_WRONG_AUTO_KEY] = "42000"; STR_ERROR[-OB_ERR_WRONG_AUTO_KEY] = "Incorrect table definition; there can be only one auto column"; @@ -5916,6 +7191,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WRONG_AUTO_KEY] = "ORA-00600: internal error code, arguments: -5193, Incorrect table " "definition; there can be only one auto column"; ERROR_NAME[-OB_ERR_TOO_MANY_KEYS] = "OB_ERR_TOO_MANY_KEYS"; + ERROR_CAUSE[-OB_ERR_TOO_MANY_KEYS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_MANY_KEYS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_MANY_KEYS] = ER_TOO_MANY_KEYS; SQLSTATE[-OB_ERR_TOO_MANY_KEYS] = "42000"; STR_ERROR[-OB_ERR_TOO_MANY_KEYS] = "Too many keys specified"; @@ -5926,6 +7203,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TOO_MANY_KEYS] = "ORA-00600: internal error code, arguments: -5194, Too many keys specified; max %ld keys allowed"; ERROR_NAME[-OB_ERR_TOO_MANY_ROWKEY_COLUMNS] = "OB_ERR_TOO_MANY_ROWKEY_COLUMNS"; + ERROR_CAUSE[-OB_ERR_TOO_MANY_ROWKEY_COLUMNS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_MANY_ROWKEY_COLUMNS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_MANY_ROWKEY_COLUMNS] = ER_TOO_MANY_KEY_PARTS; SQLSTATE[-OB_ERR_TOO_MANY_ROWKEY_COLUMNS] = "42000"; STR_ERROR[-OB_ERR_TOO_MANY_ROWKEY_COLUMNS] = "Too many key parts specified"; @@ -5936,6 +7215,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TOO_MANY_ROWKEY_COLUMNS] = "ORA-00600: internal error code, arguments: -5195, Too many key parts specified; max %ld parts allowed"; ERROR_NAME[-OB_ERR_TOO_LONG_KEY_LENGTH] = "OB_ERR_TOO_LONG_KEY_LENGTH"; + ERROR_CAUSE[-OB_ERR_TOO_LONG_KEY_LENGTH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_LONG_KEY_LENGTH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_LONG_KEY_LENGTH] = ER_TOO_LONG_KEY; SQLSTATE[-OB_ERR_TOO_LONG_KEY_LENGTH] = "42000"; STR_ERROR[-OB_ERR_TOO_LONG_KEY_LENGTH] = "Specified key was too long"; @@ -5944,6 +7225,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_TOO_LONG_KEY_LENGTH] = "ORA-01450: maximum key length exceeded"; ORACLE_STR_USER_ERROR[-OB_ERR_TOO_LONG_KEY_LENGTH] = "ORA-01450: maximum key length (%ld) exceeded"; ERROR_NAME[-OB_ERR_TOO_MANY_COLUMNS] = "OB_ERR_TOO_MANY_COLUMNS"; + ERROR_CAUSE[-OB_ERR_TOO_MANY_COLUMNS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_MANY_COLUMNS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_MANY_COLUMNS] = ER_TOO_MANY_FIELDS; SQLSTATE[-OB_ERR_TOO_MANY_COLUMNS] = "42000"; STR_ERROR[-OB_ERR_TOO_MANY_COLUMNS] = "Too many columns"; @@ -5953,6 +7236,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TOO_MANY_COLUMNS] = "ORA-00600: internal error code, arguments: -5197, Too many columns"; ERROR_NAME[-OB_ERR_TOO_LONG_COLUMN_LENGTH] = "OB_ERR_TOO_LONG_COLUMN_LENGTH"; + ERROR_CAUSE[-OB_ERR_TOO_LONG_COLUMN_LENGTH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_LONG_COLUMN_LENGTH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_LONG_COLUMN_LENGTH] = ER_TOO_BIG_FIELDLENGTH; SQLSTATE[-OB_ERR_TOO_LONG_COLUMN_LENGTH] = "42000"; STR_ERROR[-OB_ERR_TOO_LONG_COLUMN_LENGTH] = "Column length too big"; @@ -5962,6 +7247,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TOO_LONG_COLUMN_LENGTH] = "ORA-00910: specified length too long for column '%s' (max = %d byte)"; ERROR_NAME[-OB_ERR_TOO_BIG_ROWSIZE] = "OB_ERR_TOO_BIG_ROWSIZE"; + ERROR_CAUSE[-OB_ERR_TOO_BIG_ROWSIZE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_BIG_ROWSIZE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_BIG_ROWSIZE] = ER_TOO_BIG_ROWSIZE; SQLSTATE[-OB_ERR_TOO_BIG_ROWSIZE] = "42000"; STR_ERROR[-OB_ERR_TOO_BIG_ROWSIZE] = "Row size too large"; @@ -5971,6 +7258,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TOO_BIG_ROWSIZE] = "ORA-00600: internal error code, arguments: -5199, Row size too large"; ERROR_NAME[-OB_ERR_UNKNOWN_TABLE] = "OB_ERR_UNKNOWN_TABLE"; + ERROR_CAUSE[-OB_ERR_UNKNOWN_TABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UNKNOWN_TABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UNKNOWN_TABLE] = ER_UNKNOWN_TABLE; SQLSTATE[-OB_ERR_UNKNOWN_TABLE] = "42S02"; STR_ERROR[-OB_ERR_UNKNOWN_TABLE] = "Unknown table"; @@ -5980,6 +7269,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UNKNOWN_TABLE] = "ORA-00600: internal error code, arguments: -5200, Unknown table '%.*s' in %.*s"; ERROR_NAME[-OB_ERR_BAD_TABLE] = "OB_ERR_BAD_TABLE"; + ERROR_CAUSE[-OB_ERR_BAD_TABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_BAD_TABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_BAD_TABLE] = ER_BAD_TABLE_ERROR; SQLSTATE[-OB_ERR_BAD_TABLE] = "42S02"; STR_ERROR[-OB_ERR_BAD_TABLE] = "Unknown table"; @@ -5988,6 +7279,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_BAD_TABLE] = "ORA-00942: table or view does not exist"; ORACLE_STR_USER_ERROR[-OB_ERR_BAD_TABLE] = "ORA-00942: table or view '%.*s' does not exist"; ERROR_NAME[-OB_ERR_TOO_BIG_SCALE] = "OB_ERR_TOO_BIG_SCALE"; + ERROR_CAUSE[-OB_ERR_TOO_BIG_SCALE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_BIG_SCALE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_BIG_SCALE] = ER_TOO_BIG_SCALE; SQLSTATE[-OB_ERR_TOO_BIG_SCALE] = "42000"; STR_ERROR[-OB_ERR_TOO_BIG_SCALE] = "Too big scale specified for column"; @@ -5998,6 +7291,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TOO_BIG_SCALE] = "ORA-00600: internal error code, arguments: -5202, Too big scale %d specified for column '%s'. Maximum is %ld."; ERROR_NAME[-OB_ERR_TOO_BIG_PRECISION] = "OB_ERR_TOO_BIG_PRECISION"; + ERROR_CAUSE[-OB_ERR_TOO_BIG_PRECISION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_BIG_PRECISION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_BIG_PRECISION] = ER_TOO_BIG_PRECISION; SQLSTATE[-OB_ERR_TOO_BIG_PRECISION] = "42000"; STR_ERROR[-OB_ERR_TOO_BIG_PRECISION] = "Too big precision specified for column"; @@ -6008,6 +7303,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TOO_BIG_PRECISION] = "ORA-00600: internal error code, arguments: -5203, Too big " "precision %d specified for column '%s'. Maximum is %ld."; ERROR_NAME[-OB_ERR_M_BIGGER_THAN_D] = "OB_ERR_M_BIGGER_THAN_D"; + ERROR_CAUSE[-OB_ERR_M_BIGGER_THAN_D] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_M_BIGGER_THAN_D] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_M_BIGGER_THAN_D] = ER_M_BIGGER_THAN_D; SQLSTATE[-OB_ERR_M_BIGGER_THAN_D] = "42000"; STR_ERROR[-OB_ERR_M_BIGGER_THAN_D] = "precision must be >= scale"; @@ -6020,6 +7317,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5204, For float(M,D), double(M,D) or decimal(M,D), M must be >= D " "(column '%s')."; ERROR_NAME[-OB_ERR_TOO_BIG_DISPLAYWIDTH] = "OB_ERR_TOO_BIG_DISPLAYWIDTH"; + ERROR_CAUSE[-OB_ERR_TOO_BIG_DISPLAYWIDTH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_BIG_DISPLAYWIDTH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_BIG_DISPLAYWIDTH] = ER_TOO_BIG_DISPLAYWIDTH; SQLSTATE[-OB_ERR_TOO_BIG_DISPLAYWIDTH] = "42000"; STR_ERROR[-OB_ERR_TOO_BIG_DISPLAYWIDTH] = "Display width out of range for column"; @@ -6030,6 +7329,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TOO_BIG_DISPLAYWIDTH] = "ORA-00600: internal error code, arguments: -5205, Display width out of range for column '%s' (max = %ld)"; ERROR_NAME[-OB_WRONG_GROUP_FIELD] = "OB_WRONG_GROUP_FIELD"; + ERROR_CAUSE[-OB_WRONG_GROUP_FIELD] = "Internal Error"; + ERROR_SOLUTION[-OB_WRONG_GROUP_FIELD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WRONG_GROUP_FIELD] = ER_WRONG_GROUP_FIELD; SQLSTATE[-OB_WRONG_GROUP_FIELD] = "42000"; STR_ERROR[-OB_WRONG_GROUP_FIELD] = "Can't group on column"; @@ -6039,6 +7340,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_WRONG_GROUP_FIELD] = "ORA-00600: internal error code, arguments: -5206, Can't group on '%.*s'"; ERROR_NAME[-OB_NON_UNIQ_ERROR] = "OB_NON_UNIQ_ERROR"; + ERROR_CAUSE[-OB_NON_UNIQ_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_NON_UNIQ_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NON_UNIQ_ERROR] = ER_NON_UNIQ_ERROR; SQLSTATE[-OB_NON_UNIQ_ERROR] = "23000"; STR_ERROR[-OB_NON_UNIQ_ERROR] = "Column is ambiguous"; @@ -6047,6 +7350,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NON_UNIQ_ERROR] = "ORA-00918: Column is ambiguous"; ORACLE_STR_USER_ERROR[-OB_NON_UNIQ_ERROR] = "ORA-00918: column '%.*s' in %.*s ambiguously defined"; ERROR_NAME[-OB_ERR_NONUNIQ_TABLE] = "OB_ERR_NONUNIQ_TABLE"; + ERROR_CAUSE[-OB_ERR_NONUNIQ_TABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NONUNIQ_TABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NONUNIQ_TABLE] = ER_NONUNIQ_TABLE; SQLSTATE[-OB_ERR_NONUNIQ_TABLE] = "42000"; STR_ERROR[-OB_ERR_NONUNIQ_TABLE] = "Not unique table/alias"; @@ -6057,6 +7362,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NONUNIQ_TABLE] = "ORA-00600: internal error code, arguments: -5208, Not unique table/alias: \'%.*s\'"; ERROR_NAME[-OB_ERR_CANT_DROP_FIELD_OR_KEY] = "OB_ERR_CANT_DROP_FIELD_OR_KEY"; + ERROR_CAUSE[-OB_ERR_CANT_DROP_FIELD_OR_KEY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CANT_DROP_FIELD_OR_KEY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CANT_DROP_FIELD_OR_KEY] = ER_CANT_DROP_FIELD_OR_KEY; SQLSTATE[-OB_ERR_CANT_DROP_FIELD_OR_KEY] = "42000"; STR_ERROR[-OB_ERR_CANT_DROP_FIELD_OR_KEY] = "Can't DROP Column; check that column/key exists"; @@ -6065,6 +7372,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CANT_DROP_FIELD_OR_KEY] = "ORA-01418: specified index does not exist"; ORACLE_STR_USER_ERROR[-OB_ERR_CANT_DROP_FIELD_OR_KEY] = "ORA-01418: specified index '%.*s' does not exist"; ERROR_NAME[-OB_ERR_MULTIPLE_PRI_KEY] = "OB_ERR_MULTIPLE_PRI_KEY"; + ERROR_CAUSE[-OB_ERR_MULTIPLE_PRI_KEY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MULTIPLE_PRI_KEY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MULTIPLE_PRI_KEY] = ER_MULTIPLE_PRI_KEY; SQLSTATE[-OB_ERR_MULTIPLE_PRI_KEY] = "42000"; STR_ERROR[-OB_ERR_MULTIPLE_PRI_KEY] = "Multiple primary key defined"; @@ -6075,6 +7384,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MULTIPLE_PRI_KEY] = "ORA-00600: internal error code, arguments: -5210, Multiple primary key defined"; ERROR_NAME[-OB_ERR_KEY_COLUMN_DOES_NOT_EXITS] = "OB_ERR_KEY_COLUMN_DOES_NOT_EXITS"; + ERROR_CAUSE[-OB_ERR_KEY_COLUMN_DOES_NOT_EXITS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_KEY_COLUMN_DOES_NOT_EXITS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_KEY_COLUMN_DOES_NOT_EXITS] = ER_KEY_COLUMN_DOES_NOT_EXITS; SQLSTATE[-OB_ERR_KEY_COLUMN_DOES_NOT_EXITS] = "42000"; STR_ERROR[-OB_ERR_KEY_COLUMN_DOES_NOT_EXITS] = "Key column doesn't exist in table"; @@ -6085,6 +7396,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_KEY_COLUMN_DOES_NOT_EXITS] = "ORA-00600: internal error code, arguments: -5211, Key column '%.*s' doesn't exist in table"; ERROR_NAME[-OB_ERR_AUTO_PARTITION_KEY] = "OB_ERR_AUTO_PARTITION_KEY"; + ERROR_CAUSE[-OB_ERR_AUTO_PARTITION_KEY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_AUTO_PARTITION_KEY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_AUTO_PARTITION_KEY] = -1; SQLSTATE[-OB_ERR_AUTO_PARTITION_KEY] = "42000"; STR_ERROR[-OB_ERR_AUTO_PARTITION_KEY] = "auto-increment column should not be part of partition key"; @@ -6096,6 +7409,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5212, auto-increment column '%.*s' should not be part of " "partition key"; ERROR_NAME[-OB_ERR_CANT_USE_OPTION_HERE] = "OB_ERR_CANT_USE_OPTION_HERE"; + ERROR_CAUSE[-OB_ERR_CANT_USE_OPTION_HERE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CANT_USE_OPTION_HERE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CANT_USE_OPTION_HERE] = ER_CANT_USE_OPTION_HERE; SQLSTATE[-OB_ERR_CANT_USE_OPTION_HERE] = "42000"; STR_ERROR[-OB_ERR_CANT_USE_OPTION_HERE] = "Incorrect usage/placement"; @@ -6106,6 +7421,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CANT_USE_OPTION_HERE] = "ORA-00600: internal error code, arguments: -5213, Incorrect usage/placement of '%s'"; ERROR_NAME[-OB_ERR_WRONG_OBJECT] = "OB_ERR_WRONG_OBJECT"; + ERROR_CAUSE[-OB_ERR_WRONG_OBJECT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_OBJECT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_OBJECT] = ER_WRONG_OBJECT; SQLSTATE[-OB_ERR_WRONG_OBJECT] = "HY000"; STR_ERROR[-OB_ERR_WRONG_OBJECT] = "Wrong object"; @@ -6115,6 +7432,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WRONG_OBJECT] = "ORA-00600: internal error code, arguments: -5214, \'%s.%s\' is not %s"; ERROR_NAME[-OB_ERR_ON_RENAME] = "OB_ERR_ON_RENAME"; + ERROR_CAUSE[-OB_ERR_ON_RENAME] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ON_RENAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ON_RENAME] = ER_ERROR_ON_RENAME; SQLSTATE[-OB_ERR_ON_RENAME] = "HY000"; STR_ERROR[-OB_ERR_ON_RENAME] = "Error on rename table"; @@ -6124,6 +7443,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ON_RENAME] = "ORA-00600: internal error code, arguments: -5215, Error on rename of \'%s.%s\' to \'%s.%s\'"; ERROR_NAME[-OB_ERR_WRONG_KEY_COLUMN] = "OB_ERR_WRONG_KEY_COLUMN"; + ERROR_CAUSE[-OB_ERR_WRONG_KEY_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_KEY_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_KEY_COLUMN] = ER_WRONG_KEY_COLUMN; SQLSTATE[-OB_ERR_WRONG_KEY_COLUMN] = "42000"; STR_ERROR[-OB_ERR_WRONG_KEY_COLUMN] = "The used storage engine can't index column"; @@ -6134,6 +7455,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WRONG_KEY_COLUMN] = "ORA-02329: column '%.*s' of datatype string cannot be unique or a primary key"; ERROR_NAME[-OB_ERR_BAD_FIELD_ERROR] = "OB_ERR_BAD_FIELD_ERROR"; + ERROR_CAUSE[-OB_ERR_BAD_FIELD_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_BAD_FIELD_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_BAD_FIELD_ERROR] = ER_BAD_FIELD_ERROR; SQLSTATE[-OB_ERR_BAD_FIELD_ERROR] = "42S22"; STR_ERROR[-OB_ERR_BAD_FIELD_ERROR] = "Unknown column"; @@ -6142,6 +7465,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_BAD_FIELD_ERROR] = "ORA-00904: invalid identifier"; ORACLE_STR_USER_ERROR[-OB_ERR_BAD_FIELD_ERROR] = "ORA-00904: invalid identifier '%.*s' in '%.*s'"; ERROR_NAME[-OB_ERR_WRONG_FIELD_WITH_GROUP] = "OB_ERR_WRONG_FIELD_WITH_GROUP"; + ERROR_CAUSE[-OB_ERR_WRONG_FIELD_WITH_GROUP] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_FIELD_WITH_GROUP] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_FIELD_WITH_GROUP] = ER_WRONG_FIELD_WITH_GROUP; SQLSTATE[-OB_ERR_WRONG_FIELD_WITH_GROUP] = "42000"; STR_ERROR[-OB_ERR_WRONG_FIELD_WITH_GROUP] = "column is not in GROUP BY"; @@ -6150,6 +7475,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_WRONG_FIELD_WITH_GROUP] = "ORA-00979: not a GROUP BY expression"; ORACLE_STR_USER_ERROR[-OB_ERR_WRONG_FIELD_WITH_GROUP] = "ORA-00979: \'%.*s\' not a GROUP BY expression"; ERROR_NAME[-OB_ERR_CANT_CHANGE_TX_CHARACTERISTICS] = "OB_ERR_CANT_CHANGE_TX_CHARACTERISTICS"; + ERROR_CAUSE[-OB_ERR_CANT_CHANGE_TX_CHARACTERISTICS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CANT_CHANGE_TX_CHARACTERISTICS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CANT_CHANGE_TX_CHARACTERISTICS] = ER_CANT_CHANGE_TX_CHARACTERISTICS; SQLSTATE[-OB_ERR_CANT_CHANGE_TX_CHARACTERISTICS] = "25001"; STR_ERROR[-OB_ERR_CANT_CHANGE_TX_CHARACTERISTICS] = @@ -6162,6 +7489,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CANT_CHANGE_TX_CHARACTERISTICS] = "ORA-01453: SET TRANSACTION must be first statement of transaction"; ERROR_NAME[-OB_ERR_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION] = "OB_ERR_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION"; + ERROR_CAUSE[-OB_ERR_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION] = ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION; SQLSTATE[-OB_ERR_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION] = "25006"; STR_ERROR[-OB_ERR_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION] = "Cannot execute statement in a READ ONLY transaction."; @@ -6173,6 +7502,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION] = "ORA-00600: internal error code, arguments: -5220, Cannot execute statement in a READ ONLY transaction."; ERROR_NAME[-OB_ERR_MIX_OF_GROUP_FUNC_AND_FIELDS] = "OB_ERR_MIX_OF_GROUP_FUNC_AND_FIELDS"; + ERROR_CAUSE[-OB_ERR_MIX_OF_GROUP_FUNC_AND_FIELDS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MIX_OF_GROUP_FUNC_AND_FIELDS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MIX_OF_GROUP_FUNC_AND_FIELDS] = ER_MIX_OF_GROUP_FUNC_AND_FIELDS; SQLSTATE[-OB_ERR_MIX_OF_GROUP_FUNC_AND_FIELDS] = "42000"; STR_ERROR[-OB_ERR_MIX_OF_GROUP_FUNC_AND_FIELDS] = "Mixing of GROUP columns (MIN(),MAX(),COUNT(),...) with no GROUP " @@ -6187,6 +7518,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5221, Mixing of GROUP columns (MIN(),MAX(),COUNT(),...) with no " "GROUP columns is illegal if there is no GROUP BY clause"; ERROR_NAME[-OB_ERR_TRUNCATED_WRONG_VALUE] = "OB_ERR_TRUNCATED_WRONG_VALUE"; + ERROR_CAUSE[-OB_ERR_TRUNCATED_WRONG_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TRUNCATED_WRONG_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TRUNCATED_WRONG_VALUE] = ER_TRUNCATED_WRONG_VALUE; SQLSTATE[-OB_ERR_TRUNCATED_WRONG_VALUE] = "22007"; STR_ERROR[-OB_ERR_TRUNCATED_WRONG_VALUE] = "Incorrect value"; @@ -6197,6 +7530,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TRUNCATED_WRONG_VALUE] = "ORA-00600: internal error code, arguments: -5222, Truncated incorrect %.*s value: '%.*s'"; ERROR_NAME[-OB_ERR_WRONG_IDENT_NAME] = "OB_ERR_WRONG_IDENT_NAME"; + ERROR_CAUSE[-OB_ERR_WRONG_IDENT_NAME] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_IDENT_NAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_IDENT_NAME] = -1; SQLSTATE[-OB_ERR_WRONG_IDENT_NAME] = "42000"; STR_ERROR[-OB_ERR_WRONG_IDENT_NAME] = "wrong ident name"; @@ -6206,6 +7541,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WRONG_IDENT_NAME] = "ORA-00600: internal error code, arguments: -5223, wrong ident name"; ERROR_NAME[-OB_WRONG_NAME_FOR_INDEX] = "OB_WRONG_NAME_FOR_INDEX"; + ERROR_CAUSE[-OB_WRONG_NAME_FOR_INDEX] = "Internal Error"; + ERROR_SOLUTION[-OB_WRONG_NAME_FOR_INDEX] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WRONG_NAME_FOR_INDEX] = ER_WRONG_NAME_FOR_INDEX; SQLSTATE[-OB_WRONG_NAME_FOR_INDEX] = "42000"; STR_ERROR[-OB_WRONG_NAME_FOR_INDEX] = "Incorrect index name"; @@ -6216,6 +7553,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_WRONG_NAME_FOR_INDEX] = "ORA-00600: internal error code, arguments: -5224, Incorrect index name '%.*s'"; ERROR_NAME[-OB_ILLEGAL_REFERENCE] = "OB_ILLEGAL_REFERENCE"; + ERROR_CAUSE[-OB_ILLEGAL_REFERENCE] = "Internal Error"; + ERROR_SOLUTION[-OB_ILLEGAL_REFERENCE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ILLEGAL_REFERENCE] = ER_ILLEGAL_REFERENCE; SQLSTATE[-OB_ILLEGAL_REFERENCE] = "42S22"; STR_ERROR[-OB_ILLEGAL_REFERENCE] = "Reference not supported (reference to group function)"; @@ -6226,6 +7565,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ILLEGAL_REFERENCE] = "ORA-00600: internal error code, arguments: -5225, Reference '%.*s' " "not supported (reference to group function)"; ERROR_NAME[-OB_REACH_MEMORY_LIMIT] = "OB_REACH_MEMORY_LIMIT"; + ERROR_CAUSE[-OB_REACH_MEMORY_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_REACH_MEMORY_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_REACH_MEMORY_LIMIT] = -1; SQLSTATE[-OB_REACH_MEMORY_LIMIT] = "42000"; STR_ERROR[-OB_REACH_MEMORY_LIMIT] = "plan cache memory used reach the high water mark."; @@ -6236,6 +7577,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_REACH_MEMORY_LIMIT] = "ORA-00600: internal error code, arguments: -5226, plan cache memory used reach the high water mark."; ERROR_NAME[-OB_ERR_PASSWORD_FORMAT] = "OB_ERR_PASSWORD_FORMAT"; + ERROR_CAUSE[-OB_ERR_PASSWORD_FORMAT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PASSWORD_FORMAT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PASSWORD_FORMAT] = ER_PASSWORD_FORMAT; SQLSTATE[-OB_ERR_PASSWORD_FORMAT] = "42000"; STR_ERROR[-OB_ERR_PASSWORD_FORMAT] = "The password hash doesn't have the expected format. Check if the correct " @@ -6250,6 +7593,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5227, The password hash doesn't have the expected format. Check " "if the correct password algorithm is being used with the PASSWORD() function."; ERROR_NAME[-OB_ERR_NON_UPDATABLE_TABLE] = "OB_ERR_NON_UPDATABLE_TABLE"; + ERROR_CAUSE[-OB_ERR_NON_UPDATABLE_TABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NON_UPDATABLE_TABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NON_UPDATABLE_TABLE] = ER_NON_UPDATABLE_TABLE; SQLSTATE[-OB_ERR_NON_UPDATABLE_TABLE] = "HY000"; STR_ERROR[-OB_ERR_NON_UPDATABLE_TABLE] = "The target table is not updatable"; @@ -6260,6 +7605,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NON_UPDATABLE_TABLE] = "ORA-00600: internal error code, arguments: -5228, The target table %.*s of the %.*s is not updatable"; ERROR_NAME[-OB_ERR_WARN_DATA_OUT_OF_RANGE] = "OB_ERR_WARN_DATA_OUT_OF_RANGE"; + ERROR_CAUSE[-OB_ERR_WARN_DATA_OUT_OF_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WARN_DATA_OUT_OF_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WARN_DATA_OUT_OF_RANGE] = ER_WARN_DATA_OUT_OF_RANGE; SQLSTATE[-OB_ERR_WARN_DATA_OUT_OF_RANGE] = "22003"; STR_ERROR[-OB_ERR_WARN_DATA_OUT_OF_RANGE] = "Out of range value for column"; @@ -6270,6 +7617,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WARN_DATA_OUT_OF_RANGE] = "ORA-00600: internal error code, arguments: -5229, Out of range value for column '%.*s' at row %ld"; ERROR_NAME[-OB_ERR_WRONG_EXPR_IN_PARTITION_FUNC_ERROR] = "OB_ERR_WRONG_EXPR_IN_PARTITION_FUNC_ERROR"; + ERROR_CAUSE[-OB_ERR_WRONG_EXPR_IN_PARTITION_FUNC_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_EXPR_IN_PARTITION_FUNC_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_EXPR_IN_PARTITION_FUNC_ERROR] = ER_WRONG_EXPR_IN_PARTITION_FUNC_ERROR; SQLSTATE[-OB_ERR_WRONG_EXPR_IN_PARTITION_FUNC_ERROR] = "HY000"; STR_ERROR[-OB_ERR_WRONG_EXPR_IN_PARTITION_FUNC_ERROR] = @@ -6284,6 +7633,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5230, Constant or random or timezone-dependent expressions in " "(sub)partitioning function are not allowed"; ERROR_NAME[-OB_ERR_VIEW_INVALID] = "OB_ERR_VIEW_INVALID"; + ERROR_CAUSE[-OB_ERR_VIEW_INVALID] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_VIEW_INVALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_VIEW_INVALID] = ER_VIEW_INVALID; SQLSTATE[-OB_ERR_VIEW_INVALID] = "42S22"; STR_ERROR[-OB_ERR_VIEW_INVALID] = "view invalid"; @@ -6295,6 +7646,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5231, View \'%.*s.%.*s\' references invalid table(s) or column(s) " "or function(s) or definer/invoker of view lack rights to use them"; ERROR_NAME[-OB_ERR_OPTION_PREVENTS_STATEMENT] = "OB_ERR_OPTION_PREVENTS_STATEMENT"; + ERROR_CAUSE[-OB_ERR_OPTION_PREVENTS_STATEMENT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OPTION_PREVENTS_STATEMENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OPTION_PREVENTS_STATEMENT] = ER_OPTION_PREVENTS_STATEMENT; SQLSTATE[-OB_ERR_OPTION_PREVENTS_STATEMENT] = "HY000"; STR_ERROR[-OB_ERR_OPTION_PREVENTS_STATEMENT] = @@ -6309,6 +7662,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5233, The MySQL server is running with the --read-only option so " "it cannot execute this statement"; ERROR_NAME[-OB_ERR_DB_READ_ONLY] = "OB_ERR_DB_READ_ONLY"; + ERROR_CAUSE[-OB_ERR_DB_READ_ONLY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DB_READ_ONLY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DB_READ_ONLY] = -1; SQLSTATE[-OB_ERR_DB_READ_ONLY] = "HY000"; STR_ERROR[-OB_ERR_DB_READ_ONLY] = "The database is read only so it cannot execute this statement"; @@ -6317,6 +7672,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DB_READ_ONLY] = "ORA-16000: database open for read-only access"; ORACLE_STR_USER_ERROR[-OB_ERR_DB_READ_ONLY] = "ORA-16000: database \'%.*s\' open for read-only access"; ERROR_NAME[-OB_ERR_TABLE_READ_ONLY] = "OB_ERR_TABLE_READ_ONLY"; + ERROR_CAUSE[-OB_ERR_TABLE_READ_ONLY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TABLE_READ_ONLY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TABLE_READ_ONLY] = -1; SQLSTATE[-OB_ERR_TABLE_READ_ONLY] = "HY000"; STR_ERROR[-OB_ERR_TABLE_READ_ONLY] = "The table is read only so it cannot execute this statement"; @@ -6328,6 +7685,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TABLE_READ_ONLY] = "ORA-00600: internal error code, arguments: -5235, The table " "\'%.*s.%.*s\' is read only so it cannot execute this statement"; ERROR_NAME[-OB_ERR_LOCK_OR_ACTIVE_TRANSACTION] = "OB_ERR_LOCK_OR_ACTIVE_TRANSACTION"; + ERROR_CAUSE[-OB_ERR_LOCK_OR_ACTIVE_TRANSACTION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_LOCK_OR_ACTIVE_TRANSACTION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_LOCK_OR_ACTIVE_TRANSACTION] = ER_LOCK_OR_ACTIVE_TRANSACTION; SQLSTATE[-OB_ERR_LOCK_OR_ACTIVE_TRANSACTION] = "HY000"; STR_ERROR[-OB_ERR_LOCK_OR_ACTIVE_TRANSACTION] = @@ -6342,6 +7701,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5236, Can't execute the given command because you have active " "locked tables or an active transaction"; ERROR_NAME[-OB_ERR_SAME_NAME_PARTITION_FIELD] = "OB_ERR_SAME_NAME_PARTITION_FIELD"; + ERROR_CAUSE[-OB_ERR_SAME_NAME_PARTITION_FIELD] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SAME_NAME_PARTITION_FIELD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SAME_NAME_PARTITION_FIELD] = ER_SAME_NAME_PARTITION_FIELD; SQLSTATE[-OB_ERR_SAME_NAME_PARTITION_FIELD] = "HY000"; STR_ERROR[-OB_ERR_SAME_NAME_PARTITION_FIELD] = "Duplicate partition field name"; @@ -6352,6 +7713,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SAME_NAME_PARTITION_FIELD] = "ORA-00600: internal error code, arguments: -5237, Duplicate partition field name '%.*s'"; ERROR_NAME[-OB_ERR_TABLENAME_NOT_ALLOWED_HERE] = "OB_ERR_TABLENAME_NOT_ALLOWED_HERE"; + ERROR_CAUSE[-OB_ERR_TABLENAME_NOT_ALLOWED_HERE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TABLENAME_NOT_ALLOWED_HERE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TABLENAME_NOT_ALLOWED_HERE] = ER_TABLENAME_NOT_ALLOWED_HERE; SQLSTATE[-OB_ERR_TABLENAME_NOT_ALLOWED_HERE] = "42000"; STR_ERROR[-OB_ERR_TABLENAME_NOT_ALLOWED_HERE] = @@ -6366,6 +7729,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5238, Table \'%.*s\' from one of the SELECTs cannot be used in " "global ORDER clause"; ERROR_NAME[-OB_ERR_VIEW_RECURSIVE] = "OB_ERR_VIEW_RECURSIVE"; + ERROR_CAUSE[-OB_ERR_VIEW_RECURSIVE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_VIEW_RECURSIVE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_VIEW_RECURSIVE] = ER_VIEW_RECURSIVE; SQLSTATE[-OB_ERR_VIEW_RECURSIVE] = "42S02"; STR_ERROR[-OB_ERR_VIEW_RECURSIVE] = "view contains recursion"; @@ -6374,6 +7739,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_VIEW_RECURSIVE] = "ORA-01731: circular view definition encountered"; ORACLE_STR_USER_ERROR[-OB_ERR_VIEW_RECURSIVE] = "ORA-01731: view '%.*s.%.*s' encounters circular definition"; ERROR_NAME[-OB_ERR_QUALIFIER] = "OB_ERR_QUALIFIER"; + ERROR_CAUSE[-OB_ERR_QUALIFIER] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_QUALIFIER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_QUALIFIER] = -1; SQLSTATE[-OB_ERR_QUALIFIER] = "HY000"; STR_ERROR[-OB_ERR_QUALIFIER] = "Column part of USING clause cannot have qualifier"; @@ -6384,6 +7751,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_QUALIFIER] = "ORA-00600: internal error code, arguments: -5240, Column part of USING clause cannot have qualifier"; ERROR_NAME[-OB_ERR_WRONG_VALUE] = "OB_ERR_WRONG_VALUE"; + ERROR_CAUSE[-OB_ERR_WRONG_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_VALUE] = ER_WRONG_VALUE; SQLSTATE[-OB_ERR_WRONG_VALUE] = "HY000"; STR_ERROR[-OB_ERR_WRONG_VALUE] = "Incorrect value"; @@ -6393,6 +7762,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WRONG_VALUE] = "ORA-00600: internal error code, arguments: -5241, Incorrect %s value: '%s'"; ERROR_NAME[-OB_ERR_VIEW_WRONG_LIST] = "OB_ERR_VIEW_WRONG_LIST"; + ERROR_CAUSE[-OB_ERR_VIEW_WRONG_LIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_VIEW_WRONG_LIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_VIEW_WRONG_LIST] = ER_VIEW_WRONG_LIST; SQLSTATE[-OB_ERR_VIEW_WRONG_LIST] = "HY000"; STR_ERROR[-OB_ERR_VIEW_WRONG_LIST] = "View's SELECT and view's field list have different column counts"; @@ -6403,6 +7774,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_VIEW_WRONG_LIST] = "ORA-00600: internal error code, arguments: -5242, View's SELECT " "and view's field list have different column counts"; ERROR_NAME[-OB_SYS_VARS_MAYBE_DIFF_VERSION] = "OB_SYS_VARS_MAYBE_DIFF_VERSION"; + ERROR_CAUSE[-OB_SYS_VARS_MAYBE_DIFF_VERSION] = "Internal Error"; + ERROR_SOLUTION[-OB_SYS_VARS_MAYBE_DIFF_VERSION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SYS_VARS_MAYBE_DIFF_VERSION] = -1; SQLSTATE[-OB_SYS_VARS_MAYBE_DIFF_VERSION] = "HY000"; STR_ERROR[-OB_SYS_VARS_MAYBE_DIFF_VERSION] = "system variables' version maybe different"; @@ -6413,6 +7786,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SYS_VARS_MAYBE_DIFF_VERSION] = "ORA-00600: internal error code, arguments: -5243, system variables' version maybe different"; ERROR_NAME[-OB_ERR_AUTO_INCREMENT_CONFLICT] = "OB_ERR_AUTO_INCREMENT_CONFLICT"; + ERROR_CAUSE[-OB_ERR_AUTO_INCREMENT_CONFLICT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_AUTO_INCREMENT_CONFLICT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_AUTO_INCREMENT_CONFLICT] = ER_AUTO_INCREMENT_CONFLICT; SQLSTATE[-OB_ERR_AUTO_INCREMENT_CONFLICT] = "HY000"; STR_ERROR[-OB_ERR_AUTO_INCREMENT_CONFLICT] = @@ -6427,6 +7802,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5244, Auto-increment value in UPDATE conflicts with internally " "generated values"; ERROR_NAME[-OB_ERR_TASK_SKIPPED] = "OB_ERR_TASK_SKIPPED"; + ERROR_CAUSE[-OB_ERR_TASK_SKIPPED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TASK_SKIPPED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TASK_SKIPPED] = -1; SQLSTATE[-OB_ERR_TASK_SKIPPED] = "HY000"; STR_ERROR[-OB_ERR_TASK_SKIPPED] = "some tasks are skipped"; @@ -6437,6 +7814,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TASK_SKIPPED] = "ORA-00600: internal error code, arguments: -5245, some tasks are " "skipped, skipped server addr is '%s', the orginal error code is %d"; ERROR_NAME[-OB_ERR_NAME_BECOMES_EMPTY] = "OB_ERR_NAME_BECOMES_EMPTY"; + ERROR_CAUSE[-OB_ERR_NAME_BECOMES_EMPTY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NAME_BECOMES_EMPTY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NAME_BECOMES_EMPTY] = ER_NAME_BECOMES_EMPTY; SQLSTATE[-OB_ERR_NAME_BECOMES_EMPTY] = "HY000"; STR_ERROR[-OB_ERR_NAME_BECOMES_EMPTY] = "Name has become ''"; @@ -6447,6 +7826,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NAME_BECOMES_EMPTY] = "ORA-00600: internal error code, arguments: -5246, Name \'%.*s\' has become ''"; ERROR_NAME[-OB_ERR_REMOVED_SPACES] = "OB_ERR_REMOVED_SPACES"; + ERROR_CAUSE[-OB_ERR_REMOVED_SPACES] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REMOVED_SPACES] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REMOVED_SPACES] = ER_REMOVED_SPACES; SQLSTATE[-OB_ERR_REMOVED_SPACES] = "HY000"; STR_ERROR[-OB_ERR_REMOVED_SPACES] = "Leading spaces are removed from name "; @@ -6457,6 +7838,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_REMOVED_SPACES] = "ORA-00600: internal error code, arguments: -5247, Leading spaces are removed from name \'%.*s\'"; ERROR_NAME[-OB_WARN_ADD_AUTOINCREMENT_COLUMN] = "OB_WARN_ADD_AUTOINCREMENT_COLUMN"; + ERROR_CAUSE[-OB_WARN_ADD_AUTOINCREMENT_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_WARN_ADD_AUTOINCREMENT_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WARN_ADD_AUTOINCREMENT_COLUMN] = -1; SQLSTATE[-OB_WARN_ADD_AUTOINCREMENT_COLUMN] = "HY000"; STR_ERROR[-OB_WARN_ADD_AUTOINCREMENT_COLUMN] = "Alter table add auto_increment column is dangerous"; @@ -6469,6 +7852,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5248, Alter table add auto_increment column is dangerous, " "table_name=\'%.*s\', column_name=\'%s\'"; ERROR_NAME[-OB_WARN_CHAMGE_NULL_ATTRIBUTE] = "OB_WARN_CHAMGE_NULL_ATTRIBUTE"; + ERROR_CAUSE[-OB_WARN_CHAMGE_NULL_ATTRIBUTE] = "Internal Error"; + ERROR_SOLUTION[-OB_WARN_CHAMGE_NULL_ATTRIBUTE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WARN_CHAMGE_NULL_ATTRIBUTE] = -1; SQLSTATE[-OB_WARN_CHAMGE_NULL_ATTRIBUTE] = "HY000"; STR_ERROR[-OB_WARN_CHAMGE_NULL_ATTRIBUTE] = "Alter table change nullable column to not nullable is dangerous"; @@ -6481,6 +7866,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5249, Alter table change nullable column to not nullable is " "dangerous, table_name=\'%.*s\', column_name=\'%.*s\'"; ERROR_NAME[-OB_ERR_INVALID_CHARACTER_STRING] = "OB_ERR_INVALID_CHARACTER_STRING"; + ERROR_CAUSE[-OB_ERR_INVALID_CHARACTER_STRING] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_CHARACTER_STRING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_CHARACTER_STRING] = ER_INVALID_CHARACTER_STRING; SQLSTATE[-OB_ERR_INVALID_CHARACTER_STRING] = "HY000"; STR_ERROR[-OB_ERR_INVALID_CHARACTER_STRING] = "Invalid character string"; @@ -6491,6 +7878,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_CHARACTER_STRING] = "ORA-00600: internal error code, arguments: -5250, Invalid %.*s character string: \'%.*s\'"; ERROR_NAME[-OB_ERR_KILL_DENIED] = "OB_ERR_KILL_DENIED"; + ERROR_CAUSE[-OB_ERR_KILL_DENIED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_KILL_DENIED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_KILL_DENIED] = ER_KILL_DENIED_ERROR; SQLSTATE[-OB_ERR_KILL_DENIED] = "HY000"; STR_ERROR[-OB_ERR_KILL_DENIED] = "You are not owner of thread"; @@ -6501,6 +7890,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_KILL_DENIED] = "ORA-00600: internal error code, arguments: -5251, You are not owner of thread %lu"; ERROR_NAME[-OB_ERR_COLUMN_DEFINITION_AMBIGUOUS] = "OB_ERR_COLUMN_DEFINITION_AMBIGUOUS"; + ERROR_CAUSE[-OB_ERR_COLUMN_DEFINITION_AMBIGUOUS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_COLUMN_DEFINITION_AMBIGUOUS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_COLUMN_DEFINITION_AMBIGUOUS] = -1; SQLSTATE[-OB_ERR_COLUMN_DEFINITION_AMBIGUOUS] = "HY000"; STR_ERROR[-OB_ERR_COLUMN_DEFINITION_AMBIGUOUS] = @@ -6515,6 +7906,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5252, Column \'%.*s\' definition is ambiguous. Column has both " "NULL and NOT NULL attributes"; ERROR_NAME[-OB_ERR_EMPTY_QUERY] = "OB_ERR_EMPTY_QUERY"; + ERROR_CAUSE[-OB_ERR_EMPTY_QUERY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_EMPTY_QUERY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_EMPTY_QUERY] = ER_EMPTY_QUERY; SQLSTATE[-OB_ERR_EMPTY_QUERY] = "42000"; STR_ERROR[-OB_ERR_EMPTY_QUERY] = "Query was empty"; @@ -6523,6 +7916,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_EMPTY_QUERY] = "ORA-00600: internal error code, arguments: -5253, Query was empty"; ORACLE_STR_USER_ERROR[-OB_ERR_EMPTY_QUERY] = "ORA-00600: internal error code, arguments: -5253, Query was empty"; ERROR_NAME[-OB_ERR_CUT_VALUE_GROUP_CONCAT] = "OB_ERR_CUT_VALUE_GROUP_CONCAT"; + ERROR_CAUSE[-OB_ERR_CUT_VALUE_GROUP_CONCAT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CUT_VALUE_GROUP_CONCAT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CUT_VALUE_GROUP_CONCAT] = ER_CUT_VALUE_GROUP_CONCAT; SQLSTATE[-OB_ERR_CUT_VALUE_GROUP_CONCAT] = "42000"; STR_ERROR[-OB_ERR_CUT_VALUE_GROUP_CONCAT] = "Row was cut by GROUP_CONCAT()"; @@ -6533,6 +7928,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CUT_VALUE_GROUP_CONCAT] = "ORA-00600: internal error code, arguments: -5254, Row %ld was cut by GROUP_CONCAT()"; ERROR_NAME[-OB_ERR_FIELD_NOT_FOUND_PART] = "OB_ERR_FIELD_NOT_FOUND_PART"; + ERROR_CAUSE[-OB_ERR_FIELD_NOT_FOUND_PART] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_FIELD_NOT_FOUND_PART] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_FIELD_NOT_FOUND_PART] = ER_FIELD_NOT_FOUND_PART_ERROR; SQLSTATE[-OB_ERR_FIELD_NOT_FOUND_PART] = "HY000"; STR_ERROR[-OB_ERR_FIELD_NOT_FOUND_PART] = "Field in list of fields for partition function not found in table"; @@ -6543,6 +7940,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_FIELD_NOT_FOUND_PART] = "ORA-00600: internal error code, arguments: -5255, Field in " "list of fields for partition function not found in table"; ERROR_NAME[-OB_ERR_PRIMARY_CANT_HAVE_NULL] = "OB_ERR_PRIMARY_CANT_HAVE_NULL"; + ERROR_CAUSE[-OB_ERR_PRIMARY_CANT_HAVE_NULL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PRIMARY_CANT_HAVE_NULL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PRIMARY_CANT_HAVE_NULL] = ER_PRIMARY_CANT_HAVE_NULL; SQLSTATE[-OB_ERR_PRIMARY_CANT_HAVE_NULL] = "42000"; STR_ERROR[-OB_ERR_PRIMARY_CANT_HAVE_NULL] = @@ -6557,6 +7956,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5256, All parts of a PRIMARY KEY must be NOT NULL; if you need " "NULL in a key, use UNIQUE instead"; ERROR_NAME[-OB_ERR_PARTITION_FUNC_NOT_ALLOWED_ERROR] = "OB_ERR_PARTITION_FUNC_NOT_ALLOWED_ERROR"; + ERROR_CAUSE[-OB_ERR_PARTITION_FUNC_NOT_ALLOWED_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARTITION_FUNC_NOT_ALLOWED_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARTITION_FUNC_NOT_ALLOWED_ERROR] = ER_PARTITION_FUNC_NOT_ALLOWED_ERROR; SQLSTATE[-OB_ERR_PARTITION_FUNC_NOT_ALLOWED_ERROR] = "HY000"; STR_ERROR[-OB_ERR_PARTITION_FUNC_NOT_ALLOWED_ERROR] = "The PARTITION function returns the wrong type"; @@ -6567,6 +7968,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PARTITION_FUNC_NOT_ALLOWED_ERROR] = "ORA-00600: internal error code, arguments: -5257, The PARTITION function returns the wrong type"; ERROR_NAME[-OB_ERR_INVALID_BLOCK_SIZE] = "OB_ERR_INVALID_BLOCK_SIZE"; + ERROR_CAUSE[-OB_ERR_INVALID_BLOCK_SIZE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_BLOCK_SIZE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_BLOCK_SIZE] = -1; SQLSTATE[-OB_ERR_INVALID_BLOCK_SIZE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_BLOCK_SIZE] = "Invalid block size, block size should between 1024 and 1048576"; @@ -6577,6 +7980,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_BLOCK_SIZE] = "ORA-00600: internal error code, arguments: -5258, Invalid " "block size, block size should between 1024 and 1048576"; ERROR_NAME[-OB_ERR_UNKNOWN_STORAGE_ENGINE] = "OB_ERR_UNKNOWN_STORAGE_ENGINE"; + ERROR_CAUSE[-OB_ERR_UNKNOWN_STORAGE_ENGINE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UNKNOWN_STORAGE_ENGINE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UNKNOWN_STORAGE_ENGINE] = ER_UNKNOWN_STORAGE_ENGINE; SQLSTATE[-OB_ERR_UNKNOWN_STORAGE_ENGINE] = "42000"; STR_ERROR[-OB_ERR_UNKNOWN_STORAGE_ENGINE] = "Unknown storage engine"; @@ -6587,6 +7992,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UNKNOWN_STORAGE_ENGINE] = "ORA-00600: internal error code, arguments: -5259, Unknown storage engine \'%.*s\'"; ERROR_NAME[-OB_ERR_TENANT_IS_LOCKED] = "OB_ERR_TENANT_IS_LOCKED"; + ERROR_CAUSE[-OB_ERR_TENANT_IS_LOCKED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TENANT_IS_LOCKED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TENANT_IS_LOCKED] = -1; SQLSTATE[-OB_ERR_TENANT_IS_LOCKED] = "HY000"; STR_ERROR[-OB_ERR_TENANT_IS_LOCKED] = "Tenant is locked"; @@ -6596,6 +8003,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TENANT_IS_LOCKED] = "ORA-00600: internal error code, arguments: -5260, Tenant \'%.*s\' is locked"; ERROR_NAME[-OB_EER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF] = "OB_EER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF"; + ERROR_CAUSE[-OB_EER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF] = "Internal Error"; + ERROR_SOLUTION[-OB_EER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_EER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF] = ER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF; SQLSTATE[-OB_EER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF] = "HY000"; STR_ERROR[-OB_EER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF] = @@ -6610,6 +8019,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5261, A %s must include all columns in the table's partitioning " "function"; ERROR_NAME[-OB_ERR_PARTITION_FUNCTION_IS_NOT_ALLOWED] = "OB_ERR_PARTITION_FUNCTION_IS_NOT_ALLOWED"; + ERROR_CAUSE[-OB_ERR_PARTITION_FUNCTION_IS_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARTITION_FUNCTION_IS_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARTITION_FUNCTION_IS_NOT_ALLOWED] = ER_PARTITION_FUNCTION_IS_NOT_ALLOWED; SQLSTATE[-OB_ERR_PARTITION_FUNCTION_IS_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_ERR_PARTITION_FUNCTION_IS_NOT_ALLOWED] = "This partition function is not allowed"; @@ -6620,6 +8031,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PARTITION_FUNCTION_IS_NOT_ALLOWED] = "ORA-00600: internal error code, arguments: -5262, This partition function is not allowed"; ERROR_NAME[-OB_ERR_AGGREGATE_ORDER_FOR_UNION] = "OB_ERR_AGGREGATE_ORDER_FOR_UNION"; + ERROR_CAUSE[-OB_ERR_AGGREGATE_ORDER_FOR_UNION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_AGGREGATE_ORDER_FOR_UNION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_AGGREGATE_ORDER_FOR_UNION] = ER_AGGREGATE_ORDER_FOR_UNION; SQLSTATE[-OB_ERR_AGGREGATE_ORDER_FOR_UNION] = "HY000"; STR_ERROR[-OB_ERR_AGGREGATE_ORDER_FOR_UNION] = "aggregate order for union"; @@ -6632,6 +8045,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5263, Expression #%d of ORDER BY contains aggregate function and " "applies to a UNION"; ERROR_NAME[-OB_ERR_OUTLINE_EXIST] = "OB_ERR_OUTLINE_EXIST"; + ERROR_CAUSE[-OB_ERR_OUTLINE_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OUTLINE_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OUTLINE_EXIST] = -1; SQLSTATE[-OB_ERR_OUTLINE_EXIST] = "HY000"; STR_ERROR[-OB_ERR_OUTLINE_EXIST] = "Outline exists"; @@ -6641,6 +8056,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_OUTLINE_EXIST] = "ORA-00600: internal error code, arguments: -5264, Outline '%.*s' already exists"; ERROR_NAME[-OB_OUTLINE_NOT_EXIST] = "OB_OUTLINE_NOT_EXIST"; + ERROR_CAUSE[-OB_OUTLINE_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_OUTLINE_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OUTLINE_NOT_EXIST] = -1; SQLSTATE[-OB_OUTLINE_NOT_EXIST] = "HY000"; STR_ERROR[-OB_OUTLINE_NOT_EXIST] = "Outline not exists"; @@ -6650,6 +8067,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_OUTLINE_NOT_EXIST] = "ORA-00600: internal error code, arguments: -5265, Outline \'%.*s.%.*s\' doesn\'t exist"; ERROR_NAME[-OB_WARN_OPTION_BELOW_LIMIT] = "OB_WARN_OPTION_BELOW_LIMIT"; + ERROR_CAUSE[-OB_WARN_OPTION_BELOW_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_WARN_OPTION_BELOW_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WARN_OPTION_BELOW_LIMIT] = WARN_OPTION_BELOW_LIMIT; SQLSTATE[-OB_WARN_OPTION_BELOW_LIMIT] = "HY000"; STR_ERROR[-OB_WARN_OPTION_BELOW_LIMIT] = "The value should be no less than the limit"; @@ -6660,6 +8079,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_WARN_OPTION_BELOW_LIMIT] = "ORA-00600: internal error code, arguments: -5266, The value " "of \'%s\' should be no less than the value of \'%s\'"; ERROR_NAME[-OB_INVALID_OUTLINE] = "OB_INVALID_OUTLINE"; + ERROR_CAUSE[-OB_INVALID_OUTLINE] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_OUTLINE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_OUTLINE] = -1; SQLSTATE[-OB_INVALID_OUTLINE] = "HY000"; STR_ERROR[-OB_INVALID_OUTLINE] = "invalid outline"; @@ -6669,6 +8090,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_OUTLINE] = "ORA-00600: internal error code, arguments: -5267, invalid outline ,error info:%s"; ERROR_NAME[-OB_REACH_MAX_CONCURRENT_NUM] = "OB_REACH_MAX_CONCURRENT_NUM"; + ERROR_CAUSE[-OB_REACH_MAX_CONCURRENT_NUM] = "Internal Error"; + ERROR_SOLUTION[-OB_REACH_MAX_CONCURRENT_NUM] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_REACH_MAX_CONCURRENT_NUM] = -1; SQLSTATE[-OB_REACH_MAX_CONCURRENT_NUM] = "HY000"; STR_ERROR[-OB_REACH_MAX_CONCURRENT_NUM] = "SQL reach max concurrent num"; @@ -6679,6 +8102,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_REACH_MAX_CONCURRENT_NUM] = "ORA-00600: internal error code, arguments: -5268, SQL reach max concurrent num %ld"; ERROR_NAME[-OB_ERR_OPERATION_ON_RECYCLE_OBJECT] = "OB_ERR_OPERATION_ON_RECYCLE_OBJECT"; + ERROR_CAUSE[-OB_ERR_OPERATION_ON_RECYCLE_OBJECT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OPERATION_ON_RECYCLE_OBJECT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OPERATION_ON_RECYCLE_OBJECT] = -1; SQLSTATE[-OB_ERR_OPERATION_ON_RECYCLE_OBJECT] = "HY000"; STR_ERROR[-OB_ERR_OPERATION_ON_RECYCLE_OBJECT] = "can not perform DDL/DML over objects in Recycle Bin"; @@ -6689,6 +8114,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_OPERATION_ON_RECYCLE_OBJECT] = "ORA-00600: internal error code, arguments: -5269, can not perform DDL/DML over objects in Recycle Bin"; ERROR_NAME[-OB_ERR_OBJECT_NOT_IN_RECYCLEBIN] = "OB_ERR_OBJECT_NOT_IN_RECYCLEBIN"; + ERROR_CAUSE[-OB_ERR_OBJECT_NOT_IN_RECYCLEBIN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OBJECT_NOT_IN_RECYCLEBIN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OBJECT_NOT_IN_RECYCLEBIN] = -1; SQLSTATE[-OB_ERR_OBJECT_NOT_IN_RECYCLEBIN] = "HY000"; STR_ERROR[-OB_ERR_OBJECT_NOT_IN_RECYCLEBIN] = "object not in RECYCLE BIN"; @@ -6699,6 +8126,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_OBJECT_NOT_IN_RECYCLEBIN] = "ORA-00600: internal error code, arguments: -5270, object not in RECYCLE BIN"; ERROR_NAME[-OB_ERR_CON_COUNT_ERROR] = "OB_ERR_CON_COUNT_ERROR"; + ERROR_CAUSE[-OB_ERR_CON_COUNT_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CON_COUNT_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CON_COUNT_ERROR] = ER_CON_COUNT_ERROR; SQLSTATE[-OB_ERR_CON_COUNT_ERROR] = "08004"; STR_ERROR[-OB_ERR_CON_COUNT_ERROR] = "Too many connections"; @@ -6709,6 +8138,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CON_COUNT_ERROR] = "ORA-00600: internal error code, arguments: -5271, Too many connections"; ERROR_NAME[-OB_ERR_OUTLINE_CONTENT_EXIST] = "OB_ERR_OUTLINE_CONTENT_EXIST"; + ERROR_CAUSE[-OB_ERR_OUTLINE_CONTENT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OUTLINE_CONTENT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OUTLINE_CONTENT_EXIST] = -1; SQLSTATE[-OB_ERR_OUTLINE_CONTENT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_OUTLINE_CONTENT_EXIST] = "Outline content already exists when added"; @@ -6720,6 +8151,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_OUTLINE_CONTENT_EXIST] = "ORA-00600: internal error code, arguments: -5272, Outline " "content '%.*s' of outline '%.*s' already exists when added"; ERROR_NAME[-OB_ERR_OUTLINE_MAX_CONCURRENT_EXIST] = "OB_ERR_OUTLINE_MAX_CONCURRENT_EXIST"; + ERROR_CAUSE[-OB_ERR_OUTLINE_MAX_CONCURRENT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OUTLINE_MAX_CONCURRENT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OUTLINE_MAX_CONCURRENT_EXIST] = -1; SQLSTATE[-OB_ERR_OUTLINE_MAX_CONCURRENT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_OUTLINE_MAX_CONCURRENT_EXIST] = "Max concurrent already exists when added"; @@ -6730,6 +8163,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_OUTLINE_MAX_CONCURRENT_EXIST] = "ORA-00600: internal error code, arguments: -5273, Max concurrent in outline '%.*s' already exists when added"; ERROR_NAME[-OB_ERR_VALUES_IS_NOT_INT_TYPE_ERROR] = "OB_ERR_VALUES_IS_NOT_INT_TYPE_ERROR"; + ERROR_CAUSE[-OB_ERR_VALUES_IS_NOT_INT_TYPE_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_VALUES_IS_NOT_INT_TYPE_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_VALUES_IS_NOT_INT_TYPE_ERROR] = ER_VALUES_IS_NOT_INT_TYPE_ERROR; SQLSTATE[-OB_ERR_VALUES_IS_NOT_INT_TYPE_ERROR] = "HY000"; STR_ERROR[-OB_ERR_VALUES_IS_NOT_INT_TYPE_ERROR] = "VALUES value for partition must have type INT"; @@ -6740,6 +8175,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_VALUES_IS_NOT_INT_TYPE_ERROR] = "ORA-00600: internal error code, arguments: -5274, VALUES value for partition \'%.*s\' must have type INT"; ERROR_NAME[-OB_ERR_WRONG_TYPE_COLUMN_VALUE_ERROR] = "OB_ERR_WRONG_TYPE_COLUMN_VALUE_ERROR"; + ERROR_CAUSE[-OB_ERR_WRONG_TYPE_COLUMN_VALUE_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_TYPE_COLUMN_VALUE_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_TYPE_COLUMN_VALUE_ERROR] = ER_WRONG_TYPE_COLUMN_VALUE_ERROR; SQLSTATE[-OB_ERR_WRONG_TYPE_COLUMN_VALUE_ERROR] = "HY000"; STR_ERROR[-OB_ERR_WRONG_TYPE_COLUMN_VALUE_ERROR] = "Partition column values of incorrect type"; @@ -6750,6 +8187,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WRONG_TYPE_COLUMN_VALUE_ERROR] = "ORA-14019: partition bound element must be one of: string, datetime or interval literal, number, or MAXVALUE"; ERROR_NAME[-OB_ERR_PARTITION_COLUMN_LIST_ERROR] = "OB_ERR_PARTITION_COLUMN_LIST_ERROR"; + ERROR_CAUSE[-OB_ERR_PARTITION_COLUMN_LIST_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARTITION_COLUMN_LIST_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARTITION_COLUMN_LIST_ERROR] = ER_PARTITION_COLUMN_LIST_ERROR; SQLSTATE[-OB_ERR_PARTITION_COLUMN_LIST_ERROR] = "HY000"; STR_ERROR[-OB_ERR_PARTITION_COLUMN_LIST_ERROR] = "Inconsistency in usage of column lists for partitioning"; @@ -6760,6 +8199,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PARTITION_COLUMN_LIST_ERROR] = "ORA-00600: internal error code, arguments: -5276, Inconsistency in usage of column lists for partitioning"; ERROR_NAME[-OB_ERR_TOO_MANY_VALUES_ERROR] = "OB_ERR_TOO_MANY_VALUES_ERROR"; + ERROR_CAUSE[-OB_ERR_TOO_MANY_VALUES_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_MANY_VALUES_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_MANY_VALUES_ERROR] = ER_TOO_MANY_VALUES_ERROR; SQLSTATE[-OB_ERR_TOO_MANY_VALUES_ERROR] = "HY000"; STR_ERROR[-OB_ERR_TOO_MANY_VALUES_ERROR] = "Cannot have more than one value for this type of RANGE partitioning"; @@ -6772,6 +8213,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5277, Cannot have more than one value for this type of RANGE " "partitioning"; ERROR_NAME[-OB_ERR_PARTITION_VALUE_ERROR] = "OB_ERR_PARTITION_VALUE_ERROR"; + ERROR_CAUSE[-OB_ERR_PARTITION_VALUE_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARTITION_VALUE_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARTITION_VALUE_ERROR] = -1; SQLSTATE[-OB_ERR_PARTITION_VALUE_ERROR] = "HY000"; STR_ERROR[-OB_ERR_PARTITION_VALUE_ERROR] = "This partition value with incorrect charset type"; @@ -6782,6 +8225,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PARTITION_VALUE_ERROR] = "ORA-00600: internal error code, arguments: -5278, This partition value with incorrect charset type"; ERROR_NAME[-OB_ERR_PARTITION_INTERVAL_ERROR] = "OB_ERR_PARTITION_INTERVAL_ERROR"; + ERROR_CAUSE[-OB_ERR_PARTITION_INTERVAL_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARTITION_INTERVAL_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARTITION_INTERVAL_ERROR] = -1; SQLSTATE[-OB_ERR_PARTITION_INTERVAL_ERROR] = "HY000"; STR_ERROR[-OB_ERR_PARTITION_INTERVAL_ERROR] = "Partition interval must have type INT"; @@ -6792,6 +8237,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PARTITION_INTERVAL_ERROR] = "ORA-00600: internal error code, arguments: -5279, Partition interval must have type INT"; ERROR_NAME[-OB_ERR_SAME_NAME_PARTITION] = "OB_ERR_SAME_NAME_PARTITION"; + ERROR_CAUSE[-OB_ERR_SAME_NAME_PARTITION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SAME_NAME_PARTITION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SAME_NAME_PARTITION] = ER_SAME_NAME_PARTITION; SQLSTATE[-OB_ERR_SAME_NAME_PARTITION] = "HY000"; STR_ERROR[-OB_ERR_SAME_NAME_PARTITION] = "Duplicate partition name"; @@ -6802,6 +8249,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SAME_NAME_PARTITION] = "ORA-00600: internal error code, arguments: -5280, Duplicate partition name \'%.*s\'"; ERROR_NAME[-OB_ERR_RANGE_NOT_INCREASING_ERROR] = "OB_ERR_RANGE_NOT_INCREASING_ERROR"; + ERROR_CAUSE[-OB_ERR_RANGE_NOT_INCREASING_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_RANGE_NOT_INCREASING_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_RANGE_NOT_INCREASING_ERROR] = ER_RANGE_NOT_INCREASING_ERROR; SQLSTATE[-OB_ERR_RANGE_NOT_INCREASING_ERROR] = "HY000"; STR_ERROR[-OB_ERR_RANGE_NOT_INCREASING_ERROR] = @@ -6813,6 +8262,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_RANGE_NOT_INCREASING_ERROR] = "ORA-14037: partition bound of partition '%.*s' is too high"; ERROR_NAME[-OB_ERR_PARSE_PARTITION_RANGE] = "OB_ERR_PARSE_PARTITION_RANGE"; + ERROR_CAUSE[-OB_ERR_PARSE_PARTITION_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARSE_PARTITION_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARSE_PARTITION_RANGE] = ER_PARSE_ERROR; SQLSTATE[-OB_ERR_PARSE_PARTITION_RANGE] = "42000"; STR_ERROR[-OB_ERR_PARSE_PARTITION_RANGE] = "Wrong number of partitions defined, mismatch with previous setting"; @@ -6825,6 +8276,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5282, Wrong number of partitions defined, mismatch with previous " "setting"; ERROR_NAME[-OB_ERR_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF] = "OB_ERR_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF"; + ERROR_CAUSE[-OB_ERR_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF] = ER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF; SQLSTATE[-OB_ERR_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF] = "HY000"; STR_ERROR[-OB_ERR_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF] = @@ -6839,6 +8292,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5283, A PRIMARY KEY must include all columns in the table\'s " "partitioning function"; ERROR_NAME[-OB_NO_PARTITION_FOR_GIVEN_VALUE] = "OB_NO_PARTITION_FOR_GIVEN_VALUE"; + ERROR_CAUSE[-OB_NO_PARTITION_FOR_GIVEN_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_PARTITION_FOR_GIVEN_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_PARTITION_FOR_GIVEN_VALUE] = ER_NO_PARTITION_FOR_GIVEN_VALUE; SQLSTATE[-OB_NO_PARTITION_FOR_GIVEN_VALUE] = "HY000"; STR_ERROR[-OB_NO_PARTITION_FOR_GIVEN_VALUE] = "Table has no partition for value"; @@ -6849,6 +8304,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NO_PARTITION_FOR_GIVEN_VALUE] = "ORA-14400: inserted partition key does not map to any partition"; ERROR_NAME[-OB_EER_NULL_IN_VALUES_LESS_THAN] = "OB_EER_NULL_IN_VALUES_LESS_THAN"; + ERROR_CAUSE[-OB_EER_NULL_IN_VALUES_LESS_THAN] = "Internal Error"; + ERROR_SOLUTION[-OB_EER_NULL_IN_VALUES_LESS_THAN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_EER_NULL_IN_VALUES_LESS_THAN] = ER_NULL_IN_VALUES_LESS_THAN; SQLSTATE[-OB_EER_NULL_IN_VALUES_LESS_THAN] = "HY000"; STR_ERROR[-OB_EER_NULL_IN_VALUES_LESS_THAN] = "Not allowed to use NULL value in VALUES LESS THAN"; @@ -6859,6 +8316,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_EER_NULL_IN_VALUES_LESS_THAN] = "ORA-14019: partition bound element must be one of: datetime or interval literal, number, or MAXVALUE"; ERROR_NAME[-OB_ERR_PARTITION_CONST_DOMAIN_ERROR] = "OB_ERR_PARTITION_CONST_DOMAIN_ERROR"; + ERROR_CAUSE[-OB_ERR_PARTITION_CONST_DOMAIN_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARTITION_CONST_DOMAIN_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARTITION_CONST_DOMAIN_ERROR] = ER_PARTITION_CONST_DOMAIN_ERROR; SQLSTATE[-OB_ERR_PARTITION_CONST_DOMAIN_ERROR] = "HY000"; STR_ERROR[-OB_ERR_PARTITION_CONST_DOMAIN_ERROR] = "Partition constant is out of partition function domain"; @@ -6869,6 +8328,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PARTITION_CONST_DOMAIN_ERROR] = "ORA-00600: internal error code, arguments: -5286, Partition constant is out of partition function domain"; ERROR_NAME[-OB_ERR_TOO_MANY_PARTITION_FUNC_FIELDS] = "OB_ERR_TOO_MANY_PARTITION_FUNC_FIELDS"; + ERROR_CAUSE[-OB_ERR_TOO_MANY_PARTITION_FUNC_FIELDS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_MANY_PARTITION_FUNC_FIELDS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_MANY_PARTITION_FUNC_FIELDS] = ER_TOO_MANY_PARTITION_FUNC_FIELDS_ERROR; SQLSTATE[-OB_ERR_TOO_MANY_PARTITION_FUNC_FIELDS] = "HY000"; STR_ERROR[-OB_ERR_TOO_MANY_PARTITION_FUNC_FIELDS] = "Too many fields in \'list of partition fields\'"; @@ -6879,6 +8340,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TOO_MANY_PARTITION_FUNC_FIELDS] = "ORA-00600: internal error code, arguments: -5287, Too many fields in \'list of partition fields\'"; ERROR_NAME[-OB_ERR_BAD_FT_COLUMN] = "OB_ERR_BAD_FT_COLUMN"; + ERROR_CAUSE[-OB_ERR_BAD_FT_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_BAD_FT_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_BAD_FT_COLUMN] = ER_BAD_FT_COLUMN; SQLSTATE[-OB_ERR_BAD_FT_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_BAD_FT_COLUMN] = "Column cannot be part of FULLTEXT index"; @@ -6889,7 +8352,9 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_BAD_FT_COLUMN] = "ORA-00600: internal error code, arguments: -5288, Column '%.*s' cannot be part of FULLTEXT index"; ERROR_NAME[-OB_ERR_KEY_DOES_NOT_EXISTS] = "OB_ERR_KEY_DOES_NOT_EXISTS"; - MYSQL_ERRNO[-OB_ERR_KEY_DOES_NOT_EXISTS] = OB_ERR_KEY_DOES_NOT_EXISTS; + ERROR_CAUSE[-OB_ERR_KEY_DOES_NOT_EXISTS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_KEY_DOES_NOT_EXISTS] = "Contact OceanBase Support"; + MYSQL_ERRNO[-OB_ERR_KEY_DOES_NOT_EXISTS] = ER_KEY_DOES_NOT_EXISTS; SQLSTATE[-OB_ERR_KEY_DOES_NOT_EXISTS] = "42000"; STR_ERROR[-OB_ERR_KEY_DOES_NOT_EXISTS] = "key does not exist in table"; STR_USER_ERROR[-OB_ERR_KEY_DOES_NOT_EXISTS] = "Key '%.*s' doesn't exist in table '%.*s'"; @@ -6899,6 +8364,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_KEY_DOES_NOT_EXISTS] = "ORA-00600: internal error code, arguments: -5289, Key '%.*s' doesn't exist in table '%.*s'"; ERROR_NAME[-OB_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN] = "OB_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN"; + ERROR_CAUSE[-OB_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN] = ER_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN; SQLSTATE[-OB_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN] = "HY000"; STR_ERROR[-OB_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN] = "non-default value for generated column is not allowed"; @@ -6911,6 +8378,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5290, The value specified for generated column '%.*s' in table " "'%.*s' is not allowed"; ERROR_NAME[-OB_ERR_BAD_CTXCAT_COLUMN] = "OB_ERR_BAD_CTXCAT_COLUMN"; + ERROR_CAUSE[-OB_ERR_BAD_CTXCAT_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_BAD_CTXCAT_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_BAD_CTXCAT_COLUMN] = -1; SQLSTATE[-OB_ERR_BAD_CTXCAT_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_BAD_CTXCAT_COLUMN] = "The CTXCAT column must be contiguous in the index column list"; @@ -6921,6 +8390,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_BAD_CTXCAT_COLUMN] = "ORA-00600: internal error code, arguments: -5291, The CTXCAT " "column must be contiguous in the index column list"; ERROR_NAME[-OB_ERR_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN] = "OB_ERR_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN"; + ERROR_CAUSE[-OB_ERR_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN] = ER_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN; SQLSTATE[-OB_ERR_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN] = "not supported for generated columns"; @@ -6931,6 +8402,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN] = "ORA-00600: internal error code, arguments: -5292, '%s' is not supported for generated columns."; ERROR_NAME[-OB_ERR_DEPENDENT_BY_GENERATED_COLUMN] = "OB_ERR_DEPENDENT_BY_GENERATED_COLUMN"; + ERROR_CAUSE[-OB_ERR_DEPENDENT_BY_GENERATED_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DEPENDENT_BY_GENERATED_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DEPENDENT_BY_GENERATED_COLUMN] = ER_DEPENDENT_BY_GENERATED_COLUMN; SQLSTATE[-OB_ERR_DEPENDENT_BY_GENERATED_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_DEPENDENT_BY_GENERATED_COLUMN] = "Column has a generated column dependency"; @@ -6941,6 +8414,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DEPENDENT_BY_GENERATED_COLUMN] = "ORA-00600: internal error code, arguments: -5293, Column '%.*s' has a generated column dependency"; ERROR_NAME[-OB_ERR_TOO_MANY_ROWS] = "OB_ERR_TOO_MANY_ROWS"; + ERROR_CAUSE[-OB_ERR_TOO_MANY_ROWS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_MANY_ROWS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_MANY_ROWS] = ER_TOO_MANY_ROWS; SQLSTATE[-OB_ERR_TOO_MANY_ROWS] = "42000"; STR_ERROR[-OB_ERR_TOO_MANY_ROWS] = "Result consisted of more than one row"; @@ -6949,6 +8424,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_TOO_MANY_ROWS] = "ORA-01422: exact fetch returns more than requested number of rows"; ORACLE_STR_USER_ERROR[-OB_ERR_TOO_MANY_ROWS] = "ORA-01422: exact fetch returns more than requested number of rows"; ERROR_NAME[-OB_WRONG_FIELD_TERMINATORS] = "OB_WRONG_FIELD_TERMINATORS"; + ERROR_CAUSE[-OB_WRONG_FIELD_TERMINATORS] = "Internal Error"; + ERROR_SOLUTION[-OB_WRONG_FIELD_TERMINATORS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WRONG_FIELD_TERMINATORS] = ER_WRONG_FIELD_TERMINATORS; SQLSTATE[-OB_WRONG_FIELD_TERMINATORS] = "42000"; STR_ERROR[-OB_WRONG_FIELD_TERMINATORS] = "Field separator argument is not what is expected; check the manual"; @@ -6959,6 +8436,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_WRONG_FIELD_TERMINATORS] = "ORA-00600: internal error code, arguments: -5295, Field " "separator argument is not what is expected; check the manual"; ERROR_NAME[-OB_NO_READABLE_REPLICA] = "OB_NO_READABLE_REPLICA"; + ERROR_CAUSE[-OB_NO_READABLE_REPLICA] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_READABLE_REPLICA] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_READABLE_REPLICA] = -1; SQLSTATE[-OB_NO_READABLE_REPLICA] = "42000"; STR_ERROR[-OB_NO_READABLE_REPLICA] = "there has no readable replica"; @@ -6969,6 +8448,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NO_READABLE_REPLICA] = "ORA-00600: internal error code, arguments: -5296, there has no readable replica"; ERROR_NAME[-OB_ERR_UNEXPECTED_TZ_TRANSITION] = "OB_ERR_UNEXPECTED_TZ_TRANSITION"; + ERROR_CAUSE[-OB_ERR_UNEXPECTED_TZ_TRANSITION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UNEXPECTED_TZ_TRANSITION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UNEXPECTED_TZ_TRANSITION] = -1; SQLSTATE[-OB_ERR_UNEXPECTED_TZ_TRANSITION] = "HY000"; STR_ERROR[-OB_ERR_UNEXPECTED_TZ_TRANSITION] = "unexpected time zone info transition"; @@ -6979,6 +8460,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UNEXPECTED_TZ_TRANSITION] = "ORA-00600: internal error code, arguments: -5297, unexpected time zone info transition"; ERROR_NAME[-OB_ERR_SYNONYM_EXIST] = "OB_ERR_SYNONYM_EXIST"; + ERROR_CAUSE[-OB_ERR_SYNONYM_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SYNONYM_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SYNONYM_EXIST] = -1; SQLSTATE[-OB_ERR_SYNONYM_EXIST] = "HY000"; STR_ERROR[-OB_ERR_SYNONYM_EXIST] = "synonym exists"; @@ -6988,6 +8471,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SYNONYM_EXIST] = "ORA-00600: internal error code, arguments: -5298, synonym '%.*s' already exists"; ERROR_NAME[-OB_SYNONYM_NOT_EXIST] = "OB_SYNONYM_NOT_EXIST"; + ERROR_CAUSE[-OB_SYNONYM_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_SYNONYM_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SYNONYM_NOT_EXIST] = -1; SQLSTATE[-OB_SYNONYM_NOT_EXIST] = "HY000"; STR_ERROR[-OB_SYNONYM_NOT_EXIST] = "synonym not exists"; @@ -6997,6 +8482,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SYNONYM_NOT_EXIST] = "ORA-00600: internal error code, arguments: -5299, synonym \'%.*s.%.*s\' doesn\'t exist"; ERROR_NAME[-OB_ERR_MISS_ORDER_BY_EXPR] = "OB_ERR_MISS_ORDER_BY_EXPR"; + ERROR_CAUSE[-OB_ERR_MISS_ORDER_BY_EXPR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MISS_ORDER_BY_EXPR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MISS_ORDER_BY_EXPR] = -1; SQLSTATE[-OB_ERR_MISS_ORDER_BY_EXPR] = "HY000"; STR_ERROR[-OB_ERR_MISS_ORDER_BY_EXPR] = "missing ORDER BY expression in the window specification"; @@ -7006,6 +8493,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MISS_ORDER_BY_EXPR] = "ORA-30485: missing ORDER BY expression in the window specification"; ERROR_NAME[-OB_ERR_NOT_CONST_EXPR] = "OB_ERR_NOT_CONST_EXPR"; + ERROR_CAUSE[-OB_ERR_NOT_CONST_EXPR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NOT_CONST_EXPR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NOT_CONST_EXPR] = -1; SQLSTATE[-OB_ERR_NOT_CONST_EXPR] = "HY000"; STR_ERROR[-OB_ERR_NOT_CONST_EXPR] = "The argument of the window function should be a constant for a partition"; @@ -7016,6 +8505,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NOT_CONST_EXPR] = "ORA-00600: internal error code, arguments: -5301, The argument of " "the window function should be a constant for a partition"; ERROR_NAME[-OB_ERR_PARTITION_MGMT_ON_NONPARTITIONED] = "OB_ERR_PARTITION_MGMT_ON_NONPARTITIONED"; + ERROR_CAUSE[-OB_ERR_PARTITION_MGMT_ON_NONPARTITIONED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARTITION_MGMT_ON_NONPARTITIONED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARTITION_MGMT_ON_NONPARTITIONED] = ER_PARTITION_MGMT_ON_NONPARTITIONED; SQLSTATE[-OB_ERR_PARTITION_MGMT_ON_NONPARTITIONED] = "HY000"; STR_ERROR[-OB_ERR_PARTITION_MGMT_ON_NONPARTITIONED] = @@ -7030,6 +8521,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5302, Partition management on a not partitioned table is not " "possible"; ERROR_NAME[-OB_ERR_DROP_PARTITION_NON_EXISTENT] = "OB_ERR_DROP_PARTITION_NON_EXISTENT"; + ERROR_CAUSE[-OB_ERR_DROP_PARTITION_NON_EXISTENT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DROP_PARTITION_NON_EXISTENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DROP_PARTITION_NON_EXISTENT] = ER_DROP_PARTITION_NON_EXISTENT; SQLSTATE[-OB_ERR_DROP_PARTITION_NON_EXISTENT] = "HY000"; STR_ERROR[-OB_ERR_DROP_PARTITION_NON_EXISTENT] = "Error in list of partitions"; @@ -7040,6 +8533,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DROP_PARTITION_NON_EXISTENT] = "ORA-00600: internal error code, arguments: -5303, Error in list of partitions to %s"; ERROR_NAME[-OB_ERR_PARTITION_MGMT_ON_TWOPART_TABLE] = "OB_ERR_PARTITION_MGMT_ON_TWOPART_TABLE"; + ERROR_CAUSE[-OB_ERR_PARTITION_MGMT_ON_TWOPART_TABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARTITION_MGMT_ON_TWOPART_TABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARTITION_MGMT_ON_TWOPART_TABLE] = -1; SQLSTATE[-OB_ERR_PARTITION_MGMT_ON_TWOPART_TABLE] = "HY000"; STR_ERROR[-OB_ERR_PARTITION_MGMT_ON_TWOPART_TABLE] = "Partition management on a two-part table is not possible"; @@ -7051,6 +8546,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PARTITION_MGMT_ON_TWOPART_TABLE] = "ORA-00600: internal error code, arguments: -5304, Partition management on a two-part table is not possible"; ERROR_NAME[-OB_ERR_ONLY_ON_RANGE_LIST_PARTITION] = "OB_ERR_ONLY_ON_RANGE_LIST_PARTITION"; + ERROR_CAUSE[-OB_ERR_ONLY_ON_RANGE_LIST_PARTITION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ONLY_ON_RANGE_LIST_PARTITION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ONLY_ON_RANGE_LIST_PARTITION] = ER_ONLY_ON_RANGE_LIST_PARTITION; SQLSTATE[-OB_ERR_ONLY_ON_RANGE_LIST_PARTITION] = "HY000"; STR_ERROR[-OB_ERR_ONLY_ON_RANGE_LIST_PARTITION] = "can only be used on RANGE/LIST partitions"; @@ -7061,6 +8558,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ONLY_ON_RANGE_LIST_PARTITION] = "ORA-00600: internal error code, arguments: -5305, %s PARTITION can only be used on RANGE/LIST partitions"; ERROR_NAME[-OB_ERR_DROP_LAST_PARTITION] = "OB_ERR_DROP_LAST_PARTITION"; + ERROR_CAUSE[-OB_ERR_DROP_LAST_PARTITION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DROP_LAST_PARTITION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DROP_LAST_PARTITION] = ER_DROP_LAST_PARTITION; SQLSTATE[-OB_ERR_DROP_LAST_PARTITION] = "HY000"; STR_ERROR[-OB_ERR_DROP_LAST_PARTITION] = "Cannot remove all partitions, use DROP TABLE instead"; @@ -7071,6 +8570,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DROP_LAST_PARTITION] = "ORA-00600: internal error code, arguments: -5306, Cannot remove all partitions, use DROP TABLE instead"; ERROR_NAME[-OB_ERR_SCHEDULER_THREAD_NOT_ENOUGH] = "OB_ERR_SCHEDULER_THREAD_NOT_ENOUGH"; + ERROR_CAUSE[-OB_ERR_SCHEDULER_THREAD_NOT_ENOUGH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SCHEDULER_THREAD_NOT_ENOUGH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SCHEDULER_THREAD_NOT_ENOUGH] = -1; SQLSTATE[-OB_ERR_SCHEDULER_THREAD_NOT_ENOUGH] = "HY000"; STR_ERROR[-OB_ERR_SCHEDULER_THREAD_NOT_ENOUGH] = "Scheduler thread number is not enough"; @@ -7081,6 +8582,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SCHEDULER_THREAD_NOT_ENOUGH] = "ORA-00600: internal error code, arguments: -5307, Scheduler thread number is not enough"; ERROR_NAME[-OB_ERR_IGNORE_USER_HOST_NAME] = "OB_ERR_IGNORE_USER_HOST_NAME"; + ERROR_CAUSE[-OB_ERR_IGNORE_USER_HOST_NAME] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_IGNORE_USER_HOST_NAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_IGNORE_USER_HOST_NAME] = -1; SQLSTATE[-OB_ERR_IGNORE_USER_HOST_NAME] = "HY000"; STR_ERROR[-OB_ERR_IGNORE_USER_HOST_NAME] = "Ignore the host name"; @@ -7091,6 +8594,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_IGNORE_USER_HOST_NAME] = "ORA-00600: internal error code, arguments: -5308, Ignore the host name"; ERROR_NAME[-OB_IGNORE_SQL_IN_RESTORE] = "OB_IGNORE_SQL_IN_RESTORE"; + ERROR_CAUSE[-OB_IGNORE_SQL_IN_RESTORE] = "Internal Error"; + ERROR_SOLUTION[-OB_IGNORE_SQL_IN_RESTORE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_IGNORE_SQL_IN_RESTORE] = -1; SQLSTATE[-OB_IGNORE_SQL_IN_RESTORE] = "HY000"; STR_ERROR[-OB_IGNORE_SQL_IN_RESTORE] = "Ignore sql in restore process"; @@ -7101,6 +8606,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_IGNORE_SQL_IN_RESTORE] = "ORA-00600: internal error code, arguments: -5309, Ignore sql in restore process"; ERROR_NAME[-OB_ERR_TEMPORARY_TABLE_WITH_PARTITION] = "OB_ERR_TEMPORARY_TABLE_WITH_PARTITION"; + ERROR_CAUSE[-OB_ERR_TEMPORARY_TABLE_WITH_PARTITION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TEMPORARY_TABLE_WITH_PARTITION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TEMPORARY_TABLE_WITH_PARTITION] = ER_PARTITION_NO_TEMPORARY; SQLSTATE[-OB_ERR_TEMPORARY_TABLE_WITH_PARTITION] = "HY000"; STR_ERROR[-OB_ERR_TEMPORARY_TABLE_WITH_PARTITION] = "Cannot create temporary table with partitions"; @@ -7111,6 +8618,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TEMPORARY_TABLE_WITH_PARTITION] = "ORA-00600: internal error code, arguments: -5310, Cannot create temporary table with partitions"; ERROR_NAME[-OB_ERR_INVALID_COLUMN_ID] = "OB_ERR_INVALID_COLUMN_ID"; + ERROR_CAUSE[-OB_ERR_INVALID_COLUMN_ID] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_COLUMN_ID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_COLUMN_ID] = -1; SQLSTATE[-OB_ERR_INVALID_COLUMN_ID] = "HY000"; STR_ERROR[-OB_ERR_INVALID_COLUMN_ID] = "Invalid column id"; @@ -7120,6 +8629,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_COLUMN_ID] = "ORA-00600: internal error code, arguments: -5311, Invalid column id for %.*s"; ERROR_NAME[-OB_SYNC_DDL_DUPLICATE] = "OB_SYNC_DDL_DUPLICATE"; + ERROR_CAUSE[-OB_SYNC_DDL_DUPLICATE] = "Internal Error"; + ERROR_SOLUTION[-OB_SYNC_DDL_DUPLICATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SYNC_DDL_DUPLICATE] = -1; SQLSTATE[-OB_SYNC_DDL_DUPLICATE] = "HY000"; STR_ERROR[-OB_SYNC_DDL_DUPLICATE] = "Duplicated ddl id"; @@ -7129,6 +8640,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SYNC_DDL_DUPLICATE] = "ORA-00600: internal error code, arguments: -5312, Duplicated ddl id '%.*s'"; ERROR_NAME[-OB_SYNC_DDL_ERROR] = "OB_SYNC_DDL_ERROR"; + ERROR_CAUSE[-OB_SYNC_DDL_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_SYNC_DDL_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SYNC_DDL_ERROR] = -1; SQLSTATE[-OB_SYNC_DDL_ERROR] = "HY000"; STR_ERROR[-OB_SYNC_DDL_ERROR] = "Failed to sync ddl"; @@ -7138,6 +8651,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SYNC_DDL_ERROR] = "ORA-00600: internal error code, arguments: -5313, Failed to sync ddl '%.*s'"; ERROR_NAME[-OB_ERR_ROW_IS_REFERENCED] = "OB_ERR_ROW_IS_REFERENCED"; + ERROR_CAUSE[-OB_ERR_ROW_IS_REFERENCED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ROW_IS_REFERENCED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ROW_IS_REFERENCED] = ER_ROW_IS_REFERENCED_2; SQLSTATE[-OB_ERR_ROW_IS_REFERENCED] = "23000"; STR_ERROR[-OB_ERR_ROW_IS_REFERENCED] = "Cannot delete or update a parent row: a foreign key constraint fails"; @@ -7146,6 +8661,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_ROW_IS_REFERENCED] = "ORA-02292: integrity constraint violated - child record found"; ORACLE_STR_USER_ERROR[-OB_ERR_ROW_IS_REFERENCED] = "ORA-02292: integrity constraint violated - child record found"; ERROR_NAME[-OB_ERR_NO_REFERENCED_ROW] = "OB_ERR_NO_REFERENCED_ROW"; + ERROR_CAUSE[-OB_ERR_NO_REFERENCED_ROW] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_REFERENCED_ROW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_REFERENCED_ROW] = ER_NO_REFERENCED_ROW_2; SQLSTATE[-OB_ERR_NO_REFERENCED_ROW] = "23000"; STR_ERROR[-OB_ERR_NO_REFERENCED_ROW] = "Cannot add or update a child row: a foreign key constraint fails"; @@ -7155,6 +8672,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NO_REFERENCED_ROW] = "ORA-02291: integrity constraint violated - parent key not found"; ERROR_NAME[-OB_ERR_FUNC_RESULT_TOO_LARGE] = "OB_ERR_FUNC_RESULT_TOO_LARGE"; + ERROR_CAUSE[-OB_ERR_FUNC_RESULT_TOO_LARGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_FUNC_RESULT_TOO_LARGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_FUNC_RESULT_TOO_LARGE] = ER_WARN_ALLOWED_PACKET_OVERFLOWED; SQLSTATE[-OB_ERR_FUNC_RESULT_TOO_LARGE] = "HY000"; STR_ERROR[-OB_ERR_FUNC_RESULT_TOO_LARGE] = "Result of function was larger than max_allowed_packet - truncated"; @@ -7167,6 +8686,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5316, Result of %s() was larger than max_allowed_packet (%d) - " "truncated"; ERROR_NAME[-OB_ERR_CANNOT_ADD_FOREIGN] = "OB_ERR_CANNOT_ADD_FOREIGN"; + ERROR_CAUSE[-OB_ERR_CANNOT_ADD_FOREIGN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CANNOT_ADD_FOREIGN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CANNOT_ADD_FOREIGN] = ER_CANNOT_ADD_FOREIGN; SQLSTATE[-OB_ERR_CANNOT_ADD_FOREIGN] = "HY000"; STR_ERROR[-OB_ERR_CANNOT_ADD_FOREIGN] = "Cannot add foreign key constraint"; @@ -7177,6 +8698,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CANNOT_ADD_FOREIGN] = "ORA-00600: internal error code, arguments: -5317, Cannot add foreign key constraint"; ERROR_NAME[-OB_ERR_WRONG_FK_DEF] = "OB_ERR_WRONG_FK_DEF"; + ERROR_CAUSE[-OB_ERR_WRONG_FK_DEF] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_FK_DEF] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_FK_DEF] = ER_WRONG_FK_DEF; SQLSTATE[-OB_ERR_WRONG_FK_DEF] = "42000"; STR_ERROR[-OB_ERR_WRONG_FK_DEF] = "Incorrect foreign key definition: Key reference and table reference don't match"; @@ -7188,6 +8711,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WRONG_FK_DEF] = "ORA-00600: internal error code, arguments: -5318, Incorrect foreign " "key definition: Key reference and table reference don't match"; ERROR_NAME[-OB_ERR_INVALID_CHILD_COLUMN_LENGTH_FK] = "OB_ERR_INVALID_CHILD_COLUMN_LENGTH_FK"; + ERROR_CAUSE[-OB_ERR_INVALID_CHILD_COLUMN_LENGTH_FK] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_CHILD_COLUMN_LENGTH_FK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_CHILD_COLUMN_LENGTH_FK] = -1; SQLSTATE[-OB_ERR_INVALID_CHILD_COLUMN_LENGTH_FK] = "HY000"; STR_ERROR[-OB_ERR_INVALID_CHILD_COLUMN_LENGTH_FK] = "Invalid child column length"; @@ -7200,6 +8725,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5319, Child column \'%.*s\' data length cannot be less than " "parent column \'%.*s\' data length"; ERROR_NAME[-OB_ERR_ALTER_COLUMN_FK] = "OB_ERR_ALTER_COLUMN_FK"; + ERROR_CAUSE[-OB_ERR_ALTER_COLUMN_FK] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ALTER_COLUMN_FK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ALTER_COLUMN_FK] = -1; SQLSTATE[-OB_ERR_ALTER_COLUMN_FK] = "HY000"; STR_ERROR[-OB_ERR_ALTER_COLUMN_FK] = "Cannot alter foreign key column"; @@ -7210,6 +8737,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ALTER_COLUMN_FK] = "ORA-00600: internal error code, arguments: -5320, \'%.*s\': used in a foreign key constraint"; ERROR_NAME[-OB_ERR_CONNECT_BY_REQUIRED] = "OB_ERR_CONNECT_BY_REQUIRED"; + ERROR_CAUSE[-OB_ERR_CONNECT_BY_REQUIRED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CONNECT_BY_REQUIRED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CONNECT_BY_REQUIRED] = -1; SQLSTATE[-OB_ERR_CONNECT_BY_REQUIRED] = "HY000"; STR_ERROR[-OB_ERR_CONNECT_BY_REQUIRED] = "CONNECT BY clause required in this query block"; @@ -7220,6 +8749,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CONNECT_BY_REQUIRED] = "ORA-00600: internal error code, arguments: -5321, CONNECT BY clause required in this query block"; ERROR_NAME[-OB_ERR_INVALID_PSEUDO_COLUMN_PLACE] = "OB_ERR_INVALID_PSEUDO_COLUMN_PLACE"; + ERROR_CAUSE[-OB_ERR_INVALID_PSEUDO_COLUMN_PLACE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_PSEUDO_COLUMN_PLACE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_PSEUDO_COLUMN_PLACE] = -1; SQLSTATE[-OB_ERR_INVALID_PSEUDO_COLUMN_PLACE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_PSEUDO_COLUMN_PLACE] = "Specified pseudocolumn, operator or function not allowed here"; @@ -7233,6 +8764,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5322, Specified pseudocolumn, operator or function not allowed " "here"; ERROR_NAME[-OB_ERR_NOCYCLE_REQUIRED] = "OB_ERR_NOCYCLE_REQUIRED"; + ERROR_CAUSE[-OB_ERR_NOCYCLE_REQUIRED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NOCYCLE_REQUIRED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NOCYCLE_REQUIRED] = -1; SQLSTATE[-OB_ERR_NOCYCLE_REQUIRED] = "HY000"; STR_ERROR[-OB_ERR_NOCYCLE_REQUIRED] = "NOCYCLE keyword is required with CONNECT_BY_ISCYCLE pseudocolumn"; @@ -7243,6 +8776,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NOCYCLE_REQUIRED] = "ORA-00600: internal error code, arguments: -5323, NOCYCLE " "keyword is required with CONNECT_BY_ISCYCLE pseudocolumn"; ERROR_NAME[-OB_ERR_CONNECT_BY_LOOP] = "OB_ERR_CONNECT_BY_LOOP"; + ERROR_CAUSE[-OB_ERR_CONNECT_BY_LOOP] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CONNECT_BY_LOOP] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CONNECT_BY_LOOP] = -1; SQLSTATE[-OB_ERR_CONNECT_BY_LOOP] = "HY000"; STR_ERROR[-OB_ERR_CONNECT_BY_LOOP] = "CONNECT BY loop in user data"; @@ -7253,6 +8788,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CONNECT_BY_LOOP] = "ORA-00600: internal error code, arguments: -5324, CONNECT BY loop in user data"; ERROR_NAME[-OB_ERR_INVALID_SIBLINGS] = "OB_ERR_INVALID_SIBLINGS"; + ERROR_CAUSE[-OB_ERR_INVALID_SIBLINGS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_SIBLINGS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_SIBLINGS] = -1; SQLSTATE[-OB_ERR_INVALID_SIBLINGS] = "HY000"; STR_ERROR[-OB_ERR_INVALID_SIBLINGS] = "ORDER SIBLINGS BY clause not allowed here"; @@ -7261,6 +8798,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_SIBLINGS] = "ORA-30929: ORDER SIBLINGS BY clause not allowed here"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_SIBLINGS] = "ORA-30929: ORDER SIBLINGS BY clause not allowed here"; ERROR_NAME[-OB_ERR_INVALID_SEPARATOR] = "OB_ERR_INVALID_SEPARATOR"; + ERROR_CAUSE[-OB_ERR_INVALID_SEPARATOR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_SEPARATOR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_SEPARATOR] = -1; SQLSTATE[-OB_ERR_INVALID_SEPARATOR] = "HY000"; STR_ERROR[-OB_ERR_INVALID_SEPARATOR] = @@ -7275,6 +8814,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5326, when using SYS_CONNECT_BY_PATH function, cannot have " "separator as part of column value"; ERROR_NAME[-OB_ERR_INVALID_SYNONYM_NAME] = "OB_ERR_INVALID_SYNONYM_NAME"; + ERROR_CAUSE[-OB_ERR_INVALID_SYNONYM_NAME] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_SYNONYM_NAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_SYNONYM_NAME] = -1; SQLSTATE[-OB_ERR_INVALID_SYNONYM_NAME] = "HY000"; STR_ERROR[-OB_ERR_INVALID_SYNONYM_NAME] = "Database can not be specified in public synonym"; @@ -7285,6 +8826,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_SYNONYM_NAME] = "ORA-00600: internal error code, arguments: -5327, Database can not be specified in public synonym"; ERROR_NAME[-OB_ERR_LOOP_OF_SYNONYM] = "OB_ERR_LOOP_OF_SYNONYM"; + ERROR_CAUSE[-OB_ERR_LOOP_OF_SYNONYM] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_LOOP_OF_SYNONYM] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_LOOP_OF_SYNONYM] = -1; SQLSTATE[-OB_ERR_LOOP_OF_SYNONYM] = "HY000"; STR_ERROR[-OB_ERR_LOOP_OF_SYNONYM] = "Looping chain of synonyms"; @@ -7295,6 +8838,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_LOOP_OF_SYNONYM] = "ORA-00600: internal error code, arguments: -5328, Looping chain of synonyms"; ERROR_NAME[-OB_ERR_SYNONYM_SAME_AS_OBJECT] = "OB_ERR_SYNONYM_SAME_AS_OBJECT"; + ERROR_CAUSE[-OB_ERR_SYNONYM_SAME_AS_OBJECT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SYNONYM_SAME_AS_OBJECT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SYNONYM_SAME_AS_OBJECT] = -1; SQLSTATE[-OB_ERR_SYNONYM_SAME_AS_OBJECT] = "HY000"; STR_ERROR[-OB_ERR_SYNONYM_SAME_AS_OBJECT] = "Cannot create a synonym with same name as object"; @@ -7305,6 +8850,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SYNONYM_SAME_AS_OBJECT] = "ORA-00600: internal error code, arguments: -5329, Cannot create a synonym with same name as object"; ERROR_NAME[-OB_ERR_SYNONYM_TRANSLATION_INVALID] = "OB_ERR_SYNONYM_TRANSLATION_INVALID"; + ERROR_CAUSE[-OB_ERR_SYNONYM_TRANSLATION_INVALID] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SYNONYM_TRANSLATION_INVALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SYNONYM_TRANSLATION_INVALID] = -1; SQLSTATE[-OB_ERR_SYNONYM_TRANSLATION_INVALID] = "HY000"; STR_ERROR[-OB_ERR_SYNONYM_TRANSLATION_INVALID] = "Synonym translation is no longer valid"; @@ -7313,6 +8860,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SYNONYM_TRANSLATION_INVALID] = "ORA-00980: synonym translation is no longer valid"; ORACLE_STR_USER_ERROR[-OB_ERR_SYNONYM_TRANSLATION_INVALID] = "ORA-00980: synonym %s translation is no longer valid"; ERROR_NAME[-OB_ERR_EXIST_OBJECT] = "OB_ERR_EXIST_OBJECT"; + ERROR_CAUSE[-OB_ERR_EXIST_OBJECT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_EXIST_OBJECT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_EXIST_OBJECT] = -1; SQLSTATE[-OB_ERR_EXIST_OBJECT] = "HY000"; STR_ERROR[-OB_ERR_EXIST_OBJECT] = "name is already used by an existing object"; @@ -7321,6 +8870,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_EXIST_OBJECT] = "ORA-00955: name is already used by an existing object"; ORACLE_STR_USER_ERROR[-OB_ERR_EXIST_OBJECT] = "ORA-00955: name is already used by an existing object"; ERROR_NAME[-OB_ERR_ILLEGAL_VALUE_FOR_TYPE] = "OB_ERR_ILLEGAL_VALUE_FOR_TYPE"; + ERROR_CAUSE[-OB_ERR_ILLEGAL_VALUE_FOR_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ILLEGAL_VALUE_FOR_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ILLEGAL_VALUE_FOR_TYPE] = ER_ILLEGAL_VALUE_FOR_TYPE; SQLSTATE[-OB_ERR_ILLEGAL_VALUE_FOR_TYPE] = "22007"; STR_ERROR[-OB_ERR_ILLEGAL_VALUE_FOR_TYPE] = "Illegal value found during parsing"; @@ -7331,6 +8882,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ILLEGAL_VALUE_FOR_TYPE] = "ORA-00600: internal error code, arguments: -5332, Illegal %s '%.*s' value found during parsing"; ERROR_NAME[-OB_ER_TOO_LONG_SET_ENUM_VALUE] = "OB_ER_TOO_LONG_SET_ENUM_VALUE"; + ERROR_CAUSE[-OB_ER_TOO_LONG_SET_ENUM_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_TOO_LONG_SET_ENUM_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_TOO_LONG_SET_ENUM_VALUE] = ER_TOO_LONG_SET_ENUM_VALUE; SQLSTATE[-OB_ER_TOO_LONG_SET_ENUM_VALUE] = "HY000"; STR_ERROR[-OB_ER_TOO_LONG_SET_ENUM_VALUE] = "Too long enumeration/set value for column."; @@ -7341,6 +8894,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_TOO_LONG_SET_ENUM_VALUE] = "ORA-00600: internal error code, arguments: -5333, Too long enumeration/set value for column %.*s."; ERROR_NAME[-OB_ER_DUPLICATED_VALUE_IN_TYPE] = "OB_ER_DUPLICATED_VALUE_IN_TYPE"; + ERROR_CAUSE[-OB_ER_DUPLICATED_VALUE_IN_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_DUPLICATED_VALUE_IN_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_DUPLICATED_VALUE_IN_TYPE] = ER_DUPLICATED_VALUE_IN_TYPE; SQLSTATE[-OB_ER_DUPLICATED_VALUE_IN_TYPE] = "HY000"; STR_ERROR[-OB_ER_DUPLICATED_VALUE_IN_TYPE] = "Column has duplicated value"; @@ -7350,6 +8905,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_DUPLICATED_VALUE_IN_TYPE] = "ORA-00001: unique constraint violated, column '%.*s' with value '%.*s' in %s"; ERROR_NAME[-OB_ER_TOO_BIG_ENUM] = "OB_ER_TOO_BIG_ENUM"; + ERROR_CAUSE[-OB_ER_TOO_BIG_ENUM] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_TOO_BIG_ENUM] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_TOO_BIG_ENUM] = ER_TOO_BIG_ENUM; SQLSTATE[-OB_ER_TOO_BIG_ENUM] = "HY000"; STR_ERROR[-OB_ER_TOO_BIG_ENUM] = "Too many enumeration values for column"; @@ -7360,6 +8917,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_TOO_BIG_ENUM] = "ORA-00600: internal error code, arguments: -5335, Too many enumeration values for column %.*s"; ERROR_NAME[-OB_ERR_TOO_BIG_SET] = "OB_ERR_TOO_BIG_SET"; + ERROR_CAUSE[-OB_ERR_TOO_BIG_SET] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_BIG_SET] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_BIG_SET] = ER_TOO_BIG_SET; SQLSTATE[-OB_ERR_TOO_BIG_SET] = "HY000"; STR_ERROR[-OB_ERR_TOO_BIG_SET] = "Too many strings for column"; @@ -7370,6 +8929,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TOO_BIG_SET] = "ORA-00600: internal error code, arguments: -5336, Too many strings for column %.*s and SET"; ERROR_NAME[-OB_ERR_WRONG_ROWID] = "OB_ERR_WRONG_ROWID"; + ERROR_CAUSE[-OB_ERR_WRONG_ROWID] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_ROWID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_ROWID] = -1; SQLSTATE[-OB_ERR_WRONG_ROWID] = "HY000"; STR_ERROR[-OB_ERR_WRONG_ROWID] = "rowid is wrong"; @@ -7378,6 +8939,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_WRONG_ROWID] = "ORA-00600: internal error code, arguments: -5337, rowid is wrong"; ORACLE_STR_USER_ERROR[-OB_ERR_WRONG_ROWID] = "ORA-00600: internal error code, arguments: -5337, rowid is wrong"; ERROR_NAME[-OB_ERR_INVALID_WINDOW_FUNCTION_PLACE] = "OB_ERR_INVALID_WINDOW_FUNCTION_PLACE"; + ERROR_CAUSE[-OB_ERR_INVALID_WINDOW_FUNCTION_PLACE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_WINDOW_FUNCTION_PLACE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_WINDOW_FUNCTION_PLACE] = -1; SQLSTATE[-OB_ERR_INVALID_WINDOW_FUNCTION_PLACE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_WINDOW_FUNCTION_PLACE] = "Window Function not allowed here"; @@ -7388,6 +8951,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_WINDOW_FUNCTION_PLACE] = "ORA-00600: internal error code, arguments: -5338, Window Function not allowed here"; ERROR_NAME[-OB_ERR_PARSE_PARTITION_LIST] = "OB_ERR_PARSE_PARTITION_LIST"; + ERROR_CAUSE[-OB_ERR_PARSE_PARTITION_LIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARSE_PARTITION_LIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARSE_PARTITION_LIST] = -1; SQLSTATE[-OB_ERR_PARSE_PARTITION_LIST] = "HY000"; STR_ERROR[-OB_ERR_PARSE_PARTITION_LIST] = "Fail to parse list partition"; @@ -7398,6 +8963,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PARSE_PARTITION_LIST] = "ORA-00600: internal error code, arguments: -5339, Fail to parse list partition"; ERROR_NAME[-OB_ERR_MULTIPLE_DEF_CONST_IN_LIST_PART] = "OB_ERR_MULTIPLE_DEF_CONST_IN_LIST_PART"; + ERROR_CAUSE[-OB_ERR_MULTIPLE_DEF_CONST_IN_LIST_PART] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MULTIPLE_DEF_CONST_IN_LIST_PART] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MULTIPLE_DEF_CONST_IN_LIST_PART] = ER_MULTIPLE_DEF_CONST_IN_LIST_PART_ERROR; SQLSTATE[-OB_ERR_MULTIPLE_DEF_CONST_IN_LIST_PART] = "HY000"; STR_ERROR[-OB_ERR_MULTIPLE_DEF_CONST_IN_LIST_PART] = "Multiple definition of same constant in list partitioning"; @@ -7409,6 +8976,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MULTIPLE_DEF_CONST_IN_LIST_PART] = "ORA-00600: internal error code, arguments: -5340, Multiple definition of same constant in list partitioning"; ERROR_NAME[-OB_ERR_INVALID_TIMEZONE_REGION_ID] = "OB_ERR_INVALID_TIMEZONE_REGION_ID"; + ERROR_CAUSE[-OB_ERR_INVALID_TIMEZONE_REGION_ID] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_TIMEZONE_REGION_ID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_TIMEZONE_REGION_ID] = -1; SQLSTATE[-OB_ERR_INVALID_TIMEZONE_REGION_ID] = "HY000"; STR_ERROR[-OB_ERR_INVALID_TIMEZONE_REGION_ID] = "timezone region ID is invalid"; @@ -7417,6 +8986,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_TIMEZONE_REGION_ID] = "ORA-01881: timezone region ID is invalid"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_TIMEZONE_REGION_ID] = "ORA-01881: timezone region ID is invalid"; ERROR_NAME[-OB_ERR_INVALID_HEX_NUMBER] = "OB_ERR_INVALID_HEX_NUMBER"; + ERROR_CAUSE[-OB_ERR_INVALID_HEX_NUMBER] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_HEX_NUMBER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_HEX_NUMBER] = -1; SQLSTATE[-OB_ERR_INVALID_HEX_NUMBER] = "HY000"; STR_ERROR[-OB_ERR_INVALID_HEX_NUMBER] = "invalid hex number"; @@ -7425,6 +8996,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_HEX_NUMBER] = "ORA-01465: invalid hex number"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_HEX_NUMBER] = "ORA-01465: invalid hex number"; ERROR_NAME[-OB_ERR_WRONG_FUNC_ARGUMENTS_TYPE] = "OB_ERR_WRONG_FUNC_ARGUMENTS_TYPE"; + ERROR_CAUSE[-OB_ERR_WRONG_FUNC_ARGUMENTS_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_FUNC_ARGUMENTS_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_FUNC_ARGUMENTS_TYPE] = -1; SQLSTATE[-OB_ERR_WRONG_FUNC_ARGUMENTS_TYPE] = "42000"; STR_ERROR[-OB_ERR_WRONG_FUNC_ARGUMENTS_TYPE] = "wrong number or types of arguments in function"; @@ -7434,6 +9007,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WRONG_FUNC_ARGUMENTS_TYPE] = "ORA-06553: wrong number or types of arguments in call to '%.*s'"; ERROR_NAME[-OB_ERR_MULTI_UPDATE_KEY_CONFLICT] = "OB_ERR_MULTI_UPDATE_KEY_CONFLICT"; + ERROR_CAUSE[-OB_ERR_MULTI_UPDATE_KEY_CONFLICT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MULTI_UPDATE_KEY_CONFLICT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MULTI_UPDATE_KEY_CONFLICT] = ER_MULTI_UPDATE_KEY_CONFLICT; SQLSTATE[-OB_ERR_MULTI_UPDATE_KEY_CONFLICT] = "HY000"; STR_ERROR[-OB_ERR_MULTI_UPDATE_KEY_CONFLICT] = "Primary key/index key/partition key update is not allowed"; @@ -7446,6 +9021,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5344, Primary key/index key/partition key update is not allowed " "since the table is updated both as '%.*s' and '%.*s'"; ERROR_NAME[-OB_ERR_INSUFFICIENT_PX_WORKER] = "OB_ERR_INSUFFICIENT_PX_WORKER"; + ERROR_CAUSE[-OB_ERR_INSUFFICIENT_PX_WORKER] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INSUFFICIENT_PX_WORKER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INSUFFICIENT_PX_WORKER] = -1; SQLSTATE[-OB_ERR_INSUFFICIENT_PX_WORKER] = "HY000"; STR_ERROR[-OB_ERR_INSUFFICIENT_PX_WORKER] = "insufficient parallel query worker available"; @@ -7454,6 +9031,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INSUFFICIENT_PX_WORKER] = "ORA-12827: insufficient parallel query worker available"; ORACLE_STR_USER_ERROR[-OB_ERR_INSUFFICIENT_PX_WORKER] = "ORA-12827: insufficient parallel query worker available"; ERROR_NAME[-OB_ERR_FOR_UPDATE_EXPR_NOT_ALLOWED] = "OB_ERR_FOR_UPDATE_EXPR_NOT_ALLOWED"; + ERROR_CAUSE[-OB_ERR_FOR_UPDATE_EXPR_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_FOR_UPDATE_EXPR_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_FOR_UPDATE_EXPR_NOT_ALLOWED] = -1; SQLSTATE[-OB_ERR_FOR_UPDATE_EXPR_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_ERR_FOR_UPDATE_EXPR_NOT_ALLOWED] = "FOR UPDATE of this query expression is not allowed"; @@ -7464,6 +9043,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_FOR_UPDATE_EXPR_NOT_ALLOWED] = "ORA-01786: FOR UPDATE of this query expression is not allowed"; ERROR_NAME[-OB_ERR_WIN_FUNC_ARG_NOT_IN_PARTITION_BY] = "OB_ERR_WIN_FUNC_ARG_NOT_IN_PARTITION_BY"; + ERROR_CAUSE[-OB_ERR_WIN_FUNC_ARG_NOT_IN_PARTITION_BY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WIN_FUNC_ARG_NOT_IN_PARTITION_BY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WIN_FUNC_ARG_NOT_IN_PARTITION_BY] = -1; SQLSTATE[-OB_ERR_WIN_FUNC_ARG_NOT_IN_PARTITION_BY] = "HY000"; STR_ERROR[-OB_ERR_WIN_FUNC_ARG_NOT_IN_PARTITION_BY] = @@ -7476,6 +9057,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WIN_FUNC_ARG_NOT_IN_PARTITION_BY] = "ORA-30488: argument should be a function of expressions in PARTITION BY"; ERROR_NAME[-OB_ERR_TOO_LONG_STRING_IN_CONCAT] = "OB_ERR_TOO_LONG_STRING_IN_CONCAT"; + ERROR_CAUSE[-OB_ERR_TOO_LONG_STRING_IN_CONCAT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_LONG_STRING_IN_CONCAT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_LONG_STRING_IN_CONCAT] = -1; SQLSTATE[-OB_ERR_TOO_LONG_STRING_IN_CONCAT] = "HY000"; STR_ERROR[-OB_ERR_TOO_LONG_STRING_IN_CONCAT] = "result of string concatenation is too long"; @@ -7484,6 +9067,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_TOO_LONG_STRING_IN_CONCAT] = "ORA-01489: result of string concatenation is too long"; ORACLE_STR_USER_ERROR[-OB_ERR_TOO_LONG_STRING_IN_CONCAT] = "ORA-01489: result of string concatenation is too long"; ERROR_NAME[-OB_ERR_WRONG_TIMESTAMP_LTZ_COLUMN_VALUE_ERROR] = "OB_ERR_WRONG_TIMESTAMP_LTZ_COLUMN_VALUE_ERROR"; + ERROR_CAUSE[-OB_ERR_WRONG_TIMESTAMP_LTZ_COLUMN_VALUE_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_TIMESTAMP_LTZ_COLUMN_VALUE_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_TIMESTAMP_LTZ_COLUMN_VALUE_ERROR] = ER_WRONG_TYPE_COLUMN_VALUE_ERROR; SQLSTATE[-OB_ERR_WRONG_TIMESTAMP_LTZ_COLUMN_VALUE_ERROR] = "HY000"; STR_ERROR[-OB_ERR_WRONG_TIMESTAMP_LTZ_COLUMN_VALUE_ERROR] = "Partition column values of incorrect type"; @@ -7494,6 +9079,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WRONG_TIMESTAMP_LTZ_COLUMN_VALUE_ERROR] = "ORA-30078: partition bound must be TIME/TIMESTAMP WITH TIME ZONE literals"; ERROR_NAME[-OB_ERR_UPD_CAUSE_PART_CHANGE] = "OB_ERR_UPD_CAUSE_PART_CHANGE"; + ERROR_CAUSE[-OB_ERR_UPD_CAUSE_PART_CHANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UPD_CAUSE_PART_CHANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UPD_CAUSE_PART_CHANGE] = -1; SQLSTATE[-OB_ERR_UPD_CAUSE_PART_CHANGE] = "HY000"; STR_ERROR[-OB_ERR_UPD_CAUSE_PART_CHANGE] = "updating partition key column would cause a partition change"; @@ -7504,6 +9091,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UPD_CAUSE_PART_CHANGE] = "ORA-14402: updating partition key column would cause a partition change"; ERROR_NAME[-OB_ERR_INVALID_TYPE_FOR_ARGUMENT] = "OB_ERR_INVALID_TYPE_FOR_ARGUMENT"; + ERROR_CAUSE[-OB_ERR_INVALID_TYPE_FOR_ARGUMENT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_TYPE_FOR_ARGUMENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_TYPE_FOR_ARGUMENT] = -1; SQLSTATE[-OB_ERR_INVALID_TYPE_FOR_ARGUMENT] = "HY000"; STR_ERROR[-OB_ERR_INVALID_TYPE_FOR_ARGUMENT] = "invalid type given for an argument"; @@ -7512,6 +9101,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_TYPE_FOR_ARGUMENT] = "ORA-30175: invalid type given for an argument"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_TYPE_FOR_ARGUMENT] = "ORA-30175: invalid type given for an argument"; ERROR_NAME[-OB_ERR_FIELD_NOT_FOUND_IN_DATETIME_OR_INTERVAL] = "OB_ERR_FIELD_NOT_FOUND_IN_DATETIME_OR_INTERVAL"; + ERROR_CAUSE[-OB_ERR_FIELD_NOT_FOUND_IN_DATETIME_OR_INTERVAL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_FIELD_NOT_FOUND_IN_DATETIME_OR_INTERVAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_FIELD_NOT_FOUND_IN_DATETIME_OR_INTERVAL] = -1; SQLSTATE[-OB_ERR_FIELD_NOT_FOUND_IN_DATETIME_OR_INTERVAL] = "HY000"; STR_ERROR[-OB_ERR_FIELD_NOT_FOUND_IN_DATETIME_OR_INTERVAL] = "specified field not found in datetime or interval"; @@ -7523,6 +9114,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_FIELD_NOT_FOUND_IN_DATETIME_OR_INTERVAL] = "ORA-01878: specified field not found in datetime or interval"; ERROR_NAME[-OB_ERR_ADD_PART_BOUN_NOT_INC] = "OB_ERR_ADD_PART_BOUN_NOT_INC"; + ERROR_CAUSE[-OB_ERR_ADD_PART_BOUN_NOT_INC] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ADD_PART_BOUN_NOT_INC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ADD_PART_BOUN_NOT_INC] = ER_RANGE_NOT_INCREASING_ERROR; SQLSTATE[-OB_ERR_ADD_PART_BOUN_NOT_INC] = "HY000"; STR_ERROR[-OB_ERR_ADD_PART_BOUN_NOT_INC] = "VALUES LESS THAN value must be strictly increasing for each partition"; @@ -7534,6 +9127,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ADD_PART_BOUN_NOT_INC] = "ORA-14074: partition bound must collate higher than that of the last partition"; ERROR_NAME[-OB_ERR_DATA_TOO_LONG_IN_PART_CHECK] = "OB_ERR_DATA_TOO_LONG_IN_PART_CHECK"; + ERROR_CAUSE[-OB_ERR_DATA_TOO_LONG_IN_PART_CHECK] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DATA_TOO_LONG_IN_PART_CHECK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DATA_TOO_LONG_IN_PART_CHECK] = ER_DATA_TOO_LONG; SQLSTATE[-OB_ERR_DATA_TOO_LONG_IN_PART_CHECK] = "22001"; STR_ERROR[-OB_ERR_DATA_TOO_LONG_IN_PART_CHECK] = "Data too long for column"; @@ -7543,6 +9138,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DATA_TOO_LONG_IN_PART_CHECK] = "ORA-14036: partition bound value too large for column"; ERROR_NAME[-OB_ERR_WRONG_TYPE_COLUMN_VALUE_V2_ERROR] = "OB_ERR_WRONG_TYPE_COLUMN_VALUE_V2_ERROR"; + ERROR_CAUSE[-OB_ERR_WRONG_TYPE_COLUMN_VALUE_V2_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WRONG_TYPE_COLUMN_VALUE_V2_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WRONG_TYPE_COLUMN_VALUE_V2_ERROR] = ER_WRONG_TYPE_COLUMN_VALUE_ERROR; SQLSTATE[-OB_ERR_WRONG_TYPE_COLUMN_VALUE_V2_ERROR] = "HY000"; STR_ERROR[-OB_ERR_WRONG_TYPE_COLUMN_VALUE_V2_ERROR] = "Partition column values of incorrect type"; @@ -7553,6 +9150,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WRONG_TYPE_COLUMN_VALUE_V2_ERROR] = "ORA-14308: partition bound element must be one of: string, datetime or interval literal, number, or NULL"; ERROR_NAME[-OB_CANT_AGGREGATE_3COLLATIONS] = "OB_CANT_AGGREGATE_3COLLATIONS"; + ERROR_CAUSE[-OB_CANT_AGGREGATE_3COLLATIONS] = "Internal Error"; + ERROR_SOLUTION[-OB_CANT_AGGREGATE_3COLLATIONS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANT_AGGREGATE_3COLLATIONS] = ER_CANT_AGGREGATE_3COLLATIONS; SQLSTATE[-OB_CANT_AGGREGATE_3COLLATIONS] = "HY000"; STR_ERROR[-OB_CANT_AGGREGATE_3COLLATIONS] = "Illegal mix of collations"; @@ -7563,6 +9162,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CANT_AGGREGATE_3COLLATIONS] = "ORA-00600: internal error code, arguments: -5356, Illegal mix of collations"; ERROR_NAME[-OB_CANT_AGGREGATE_NCOLLATIONS] = "OB_CANT_AGGREGATE_NCOLLATIONS"; + ERROR_CAUSE[-OB_CANT_AGGREGATE_NCOLLATIONS] = "Internal Error"; + ERROR_SOLUTION[-OB_CANT_AGGREGATE_NCOLLATIONS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANT_AGGREGATE_NCOLLATIONS] = ER_CANT_AGGREGATE_NCOLLATIONS; SQLSTATE[-OB_CANT_AGGREGATE_NCOLLATIONS] = "HY000"; STR_ERROR[-OB_CANT_AGGREGATE_NCOLLATIONS] = "Illegal mix of collations"; @@ -7573,6 +9174,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CANT_AGGREGATE_NCOLLATIONS] = "ORA-00600: internal error code, arguments: -5357, Illegal mix of collations"; ERROR_NAME[-OB_ERR_NO_SYS_PRIVILEGE] = "OB_ERR_NO_SYS_PRIVILEGE"; + ERROR_CAUSE[-OB_ERR_NO_SYS_PRIVILEGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_SYS_PRIVILEGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_SYS_PRIVILEGE] = -1; SQLSTATE[-OB_ERR_NO_SYS_PRIVILEGE] = "HY000"; STR_ERROR[-OB_ERR_NO_SYS_PRIVILEGE] = "insufficient privileges"; @@ -7581,6 +9184,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_NO_SYS_PRIVILEGE] = "ORA-01031: insufficient privileges"; ORACLE_STR_USER_ERROR[-OB_ERR_NO_SYS_PRIVILEGE] = "ORA-01031: insufficient privileges"; ERROR_NAME[-OB_ERR_NO_LOGIN_PRIVILEGE] = "OB_ERR_NO_LOGIN_PRIVILEGE"; + ERROR_CAUSE[-OB_ERR_NO_LOGIN_PRIVILEGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_LOGIN_PRIVILEGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_LOGIN_PRIVILEGE] = -1; SQLSTATE[-OB_ERR_NO_LOGIN_PRIVILEGE] = "HY000"; STR_ERROR[-OB_ERR_NO_LOGIN_PRIVILEGE] = "user lacks CREATE SESSION privilege logon denied"; @@ -7591,6 +9196,8 @@ static struct ObStrErrorInit { "ORA-01045: user %.*s lacks CREATE SESSION privilege; logon denied"; ERROR_NAME[-OB_ERR_CANNOT_REVOKE_PRIVILEGES_YOU_DID_NOT_GRANT] = "OB_ERR_CANNOT_REVOKE_PRIVILEGES_YOU_DID_NOT_GRANT"; + ERROR_CAUSE[-OB_ERR_CANNOT_REVOKE_PRIVILEGES_YOU_DID_NOT_GRANT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CANNOT_REVOKE_PRIVILEGES_YOU_DID_NOT_GRANT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CANNOT_REVOKE_PRIVILEGES_YOU_DID_NOT_GRANT] = OB_ERR_NO_GRANT; SQLSTATE[-OB_ERR_CANNOT_REVOKE_PRIVILEGES_YOU_DID_NOT_GRANT] = "42000"; STR_ERROR[-OB_ERR_CANNOT_REVOKE_PRIVILEGES_YOU_DID_NOT_GRANT] = "No such grant defined"; @@ -7601,6 +9208,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CANNOT_REVOKE_PRIVILEGES_YOU_DID_NOT_GRANT] = "ORA-01927: cannot REVOKE privileges you did not grant"; ERROR_NAME[-OB_ERR_SYSTEM_PRIVILEGES_NOT_GRANTED_TO] = "OB_ERR_SYSTEM_PRIVILEGES_NOT_GRANTED_TO"; + ERROR_CAUSE[-OB_ERR_SYSTEM_PRIVILEGES_NOT_GRANTED_TO] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SYSTEM_PRIVILEGES_NOT_GRANTED_TO] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SYSTEM_PRIVILEGES_NOT_GRANTED_TO] = -1; SQLSTATE[-OB_ERR_SYSTEM_PRIVILEGES_NOT_GRANTED_TO] = "HY000"; STR_ERROR[-OB_ERR_SYSTEM_PRIVILEGES_NOT_GRANTED_TO] = "system privileges not granted to"; @@ -7611,6 +9220,8 @@ static struct ObStrErrorInit { "ORA-01952: system privileges not granted to '%.*s'"; ERROR_NAME[-OB_ERR_ONLY_SELECT_AND_ALTER_PRIVILEGES_ARE_VALID_FOR_SEQUENCES] = "OB_ERR_ONLY_SELECT_AND_ALTER_PRIVILEGES_ARE_VALID_FOR_SEQUENCES"; + ERROR_CAUSE[-OB_ERR_ONLY_SELECT_AND_ALTER_PRIVILEGES_ARE_VALID_FOR_SEQUENCES] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ONLY_SELECT_AND_ALTER_PRIVILEGES_ARE_VALID_FOR_SEQUENCES] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ONLY_SELECT_AND_ALTER_PRIVILEGES_ARE_VALID_FOR_SEQUENCES] = -1; SQLSTATE[-OB_ERR_ONLY_SELECT_AND_ALTER_PRIVILEGES_ARE_VALID_FOR_SEQUENCES] = "HY000"; STR_ERROR[-OB_ERR_ONLY_SELECT_AND_ALTER_PRIVILEGES_ARE_VALID_FOR_SEQUENCES] = @@ -7623,6 +9234,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ONLY_SELECT_AND_ALTER_PRIVILEGES_ARE_VALID_FOR_SEQUENCES] = "ORA-02205: only SELECT and ALTER privileges are valid for sequences"; ERROR_NAME[-OB_ERR_EXECUTE_PRIVILEGE_NOT_ALLOWED_FOR_TABLES] = "OB_ERR_EXECUTE_PRIVILEGE_NOT_ALLOWED_FOR_TABLES"; + ERROR_CAUSE[-OB_ERR_EXECUTE_PRIVILEGE_NOT_ALLOWED_FOR_TABLES] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_EXECUTE_PRIVILEGE_NOT_ALLOWED_FOR_TABLES] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_EXECUTE_PRIVILEGE_NOT_ALLOWED_FOR_TABLES] = -1; SQLSTATE[-OB_ERR_EXECUTE_PRIVILEGE_NOT_ALLOWED_FOR_TABLES] = "HY000"; STR_ERROR[-OB_ERR_EXECUTE_PRIVILEGE_NOT_ALLOWED_FOR_TABLES] = "EXECUTE privilege not allowed for tables"; @@ -7634,6 +9247,8 @@ static struct ObStrErrorInit { "ORA-02224: EXECUTE privilege not allowed for tables"; ERROR_NAME[-OB_ERR_ONLY_EXECUTE_AND_DEBUG_PRIVILEGES_ARE_VALID_FOR_PROCEDURES] = "OB_ERR_ONLY_EXECUTE_AND_DEBUG_PRIVILEGES_ARE_VALID_FOR_PROCEDURES"; + ERROR_CAUSE[-OB_ERR_ONLY_EXECUTE_AND_DEBUG_PRIVILEGES_ARE_VALID_FOR_PROCEDURES] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ONLY_EXECUTE_AND_DEBUG_PRIVILEGES_ARE_VALID_FOR_PROCEDURES] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ONLY_EXECUTE_AND_DEBUG_PRIVILEGES_ARE_VALID_FOR_PROCEDURES] = -1; SQLSTATE[-OB_ERR_ONLY_EXECUTE_AND_DEBUG_PRIVILEGES_ARE_VALID_FOR_PROCEDURES] = "HY000"; STR_ERROR[-OB_ERR_ONLY_EXECUTE_AND_DEBUG_PRIVILEGES_ARE_VALID_FOR_PROCEDURES] = @@ -7647,6 +9262,8 @@ static struct ObStrErrorInit { "ORA-02225: only EXECUTE and DEBUG privileges are valid for procedures"; ERROR_NAME[-OB_ERR_ONLY_EXECUTE_DEBUG_AND_UNDER_PRIVILEGES_ARE_VALID_FOR_TYPES] = "OB_ERR_ONLY_EXECUTE_DEBUG_AND_UNDER_PRIVILEGES_ARE_VALID_FOR_TYPES"; + ERROR_CAUSE[-OB_ERR_ONLY_EXECUTE_DEBUG_AND_UNDER_PRIVILEGES_ARE_VALID_FOR_TYPES] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ONLY_EXECUTE_DEBUG_AND_UNDER_PRIVILEGES_ARE_VALID_FOR_TYPES] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ONLY_EXECUTE_DEBUG_AND_UNDER_PRIVILEGES_ARE_VALID_FOR_TYPES] = -1; SQLSTATE[-OB_ERR_ONLY_EXECUTE_DEBUG_AND_UNDER_PRIVILEGES_ARE_VALID_FOR_TYPES] = "HY000"; STR_ERROR[-OB_ERR_ONLY_EXECUTE_DEBUG_AND_UNDER_PRIVILEGES_ARE_VALID_FOR_TYPES] = @@ -7659,6 +9276,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ONLY_EXECUTE_DEBUG_AND_UNDER_PRIVILEGES_ARE_VALID_FOR_TYPES] = "ORA-02305: only EXECUTE, DEBUG, and UNDER privileges are valid for types"; ERROR_NAME[-OB_ERR_ADMIN_OPTION_NOT_GRANTED_FOR_ROLE] = "OB_ERR_ADMIN_OPTION_NOT_GRANTED_FOR_ROLE"; + ERROR_CAUSE[-OB_ERR_ADMIN_OPTION_NOT_GRANTED_FOR_ROLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ADMIN_OPTION_NOT_GRANTED_FOR_ROLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ADMIN_OPTION_NOT_GRANTED_FOR_ROLE] = -1; SQLSTATE[-OB_ERR_ADMIN_OPTION_NOT_GRANTED_FOR_ROLE] = "HY000"; STR_ERROR[-OB_ERR_ADMIN_OPTION_NOT_GRANTED_FOR_ROLE] = "ADMIN option not granted for role"; @@ -7668,6 +9287,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ADMIN_OPTION_NOT_GRANTED_FOR_ROLE] = "ORA-01932: ADMIN option not granted for role '%.*s'"; ERROR_NAME[-OB_ERR_USER_OR_ROLE_DOES_NOT_EXIST] = "OB_ERR_USER_OR_ROLE_DOES_NOT_EXIST"; + ERROR_CAUSE[-OB_ERR_USER_OR_ROLE_DOES_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_USER_OR_ROLE_DOES_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_USER_OR_ROLE_DOES_NOT_EXIST] = -1; SQLSTATE[-OB_ERR_USER_OR_ROLE_DOES_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_USER_OR_ROLE_DOES_NOT_EXIST] = "user or role does not exist"; @@ -7676,6 +9297,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_USER_OR_ROLE_DOES_NOT_EXIST] = "ORA-01917: user or role does not exist"; ORACLE_STR_USER_ERROR[-OB_ERR_USER_OR_ROLE_DOES_NOT_EXIST] = "ORA-01917: user or role '%.*s' does not exist"; ERROR_NAME[-OB_ERR_MISSING_ON_KEYWORD] = "OB_ERR_MISSING_ON_KEYWORD"; + ERROR_CAUSE[-OB_ERR_MISSING_ON_KEYWORD] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MISSING_ON_KEYWORD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MISSING_ON_KEYWORD] = -1; SQLSTATE[-OB_ERR_MISSING_ON_KEYWORD] = "HY000"; STR_ERROR[-OB_ERR_MISSING_ON_KEYWORD] = "missing ON keyword"; @@ -7684,6 +9307,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_MISSING_ON_KEYWORD] = "ORA-00969: missing ON keyword"; ORACLE_STR_USER_ERROR[-OB_ERR_MISSING_ON_KEYWORD] = "ORA-00969: missing ON keyword"; ERROR_NAME[-OB_ERR_NO_GRANT_OPTION] = "OB_ERR_NO_GRANT_OPTION"; + ERROR_CAUSE[-OB_ERR_NO_GRANT_OPTION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_GRANT_OPTION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_GRANT_OPTION] = -1; SQLSTATE[-OB_ERR_NO_GRANT_OPTION] = "HY000"; STR_ERROR[-OB_ERR_NO_GRANT_OPTION] = "grant option does not exists"; @@ -7693,6 +9318,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NO_GRANT_OPTION] = "ORA-01720: grant option does not exist for '%.*s.%.*s'"; ERROR_NAME[-OB_ERR_ALTER_INDEX_AND_EXECUTE_NOT_ALLOWED_FOR_VIEWS] = "OB_ERR_ALTER_INDEX_AND_EXECUTE_NOT_ALLOWED_FOR_VIEWS"; + ERROR_CAUSE[-OB_ERR_ALTER_INDEX_AND_EXECUTE_NOT_ALLOWED_FOR_VIEWS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ALTER_INDEX_AND_EXECUTE_NOT_ALLOWED_FOR_VIEWS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ALTER_INDEX_AND_EXECUTE_NOT_ALLOWED_FOR_VIEWS] = -1; SQLSTATE[-OB_ERR_ALTER_INDEX_AND_EXECUTE_NOT_ALLOWED_FOR_VIEWS] = "HY000"; STR_ERROR[-OB_ERR_ALTER_INDEX_AND_EXECUTE_NOT_ALLOWED_FOR_VIEWS] = "ALTER, INDEX and EXECUTE not allowed for views"; @@ -7704,6 +9331,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ALTER_INDEX_AND_EXECUTE_NOT_ALLOWED_FOR_VIEWS] = "ORA-02204: ALTER, INDEX and EXECUTE not allowed for views"; ERROR_NAME[-OB_ERR_CIRCULAR_ROLE_GRANT_DETECTED] = "OB_ERR_CIRCULAR_ROLE_GRANT_DETECTED"; + ERROR_CAUSE[-OB_ERR_CIRCULAR_ROLE_GRANT_DETECTED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CIRCULAR_ROLE_GRANT_DETECTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CIRCULAR_ROLE_GRANT_DETECTED] = -1; SQLSTATE[-OB_ERR_CIRCULAR_ROLE_GRANT_DETECTED] = "HY000"; STR_ERROR[-OB_ERR_CIRCULAR_ROLE_GRANT_DETECTED] = "circular role grant detected"; @@ -7712,6 +9341,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CIRCULAR_ROLE_GRANT_DETECTED] = "ORA-01934: circular role grant detected"; ORACLE_STR_USER_ERROR[-OB_ERR_CIRCULAR_ROLE_GRANT_DETECTED] = "ORA-01934: circular role grant detected"; ERROR_NAME[-OB_ERR_INVALID_PRIVILEGE_ON_DIRECTORIES] = "OB_ERR_INVALID_PRIVILEGE_ON_DIRECTORIES"; + ERROR_CAUSE[-OB_ERR_INVALID_PRIVILEGE_ON_DIRECTORIES] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_PRIVILEGE_ON_DIRECTORIES] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_PRIVILEGE_ON_DIRECTORIES] = -1; SQLSTATE[-OB_ERR_INVALID_PRIVILEGE_ON_DIRECTORIES] = "HY000"; STR_ERROR[-OB_ERR_INVALID_PRIVILEGE_ON_DIRECTORIES] = "invalid privilege on directories"; @@ -7720,6 +9351,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_PRIVILEGE_ON_DIRECTORIES] = "ORA-22928: invalid privilege on directories"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_PRIVILEGE_ON_DIRECTORIES] = "ORA-22928: invalid privilege on directories"; ERROR_NAME[-OB_ERR_DIRECTORY_ACCESS_DENIED] = "OB_ERR_DIRECTORY_ACCESS_DENIED"; + ERROR_CAUSE[-OB_ERR_DIRECTORY_ACCESS_DENIED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DIRECTORY_ACCESS_DENIED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DIRECTORY_ACCESS_DENIED] = -1; SQLSTATE[-OB_ERR_DIRECTORY_ACCESS_DENIED] = "HY000"; STR_ERROR[-OB_ERR_DIRECTORY_ACCESS_DENIED] = "directory access denied"; @@ -7728,6 +9361,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DIRECTORY_ACCESS_DENIED] = "ORA-29289: directory access denied"; ORACLE_STR_USER_ERROR[-OB_ERR_DIRECTORY_ACCESS_DENIED] = "ORA-29289: directory access denied"; ERROR_NAME[-OB_ERR_MISSING_OR_INVALID_ROLE_NAME] = "OB_ERR_MISSING_OR_INVALID_ROLE_NAME"; + ERROR_CAUSE[-OB_ERR_MISSING_OR_INVALID_ROLE_NAME] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MISSING_OR_INVALID_ROLE_NAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MISSING_OR_INVALID_ROLE_NAME] = -1; SQLSTATE[-OB_ERR_MISSING_OR_INVALID_ROLE_NAME] = "HY000"; STR_ERROR[-OB_ERR_MISSING_OR_INVALID_ROLE_NAME] = "missing or invalid role name"; @@ -7736,6 +9371,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_MISSING_OR_INVALID_ROLE_NAME] = "ORA-01937: missing or invalid role name"; ORACLE_STR_USER_ERROR[-OB_ERR_MISSING_OR_INVALID_ROLE_NAME] = "ORA-01937: missing or invalid role name"; ERROR_NAME[-OB_ERR_ROLE_NOT_GRANTED_OR_DOES_NOT_EXIST] = "OB_ERR_ROLE_NOT_GRANTED_OR_DOES_NOT_EXIST"; + ERROR_CAUSE[-OB_ERR_ROLE_NOT_GRANTED_OR_DOES_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ROLE_NOT_GRANTED_OR_DOES_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ROLE_NOT_GRANTED_OR_DOES_NOT_EXIST] = -1; SQLSTATE[-OB_ERR_ROLE_NOT_GRANTED_OR_DOES_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_ROLE_NOT_GRANTED_OR_DOES_NOT_EXIST] = "role not granted or does not exist"; @@ -7745,6 +9382,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ROLE_NOT_GRANTED_OR_DOES_NOT_EXIST] = "ORA-01924: role '%.*s' not granted or does not exist"; ERROR_NAME[-OB_ERR_DEFAULT_ROLE_NOT_GRANTED_TO_USER] = "OB_ERR_DEFAULT_ROLE_NOT_GRANTED_TO_USER"; + ERROR_CAUSE[-OB_ERR_DEFAULT_ROLE_NOT_GRANTED_TO_USER] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DEFAULT_ROLE_NOT_GRANTED_TO_USER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DEFAULT_ROLE_NOT_GRANTED_TO_USER] = -1; SQLSTATE[-OB_ERR_DEFAULT_ROLE_NOT_GRANTED_TO_USER] = "HY000"; STR_ERROR[-OB_ERR_DEFAULT_ROLE_NOT_GRANTED_TO_USER] = "DEFAULT ROLE not granted to user"; @@ -7754,6 +9393,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DEFAULT_ROLE_NOT_GRANTED_TO_USER] = "ORA-01955: DEFAULT ROLE '%.*s' not granted to user"; ERROR_NAME[-OB_ERR_ROLE_NOT_GRANTED_TO] = "OB_ERR_ROLE_NOT_GRANTED_TO"; + ERROR_CAUSE[-OB_ERR_ROLE_NOT_GRANTED_TO] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ROLE_NOT_GRANTED_TO] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ROLE_NOT_GRANTED_TO] = -1; SQLSTATE[-OB_ERR_ROLE_NOT_GRANTED_TO] = "HY000"; STR_ERROR[-OB_ERR_ROLE_NOT_GRANTED_TO] = "ROLE not granted to"; @@ -7762,6 +9403,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_ROLE_NOT_GRANTED_TO] = "ORA-01951: ROLE not granted to"; ORACLE_STR_USER_ERROR[-OB_ERR_ROLE_NOT_GRANTED_TO] = "ORA-01951: ROLE '%.*s' not granted to '%.*s'"; ERROR_NAME[-OB_ERR_CANNOT_GRANT_TO_A_ROLE_WITH_GRANT_OPTION] = "OB_ERR_CANNOT_GRANT_TO_A_ROLE_WITH_GRANT_OPTION"; + ERROR_CAUSE[-OB_ERR_CANNOT_GRANT_TO_A_ROLE_WITH_GRANT_OPTION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CANNOT_GRANT_TO_A_ROLE_WITH_GRANT_OPTION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CANNOT_GRANT_TO_A_ROLE_WITH_GRANT_OPTION] = -1; SQLSTATE[-OB_ERR_CANNOT_GRANT_TO_A_ROLE_WITH_GRANT_OPTION] = "HY000"; STR_ERROR[-OB_ERR_CANNOT_GRANT_TO_A_ROLE_WITH_GRANT_OPTION] = "cannot GRANT to a role WITH GRANT OPTION"; @@ -7772,6 +9415,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CANNOT_GRANT_TO_A_ROLE_WITH_GRANT_OPTION] = "ORA-01926: cannot GRANT to a role WITH GRANT OPTION"; ERROR_NAME[-OB_ERR_DUPLICATE_USERNAME_IN_LIST] = "OB_ERR_DUPLICATE_USERNAME_IN_LIST"; + ERROR_CAUSE[-OB_ERR_DUPLICATE_USERNAME_IN_LIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DUPLICATE_USERNAME_IN_LIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DUPLICATE_USERNAME_IN_LIST] = -1; SQLSTATE[-OB_ERR_DUPLICATE_USERNAME_IN_LIST] = "HY000"; STR_ERROR[-OB_ERR_DUPLICATE_USERNAME_IN_LIST] = "duplicate username in list"; @@ -7780,6 +9425,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DUPLICATE_USERNAME_IN_LIST] = "ORA-01700: duplicate username in list"; ORACLE_STR_USER_ERROR[-OB_ERR_DUPLICATE_USERNAME_IN_LIST] = "ORA-01700: duplicate username in list"; ERROR_NAME[-OB_ERR_CANNOT_GRANT_STRING_TO_A_ROLE] = "OB_ERR_CANNOT_GRANT_STRING_TO_A_ROLE"; + ERROR_CAUSE[-OB_ERR_CANNOT_GRANT_STRING_TO_A_ROLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CANNOT_GRANT_STRING_TO_A_ROLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CANNOT_GRANT_STRING_TO_A_ROLE] = -1; SQLSTATE[-OB_ERR_CANNOT_GRANT_STRING_TO_A_ROLE] = "HY000"; STR_ERROR[-OB_ERR_CANNOT_GRANT_STRING_TO_A_ROLE] = "cannot grant string to a role"; @@ -7789,6 +9436,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CANNOT_GRANT_STRING_TO_A_ROLE] = "ORA-01931: cannot grant %.*s to a role"; ERROR_NAME[-OB_ERR_CASCADE_CONSTRAINTS_MUST_BE_SPECIFIED_TO_PERFORM_THIS_REVOKE] = "OB_ERR_CASCADE_CONSTRAINTS_MUST_BE_SPECIFIED_TO_PERFORM_THIS_REVOKE"; + ERROR_CAUSE[-OB_ERR_CASCADE_CONSTRAINTS_MUST_BE_SPECIFIED_TO_PERFORM_THIS_REVOKE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CASCADE_CONSTRAINTS_MUST_BE_SPECIFIED_TO_PERFORM_THIS_REVOKE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CASCADE_CONSTRAINTS_MUST_BE_SPECIFIED_TO_PERFORM_THIS_REVOKE] = -1; SQLSTATE[-OB_ERR_CASCADE_CONSTRAINTS_MUST_BE_SPECIFIED_TO_PERFORM_THIS_REVOKE] = "HY000"; STR_ERROR[-OB_ERR_CASCADE_CONSTRAINTS_MUST_BE_SPECIFIED_TO_PERFORM_THIS_REVOKE] = @@ -7802,6 +9451,8 @@ static struct ObStrErrorInit { "ORA-01981: CASCADE CONSTRAINTS must be specified to perform this revoke"; ERROR_NAME[-OB_ERR_YOU_MAY_NOT_REVOKE_PRIVILEGES_FROM_YOURSELF] = "OB_ERR_YOU_MAY_NOT_REVOKE_PRIVILEGES_FROM_YOURSELF"; + ERROR_CAUSE[-OB_ERR_YOU_MAY_NOT_REVOKE_PRIVILEGES_FROM_YOURSELF] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_YOU_MAY_NOT_REVOKE_PRIVILEGES_FROM_YOURSELF] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_YOU_MAY_NOT_REVOKE_PRIVILEGES_FROM_YOURSELF] = -1; SQLSTATE[-OB_ERR_YOU_MAY_NOT_REVOKE_PRIVILEGES_FROM_YOURSELF] = "HY000"; STR_ERROR[-OB_ERR_YOU_MAY_NOT_REVOKE_PRIVILEGES_FROM_YOURSELF] = @@ -7814,6 +9465,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_YOU_MAY_NOT_REVOKE_PRIVILEGES_FROM_YOURSELF] = "ORA-01749: you may not GRANT/REVOKE privileges to/from yourself"; ERROR_NAME[-OB_ERR_SP_ALREADY_EXISTS] = "OB_ERR_SP_ALREADY_EXISTS"; + ERROR_CAUSE[-OB_ERR_SP_ALREADY_EXISTS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_ALREADY_EXISTS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_ALREADY_EXISTS] = ER_SP_ALREADY_EXISTS; SQLSTATE[-OB_ERR_SP_ALREADY_EXISTS] = "42000"; STR_ERROR[-OB_ERR_SP_ALREADY_EXISTS] = "procedure/function already exists"; @@ -7824,6 +9477,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SP_ALREADY_EXISTS] = "ORA-00600: internal error code, arguments: -5541, %s %.*s already exists"; ERROR_NAME[-OB_ERR_SP_DOES_NOT_EXIST] = "OB_ERR_SP_DOES_NOT_EXIST"; + ERROR_CAUSE[-OB_ERR_SP_DOES_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_DOES_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_DOES_NOT_EXIST] = ER_SP_DOES_NOT_EXIST; SQLSTATE[-OB_ERR_SP_DOES_NOT_EXIST] = "42000"; STR_ERROR[-OB_ERR_SP_DOES_NOT_EXIST] = "procedure/function does not exist"; @@ -7834,6 +9489,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SP_DOES_NOT_EXIST] = "ORA-00600: internal error code, arguments: -5542, %s %.*s.%.*s does not exist"; ERROR_NAME[-OB_ERR_SP_UNDECLARED_VAR] = "OB_ERR_SP_UNDECLARED_VAR"; + ERROR_CAUSE[-OB_ERR_SP_UNDECLARED_VAR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_UNDECLARED_VAR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_UNDECLARED_VAR] = ER_SP_UNDECLARED_VAR; SQLSTATE[-OB_ERR_SP_UNDECLARED_VAR] = "42000"; STR_ERROR[-OB_ERR_SP_UNDECLARED_VAR] = "Undeclared variable"; @@ -7842,6 +9499,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SP_UNDECLARED_VAR] = "PLS-00201: identifier must be declared"; ORACLE_STR_USER_ERROR[-OB_ERR_SP_UNDECLARED_VAR] = "PLS-00201: identifier '%.*s' must be declared"; ERROR_NAME[-OB_ERR_SP_UNDECLARED_TYPE] = "OB_ERR_SP_UNDECLARED_TYPE"; + ERROR_CAUSE[-OB_ERR_SP_UNDECLARED_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_UNDECLARED_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_UNDECLARED_TYPE] = ER_SP_UNDECLARED_VAR; SQLSTATE[-OB_ERR_SP_UNDECLARED_TYPE] = "42000"; STR_ERROR[-OB_ERR_SP_UNDECLARED_TYPE] = "Undeclared type"; @@ -7851,6 +9510,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SP_UNDECLARED_TYPE] = "ORA-00600: internal error code, arguments: -5544, Undeclared type: %.*s"; ERROR_NAME[-OB_ERR_SP_COND_MISMATCH] = "OB_ERR_SP_COND_MISMATCH"; + ERROR_CAUSE[-OB_ERR_SP_COND_MISMATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_COND_MISMATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_COND_MISMATCH] = ER_SP_COND_MISMATCH; SQLSTATE[-OB_ERR_SP_COND_MISMATCH] = "42000"; STR_ERROR[-OB_ERR_SP_COND_MISMATCH] = "Undefined CONDITION"; @@ -7861,6 +9522,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SP_COND_MISMATCH] = "ORA-00600: internal error code, arguments: -5545, Undefined CONDITION: %.*s"; ERROR_NAME[-OB_ERR_SP_LILABEL_MISMATCH] = "OB_ERR_SP_LILABEL_MISMATCH"; + ERROR_CAUSE[-OB_ERR_SP_LILABEL_MISMATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_LILABEL_MISMATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_LILABEL_MISMATCH] = ER_SP_LILABEL_MISMATCH; SQLSTATE[-OB_ERR_SP_LILABEL_MISMATCH] = "42000"; STR_ERROR[-OB_ERR_SP_LILABEL_MISMATCH] = "no matching label"; @@ -7869,6 +9532,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SP_LILABEL_MISMATCH] = "PLS-00201: identifier must be declared"; ORACLE_STR_USER_ERROR[-OB_ERR_SP_LILABEL_MISMATCH] = "PLS-00201: identifier '%.*s' must be declared"; ERROR_NAME[-OB_ERR_SP_CURSOR_MISMATCH] = "OB_ERR_SP_CURSOR_MISMATCH"; + ERROR_CAUSE[-OB_ERR_SP_CURSOR_MISMATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_CURSOR_MISMATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_CURSOR_MISMATCH] = ER_SP_CURSOR_MISMATCH; SQLSTATE[-OB_ERR_SP_CURSOR_MISMATCH] = "42000"; STR_ERROR[-OB_ERR_SP_CURSOR_MISMATCH] = "Undefined CURSOR"; @@ -7878,6 +9543,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SP_CURSOR_MISMATCH] = "ORA-00600: internal error code, arguments: -5547, Undefined CURSOR: %.*s"; ERROR_NAME[-OB_ERR_SP_DUP_PARAM] = "OB_ERR_SP_DUP_PARAM"; + ERROR_CAUSE[-OB_ERR_SP_DUP_PARAM] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_DUP_PARAM] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_DUP_PARAM] = ER_SP_DUP_PARAM; SQLSTATE[-OB_ERR_SP_DUP_PARAM] = "42000"; STR_ERROR[-OB_ERR_SP_DUP_PARAM] = "Duplicate parameter"; @@ -7887,6 +9554,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SP_DUP_PARAM] = "ORA-00600: internal error code, arguments: -5548, Duplicate parameter: %.*s"; ERROR_NAME[-OB_ERR_SP_DUP_VAR] = "OB_ERR_SP_DUP_VAR"; + ERROR_CAUSE[-OB_ERR_SP_DUP_VAR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_DUP_VAR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_DUP_VAR] = ER_SP_DUP_VAR; SQLSTATE[-OB_ERR_SP_DUP_VAR] = "42000"; STR_ERROR[-OB_ERR_SP_DUP_VAR] = "Duplicate variable"; @@ -7896,6 +9565,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SP_DUP_VAR] = "ORA-00600: internal error code, arguments: -5549, Duplicate variable: %.*s"; ERROR_NAME[-OB_ERR_SP_DUP_TYPE] = "OB_ERR_SP_DUP_TYPE"; + ERROR_CAUSE[-OB_ERR_SP_DUP_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_DUP_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_DUP_TYPE] = ER_SP_DUP_PARAM; SQLSTATE[-OB_ERR_SP_DUP_TYPE] = "42000"; STR_ERROR[-OB_ERR_SP_DUP_TYPE] = "Duplicate type"; @@ -7905,6 +9576,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SP_DUP_TYPE] = "ORA-00600: internal error code, arguments: -5550, Duplicate type: %.*s"; ERROR_NAME[-OB_ERR_SP_DUP_CONDITION] = "OB_ERR_SP_DUP_CONDITION"; + ERROR_CAUSE[-OB_ERR_SP_DUP_CONDITION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_DUP_CONDITION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_DUP_CONDITION] = ER_SP_DUP_COND; SQLSTATE[-OB_ERR_SP_DUP_CONDITION] = "42000"; STR_ERROR[-OB_ERR_SP_DUP_CONDITION] = "Duplicate condition"; @@ -7915,6 +9588,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SP_DUP_CONDITION] = "ORA-00600: internal error code, arguments: -5551, Duplicate condition: %.*s"; ERROR_NAME[-OB_ERR_SP_DUP_LABEL] = "OB_ERR_SP_DUP_LABEL"; + ERROR_CAUSE[-OB_ERR_SP_DUP_LABEL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_DUP_LABEL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_DUP_LABEL] = ER_SP_DUP_PARAM; SQLSTATE[-OB_ERR_SP_DUP_LABEL] = "42000"; STR_ERROR[-OB_ERR_SP_DUP_LABEL] = "Duplicate label"; @@ -7924,6 +9599,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SP_DUP_LABEL] = "ORA-00600: internal error code, arguments: -5552, Duplicate label: %.*s"; ERROR_NAME[-OB_ERR_SP_DUP_CURSOR] = "OB_ERR_SP_DUP_CURSOR"; + ERROR_CAUSE[-OB_ERR_SP_DUP_CURSOR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_DUP_CURSOR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_DUP_CURSOR] = ER_SP_DUP_CURS; SQLSTATE[-OB_ERR_SP_DUP_CURSOR] = "42000"; STR_ERROR[-OB_ERR_SP_DUP_CURSOR] = "Duplicate cursor"; @@ -7933,6 +9610,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SP_DUP_CURSOR] = "ORA-00600: internal error code, arguments: -5553, Duplicate cursor: %.*s"; ERROR_NAME[-OB_ERR_SP_INVALID_FETCH_ARG] = "OB_ERR_SP_INVALID_FETCH_ARG"; + ERROR_CAUSE[-OB_ERR_SP_INVALID_FETCH_ARG] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_INVALID_FETCH_ARG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_INVALID_FETCH_ARG] = ER_SP_WRONG_NO_OF_FETCH_ARGS; SQLSTATE[-OB_ERR_SP_INVALID_FETCH_ARG] = "HY000"; STR_ERROR[-OB_ERR_SP_INVALID_FETCH_ARG] = "Incorrect number of FETCH variables"; @@ -7943,6 +9622,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SP_INVALID_FETCH_ARG] = "ORA-00600: internal error code, arguments: -5554, Incorrect number of FETCH variables"; ERROR_NAME[-OB_ERR_SP_WRONG_ARG_NUM] = "OB_ERR_SP_WRONG_ARG_NUM"; + ERROR_CAUSE[-OB_ERR_SP_WRONG_ARG_NUM] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_WRONG_ARG_NUM] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_WRONG_ARG_NUM] = ER_SP_WRONG_NO_OF_ARGS; SQLSTATE[-OB_ERR_SP_WRONG_ARG_NUM] = "42000"; STR_ERROR[-OB_ERR_SP_WRONG_ARG_NUM] = "Incorrect number of arguments"; @@ -7953,6 +9634,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SP_WRONG_ARG_NUM] = "ORA-00600: internal error code, arguments: -5555, Incorrect " "number of arguments for %s %s; expected %u, got %u"; ERROR_NAME[-OB_ERR_SP_UNHANDLED_EXCEPTION] = "OB_ERR_SP_UNHANDLED_EXCEPTION"; + ERROR_CAUSE[-OB_ERR_SP_UNHANDLED_EXCEPTION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_UNHANDLED_EXCEPTION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_UNHANDLED_EXCEPTION] = ER_SIGNAL_EXCEPTION; SQLSTATE[-OB_ERR_SP_UNHANDLED_EXCEPTION] = "HY000"; STR_ERROR[-OB_ERR_SP_UNHANDLED_EXCEPTION] = "Unhandled exception has occurred in PL"; @@ -7963,6 +9646,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SP_UNHANDLED_EXCEPTION] = "ORA-00600: internal error code, arguments: -5556, Unhandled user-defined exception condition"; ERROR_NAME[-OB_ERR_SP_BAD_CONDITION_TYPE] = "OB_ERR_SP_BAD_CONDITION_TYPE"; + ERROR_CAUSE[-OB_ERR_SP_BAD_CONDITION_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_BAD_CONDITION_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_BAD_CONDITION_TYPE] = ER_SIGNAL_BAD_CONDITION_TYPE; SQLSTATE[-OB_ERR_SP_BAD_CONDITION_TYPE] = "HY000"; STR_ERROR[-OB_ERR_SP_BAD_CONDITION_TYPE] = "SIGNAL/RESIGNAL can only use a CONDITION defined with SQLSTATE"; @@ -7974,6 +9659,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5557, SIGNAL/RESIGNAL can only use a CONDITION defined with " "SQLSTATE"; ERROR_NAME[-OB_ERR_PACKAGE_ALREADY_EXISTS] = "OB_ERR_PACKAGE_ALREADY_EXISTS"; + ERROR_CAUSE[-OB_ERR_PACKAGE_ALREADY_EXISTS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PACKAGE_ALREADY_EXISTS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PACKAGE_ALREADY_EXISTS] = -1; SQLSTATE[-OB_ERR_PACKAGE_ALREADY_EXISTS] = "42000"; STR_ERROR[-OB_ERR_PACKAGE_ALREADY_EXISTS] = "package already exists"; @@ -7984,6 +9671,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PACKAGE_ALREADY_EXISTS] = "ORA-00600: internal error code, arguments: -5558, %s \'%.*s.%.*s\' already exists"; ERROR_NAME[-OB_ERR_PACKAGE_DOSE_NOT_EXIST] = "OB_ERR_PACKAGE_DOSE_NOT_EXIST"; + ERROR_CAUSE[-OB_ERR_PACKAGE_DOSE_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PACKAGE_DOSE_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PACKAGE_DOSE_NOT_EXIST] = -1; SQLSTATE[-OB_ERR_PACKAGE_DOSE_NOT_EXIST] = "42000"; STR_ERROR[-OB_ERR_PACKAGE_DOSE_NOT_EXIST] = "package does not exist"; @@ -7994,6 +9683,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PACKAGE_DOSE_NOT_EXIST] = "ORA-00600: internal error code, arguments: -5559, %s \'%.*s.%.*s\' does not exist"; ERROR_NAME[-OB_EER_UNKNOWN_STMT_HANDLER] = "OB_EER_UNKNOWN_STMT_HANDLER"; + ERROR_CAUSE[-OB_EER_UNKNOWN_STMT_HANDLER] = "Internal Error"; + ERROR_SOLUTION[-OB_EER_UNKNOWN_STMT_HANDLER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_EER_UNKNOWN_STMT_HANDLER] = ER_UNKNOWN_STMT_HANDLER; SQLSTATE[-OB_EER_UNKNOWN_STMT_HANDLER] = "HY000"; STR_ERROR[-OB_EER_UNKNOWN_STMT_HANDLER] = "Unknown prepared statement handle"; @@ -8004,6 +9695,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_EER_UNKNOWN_STMT_HANDLER] = "ORA-00600: internal error code, arguments: -5560, Unknown prepared statement handle"; ERROR_NAME[-OB_ERR_INVALID_WINDOW_FUNC_USE] = "OB_ERR_INVALID_WINDOW_FUNC_USE"; + ERROR_CAUSE[-OB_ERR_INVALID_WINDOW_FUNC_USE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_WINDOW_FUNC_USE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_WINDOW_FUNC_USE] = -1; SQLSTATE[-OB_ERR_INVALID_WINDOW_FUNC_USE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_WINDOW_FUNC_USE] = "Invalid use of window function"; @@ -8014,6 +9707,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_WINDOW_FUNC_USE] = "ORA-00600: internal error code, arguments: -5561, Invalid use of window function"; ERROR_NAME[-OB_ERR_CONSTRAINT_DUPLICATE] = "OB_ERR_CONSTRAINT_DUPLICATE"; + ERROR_CAUSE[-OB_ERR_CONSTRAINT_DUPLICATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CONSTRAINT_DUPLICATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CONSTRAINT_DUPLICATE] = -1; SQLSTATE[-OB_ERR_CONSTRAINT_DUPLICATE] = "HY000"; STR_ERROR[-OB_ERR_CONSTRAINT_DUPLICATE] = "Duplicate constraint name"; @@ -8022,6 +9717,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CONSTRAINT_DUPLICATE] = "ORA-00001: unique constraint violated"; ORACLE_STR_USER_ERROR[-OB_ERR_CONSTRAINT_DUPLICATE] = "ORA-00001: unique constraint (%.*s) violated"; ERROR_NAME[-OB_ERR_CONTRAINT_NOT_FOUND] = "OB_ERR_CONTRAINT_NOT_FOUND"; + ERROR_CAUSE[-OB_ERR_CONTRAINT_NOT_FOUND] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CONTRAINT_NOT_FOUND] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CONTRAINT_NOT_FOUND] = -1; SQLSTATE[-OB_ERR_CONTRAINT_NOT_FOUND] = "HY000"; STR_ERROR[-OB_ERR_CONTRAINT_NOT_FOUND] = "Constraint not found"; @@ -8032,6 +9729,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CONTRAINT_NOT_FOUND] = "ORA-00600: internal error code, arguments: -5563, Constraint not found"; ERROR_NAME[-OB_ERR_ALTER_TABLE_ALTER_DUPLICATED_INDEX] = "OB_ERR_ALTER_TABLE_ALTER_DUPLICATED_INDEX"; + ERROR_CAUSE[-OB_ERR_ALTER_TABLE_ALTER_DUPLICATED_INDEX] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ALTER_TABLE_ALTER_DUPLICATED_INDEX] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ALTER_TABLE_ALTER_DUPLICATED_INDEX] = -1; SQLSTATE[-OB_ERR_ALTER_TABLE_ALTER_DUPLICATED_INDEX] = "HY000"; STR_ERROR[-OB_ERR_ALTER_TABLE_ALTER_DUPLICATED_INDEX] = "Duplicate alter index operations"; @@ -8042,6 +9741,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ALTER_TABLE_ALTER_DUPLICATED_INDEX] = "ORA-00600: internal error code, arguments: -5564, Duplicate alter index operations on column \'%.*s\'"; ERROR_NAME[-OB_EER_INVALID_ARGUMENT_FOR_LOGARITHM] = "OB_EER_INVALID_ARGUMENT_FOR_LOGARITHM"; + ERROR_CAUSE[-OB_EER_INVALID_ARGUMENT_FOR_LOGARITHM] = "Internal Error"; + ERROR_SOLUTION[-OB_EER_INVALID_ARGUMENT_FOR_LOGARITHM] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_EER_INVALID_ARGUMENT_FOR_LOGARITHM] = ER_INVALID_ARGUMENT_FOR_LOGARITHM; SQLSTATE[-OB_EER_INVALID_ARGUMENT_FOR_LOGARITHM] = "2201E"; STR_ERROR[-OB_EER_INVALID_ARGUMENT_FOR_LOGARITHM] = "Invalid argument for logarithm"; @@ -8052,6 +9753,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_EER_INVALID_ARGUMENT_FOR_LOGARITHM] = "ORA-00600: internal error code, arguments: -5565, Invalid argument for logarithm"; ERROR_NAME[-OB_ERR_REORGANIZE_OUTSIDE_RANGE] = "OB_ERR_REORGANIZE_OUTSIDE_RANGE"; + ERROR_CAUSE[-OB_ERR_REORGANIZE_OUTSIDE_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REORGANIZE_OUTSIDE_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REORGANIZE_OUTSIDE_RANGE] = ER_REORG_OUTSIDE_RANGE; SQLSTATE[-OB_ERR_REORGANIZE_OUTSIDE_RANGE] = "HY000"; STR_ERROR[-OB_ERR_REORGANIZE_OUTSIDE_RANGE] = "Reorganize of range partitions cannot change total ranges except " @@ -8066,6 +9769,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5566, Reorganize of range partitions cannot change total ranges " "except for last partition where it can extend the range"; ERROR_NAME[-OB_ER_SP_RECURSION_LIMIT] = "OB_ER_SP_RECURSION_LIMIT"; + ERROR_CAUSE[-OB_ER_SP_RECURSION_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_SP_RECURSION_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_SP_RECURSION_LIMIT] = ER_SP_RECURSION_LIMIT; SQLSTATE[-OB_ER_SP_RECURSION_LIMIT] = "HY000"; STR_ERROR[-OB_ER_SP_RECURSION_LIMIT] = "Recursive limit was exceeded"; @@ -8078,6 +9783,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5567, Recursive limit %ld (as set by the max_sp_recursion_depth " "variable) was exceeded for routine"; ERROR_NAME[-OB_ER_UNSUPPORTED_PS] = "OB_ER_UNSUPPORTED_PS"; + ERROR_CAUSE[-OB_ER_UNSUPPORTED_PS] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_UNSUPPORTED_PS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_UNSUPPORTED_PS] = ER_UNSUPPORTED_PS; SQLSTATE[-OB_ER_UNSUPPORTED_PS] = "HY000"; STR_ERROR[-OB_ER_UNSUPPORTED_PS] = "This command is not supported in the prepared statement protocol yet"; @@ -8088,6 +9795,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_UNSUPPORTED_PS] = "ORA-00600: internal error code, arguments: -5568, This command is " "not supported in the prepared statement protocol yet"; ERROR_NAME[-OB_ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG] = "OB_ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG"; + ERROR_CAUSE[-OB_ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG] = ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG; SQLSTATE[-OB_ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG] = "0A000"; STR_ERROR[-OB_ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG] = "stmt is not allowed in stored function"; @@ -8098,6 +9807,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG] = "ORA-00600: internal error code, arguments: -5569, %s is not allowed in stored function"; ERROR_NAME[-OB_ER_SP_NO_RECURSION] = "OB_ER_SP_NO_RECURSION"; + ERROR_CAUSE[-OB_ER_SP_NO_RECURSION] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_SP_NO_RECURSION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_SP_NO_RECURSION] = ER_SP_NO_RECURSION; SQLSTATE[-OB_ER_SP_NO_RECURSION] = "HY000"; STR_ERROR[-OB_ER_SP_NO_RECURSION] = "Recursive stored functions are not allowed."; @@ -8108,6 +9819,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_SP_NO_RECURSION] = "ORA-00600: internal error code, arguments: -5570, Recursive stored functions are not allowed."; ERROR_NAME[-OB_ER_SP_CASE_NOT_FOUND] = "OB_ER_SP_CASE_NOT_FOUND"; + ERROR_CAUSE[-OB_ER_SP_CASE_NOT_FOUND] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_SP_CASE_NOT_FOUND] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_SP_CASE_NOT_FOUND] = ER_SP_CASE_NOT_FOUND; SQLSTATE[-OB_ER_SP_CASE_NOT_FOUND] = "20000"; STR_ERROR[-OB_ER_SP_CASE_NOT_FOUND] = "Case not found for CASE statement"; @@ -8118,6 +9831,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_SP_CASE_NOT_FOUND] = "ORA-00600: internal error code, arguments: -5571, Case not found for CASE statement"; ERROR_NAME[-OB_ERR_INVALID_SPLIT_COUNT] = "OB_ERR_INVALID_SPLIT_COUNT"; + ERROR_CAUSE[-OB_ERR_INVALID_SPLIT_COUNT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_SPLIT_COUNT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_SPLIT_COUNT] = -1; SQLSTATE[-OB_ERR_INVALID_SPLIT_COUNT] = "HY000"; STR_ERROR[-OB_ERR_INVALID_SPLIT_COUNT] = "a partition may be split into exactly two new partitions"; @@ -8128,6 +9843,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_SPLIT_COUNT] = "ORA-00600: internal error code, arguments: -5572, a partition may be split into exactly two new partitions"; ERROR_NAME[-OB_ERR_INVALID_SPLIT_GRAMMAR] = "OB_ERR_INVALID_SPLIT_GRAMMAR"; + ERROR_CAUSE[-OB_ERR_INVALID_SPLIT_GRAMMAR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_SPLIT_GRAMMAR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_SPLIT_GRAMMAR] = -1; SQLSTATE[-OB_ERR_INVALID_SPLIT_GRAMMAR] = "HY000"; STR_ERROR[-OB_ERR_INVALID_SPLIT_GRAMMAR] = "this physical attribute may not be specified for a table partition"; @@ -8140,6 +9857,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5573, this physical attribute may not be specified for a table " "partition"; ERROR_NAME[-OB_ERR_MISS_VALUES] = "OB_ERR_MISS_VALUES"; + ERROR_CAUSE[-OB_ERR_MISS_VALUES] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MISS_VALUES] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MISS_VALUES] = -1; SQLSTATE[-OB_ERR_MISS_VALUES] = "HY000"; STR_ERROR[-OB_ERR_MISS_VALUES] = "missing VALUES keyword"; @@ -8148,6 +9867,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_MISS_VALUES] = "ORA-00926: missing VALUES keyword"; ORACLE_STR_USER_ERROR[-OB_ERR_MISS_VALUES] = "ORA-00926: missing VALUES keyword"; ERROR_NAME[-OB_ERR_MISS_AT_VALUES] = "OB_ERR_MISS_AT_VALUES"; + ERROR_CAUSE[-OB_ERR_MISS_AT_VALUES] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MISS_AT_VALUES] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MISS_AT_VALUES] = -1; SQLSTATE[-OB_ERR_MISS_AT_VALUES] = "HY000"; STR_ERROR[-OB_ERR_MISS_AT_VALUES] = "missing AT or VALUES keyword"; @@ -8158,6 +9879,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MISS_AT_VALUES] = "ORA-00600: internal error code, arguments: -5575, missing AT or VALUES keyword"; ERROR_NAME[-OB_ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG] = "OB_ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG"; + ERROR_CAUSE[-OB_ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG] = ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG; SQLSTATE[-OB_ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG] = "HY000"; STR_ERROR[-OB_ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG] = @@ -8172,6 +9895,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5576, Explicit or implicit commit is not allowed in stored " "function."; ERROR_NAME[-OB_PC_GET_LOCATION_ERROR] = "OB_PC_GET_LOCATION_ERROR"; + ERROR_CAUSE[-OB_PC_GET_LOCATION_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_PC_GET_LOCATION_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PC_GET_LOCATION_ERROR] = -1; SQLSTATE[-OB_PC_GET_LOCATION_ERROR] = "HY000"; STR_ERROR[-OB_PC_GET_LOCATION_ERROR] = "Plan cache get location failed"; @@ -8182,6 +9907,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PC_GET_LOCATION_ERROR] = "ORA-00600: internal error code, arguments: -5577, Plan cache get location failed"; ERROR_NAME[-OB_PC_LOCK_CONFLICT] = "OB_PC_LOCK_CONFLICT"; + ERROR_CAUSE[-OB_PC_LOCK_CONFLICT] = "Internal Error"; + ERROR_SOLUTION[-OB_PC_LOCK_CONFLICT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PC_LOCK_CONFLICT] = -1; SQLSTATE[-OB_PC_LOCK_CONFLICT] = "HY000"; STR_ERROR[-OB_PC_LOCK_CONFLICT] = "Plan cache lock conflict"; @@ -8192,6 +9919,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PC_LOCK_CONFLICT] = "ORA-00600: internal error code, arguments: -5578, Plan cache lock conflict"; ERROR_NAME[-OB_ER_SP_NO_RETSET] = "OB_ER_SP_NO_RETSET"; + ERROR_CAUSE[-OB_ER_SP_NO_RETSET] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_SP_NO_RETSET] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_SP_NO_RETSET] = ER_SP_NO_RETSET; SQLSTATE[-OB_ER_SP_NO_RETSET] = "0A000"; STR_ERROR[-OB_ER_SP_NO_RETSET] = "Not allowed to return a result set in pl function"; @@ -8202,6 +9931,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_SP_NO_RETSET] = "ORA-00600: internal error code, arguments: -5579, Not allowed to return a result set in pl function"; ERROR_NAME[-OB_ER_SP_NORETURNEND] = "OB_ER_SP_NORETURNEND"; + ERROR_CAUSE[-OB_ER_SP_NORETURNEND] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_SP_NORETURNEND] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_SP_NORETURNEND] = ER_SP_NORETURNEND; SQLSTATE[-OB_ER_SP_NORETURNEND] = "2F005"; STR_ERROR[-OB_ER_SP_NORETURNEND] = "FUNCTION ended without RETURN"; @@ -8212,6 +9943,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_SP_NORETURNEND] = "ORA-00600: internal error code, arguments: -5580, FUNCTION %s ended without RETURN"; ERROR_NAME[-OB_ERR_SP_DUP_HANDLER] = "OB_ERR_SP_DUP_HANDLER"; + ERROR_CAUSE[-OB_ERR_SP_DUP_HANDLER] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_DUP_HANDLER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_DUP_HANDLER] = ER_SP_DUP_HANDLER; SQLSTATE[-OB_ERR_SP_DUP_HANDLER] = "42000"; STR_ERROR[-OB_ERR_SP_DUP_HANDLER] = "Duplicate handler declared in the same block"; @@ -8222,6 +9955,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SP_DUP_HANDLER] = "ORA-00600: internal error code, arguments: -5581, Duplicate handler declared in the same block"; ERROR_NAME[-OB_ER_SP_NO_RECURSIVE_CREATE] = "OB_ER_SP_NO_RECURSIVE_CREATE"; + ERROR_CAUSE[-OB_ER_SP_NO_RECURSIVE_CREATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_SP_NO_RECURSIVE_CREATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_SP_NO_RECURSIVE_CREATE] = ER_SP_NO_RECURSIVE_CREATE; SQLSTATE[-OB_ER_SP_NO_RECURSIVE_CREATE] = "2F003"; STR_ERROR[-OB_ER_SP_NO_RECURSIVE_CREATE] = "Can\'t create a routine from within another routine"; @@ -8232,6 +9967,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_SP_NO_RECURSIVE_CREATE] = "ORA-00600: internal error code, arguments: -5582, Can\'t create a routine from within another routine"; ERROR_NAME[-OB_ER_SP_BADRETURN] = "OB_ER_SP_BADRETURN"; + ERROR_CAUSE[-OB_ER_SP_BADRETURN] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_SP_BADRETURN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_SP_BADRETURN] = ER_SP_BADRETURN; SQLSTATE[-OB_ER_SP_BADRETURN] = "42000"; STR_ERROR[-OB_ER_SP_BADRETURN] = "RETURN is only allowed in a FUNCTION"; @@ -8241,6 +9978,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_SP_BADRETURN] = "PLS-00372: In a procedure, RETURN statement cannot contain an expression"; ERROR_NAME[-OB_ER_SP_BAD_CURSOR_SELECT] = "OB_ER_SP_BAD_CURSOR_SELECT"; + ERROR_CAUSE[-OB_ER_SP_BAD_CURSOR_SELECT] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_SP_BAD_CURSOR_SELECT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_SP_BAD_CURSOR_SELECT] = ER_SP_BAD_CURSOR_SELECT; SQLSTATE[-OB_ER_SP_BAD_CURSOR_SELECT] = "42000"; STR_ERROR[-OB_ER_SP_BAD_CURSOR_SELECT] = "Cursor SELECT must not have INTO"; @@ -8251,6 +9990,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_SP_BAD_CURSOR_SELECT] = "ORA-00600: internal error code, arguments: -5584, Cursor SELECT must not have INTO"; ERROR_NAME[-OB_ER_SP_BAD_SQLSTATE] = "OB_ER_SP_BAD_SQLSTATE"; + ERROR_CAUSE[-OB_ER_SP_BAD_SQLSTATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_SP_BAD_SQLSTATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_SP_BAD_SQLSTATE] = ER_SP_BAD_SQLSTATE; SQLSTATE[-OB_ER_SP_BAD_SQLSTATE] = "42000"; STR_ERROR[-OB_ER_SP_BAD_SQLSTATE] = "Bad SQLSTATE"; @@ -8260,6 +10001,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_SP_BAD_SQLSTATE] = "ORA-00600: internal error code, arguments: -5585, Bad SQLSTATE: \'%.*s\'"; ERROR_NAME[-OB_ER_SP_VARCOND_AFTER_CURSHNDLR] = "OB_ER_SP_VARCOND_AFTER_CURSHNDLR"; + ERROR_CAUSE[-OB_ER_SP_VARCOND_AFTER_CURSHNDLR] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_SP_VARCOND_AFTER_CURSHNDLR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_SP_VARCOND_AFTER_CURSHNDLR] = ER_SP_VARCOND_AFTER_CURSHNDLR; SQLSTATE[-OB_ER_SP_VARCOND_AFTER_CURSHNDLR] = "42000"; STR_ERROR[-OB_ER_SP_VARCOND_AFTER_CURSHNDLR] = @@ -8274,6 +10017,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5586, Variable or condition declaration after cursor or handler " "declaration"; ERROR_NAME[-OB_ER_SP_CURSOR_AFTER_HANDLER] = "OB_ER_SP_CURSOR_AFTER_HANDLER"; + ERROR_CAUSE[-OB_ER_SP_CURSOR_AFTER_HANDLER] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_SP_CURSOR_AFTER_HANDLER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_SP_CURSOR_AFTER_HANDLER] = ER_SP_CURSOR_AFTER_HANDLER; SQLSTATE[-OB_ER_SP_CURSOR_AFTER_HANDLER] = "42000"; STR_ERROR[-OB_ER_SP_CURSOR_AFTER_HANDLER] = "Cursor declaration after handler declaration"; @@ -8284,6 +10029,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_SP_CURSOR_AFTER_HANDLER] = "ORA-00600: internal error code, arguments: -5587, Cursor declaration after handler declaration"; ERROR_NAME[-OB_ER_SP_WRONG_NAME] = "OB_ER_SP_WRONG_NAME"; + ERROR_CAUSE[-OB_ER_SP_WRONG_NAME] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_SP_WRONG_NAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_SP_WRONG_NAME] = ER_SP_WRONG_NAME; SQLSTATE[-OB_ER_SP_WRONG_NAME] = "42000"; STR_ERROR[-OB_ER_SP_WRONG_NAME] = "Incorrect routine name"; @@ -8293,6 +10040,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_SP_WRONG_NAME] = "ORA-00600: internal error code, arguments: -5588, Incorrect routine name \'%.*s\'"; ERROR_NAME[-OB_ER_SP_CURSOR_ALREADY_OPEN] = "OB_ER_SP_CURSOR_ALREADY_OPEN"; + ERROR_CAUSE[-OB_ER_SP_CURSOR_ALREADY_OPEN] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_SP_CURSOR_ALREADY_OPEN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_SP_CURSOR_ALREADY_OPEN] = ER_SP_CURSOR_ALREADY_OPEN; SQLSTATE[-OB_ER_SP_CURSOR_ALREADY_OPEN] = "24000"; STR_ERROR[-OB_ER_SP_CURSOR_ALREADY_OPEN] = "Cursor is already open"; @@ -8303,6 +10052,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_SP_CURSOR_ALREADY_OPEN] = "ORA-00600: internal error code, arguments: -5589, Cursor is already open"; ERROR_NAME[-OB_ER_SP_CURSOR_NOT_OPEN] = "OB_ER_SP_CURSOR_NOT_OPEN"; + ERROR_CAUSE[-OB_ER_SP_CURSOR_NOT_OPEN] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_SP_CURSOR_NOT_OPEN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_SP_CURSOR_NOT_OPEN] = ER_SP_CURSOR_NOT_OPEN; SQLSTATE[-OB_ER_SP_CURSOR_NOT_OPEN] = "24000"; STR_ERROR[-OB_ER_SP_CURSOR_NOT_OPEN] = "Cursor is not open"; @@ -8313,6 +10064,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_SP_CURSOR_NOT_OPEN] = "ORA-00600: internal error code, arguments: -5590, Cursor is not open"; ERROR_NAME[-OB_ER_SP_CANT_SET_AUTOCOMMIT] = "OB_ER_SP_CANT_SET_AUTOCOMMIT"; + ERROR_CAUSE[-OB_ER_SP_CANT_SET_AUTOCOMMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_SP_CANT_SET_AUTOCOMMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_SP_CANT_SET_AUTOCOMMIT] = ER_SP_CANT_SET_AUTOCOMMIT; SQLSTATE[-OB_ER_SP_CANT_SET_AUTOCOMMIT] = "HY000"; STR_ERROR[-OB_ER_SP_CANT_SET_AUTOCOMMIT] = "Not allowed to set autocommit from a stored function"; @@ -8323,6 +10076,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_SP_CANT_SET_AUTOCOMMIT] = "ORA-00600: internal error code, arguments: -5591, Not allowed to set autocommit from a stored function"; ERROR_NAME[-OB_ER_SP_NOT_VAR_ARG] = "OB_ER_SP_NOT_VAR_ARG"; + ERROR_CAUSE[-OB_ER_SP_NOT_VAR_ARG] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_SP_NOT_VAR_ARG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_SP_NOT_VAR_ARG] = ER_SP_NOT_VAR_ARG; SQLSTATE[-OB_ER_SP_NOT_VAR_ARG] = "42000"; STR_ERROR[-OB_ER_SP_NOT_VAR_ARG] = "OUT or INOUT argument for routine is not a variable"; @@ -8333,6 +10088,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_SP_NOT_VAR_ARG] = "ORA-00600: internal error code, arguments: -5592, OUT or INOUT argument %d for routine %.*s is not a variable"; ERROR_NAME[-OB_ER_SP_LILABEL_MISMATCH] = "OB_ER_SP_LILABEL_MISMATCH"; + ERROR_CAUSE[-OB_ER_SP_LILABEL_MISMATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_SP_LILABEL_MISMATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_SP_LILABEL_MISMATCH] = ER_SP_LILABEL_MISMATCH; SQLSTATE[-OB_ER_SP_LILABEL_MISMATCH] = "42000"; STR_ERROR[-OB_ER_SP_LILABEL_MISMATCH] = "with no matching label"; @@ -8343,6 +10100,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_SP_LILABEL_MISMATCH] = "ORA-00600: internal error code, arguments: -5593, %s with no matching label: %s"; ERROR_NAME[-OB_ERR_TRUNCATE_ILLEGAL_FK] = "OB_ERR_TRUNCATE_ILLEGAL_FK"; + ERROR_CAUSE[-OB_ERR_TRUNCATE_ILLEGAL_FK] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TRUNCATE_ILLEGAL_FK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TRUNCATE_ILLEGAL_FK] = ER_TRUNCATE_ILLEGAL_FK; SQLSTATE[-OB_ERR_TRUNCATE_ILLEGAL_FK] = "42000"; STR_ERROR[-OB_ERR_TRUNCATE_ILLEGAL_FK] = "Cannot truncate a table referenced in a foreign key constraint"; @@ -8353,6 +10112,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TRUNCATE_ILLEGAL_FK] = "ORA-00600: internal error code, arguments: -5594, Cannot " "truncate a table referenced in a foreign key constraint %.*s"; ERROR_NAME[-OB_ERR_DUP_KEY] = "OB_ERR_DUP_KEY"; + ERROR_CAUSE[-OB_ERR_DUP_KEY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DUP_KEY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DUP_KEY] = ER_DUP_KEY; SQLSTATE[-OB_ERR_DUP_KEY] = "23000"; STR_ERROR[-OB_ERR_DUP_KEY] = "Can't write; duplicate key in table"; @@ -8361,6 +10122,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DUP_KEY] = "ORA-00001: unique constraint violated"; ORACLE_STR_USER_ERROR[-OB_ERR_DUP_KEY] = "ORA-00001: unique constraint (%.*s) violated"; ERROR_NAME[-OB_ER_INVALID_USE_OF_NULL] = "OB_ER_INVALID_USE_OF_NULL"; + ERROR_CAUSE[-OB_ER_INVALID_USE_OF_NULL] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_INVALID_USE_OF_NULL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_INVALID_USE_OF_NULL] = ER_INVALID_USE_OF_NULL; SQLSTATE[-OB_ER_INVALID_USE_OF_NULL] = "22004"; STR_ERROR[-OB_ER_INVALID_USE_OF_NULL] = "Invalid use of NULL value"; @@ -8371,6 +10134,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ER_INVALID_USE_OF_NULL] = "ORA-00600: internal error code, arguments: -5596, Invalid use of NULL value"; ERROR_NAME[-OB_ERR_SPLIT_LIST_LESS_VALUE] = "OB_ERR_SPLIT_LIST_LESS_VALUE"; + ERROR_CAUSE[-OB_ERR_SPLIT_LIST_LESS_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SPLIT_LIST_LESS_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SPLIT_LIST_LESS_VALUE] = -1; SQLSTATE[-OB_ERR_SPLIT_LIST_LESS_VALUE] = "HY000"; STR_ERROR[-OB_ERR_SPLIT_LIST_LESS_VALUE] = "last resulting partition cannot contain bounds"; @@ -8381,6 +10146,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SPLIT_LIST_LESS_VALUE] = "ORA-00600: internal error code, arguments: -5597, last resulting partition cannot contain bounds"; ERROR_NAME[-OB_ERR_ADD_PARTITION_TO_DEFAULT_LIST] = "OB_ERR_ADD_PARTITION_TO_DEFAULT_LIST"; + ERROR_CAUSE[-OB_ERR_ADD_PARTITION_TO_DEFAULT_LIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ADD_PARTITION_TO_DEFAULT_LIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ADD_PARTITION_TO_DEFAULT_LIST] = -1; SQLSTATE[-OB_ERR_ADD_PARTITION_TO_DEFAULT_LIST] = "HY000"; STR_ERROR[-OB_ERR_ADD_PARTITION_TO_DEFAULT_LIST] = "cannot add partition when DEFAULT partition exists"; @@ -8391,6 +10158,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ADD_PARTITION_TO_DEFAULT_LIST] = "ORA-00600: internal error code, arguments: -5598, cannot add partition when DEFAULT partition exists"; ERROR_NAME[-OB_ERR_SPLIT_INTO_ONE_PARTITION] = "OB_ERR_SPLIT_INTO_ONE_PARTITION"; + ERROR_CAUSE[-OB_ERR_SPLIT_INTO_ONE_PARTITION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SPLIT_INTO_ONE_PARTITION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SPLIT_INTO_ONE_PARTITION] = -1; SQLSTATE[-OB_ERR_SPLIT_INTO_ONE_PARTITION] = "HY000"; STR_ERROR[-OB_ERR_SPLIT_INTO_ONE_PARTITION] = "cannot split partition into one partition, use rename instead"; @@ -8402,6 +10171,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5599, cannot split partition into one partition, use rename " "instead"; ERROR_NAME[-OB_ERR_NO_TENANT_PRIVILEGE] = "OB_ERR_NO_TENANT_PRIVILEGE"; + ERROR_CAUSE[-OB_ERR_NO_TENANT_PRIVILEGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_TENANT_PRIVILEGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_TENANT_PRIVILEGE] = -1; SQLSTATE[-OB_ERR_NO_TENANT_PRIVILEGE] = "HY000"; STR_ERROR[-OB_ERR_NO_TENANT_PRIVILEGE] = "can not create user in sys tenant"; @@ -8412,6 +10183,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NO_TENANT_PRIVILEGE] = "ORA-00600: internal error code, arguments: -5600, can not create user %s in sys tenant, name %.*s"; ERROR_NAME[-OB_ERR_INVALID_PERCENTAGE] = "OB_ERR_INVALID_PERCENTAGE"; + ERROR_CAUSE[-OB_ERR_INVALID_PERCENTAGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_PERCENTAGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_PERCENTAGE] = -1; SQLSTATE[-OB_ERR_INVALID_PERCENTAGE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_PERCENTAGE] = "Percentage should between 1 and 99"; @@ -8422,6 +10195,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_PERCENTAGE] = "ORA-00600: internal error code, arguments: -5601, Percentage should between 1 and 99"; ERROR_NAME[-OB_ERR_COLLECT_HISTOGRAM] = "OB_ERR_COLLECT_HISTOGRAM"; + ERROR_CAUSE[-OB_ERR_COLLECT_HISTOGRAM] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_COLLECT_HISTOGRAM] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_COLLECT_HISTOGRAM] = -1; SQLSTATE[-OB_ERR_COLLECT_HISTOGRAM] = "HY000"; STR_ERROR[-OB_ERR_COLLECT_HISTOGRAM] = "Should collect histogram after major freeze"; @@ -8432,6 +10207,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_COLLECT_HISTOGRAM] = "ORA-00600: internal error code, arguments: -5602, Should collect histogram after major freeze"; ERROR_NAME[-OB_ER_TEMP_TABLE_IN_USE] = "OB_ER_TEMP_TABLE_IN_USE"; + ERROR_CAUSE[-OB_ER_TEMP_TABLE_IN_USE] = "Internal Error"; + ERROR_SOLUTION[-OB_ER_TEMP_TABLE_IN_USE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ER_TEMP_TABLE_IN_USE] = -1; SQLSTATE[-OB_ER_TEMP_TABLE_IN_USE] = "0A000"; STR_ERROR[-OB_ER_TEMP_TABLE_IN_USE] = "Attempt to create, alter or drop an index on temporary table already in use"; @@ -8444,6 +10221,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5603, Attempt to create, alter or drop an index on temporary " "table already in use"; ERROR_NAME[-OB_ERR_INVALID_NLS_PARAMETER_STRING] = "OB_ERR_INVALID_NLS_PARAMETER_STRING"; + ERROR_CAUSE[-OB_ERR_INVALID_NLS_PARAMETER_STRING] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_NLS_PARAMETER_STRING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_NLS_PARAMETER_STRING] = -1; SQLSTATE[-OB_ERR_INVALID_NLS_PARAMETER_STRING] = "HY000"; STR_ERROR[-OB_ERR_INVALID_NLS_PARAMETER_STRING] = "invalid NLS parameter string used in SQL function"; @@ -8454,6 +10233,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_NLS_PARAMETER_STRING] = "ORA-12702: invalid NLS parameter string used in SQL function"; ERROR_NAME[-OB_ERR_DATETIME_INTERVAL_PRECISION_OUT_OF_RANGE] = "OB_ERR_DATETIME_INTERVAL_PRECISION_OUT_OF_RANGE"; + ERROR_CAUSE[-OB_ERR_DATETIME_INTERVAL_PRECISION_OUT_OF_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DATETIME_INTERVAL_PRECISION_OUT_OF_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DATETIME_INTERVAL_PRECISION_OUT_OF_RANGE] = -1; SQLSTATE[-OB_ERR_DATETIME_INTERVAL_PRECISION_OUT_OF_RANGE] = "HY000"; STR_ERROR[-OB_ERR_DATETIME_INTERVAL_PRECISION_OUT_OF_RANGE] = "datetime/interval precision is out of range"; @@ -8464,6 +10245,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DATETIME_INTERVAL_PRECISION_OUT_OF_RANGE] = "ORA-30088: datetime/interval precision is out of range"; ERROR_NAME[-OB_ERR_CMD_NOT_PROPERLY_ENDED] = "OB_ERR_CMD_NOT_PROPERLY_ENDED"; + ERROR_CAUSE[-OB_ERR_CMD_NOT_PROPERLY_ENDED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CMD_NOT_PROPERLY_ENDED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CMD_NOT_PROPERLY_ENDED] = -1; SQLSTATE[-OB_ERR_CMD_NOT_PROPERLY_ENDED] = "HY000"; STR_ERROR[-OB_ERR_CMD_NOT_PROPERLY_ENDED] = "SQL command not properly ended"; @@ -8472,6 +10255,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CMD_NOT_PROPERLY_ENDED] = "ORA-00933: SQL command not properly ended"; ORACLE_STR_USER_ERROR[-OB_ERR_CMD_NOT_PROPERLY_ENDED] = "ORA-00933: SQL command not properly ended"; ERROR_NAME[-OB_ERR_INVALID_NUMBER_FORMAT_MODEL] = "OB_ERR_INVALID_NUMBER_FORMAT_MODEL"; + ERROR_CAUSE[-OB_ERR_INVALID_NUMBER_FORMAT_MODEL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_NUMBER_FORMAT_MODEL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_NUMBER_FORMAT_MODEL] = -1; SQLSTATE[-OB_ERR_INVALID_NUMBER_FORMAT_MODEL] = "42000"; STR_ERROR[-OB_ERR_INVALID_NUMBER_FORMAT_MODEL] = "invalid number format model"; @@ -8480,6 +10265,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_NUMBER_FORMAT_MODEL] = "ORA-01481: invalid number format model"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_NUMBER_FORMAT_MODEL] = "ORA-01481: invalid number format model"; ERROR_NAME[-OB_WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED] = "OB_WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED"; + ERROR_CAUSE[-OB_WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED] = "Internal Error"; + ERROR_SOLUTION[-OB_WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED] = ER_WRONG_FIELD_TERMINATORS; SQLSTATE[-OB_WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED] = "HY000"; STR_ERROR[-OB_WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED] = "Non-ASCII separator arguments are not fully supported"; @@ -8491,6 +10278,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED] = "ORA-00600: internal error code, arguments: -5609, Non-ASCII separator arguments are not fully supported"; ERROR_NAME[-OB_WARN_AMBIGUOUS_FIELD_TERM] = "OB_WARN_AMBIGUOUS_FIELD_TERM"; + ERROR_CAUSE[-OB_WARN_AMBIGUOUS_FIELD_TERM] = "Internal Error"; + ERROR_SOLUTION[-OB_WARN_AMBIGUOUS_FIELD_TERM] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WARN_AMBIGUOUS_FIELD_TERM] = ER_WRONG_FIELD_TERMINATORS; SQLSTATE[-OB_WARN_AMBIGUOUS_FIELD_TERM] = "HY000"; STR_ERROR[-OB_WARN_AMBIGUOUS_FIELD_TERM] = "First character of the FIELDS TERMINATED string is ambiguous; please " @@ -8505,6 +10294,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5610, First character of the FIELDS TERMINATED string is " "ambiguous; please use non-optional and non-empty FIELDS ENCLOSED BY"; ERROR_NAME[-OB_WARN_TOO_FEW_RECORDS] = "OB_WARN_TOO_FEW_RECORDS"; + ERROR_CAUSE[-OB_WARN_TOO_FEW_RECORDS] = "Internal Error"; + ERROR_SOLUTION[-OB_WARN_TOO_FEW_RECORDS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WARN_TOO_FEW_RECORDS] = ER_WARN_TOO_FEW_RECORDS; SQLSTATE[-OB_WARN_TOO_FEW_RECORDS] = "01000"; STR_ERROR[-OB_WARN_TOO_FEW_RECORDS] = "Row doesn't contain data for all columns"; @@ -8515,6 +10306,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_WARN_TOO_FEW_RECORDS] = "ORA-00600: internal error code, arguments: -5611, Row %ld doesn't contain data for all columns"; ERROR_NAME[-OB_WARN_TOO_MANY_RECORDS] = "OB_WARN_TOO_MANY_RECORDS"; + ERROR_CAUSE[-OB_WARN_TOO_MANY_RECORDS] = "Internal Error"; + ERROR_SOLUTION[-OB_WARN_TOO_MANY_RECORDS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_WARN_TOO_MANY_RECORDS] = ER_WARN_TOO_MANY_RECORDS; SQLSTATE[-OB_WARN_TOO_MANY_RECORDS] = "01000"; STR_ERROR[-OB_WARN_TOO_MANY_RECORDS] = "Row was truncated; it contained more data than there were input columns"; @@ -8527,6 +10320,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5612, Row %ld was truncated; it contained more data than there " "were input columns"; ERROR_NAME[-OB_ERR_TOO_MANY_VALUES] = "OB_ERR_TOO_MANY_VALUES"; + ERROR_CAUSE[-OB_ERR_TOO_MANY_VALUES] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_MANY_VALUES] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_MANY_VALUES] = -1; SQLSTATE[-OB_ERR_TOO_MANY_VALUES] = "HY000"; STR_ERROR[-OB_ERR_TOO_MANY_VALUES] = "too many values"; @@ -8535,6 +10330,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_TOO_MANY_VALUES] = "ORA-00913: too many values"; ORACLE_STR_USER_ERROR[-OB_ERR_TOO_MANY_VALUES] = "ORA-00913: too many values"; ERROR_NAME[-OB_ERR_NOT_ENOUGH_VALUES] = "OB_ERR_NOT_ENOUGH_VALUES"; + ERROR_CAUSE[-OB_ERR_NOT_ENOUGH_VALUES] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NOT_ENOUGH_VALUES] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NOT_ENOUGH_VALUES] = -1; SQLSTATE[-OB_ERR_NOT_ENOUGH_VALUES] = "HY000"; STR_ERROR[-OB_ERR_NOT_ENOUGH_VALUES] = "not enough values"; @@ -8543,6 +10340,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_NOT_ENOUGH_VALUES] = "ORA-00947: not enough values"; ORACLE_STR_USER_ERROR[-OB_ERR_NOT_ENOUGH_VALUES] = "ORA-00947: not enough values"; ERROR_NAME[-OB_ERR_MORE_THAN_ONE_ROW] = "OB_ERR_MORE_THAN_ONE_ROW"; + ERROR_CAUSE[-OB_ERR_MORE_THAN_ONE_ROW] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MORE_THAN_ONE_ROW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MORE_THAN_ONE_ROW] = -1; SQLSTATE[-OB_ERR_MORE_THAN_ONE_ROW] = "HY000"; STR_ERROR[-OB_ERR_MORE_THAN_ONE_ROW] = "single-row subquery returns more than one row"; @@ -8551,6 +10350,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_MORE_THAN_ONE_ROW] = "ORA-01427: single-row subquery returns more than one row"; ORACLE_STR_USER_ERROR[-OB_ERR_MORE_THAN_ONE_ROW] = "ORA-01427: single-row subquery returns more than one row"; ERROR_NAME[-OB_ERR_NOT_SUBQUERY] = "OB_ERR_NOT_SUBQUERY"; + ERROR_CAUSE[-OB_ERR_NOT_SUBQUERY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NOT_SUBQUERY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NOT_SUBQUERY] = -1; SQLSTATE[-OB_ERR_NOT_SUBQUERY] = "HY000"; STR_ERROR[-OB_ERR_NOT_SUBQUERY] = "UPDATE ... SET expression must be a subquery"; @@ -8559,6 +10360,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_NOT_SUBQUERY] = "ORA-01767: UPDATE ... SET expression must be a subquery"; ORACLE_STR_USER_ERROR[-OB_ERR_NOT_SUBQUERY] = "ORA-01767: UPDATE ... SET expression must be a subquery"; ERROR_NAME[-OB_INAPPROPRIATE_INTO] = "OB_INAPPROPRIATE_INTO"; + ERROR_CAUSE[-OB_INAPPROPRIATE_INTO] = "Internal Error"; + ERROR_SOLUTION[-OB_INAPPROPRIATE_INTO] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INAPPROPRIATE_INTO] = -1; SQLSTATE[-OB_INAPPROPRIATE_INTO] = "HY000"; STR_ERROR[-OB_INAPPROPRIATE_INTO] = "inappropriate INTO"; @@ -8567,6 +10370,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_INAPPROPRIATE_INTO] = "ORA-01744: inappropriate INTO"; ORACLE_STR_USER_ERROR[-OB_INAPPROPRIATE_INTO] = "ORA-01744: inappropriate INTO"; ERROR_NAME[-OB_ERR_TABLE_IS_REFERENCED] = "OB_ERR_TABLE_IS_REFERENCED"; + ERROR_CAUSE[-OB_ERR_TABLE_IS_REFERENCED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TABLE_IS_REFERENCED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TABLE_IS_REFERENCED] = ER_ROW_IS_REFERENCED; SQLSTATE[-OB_ERR_TABLE_IS_REFERENCED] = "23000"; STR_ERROR[-OB_ERR_TABLE_IS_REFERENCED] = "Cannot delete or update a parent row: a foreign key constraint fails"; @@ -8577,6 +10382,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TABLE_IS_REFERENCED] = "ORA-02292: integrity constraint violated - child record found"; ERROR_NAME[-OB_ERR_QUALIFIER_EXISTS_FOR_USING_COLUMN] = "OB_ERR_QUALIFIER_EXISTS_FOR_USING_COLUMN"; + ERROR_CAUSE[-OB_ERR_QUALIFIER_EXISTS_FOR_USING_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_QUALIFIER_EXISTS_FOR_USING_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_QUALIFIER_EXISTS_FOR_USING_COLUMN] = -1; SQLSTATE[-OB_ERR_QUALIFIER_EXISTS_FOR_USING_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_QUALIFIER_EXISTS_FOR_USING_COLUMN] = "Column part of using clause can not have qualifier"; @@ -8587,6 +10394,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_QUALIFIER_EXISTS_FOR_USING_COLUMN] = "ORA-25154: Column part of using clause can not have qualifier"; ERROR_NAME[-OB_ERR_OUTER_JOIN_NESTED] = "OB_ERR_OUTER_JOIN_NESTED"; + ERROR_CAUSE[-OB_ERR_OUTER_JOIN_NESTED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OUTER_JOIN_NESTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OUTER_JOIN_NESTED] = -1; SQLSTATE[-OB_ERR_OUTER_JOIN_NESTED] = "HY000"; STR_ERROR[-OB_ERR_OUTER_JOIN_NESTED] = "two tables cannot be outer-joined to each other"; @@ -8595,6 +10404,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_OUTER_JOIN_NESTED] = "ORA-01416: two tables cannot be outer-joined to each other"; ORACLE_STR_USER_ERROR[-OB_ERR_OUTER_JOIN_NESTED] = "ORA-01416: two tables cannot be outer-joined to each other"; ERROR_NAME[-OB_ERR_MULTI_OUTER_JOIN_TABLE] = "OB_ERR_MULTI_OUTER_JOIN_TABLE"; + ERROR_CAUSE[-OB_ERR_MULTI_OUTER_JOIN_TABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MULTI_OUTER_JOIN_TABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MULTI_OUTER_JOIN_TABLE] = -1; SQLSTATE[-OB_ERR_MULTI_OUTER_JOIN_TABLE] = "HY000"; STR_ERROR[-OB_ERR_MULTI_OUTER_JOIN_TABLE] = "a predicate may reference only one outer-joined table"; @@ -8605,6 +10416,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MULTI_OUTER_JOIN_TABLE] = "ORA-01468: a predicate may reference only one outer-joined table"; ERROR_NAME[-OB_ERR_OUTER_JOIN_ON_CORRELATION_COLUMN] = "OB_ERR_OUTER_JOIN_ON_CORRELATION_COLUMN"; + ERROR_CAUSE[-OB_ERR_OUTER_JOIN_ON_CORRELATION_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OUTER_JOIN_ON_CORRELATION_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OUTER_JOIN_ON_CORRELATION_COLUMN] = -1; SQLSTATE[-OB_ERR_OUTER_JOIN_ON_CORRELATION_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_OUTER_JOIN_ON_CORRELATION_COLUMN] = "an outer join cannot be specified on a correlation column"; @@ -8616,6 +10429,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_OUTER_JOIN_ON_CORRELATION_COLUMN] = "ORA-01705: an outer join cannot be specified on a correlation column"; ERROR_NAME[-OB_ERR_OUTER_JOIN_AMBIGUOUS] = "OB_ERR_OUTER_JOIN_AMBIGUOUS"; + ERROR_CAUSE[-OB_ERR_OUTER_JOIN_AMBIGUOUS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OUTER_JOIN_AMBIGUOUS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OUTER_JOIN_AMBIGUOUS] = -1; SQLSTATE[-OB_ERR_OUTER_JOIN_AMBIGUOUS] = "HY000"; STR_ERROR[-OB_ERR_OUTER_JOIN_AMBIGUOUS] = "outer join operator (+) not allowed in operand of OR or IN"; @@ -8626,6 +10441,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_OUTER_JOIN_AMBIGUOUS] = "ORA-01719: outer join operator (+) not allowed in operand of OR or IN"; ERROR_NAME[-OB_ERR_OUTER_JOIN_WITH_SUBQUERY] = "OB_ERR_OUTER_JOIN_WITH_SUBQUERY"; + ERROR_CAUSE[-OB_ERR_OUTER_JOIN_WITH_SUBQUERY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OUTER_JOIN_WITH_SUBQUERY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OUTER_JOIN_WITH_SUBQUERY] = -1; SQLSTATE[-OB_ERR_OUTER_JOIN_WITH_SUBQUERY] = "HY000"; STR_ERROR[-OB_ERR_OUTER_JOIN_WITH_SUBQUERY] = "a column may not be outer-joined to a subquery"; @@ -8635,6 +10452,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_OUTER_JOIN_WITH_SUBQUERY] = "ORA-01799: a column may not be outer-joined to a subquery"; ERROR_NAME[-OB_ERR_OUTER_JOIN_WITH_ANSI_JOIN] = "OB_ERR_OUTER_JOIN_WITH_ANSI_JOIN"; + ERROR_CAUSE[-OB_ERR_OUTER_JOIN_WITH_ANSI_JOIN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OUTER_JOIN_WITH_ANSI_JOIN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OUTER_JOIN_WITH_ANSI_JOIN] = -1; SQLSTATE[-OB_ERR_OUTER_JOIN_WITH_ANSI_JOIN] = "HY000"; STR_ERROR[-OB_ERR_OUTER_JOIN_WITH_ANSI_JOIN] = "old style outer join (+) cannot be used with ANSI joins"; @@ -8645,6 +10464,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_OUTER_JOIN_WITH_ANSI_JOIN] = "ORA-25156: old style outer join (+) cannot be used with ANSI joins"; ERROR_NAME[-OB_ERR_OUTER_JOIN_NOT_ALLOWED] = "OB_ERR_OUTER_JOIN_NOT_ALLOWED"; + ERROR_CAUSE[-OB_ERR_OUTER_JOIN_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OUTER_JOIN_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OUTER_JOIN_NOT_ALLOWED] = -1; SQLSTATE[-OB_ERR_OUTER_JOIN_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_ERR_OUTER_JOIN_NOT_ALLOWED] = "outer join operator (+) is not allowed here"; @@ -8653,6 +10474,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_OUTER_JOIN_NOT_ALLOWED] = "ORA-30563: outer join operator (+) is not allowed here"; ORACLE_STR_USER_ERROR[-OB_ERR_OUTER_JOIN_NOT_ALLOWED] = "ORA-30563: outer join operator (+) is not allowed here"; ERROR_NAME[-OB_SCHEMA_EAGAIN] = "OB_SCHEMA_EAGAIN"; + ERROR_CAUSE[-OB_SCHEMA_EAGAIN] = "Internal Error"; + ERROR_SOLUTION[-OB_SCHEMA_EAGAIN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SCHEMA_EAGAIN] = -1; SQLSTATE[-OB_SCHEMA_EAGAIN] = "HY000"; STR_ERROR[-OB_SCHEMA_EAGAIN] = "Schema try again"; @@ -8661,6 +10484,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_SCHEMA_EAGAIN] = "ORA-00600: internal error code, arguments: -5627, Schema try again"; ORACLE_STR_USER_ERROR[-OB_SCHEMA_EAGAIN] = "ORA-00600: internal error code, arguments: -5627, Schema try again"; ERROR_NAME[-OB_ERR_ZERO_LEN_COL] = "OB_ERR_ZERO_LEN_COL"; + ERROR_CAUSE[-OB_ERR_ZERO_LEN_COL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ZERO_LEN_COL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ZERO_LEN_COL] = -1; SQLSTATE[-OB_ERR_ZERO_LEN_COL] = "HY000"; STR_ERROR[-OB_ERR_ZERO_LEN_COL] = "zero-length columns are not allowed"; @@ -8669,6 +10494,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_ZERO_LEN_COL] = "ORA-01723: zero-length columns are not allowed"; ORACLE_STR_USER_ERROR[-OB_ERR_ZERO_LEN_COL] = "ORA-01723: zero-length columns are not allowed"; ERROR_NAME[-OB_ERR_YEAR_CONFLICTS_WITH_JULIAN_DATE] = "OB_ERR_YEAR_CONFLICTS_WITH_JULIAN_DATE"; + ERROR_CAUSE[-OB_ERR_YEAR_CONFLICTS_WITH_JULIAN_DATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_YEAR_CONFLICTS_WITH_JULIAN_DATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_YEAR_CONFLICTS_WITH_JULIAN_DATE] = -1; SQLSTATE[-OB_ERR_YEAR_CONFLICTS_WITH_JULIAN_DATE] = "HY000"; STR_ERROR[-OB_ERR_YEAR_CONFLICTS_WITH_JULIAN_DATE] = "year conflicts with Julian date"; @@ -8677,6 +10504,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_YEAR_CONFLICTS_WITH_JULIAN_DATE] = "ORA-01831: year conflicts with Julian date"; ORACLE_STR_USER_ERROR[-OB_ERR_YEAR_CONFLICTS_WITH_JULIAN_DATE] = "ORA-01831: year conflicts with Julian date"; ERROR_NAME[-OB_ERR_DAY_OF_YEAR_CONFLICTS_WITH_JULIAN_DATE] = "OB_ERR_DAY_OF_YEAR_CONFLICTS_WITH_JULIAN_DATE"; + ERROR_CAUSE[-OB_ERR_DAY_OF_YEAR_CONFLICTS_WITH_JULIAN_DATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DAY_OF_YEAR_CONFLICTS_WITH_JULIAN_DATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DAY_OF_YEAR_CONFLICTS_WITH_JULIAN_DATE] = -1; SQLSTATE[-OB_ERR_DAY_OF_YEAR_CONFLICTS_WITH_JULIAN_DATE] = "HY000"; STR_ERROR[-OB_ERR_DAY_OF_YEAR_CONFLICTS_WITH_JULIAN_DATE] = "day of year conflicts with Julian date"; @@ -8687,6 +10516,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DAY_OF_YEAR_CONFLICTS_WITH_JULIAN_DATE] = "ORA-01832: day of year conflicts with Julian date"; ERROR_NAME[-OB_ERR_MONTH_CONFLICTS_WITH_JULIAN_DATE] = "OB_ERR_MONTH_CONFLICTS_WITH_JULIAN_DATE"; + ERROR_CAUSE[-OB_ERR_MONTH_CONFLICTS_WITH_JULIAN_DATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MONTH_CONFLICTS_WITH_JULIAN_DATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MONTH_CONFLICTS_WITH_JULIAN_DATE] = -1; SQLSTATE[-OB_ERR_MONTH_CONFLICTS_WITH_JULIAN_DATE] = "HY000"; STR_ERROR[-OB_ERR_MONTH_CONFLICTS_WITH_JULIAN_DATE] = "month conflicts with Julian date"; @@ -8695,6 +10526,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_MONTH_CONFLICTS_WITH_JULIAN_DATE] = "ORA-01833: month conflicts with Julian date"; ORACLE_STR_USER_ERROR[-OB_ERR_MONTH_CONFLICTS_WITH_JULIAN_DATE] = "ORA-01833: month conflicts with Julian date"; ERROR_NAME[-OB_ERR_DAY_OF_MONTH_CONFLICTS_WITH_JULIAN_DATE] = "OB_ERR_DAY_OF_MONTH_CONFLICTS_WITH_JULIAN_DATE"; + ERROR_CAUSE[-OB_ERR_DAY_OF_MONTH_CONFLICTS_WITH_JULIAN_DATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DAY_OF_MONTH_CONFLICTS_WITH_JULIAN_DATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DAY_OF_MONTH_CONFLICTS_WITH_JULIAN_DATE] = -1; SQLSTATE[-OB_ERR_DAY_OF_MONTH_CONFLICTS_WITH_JULIAN_DATE] = "HY000"; STR_ERROR[-OB_ERR_DAY_OF_MONTH_CONFLICTS_WITH_JULIAN_DATE] = "day of month conflicts with Julian date"; @@ -8705,6 +10538,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DAY_OF_MONTH_CONFLICTS_WITH_JULIAN_DATE] = "ORA-01834: day of month conflicts with Julian date"; ERROR_NAME[-OB_ERR_DAY_OF_WEEK_CONFLICTS_WITH_JULIAN_DATE] = "OB_ERR_DAY_OF_WEEK_CONFLICTS_WITH_JULIAN_DATE"; + ERROR_CAUSE[-OB_ERR_DAY_OF_WEEK_CONFLICTS_WITH_JULIAN_DATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DAY_OF_WEEK_CONFLICTS_WITH_JULIAN_DATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DAY_OF_WEEK_CONFLICTS_WITH_JULIAN_DATE] = -1; SQLSTATE[-OB_ERR_DAY_OF_WEEK_CONFLICTS_WITH_JULIAN_DATE] = "HY000"; STR_ERROR[-OB_ERR_DAY_OF_WEEK_CONFLICTS_WITH_JULIAN_DATE] = "day of week conflicts with Julian date"; @@ -8715,6 +10550,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DAY_OF_WEEK_CONFLICTS_WITH_JULIAN_DATE] = "ORA-01835: day of week conflicts with Julian date"; ERROR_NAME[-OB_ERR_HOUR_CONFLICTS_WITH_SECONDS_IN_DAY] = "OB_ERR_HOUR_CONFLICTS_WITH_SECONDS_IN_DAY"; + ERROR_CAUSE[-OB_ERR_HOUR_CONFLICTS_WITH_SECONDS_IN_DAY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_HOUR_CONFLICTS_WITH_SECONDS_IN_DAY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_HOUR_CONFLICTS_WITH_SECONDS_IN_DAY] = -1; SQLSTATE[-OB_ERR_HOUR_CONFLICTS_WITH_SECONDS_IN_DAY] = "HY000"; STR_ERROR[-OB_ERR_HOUR_CONFLICTS_WITH_SECONDS_IN_DAY] = "hour conflicts with seconds in day"; @@ -8724,6 +10561,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_HOUR_CONFLICTS_WITH_SECONDS_IN_DAY] = "ORA-01836: hour conflicts with seconds in day"; ERROR_NAME[-OB_ERR_MINUTES_OF_HOUR_CONFLICTS_WITH_SECONDS_IN_DAY] = "OB_ERR_MINUTES_OF_HOUR_CONFLICTS_WITH_SECONDS_IN_DAY"; + ERROR_CAUSE[-OB_ERR_MINUTES_OF_HOUR_CONFLICTS_WITH_SECONDS_IN_DAY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MINUTES_OF_HOUR_CONFLICTS_WITH_SECONDS_IN_DAY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MINUTES_OF_HOUR_CONFLICTS_WITH_SECONDS_IN_DAY] = -1; SQLSTATE[-OB_ERR_MINUTES_OF_HOUR_CONFLICTS_WITH_SECONDS_IN_DAY] = "HY000"; STR_ERROR[-OB_ERR_MINUTES_OF_HOUR_CONFLICTS_WITH_SECONDS_IN_DAY] = "minutes of hour conflicts with seconds in day"; @@ -8736,6 +10575,8 @@ static struct ObStrErrorInit { "ORA-01837: minutes of hour conflicts with seconds in day"; ERROR_NAME[-OB_ERR_SECONDS_OF_MINUTE_CONFLICTS_WITH_SECONDS_IN_DAY] = "OB_ERR_SECONDS_OF_MINUTE_CONFLICTS_WITH_SECONDS_IN_DAY"; + ERROR_CAUSE[-OB_ERR_SECONDS_OF_MINUTE_CONFLICTS_WITH_SECONDS_IN_DAY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SECONDS_OF_MINUTE_CONFLICTS_WITH_SECONDS_IN_DAY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SECONDS_OF_MINUTE_CONFLICTS_WITH_SECONDS_IN_DAY] = -1; SQLSTATE[-OB_ERR_SECONDS_OF_MINUTE_CONFLICTS_WITH_SECONDS_IN_DAY] = "HY000"; STR_ERROR[-OB_ERR_SECONDS_OF_MINUTE_CONFLICTS_WITH_SECONDS_IN_DAY] = @@ -8748,6 +10589,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SECONDS_OF_MINUTE_CONFLICTS_WITH_SECONDS_IN_DAY] = "ORA-01838: seconds of minute conflicts with seconds in day"; ERROR_NAME[-OB_ERR_DATE_NOT_VALID_FOR_MONTH_SPECIFIED] = "OB_ERR_DATE_NOT_VALID_FOR_MONTH_SPECIFIED"; + ERROR_CAUSE[-OB_ERR_DATE_NOT_VALID_FOR_MONTH_SPECIFIED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DATE_NOT_VALID_FOR_MONTH_SPECIFIED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DATE_NOT_VALID_FOR_MONTH_SPECIFIED] = -1; SQLSTATE[-OB_ERR_DATE_NOT_VALID_FOR_MONTH_SPECIFIED] = "HY000"; STR_ERROR[-OB_ERR_DATE_NOT_VALID_FOR_MONTH_SPECIFIED] = "date not valid for month specified"; @@ -8756,6 +10599,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DATE_NOT_VALID_FOR_MONTH_SPECIFIED] = "ORA-01839: date not valid for month specified"; ORACLE_STR_USER_ERROR[-OB_ERR_DATE_NOT_VALID_FOR_MONTH_SPECIFIED] = "ORA-01839: date not valid for month specified"; ERROR_NAME[-OB_ERR_INPUT_VALUE_NOT_LONG_ENOUGH] = "OB_ERR_INPUT_VALUE_NOT_LONG_ENOUGH"; + ERROR_CAUSE[-OB_ERR_INPUT_VALUE_NOT_LONG_ENOUGH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INPUT_VALUE_NOT_LONG_ENOUGH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INPUT_VALUE_NOT_LONG_ENOUGH] = -1; SQLSTATE[-OB_ERR_INPUT_VALUE_NOT_LONG_ENOUGH] = "HY000"; STR_ERROR[-OB_ERR_INPUT_VALUE_NOT_LONG_ENOUGH] = "input value not long enough for date format"; @@ -8765,6 +10610,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INPUT_VALUE_NOT_LONG_ENOUGH] = "ORA-01840: input value not long enough for date format"; ERROR_NAME[-OB_ERR_INVALID_QUARTER_VALUE] = "OB_ERR_INVALID_QUARTER_VALUE"; + ERROR_CAUSE[-OB_ERR_INVALID_QUARTER_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_QUARTER_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_QUARTER_VALUE] = -1; SQLSTATE[-OB_ERR_INVALID_QUARTER_VALUE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_QUARTER_VALUE] = "quarter must be between 1 and 4"; @@ -8773,6 +10620,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_QUARTER_VALUE] = "ORA-01842: quarter must be between 1 and 4"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_QUARTER_VALUE] = "ORA-01842: quarter must be between 1 and 4"; ERROR_NAME[-OB_ERR_INVALID_MONTH] = "OB_ERR_INVALID_MONTH"; + ERROR_CAUSE[-OB_ERR_INVALID_MONTH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_MONTH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_MONTH] = -1; SQLSTATE[-OB_ERR_INVALID_MONTH] = "HY000"; STR_ERROR[-OB_ERR_INVALID_MONTH] = "not a valid month"; @@ -8781,6 +10630,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_MONTH] = "ORA-01843: not a valid month"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_MONTH] = "ORA-01843: not a valid month"; ERROR_NAME[-OB_ERR_INVALID_DAY_OF_THE_WEEK] = "OB_ERR_INVALID_DAY_OF_THE_WEEK"; + ERROR_CAUSE[-OB_ERR_INVALID_DAY_OF_THE_WEEK] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_DAY_OF_THE_WEEK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_DAY_OF_THE_WEEK] = -1; SQLSTATE[-OB_ERR_INVALID_DAY_OF_THE_WEEK] = "HY000"; STR_ERROR[-OB_ERR_INVALID_DAY_OF_THE_WEEK] = "not a valid day of the week"; @@ -8789,6 +10640,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_DAY_OF_THE_WEEK] = "ORA-01846: not a valid day of the week"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_DAY_OF_THE_WEEK] = "ORA-01846: not a valid day of the week"; ERROR_NAME[-OB_ERR_INVALID_DAY_OF_YEAR_VALUE] = "OB_ERR_INVALID_DAY_OF_YEAR_VALUE"; + ERROR_CAUSE[-OB_ERR_INVALID_DAY_OF_YEAR_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_DAY_OF_YEAR_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_DAY_OF_YEAR_VALUE] = -1; SQLSTATE[-OB_ERR_INVALID_DAY_OF_YEAR_VALUE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_DAY_OF_YEAR_VALUE] = "day of year must be between 1 and 365 (366 for leap year)"; @@ -8799,6 +10652,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_DAY_OF_YEAR_VALUE] = "ORA-01848: day of year must be between 1 and 365 (366 for leap year)"; ERROR_NAME[-OB_ERR_INVALID_HOUR12_VALUE] = "OB_ERR_INVALID_HOUR12_VALUE"; + ERROR_CAUSE[-OB_ERR_INVALID_HOUR12_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_HOUR12_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_HOUR12_VALUE] = -1; SQLSTATE[-OB_ERR_INVALID_HOUR12_VALUE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_HOUR12_VALUE] = "hour must be between 1 and 12"; @@ -8807,6 +10662,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_HOUR12_VALUE] = "ORA-01849: hour must be between 1 and 12"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_HOUR12_VALUE] = "ORA-01849: hour must be between 1 and 12"; ERROR_NAME[-OB_ERR_INVALID_HOUR24_VALUE] = "OB_ERR_INVALID_HOUR24_VALUE"; + ERROR_CAUSE[-OB_ERR_INVALID_HOUR24_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_HOUR24_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_HOUR24_VALUE] = -1; SQLSTATE[-OB_ERR_INVALID_HOUR24_VALUE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_HOUR24_VALUE] = "hour must be between 0 and 23"; @@ -8815,6 +10672,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_HOUR24_VALUE] = "ORA-01850: hour must be between 0 and 23"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_HOUR24_VALUE] = "ORA-01850: hour must be between 0 and 23"; ERROR_NAME[-OB_ERR_INVALID_MINUTES_VALUE] = "OB_ERR_INVALID_MINUTES_VALUE"; + ERROR_CAUSE[-OB_ERR_INVALID_MINUTES_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_MINUTES_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_MINUTES_VALUE] = -1; SQLSTATE[-OB_ERR_INVALID_MINUTES_VALUE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_MINUTES_VALUE] = "minutes must be between 0 and 59"; @@ -8823,6 +10682,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_MINUTES_VALUE] = "ORA-01851: minutes must be between 0 and 59"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_MINUTES_VALUE] = "ORA-01851: minutes must be between 0 and 59"; ERROR_NAME[-OB_ERR_INVALID_SECONDS_VALUE] = "OB_ERR_INVALID_SECONDS_VALUE"; + ERROR_CAUSE[-OB_ERR_INVALID_SECONDS_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_SECONDS_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_SECONDS_VALUE] = -1; SQLSTATE[-OB_ERR_INVALID_SECONDS_VALUE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_SECONDS_VALUE] = "seconds must be between 0 and 59"; @@ -8831,6 +10692,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_SECONDS_VALUE] = "ORA-01852: seconds must be between 0 and 59"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_SECONDS_VALUE] = "ORA-01852: seconds must be between 0 and 59"; ERROR_NAME[-OB_ERR_INVALID_SECONDS_IN_DAY_VALUE] = "OB_ERR_INVALID_SECONDS_IN_DAY_VALUE"; + ERROR_CAUSE[-OB_ERR_INVALID_SECONDS_IN_DAY_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_SECONDS_IN_DAY_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_SECONDS_IN_DAY_VALUE] = -1; SQLSTATE[-OB_ERR_INVALID_SECONDS_IN_DAY_VALUE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_SECONDS_IN_DAY_VALUE] = "seconds in day must be between 0 and 86399"; @@ -8840,6 +10703,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_SECONDS_IN_DAY_VALUE] = "ORA-01853: seconds in day must be between 0 and 86399"; ERROR_NAME[-OB_ERR_INVALID_JULIAN_DATE_VALUE] = "OB_ERR_INVALID_JULIAN_DATE_VALUE"; + ERROR_CAUSE[-OB_ERR_INVALID_JULIAN_DATE_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_JULIAN_DATE_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_JULIAN_DATE_VALUE] = -1; SQLSTATE[-OB_ERR_INVALID_JULIAN_DATE_VALUE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_JULIAN_DATE_VALUE] = "julian date must be between 1 and 5373484"; @@ -8848,6 +10713,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_JULIAN_DATE_VALUE] = "ORA-01854: julian date must be between 1 and 5373484"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_JULIAN_DATE_VALUE] = "ORA-01854: julian date must be between 1 and 5373484"; ERROR_NAME[-OB_ERR_AM_OR_PM_REQUIRED] = "OB_ERR_AM_OR_PM_REQUIRED"; + ERROR_CAUSE[-OB_ERR_AM_OR_PM_REQUIRED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_AM_OR_PM_REQUIRED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_AM_OR_PM_REQUIRED] = -1; SQLSTATE[-OB_ERR_AM_OR_PM_REQUIRED] = "HY000"; STR_ERROR[-OB_ERR_AM_OR_PM_REQUIRED] = "AM/A.M. or PM/P.M. required"; @@ -8856,6 +10723,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_AM_OR_PM_REQUIRED] = "ORA-01855: AM/A.M. or PM/P.M. required"; ORACLE_STR_USER_ERROR[-OB_ERR_AM_OR_PM_REQUIRED] = "ORA-01855: AM/A.M. or PM/P.M. required"; ERROR_NAME[-OB_ERR_BC_OR_AD_REQUIRED] = "OB_ERR_BC_OR_AD_REQUIRED"; + ERROR_CAUSE[-OB_ERR_BC_OR_AD_REQUIRED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_BC_OR_AD_REQUIRED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_BC_OR_AD_REQUIRED] = -1; SQLSTATE[-OB_ERR_BC_OR_AD_REQUIRED] = "HY000"; STR_ERROR[-OB_ERR_BC_OR_AD_REQUIRED] = "BC/B.C. or AD/A.D. required"; @@ -8864,6 +10733,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_BC_OR_AD_REQUIRED] = "ORA-01856: BC/B.C. or AD/A.D. required"; ORACLE_STR_USER_ERROR[-OB_ERR_BC_OR_AD_REQUIRED] = "ORA-01856: BC/B.C. or AD/A.D. required"; ERROR_NAME[-OB_ERR_FORMAT_CODE_APPEARS_TWICE] = "OB_ERR_FORMAT_CODE_APPEARS_TWICE"; + ERROR_CAUSE[-OB_ERR_FORMAT_CODE_APPEARS_TWICE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_FORMAT_CODE_APPEARS_TWICE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_FORMAT_CODE_APPEARS_TWICE] = -1; SQLSTATE[-OB_ERR_FORMAT_CODE_APPEARS_TWICE] = "HY000"; STR_ERROR[-OB_ERR_FORMAT_CODE_APPEARS_TWICE] = "format code appears twice"; @@ -8872,6 +10743,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_FORMAT_CODE_APPEARS_TWICE] = "ORA-01810: format code appears twice"; ORACLE_STR_USER_ERROR[-OB_ERR_FORMAT_CODE_APPEARS_TWICE] = "ORA-01810: format code appears twice"; ERROR_NAME[-OB_ERR_DAY_OF_WEEK_SPECIFIED_MORE_THAN_ONCE] = "OB_ERR_DAY_OF_WEEK_SPECIFIED_MORE_THAN_ONCE"; + ERROR_CAUSE[-OB_ERR_DAY_OF_WEEK_SPECIFIED_MORE_THAN_ONCE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DAY_OF_WEEK_SPECIFIED_MORE_THAN_ONCE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DAY_OF_WEEK_SPECIFIED_MORE_THAN_ONCE] = -1; SQLSTATE[-OB_ERR_DAY_OF_WEEK_SPECIFIED_MORE_THAN_ONCE] = "HY000"; STR_ERROR[-OB_ERR_DAY_OF_WEEK_SPECIFIED_MORE_THAN_ONCE] = "day of week may only be specified once"; @@ -8882,6 +10755,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DAY_OF_WEEK_SPECIFIED_MORE_THAN_ONCE] = "ORA-01817: day of week may only be specified once"; ERROR_NAME[-OB_ERR_SIGNED_YEAR_PRECLUDES_USE_OF_BC_AD] = "OB_ERR_SIGNED_YEAR_PRECLUDES_USE_OF_BC_AD"; + ERROR_CAUSE[-OB_ERR_SIGNED_YEAR_PRECLUDES_USE_OF_BC_AD] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SIGNED_YEAR_PRECLUDES_USE_OF_BC_AD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SIGNED_YEAR_PRECLUDES_USE_OF_BC_AD] = -1; SQLSTATE[-OB_ERR_SIGNED_YEAR_PRECLUDES_USE_OF_BC_AD] = "HY000"; STR_ERROR[-OB_ERR_SIGNED_YEAR_PRECLUDES_USE_OF_BC_AD] = "signed year precludes use of BC/AD"; @@ -8890,6 +10765,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SIGNED_YEAR_PRECLUDES_USE_OF_BC_AD] = "ORA-01819: signed year precludes use of BC/AD"; ORACLE_STR_USER_ERROR[-OB_ERR_SIGNED_YEAR_PRECLUDES_USE_OF_BC_AD] = "ORA-01819: signed year precludes use of BC/AD"; ERROR_NAME[-OB_ERR_JULIAN_DATE_PRECLUDES_USE_OF_DAY_OF_YEAR] = "OB_ERR_JULIAN_DATE_PRECLUDES_USE_OF_DAY_OF_YEAR"; + ERROR_CAUSE[-OB_ERR_JULIAN_DATE_PRECLUDES_USE_OF_DAY_OF_YEAR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_JULIAN_DATE_PRECLUDES_USE_OF_DAY_OF_YEAR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_JULIAN_DATE_PRECLUDES_USE_OF_DAY_OF_YEAR] = -1; SQLSTATE[-OB_ERR_JULIAN_DATE_PRECLUDES_USE_OF_DAY_OF_YEAR] = "HY000"; STR_ERROR[-OB_ERR_JULIAN_DATE_PRECLUDES_USE_OF_DAY_OF_YEAR] = "Julian date precludes use of day of year"; @@ -8900,6 +10777,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_JULIAN_DATE_PRECLUDES_USE_OF_DAY_OF_YEAR] = "ORA-01811: Julian date precludes use of day of year"; ERROR_NAME[-OB_ERR_YEAR_MAY_ONLY_BE_SPECIFIED_ONCE] = "OB_ERR_YEAR_MAY_ONLY_BE_SPECIFIED_ONCE"; + ERROR_CAUSE[-OB_ERR_YEAR_MAY_ONLY_BE_SPECIFIED_ONCE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_YEAR_MAY_ONLY_BE_SPECIFIED_ONCE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_YEAR_MAY_ONLY_BE_SPECIFIED_ONCE] = -1; SQLSTATE[-OB_ERR_YEAR_MAY_ONLY_BE_SPECIFIED_ONCE] = "HY000"; STR_ERROR[-OB_ERR_YEAR_MAY_ONLY_BE_SPECIFIED_ONCE] = "year may only be specified once"; @@ -8908,6 +10787,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_YEAR_MAY_ONLY_BE_SPECIFIED_ONCE] = "ORA-01812: year may only be specified once"; ORACLE_STR_USER_ERROR[-OB_ERR_YEAR_MAY_ONLY_BE_SPECIFIED_ONCE] = "ORA-01812: year may only be specified once"; ERROR_NAME[-OB_ERR_HOUR_MAY_ONLY_BE_SPECIFIED_ONCE] = "OB_ERR_HOUR_MAY_ONLY_BE_SPECIFIED_ONCE"; + ERROR_CAUSE[-OB_ERR_HOUR_MAY_ONLY_BE_SPECIFIED_ONCE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_HOUR_MAY_ONLY_BE_SPECIFIED_ONCE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_HOUR_MAY_ONLY_BE_SPECIFIED_ONCE] = -1; SQLSTATE[-OB_ERR_HOUR_MAY_ONLY_BE_SPECIFIED_ONCE] = "HY000"; STR_ERROR[-OB_ERR_HOUR_MAY_ONLY_BE_SPECIFIED_ONCE] = "hour may only be specified once"; @@ -8916,6 +10797,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_HOUR_MAY_ONLY_BE_SPECIFIED_ONCE] = "ORA-01813: hour may only be specified once"; ORACLE_STR_USER_ERROR[-OB_ERR_HOUR_MAY_ONLY_BE_SPECIFIED_ONCE] = "ORA-01813: hour may only be specified once"; ERROR_NAME[-OB_ERR_AM_PM_CONFLICTS_WITH_USE_OF_AM_DOT_PM_DOT] = "OB_ERR_AM_PM_CONFLICTS_WITH_USE_OF_AM_DOT_PM_DOT"; + ERROR_CAUSE[-OB_ERR_AM_PM_CONFLICTS_WITH_USE_OF_AM_DOT_PM_DOT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_AM_PM_CONFLICTS_WITH_USE_OF_AM_DOT_PM_DOT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_AM_PM_CONFLICTS_WITH_USE_OF_AM_DOT_PM_DOT] = -1; SQLSTATE[-OB_ERR_AM_PM_CONFLICTS_WITH_USE_OF_AM_DOT_PM_DOT] = "HY000"; STR_ERROR[-OB_ERR_AM_PM_CONFLICTS_WITH_USE_OF_AM_DOT_PM_DOT] = "AM/PM conflicts with use of A.M./P.M."; @@ -8926,6 +10809,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_AM_PM_CONFLICTS_WITH_USE_OF_AM_DOT_PM_DOT] = "ORA-01814: AM/PM conflicts with use of A.M./P.M."; ERROR_NAME[-OB_ERR_BC_AD_CONFLICT_WITH_USE_OF_BC_DOT_AD_DOT] = "OB_ERR_BC_AD_CONFLICT_WITH_USE_OF_BC_DOT_AD_DOT"; + ERROR_CAUSE[-OB_ERR_BC_AD_CONFLICT_WITH_USE_OF_BC_DOT_AD_DOT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_BC_AD_CONFLICT_WITH_USE_OF_BC_DOT_AD_DOT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_BC_AD_CONFLICT_WITH_USE_OF_BC_DOT_AD_DOT] = -1; SQLSTATE[-OB_ERR_BC_AD_CONFLICT_WITH_USE_OF_BC_DOT_AD_DOT] = "HY000"; STR_ERROR[-OB_ERR_BC_AD_CONFLICT_WITH_USE_OF_BC_DOT_AD_DOT] = "BC/AD conflicts with use of B.C./A.D."; @@ -8936,6 +10821,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_BC_AD_CONFLICT_WITH_USE_OF_BC_DOT_AD_DOT] = "ORA-01815: BC/AD conflicts with use of B.C./A.D."; ERROR_NAME[-OB_ERR_MONTH_MAY_ONLY_BE_SPECIFIED_ONCE] = "OB_ERR_MONTH_MAY_ONLY_BE_SPECIFIED_ONCE"; + ERROR_CAUSE[-OB_ERR_MONTH_MAY_ONLY_BE_SPECIFIED_ONCE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MONTH_MAY_ONLY_BE_SPECIFIED_ONCE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MONTH_MAY_ONLY_BE_SPECIFIED_ONCE] = -1; SQLSTATE[-OB_ERR_MONTH_MAY_ONLY_BE_SPECIFIED_ONCE] = "HY000"; STR_ERROR[-OB_ERR_MONTH_MAY_ONLY_BE_SPECIFIED_ONCE] = "month may only be specified once"; @@ -8944,6 +10831,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_MONTH_MAY_ONLY_BE_SPECIFIED_ONCE] = "ORA-01816: month may only be specified once"; ORACLE_STR_USER_ERROR[-OB_ERR_MONTH_MAY_ONLY_BE_SPECIFIED_ONCE] = "ORA-01816: month may only be specified once"; ERROR_NAME[-OB_ERR_DAY_OF_WEEK_MAY_ONLY_BE_SPECIFIED_ONCE] = "OB_ERR_DAY_OF_WEEK_MAY_ONLY_BE_SPECIFIED_ONCE"; + ERROR_CAUSE[-OB_ERR_DAY_OF_WEEK_MAY_ONLY_BE_SPECIFIED_ONCE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DAY_OF_WEEK_MAY_ONLY_BE_SPECIFIED_ONCE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DAY_OF_WEEK_MAY_ONLY_BE_SPECIFIED_ONCE] = -1; SQLSTATE[-OB_ERR_DAY_OF_WEEK_MAY_ONLY_BE_SPECIFIED_ONCE] = "HY000"; STR_ERROR[-OB_ERR_DAY_OF_WEEK_MAY_ONLY_BE_SPECIFIED_ONCE] = "day of week may only be specified once"; @@ -8954,6 +10843,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DAY_OF_WEEK_MAY_ONLY_BE_SPECIFIED_ONCE] = "ORA-01817: day of week may only be specified once"; ERROR_NAME[-OB_ERR_FORMAT_CODE_CANNOT_APPEAR] = "OB_ERR_FORMAT_CODE_CANNOT_APPEAR"; + ERROR_CAUSE[-OB_ERR_FORMAT_CODE_CANNOT_APPEAR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_FORMAT_CODE_CANNOT_APPEAR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_FORMAT_CODE_CANNOT_APPEAR] = -1; SQLSTATE[-OB_ERR_FORMAT_CODE_CANNOT_APPEAR] = "HY000"; STR_ERROR[-OB_ERR_FORMAT_CODE_CANNOT_APPEAR] = "format code cannot appear in date input format"; @@ -8963,6 +10854,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_FORMAT_CODE_CANNOT_APPEAR] = "ORA-01820: format code cannot appear in date input format"; ERROR_NAME[-OB_ERR_NON_NUMERIC_CHARACTER_VALUE] = "OB_ERR_NON_NUMERIC_CHARACTER_VALUE"; + ERROR_CAUSE[-OB_ERR_NON_NUMERIC_CHARACTER_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NON_NUMERIC_CHARACTER_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NON_NUMERIC_CHARACTER_VALUE] = -1; SQLSTATE[-OB_ERR_NON_NUMERIC_CHARACTER_VALUE] = "HY000"; STR_ERROR[-OB_ERR_NON_NUMERIC_CHARACTER_VALUE] = "a non-numeric character was found where a numeric was expected"; @@ -8974,6 +10867,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NON_NUMERIC_CHARACTER_VALUE] = "ORA-01858: a non-numeric character was found where a numeric was expected"; ERROR_NAME[-OB_INVALID_MERIDIAN_INDICATOR_USE] = "OB_INVALID_MERIDIAN_INDICATOR_USE"; + ERROR_CAUSE[-OB_INVALID_MERIDIAN_INDICATOR_USE] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_MERIDIAN_INDICATOR_USE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_MERIDIAN_INDICATOR_USE] = -1; SQLSTATE[-OB_INVALID_MERIDIAN_INDICATOR_USE] = "HY000"; STR_ERROR[-OB_INVALID_MERIDIAN_INDICATOR_USE] = "'HH24' precludes use of meridian indicator"; @@ -8982,6 +10877,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_INVALID_MERIDIAN_INDICATOR_USE] = "ORA-01818: 'HH24' precludes use of meridian indicator"; ORACLE_STR_USER_ERROR[-OB_INVALID_MERIDIAN_INDICATOR_USE] = "ORA-01818: 'HH24' precludes use of meridian indicator"; ERROR_NAME[-OB_ERR_INVALID_CHAR_FOLLOWING_ESCAPE_CHAR] = "OB_ERR_INVALID_CHAR_FOLLOWING_ESCAPE_CHAR"; + ERROR_CAUSE[-OB_ERR_INVALID_CHAR_FOLLOWING_ESCAPE_CHAR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_CHAR_FOLLOWING_ESCAPE_CHAR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_CHAR_FOLLOWING_ESCAPE_CHAR] = -1; SQLSTATE[-OB_ERR_INVALID_CHAR_FOLLOWING_ESCAPE_CHAR] = "HY000"; STR_ERROR[-OB_ERR_INVALID_CHAR_FOLLOWING_ESCAPE_CHAR] = @@ -8994,6 +10891,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_CHAR_FOLLOWING_ESCAPE_CHAR] = "ORA-01424: missing or illegal character following the escape character"; ERROR_NAME[-OB_ERR_INVALID_ESCAPE_CHAR_LENGTH] = "OB_ERR_INVALID_ESCAPE_CHAR_LENGTH"; + ERROR_CAUSE[-OB_ERR_INVALID_ESCAPE_CHAR_LENGTH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_ESCAPE_CHAR_LENGTH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_ESCAPE_CHAR_LENGTH] = -1; SQLSTATE[-OB_ERR_INVALID_ESCAPE_CHAR_LENGTH] = "HY000"; STR_ERROR[-OB_ERR_INVALID_ESCAPE_CHAR_LENGTH] = "escape character must be character string of length 1"; @@ -9004,6 +10903,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_ESCAPE_CHAR_LENGTH] = "ORA-01425: escape character must be character string of length 1"; ERROR_NAME[-OB_ERR_DAY_OF_MONTH_RANGE] = "OB_ERR_DAY_OF_MONTH_RANGE"; + ERROR_CAUSE[-OB_ERR_DAY_OF_MONTH_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DAY_OF_MONTH_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DAY_OF_MONTH_RANGE] = -1; SQLSTATE[-OB_ERR_DAY_OF_MONTH_RANGE] = "HY000"; STR_ERROR[-OB_ERR_DAY_OF_MONTH_RANGE] = "day of month must be between 1 and last day of month"; @@ -9013,6 +10914,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DAY_OF_MONTH_RANGE] = "ORA-01847: day of month must be between 1 and last day of month"; ERROR_NAME[-OB_ERR_NOT_SELECTED_EXPR] = "OB_ERR_NOT_SELECTED_EXPR"; + ERROR_CAUSE[-OB_ERR_NOT_SELECTED_EXPR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NOT_SELECTED_EXPR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NOT_SELECTED_EXPR] = -1; SQLSTATE[-OB_ERR_NOT_SELECTED_EXPR] = "HY000"; STR_ERROR[-OB_ERR_NOT_SELECTED_EXPR] = "not a SELECTed expression"; @@ -9021,6 +10924,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_NOT_SELECTED_EXPR] = "ORA-01791: not a SELECTed expression"; ORACLE_STR_USER_ERROR[-OB_ERR_NOT_SELECTED_EXPR] = "ORA-01791: not a SELECTed expression"; ERROR_NAME[-OB_ERR_INVALID_YEAR_VALUE] = "OB_ERR_INVALID_YEAR_VALUE"; + ERROR_CAUSE[-OB_ERR_INVALID_YEAR_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_YEAR_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_YEAR_VALUE] = -1; SQLSTATE[-OB_ERR_INVALID_YEAR_VALUE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_YEAR_VALUE] = "(full) year must be between -4713 and +9999, and not be 0"; @@ -9031,6 +10936,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_YEAR_VALUE] = "ORA-01841: (full) year must be between -4713 and +9999, and not be 0"; ERROR_NAME[-OB_ERR_UK_PK_DUPLICATE] = "OB_ERR_UK_PK_DUPLICATE"; + ERROR_CAUSE[-OB_ERR_UK_PK_DUPLICATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UK_PK_DUPLICATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UK_PK_DUPLICATE] = -1; SQLSTATE[-OB_ERR_UK_PK_DUPLICATE] = "HY000"; STR_ERROR[-OB_ERR_UK_PK_DUPLICATE] = "such unique or primary key already exists in the table"; @@ -9040,6 +10947,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UK_PK_DUPLICATE] = "ORA-02261: such unique or primary key already exists in the table"; ERROR_NAME[-OB_ERR_COLUMN_LIST_ALREADY_INDEXED] = "OB_ERR_COLUMN_LIST_ALREADY_INDEXED"; + ERROR_CAUSE[-OB_ERR_COLUMN_LIST_ALREADY_INDEXED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_COLUMN_LIST_ALREADY_INDEXED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_COLUMN_LIST_ALREADY_INDEXED] = -1; SQLSTATE[-OB_ERR_COLUMN_LIST_ALREADY_INDEXED] = "HY000"; STR_ERROR[-OB_ERR_COLUMN_LIST_ALREADY_INDEXED] = "such column list already indexed"; @@ -9048,6 +10957,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_COLUMN_LIST_ALREADY_INDEXED] = "ORA-01408: such column list already indexed"; ORACLE_STR_USER_ERROR[-OB_ERR_COLUMN_LIST_ALREADY_INDEXED] = "ORA-01408: such column list already indexed"; ERROR_NAME[-OB_ERR_BUSHY_TREE_NOT_SUPPORTED] = "OB_ERR_BUSHY_TREE_NOT_SUPPORTED"; + ERROR_CAUSE[-OB_ERR_BUSHY_TREE_NOT_SUPPORTED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_BUSHY_TREE_NOT_SUPPORTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_BUSHY_TREE_NOT_SUPPORTED] = -1; SQLSTATE[-OB_ERR_BUSHY_TREE_NOT_SUPPORTED] = "HY000"; STR_ERROR[-OB_ERR_BUSHY_TREE_NOT_SUPPORTED] = "PX does not support processing a bushy tree"; @@ -9058,6 +10969,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_BUSHY_TREE_NOT_SUPPORTED] = "ORA-00600: internal error code, arguments: -5673, PX does not support processing a bushy tree"; ERROR_NAME[-OB_ERR_ARGUMENT_OUT_OF_RANGE] = "OB_ERR_ARGUMENT_OUT_OF_RANGE"; + ERROR_CAUSE[-OB_ERR_ARGUMENT_OUT_OF_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ARGUMENT_OUT_OF_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ARGUMENT_OUT_OF_RANGE] = -1; SQLSTATE[-OB_ERR_ARGUMENT_OUT_OF_RANGE] = "HY000"; STR_ERROR[-OB_ERR_ARGUMENT_OUT_OF_RANGE] = "argument is out of range"; @@ -9066,6 +10979,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_ARGUMENT_OUT_OF_RANGE] = "ORA-01428: argument is out of range"; ORACLE_STR_USER_ERROR[-OB_ERR_ARGUMENT_OUT_OF_RANGE] = "ORA-01428: argument '%ld' is out of range"; ERROR_NAME[-OB_ERR_ORDER_BY_ITEM_NOT_IN_SELECT_LIST] = "OB_ERR_ORDER_BY_ITEM_NOT_IN_SELECT_LIST"; + ERROR_CAUSE[-OB_ERR_ORDER_BY_ITEM_NOT_IN_SELECT_LIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ORDER_BY_ITEM_NOT_IN_SELECT_LIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ORDER_BY_ITEM_NOT_IN_SELECT_LIST] = -1; SQLSTATE[-OB_ERR_ORDER_BY_ITEM_NOT_IN_SELECT_LIST] = "HY000"; STR_ERROR[-OB_ERR_ORDER_BY_ITEM_NOT_IN_SELECT_LIST] = @@ -9078,6 +10993,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ORDER_BY_ITEM_NOT_IN_SELECT_LIST] = "ORA-01785: ORDER BY item must be the number of a SELECT-list expression"; ERROR_NAME[-OB_ERR_INTERVAL_INVALID] = "OB_ERR_INTERVAL_INVALID"; + ERROR_CAUSE[-OB_ERR_INTERVAL_INVALID] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INTERVAL_INVALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INTERVAL_INVALID] = -1; SQLSTATE[-OB_ERR_INTERVAL_INVALID] = "HY000"; STR_ERROR[-OB_ERR_INTERVAL_INVALID] = "the interval is invalid"; @@ -9086,6 +11003,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INTERVAL_INVALID] = "ORA-01867: the interval is invalid"; ORACLE_STR_USER_ERROR[-OB_ERR_INTERVAL_INVALID] = "ORA-01867: the interval is invalid"; ERROR_NAME[-OB_ERR_NUMERIC_OR_VALUE_ERROR] = "OB_ERR_NUMERIC_OR_VALUE_ERROR"; + ERROR_CAUSE[-OB_ERR_NUMERIC_OR_VALUE_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NUMERIC_OR_VALUE_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NUMERIC_OR_VALUE_ERROR] = -1; SQLSTATE[-OB_ERR_NUMERIC_OR_VALUE_ERROR] = "HY000"; STR_ERROR[-OB_ERR_NUMERIC_OR_VALUE_ERROR] = "PL/SQL: numeric or value error"; @@ -9094,6 +11013,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_NUMERIC_OR_VALUE_ERROR] = "ORA-06502: PL/SQL: numeric or value error"; ORACLE_STR_USER_ERROR[-OB_ERR_NUMERIC_OR_VALUE_ERROR] = "ORA-06502: PL/SQL: numeric or value error: %.*s"; ERROR_NAME[-OB_ERR_CONSTRAINT_NAME_DUPLICATE] = "OB_ERR_CONSTRAINT_NAME_DUPLICATE"; + ERROR_CAUSE[-OB_ERR_CONSTRAINT_NAME_DUPLICATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CONSTRAINT_NAME_DUPLICATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CONSTRAINT_NAME_DUPLICATE] = -1; SQLSTATE[-OB_ERR_CONSTRAINT_NAME_DUPLICATE] = "HY000"; STR_ERROR[-OB_ERR_CONSTRAINT_NAME_DUPLICATE] = "name already used by an existing constraint"; @@ -9102,6 +11023,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CONSTRAINT_NAME_DUPLICATE] = "ORA-02264: name already used by an existing constraint"; ORACLE_STR_USER_ERROR[-OB_ERR_CONSTRAINT_NAME_DUPLICATE] = "ORA-02264: name already used by an existing constraint"; ERROR_NAME[-OB_ERR_ONLY_HAVE_INVISIBLE_COL_IN_TABLE] = "OB_ERR_ONLY_HAVE_INVISIBLE_COL_IN_TABLE"; + ERROR_CAUSE[-OB_ERR_ONLY_HAVE_INVISIBLE_COL_IN_TABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ONLY_HAVE_INVISIBLE_COL_IN_TABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ONLY_HAVE_INVISIBLE_COL_IN_TABLE] = -1; SQLSTATE[-OB_ERR_ONLY_HAVE_INVISIBLE_COL_IN_TABLE] = "HY000"; STR_ERROR[-OB_ERR_ONLY_HAVE_INVISIBLE_COL_IN_TABLE] = "table must have at least one column that is not invisible"; @@ -9113,6 +11036,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ONLY_HAVE_INVISIBLE_COL_IN_TABLE] = "ORA-54039: table must have at least one column that is not invisible"; ERROR_NAME[-OB_ERR_INVISIBLE_COL_ON_UNSUPPORTED_TABLE_TYPE] = "OB_ERR_INVISIBLE_COL_ON_UNSUPPORTED_TABLE_TYPE"; + ERROR_CAUSE[-OB_ERR_INVISIBLE_COL_ON_UNSUPPORTED_TABLE_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVISIBLE_COL_ON_UNSUPPORTED_TABLE_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVISIBLE_COL_ON_UNSUPPORTED_TABLE_TYPE] = -1; SQLSTATE[-OB_ERR_INVISIBLE_COL_ON_UNSUPPORTED_TABLE_TYPE] = "HY000"; STR_ERROR[-OB_ERR_INVISIBLE_COL_ON_UNSUPPORTED_TABLE_TYPE] = @@ -9126,6 +11051,8 @@ static struct ObStrErrorInit { "ORA-54042: Invisible column is not supported on this type of table."; ERROR_NAME[-OB_ERR_MODIFY_COL_VISIBILITY_COMBINED_WITH_OTHER_OPTION] = "OB_ERR_MODIFY_COL_VISIBILITY_COMBINED_WITH_OTHER_OPTION"; + ERROR_CAUSE[-OB_ERR_MODIFY_COL_VISIBILITY_COMBINED_WITH_OTHER_OPTION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MODIFY_COL_VISIBILITY_COMBINED_WITH_OTHER_OPTION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MODIFY_COL_VISIBILITY_COMBINED_WITH_OTHER_OPTION] = -1; SQLSTATE[-OB_ERR_MODIFY_COL_VISIBILITY_COMBINED_WITH_OTHER_OPTION] = "HY000"; STR_ERROR[-OB_ERR_MODIFY_COL_VISIBILITY_COMBINED_WITH_OTHER_OPTION] = @@ -9138,6 +11065,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MODIFY_COL_VISIBILITY_COMBINED_WITH_OTHER_OPTION] = "ORA-54046: Column visibility modifications cannot be combined with any other modified column DDL option."; ERROR_NAME[-OB_ERR_MODIFY_COL_VISIBILITY_BY_SYS_USER] = "OB_ERR_MODIFY_COL_VISIBILITY_BY_SYS_USER"; + ERROR_CAUSE[-OB_ERR_MODIFY_COL_VISIBILITY_BY_SYS_USER] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MODIFY_COL_VISIBILITY_BY_SYS_USER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MODIFY_COL_VISIBILITY_BY_SYS_USER] = -1; SQLSTATE[-OB_ERR_MODIFY_COL_VISIBILITY_BY_SYS_USER] = "HY000"; STR_ERROR[-OB_ERR_MODIFY_COL_VISIBILITY_BY_SYS_USER] = @@ -9150,6 +11079,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MODIFY_COL_VISIBILITY_BY_SYS_USER] = "ORA-54053: The visibility of a column from a table owned by a SYS user cannot be changed."; ERROR_NAME[-OB_ERR_TOO_MANY_ARGS_FOR_FUN] = "OB_ERR_TOO_MANY_ARGS_FOR_FUN"; + ERROR_CAUSE[-OB_ERR_TOO_MANY_ARGS_FOR_FUN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TOO_MANY_ARGS_FOR_FUN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TOO_MANY_ARGS_FOR_FUN] = -1; SQLSTATE[-OB_ERR_TOO_MANY_ARGS_FOR_FUN] = "HY000"; STR_ERROR[-OB_ERR_TOO_MANY_ARGS_FOR_FUN] = "too many arguments for function"; @@ -9158,6 +11089,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_TOO_MANY_ARGS_FOR_FUN] = "ORA-00939: too many arguments for function"; ORACLE_STR_USER_ERROR[-OB_ERR_TOO_MANY_ARGS_FOR_FUN] = "ORA-00939: too many arguments for function"; ERROR_NAME[-OB_PX_SQL_NEED_RETRY] = "OB_PX_SQL_NEED_RETRY"; + ERROR_CAUSE[-OB_PX_SQL_NEED_RETRY] = "Internal Error"; + ERROR_SOLUTION[-OB_PX_SQL_NEED_RETRY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PX_SQL_NEED_RETRY] = -1; SQLSTATE[-OB_PX_SQL_NEED_RETRY] = "HY000"; STR_ERROR[-OB_PX_SQL_NEED_RETRY] = "PX sql need retry"; @@ -9167,6 +11100,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PX_SQL_NEED_RETRY] = "ORA-00600: internal error code, arguments: -5684, PX sql need retry"; ERROR_NAME[-OB_TENANT_HAS_BEEN_DROPPED] = "OB_TENANT_HAS_BEEN_DROPPED"; + ERROR_CAUSE[-OB_TENANT_HAS_BEEN_DROPPED] = "Internal Error"; + ERROR_SOLUTION[-OB_TENANT_HAS_BEEN_DROPPED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TENANT_HAS_BEEN_DROPPED] = -1; SQLSTATE[-OB_TENANT_HAS_BEEN_DROPPED] = "HY000"; STR_ERROR[-OB_TENANT_HAS_BEEN_DROPPED] = "tenant has been dropped"; @@ -9177,6 +11112,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TENANT_HAS_BEEN_DROPPED] = "ORA-00600: internal error code, arguments: -5685, Tenant '%.*s' has been dropped"; ERROR_NAME[-OB_ERR_EXTRACT_FIELD_INVALID] = "OB_ERR_EXTRACT_FIELD_INVALID"; + ERROR_CAUSE[-OB_ERR_EXTRACT_FIELD_INVALID] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_EXTRACT_FIELD_INVALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_EXTRACT_FIELD_INVALID] = -1; SQLSTATE[-OB_ERR_EXTRACT_FIELD_INVALID] = "HY000"; STR_ERROR[-OB_ERR_EXTRACT_FIELD_INVALID] = "invalid extract field for extract source"; @@ -9185,6 +11122,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_EXTRACT_FIELD_INVALID] = "ORA-30076: invalid extract field for extract source"; ORACLE_STR_USER_ERROR[-OB_ERR_EXTRACT_FIELD_INVALID] = "ORA-30076: invalid extract field for extract source"; ERROR_NAME[-OB_ERR_PACKAGE_COMPILE_ERROR] = "OB_ERR_PACKAGE_COMPILE_ERROR"; + ERROR_CAUSE[-OB_ERR_PACKAGE_COMPILE_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PACKAGE_COMPILE_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PACKAGE_COMPILE_ERROR] = -1; SQLSTATE[-OB_ERR_PACKAGE_COMPILE_ERROR] = "42000"; STR_ERROR[-OB_ERR_PACKAGE_COMPILE_ERROR] = "package compile error"; @@ -9195,6 +11134,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PACKAGE_COMPILE_ERROR] = "ORA-00600: internal error code, arguments: -5687, %s \'%.*s.%.*s\' compile error"; ERROR_NAME[-OB_ERR_SP_EMPTY_BLOCK] = "OB_ERR_SP_EMPTY_BLOCK"; + ERROR_CAUSE[-OB_ERR_SP_EMPTY_BLOCK] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_EMPTY_BLOCK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_EMPTY_BLOCK] = -1; SQLSTATE[-OB_ERR_SP_EMPTY_BLOCK] = "42000"; STR_ERROR[-OB_ERR_SP_EMPTY_BLOCK] = "Empty block prohibited in Oracle"; @@ -9205,6 +11146,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SP_EMPTY_BLOCK] = "ORA-00600: internal error code, arguments: -5688, Empty block prohibited in Oracle"; ERROR_NAME[-OB_ARRAY_BINDING_ROLLBACK] = "OB_ARRAY_BINDING_ROLLBACK"; + ERROR_CAUSE[-OB_ARRAY_BINDING_ROLLBACK] = "Internal Error"; + ERROR_SOLUTION[-OB_ARRAY_BINDING_ROLLBACK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ARRAY_BINDING_ROLLBACK] = -1; SQLSTATE[-OB_ARRAY_BINDING_ROLLBACK] = "HY000"; STR_ERROR[-OB_ARRAY_BINDING_ROLLBACK] = "array binding need rollback"; @@ -9215,6 +11158,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ARRAY_BINDING_ROLLBACK] = "ORA-00600: internal error code, arguments: -5689, array binding need rollback"; ERROR_NAME[-OB_ERR_INVALID_SUBQUERY_USE] = "OB_ERR_INVALID_SUBQUERY_USE"; + ERROR_CAUSE[-OB_ERR_INVALID_SUBQUERY_USE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_SUBQUERY_USE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_SUBQUERY_USE] = -1; SQLSTATE[-OB_ERR_INVALID_SUBQUERY_USE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_SUBQUERY_USE] = "subquery not allowed here"; @@ -9223,6 +11168,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_SUBQUERY_USE] = "ORA-02251: subquery not allowed here"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_SUBQUERY_USE] = "ORA-02251: subquery not allowed here"; ERROR_NAME[-OB_ERR_DATE_OR_SYS_VAR_CANNOT_IN_CHECK_CST] = "OB_ERR_DATE_OR_SYS_VAR_CANNOT_IN_CHECK_CST"; + ERROR_CAUSE[-OB_ERR_DATE_OR_SYS_VAR_CANNOT_IN_CHECK_CST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DATE_OR_SYS_VAR_CANNOT_IN_CHECK_CST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DATE_OR_SYS_VAR_CANNOT_IN_CHECK_CST] = -1; SQLSTATE[-OB_ERR_DATE_OR_SYS_VAR_CANNOT_IN_CHECK_CST] = "HY000"; STR_ERROR[-OB_ERR_DATE_OR_SYS_VAR_CANNOT_IN_CHECK_CST] = @@ -9235,6 +11182,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DATE_OR_SYS_VAR_CANNOT_IN_CHECK_CST] = "ORA-02436: date or system variable wrongly specified in CHECK constraint"; ERROR_NAME[-OB_ERR_NONEXISTENT_CONSTRAINT] = "OB_ERR_NONEXISTENT_CONSTRAINT"; + ERROR_CAUSE[-OB_ERR_NONEXISTENT_CONSTRAINT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NONEXISTENT_CONSTRAINT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NONEXISTENT_CONSTRAINT] = -1; SQLSTATE[-OB_ERR_NONEXISTENT_CONSTRAINT] = "HY000"; STR_ERROR[-OB_ERR_NONEXISTENT_CONSTRAINT] = "Cannot drop constraint - nonexistent constraint"; @@ -9244,6 +11193,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NONEXISTENT_CONSTRAINT] = "ORA-02443: Cannot drop constraint - nonexistent constraint"; ERROR_NAME[-OB_ERR_CHECK_CONSTRAINT_VIOLATED] = "OB_ERR_CHECK_CONSTRAINT_VIOLATED"; + ERROR_CAUSE[-OB_ERR_CHECK_CONSTRAINT_VIOLATED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CHECK_CONSTRAINT_VIOLATED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CHECK_CONSTRAINT_VIOLATED] = -1; SQLSTATE[-OB_ERR_CHECK_CONSTRAINT_VIOLATED] = "HY000"; STR_ERROR[-OB_ERR_CHECK_CONSTRAINT_VIOLATED] = "check constraint violated"; @@ -9252,6 +11203,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CHECK_CONSTRAINT_VIOLATED] = "ORA-02290: check constraint violated"; ORACLE_STR_USER_ERROR[-OB_ERR_CHECK_CONSTRAINT_VIOLATED] = "ORA-02290: check constraint violated"; ERROR_NAME[-OB_ERR_GROUP_FUNC_NOT_ALLOWED] = "OB_ERR_GROUP_FUNC_NOT_ALLOWED"; + ERROR_CAUSE[-OB_ERR_GROUP_FUNC_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_GROUP_FUNC_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_GROUP_FUNC_NOT_ALLOWED] = -1; SQLSTATE[-OB_ERR_GROUP_FUNC_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_ERR_GROUP_FUNC_NOT_ALLOWED] = "group function is not allowed here"; @@ -9260,6 +11213,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_GROUP_FUNC_NOT_ALLOWED] = "ORA-00934: group function is not allowed here"; ORACLE_STR_USER_ERROR[-OB_ERR_GROUP_FUNC_NOT_ALLOWED] = "ORA-00934: group function is not allowed here"; ERROR_NAME[-OB_ERR_POLICY_STRING_NOT_FOUND] = "OB_ERR_POLICY_STRING_NOT_FOUND"; + ERROR_CAUSE[-OB_ERR_POLICY_STRING_NOT_FOUND] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_POLICY_STRING_NOT_FOUND] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_POLICY_STRING_NOT_FOUND] = -1; SQLSTATE[-OB_ERR_POLICY_STRING_NOT_FOUND] = "HY000"; STR_ERROR[-OB_ERR_POLICY_STRING_NOT_FOUND] = "policy string not found"; @@ -9268,6 +11223,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_POLICY_STRING_NOT_FOUND] = "ORA-12416: policy string not found"; ORACLE_STR_USER_ERROR[-OB_ERR_POLICY_STRING_NOT_FOUND] = "ORA-12416: policy string not found"; ERROR_NAME[-OB_ERR_INVALID_LABEL_STRING] = "OB_ERR_INVALID_LABEL_STRING"; + ERROR_CAUSE[-OB_ERR_INVALID_LABEL_STRING] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_LABEL_STRING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_LABEL_STRING] = -1; SQLSTATE[-OB_ERR_INVALID_LABEL_STRING] = "HY000"; STR_ERROR[-OB_ERR_INVALID_LABEL_STRING] = "invalid label string"; @@ -9277,6 +11234,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_LABEL_STRING] = "ORA-12401: invalid label string"; ERROR_NAME[-OB_ERR_UNDEFINED_COMPARTMENT_STRING_FOR_POLICY_STRING] = "OB_ERR_UNDEFINED_COMPARTMENT_STRING_FOR_POLICY_STRING"; + ERROR_CAUSE[-OB_ERR_UNDEFINED_COMPARTMENT_STRING_FOR_POLICY_STRING] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UNDEFINED_COMPARTMENT_STRING_FOR_POLICY_STRING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UNDEFINED_COMPARTMENT_STRING_FOR_POLICY_STRING] = -1; SQLSTATE[-OB_ERR_UNDEFINED_COMPARTMENT_STRING_FOR_POLICY_STRING] = "HY000"; STR_ERROR[-OB_ERR_UNDEFINED_COMPARTMENT_STRING_FOR_POLICY_STRING] = @@ -9289,6 +11248,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UNDEFINED_COMPARTMENT_STRING_FOR_POLICY_STRING] = "ORA-12462: undefined compartment string for policy string"; ERROR_NAME[-OB_ERR_UNDEFINED_LEVEL_STRING_FOR_POLICY_STRING] = "OB_ERR_UNDEFINED_LEVEL_STRING_FOR_POLICY_STRING"; + ERROR_CAUSE[-OB_ERR_UNDEFINED_LEVEL_STRING_FOR_POLICY_STRING] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UNDEFINED_LEVEL_STRING_FOR_POLICY_STRING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UNDEFINED_LEVEL_STRING_FOR_POLICY_STRING] = -1; SQLSTATE[-OB_ERR_UNDEFINED_LEVEL_STRING_FOR_POLICY_STRING] = "HY000"; STR_ERROR[-OB_ERR_UNDEFINED_LEVEL_STRING_FOR_POLICY_STRING] = "undefined level string for policy string"; @@ -9299,6 +11260,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UNDEFINED_LEVEL_STRING_FOR_POLICY_STRING] = "ORA-12461: undefined level string for policy string"; ERROR_NAME[-OB_ERR_UNDEFINED_GROUP_STRING_FOR_POLICY_STRING] = "OB_ERR_UNDEFINED_GROUP_STRING_FOR_POLICY_STRING"; + ERROR_CAUSE[-OB_ERR_UNDEFINED_GROUP_STRING_FOR_POLICY_STRING] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UNDEFINED_GROUP_STRING_FOR_POLICY_STRING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UNDEFINED_GROUP_STRING_FOR_POLICY_STRING] = -1; SQLSTATE[-OB_ERR_UNDEFINED_GROUP_STRING_FOR_POLICY_STRING] = "HY000"; STR_ERROR[-OB_ERR_UNDEFINED_GROUP_STRING_FOR_POLICY_STRING] = "undefined group string for policy string"; @@ -9309,6 +11272,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UNDEFINED_GROUP_STRING_FOR_POLICY_STRING] = "ORA-12463: undefined group string for policy string"; ERROR_NAME[-OB_ERR_LBAC_ERROR] = "OB_ERR_LBAC_ERROR"; + ERROR_CAUSE[-OB_ERR_LBAC_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_LBAC_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_LBAC_ERROR] = -1; SQLSTATE[-OB_ERR_LBAC_ERROR] = "HY000"; STR_ERROR[-OB_ERR_LBAC_ERROR] = "LBAC error"; @@ -9318,6 +11283,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_LBAC_ERROR] = "ORA-12432: LBAC error: %s"; ERROR_NAME[-OB_ERR_POLICY_ROLE_ALREADY_EXISTS_FOR_POLICY_STRING] = "OB_ERR_POLICY_ROLE_ALREADY_EXISTS_FOR_POLICY_STRING"; + ERROR_CAUSE[-OB_ERR_POLICY_ROLE_ALREADY_EXISTS_FOR_POLICY_STRING] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_POLICY_ROLE_ALREADY_EXISTS_FOR_POLICY_STRING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_POLICY_ROLE_ALREADY_EXISTS_FOR_POLICY_STRING] = -1; SQLSTATE[-OB_ERR_POLICY_ROLE_ALREADY_EXISTS_FOR_POLICY_STRING] = "HY000"; STR_ERROR[-OB_ERR_POLICY_ROLE_ALREADY_EXISTS_FOR_POLICY_STRING] = "policy role already exists for policy string"; @@ -9329,6 +11296,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_POLICY_ROLE_ALREADY_EXISTS_FOR_POLICY_STRING] = "ORA-12447: policy role already exists for policy string"; ERROR_NAME[-OB_ERR_NULL_OR_INVALID_USER_LABEL] = "OB_ERR_NULL_OR_INVALID_USER_LABEL"; + ERROR_CAUSE[-OB_ERR_NULL_OR_INVALID_USER_LABEL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NULL_OR_INVALID_USER_LABEL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NULL_OR_INVALID_USER_LABEL] = -1; SQLSTATE[-OB_ERR_NULL_OR_INVALID_USER_LABEL] = "HY000"; STR_ERROR[-OB_ERR_NULL_OR_INVALID_USER_LABEL] = "NULL or invalid user label"; @@ -9337,6 +11306,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_NULL_OR_INVALID_USER_LABEL] = "ORA-12470: NULL or invalid user label"; ORACLE_STR_USER_ERROR[-OB_ERR_NULL_OR_INVALID_USER_LABEL] = "ORA-12470: NULL or invalid user label: %s"; ERROR_NAME[-OB_ERR_ADD_INDEX] = "OB_ERR_ADD_INDEX"; + ERROR_CAUSE[-OB_ERR_ADD_INDEX] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ADD_INDEX] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ADD_INDEX] = -1; SQLSTATE[-OB_ERR_ADD_INDEX] = "HY000"; STR_ERROR[-OB_ERR_ADD_INDEX] = "Add index failed"; @@ -9345,6 +11316,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_ADD_INDEX] = "ORA-00600: internal error code, arguments: -5703, Add index failed"; ORACLE_STR_USER_ERROR[-OB_ERR_ADD_INDEX] = "ORA-00600: internal error code, arguments: -5703, Add index failed"; ERROR_NAME[-OB_ERR_PROFILE_STRING_DOES_NOT_EXIST] = "OB_ERR_PROFILE_STRING_DOES_NOT_EXIST"; + ERROR_CAUSE[-OB_ERR_PROFILE_STRING_DOES_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PROFILE_STRING_DOES_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PROFILE_STRING_DOES_NOT_EXIST] = -1; SQLSTATE[-OB_ERR_PROFILE_STRING_DOES_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_PROFILE_STRING_DOES_NOT_EXIST] = "profile string does not exist"; @@ -9353,6 +11326,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_PROFILE_STRING_DOES_NOT_EXIST] = "ORA-02380: profile string does not exist"; ORACLE_STR_USER_ERROR[-OB_ERR_PROFILE_STRING_DOES_NOT_EXIST] = "ORA-02380: profile %.*s does not exist"; ERROR_NAME[-OB_ERR_INVALID_RESOURCE_LIMIT] = "OB_ERR_INVALID_RESOURCE_LIMIT"; + ERROR_CAUSE[-OB_ERR_INVALID_RESOURCE_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_RESOURCE_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_RESOURCE_LIMIT] = -1; SQLSTATE[-OB_ERR_INVALID_RESOURCE_LIMIT] = "HY000"; STR_ERROR[-OB_ERR_INVALID_RESOURCE_LIMIT] = "invalid resource limit"; @@ -9361,6 +11336,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_RESOURCE_LIMIT] = "ORA-02377: invalid resource limit"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_RESOURCE_LIMIT] = "ORA-02377: invalid resource limit %s"; ERROR_NAME[-OB_ERR_PROFILE_STRING_ALREADY_EXISTS] = "OB_ERR_PROFILE_STRING_ALREADY_EXISTS"; + ERROR_CAUSE[-OB_ERR_PROFILE_STRING_ALREADY_EXISTS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PROFILE_STRING_ALREADY_EXISTS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PROFILE_STRING_ALREADY_EXISTS] = -1; SQLSTATE[-OB_ERR_PROFILE_STRING_ALREADY_EXISTS] = "HY000"; STR_ERROR[-OB_ERR_PROFILE_STRING_ALREADY_EXISTS] = "profile string already exists"; @@ -9369,6 +11346,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_PROFILE_STRING_ALREADY_EXISTS] = "ORA-02379: profile string already exists"; ORACLE_STR_USER_ERROR[-OB_ERR_PROFILE_STRING_ALREADY_EXISTS] = "ORA-02379: profile %.*s already exists"; ERROR_NAME[-OB_ERR_PROFILE_STRING_HAS_USERS_ASSIGNED] = "OB_ERR_PROFILE_STRING_HAS_USERS_ASSIGNED"; + ERROR_CAUSE[-OB_ERR_PROFILE_STRING_HAS_USERS_ASSIGNED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PROFILE_STRING_HAS_USERS_ASSIGNED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PROFILE_STRING_HAS_USERS_ASSIGNED] = -1; SQLSTATE[-OB_ERR_PROFILE_STRING_HAS_USERS_ASSIGNED] = "HY000"; STR_ERROR[-OB_ERR_PROFILE_STRING_HAS_USERS_ASSIGNED] = @@ -9382,6 +11361,8 @@ static struct ObStrErrorInit { "ORA-02382: profile %.*s has users assigned, cannot drop without CASCADE"; ERROR_NAME[-OB_ERR_THE_LEADING_PRECISION_OF_THE_INTERVAL_IS_TOO_SMALL] = "OB_ERR_THE_LEADING_PRECISION_OF_THE_INTERVAL_IS_TOO_SMALL"; + ERROR_CAUSE[-OB_ERR_THE_LEADING_PRECISION_OF_THE_INTERVAL_IS_TOO_SMALL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_THE_LEADING_PRECISION_OF_THE_INTERVAL_IS_TOO_SMALL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_THE_LEADING_PRECISION_OF_THE_INTERVAL_IS_TOO_SMALL] = -1; SQLSTATE[-OB_ERR_THE_LEADING_PRECISION_OF_THE_INTERVAL_IS_TOO_SMALL] = "HY000"; STR_ERROR[-OB_ERR_THE_LEADING_PRECISION_OF_THE_INTERVAL_IS_TOO_SMALL] = @@ -9394,6 +11375,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_THE_LEADING_PRECISION_OF_THE_INTERVAL_IS_TOO_SMALL] = "ORA-01873: the leading precision of the interval is too small"; ERROR_NAME[-OB_ERR_INVALID_TIME_ZONE_HOUR] = "OB_ERR_INVALID_TIME_ZONE_HOUR"; + ERROR_CAUSE[-OB_ERR_INVALID_TIME_ZONE_HOUR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_TIME_ZONE_HOUR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_TIME_ZONE_HOUR] = -1; SQLSTATE[-OB_ERR_INVALID_TIME_ZONE_HOUR] = "HY000"; STR_ERROR[-OB_ERR_INVALID_TIME_ZONE_HOUR] = "time zone hour must be between -12 and 14"; @@ -9402,6 +11385,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_TIME_ZONE_HOUR] = "ORA-01874: time zone hour must be between -15 and 15"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_TIME_ZONE_HOUR] = "ORA-01874: time zone hour must be between -15 and 15"; ERROR_NAME[-OB_ERR_INVALID_TIME_ZONE_MINUTE] = "OB_ERR_INVALID_TIME_ZONE_MINUTE"; + ERROR_CAUSE[-OB_ERR_INVALID_TIME_ZONE_MINUTE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_TIME_ZONE_MINUTE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_TIME_ZONE_MINUTE] = -1; SQLSTATE[-OB_ERR_INVALID_TIME_ZONE_MINUTE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_TIME_ZONE_MINUTE] = "time zone minute must be between -59 and 59"; @@ -9410,6 +11395,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_TIME_ZONE_MINUTE] = "ORA-01875: time zone minute must be between -59 and 59"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_TIME_ZONE_MINUTE] = "ORA-01875: time zone minute must be between -59 and 59"; ERROR_NAME[-OB_ERR_NOT_A_VALID_TIME_ZONE] = "OB_ERR_NOT_A_VALID_TIME_ZONE"; + ERROR_CAUSE[-OB_ERR_NOT_A_VALID_TIME_ZONE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NOT_A_VALID_TIME_ZONE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NOT_A_VALID_TIME_ZONE] = -1; SQLSTATE[-OB_ERR_NOT_A_VALID_TIME_ZONE] = "HY000"; STR_ERROR[-OB_ERR_NOT_A_VALID_TIME_ZONE] = "not a valid time zone"; @@ -9419,6 +11406,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NOT_A_VALID_TIME_ZONE] = "ORA-01857: not a valid time zone"; ERROR_NAME[-OB_ERR_DATE_FORMAT_IS_TOO_LONG_FOR_INTERNAL_BUFFER] = "OB_ERR_DATE_FORMAT_IS_TOO_LONG_FOR_INTERNAL_BUFFER"; + ERROR_CAUSE[-OB_ERR_DATE_FORMAT_IS_TOO_LONG_FOR_INTERNAL_BUFFER] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DATE_FORMAT_IS_TOO_LONG_FOR_INTERNAL_BUFFER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DATE_FORMAT_IS_TOO_LONG_FOR_INTERNAL_BUFFER] = -1; SQLSTATE[-OB_ERR_DATE_FORMAT_IS_TOO_LONG_FOR_INTERNAL_BUFFER] = "HY000"; STR_ERROR[-OB_ERR_DATE_FORMAT_IS_TOO_LONG_FOR_INTERNAL_BUFFER] = "date format is too long for internal buffer"; @@ -9429,6 +11418,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DATE_FORMAT_IS_TOO_LONG_FOR_INTERNAL_BUFFER] = "ORA-01801: date format is too long for internal buffer"; ERROR_NAME[-OB_ERR_ADD_CHECK_CONSTRAINT_VIOLATED] = "OB_ERR_ADD_CHECK_CONSTRAINT_VIOLATED"; + ERROR_CAUSE[-OB_ERR_ADD_CHECK_CONSTRAINT_VIOLATED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ADD_CHECK_CONSTRAINT_VIOLATED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ADD_CHECK_CONSTRAINT_VIOLATED] = -1; SQLSTATE[-OB_ERR_ADD_CHECK_CONSTRAINT_VIOLATED] = "HY000"; STR_ERROR[-OB_ERR_ADD_CHECK_CONSTRAINT_VIOLATED] = "cannot validate - check constraint violated"; @@ -9438,6 +11429,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ADD_CHECK_CONSTRAINT_VIOLATED] = "ORA-02293: cannot validate (%.*s.%.*s) - check constraint violated"; ERROR_NAME[-OB_ERR_ILLEGAL_VIEW_UPDATE] = "OB_ERR_ILLEGAL_VIEW_UPDATE"; + ERROR_CAUSE[-OB_ERR_ILLEGAL_VIEW_UPDATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ILLEGAL_VIEW_UPDATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ILLEGAL_VIEW_UPDATE] = -1; SQLSTATE[-OB_ERR_ILLEGAL_VIEW_UPDATE] = "HY000"; STR_ERROR[-OB_ERR_ILLEGAL_VIEW_UPDATE] = "data manipulation operation not legal on this view"; @@ -9447,6 +11440,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ILLEGAL_VIEW_UPDATE] = "ORA-01732: data manipulation operation not legal on this view"; ERROR_NAME[-OB_ERR_VIRTUAL_COL_NOT_ALLOWED] = "OB_ERR_VIRTUAL_COL_NOT_ALLOWED"; + ERROR_CAUSE[-OB_ERR_VIRTUAL_COL_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_VIRTUAL_COL_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_VIRTUAL_COL_NOT_ALLOWED] = -1; SQLSTATE[-OB_ERR_VIRTUAL_COL_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_ERR_VIRTUAL_COL_NOT_ALLOWED] = "virtual column not allowed here"; @@ -9455,6 +11450,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_VIRTUAL_COL_NOT_ALLOWED] = "ORA-01733: virtual column not allowed here"; ORACLE_STR_USER_ERROR[-OB_ERR_VIRTUAL_COL_NOT_ALLOWED] = "ORA-01733: virtual column not allowed here"; ERROR_NAME[-OB_ERR_O_VIEW_MULTIUPDATE] = "OB_ERR_O_VIEW_MULTIUPDATE"; + ERROR_CAUSE[-OB_ERR_O_VIEW_MULTIUPDATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_O_VIEW_MULTIUPDATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_O_VIEW_MULTIUPDATE] = -1; SQLSTATE[-OB_ERR_O_VIEW_MULTIUPDATE] = "HY000"; STR_ERROR[-OB_ERR_O_VIEW_MULTIUPDATE] = "cannot modify more than one base table through a join view"; @@ -9465,6 +11462,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_O_VIEW_MULTIUPDATE] = "ORA-01776: cannot modify more than one base table through a join view"; ERROR_NAME[-OB_ERR_NON_INSERTABLE_TABLE] = "OB_ERR_NON_INSERTABLE_TABLE"; + ERROR_CAUSE[-OB_ERR_NON_INSERTABLE_TABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NON_INSERTABLE_TABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NON_INSERTABLE_TABLE] = ER_NON_INSERTABLE_TABLE; SQLSTATE[-OB_ERR_NON_INSERTABLE_TABLE] = "HY000"; STR_ERROR[-OB_ERR_NON_INSERTABLE_TABLE] = "The target table is not insertable"; @@ -9475,6 +11474,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NON_INSERTABLE_TABLE] = "ORA-00600: internal error code, arguments: -5717, The target table %.*s of the INSERT is not insertable-into"; ERROR_NAME[-OB_ERR_VIEW_MULTIUPDATE] = "OB_ERR_VIEW_MULTIUPDATE"; + ERROR_CAUSE[-OB_ERR_VIEW_MULTIUPDATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_VIEW_MULTIUPDATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_VIEW_MULTIUPDATE] = ER_VIEW_MULTIUPDATE; SQLSTATE[-OB_ERR_VIEW_MULTIUPDATE] = "HY000"; STR_ERROR[-OB_ERR_VIEW_MULTIUPDATE] = "Can not modify more than one base table through a join view"; @@ -9486,6 +11487,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_VIEW_MULTIUPDATE] = "ORA-00600: internal error code, arguments: -5718, Can not " "modify more than one base table through a join view '%.*s.%.*s'"; ERROR_NAME[-OB_ERR_NONUPDATEABLE_COLUMN] = "OB_ERR_NONUPDATEABLE_COLUMN"; + ERROR_CAUSE[-OB_ERR_NONUPDATEABLE_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NONUPDATEABLE_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NONUPDATEABLE_COLUMN] = ER_NONUPDATEABLE_COLUMN; SQLSTATE[-OB_ERR_NONUPDATEABLE_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_NONUPDATEABLE_COLUMN] = "Column is not updatable"; @@ -9496,6 +11499,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NONUPDATEABLE_COLUMN] = "ORA-00600: internal error code, arguments: -5719, Column '%.*s' is not updatable"; ERROR_NAME[-OB_ERR_VIEW_DELETE_MERGE_VIEW] = "OB_ERR_VIEW_DELETE_MERGE_VIEW"; + ERROR_CAUSE[-OB_ERR_VIEW_DELETE_MERGE_VIEW] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_VIEW_DELETE_MERGE_VIEW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_VIEW_DELETE_MERGE_VIEW] = ER_VIEW_DELETE_MERGE_VIEW; SQLSTATE[-OB_ERR_VIEW_DELETE_MERGE_VIEW] = "HY000"; STR_ERROR[-OB_ERR_VIEW_DELETE_MERGE_VIEW] = "Can not delete from join view"; @@ -9506,6 +11511,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_VIEW_DELETE_MERGE_VIEW] = "ORA-00600: internal error code, arguments: -5720, Can not delete from join view '%.*s.%.*s'"; ERROR_NAME[-OB_ERR_O_DELETE_VIEW_NON_KEY_PRESERVED] = "OB_ERR_O_DELETE_VIEW_NON_KEY_PRESERVED"; + ERROR_CAUSE[-OB_ERR_O_DELETE_VIEW_NON_KEY_PRESERVED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_O_DELETE_VIEW_NON_KEY_PRESERVED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_O_DELETE_VIEW_NON_KEY_PRESERVED] = -1; SQLSTATE[-OB_ERR_O_DELETE_VIEW_NON_KEY_PRESERVED] = "HY000"; STR_ERROR[-OB_ERR_O_DELETE_VIEW_NON_KEY_PRESERVED] = @@ -9518,6 +11525,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_O_DELETE_VIEW_NON_KEY_PRESERVED] = "ORA-01752: cannot delete from view without exactly one key-preserved table"; ERROR_NAME[-OB_ERR_O_UPDATE_VIEW_NON_KEY_PRESERVED] = "OB_ERR_O_UPDATE_VIEW_NON_KEY_PRESERVED"; + ERROR_CAUSE[-OB_ERR_O_UPDATE_VIEW_NON_KEY_PRESERVED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_O_UPDATE_VIEW_NON_KEY_PRESERVED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_O_UPDATE_VIEW_NON_KEY_PRESERVED] = -1; SQLSTATE[-OB_ERR_O_UPDATE_VIEW_NON_KEY_PRESERVED] = "HY000"; STR_ERROR[-OB_ERR_O_UPDATE_VIEW_NON_KEY_PRESERVED] = @@ -9530,6 +11539,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_O_UPDATE_VIEW_NON_KEY_PRESERVED] = "ORA-01779: cannot modify a column which maps to a non key-preserved table"; ERROR_NAME[-OB_ERR_MODIFY_READ_ONLY_VIEW] = "OB_ERR_MODIFY_READ_ONLY_VIEW"; + ERROR_CAUSE[-OB_ERR_MODIFY_READ_ONLY_VIEW] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MODIFY_READ_ONLY_VIEW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MODIFY_READ_ONLY_VIEW] = -1; SQLSTATE[-OB_ERR_MODIFY_READ_ONLY_VIEW] = "HY000"; STR_ERROR[-OB_ERR_MODIFY_READ_ONLY_VIEW] = "cannot perform a DML operation on a read-only view"; @@ -9539,6 +11550,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MODIFY_READ_ONLY_VIEW] = "ORA-42399: cannot perform a DML operation on a read-only view"; ERROR_NAME[-OB_ERR_INVALID_INITRANS_VALUE] = "OB_ERR_INVALID_INITRANS_VALUE"; + ERROR_CAUSE[-OB_ERR_INVALID_INITRANS_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_INITRANS_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_INITRANS_VALUE] = -1; SQLSTATE[-OB_ERR_INVALID_INITRANS_VALUE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_INITRANS_VALUE] = "invalid INITRANS option value"; @@ -9547,6 +11560,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_INITRANS_VALUE] = "ORA-02207: invalid INITRANS option value"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_INITRANS_VALUE] = "ORA-02207: invalid INITRANS option value"; ERROR_NAME[-OB_ERR_INVALID_MAXTRANS_VALUE] = "OB_ERR_INVALID_MAXTRANS_VALUE"; + ERROR_CAUSE[-OB_ERR_INVALID_MAXTRANS_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_MAXTRANS_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_MAXTRANS_VALUE] = -1; SQLSTATE[-OB_ERR_INVALID_MAXTRANS_VALUE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_MAXTRANS_VALUE] = "invalid MAXTRANS option value"; @@ -9555,6 +11570,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_MAXTRANS_VALUE] = "ORA-02209: invalid MAXTRANS option value"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_MAXTRANS_VALUE] = "ORA-02209: invalid MAXTRANS option value"; ERROR_NAME[-OB_ERR_INVALID_PCTFREE_OR_PCTUSED_VALUE] = "OB_ERR_INVALID_PCTFREE_OR_PCTUSED_VALUE"; + ERROR_CAUSE[-OB_ERR_INVALID_PCTFREE_OR_PCTUSED_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_PCTFREE_OR_PCTUSED_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_PCTFREE_OR_PCTUSED_VALUE] = -1; SQLSTATE[-OB_ERR_INVALID_PCTFREE_OR_PCTUSED_VALUE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_PCTFREE_OR_PCTUSED_VALUE] = "invalid value for PCTFREE or PCTUSED"; @@ -9563,6 +11580,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_PCTFREE_OR_PCTUSED_VALUE] = "ORA-02211: invalid value for PCTFREE or PCTUSED"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_PCTFREE_OR_PCTUSED_VALUE] = "ORA-02211: invalid value for PCTFREE or PCTUSED"; ERROR_NAME[-OB_ERR_PROXY_REROUTE] = "OB_ERR_PROXY_REROUTE"; + ERROR_CAUSE[-OB_ERR_PROXY_REROUTE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PROXY_REROUTE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PROXY_REROUTE] = -1; SQLSTATE[-OB_ERR_PROXY_REROUTE] = "HY000"; STR_ERROR[-OB_ERR_PROXY_REROUTE] = "SQL request should be rerouted"; @@ -9573,6 +11592,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PROXY_REROUTE] = "ORA-00600: internal error code, arguments: -5727, SQL request should be rerouted"; ERROR_NAME[-OB_ERR_ILLEGAL_ARGUMENT_FOR_FUNCTION] = "OB_ERR_ILLEGAL_ARGUMENT_FOR_FUNCTION"; + ERROR_CAUSE[-OB_ERR_ILLEGAL_ARGUMENT_FOR_FUNCTION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ILLEGAL_ARGUMENT_FOR_FUNCTION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ILLEGAL_ARGUMENT_FOR_FUNCTION] = -1; SQLSTATE[-OB_ERR_ILLEGAL_ARGUMENT_FOR_FUNCTION] = "HY000"; STR_ERROR[-OB_ERR_ILLEGAL_ARGUMENT_FOR_FUNCTION] = "illegal argument for function"; @@ -9581,6 +11602,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_ILLEGAL_ARGUMENT_FOR_FUNCTION] = "ORA-01760: illegal argument for function"; ORACLE_STR_USER_ERROR[-OB_ERR_ILLEGAL_ARGUMENT_FOR_FUNCTION] = "ORA-01760: illegal argument for function"; ERROR_NAME[-OB_ERR_OPERATOR_CANNOT_BE_USED_WITH_LIST] = "OB_ERR_OPERATOR_CANNOT_BE_USED_WITH_LIST"; + ERROR_CAUSE[-OB_ERR_OPERATOR_CANNOT_BE_USED_WITH_LIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OPERATOR_CANNOT_BE_USED_WITH_LIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OPERATOR_CANNOT_BE_USED_WITH_LIST] = -1; SQLSTATE[-OB_ERR_OPERATOR_CANNOT_BE_USED_WITH_LIST] = "HY000"; STR_ERROR[-OB_ERR_OPERATOR_CANNOT_BE_USED_WITH_LIST] = "this operator cannot be used with lists"; @@ -9590,6 +11613,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_OPERATOR_CANNOT_BE_USED_WITH_LIST] = "ORA-01796: this operator cannot be used with lists"; ERROR_NAME[-OB_ERR_INVALID_SAMPLING_RANGE] = "OB_ERR_INVALID_SAMPLING_RANGE"; + ERROR_CAUSE[-OB_ERR_INVALID_SAMPLING_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_SAMPLING_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_SAMPLING_RANGE] = -1; SQLSTATE[-OB_ERR_INVALID_SAMPLING_RANGE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_SAMPLING_RANGE] = "SAMPLE percentage must be in the range [0.000001,100)"; @@ -9600,6 +11625,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_SAMPLING_RANGE] = "ORA-30562: SAMPLE percentage must be in the range [0.000001,100)"; ERROR_NAME[-OB_ERR_SPECIFY_DATABASE_NOT_ALLOWED] = "OB_ERR_SPECIFY_DATABASE_NOT_ALLOWED"; + ERROR_CAUSE[-OB_ERR_SPECIFY_DATABASE_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SPECIFY_DATABASE_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SPECIFY_DATABASE_NOT_ALLOWED] = -1; SQLSTATE[-OB_ERR_SPECIFY_DATABASE_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_ERR_SPECIFY_DATABASE_NOT_ALLOWED] = "specifying owner's name of the table is not allowed"; @@ -9610,6 +11637,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SPECIFY_DATABASE_NOT_ALLOWED] = "ORA-01765: specifying owner's name of the table is not allowed"; ERROR_NAME[-OB_ERR_STMT_TRIGGER_WITH_WHEN_CLAUSE] = "OB_ERR_STMT_TRIGGER_WITH_WHEN_CLAUSE"; + ERROR_CAUSE[-OB_ERR_STMT_TRIGGER_WITH_WHEN_CLAUSE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_STMT_TRIGGER_WITH_WHEN_CLAUSE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_STMT_TRIGGER_WITH_WHEN_CLAUSE] = -1; SQLSTATE[-OB_ERR_STMT_TRIGGER_WITH_WHEN_CLAUSE] = "HY000"; STR_ERROR[-OB_ERR_STMT_TRIGGER_WITH_WHEN_CLAUSE] = "stmt trigger with when clause"; @@ -9618,6 +11647,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_STMT_TRIGGER_WITH_WHEN_CLAUSE] = "ORA-04077: stmt trigger with when clause"; ORACLE_STR_USER_ERROR[-OB_ERR_STMT_TRIGGER_WITH_WHEN_CLAUSE] = "ORA-04077: stmt trigger with when clause"; ERROR_NAME[-OB_ERR_TRIGGER_NOT_EXIST] = "OB_ERR_TRIGGER_NOT_EXIST"; + ERROR_CAUSE[-OB_ERR_TRIGGER_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TRIGGER_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TRIGGER_NOT_EXIST] = -1; SQLSTATE[-OB_ERR_TRIGGER_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_TRIGGER_NOT_EXIST] = "trigger does not exist"; @@ -9626,6 +11657,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_TRIGGER_NOT_EXIST] = "ORA-04080: trigger not exist"; ORACLE_STR_USER_ERROR[-OB_ERR_TRIGGER_NOT_EXIST] = "ORA-04080: trigger '%.*s' does not exist"; ERROR_NAME[-OB_ERR_TRIGGER_ALREADY_EXIST] = "OB_ERR_TRIGGER_ALREADY_EXIST"; + ERROR_CAUSE[-OB_ERR_TRIGGER_ALREADY_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TRIGGER_ALREADY_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TRIGGER_ALREADY_EXIST] = -1; SQLSTATE[-OB_ERR_TRIGGER_ALREADY_EXIST] = "HY000"; STR_ERROR[-OB_ERR_TRIGGER_ALREADY_EXIST] = "trigger already exist"; @@ -9634,6 +11667,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_TRIGGER_ALREADY_EXIST] = "ORA-04081: trigger already exist"; ORACLE_STR_USER_ERROR[-OB_ERR_TRIGGER_ALREADY_EXIST] = "ORA-04081: trigger '%.*s' already exist"; ERROR_NAME[-OB_ERR_TRIGGER_EXIST_ON_OTHER_TABLE] = "OB_ERR_TRIGGER_EXIST_ON_OTHER_TABLE"; + ERROR_CAUSE[-OB_ERR_TRIGGER_EXIST_ON_OTHER_TABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TRIGGER_EXIST_ON_OTHER_TABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TRIGGER_EXIST_ON_OTHER_TABLE] = -1; SQLSTATE[-OB_ERR_TRIGGER_EXIST_ON_OTHER_TABLE] = "HY000"; STR_ERROR[-OB_ERR_TRIGGER_EXIST_ON_OTHER_TABLE] = "trigger already exists on another table, cannot replace it"; @@ -9645,6 +11680,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TRIGGER_EXIST_ON_OTHER_TABLE] = "ORA-04095: trigger '%.*s' already exists on another table, cannot replace it"; ERROR_NAME[-OB_ERR_SIGNALED_IN_PARALLEL_QUERY_SERVER] = "OB_ERR_SIGNALED_IN_PARALLEL_QUERY_SERVER"; + ERROR_CAUSE[-OB_ERR_SIGNALED_IN_PARALLEL_QUERY_SERVER] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SIGNALED_IN_PARALLEL_QUERY_SERVER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SIGNALED_IN_PARALLEL_QUERY_SERVER] = -1; SQLSTATE[-OB_ERR_SIGNALED_IN_PARALLEL_QUERY_SERVER] = "HY000"; STR_ERROR[-OB_ERR_SIGNALED_IN_PARALLEL_QUERY_SERVER] = "error signaled in parallel query server"; @@ -9654,6 +11691,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SIGNALED_IN_PARALLEL_QUERY_SERVER] = "ORA-12801: error signaled in parallel query server"; ERROR_NAME[-OB_ERR_CTE_ILLEGAL_QUERY_NAME] = "OB_ERR_CTE_ILLEGAL_QUERY_NAME"; + ERROR_CAUSE[-OB_ERR_CTE_ILLEGAL_QUERY_NAME] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_ILLEGAL_QUERY_NAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_ILLEGAL_QUERY_NAME] = -1; SQLSTATE[-OB_ERR_CTE_ILLEGAL_QUERY_NAME] = "HY000"; STR_ERROR[-OB_ERR_CTE_ILLEGAL_QUERY_NAME] = "illegal reference of a query name in WITH clause"; @@ -9663,6 +11702,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CTE_ILLEGAL_QUERY_NAME] = "ORA-32031: illegal reference of a query name in WITH clause"; ERROR_NAME[-OB_ERR_CTE_UNSUPPORTED_COLUMN_ALIASING] = "OB_ERR_CTE_UNSUPPORTED_COLUMN_ALIASING"; + ERROR_CAUSE[-OB_ERR_CTE_UNSUPPORTED_COLUMN_ALIASING] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_UNSUPPORTED_COLUMN_ALIASING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_UNSUPPORTED_COLUMN_ALIASING] = -1; SQLSTATE[-OB_ERR_CTE_UNSUPPORTED_COLUMN_ALIASING] = "HY000"; STR_ERROR[-OB_ERR_CTE_UNSUPPORTED_COLUMN_ALIASING] = "unsupported column aliasing"; @@ -9671,6 +11712,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CTE_UNSUPPORTED_COLUMN_ALIASING] = "ORA-32033: unsupported column aliasing"; ORACLE_STR_USER_ERROR[-OB_ERR_CTE_UNSUPPORTED_COLUMN_ALIASING] = "ORA-32033: unsupported column aliasing"; ERROR_NAME[-OB_ERR_UNSUPPORTED_USE_OF_CTE] = "OB_ERR_UNSUPPORTED_USE_OF_CTE"; + ERROR_CAUSE[-OB_ERR_UNSUPPORTED_USE_OF_CTE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UNSUPPORTED_USE_OF_CTE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UNSUPPORTED_USE_OF_CTE] = -1; SQLSTATE[-OB_ERR_UNSUPPORTED_USE_OF_CTE] = "HY000"; STR_ERROR[-OB_ERR_UNSUPPORTED_USE_OF_CTE] = "unsupported use of WITH clause"; @@ -9679,6 +11722,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_UNSUPPORTED_USE_OF_CTE] = "ORA-32034: unsupported use of WITH clause"; ORACLE_STR_USER_ERROR[-OB_ERR_UNSUPPORTED_USE_OF_CTE] = "ORA-32034: unsupported use of WITH clause"; ERROR_NAME[-OB_ERR_CTE_COLUMN_NUMBER_NOT_MATCH] = "OB_ERR_CTE_COLUMN_NUMBER_NOT_MATCH"; + ERROR_CAUSE[-OB_ERR_CTE_COLUMN_NUMBER_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_COLUMN_NUMBER_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_COLUMN_NUMBER_NOT_MATCH] = -1; SQLSTATE[-OB_ERR_CTE_COLUMN_NUMBER_NOT_MATCH] = "HY000"; STR_ERROR[-OB_ERR_CTE_COLUMN_NUMBER_NOT_MATCH] = @@ -9691,6 +11736,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CTE_COLUMN_NUMBER_NOT_MATCH] = "ORA-32038: number of WITH clause column names does not match number of elements in select list"; ERROR_NAME[-OB_ERR_NEED_COLUMN_ALIAS_LIST_IN_RECURSIVE_CTE] = "OB_ERR_NEED_COLUMN_ALIAS_LIST_IN_RECURSIVE_CTE"; + ERROR_CAUSE[-OB_ERR_NEED_COLUMN_ALIAS_LIST_IN_RECURSIVE_CTE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NEED_COLUMN_ALIAS_LIST_IN_RECURSIVE_CTE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NEED_COLUMN_ALIAS_LIST_IN_RECURSIVE_CTE] = -1; SQLSTATE[-OB_ERR_NEED_COLUMN_ALIAS_LIST_IN_RECURSIVE_CTE] = "HY000"; STR_ERROR[-OB_ERR_NEED_COLUMN_ALIAS_LIST_IN_RECURSIVE_CTE] = "recursive WITH clause must have column alias list"; @@ -9702,6 +11749,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NEED_COLUMN_ALIAS_LIST_IN_RECURSIVE_CTE] = "ORA-32039: recursive WITH clause must have column alias list"; ERROR_NAME[-OB_ERR_NEED_UNION_ALL_IN_RECURSIVE_CTE] = "OB_ERR_NEED_UNION_ALL_IN_RECURSIVE_CTE"; + ERROR_CAUSE[-OB_ERR_NEED_UNION_ALL_IN_RECURSIVE_CTE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NEED_UNION_ALL_IN_RECURSIVE_CTE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NEED_UNION_ALL_IN_RECURSIVE_CTE] = -1; SQLSTATE[-OB_ERR_NEED_UNION_ALL_IN_RECURSIVE_CTE] = "HY000"; STR_ERROR[-OB_ERR_NEED_UNION_ALL_IN_RECURSIVE_CTE] = "recursive WITH clause must use a UNION ALL operation"; @@ -9712,6 +11761,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NEED_UNION_ALL_IN_RECURSIVE_CTE] = "ORA-32040: recursive WITH clause must use a UNION ALL operation"; ERROR_NAME[-OB_ERR_NEED_ONLY_TWO_BRANCH_IN_RECURSIVE_CTE] = "OB_ERR_NEED_ONLY_TWO_BRANCH_IN_RECURSIVE_CTE"; + ERROR_CAUSE[-OB_ERR_NEED_ONLY_TWO_BRANCH_IN_RECURSIVE_CTE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NEED_ONLY_TWO_BRANCH_IN_RECURSIVE_CTE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NEED_ONLY_TWO_BRANCH_IN_RECURSIVE_CTE] = -1; SQLSTATE[-OB_ERR_NEED_ONLY_TWO_BRANCH_IN_RECURSIVE_CTE] = "HY000"; STR_ERROR[-OB_ERR_NEED_ONLY_TWO_BRANCH_IN_RECURSIVE_CTE] = @@ -9725,6 +11776,8 @@ static struct ObStrErrorInit { "ORA-32041: UNION ALL operation in recursive WITH clause must have only two branches"; ERROR_NAME[-OB_ERR_NEED_REFERENCE_ITSELF_DIRECTLY_IN_RECURSIVE_CTE] = "OB_ERR_NEED_REFERENCE_ITSELF_DIRECTLY_IN_RECURSIVE_CTE"; + ERROR_CAUSE[-OB_ERR_NEED_REFERENCE_ITSELF_DIRECTLY_IN_RECURSIVE_CTE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NEED_REFERENCE_ITSELF_DIRECTLY_IN_RECURSIVE_CTE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NEED_REFERENCE_ITSELF_DIRECTLY_IN_RECURSIVE_CTE] = -1; SQLSTATE[-OB_ERR_NEED_REFERENCE_ITSELF_DIRECTLY_IN_RECURSIVE_CTE] = "HY000"; STR_ERROR[-OB_ERR_NEED_REFERENCE_ITSELF_DIRECTLY_IN_RECURSIVE_CTE] = @@ -9737,6 +11790,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NEED_REFERENCE_ITSELF_DIRECTLY_IN_RECURSIVE_CTE] = "ORA-32042: recursive WITH clause must reference itself directly in one of the UNION ALL branches"; ERROR_NAME[-OB_ERR_NEED_INIT_BRANCH_IN_RECURSIVE_CTE] = "OB_ERR_NEED_INIT_BRANCH_IN_RECURSIVE_CTE"; + ERROR_CAUSE[-OB_ERR_NEED_INIT_BRANCH_IN_RECURSIVE_CTE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NEED_INIT_BRANCH_IN_RECURSIVE_CTE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NEED_INIT_BRANCH_IN_RECURSIVE_CTE] = -1; SQLSTATE[-OB_ERR_NEED_INIT_BRANCH_IN_RECURSIVE_CTE] = "HY000"; STR_ERROR[-OB_ERR_NEED_INIT_BRANCH_IN_RECURSIVE_CTE] = "recursive WITH clause needs an initialization branch"; @@ -9747,6 +11802,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NEED_INIT_BRANCH_IN_RECURSIVE_CTE] = "ORA-32043: recursive WITH clause needs an initialization branch"; ERROR_NAME[-OB_ERR_CYCLE_FOUND_IN_RECURSIVE_CTE] = "OB_ERR_CYCLE_FOUND_IN_RECURSIVE_CTE"; + ERROR_CAUSE[-OB_ERR_CYCLE_FOUND_IN_RECURSIVE_CTE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CYCLE_FOUND_IN_RECURSIVE_CTE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CYCLE_FOUND_IN_RECURSIVE_CTE] = -1; SQLSTATE[-OB_ERR_CYCLE_FOUND_IN_RECURSIVE_CTE] = "HY000"; STR_ERROR[-OB_ERR_CYCLE_FOUND_IN_RECURSIVE_CTE] = "cycle detected while executing recursive WITH query"; @@ -9757,6 +11814,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CYCLE_FOUND_IN_RECURSIVE_CTE] = "ORA-32044: cycle detected while executing recursive WITH query"; ERROR_NAME[-OB_ERR_CTE_REACH_MAX_LEVEL_RECURSION] = "OB_ERR_CTE_REACH_MAX_LEVEL_RECURSION"; + ERROR_CAUSE[-OB_ERR_CTE_REACH_MAX_LEVEL_RECURSION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_REACH_MAX_LEVEL_RECURSION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_REACH_MAX_LEVEL_RECURSION] = -1; SQLSTATE[-OB_ERR_CTE_REACH_MAX_LEVEL_RECURSION] = "HY000"; STR_ERROR[-OB_ERR_CTE_REACH_MAX_LEVEL_RECURSION] = @@ -9769,6 +11828,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CTE_REACH_MAX_LEVEL_RECURSION] = "ORA-32045: maximum level of recursion reached while executing recursive WITH query"; ERROR_NAME[-OB_ERR_CTE_ILLEGAL_SEARCH_PSEUDO_NAME] = "OB_ERR_CTE_ILLEGAL_SEARCH_PSEUDO_NAME"; + ERROR_CAUSE[-OB_ERR_CTE_ILLEGAL_SEARCH_PSEUDO_NAME] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_ILLEGAL_SEARCH_PSEUDO_NAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_ILLEGAL_SEARCH_PSEUDO_NAME] = -1; SQLSTATE[-OB_ERR_CTE_ILLEGAL_SEARCH_PSEUDO_NAME] = "HY000"; STR_ERROR[-OB_ERR_CTE_ILLEGAL_SEARCH_PSEUDO_NAME] = @@ -9781,6 +11842,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CTE_ILLEGAL_SEARCH_PSEUDO_NAME] = "ORA-32046: sequence column name for SEARCH clause must not be part of the column alias list"; ERROR_NAME[-OB_ERR_CTE_ILLEGAL_CYCLE_NON_CYCLE_VALUE] = "OB_ERR_CTE_ILLEGAL_CYCLE_NON_CYCLE_VALUE"; + ERROR_CAUSE[-OB_ERR_CTE_ILLEGAL_CYCLE_NON_CYCLE_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_ILLEGAL_CYCLE_NON_CYCLE_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_ILLEGAL_CYCLE_NON_CYCLE_VALUE] = -1; SQLSTATE[-OB_ERR_CTE_ILLEGAL_CYCLE_NON_CYCLE_VALUE] = "HY000"; STR_ERROR[-OB_ERR_CTE_ILLEGAL_CYCLE_NON_CYCLE_VALUE] = @@ -9793,6 +11856,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CTE_ILLEGAL_CYCLE_NON_CYCLE_VALUE] = "ORA-32047: cycle mark value and non-cycle mark value must be one byte character string values"; ERROR_NAME[-OB_ERR_CTE_ILLEGAL_CYCLE_PSEUDO_NAME] = "OB_ERR_CTE_ILLEGAL_CYCLE_PSEUDO_NAME"; + ERROR_CAUSE[-OB_ERR_CTE_ILLEGAL_CYCLE_PSEUDO_NAME] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_ILLEGAL_CYCLE_PSEUDO_NAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_ILLEGAL_CYCLE_PSEUDO_NAME] = -1; SQLSTATE[-OB_ERR_CTE_ILLEGAL_CYCLE_PSEUDO_NAME] = "HY000"; STR_ERROR[-OB_ERR_CTE_ILLEGAL_CYCLE_PSEUDO_NAME] = @@ -9805,6 +11870,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CTE_ILLEGAL_CYCLE_PSEUDO_NAME] = "ORA-32048: cycle mark column name for CYCLE clause must not be part of the column alias list"; ERROR_NAME[-OB_ERR_CTE_COLUMN_ALIAS_DUPLICATE] = "OB_ERR_CTE_COLUMN_ALIAS_DUPLICATE"; + ERROR_CAUSE[-OB_ERR_CTE_COLUMN_ALIAS_DUPLICATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_COLUMN_ALIAS_DUPLICATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_COLUMN_ALIAS_DUPLICATE] = -1; SQLSTATE[-OB_ERR_CTE_COLUMN_ALIAS_DUPLICATE] = "HY000"; STR_ERROR[-OB_ERR_CTE_COLUMN_ALIAS_DUPLICATE] = "duplicate name found in column alias list for WITH clause"; @@ -9815,6 +11882,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CTE_COLUMN_ALIAS_DUPLICATE] = "ORA-32049: duplicate name found in column alias list for WITH clause"; ERROR_NAME[-OB_ERR_CTE_ILLEGAL_SEARCH_CYCLE_CLAUSE] = "OB_ERR_CTE_ILLEGAL_SEARCH_CYCLE_CLAUSE"; + ERROR_CAUSE[-OB_ERR_CTE_ILLEGAL_SEARCH_CYCLE_CLAUSE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_ILLEGAL_SEARCH_CYCLE_CLAUSE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_ILLEGAL_SEARCH_CYCLE_CLAUSE] = -1; SQLSTATE[-OB_ERR_CTE_ILLEGAL_SEARCH_CYCLE_CLAUSE] = "HY000"; STR_ERROR[-OB_ERR_CTE_ILLEGAL_SEARCH_CYCLE_CLAUSE] = @@ -9827,6 +11896,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CTE_ILLEGAL_SEARCH_CYCLE_CLAUSE] = "ORA-32480: SEARCH and CYCLE clauses can only be specified for recursive WITH clause elements"; ERROR_NAME[-OB_ERR_CTE_DUPLICATE_CYCLE_NON_CYCLE_VALUE] = "OB_ERR_CTE_DUPLICATE_CYCLE_NON_CYCLE_VALUE"; + ERROR_CAUSE[-OB_ERR_CTE_DUPLICATE_CYCLE_NON_CYCLE_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_DUPLICATE_CYCLE_NON_CYCLE_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_DUPLICATE_CYCLE_NON_CYCLE_VALUE] = -1; SQLSTATE[-OB_ERR_CTE_DUPLICATE_CYCLE_NON_CYCLE_VALUE] = "HY000"; STR_ERROR[-OB_ERR_CTE_DUPLICATE_CYCLE_NON_CYCLE_VALUE] = @@ -9839,6 +11910,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CTE_DUPLICATE_CYCLE_NON_CYCLE_VALUE] = "ORA-32481: cycle value for CYCLE clause must be different from the non-cycle value"; ERROR_NAME[-OB_ERR_CTE_DUPLICATE_SEQ_NAME_CYCLE_COLUMN] = "OB_ERR_CTE_DUPLICATE_SEQ_NAME_CYCLE_COLUMN"; + ERROR_CAUSE[-OB_ERR_CTE_DUPLICATE_SEQ_NAME_CYCLE_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_DUPLICATE_SEQ_NAME_CYCLE_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_DUPLICATE_SEQ_NAME_CYCLE_COLUMN] = -1; SQLSTATE[-OB_ERR_CTE_DUPLICATE_SEQ_NAME_CYCLE_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_CTE_DUPLICATE_SEQ_NAME_CYCLE_COLUMN] = @@ -9851,6 +11924,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CTE_DUPLICATE_SEQ_NAME_CYCLE_COLUMN] = "ORA-32482: sequence column for SEARCH clause must be different from the cycle mark column for CYCLE clause"; ERROR_NAME[-OB_ERR_CTE_DUPLICATE_NAME_IN_SEARCH_CLAUSE] = "OB_ERR_CTE_DUPLICATE_NAME_IN_SEARCH_CLAUSE"; + ERROR_CAUSE[-OB_ERR_CTE_DUPLICATE_NAME_IN_SEARCH_CLAUSE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_DUPLICATE_NAME_IN_SEARCH_CLAUSE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_DUPLICATE_NAME_IN_SEARCH_CLAUSE] = -1; SQLSTATE[-OB_ERR_CTE_DUPLICATE_NAME_IN_SEARCH_CLAUSE] = "HY000"; STR_ERROR[-OB_ERR_CTE_DUPLICATE_NAME_IN_SEARCH_CLAUSE] = @@ -9863,6 +11938,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CTE_DUPLICATE_NAME_IN_SEARCH_CLAUSE] = "ORA-32483: duplicate name found in sort specification list for SEARCH clause of WITH clause"; ERROR_NAME[-OB_ERR_CTE_DUPLICATE_NAME_IN_CYCLE_CLAUSE] = "OB_ERR_CTE_DUPLICATE_NAME_IN_CYCLE_CLAUSE"; + ERROR_CAUSE[-OB_ERR_CTE_DUPLICATE_NAME_IN_CYCLE_CLAUSE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_DUPLICATE_NAME_IN_CYCLE_CLAUSE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_DUPLICATE_NAME_IN_CYCLE_CLAUSE] = -1; SQLSTATE[-OB_ERR_CTE_DUPLICATE_NAME_IN_CYCLE_CLAUSE] = "HY000"; STR_ERROR[-OB_ERR_CTE_DUPLICATE_NAME_IN_CYCLE_CLAUSE] = @@ -9875,6 +11952,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CTE_DUPLICATE_NAME_IN_CYCLE_CLAUSE] = "ORA-32484: duplicate name found in cycle column list for CYCLE clause of WITH clause"; ERROR_NAME[-OB_ERR_CTE_ILLEGAL_COLUMN_IN_CYCLE_CLAUSE] = "OB_ERR_CTE_ILLEGAL_COLUMN_IN_CYCLE_CLAUSE"; + ERROR_CAUSE[-OB_ERR_CTE_ILLEGAL_COLUMN_IN_CYCLE_CLAUSE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_ILLEGAL_COLUMN_IN_CYCLE_CLAUSE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_ILLEGAL_COLUMN_IN_CYCLE_CLAUSE] = -1; SQLSTATE[-OB_ERR_CTE_ILLEGAL_COLUMN_IN_CYCLE_CLAUSE] = "HY000"; STR_ERROR[-OB_ERR_CTE_ILLEGAL_COLUMN_IN_CYCLE_CLAUSE] = @@ -9889,6 +11968,8 @@ static struct ObStrErrorInit { "ORA-32485: element in cycle column list of CYCLE clause must appear in the column alias list of the WITH " "clause element"; ERROR_NAME[-OB_ERR_CTE_ILLEGAL_RECURSIVE_BRANCH] = "OB_ERR_CTE_ILLEGAL_RECURSIVE_BRANCH"; + ERROR_CAUSE[-OB_ERR_CTE_ILLEGAL_RECURSIVE_BRANCH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_ILLEGAL_RECURSIVE_BRANCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_ILLEGAL_RECURSIVE_BRANCH] = -1; SQLSTATE[-OB_ERR_CTE_ILLEGAL_RECURSIVE_BRANCH] = "HY000"; STR_ERROR[-OB_ERR_CTE_ILLEGAL_RECURSIVE_BRANCH] = @@ -9901,6 +11982,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CTE_ILLEGAL_RECURSIVE_BRANCH] = "ORA-32486: unsupported operation in recursive branch of recursive WITH clause"; ERROR_NAME[-OB_ERR_ILLEGAL_JOIN_IN_RECURSIVE_CTE] = "OB_ERR_ILLEGAL_JOIN_IN_RECURSIVE_CTE"; + ERROR_CAUSE[-OB_ERR_ILLEGAL_JOIN_IN_RECURSIVE_CTE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ILLEGAL_JOIN_IN_RECURSIVE_CTE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ILLEGAL_JOIN_IN_RECURSIVE_CTE] = -1; SQLSTATE[-OB_ERR_ILLEGAL_JOIN_IN_RECURSIVE_CTE] = "HY000"; STR_ERROR[-OB_ERR_ILLEGAL_JOIN_IN_RECURSIVE_CTE] = "unsupported join in recursive WITH query"; @@ -9910,6 +11993,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ILLEGAL_JOIN_IN_RECURSIVE_CTE] = "ORA-32487: unsupported join in recursive WITH query"; ERROR_NAME[-OB_ERR_CTE_NEED_COLUMN_ALIAS_LIST] = "OB_ERR_CTE_NEED_COLUMN_ALIAS_LIST"; + ERROR_CAUSE[-OB_ERR_CTE_NEED_COLUMN_ALIAS_LIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_NEED_COLUMN_ALIAS_LIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_NEED_COLUMN_ALIAS_LIST] = -1; SQLSTATE[-OB_ERR_CTE_NEED_COLUMN_ALIAS_LIST] = "HY000"; STR_ERROR[-OB_ERR_CTE_NEED_COLUMN_ALIAS_LIST] = "WITH clause element did not have a column alias list"; @@ -9920,6 +12005,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CTE_NEED_COLUMN_ALIAS_LIST] = "ORA-32488: WITH clause element did not have a column alias list"; ERROR_NAME[-OB_ERR_CTE_ILLEGAL_COLUMN_IN_SERACH_CALUSE] = "OB_ERR_CTE_ILLEGAL_COLUMN_IN_SERACH_CALUSE"; + ERROR_CAUSE[-OB_ERR_CTE_ILLEGAL_COLUMN_IN_SERACH_CALUSE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_ILLEGAL_COLUMN_IN_SERACH_CALUSE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_ILLEGAL_COLUMN_IN_SERACH_CALUSE] = -1; SQLSTATE[-OB_ERR_CTE_ILLEGAL_COLUMN_IN_SERACH_CALUSE] = "HY000"; STR_ERROR[-OB_ERR_CTE_ILLEGAL_COLUMN_IN_SERACH_CALUSE] = @@ -9937,6 +12024,8 @@ static struct ObStrErrorInit { "WITH clause element"; ERROR_NAME[-OB_ERR_CTE_RECURSIVE_QUERY_NAME_REFERENCED_MORE_THAN_ONCE] = "OB_ERR_CTE_RECURSIVE_QUERY_NAME_REFERENCED_MORE_THAN_ONCE"; + ERROR_CAUSE[-OB_ERR_CTE_RECURSIVE_QUERY_NAME_REFERENCED_MORE_THAN_ONCE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CTE_RECURSIVE_QUERY_NAME_REFERENCED_MORE_THAN_ONCE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CTE_RECURSIVE_QUERY_NAME_REFERENCED_MORE_THAN_ONCE] = -1; SQLSTATE[-OB_ERR_CTE_RECURSIVE_QUERY_NAME_REFERENCED_MORE_THAN_ONCE] = "HY000"; STR_ERROR[-OB_ERR_CTE_RECURSIVE_QUERY_NAME_REFERENCED_MORE_THAN_ONCE] = @@ -9951,6 +12040,8 @@ static struct ObStrErrorInit { "ORA-32490: recursive query name referenced more than once in recursive branch of recursive WITH clause " "element"; ERROR_NAME[-OB_ERR_CBY_PSEUDO_COLUMN_NOT_ALLOWED] = "OB_ERR_CBY_PSEUDO_COLUMN_NOT_ALLOWED"; + ERROR_CAUSE[-OB_ERR_CBY_PSEUDO_COLUMN_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CBY_PSEUDO_COLUMN_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CBY_PSEUDO_COLUMN_NOT_ALLOWED] = -1; SQLSTATE[-OB_ERR_CBY_PSEUDO_COLUMN_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_ERR_CBY_PSEUDO_COLUMN_NOT_ALLOWED] = "Specified pseudo column or operator not allowed here"; @@ -9961,6 +12052,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CBY_PSEUDO_COLUMN_NOT_ALLOWED] = "ORA-00976: Specified pseudo column or operator not allowed here"; ERROR_NAME[-OB_ERR_CBY_LOOP] = "OB_ERR_CBY_LOOP"; + ERROR_CAUSE[-OB_ERR_CBY_LOOP] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CBY_LOOP] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CBY_LOOP] = -1; SQLSTATE[-OB_ERR_CBY_LOOP] = "HY000"; STR_ERROR[-OB_ERR_CBY_LOOP] = "CONNECT BY loop in user data"; @@ -9969,6 +12062,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CBY_LOOP] = "ORA-01436: CONNECT BY loop in user data"; ORACLE_STR_USER_ERROR[-OB_ERR_CBY_LOOP] = "ORA-01436: CONNECT BY loop in user data"; ERROR_NAME[-OB_ERR_CBY_JOIN_NOT_ALLOWED] = "OB_ERR_CBY_JOIN_NOT_ALLOWED"; + ERROR_CAUSE[-OB_ERR_CBY_JOIN_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CBY_JOIN_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CBY_JOIN_NOT_ALLOWED] = -1; SQLSTATE[-OB_ERR_CBY_JOIN_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_ERR_CBY_JOIN_NOT_ALLOWED] = "cannot have join with CONNECT BY"; @@ -9977,6 +12072,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CBY_JOIN_NOT_ALLOWED] = "ORA-01437: cannot have join with CONNECT BY"; ORACLE_STR_USER_ERROR[-OB_ERR_CBY_JOIN_NOT_ALLOWED] = "ORA-01437: cannot have join with CONNECT BY"; ERROR_NAME[-OB_ERR_CBY_CONNECT_BY_REQUIRED] = "OB_ERR_CBY_CONNECT_BY_REQUIRED"; + ERROR_CAUSE[-OB_ERR_CBY_CONNECT_BY_REQUIRED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CBY_CONNECT_BY_REQUIRED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CBY_CONNECT_BY_REQUIRED] = -1; SQLSTATE[-OB_ERR_CBY_CONNECT_BY_REQUIRED] = "HY000"; STR_ERROR[-OB_ERR_CBY_CONNECT_BY_REQUIRED] = "CONNECT BY clause required in this query block"; @@ -9986,6 +12083,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CBY_CONNECT_BY_REQUIRED] = "ORA-01788: CONNECT BY clause required in this query block"; ERROR_NAME[-OB_ERR_CBY_CONNECT_BY_PATH_NOT_ALLOWED] = "OB_ERR_CBY_CONNECT_BY_PATH_NOT_ALLOWED"; + ERROR_CAUSE[-OB_ERR_CBY_CONNECT_BY_PATH_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CBY_CONNECT_BY_PATH_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CBY_CONNECT_BY_PATH_NOT_ALLOWED] = -1; SQLSTATE[-OB_ERR_CBY_CONNECT_BY_PATH_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_ERR_CBY_CONNECT_BY_PATH_NOT_ALLOWED] = "SYS_CONNECT_BY_PATH function is not allowed here"; @@ -9996,6 +12095,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CBY_CONNECT_BY_PATH_NOT_ALLOWED] = "ORA-30002: SYS_CONNECT_BY_PATH function is not allowed here"; ERROR_NAME[-OB_ERR_CBY_CONNECT_BY_PATH_ILLEGAL_PARAM] = "OB_ERR_CBY_CONNECT_BY_PATH_ILLEGAL_PARAM"; + ERROR_CAUSE[-OB_ERR_CBY_CONNECT_BY_PATH_ILLEGAL_PARAM] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CBY_CONNECT_BY_PATH_ILLEGAL_PARAM] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CBY_CONNECT_BY_PATH_ILLEGAL_PARAM] = -1; SQLSTATE[-OB_ERR_CBY_CONNECT_BY_PATH_ILLEGAL_PARAM] = "HY000"; STR_ERROR[-OB_ERR_CBY_CONNECT_BY_PATH_ILLEGAL_PARAM] = "illegal parameter in SYS_CONNECT_BY_PATH function"; @@ -10006,6 +12107,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CBY_CONNECT_BY_PATH_ILLEGAL_PARAM] = "ORA-30003: illegal parameter in SYS_CONNECT_BY_PATH function"; ERROR_NAME[-OB_ERR_CBY_CONNECT_BY_PATH_INVALID_SEPARATOR] = "OB_ERR_CBY_CONNECT_BY_PATH_INVALID_SEPARATOR"; + ERROR_CAUSE[-OB_ERR_CBY_CONNECT_BY_PATH_INVALID_SEPARATOR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CBY_CONNECT_BY_PATH_INVALID_SEPARATOR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CBY_CONNECT_BY_PATH_INVALID_SEPARATOR] = -1; SQLSTATE[-OB_ERR_CBY_CONNECT_BY_PATH_INVALID_SEPARATOR] = "HY000"; STR_ERROR[-OB_ERR_CBY_CONNECT_BY_PATH_INVALID_SEPARATOR] = @@ -10022,6 +12125,8 @@ static struct ObStrErrorInit { "ORA-30004: A column value contained the string that the SYS_CONNECT_BY_PATH function was to use to separate " "column values."; ERROR_NAME[-OB_ERR_CBY_CONNECT_BY_ROOT_ILLEGAL_USED] = "OB_ERR_CBY_CONNECT_BY_ROOT_ILLEGAL_USED"; + ERROR_CAUSE[-OB_ERR_CBY_CONNECT_BY_ROOT_ILLEGAL_USED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CBY_CONNECT_BY_ROOT_ILLEGAL_USED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CBY_CONNECT_BY_ROOT_ILLEGAL_USED] = -1; SQLSTATE[-OB_ERR_CBY_CONNECT_BY_ROOT_ILLEGAL_USED] = "HY000"; STR_ERROR[-OB_ERR_CBY_CONNECT_BY_ROOT_ILLEGAL_USED] = @@ -10034,6 +12139,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CBY_CONNECT_BY_ROOT_ILLEGAL_USED] = "ORA-30007: CONNECT BY ROOT operator is not supported in the START WITH or in the CONNECT BY condition"; ERROR_NAME[-OB_ERR_CBY_OREDER_SIBLINGS_BY_NOT_ALLOWED] = "OB_ERR_CBY_OREDER_SIBLINGS_BY_NOT_ALLOWED"; + ERROR_CAUSE[-OB_ERR_CBY_OREDER_SIBLINGS_BY_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CBY_OREDER_SIBLINGS_BY_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CBY_OREDER_SIBLINGS_BY_NOT_ALLOWED] = -1; SQLSTATE[-OB_ERR_CBY_OREDER_SIBLINGS_BY_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_ERR_CBY_OREDER_SIBLINGS_BY_NOT_ALLOWED] = "ORDER SIBLINGS BY clause not allowed here"; @@ -10044,6 +12151,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CBY_OREDER_SIBLINGS_BY_NOT_ALLOWED] = "ORA-30929: ORDER SIBLINGS BY clause not allowed here"; ERROR_NAME[-OB_ERR_CBY_NOCYCLE_REQUIRED] = "OB_ERR_CBY_NOCYCLE_REQUIRED"; + ERROR_CAUSE[-OB_ERR_CBY_NOCYCLE_REQUIRED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CBY_NOCYCLE_REQUIRED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CBY_NOCYCLE_REQUIRED] = -1; SQLSTATE[-OB_ERR_CBY_NOCYCLE_REQUIRED] = "HY000"; STR_ERROR[-OB_ERR_CBY_NOCYCLE_REQUIRED] = "NOCYCLE keyword is required with CONNECT_BY_ISCYCLE pseudo column"; @@ -10054,6 +12163,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CBY_NOCYCLE_REQUIRED] = "ORA-30930: NOCYCLE keyword is required with CONNECT_BY_ISCYCLE pseudo column"; ERROR_NAME[-OB_ERR_NOT_ENOUGH_ARGS_FOR_FUN] = "OB_ERR_NOT_ENOUGH_ARGS_FOR_FUN"; + ERROR_CAUSE[-OB_ERR_NOT_ENOUGH_ARGS_FOR_FUN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NOT_ENOUGH_ARGS_FOR_FUN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NOT_ENOUGH_ARGS_FOR_FUN] = -1; SQLSTATE[-OB_ERR_NOT_ENOUGH_ARGS_FOR_FUN] = "HY000"; STR_ERROR[-OB_ERR_NOT_ENOUGH_ARGS_FOR_FUN] = "not enough arguments for function"; @@ -10062,6 +12173,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_NOT_ENOUGH_ARGS_FOR_FUN] = "ORA-00938: not enough arguments for function"; ORACLE_STR_USER_ERROR[-OB_ERR_NOT_ENOUGH_ARGS_FOR_FUN] = "ORA-00938: not enough arguments for function"; ERROR_NAME[-OB_ERR_PREPARE_STMT_CHECKSUM] = "OB_ERR_PREPARE_STMT_CHECKSUM"; + ERROR_CAUSE[-OB_ERR_PREPARE_STMT_CHECKSUM] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PREPARE_STMT_CHECKSUM] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PREPARE_STMT_CHECKSUM] = -1; SQLSTATE[-OB_ERR_PREPARE_STMT_CHECKSUM] = "HY000"; STR_ERROR[-OB_ERR_PREPARE_STMT_CHECKSUM] = "Prepare statement checksum error"; @@ -10070,6 +12183,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_PREPARE_STMT_CHECKSUM] = "ORA-00603: Oracle Server session terminated by fatal error"; ORACLE_STR_USER_ERROR[-OB_ERR_PREPARE_STMT_CHECKSUM] = "ORA-00603: Oracle Server session terminated by fatal error"; ERROR_NAME[-OB_ERR_ENABLE_NONEXISTENT_CONSTRAINT] = "OB_ERR_ENABLE_NONEXISTENT_CONSTRAINT"; + ERROR_CAUSE[-OB_ERR_ENABLE_NONEXISTENT_CONSTRAINT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ENABLE_NONEXISTENT_CONSTRAINT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ENABLE_NONEXISTENT_CONSTRAINT] = -1; SQLSTATE[-OB_ERR_ENABLE_NONEXISTENT_CONSTRAINT] = "HY000"; STR_ERROR[-OB_ERR_ENABLE_NONEXISTENT_CONSTRAINT] = "cannot enable constraint - no such constraint"; @@ -10080,6 +12195,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ENABLE_NONEXISTENT_CONSTRAINT] = "ORA-02430: cannot enable constraint (%.*s) - no such constraint"; ERROR_NAME[-OB_ERR_DISABLE_NONEXISTENT_CONSTRAINT] = "OB_ERR_DISABLE_NONEXISTENT_CONSTRAINT"; + ERROR_CAUSE[-OB_ERR_DISABLE_NONEXISTENT_CONSTRAINT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DISABLE_NONEXISTENT_CONSTRAINT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DISABLE_NONEXISTENT_CONSTRAINT] = -1; SQLSTATE[-OB_ERR_DISABLE_NONEXISTENT_CONSTRAINT] = "HY000"; STR_ERROR[-OB_ERR_DISABLE_NONEXISTENT_CONSTRAINT] = "cannot disable constraint - no such constraint"; @@ -10090,6 +12207,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DISABLE_NONEXISTENT_CONSTRAINT] = "ORA-02431: cannot disable constraint (%.*s) - no such constraint"; ERROR_NAME[-OB_ERR_DOWNGRADE_DOP] = "OB_ERR_DOWNGRADE_DOP"; + ERROR_CAUSE[-OB_ERR_DOWNGRADE_DOP] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DOWNGRADE_DOP] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DOWNGRADE_DOP] = -1; SQLSTATE[-OB_ERR_DOWNGRADE_DOP] = "HY000"; STR_ERROR[-OB_ERR_DOWNGRADE_DOP] = "PX DOP downgrade"; @@ -10098,6 +12217,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DOWNGRADE_DOP] = "ORA-00000: PX DOP downgrade"; ORACLE_STR_USER_ERROR[-OB_ERR_DOWNGRADE_DOP] = "ORA-00000: PX DOP downgrade from %ld to %ld"; ERROR_NAME[-OB_ERR_DOWNGRADE_PARALLEL_MAX_SERVERS] = "OB_ERR_DOWNGRADE_PARALLEL_MAX_SERVERS"; + ERROR_CAUSE[-OB_ERR_DOWNGRADE_PARALLEL_MAX_SERVERS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DOWNGRADE_PARALLEL_MAX_SERVERS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DOWNGRADE_PARALLEL_MAX_SERVERS] = -1; SQLSTATE[-OB_ERR_DOWNGRADE_PARALLEL_MAX_SERVERS] = "HY000"; STR_ERROR[-OB_ERR_DOWNGRADE_PARALLEL_MAX_SERVERS] = @@ -10110,6 +12231,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DOWNGRADE_PARALLEL_MAX_SERVERS] = "ORA-00000: parallel_max_servers downgrade due to insufficent cpu resource from %ld to %ld"; ERROR_NAME[-OB_ERR_ORPHANED_CHILD_RECORD_EXISTS] = "OB_ERR_ORPHANED_CHILD_RECORD_EXISTS"; + ERROR_CAUSE[-OB_ERR_ORPHANED_CHILD_RECORD_EXISTS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ORPHANED_CHILD_RECORD_EXISTS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ORPHANED_CHILD_RECORD_EXISTS] = -1; SQLSTATE[-OB_ERR_ORPHANED_CHILD_RECORD_EXISTS] = "HY000"; STR_ERROR[-OB_ERR_ORPHANED_CHILD_RECORD_EXISTS] = "cannot validate - parent keys not found"; @@ -10119,6 +12242,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ORPHANED_CHILD_RECORD_EXISTS] = "ORA-02298: cannot validate (%.*s.%.*s) - parent keys not found"; ERROR_NAME[-OB_ERR_COL_CHECK_CST_REFER_ANOTHER_COL] = "OB_ERR_COL_CHECK_CST_REFER_ANOTHER_COL"; + ERROR_CAUSE[-OB_ERR_COL_CHECK_CST_REFER_ANOTHER_COL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_COL_CHECK_CST_REFER_ANOTHER_COL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_COL_CHECK_CST_REFER_ANOTHER_COL] = -1; SQLSTATE[-OB_ERR_COL_CHECK_CST_REFER_ANOTHER_COL] = "HY000"; STR_ERROR[-OB_ERR_COL_CHECK_CST_REFER_ANOTHER_COL] = "Column check constraint cannot reference other columns"; @@ -10129,6 +12254,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_COL_CHECK_CST_REFER_ANOTHER_COL] = "ORA-02438: Column check constraint cannot reference other columns"; ERROR_NAME[-OB_BATCHED_MULTI_STMT_ROLLBACK] = "OB_BATCHED_MULTI_STMT_ROLLBACK"; + ERROR_CAUSE[-OB_BATCHED_MULTI_STMT_ROLLBACK] = "Internal Error"; + ERROR_SOLUTION[-OB_BATCHED_MULTI_STMT_ROLLBACK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BATCHED_MULTI_STMT_ROLLBACK] = -1; SQLSTATE[-OB_BATCHED_MULTI_STMT_ROLLBACK] = "HY000"; STR_ERROR[-OB_BATCHED_MULTI_STMT_ROLLBACK] = "batched multi statement execution needs rollback"; @@ -10139,6 +12266,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_BATCHED_MULTI_STMT_ROLLBACK] = "ORA-00600: internal error code, arguments: -5787, batched multi statement execution needs rollback"; ERROR_NAME[-OB_ERR_FOR_UPDATE_SELECT_VIEW_CANNOT] = "OB_ERR_FOR_UPDATE_SELECT_VIEW_CANNOT"; + ERROR_CAUSE[-OB_ERR_FOR_UPDATE_SELECT_VIEW_CANNOT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_FOR_UPDATE_SELECT_VIEW_CANNOT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_FOR_UPDATE_SELECT_VIEW_CANNOT] = -1; SQLSTATE[-OB_ERR_FOR_UPDATE_SELECT_VIEW_CANNOT] = "HY000"; STR_ERROR[-OB_ERR_FOR_UPDATE_SELECT_VIEW_CANNOT] = @@ -10151,6 +12280,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_FOR_UPDATE_SELECT_VIEW_CANNOT] = "ORA-02014: cannot select FOR UPDATE from view with DISTINCT, GROUP BY, etc."; ERROR_NAME[-OB_ERR_POLICY_WITH_CHECK_OPTION_VIOLATION] = "OB_ERR_POLICY_WITH_CHECK_OPTION_VIOLATION"; + ERROR_CAUSE[-OB_ERR_POLICY_WITH_CHECK_OPTION_VIOLATION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_POLICY_WITH_CHECK_OPTION_VIOLATION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_POLICY_WITH_CHECK_OPTION_VIOLATION] = -1; SQLSTATE[-OB_ERR_POLICY_WITH_CHECK_OPTION_VIOLATION] = "HY000"; STR_ERROR[-OB_ERR_POLICY_WITH_CHECK_OPTION_VIOLATION] = "policy with check option violation"; @@ -10159,6 +12290,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_POLICY_WITH_CHECK_OPTION_VIOLATION] = "ORA-28115: policy with check option violation"; ORACLE_STR_USER_ERROR[-OB_ERR_POLICY_WITH_CHECK_OPTION_VIOLATION] = "ORA-28115: policy with check option violation"; ERROR_NAME[-OB_ERR_POLICY_ALREADY_APPLIED_TO_TABLE] = "OB_ERR_POLICY_ALREADY_APPLIED_TO_TABLE"; + ERROR_CAUSE[-OB_ERR_POLICY_ALREADY_APPLIED_TO_TABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_POLICY_ALREADY_APPLIED_TO_TABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_POLICY_ALREADY_APPLIED_TO_TABLE] = -1; SQLSTATE[-OB_ERR_POLICY_ALREADY_APPLIED_TO_TABLE] = "HY000"; STR_ERROR[-OB_ERR_POLICY_ALREADY_APPLIED_TO_TABLE] = "policy already applied to table"; @@ -10167,6 +12300,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_POLICY_ALREADY_APPLIED_TO_TABLE] = "ORA-12444: policy already applied to table"; ORACLE_STR_USER_ERROR[-OB_ERR_POLICY_ALREADY_APPLIED_TO_TABLE] = "ORA-12444: policy already applied to table"; ERROR_NAME[-OB_ERR_MUTATING_TABLE_OPERATION] = "OB_ERR_MUTATING_TABLE_OPERATION"; + ERROR_CAUSE[-OB_ERR_MUTATING_TABLE_OPERATION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MUTATING_TABLE_OPERATION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MUTATING_TABLE_OPERATION] = -1; SQLSTATE[-OB_ERR_MUTATING_TABLE_OPERATION] = "HY000"; STR_ERROR[-OB_ERR_MUTATING_TABLE_OPERATION] = "table is mutating, trigger/function may not see it"; @@ -10178,6 +12313,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MUTATING_TABLE_OPERATION] = "ORA-04091: table '%.*s'.'%.*s' is mutating, trigger/function may not see it"; ERROR_NAME[-OB_ERR_MODIFY_OR_DROP_MULTI_COLUMN_CONSTRAINT] = "OB_ERR_MODIFY_OR_DROP_MULTI_COLUMN_CONSTRAINT"; + ERROR_CAUSE[-OB_ERR_MODIFY_OR_DROP_MULTI_COLUMN_CONSTRAINT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MODIFY_OR_DROP_MULTI_COLUMN_CONSTRAINT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MODIFY_OR_DROP_MULTI_COLUMN_CONSTRAINT] = -1; SQLSTATE[-OB_ERR_MODIFY_OR_DROP_MULTI_COLUMN_CONSTRAINT] = "HY000"; STR_ERROR[-OB_ERR_MODIFY_OR_DROP_MULTI_COLUMN_CONSTRAINT] = "column is referenced in a multi-column constraint"; @@ -10189,6 +12326,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MODIFY_OR_DROP_MULTI_COLUMN_CONSTRAINT] = "ORA-12991: column is referenced in a multi-column constraint"; ERROR_NAME[-OB_ERR_DROP_PARENT_KEY_COLUMN] = "OB_ERR_DROP_PARENT_KEY_COLUMN"; + ERROR_CAUSE[-OB_ERR_DROP_PARENT_KEY_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DROP_PARENT_KEY_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DROP_PARENT_KEY_COLUMN] = -1; SQLSTATE[-OB_ERR_DROP_PARENT_KEY_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_DROP_PARENT_KEY_COLUMN] = "cannot drop parent key column"; @@ -10197,6 +12336,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DROP_PARENT_KEY_COLUMN] = "ORA-12992: cannot drop parent key column"; ORACLE_STR_USER_ERROR[-OB_ERR_DROP_PARENT_KEY_COLUMN] = "ORA-12992: cannot drop parent key column"; ERROR_NAME[-OB_AUTOINC_SERVICE_BUSY] = "OB_AUTOINC_SERVICE_BUSY"; + ERROR_CAUSE[-OB_AUTOINC_SERVICE_BUSY] = "Internal Error"; + ERROR_SOLUTION[-OB_AUTOINC_SERVICE_BUSY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_AUTOINC_SERVICE_BUSY] = -1; SQLSTATE[-OB_AUTOINC_SERVICE_BUSY] = "HY000"; STR_ERROR[-OB_AUTOINC_SERVICE_BUSY] = "auto increment service busy"; @@ -10205,6 +12346,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_AUTOINC_SERVICE_BUSY] = "ORA-00600: auto increment service busy"; ORACLE_STR_USER_ERROR[-OB_AUTOINC_SERVICE_BUSY] = "ORA-00600: auto increment service busy"; ERROR_NAME[-OB_ERR_CONSTRAINT_CONSTRAINT_DISABLE_VALIDATE] = "OB_ERR_CONSTRAINT_CONSTRAINT_DISABLE_VALIDATE"; + ERROR_CAUSE[-OB_ERR_CONSTRAINT_CONSTRAINT_DISABLE_VALIDATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CONSTRAINT_CONSTRAINT_DISABLE_VALIDATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CONSTRAINT_CONSTRAINT_DISABLE_VALIDATE] = -1; SQLSTATE[-OB_ERR_CONSTRAINT_CONSTRAINT_DISABLE_VALIDATE] = "HY000"; STR_ERROR[-OB_ERR_CONSTRAINT_CONSTRAINT_DISABLE_VALIDATE] = @@ -10217,6 +12360,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CONSTRAINT_CONSTRAINT_DISABLE_VALIDATE] = "ORA-25128: No insert/update/delete on table with constraint (%.*s.%.*s) disabled and validated"; ERROR_NAME[-OB_ERR_AUTONOMOUS_TRANSACTION_ROLLBACK] = "OB_ERR_AUTONOMOUS_TRANSACTION_ROLLBACK"; + ERROR_CAUSE[-OB_ERR_AUTONOMOUS_TRANSACTION_ROLLBACK] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_AUTONOMOUS_TRANSACTION_ROLLBACK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_AUTONOMOUS_TRANSACTION_ROLLBACK] = -1; SQLSTATE[-OB_ERR_AUTONOMOUS_TRANSACTION_ROLLBACK] = "HY000"; STR_ERROR[-OB_ERR_AUTONOMOUS_TRANSACTION_ROLLBACK] = "active autonomous transaction detected and rolled back"; @@ -10227,6 +12372,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_AUTONOMOUS_TRANSACTION_ROLLBACK] = "ORA-06519: active autonomous transaction detected and rolled back"; ERROR_NAME[-OB_ORDERBY_CLAUSE_NOT_ALLOWED] = "OB_ORDERBY_CLAUSE_NOT_ALLOWED"; + ERROR_CAUSE[-OB_ORDERBY_CLAUSE_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_ORDERBY_CLAUSE_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ORDERBY_CLAUSE_NOT_ALLOWED] = -1; SQLSTATE[-OB_ORDERBY_CLAUSE_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_ORDERBY_CLAUSE_NOT_ALLOWED] = "ORDER BY not allowed here"; @@ -10235,6 +12382,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ORDERBY_CLAUSE_NOT_ALLOWED] = "ORA-30487: ORDER BY not allowed here"; ORACLE_STR_USER_ERROR[-OB_ORDERBY_CLAUSE_NOT_ALLOWED] = "ORA-30487: ORDER BY not allowed here"; ERROR_NAME[-OB_DISTINCT_NOT_ALLOWED] = "OB_DISTINCT_NOT_ALLOWED"; + ERROR_CAUSE[-OB_DISTINCT_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_DISTINCT_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DISTINCT_NOT_ALLOWED] = -1; SQLSTATE[-OB_DISTINCT_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_DISTINCT_NOT_ALLOWED] = "DISTINCT not allowed here"; @@ -10243,6 +12392,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_DISTINCT_NOT_ALLOWED] = "ORA-30482: DISTINCT not allowed here"; ORACLE_STR_USER_ERROR[-OB_DISTINCT_NOT_ALLOWED] = "ORA-30482: DISTINCT not allowed here"; ERROR_NAME[-OB_ERR_ASSIGN_USER_VARIABLE_NOT_ALLOWED] = "OB_ERR_ASSIGN_USER_VARIABLE_NOT_ALLOWED"; + ERROR_CAUSE[-OB_ERR_ASSIGN_USER_VARIABLE_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ASSIGN_USER_VARIABLE_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ASSIGN_USER_VARIABLE_NOT_ALLOWED] = -1; SQLSTATE[-OB_ERR_ASSIGN_USER_VARIABLE_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_ERR_ASSIGN_USER_VARIABLE_NOT_ALLOWED] = @@ -10257,6 +12408,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5799, assign user variable with := only allowed in select filed " "list and as root expression"; ERROR_NAME[-OB_ERR_MODIFY_NONEXISTENT_CONSTRAINT] = "OB_ERR_MODIFY_NONEXISTENT_CONSTRAINT"; + ERROR_CAUSE[-OB_ERR_MODIFY_NONEXISTENT_CONSTRAINT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MODIFY_NONEXISTENT_CONSTRAINT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MODIFY_NONEXISTENT_CONSTRAINT] = -1; SQLSTATE[-OB_ERR_MODIFY_NONEXISTENT_CONSTRAINT] = "HY000"; STR_ERROR[-OB_ERR_MODIFY_NONEXISTENT_CONSTRAINT] = "cannot modify constraint - no such constraint"; @@ -10267,6 +12420,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MODIFY_NONEXISTENT_CONSTRAINT] = "ORA-25129: cannot modify constraint (%.*s) - no such constraint"; ERROR_NAME[-OB_ERR_SP_EXCEPTION_HANDLE_ILLEGAL] = "OB_ERR_SP_EXCEPTION_HANDLE_ILLEGAL"; + ERROR_CAUSE[-OB_ERR_SP_EXCEPTION_HANDLE_ILLEGAL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SP_EXCEPTION_HANDLE_ILLEGAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SP_EXCEPTION_HANDLE_ILLEGAL] = -1; SQLSTATE[-OB_ERR_SP_EXCEPTION_HANDLE_ILLEGAL] = "HY000"; STR_ERROR[-OB_ERR_SP_EXCEPTION_HANDLE_ILLEGAL] = @@ -10281,6 +12436,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5801, implementation restriction: exception handler in nested " "transaction is illegal"; ERROR_NAME[-OB_INVALID_ROWID] = "OB_INVALID_ROWID"; + ERROR_CAUSE[-OB_INVALID_ROWID] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_ROWID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_ROWID] = -1; SQLSTATE[-OB_INVALID_ROWID] = "HY000"; STR_ERROR[-OB_INVALID_ROWID] = "invalid ROWID"; @@ -10289,6 +12446,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_INVALID_ROWID] = "ORA-01410: invalid ROWID"; ORACLE_STR_USER_ERROR[-OB_INVALID_ROWID] = "ORA-01410: invalid ROWID"; ERROR_NAME[-OB_ERR_INVALID_INSERT_COLUMN] = "OB_ERR_INVALID_INSERT_COLUMN"; + ERROR_CAUSE[-OB_ERR_INVALID_INSERT_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_INSERT_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_INSERT_COLUMN] = -1; SQLSTATE[-OB_ERR_INVALID_INSERT_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_INVALID_INSERT_COLUMN] = "Invalid column in the INSERT VALUES Clause"; @@ -10298,6 +12457,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_INSERT_COLUMN] = "ORA-38101: Invalid column in the INSERT VALUES Clause:'%.*s'.'%.*s'"; ERROR_NAME[-OB_INCORRECT_USE_OF_OPERATOR] = "OB_INCORRECT_USE_OF_OPERATOR"; + ERROR_CAUSE[-OB_INCORRECT_USE_OF_OPERATOR] = "Internal Error"; + ERROR_SOLUTION[-OB_INCORRECT_USE_OF_OPERATOR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INCORRECT_USE_OF_OPERATOR] = -1; SQLSTATE[-OB_INCORRECT_USE_OF_OPERATOR] = "HY000"; STR_ERROR[-OB_INCORRECT_USE_OF_OPERATOR] = "incorrect use of operator"; @@ -10307,6 +12468,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INCORRECT_USE_OF_OPERATOR] = "ORA-13207: incorrect use of the ['%.*s'] operator"; ERROR_NAME[-OB_ERR_NON_CONST_EXPR_IS_NOT_ALLOWED_FOR_PIVOT_UNPIVOT_VALUES] = "OB_ERR_NON_CONST_EXPR_IS_NOT_ALLOWED_FOR_PIVOT_UNPIVOT_VALUES"; + ERROR_CAUSE[-OB_ERR_NON_CONST_EXPR_IS_NOT_ALLOWED_FOR_PIVOT_UNPIVOT_VALUES] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NON_CONST_EXPR_IS_NOT_ALLOWED_FOR_PIVOT_UNPIVOT_VALUES] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NON_CONST_EXPR_IS_NOT_ALLOWED_FOR_PIVOT_UNPIVOT_VALUES] = -1; SQLSTATE[-OB_ERR_NON_CONST_EXPR_IS_NOT_ALLOWED_FOR_PIVOT_UNPIVOT_VALUES] = "HY000"; STR_ERROR[-OB_ERR_NON_CONST_EXPR_IS_NOT_ALLOWED_FOR_PIVOT_UNPIVOT_VALUES] = @@ -10320,6 +12483,8 @@ static struct ObStrErrorInit { "ORA-56901: non-constant expression is not allowed for pivot|unpivot values"; ERROR_NAME[-OB_ERR_EXPECT_AGGREGATE_FUNCTION_INSIDE_PIVOT_OPERATION] = "OB_ERR_EXPECT_AGGREGATE_FUNCTION_INSIDE_PIVOT_OPERATION"; + ERROR_CAUSE[-OB_ERR_EXPECT_AGGREGATE_FUNCTION_INSIDE_PIVOT_OPERATION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_EXPECT_AGGREGATE_FUNCTION_INSIDE_PIVOT_OPERATION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_EXPECT_AGGREGATE_FUNCTION_INSIDE_PIVOT_OPERATION] = -1; SQLSTATE[-OB_ERR_EXPECT_AGGREGATE_FUNCTION_INSIDE_PIVOT_OPERATION] = "HY000"; STR_ERROR[-OB_ERR_EXPECT_AGGREGATE_FUNCTION_INSIDE_PIVOT_OPERATION] = @@ -10332,6 +12497,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_EXPECT_AGGREGATE_FUNCTION_INSIDE_PIVOT_OPERATION] = "ORA-56902: expect aggregate function inside pivot operation"; ERROR_NAME[-OB_ERR_EXP_NEED_SAME_DATATYPE] = "OB_ERR_EXP_NEED_SAME_DATATYPE"; + ERROR_CAUSE[-OB_ERR_EXP_NEED_SAME_DATATYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_EXP_NEED_SAME_DATATYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_EXP_NEED_SAME_DATATYPE] = -1; SQLSTATE[-OB_ERR_EXP_NEED_SAME_DATATYPE] = "HY000"; STR_ERROR[-OB_ERR_EXP_NEED_SAME_DATATYPE] = "expression must have same datatype as corresponding expression"; @@ -10342,6 +12509,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_EXP_NEED_SAME_DATATYPE] = "ORA-01790: expression must have same datatype as corresponding expression"; ERROR_NAME[-OB_ERR_CHARACTER_SET_MISMATCH] = "OB_ERR_CHARACTER_SET_MISMATCH"; + ERROR_CAUSE[-OB_ERR_CHARACTER_SET_MISMATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CHARACTER_SET_MISMATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CHARACTER_SET_MISMATCH] = -1; SQLSTATE[-OB_ERR_CHARACTER_SET_MISMATCH] = "HY000"; STR_ERROR[-OB_ERR_CHARACTER_SET_MISMATCH] = "character set mismatch"; @@ -10350,6 +12519,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CHARACTER_SET_MISMATCH] = "ORA-12704: character set mismatch"; ORACLE_STR_USER_ERROR[-OB_ERR_CHARACTER_SET_MISMATCH] = "ORA-12704: character set mismatch"; ERROR_NAME[-OB_ERR_REGEXP_NOMATCH] = "OB_ERR_REGEXP_NOMATCH"; + ERROR_CAUSE[-OB_ERR_REGEXP_NOMATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_NOMATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_NOMATCH] = -1; SQLSTATE[-OB_ERR_REGEXP_NOMATCH] = "HY000"; STR_ERROR[-OB_ERR_REGEXP_NOMATCH] = "regular expression failed to match"; @@ -10360,6 +12531,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_NOMATCH] = "ORA-00600: internal error code, arguments: -5809, regular expression failed to match"; ERROR_NAME[-OB_ERR_REGEXP_BADPAT] = "OB_ERR_REGEXP_BADPAT"; + ERROR_CAUSE[-OB_ERR_REGEXP_BADPAT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_BADPAT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_BADPAT] = -1; SQLSTATE[-OB_ERR_REGEXP_BADPAT] = "HY000"; STR_ERROR[-OB_ERR_REGEXP_BADPAT] = "invalid regular expression (reg version 0.8)"; @@ -10370,6 +12543,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_BADPAT] = "ORA-00600: internal error code, arguments: -5810, invalid regular expression (reg version 0.8)"; ERROR_NAME[-OB_ERR_REGEXP_EESCAPE] = "OB_ERR_REGEXP_EESCAPE"; + ERROR_CAUSE[-OB_ERR_REGEXP_EESCAPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_EESCAPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_EESCAPE] = -1; SQLSTATE[-OB_ERR_REGEXP_EESCAPE] = "HY000"; STR_ERROR[-OB_ERR_REGEXP_EESCAPE] = "invalid escape \\ sequence in regular expression"; @@ -10380,6 +12555,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_EESCAPE] = "ORA-00600: internal error code, arguments: -5811, invalid escape \\ sequence in regular expression"; ERROR_NAME[-OB_ERR_REGEXP_EBRACK] = "OB_ERR_REGEXP_EBRACK"; + ERROR_CAUSE[-OB_ERR_REGEXP_EBRACK] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_EBRACK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_EBRACK] = -1; SQLSTATE[-OB_ERR_REGEXP_EBRACK] = "HY000"; STR_ERROR[-OB_ERR_REGEXP_EBRACK] = "unmatched bracket in regular expression"; @@ -10388,6 +12565,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_REGEXP_EBRACK] = "ORA-12726: unmatched bracket in regular expression"; ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_EBRACK] = "ORA-12726: unmatched bracket in regular expression"; ERROR_NAME[-OB_ERR_REGEXP_EPAREN] = "OB_ERR_REGEXP_EPAREN"; + ERROR_CAUSE[-OB_ERR_REGEXP_EPAREN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_EPAREN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_EPAREN] = -1; SQLSTATE[-OB_ERR_REGEXP_EPAREN] = "HY000"; STR_ERROR[-OB_ERR_REGEXP_EPAREN] = "unmatched parentheses in regular expression"; @@ -10396,6 +12575,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_REGEXP_EPAREN] = "ORA-12725: unmatched parentheses in regular expression"; ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_EPAREN] = "ORA-12725: unmatched parentheses in regular expression"; ERROR_NAME[-OB_ERR_REGEXP_ESUBREG] = "OB_ERR_REGEXP_ESUBREG"; + ERROR_CAUSE[-OB_ERR_REGEXP_ESUBREG] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_ESUBREG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_ESUBREG] = -1; SQLSTATE[-OB_ERR_REGEXP_ESUBREG] = "HY000"; STR_ERROR[-OB_ERR_REGEXP_ESUBREG] = "invalid back reference in regular expression"; @@ -10404,6 +12585,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_REGEXP_ESUBREG] = "ORA-12727: invalid back reference in regular expression"; ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_ESUBREG] = "ORA-12727: invalid back reference in regular expression"; ERROR_NAME[-OB_ERR_REGEXP_ERANGE] = "OB_ERR_REGEXP_ERANGE"; + ERROR_CAUSE[-OB_ERR_REGEXP_ERANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_ERANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_ERANGE] = -1; SQLSTATE[-OB_ERR_REGEXP_ERANGE] = "HY000"; STR_ERROR[-OB_ERR_REGEXP_ERANGE] = "invalid range in regular expression"; @@ -10412,6 +12595,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_REGEXP_ERANGE] = "ORA-12728: invalid range in regular expression"; ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_ERANGE] = "ORA-12728: invalid range in regular expression"; ERROR_NAME[-OB_ERR_REGEXP_ECTYPE] = "OB_ERR_REGEXP_ECTYPE"; + ERROR_CAUSE[-OB_ERR_REGEXP_ECTYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_ECTYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_ECTYPE] = -1; SQLSTATE[-OB_ERR_REGEXP_ECTYPE] = "HY000"; STR_ERROR[-OB_ERR_REGEXP_ECTYPE] = "invalid character class in regular expression"; @@ -10420,16 +12605,18 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_REGEXP_ECTYPE] = "ORA-12729: invalid character class in regular expression"; ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_ECTYPE] = "ORA-12729: invalid character class in regular expression"; ERROR_NAME[-OB_ERR_REGEXP_ECOLLATE] = "OB_ERR_REGEXP_ECOLLATE"; + ERROR_CAUSE[-OB_ERR_REGEXP_ECOLLATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_ECOLLATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_ECOLLATE] = -1; SQLSTATE[-OB_ERR_REGEXP_ECOLLATE] = "HY000"; STR_ERROR[-OB_ERR_REGEXP_ECOLLATE] = "invalid collation class in regular expression"; STR_USER_ERROR[-OB_ERR_REGEXP_ECOLLATE] = "invalid collation class in regular expression"; - ORACLE_ERRNO[-OB_ERR_REGEXP_ECOLLATE] = 600; - ORACLE_STR_ERROR[-OB_ERR_REGEXP_ECOLLATE] = - "ORA-00600: internal error code, arguments: -5817, invalid collation class in regular expression"; - ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_ECOLLATE] = - "ORA-00600: internal error code, arguments: -5817, invalid collation class in regular expression"; + ORACLE_ERRNO[-OB_ERR_REGEXP_ECOLLATE] = 12731; + ORACLE_STR_ERROR[-OB_ERR_REGEXP_ECOLLATE] = "ORA-12731: invalid collation class in regular expression"; + ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_ECOLLATE] = "ORA-12731: invalid collation class in regular expression"; ERROR_NAME[-OB_ERR_REGEXP_EBRACE] = "OB_ERR_REGEXP_EBRACE"; + ERROR_CAUSE[-OB_ERR_REGEXP_EBRACE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_EBRACE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_EBRACE] = -1; SQLSTATE[-OB_ERR_REGEXP_EBRACE] = "HY000"; STR_ERROR[-OB_ERR_REGEXP_EBRACE] = "braces {} not balanced in in regular expression"; @@ -10440,6 +12627,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_EBRACE] = "ORA-00600: internal error code, arguments: -5818, braces {} not balanced in in regular expression"; ERROR_NAME[-OB_ERR_REGEXP_BADBR] = "OB_ERR_REGEXP_BADBR"; + ERROR_CAUSE[-OB_ERR_REGEXP_BADBR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_BADBR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_BADBR] = -1; SQLSTATE[-OB_ERR_REGEXP_BADBR] = "HY000"; STR_ERROR[-OB_ERR_REGEXP_BADBR] = "invalid repetition count(s) in regular expression"; @@ -10450,6 +12639,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_BADBR] = "ORA-00600: internal error code, arguments: -5819, invalid repetition count(s) in regular expression"; ERROR_NAME[-OB_ERR_REGEXP_BADRPT] = "OB_ERR_REGEXP_BADRPT"; + ERROR_CAUSE[-OB_ERR_REGEXP_BADRPT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_BADRPT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_BADRPT] = -1; SQLSTATE[-OB_ERR_REGEXP_BADRPT] = "HY000"; STR_ERROR[-OB_ERR_REGEXP_BADRPT] = "The regular expression was too complex and current library can't be parsed"; @@ -10461,6 +12652,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_BADRPT] = "ORA-00600: internal error code, arguments: -5820, The regular " "expression was too complex and current library can't be parsed"; ERROR_NAME[-OB_ERR_REGEXP_ASSERT] = "OB_ERR_REGEXP_ASSERT"; + ERROR_CAUSE[-OB_ERR_REGEXP_ASSERT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_ASSERT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_ASSERT] = -1; SQLSTATE[-OB_ERR_REGEXP_ASSERT] = "HY000"; STR_ERROR[-OB_ERR_REGEXP_ASSERT] = "regular expression internal error"; @@ -10471,6 +12664,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_ASSERT] = "ORA-00600: internal error code, arguments: -5821, regular expression internal error"; ERROR_NAME[-OB_ERR_REGEXP_INVARG] = "OB_ERR_REGEXP_INVARG"; + ERROR_CAUSE[-OB_ERR_REGEXP_INVARG] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_INVARG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_INVARG] = -1; SQLSTATE[-OB_ERR_REGEXP_INVARG] = "HY000"; STR_ERROR[-OB_ERR_REGEXP_INVARG] = "invalid argument in regular expression"; @@ -10481,6 +12676,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_INVARG] = "ORA-00600: internal error code, arguments: -5822, invalid argument in regular expression"; ERROR_NAME[-OB_ERR_REGEXP_MIXED] = "OB_ERR_REGEXP_MIXED"; + ERROR_CAUSE[-OB_ERR_REGEXP_MIXED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_MIXED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_MIXED] = -1; SQLSTATE[-OB_ERR_REGEXP_MIXED] = "HY000"; STR_ERROR[-OB_ERR_REGEXP_MIXED] = "character widths of regex and string differ in regular expression"; @@ -10491,6 +12688,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_MIXED] = "ORA-00600: internal error code, arguments: -5823, character widths " "of regex and string differ in regular expression"; ERROR_NAME[-OB_ERR_REGEXP_BADOPT] = "OB_ERR_REGEXP_BADOPT"; + ERROR_CAUSE[-OB_ERR_REGEXP_BADOPT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_BADOPT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_BADOPT] = -1; SQLSTATE[-OB_ERR_REGEXP_BADOPT] = "HY000"; STR_ERROR[-OB_ERR_REGEXP_BADOPT] = "invalid embedded option in regular expression"; @@ -10501,6 +12700,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_REGEXP_BADOPT] = "ORA-00600: internal error code, arguments: -5824, invalid embedded option in regular expression"; ERROR_NAME[-OB_ERR_REGEXP_ETOOBIG] = "OB_ERR_REGEXP_ETOOBIG"; + ERROR_CAUSE[-OB_ERR_REGEXP_ETOOBIG] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REGEXP_ETOOBIG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REGEXP_ETOOBIG] = -1; SQLSTATE[-OB_ERR_REGEXP_ETOOBIG] = "HY000"; STR_ERROR[-OB_ERR_REGEXP_ETOOBIG] = @@ -10514,6 +12715,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5825, nfa has too many states in regular expression, may be the " "regular expression too long"; ERROR_NAME[-OB_NOT_SUPPORTED_ROWID_TYPE] = "OB_NOT_SUPPORTED_ROWID_TYPE"; + ERROR_CAUSE[-OB_NOT_SUPPORTED_ROWID_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_SUPPORTED_ROWID_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_SUPPORTED_ROWID_TYPE] = -1; SQLSTATE[-OB_NOT_SUPPORTED_ROWID_TYPE] = "HY000"; STR_ERROR[-OB_NOT_SUPPORTED_ROWID_TYPE] = "ROWID for tables without primary key is not implemented"; @@ -10524,6 +12727,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NOT_SUPPORTED_ROWID_TYPE] = "ORA-00600: internal error code, arguments: -5826, ROWID for tables without primary key is not implemented"; ERROR_NAME[-OB_ERR_PARALLEL_DDL_CONFLICT] = "OB_ERR_PARALLEL_DDL_CONFLICT"; + ERROR_CAUSE[-OB_ERR_PARALLEL_DDL_CONFLICT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARALLEL_DDL_CONFLICT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARALLEL_DDL_CONFLICT] = -1; SQLSTATE[-OB_ERR_PARALLEL_DDL_CONFLICT] = "HY000"; STR_ERROR[-OB_ERR_PARALLEL_DDL_CONFLICT] = @@ -10538,6 +12743,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5827, the definition of relative objects have been modified, " "please check and retry"; ERROR_NAME[-OB_ERR_SUBSCRIPT_BEYOND_COUNT] = "OB_ERR_SUBSCRIPT_BEYOND_COUNT"; + ERROR_CAUSE[-OB_ERR_SUBSCRIPT_BEYOND_COUNT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SUBSCRIPT_BEYOND_COUNT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SUBSCRIPT_BEYOND_COUNT] = -1; SQLSTATE[-OB_ERR_SUBSCRIPT_BEYOND_COUNT] = "HY000"; STR_ERROR[-OB_ERR_SUBSCRIPT_BEYOND_COUNT] = "Subscript beyond count"; @@ -10546,6 +12753,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SUBSCRIPT_BEYOND_COUNT] = "ORA-06533: Subscript beyond count"; ORACLE_STR_USER_ERROR[-OB_ERR_SUBSCRIPT_BEYOND_COUNT] = "ORA-06533: Subscript beyond count"; ERROR_NAME[-OB_ERR_NOT_PARTITIONED] = "OB_ERR_NOT_PARTITIONED"; + ERROR_CAUSE[-OB_ERR_NOT_PARTITIONED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NOT_PARTITIONED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NOT_PARTITIONED] = -1; SQLSTATE[-OB_ERR_NOT_PARTITIONED] = "HY000"; STR_ERROR[-OB_ERR_NOT_PARTITIONED] = "PARTITION () clause on non partitioned table"; @@ -10554,6 +12763,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_NOT_PARTITIONED] = "ORA-14501: object is not partitioned"; ORACLE_STR_USER_ERROR[-OB_ERR_NOT_PARTITIONED] = "ORA-14501: object is not partitioned"; ERROR_NAME[-OB_UNKNOWN_SUBPARTITION] = "OB_UNKNOWN_SUBPARTITION"; + ERROR_CAUSE[-OB_UNKNOWN_SUBPARTITION] = "Internal Error"; + ERROR_SOLUTION[-OB_UNKNOWN_SUBPARTITION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_UNKNOWN_SUBPARTITION] = -1; SQLSTATE[-OB_UNKNOWN_SUBPARTITION] = "HY000"; STR_ERROR[-OB_UNKNOWN_SUBPARTITION] = "Unknown subpartition"; @@ -10562,6 +12773,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_UNKNOWN_SUBPARTITION] = "ORA-14251: Specified subpartition does not exist"; ORACLE_STR_USER_ERROR[-OB_UNKNOWN_SUBPARTITION] = "ORA-14251: Specified subpartition does not exist"; ERROR_NAME[-OB_ERR_INVALID_SQL_ROW_LIMITING] = "OB_ERR_INVALID_SQL_ROW_LIMITING"; + ERROR_CAUSE[-OB_ERR_INVALID_SQL_ROW_LIMITING] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_SQL_ROW_LIMITING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_SQL_ROW_LIMITING] = -1; SQLSTATE[-OB_ERR_INVALID_SQL_ROW_LIMITING] = "HY000"; STR_ERROR[-OB_ERR_INVALID_SQL_ROW_LIMITING] = "Invalid SQL ROW LIMITING expression was specified."; @@ -10572,6 +12785,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_SQL_ROW_LIMITING] = "ORA-62550: Invalid SQL ROW LIMITING expression was specified."; ERROR_NAME[-INCORRECT_ARGUMENTS_TO_ESCAPE] = "INCORRECT_ARGUMENTS_TO_ESCAPE"; + ERROR_CAUSE[-INCORRECT_ARGUMENTS_TO_ESCAPE] = "Internal Error"; + ERROR_SOLUTION[-INCORRECT_ARGUMENTS_TO_ESCAPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-INCORRECT_ARGUMENTS_TO_ESCAPE] = -1210; SQLSTATE[-INCORRECT_ARGUMENTS_TO_ESCAPE] = "HY000"; STR_ERROR[-INCORRECT_ARGUMENTS_TO_ESCAPE] = "Incorrect arguments to ESCAPE"; @@ -10582,6 +12797,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-INCORRECT_ARGUMENTS_TO_ESCAPE] = "ORA-00600: internal error code, arguments: -5832, Incorrect arguments to ESCAPE"; ERROR_NAME[-STATIC_ENG_NOT_IMPLEMENT] = "STATIC_ENG_NOT_IMPLEMENT"; + ERROR_CAUSE[-STATIC_ENG_NOT_IMPLEMENT] = "Internal Error"; + ERROR_SOLUTION[-STATIC_ENG_NOT_IMPLEMENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-STATIC_ENG_NOT_IMPLEMENT] = -1; SQLSTATE[-STATIC_ENG_NOT_IMPLEMENT] = "HY000"; STR_ERROR[-STATIC_ENG_NOT_IMPLEMENT] = @@ -10595,6 +12812,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5833, not implemented in SQL static typing engine, will try the " "old engine automatically"; ERROR_NAME[-OB_OBJ_ALREADY_EXIST] = "OB_OBJ_ALREADY_EXIST"; + ERROR_CAUSE[-OB_OBJ_ALREADY_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_OBJ_ALREADY_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OBJ_ALREADY_EXIST] = -1; SQLSTATE[-OB_OBJ_ALREADY_EXIST] = "HY000"; STR_ERROR[-OB_OBJ_ALREADY_EXIST] = "name is already used by an existing object"; @@ -10603,6 +12822,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_OBJ_ALREADY_EXIST] = "ORA-00955: name is already used by an existing object"; ORACLE_STR_USER_ERROR[-OB_OBJ_ALREADY_EXIST] = "ORA-00955: name is already used by an existing object"; ERROR_NAME[-OB_DBLINK_NOT_EXIST_TO_ACCESS] = "OB_DBLINK_NOT_EXIST_TO_ACCESS"; + ERROR_CAUSE[-OB_DBLINK_NOT_EXIST_TO_ACCESS] = "Internal Error"; + ERROR_SOLUTION[-OB_DBLINK_NOT_EXIST_TO_ACCESS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DBLINK_NOT_EXIST_TO_ACCESS] = -1; SQLSTATE[-OB_DBLINK_NOT_EXIST_TO_ACCESS] = "HY000"; STR_ERROR[-OB_DBLINK_NOT_EXIST_TO_ACCESS] = "connection description for remote database not found"; @@ -10613,6 +12834,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_DBLINK_NOT_EXIST_TO_ACCESS] = "ORA-02019: connection description for remote database not found"; ERROR_NAME[-OB_DBLINK_NOT_EXIST_TO_DROP] = "OB_DBLINK_NOT_EXIST_TO_DROP"; + ERROR_CAUSE[-OB_DBLINK_NOT_EXIST_TO_DROP] = "Internal Error"; + ERROR_SOLUTION[-OB_DBLINK_NOT_EXIST_TO_DROP] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_DBLINK_NOT_EXIST_TO_DROP] = -1; SQLSTATE[-OB_DBLINK_NOT_EXIST_TO_DROP] = "HY000"; STR_ERROR[-OB_DBLINK_NOT_EXIST_TO_DROP] = "database link not found"; @@ -10621,6 +12844,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_DBLINK_NOT_EXIST_TO_DROP] = "ORA-02024: database link not found"; ORACLE_STR_USER_ERROR[-OB_DBLINK_NOT_EXIST_TO_DROP] = "ORA-02024: database link not found"; ERROR_NAME[-OB_ERR_ACCESS_INTO_NULL] = "OB_ERR_ACCESS_INTO_NULL"; + ERROR_CAUSE[-OB_ERR_ACCESS_INTO_NULL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ACCESS_INTO_NULL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ACCESS_INTO_NULL] = -1; SQLSTATE[-OB_ERR_ACCESS_INTO_NULL] = "HY000"; STR_ERROR[-OB_ERR_ACCESS_INTO_NULL] = "Reference to uninitialized composite"; @@ -10629,6 +12854,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_ACCESS_INTO_NULL] = "ORA-06530: Reference to uninitialized composite"; ORACLE_STR_USER_ERROR[-OB_ERR_ACCESS_INTO_NULL] = "ORA-06530: Reference to uninitialized composite"; ERROR_NAME[-OB_ERR_COLLECION_NULL] = "OB_ERR_COLLECION_NULL"; + ERROR_CAUSE[-OB_ERR_COLLECION_NULL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_COLLECION_NULL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_COLLECION_NULL] = -1; SQLSTATE[-OB_ERR_COLLECION_NULL] = "HY000"; STR_ERROR[-OB_ERR_COLLECION_NULL] = "Reference to uninitialized collection"; @@ -10637,6 +12864,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_COLLECION_NULL] = "ORA-06531: Reference to uninitialized collection"; ORACLE_STR_USER_ERROR[-OB_ERR_COLLECION_NULL] = "ORA-06531: Reference to uninitialized collection"; ERROR_NAME[-OB_ERR_NO_DATA_NEEDED] = "OB_ERR_NO_DATA_NEEDED"; + ERROR_CAUSE[-OB_ERR_NO_DATA_NEEDED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_DATA_NEEDED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_DATA_NEEDED] = -1; SQLSTATE[-OB_ERR_NO_DATA_NEEDED] = "HY000"; STR_ERROR[-OB_ERR_NO_DATA_NEEDED] = "no more rows needed"; @@ -10645,6 +12874,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_NO_DATA_NEEDED] = "ORA-06548: no more rows needed"; ORACLE_STR_USER_ERROR[-OB_ERR_NO_DATA_NEEDED] = "ORA-06548: no more rows needed"; ERROR_NAME[-OB_ERR_PROGRAM_ERROR] = "OB_ERR_PROGRAM_ERROR"; + ERROR_CAUSE[-OB_ERR_PROGRAM_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PROGRAM_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PROGRAM_ERROR] = -1; SQLSTATE[-OB_ERR_PROGRAM_ERROR] = "HY000"; STR_ERROR[-OB_ERR_PROGRAM_ERROR] = "PL/SQL: program error"; @@ -10653,6 +12884,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_PROGRAM_ERROR] = "ORA-06501: PL/SQL: program error"; ORACLE_STR_USER_ERROR[-OB_ERR_PROGRAM_ERROR] = "ORA-06501: PL/SQL: program error"; ERROR_NAME[-OB_ERR_ROWTYPE_MISMATCH] = "OB_ERR_ROWTYPE_MISMATCH"; + ERROR_CAUSE[-OB_ERR_ROWTYPE_MISMATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ROWTYPE_MISMATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ROWTYPE_MISMATCH] = -1; SQLSTATE[-OB_ERR_ROWTYPE_MISMATCH] = "HY000"; STR_ERROR[-OB_ERR_ROWTYPE_MISMATCH] = "PL/SQL: Return types of Result Set variables or query do not match"; @@ -10663,6 +12896,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ROWTYPE_MISMATCH] = "ORA-06504: PL/SQL: Return types of Result Set variables or query do not match"; ERROR_NAME[-OB_ERR_STORAGE_ERROR] = "OB_ERR_STORAGE_ERROR"; + ERROR_CAUSE[-OB_ERR_STORAGE_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_STORAGE_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_STORAGE_ERROR] = -1; SQLSTATE[-OB_ERR_STORAGE_ERROR] = "HY000"; STR_ERROR[-OB_ERR_STORAGE_ERROR] = "PL/SQL: storage error"; @@ -10671,6 +12906,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_STORAGE_ERROR] = "ORA-06500: PL/SQL: storage error"; ORACLE_STR_USER_ERROR[-OB_ERR_STORAGE_ERROR] = "ORA-06500: PL/SQL: storage error"; ERROR_NAME[-OB_ERR_SUBSCRIPT_OUTSIDE_LIMIT] = "OB_ERR_SUBSCRIPT_OUTSIDE_LIMIT"; + ERROR_CAUSE[-OB_ERR_SUBSCRIPT_OUTSIDE_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SUBSCRIPT_OUTSIDE_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SUBSCRIPT_OUTSIDE_LIMIT] = -1; SQLSTATE[-OB_ERR_SUBSCRIPT_OUTSIDE_LIMIT] = "HY000"; STR_ERROR[-OB_ERR_SUBSCRIPT_OUTSIDE_LIMIT] = "Subscript outside of limit"; @@ -10679,6 +12916,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SUBSCRIPT_OUTSIDE_LIMIT] = "ORA-06532: Subscript outside of limit"; ORACLE_STR_USER_ERROR[-OB_ERR_SUBSCRIPT_OUTSIDE_LIMIT] = "ORA-06532: Subscript outside of limit"; ERROR_NAME[-OB_ERR_INVALID_CURSOR] = "OB_ERR_INVALID_CURSOR"; + ERROR_CAUSE[-OB_ERR_INVALID_CURSOR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_CURSOR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_CURSOR] = -1; SQLSTATE[-OB_ERR_INVALID_CURSOR] = "HY000"; STR_ERROR[-OB_ERR_INVALID_CURSOR] = "invalid cursor"; @@ -10687,6 +12926,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_CURSOR] = "ORA-01001: invalid cursor"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_CURSOR] = "ORA-01001: invalid cursor"; ERROR_NAME[-OB_ERR_LOGIN_DENIED] = "OB_ERR_LOGIN_DENIED"; + ERROR_CAUSE[-OB_ERR_LOGIN_DENIED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_LOGIN_DENIED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_LOGIN_DENIED] = -1; SQLSTATE[-OB_ERR_LOGIN_DENIED] = "HY000"; STR_ERROR[-OB_ERR_LOGIN_DENIED] = "invalid username/password; logon denied"; @@ -10695,6 +12936,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_LOGIN_DENIED] = "ORA-01017: invalid username/password; logon deniedd"; ORACLE_STR_USER_ERROR[-OB_ERR_LOGIN_DENIED] = "ORA-01017: invalid username/password; logon deniedd"; ERROR_NAME[-OB_ERR_NOT_LOGGED_ON] = "OB_ERR_NOT_LOGGED_ON"; + ERROR_CAUSE[-OB_ERR_NOT_LOGGED_ON] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NOT_LOGGED_ON] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NOT_LOGGED_ON] = -1; SQLSTATE[-OB_ERR_NOT_LOGGED_ON] = "HY000"; STR_ERROR[-OB_ERR_NOT_LOGGED_ON] = "not logged on"; @@ -10703,6 +12946,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_NOT_LOGGED_ON] = "ORA-01012: not logged on"; ORACLE_STR_USER_ERROR[-OB_ERR_NOT_LOGGED_ON] = "ORA-01012: not logged on"; ERROR_NAME[-OB_ERR_SELF_IS_NULL] = "OB_ERR_SELF_IS_NULL"; + ERROR_CAUSE[-OB_ERR_SELF_IS_NULL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SELF_IS_NULL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SELF_IS_NULL] = -1; SQLSTATE[-OB_ERR_SELF_IS_NULL] = "HY000"; STR_ERROR[-OB_ERR_SELF_IS_NULL] = "method dispatch on NULL SELF argument is disallowed"; @@ -10711,6 +12956,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SELF_IS_NULL] = "ORA-30625: method dispatch on NULL SELF argument is disallowed"; ORACLE_STR_USER_ERROR[-OB_ERR_SELF_IS_NULL] = "ORA-30625: method dispatch on NULL SELF argument is disallowed"; ERROR_NAME[-OB_ERR_TIMEOUT_ON_RESOURCE] = "OB_ERR_TIMEOUT_ON_RESOURCE"; + ERROR_CAUSE[-OB_ERR_TIMEOUT_ON_RESOURCE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TIMEOUT_ON_RESOURCE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TIMEOUT_ON_RESOURCE] = -1; SQLSTATE[-OB_ERR_TIMEOUT_ON_RESOURCE] = "HY000"; STR_ERROR[-OB_ERR_TIMEOUT_ON_RESOURCE] = "timeout occurred while waiting for a resource"; @@ -10719,6 +12966,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_TIMEOUT_ON_RESOURCE] = "ORA-00051: timeout occurred while waiting for a resource"; ORACLE_STR_USER_ERROR[-OB_ERR_TIMEOUT_ON_RESOURCE] = "ORA-00051: timeout occurred while waiting for a resource"; ERROR_NAME[-OB_COLUMN_CANT_CHANGE_TO_NOT_NULL] = "OB_COLUMN_CANT_CHANGE_TO_NOT_NULL"; + ERROR_CAUSE[-OB_COLUMN_CANT_CHANGE_TO_NOT_NULL] = "Internal Error"; + ERROR_SOLUTION[-OB_COLUMN_CANT_CHANGE_TO_NOT_NULL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_COLUMN_CANT_CHANGE_TO_NOT_NULL] = -1; SQLSTATE[-OB_COLUMN_CANT_CHANGE_TO_NOT_NULL] = "HY000"; STR_ERROR[-OB_COLUMN_CANT_CHANGE_TO_NOT_NULL] = "column to be modified to NOT NULL is already NOT NULL"; @@ -10729,6 +12978,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_COLUMN_CANT_CHANGE_TO_NOT_NULL] = "ORA-01442: column to be modified to NOT NULL is already NOT NULL"; ERROR_NAME[-OB_COLUMN_CANT_CHANGE_TO_NULLALE] = "OB_COLUMN_CANT_CHANGE_TO_NULLALE"; + ERROR_CAUSE[-OB_COLUMN_CANT_CHANGE_TO_NULLALE] = "Internal Error"; + ERROR_SOLUTION[-OB_COLUMN_CANT_CHANGE_TO_NULLALE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_COLUMN_CANT_CHANGE_TO_NULLALE] = -1; SQLSTATE[-OB_COLUMN_CANT_CHANGE_TO_NULLALE] = "HY000"; STR_ERROR[-OB_COLUMN_CANT_CHANGE_TO_NULLALE] = "column to be modified to NULL cannot be modified to NULL"; @@ -10739,6 +12990,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_COLUMN_CANT_CHANGE_TO_NULLALE] = "ORA-01451: column to be modified to NULL cannot be modified to NULL"; ERROR_NAME[-OB_ENABLE_NOT_NULL_CONSTRAINT_VIOLATED] = "OB_ENABLE_NOT_NULL_CONSTRAINT_VIOLATED"; + ERROR_CAUSE[-OB_ENABLE_NOT_NULL_CONSTRAINT_VIOLATED] = "Internal Error"; + ERROR_SOLUTION[-OB_ENABLE_NOT_NULL_CONSTRAINT_VIOLATED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ENABLE_NOT_NULL_CONSTRAINT_VIOLATED] = -1; SQLSTATE[-OB_ENABLE_NOT_NULL_CONSTRAINT_VIOLATED] = "HY000"; STR_ERROR[-OB_ENABLE_NOT_NULL_CONSTRAINT_VIOLATED] = "cannot enable - null values found"; @@ -10748,6 +13001,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ENABLE_NOT_NULL_CONSTRAINT_VIOLATED] = "ORA-02296: cannot enable (%.*s.%.*s) - null values found"; ERROR_NAME[-OB_ERR_ARGUMENT_SHOULD_CONSTANT] = "OB_ERR_ARGUMENT_SHOULD_CONSTANT"; + ERROR_CAUSE[-OB_ERR_ARGUMENT_SHOULD_CONSTANT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ARGUMENT_SHOULD_CONSTANT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ARGUMENT_SHOULD_CONSTANT] = -1; SQLSTATE[-OB_ERR_ARGUMENT_SHOULD_CONSTANT] = "HY000"; STR_ERROR[-OB_ERR_ARGUMENT_SHOULD_CONSTANT] = "Argument should be a constant."; @@ -10756,6 +13011,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_ARGUMENT_SHOULD_CONSTANT] = "ORA-30496: Argument should be a constant."; ORACLE_STR_USER_ERROR[-OB_ERR_ARGUMENT_SHOULD_CONSTANT] = "ORA-30496: Argument should be a constant."; ERROR_NAME[-OB_ERR_NOT_A_SINGLE_GROUP_FUNCTION] = "OB_ERR_NOT_A_SINGLE_GROUP_FUNCTION"; + ERROR_CAUSE[-OB_ERR_NOT_A_SINGLE_GROUP_FUNCTION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NOT_A_SINGLE_GROUP_FUNCTION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NOT_A_SINGLE_GROUP_FUNCTION] = -1; SQLSTATE[-OB_ERR_NOT_A_SINGLE_GROUP_FUNCTION] = "HY000"; STR_ERROR[-OB_ERR_NOT_A_SINGLE_GROUP_FUNCTION] = "not a single-group group function"; @@ -10764,6 +13021,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_NOT_A_SINGLE_GROUP_FUNCTION] = "ORA-00937: not a single-group group function"; ORACLE_STR_USER_ERROR[-OB_ERR_NOT_A_SINGLE_GROUP_FUNCTION] = "ORA-00937: not a single-group group function"; ERROR_NAME[-OB_ERR_ZERO_LENGTH_IDENTIFIER] = "OB_ERR_ZERO_LENGTH_IDENTIFIER"; + ERROR_CAUSE[-OB_ERR_ZERO_LENGTH_IDENTIFIER] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ZERO_LENGTH_IDENTIFIER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ZERO_LENGTH_IDENTIFIER] = -1; SQLSTATE[-OB_ERR_ZERO_LENGTH_IDENTIFIER] = "HY000"; STR_ERROR[-OB_ERR_ZERO_LENGTH_IDENTIFIER] = "illegal zero-length identifier"; @@ -10772,6 +13031,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_ZERO_LENGTH_IDENTIFIER] = "ORA-01741: illegal zero-length identifier"; ORACLE_STR_USER_ERROR[-OB_ERR_ZERO_LENGTH_IDENTIFIER] = "ORA-01741: illegal zero-length identifier"; ERROR_NAME[-OB_ERR_PARAM_VALUE_INVALID] = "OB_ERR_PARAM_VALUE_INVALID"; + ERROR_CAUSE[-OB_ERR_PARAM_VALUE_INVALID] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARAM_VALUE_INVALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARAM_VALUE_INVALID] = -1; SQLSTATE[-OB_ERR_PARAM_VALUE_INVALID] = "HY000"; STR_ERROR[-OB_ERR_PARAM_VALUE_INVALID] = "parameter cannot be modified because specified value is invalid"; @@ -10782,6 +13043,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PARAM_VALUE_INVALID] = "ORA-02097: parameter cannot be modified because specified value is invalid"; ERROR_NAME[-OB_ERR_DBMS_SQL_CURSOR_NOT_EXIST] = "OB_ERR_DBMS_SQL_CURSOR_NOT_EXIST"; + ERROR_CAUSE[-OB_ERR_DBMS_SQL_CURSOR_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DBMS_SQL_CURSOR_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DBMS_SQL_CURSOR_NOT_EXIST] = -1; SQLSTATE[-OB_ERR_DBMS_SQL_CURSOR_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_DBMS_SQL_CURSOR_NOT_EXIST] = "DBMS_SQL access denied"; @@ -10790,6 +13053,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DBMS_SQL_CURSOR_NOT_EXIST] = "ORA-29471: DBMS_SQL access denied"; ORACLE_STR_USER_ERROR[-OB_ERR_DBMS_SQL_CURSOR_NOT_EXIST] = "ORA-29471: DBMS_SQL access denied"; ERROR_NAME[-OB_ERR_DBMS_SQL_NOT_ALL_VAR_BIND] = "OB_ERR_DBMS_SQL_NOT_ALL_VAR_BIND"; + ERROR_CAUSE[-OB_ERR_DBMS_SQL_NOT_ALL_VAR_BIND] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DBMS_SQL_NOT_ALL_VAR_BIND] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DBMS_SQL_NOT_ALL_VAR_BIND] = -1; SQLSTATE[-OB_ERR_DBMS_SQL_NOT_ALL_VAR_BIND] = "HY000"; STR_ERROR[-OB_ERR_DBMS_SQL_NOT_ALL_VAR_BIND] = "not all variables bound"; @@ -10798,6 +13063,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DBMS_SQL_NOT_ALL_VAR_BIND] = "ORA-01008: not all variables bound"; ORACLE_STR_USER_ERROR[-OB_ERR_DBMS_SQL_NOT_ALL_VAR_BIND] = "ORA-01008: not all variables bound"; ERROR_NAME[-OB_ERR_CONFLICTING_DECLARATIONS] = "OB_ERR_CONFLICTING_DECLARATIONS"; + ERROR_CAUSE[-OB_ERR_CONFLICTING_DECLARATIONS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CONFLICTING_DECLARATIONS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CONFLICTING_DECLARATIONS] = ER_CONFLICTING_DECLARATIONS; SQLSTATE[-OB_ERR_CONFLICTING_DECLARATIONS] = "42000"; STR_ERROR[-OB_ERR_CONFLICTING_DECLARATIONS] = "Conflicting declarations"; @@ -10808,6 +13075,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CONFLICTING_DECLARATIONS] = "ORA-00600: internal error code, arguments: -5858, Conflicting declarations: '%s' and '%s'"; ERROR_NAME[-OB_ERR_DROP_COL_REFERENCED_MULTI_COLS_CONSTRAINT] = "OB_ERR_DROP_COL_REFERENCED_MULTI_COLS_CONSTRAINT"; + ERROR_CAUSE[-OB_ERR_DROP_COL_REFERENCED_MULTI_COLS_CONSTRAINT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DROP_COL_REFERENCED_MULTI_COLS_CONSTRAINT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DROP_COL_REFERENCED_MULTI_COLS_CONSTRAINT] = -1; SQLSTATE[-OB_ERR_DROP_COL_REFERENCED_MULTI_COLS_CONSTRAINT] = "HY000"; STR_ERROR[-OB_ERR_DROP_COL_REFERENCED_MULTI_COLS_CONSTRAINT] = "column is referenced in a multi-column constraint"; @@ -10819,6 +13088,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DROP_COL_REFERENCED_MULTI_COLS_CONSTRAINT] = "ORA-12991: column is referenced in a multi-column constraint"; ERROR_NAME[-OB_ERR_MODIFY_COL_DATATYEP_REFERENCED_CONSTRAINT] = "OB_ERR_MODIFY_COL_DATATYEP_REFERENCED_CONSTRAINT"; + ERROR_CAUSE[-OB_ERR_MODIFY_COL_DATATYEP_REFERENCED_CONSTRAINT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MODIFY_COL_DATATYEP_REFERENCED_CONSTRAINT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MODIFY_COL_DATATYEP_REFERENCED_CONSTRAINT] = -1; SQLSTATE[-OB_ERR_MODIFY_COL_DATATYEP_REFERENCED_CONSTRAINT] = "HY000"; STR_ERROR[-OB_ERR_MODIFY_COL_DATATYEP_REFERENCED_CONSTRAINT] = @@ -10831,6 +13102,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MODIFY_COL_DATATYEP_REFERENCED_CONSTRAINT] = "ORA-01463: cannot modify column datatype with current constraint(s)"; ERROR_NAME[-OB_ERR_PERCENTILE_VALUE_INVALID] = "OB_ERR_PERCENTILE_VALUE_INVALID"; + ERROR_CAUSE[-OB_ERR_PERCENTILE_VALUE_INVALID] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PERCENTILE_VALUE_INVALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PERCENTILE_VALUE_INVALID] = -1; SQLSTATE[-OB_ERR_PERCENTILE_VALUE_INVALID] = "HY000"; STR_ERROR[-OB_ERR_PERCENTILE_VALUE_INVALID] = "The percentile value should be a number between 0 and 1."; @@ -10842,6 +13115,8 @@ static struct ObStrErrorInit { "ORA-30493: The percentile value should be a number between 0 and 1."; ERROR_NAME[-OB_ERR_ARGUMENT_SHOULD_NUMERIC_DATE_DATETIME_TYPE] = "OB_ERR_ARGUMENT_SHOULD_NUMERIC_DATE_DATETIME_TYPE"; + ERROR_CAUSE[-OB_ERR_ARGUMENT_SHOULD_NUMERIC_DATE_DATETIME_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ARGUMENT_SHOULD_NUMERIC_DATE_DATETIME_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ARGUMENT_SHOULD_NUMERIC_DATE_DATETIME_TYPE] = -1; SQLSTATE[-OB_ERR_ARGUMENT_SHOULD_NUMERIC_DATE_DATETIME_TYPE] = "HY000"; STR_ERROR[-OB_ERR_ARGUMENT_SHOULD_NUMERIC_DATE_DATETIME_TYPE] = @@ -10854,6 +13129,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ARGUMENT_SHOULD_NUMERIC_DATE_DATETIME_TYPE] = "ORA-30495: The argument should be of numeric or date/datetime type."; ERROR_NAME[-OB_ERR_ALTER_TABLE_RENAME_WITH_OPTION] = "OB_ERR_ALTER_TABLE_RENAME_WITH_OPTION"; + ERROR_CAUSE[-OB_ERR_ALTER_TABLE_RENAME_WITH_OPTION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ALTER_TABLE_RENAME_WITH_OPTION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ALTER_TABLE_RENAME_WITH_OPTION] = -1; SQLSTATE[-OB_ERR_ALTER_TABLE_RENAME_WITH_OPTION] = "HY000"; STR_ERROR[-OB_ERR_ALTER_TABLE_RENAME_WITH_OPTION] = @@ -10866,6 +13143,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ALTER_TABLE_RENAME_WITH_OPTION] = "ORA-14047: ALTER TABLE|INDEX RENAME may not be combined with other operations"; ERROR_NAME[-OB_ERR_ONLY_SIMPLE_COLUMN_NAME_ALLOWED] = "OB_ERR_ONLY_SIMPLE_COLUMN_NAME_ALLOWED"; + ERROR_CAUSE[-OB_ERR_ONLY_SIMPLE_COLUMN_NAME_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ONLY_SIMPLE_COLUMN_NAME_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ONLY_SIMPLE_COLUMN_NAME_ALLOWED] = -1; SQLSTATE[-OB_ERR_ONLY_SIMPLE_COLUMN_NAME_ALLOWED] = "HY000"; STR_ERROR[-OB_ERR_ONLY_SIMPLE_COLUMN_NAME_ALLOWED] = "only simple column names allowed here."; @@ -10875,6 +13154,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ONLY_SIMPLE_COLUMN_NAME_ALLOWED] = "ORA-01748: only simple column names allowed here."; ERROR_NAME[-OB_ERR_SAFE_UPDATE_MODE_NEED_WHERE_OR_LIMIT] = "OB_ERR_SAFE_UPDATE_MODE_NEED_WHERE_OR_LIMIT"; + ERROR_CAUSE[-OB_ERR_SAFE_UPDATE_MODE_NEED_WHERE_OR_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SAFE_UPDATE_MODE_NEED_WHERE_OR_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SAFE_UPDATE_MODE_NEED_WHERE_OR_LIMIT] = ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE; SQLSTATE[-OB_ERR_SAFE_UPDATE_MODE_NEED_WHERE_OR_LIMIT] = "HY000"; STR_ERROR[-OB_ERR_SAFE_UPDATE_MODE_NEED_WHERE_OR_LIMIT] = @@ -10889,6 +13170,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -5865, You are using safe update mode and you tried to update a " "table without a WHERE that uses a KEY column"; ERROR_NAME[-OB_ERR_SPECIFIY_PARTITION_DESCRIPTION] = "OB_ERR_SPECIFIY_PARTITION_DESCRIPTION"; + ERROR_CAUSE[-OB_ERR_SPECIFIY_PARTITION_DESCRIPTION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SPECIFIY_PARTITION_DESCRIPTION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SPECIFIY_PARTITION_DESCRIPTION] = -1; SQLSTATE[-OB_ERR_SPECIFIY_PARTITION_DESCRIPTION] = "HY000"; STR_ERROR[-OB_ERR_SPECIFIY_PARTITION_DESCRIPTION] = @@ -10901,6 +13184,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SPECIFIY_PARTITION_DESCRIPTION] = "ORA-14170: cannot specify <(sub)partition-description> clause in CREATE TABLE or CREATE INDEX"; ERROR_NAME[-OB_ERR_SAME_NAME_SUBPARTITION] = "OB_ERR_SAME_NAME_SUBPARTITION"; + ERROR_CAUSE[-OB_ERR_SAME_NAME_SUBPARTITION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SAME_NAME_SUBPARTITION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SAME_NAME_SUBPARTITION] = -1; SQLSTATE[-OB_ERR_SAME_NAME_SUBPARTITION] = "HY000"; STR_ERROR[-OB_ERR_SAME_NAME_SUBPARTITION] = "Duplicate partition name"; @@ -10909,6 +13194,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SAME_NAME_SUBPARTITION] = "ORA-14159: duplicate subpartition name"; ORACLE_STR_USER_ERROR[-OB_ERR_SAME_NAME_SUBPARTITION] = "ORA-14159: duplicate subpartition name %.*s"; ERROR_NAME[-OB_ERR_UPDATE_ORDER_BY] = "OB_ERR_UPDATE_ORDER_BY"; + ERROR_CAUSE[-OB_ERR_UPDATE_ORDER_BY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UPDATE_ORDER_BY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UPDATE_ORDER_BY] = -1; SQLSTATE[-OB_ERR_UPDATE_ORDER_BY] = "HY000"; STR_ERROR[-OB_ERR_UPDATE_ORDER_BY] = "Incorrect usage of UPDATE and ORDER BY"; @@ -10919,6 +13206,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UPDATE_ORDER_BY] = "ORA-00600: internal error code, arguments: -5868, Incorrect usage of UPDATE and ORDER BY"; ERROR_NAME[-OB_ERR_UPDATE_LIMIT] = "OB_ERR_UPDATE_LIMIT"; + ERROR_CAUSE[-OB_ERR_UPDATE_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UPDATE_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UPDATE_LIMIT] = -1; SQLSTATE[-OB_ERR_UPDATE_LIMIT] = "HY000"; STR_ERROR[-OB_ERR_UPDATE_LIMIT] = "Incorrect usage of UPDATE and LIMIT"; @@ -10929,6 +13218,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UPDATE_LIMIT] = "ORA-00600: internal error code, arguments: -5869, Incorrect usage of UPDATE and LIMIT"; ERROR_NAME[-OB_ROWID_TYPE_MISMATCH] = "OB_ROWID_TYPE_MISMATCH"; + ERROR_CAUSE[-OB_ROWID_TYPE_MISMATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_ROWID_TYPE_MISMATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ROWID_TYPE_MISMATCH] = -1; SQLSTATE[-OB_ROWID_TYPE_MISMATCH] = "HY000"; STR_ERROR[-OB_ROWID_TYPE_MISMATCH] = "rowid type mismatch"; @@ -10937,6 +13228,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ROWID_TYPE_MISMATCH] = "ORA-00600: rowid type mismatch"; ORACLE_STR_USER_ERROR[-OB_ROWID_TYPE_MISMATCH] = "ORA-00600: rowid type mismatch, expect %s, got %s"; ERROR_NAME[-OB_ROWID_NUM_MISMATCH] = "OB_ROWID_NUM_MISMATCH"; + ERROR_CAUSE[-OB_ROWID_NUM_MISMATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_ROWID_NUM_MISMATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ROWID_NUM_MISMATCH] = -1; SQLSTATE[-OB_ROWID_NUM_MISMATCH] = "HY000"; STR_ERROR[-OB_ROWID_NUM_MISMATCH] = "rowid num mismatch"; @@ -10945,6 +13238,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ROWID_NUM_MISMATCH] = "ORA-00600: rowid type mismatch"; ORACLE_STR_USER_ERROR[-OB_ROWID_NUM_MISMATCH] = "ORA-00600: rowid type mismatch, expect %ld, actual %ld"; ERROR_NAME[-OB_NO_COLUMN_ALIAS] = "OB_NO_COLUMN_ALIAS"; + ERROR_CAUSE[-OB_NO_COLUMN_ALIAS] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_COLUMN_ALIAS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_COLUMN_ALIAS] = -1; SQLSTATE[-OB_NO_COLUMN_ALIAS] = "HY000"; STR_ERROR[-OB_NO_COLUMN_ALIAS] = "must name this expression with a column alias"; @@ -10953,6 +13248,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NO_COLUMN_ALIAS] = "ORA-00998: must name this expression with a column alias"; ORACLE_STR_USER_ERROR[-OB_NO_COLUMN_ALIAS] = "ORA-00998: must name %.*s with a column alias"; ERROR_NAME[-OB_ERR_NUMERIC_NOT_MATCH_FORMAT_LENGTH] = "OB_ERR_NUMERIC_NOT_MATCH_FORMAT_LENGTH"; + ERROR_CAUSE[-OB_ERR_NUMERIC_NOT_MATCH_FORMAT_LENGTH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NUMERIC_NOT_MATCH_FORMAT_LENGTH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NUMERIC_NOT_MATCH_FORMAT_LENGTH] = -1; SQLSTATE[-OB_ERR_NUMERIC_NOT_MATCH_FORMAT_LENGTH] = "HY000"; STR_ERROR[-OB_ERR_NUMERIC_NOT_MATCH_FORMAT_LENGTH] = @@ -10965,6 +13262,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NUMERIC_NOT_MATCH_FORMAT_LENGTH] = "ORA-01862: the numeric value does not match the length of the format item"; ERROR_NAME[-OB_ERR_INVALID_DATATYPE] = "OB_ERR_INVALID_DATATYPE"; + ERROR_CAUSE[-OB_ERR_INVALID_DATATYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_DATATYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_DATATYPE] = -1; SQLSTATE[-OB_ERR_INVALID_DATATYPE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_DATATYPE] = "invalid datatype"; @@ -10973,6 +13272,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_DATATYPE] = "ORA-00902: invalid datatype"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_DATATYPE] = "ORA-00902: invalid datatype"; ERROR_NAME[-OB_ERR_NOT_COMPOSITE_PARTITION] = "OB_ERR_NOT_COMPOSITE_PARTITION"; + ERROR_CAUSE[-OB_ERR_NOT_COMPOSITE_PARTITION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NOT_COMPOSITE_PARTITION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NOT_COMPOSITE_PARTITION] = -1; SQLSTATE[-OB_ERR_NOT_COMPOSITE_PARTITION] = "HY000"; STR_ERROR[-OB_ERR_NOT_COMPOSITE_PARTITION] = "table is not partitioned by composite partition method"; @@ -10983,6 +13284,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NOT_COMPOSITE_PARTITION] = "ORA-14253: table is not partitioned by composite partition method"; ERROR_NAME[-OB_ERR_SUBPARTITION_NOT_EXPECT_VALUES_IN] = "OB_ERR_SUBPARTITION_NOT_EXPECT_VALUES_IN"; + ERROR_CAUSE[-OB_ERR_SUBPARTITION_NOT_EXPECT_VALUES_IN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SUBPARTITION_NOT_EXPECT_VALUES_IN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SUBPARTITION_NOT_EXPECT_VALUES_IN] = -1; SQLSTATE[-OB_ERR_SUBPARTITION_NOT_EXPECT_VALUES_IN] = "HY000"; STR_ERROR[-OB_ERR_SUBPARTITION_NOT_EXPECT_VALUES_IN] = @@ -10995,6 +13298,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SUBPARTITION_NOT_EXPECT_VALUES_IN] = "ORA-14214: VALUES () cannot be used for Range subpartitioned tables"; ERROR_NAME[-OB_ERR_SUBPARTITION_EXPECT_VALUES_IN] = "OB_ERR_SUBPARTITION_EXPECT_VALUES_IN"; + ERROR_CAUSE[-OB_ERR_SUBPARTITION_EXPECT_VALUES_IN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SUBPARTITION_EXPECT_VALUES_IN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SUBPARTITION_EXPECT_VALUES_IN] = -1; SQLSTATE[-OB_ERR_SUBPARTITION_EXPECT_VALUES_IN] = "HY000"; STR_ERROR[-OB_ERR_SUBPARTITION_EXPECT_VALUES_IN] = "VALUES IN () clause expected"; @@ -11003,6 +13308,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_SUBPARTITION_EXPECT_VALUES_IN] = "ORA-14217: VALUES () clause expected"; ORACLE_STR_USER_ERROR[-OB_ERR_SUBPARTITION_EXPECT_VALUES_IN] = "ORA-14217: VALUES () clause expected"; ERROR_NAME[-OB_ERR_PARTITION_NOT_EXPECT_VALUES_LESS_THAN] = "OB_ERR_PARTITION_NOT_EXPECT_VALUES_LESS_THAN"; + ERROR_CAUSE[-OB_ERR_PARTITION_NOT_EXPECT_VALUES_LESS_THAN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARTITION_NOT_EXPECT_VALUES_LESS_THAN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARTITION_NOT_EXPECT_VALUES_LESS_THAN] = -1; SQLSTATE[-OB_ERR_PARTITION_NOT_EXPECT_VALUES_LESS_THAN] = "HY000"; STR_ERROR[-OB_ERR_PARTITION_NOT_EXPECT_VALUES_LESS_THAN] = @@ -11015,6 +13322,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PARTITION_NOT_EXPECT_VALUES_LESS_THAN] = "ORA-14310: VALUES LESS THAN or AT clause cannot be used with List partitioned tables"; ERROR_NAME[-OB_ERR_PARTITION_EXPECT_VALUES_LESS_THAN] = "OB_ERR_PARTITION_EXPECT_VALUES_LESS_THAN"; + ERROR_CAUSE[-OB_ERR_PARTITION_EXPECT_VALUES_LESS_THAN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PARTITION_EXPECT_VALUES_LESS_THAN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PARTITION_EXPECT_VALUES_LESS_THAN] = -1; SQLSTATE[-OB_ERR_PARTITION_EXPECT_VALUES_LESS_THAN] = "HY000"; STR_ERROR[-OB_ERR_PARTITION_EXPECT_VALUES_LESS_THAN] = "Expecting VALUES LESS THAN or AT clause"; @@ -11024,6 +13333,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PARTITION_EXPECT_VALUES_LESS_THAN] = "ORA-14311: Expecting VALUES LESS THAN or AT clause"; ERROR_NAME[-OB_ERR_PROGRAM_UNIT_NOT_EXIST] = "OB_ERR_PROGRAM_UNIT_NOT_EXIST"; + ERROR_CAUSE[-OB_ERR_PROGRAM_UNIT_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PROGRAM_UNIT_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PROGRAM_UNIT_NOT_EXIST] = -1; SQLSTATE[-OB_ERR_PROGRAM_UNIT_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_PROGRAM_UNIT_NOT_EXIST] = "Procedure, function, package, or package body does not exist"; @@ -11034,6 +13345,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PROGRAM_UNIT_NOT_EXIST] = "ORA-04042: procedure, function, package, or package body does not exist"; ERROR_NAME[-OB_ERR_INVALID_RESTORE_POINT_NAME] = "OB_ERR_INVALID_RESTORE_POINT_NAME"; + ERROR_CAUSE[-OB_ERR_INVALID_RESTORE_POINT_NAME] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_RESTORE_POINT_NAME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_RESTORE_POINT_NAME] = -1; SQLSTATE[-OB_ERR_INVALID_RESTORE_POINT_NAME] = "HY000"; STR_ERROR[-OB_ERR_INVALID_RESTORE_POINT_NAME] = "invalid restore point name specified in connection string"; @@ -11044,6 +13357,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_RESTORE_POINT_NAME] = "ORA-00600: internal error code, arguments: -5881, invalid restore point name specified in connection string"; ERROR_NAME[-OB_ERR_INPUT_TIME_TYPE] = "OB_ERR_INPUT_TIME_TYPE"; + ERROR_CAUSE[-OB_ERR_INPUT_TIME_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INPUT_TIME_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INPUT_TIME_TYPE] = -1; SQLSTATE[-OB_ERR_INPUT_TIME_TYPE] = "HY000"; STR_ERROR[-OB_ERR_INPUT_TIME_TYPE] = "invalid time limit specified"; @@ -11052,6 +13367,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INPUT_TIME_TYPE] = "ORA-14312: invalid time limit specified"; ORACLE_STR_USER_ERROR[-OB_ERR_INPUT_TIME_TYPE] = "ORA-14312: invalid time limit specified"; ERROR_NAME[-OB_ERR_IN_ARRAY_DML] = "OB_ERR_IN_ARRAY_DML"; + ERROR_CAUSE[-OB_ERR_IN_ARRAY_DML] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_IN_ARRAY_DML] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_IN_ARRAY_DML] = -1; SQLSTATE[-OB_ERR_IN_ARRAY_DML] = "HY000"; STR_ERROR[-OB_ERR_IN_ARRAY_DML] = "error(s) in array DML"; @@ -11060,6 +13377,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_IN_ARRAY_DML] = "ORA-24381: error(s) in array DML"; ORACLE_STR_USER_ERROR[-OB_ERR_IN_ARRAY_DML] = "ORA-24381: error(s) in array DML"; ERROR_NAME[-OB_ERR_TRIGGER_COMPILE_ERROR] = "OB_ERR_TRIGGER_COMPILE_ERROR"; + ERROR_CAUSE[-OB_ERR_TRIGGER_COMPILE_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TRIGGER_COMPILE_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TRIGGER_COMPILE_ERROR] = -1; SQLSTATE[-OB_ERR_TRIGGER_COMPILE_ERROR] = "42000"; STR_ERROR[-OB_ERR_TRIGGER_COMPILE_ERROR] = "trigger compile error"; @@ -11070,6 +13389,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TRIGGER_COMPILE_ERROR] = "ORA-00600: internal error code, arguments: -5884, %s \'%.*s.%.*s\' compile error"; ERROR_NAME[-OB_ERR_MISSING_OR_INVALID_PASSWORD] = "OB_ERR_MISSING_OR_INVALID_PASSWORD"; + ERROR_CAUSE[-OB_ERR_MISSING_OR_INVALID_PASSWORD] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MISSING_OR_INVALID_PASSWORD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MISSING_OR_INVALID_PASSWORD] = -1; SQLSTATE[-OB_ERR_MISSING_OR_INVALID_PASSWORD] = "HY000"; STR_ERROR[-OB_ERR_MISSING_OR_INVALID_PASSWORD] = "missing or invalid password(s)"; @@ -11078,6 +13399,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_MISSING_OR_INVALID_PASSWORD] = "ORA-00988: missing or invalid password(s)"; ORACLE_STR_USER_ERROR[-OB_ERR_MISSING_OR_INVALID_PASSWORD] = "ORA-00988: missing or invalid password(s)"; ERROR_NAME[-OB_ERR_NO_MATCHING_UK_PK_FOR_COL_LIST] = "OB_ERR_NO_MATCHING_UK_PK_FOR_COL_LIST"; + ERROR_CAUSE[-OB_ERR_NO_MATCHING_UK_PK_FOR_COL_LIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_NO_MATCHING_UK_PK_FOR_COL_LIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_NO_MATCHING_UK_PK_FOR_COL_LIST] = -1; SQLSTATE[-OB_ERR_NO_MATCHING_UK_PK_FOR_COL_LIST] = "HY000"; STR_ERROR[-OB_ERR_NO_MATCHING_UK_PK_FOR_COL_LIST] = "no matching unique or primary key for this column-list"; @@ -11088,6 +13411,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_NO_MATCHING_UK_PK_FOR_COL_LIST] = "ORA-02270: no matching unique or primary key for this column-list"; ERROR_NAME[-OB_ERR_DUP_FK_IN_TABLE] = "OB_ERR_DUP_FK_IN_TABLE"; + ERROR_CAUSE[-OB_ERR_DUP_FK_IN_TABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DUP_FK_IN_TABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DUP_FK_IN_TABLE] = -1; SQLSTATE[-OB_ERR_DUP_FK_IN_TABLE] = "HY000"; STR_ERROR[-OB_ERR_DUP_FK_IN_TABLE] = "duplicate referential constraint specifications"; @@ -11096,6 +13421,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DUP_FK_IN_TABLE] = "ORA-02774: duplicate referential constraint specifications"; ORACLE_STR_USER_ERROR[-OB_ERR_DUP_FK_IN_TABLE] = "ORA-02774: duplicate referential constraint specifications"; ERROR_NAME[-OB_ERR_DUP_FK_EXISTS] = "OB_ERR_DUP_FK_EXISTS"; + ERROR_CAUSE[-OB_ERR_DUP_FK_EXISTS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DUP_FK_EXISTS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DUP_FK_EXISTS] = -1; SQLSTATE[-OB_ERR_DUP_FK_EXISTS] = "HY000"; STR_ERROR[-OB_ERR_DUP_FK_EXISTS] = "such a referential constraint already exists in the table"; @@ -11105,6 +13432,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DUP_FK_EXISTS] = "ORA-02775: such a referential constraint already exists in the table"; ERROR_NAME[-OB_ERR_INVALID_VIRTUAL_COLUMN_TYPE] = "OB_ERR_INVALID_VIRTUAL_COLUMN_TYPE"; + ERROR_CAUSE[-OB_ERR_INVALID_VIRTUAL_COLUMN_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_VIRTUAL_COLUMN_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_VIRTUAL_COLUMN_TYPE] = -1; SQLSTATE[-OB_ERR_INVALID_VIRTUAL_COLUMN_TYPE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_VIRTUAL_COLUMN_TYPE] = "specified data type is not supported for a virtual column"; @@ -11115,6 +13444,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_VIRTUAL_COLUMN_TYPE] = "ORA-54003: specified data type is not supported for a virtual column"; ERROR_NAME[-OB_ERR_REFERENCED_TABLE_HAS_NO_PK] = "OB_ERR_REFERENCED_TABLE_HAS_NO_PK"; + ERROR_CAUSE[-OB_ERR_REFERENCED_TABLE_HAS_NO_PK] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REFERENCED_TABLE_HAS_NO_PK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REFERENCED_TABLE_HAS_NO_PK] = -1; SQLSTATE[-OB_ERR_REFERENCED_TABLE_HAS_NO_PK] = "HY000"; STR_ERROR[-OB_ERR_REFERENCED_TABLE_HAS_NO_PK] = "referenced table does not have a primary key"; @@ -11124,6 +13455,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_REFERENCED_TABLE_HAS_NO_PK] = "ORA-02268: referenced table does not have a primary key"; ERROR_NAME[-OB_ERR_MODIFY_PART_COLUMN_TYPE] = "OB_ERR_MODIFY_PART_COLUMN_TYPE"; + ERROR_CAUSE[-OB_ERR_MODIFY_PART_COLUMN_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MODIFY_PART_COLUMN_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MODIFY_PART_COLUMN_TYPE] = -1; SQLSTATE[-OB_ERR_MODIFY_PART_COLUMN_TYPE] = "HY000"; STR_ERROR[-OB_ERR_MODIFY_PART_COLUMN_TYPE] = @@ -11136,6 +13469,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MODIFY_PART_COLUMN_TYPE] = "ORA-14060: data type or length of a table partitioning column may not be changed"; ERROR_NAME[-OB_ERR_MODIFY_SUBPART_COLUMN_TYPE] = "OB_ERR_MODIFY_SUBPART_COLUMN_TYPE"; + ERROR_CAUSE[-OB_ERR_MODIFY_SUBPART_COLUMN_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_MODIFY_SUBPART_COLUMN_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_MODIFY_SUBPART_COLUMN_TYPE] = -1; SQLSTATE[-OB_ERR_MODIFY_SUBPART_COLUMN_TYPE] = "HY000"; STR_ERROR[-OB_ERR_MODIFY_SUBPART_COLUMN_TYPE] = @@ -11148,6 +13483,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_MODIFY_SUBPART_COLUMN_TYPE] = "ORA-14265: data type or length of a table subpartitioning column may not be changed"; ERROR_NAME[-OB_ERR_DECREASE_COLUMN_LENGTH] = "OB_ERR_DECREASE_COLUMN_LENGTH"; + ERROR_CAUSE[-OB_ERR_DECREASE_COLUMN_LENGTH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DECREASE_COLUMN_LENGTH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DECREASE_COLUMN_LENGTH] = -1; SQLSTATE[-OB_ERR_DECREASE_COLUMN_LENGTH] = "HY000"; STR_ERROR[-OB_ERR_DECREASE_COLUMN_LENGTH] = "cannot decrease column length because some value is too big"; @@ -11158,6 +13495,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DECREASE_COLUMN_LENGTH] = "ORA-01441: cannot decrease column length because some value is too big"; ERROR_NAME[-OB_ERR_DATETIME_INTERVAL_INTERNAL_ERROR] = "OB_ERR_DATETIME_INTERVAL_INTERNAL_ERROR"; + ERROR_CAUSE[-OB_ERR_DATETIME_INTERVAL_INTERNAL_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DATETIME_INTERVAL_INTERNAL_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DATETIME_INTERVAL_INTERNAL_ERROR] = -1; SQLSTATE[-OB_ERR_DATETIME_INTERVAL_INTERNAL_ERROR] = "HY000"; STR_ERROR[-OB_ERR_DATETIME_INTERVAL_INTERNAL_ERROR] = "Datetime/Interval internal error"; @@ -11166,6 +13505,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DATETIME_INTERVAL_INTERNAL_ERROR] = "ORA-01891: Datetime/Interval internal error"; ORACLE_STR_USER_ERROR[-OB_ERR_DATETIME_INTERVAL_INTERNAL_ERROR] = "ORA-01891: Datetime/Interval internal error"; ERROR_NAME[-OB_ERR_REMOTE_PART_ILLEGAL] = "OB_ERR_REMOTE_PART_ILLEGAL"; + ERROR_CAUSE[-OB_ERR_REMOTE_PART_ILLEGAL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REMOTE_PART_ILLEGAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REMOTE_PART_ILLEGAL] = -1; SQLSTATE[-OB_ERR_REMOTE_PART_ILLEGAL] = "HY000"; STR_ERROR[-OB_ERR_REMOTE_PART_ILLEGAL] = "partition extended table name cannot refer to a remote object"; @@ -11176,6 +13517,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_REMOTE_PART_ILLEGAL] = "ORA-14100: partition extended table name cannot refer to a remote object"; ERROR_NAME[-OB_ERR_A_VIEW_NOT_APPROPRIATE_HERE] = "OB_ERR_A_VIEW_NOT_APPROPRIATE_HERE"; + ERROR_CAUSE[-OB_ERR_A_VIEW_NOT_APPROPRIATE_HERE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_A_VIEW_NOT_APPROPRIATE_HERE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_A_VIEW_NOT_APPROPRIATE_HERE] = -1; SQLSTATE[-OB_ERR_A_VIEW_NOT_APPROPRIATE_HERE] = "HY000"; STR_ERROR[-OB_ERR_A_VIEW_NOT_APPROPRIATE_HERE] = "a view is not appropriate here"; @@ -11184,6 +13527,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_A_VIEW_NOT_APPROPRIATE_HERE] = "ORA-01702: a view is not appropriate here"; ORACLE_STR_USER_ERROR[-OB_ERR_A_VIEW_NOT_APPROPRIATE_HERE] = "ORA-01702: a view is not appropriate here"; ERROR_NAME[-OB_ROWID_VIEW_NO_KEY_PRESERVED] = "OB_ROWID_VIEW_NO_KEY_PRESERVED"; + ERROR_CAUSE[-OB_ROWID_VIEW_NO_KEY_PRESERVED] = "Internal Error"; + ERROR_SOLUTION[-OB_ROWID_VIEW_NO_KEY_PRESERVED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ROWID_VIEW_NO_KEY_PRESERVED] = -1; SQLSTATE[-OB_ROWID_VIEW_NO_KEY_PRESERVED] = "HY000"; STR_ERROR[-OB_ROWID_VIEW_NO_KEY_PRESERVED] = @@ -11196,6 +13541,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ROWID_VIEW_NO_KEY_PRESERVED] = "ORA-01445: cannot select ROWID from, or sample, a join view without a key-preserved table"; ERROR_NAME[-OB_ROWID_VIEW_HAS_DISTINCT_ETC] = "OB_ROWID_VIEW_HAS_DISTINCT_ETC"; + ERROR_CAUSE[-OB_ROWID_VIEW_HAS_DISTINCT_ETC] = "Internal Error"; + ERROR_SOLUTION[-OB_ROWID_VIEW_HAS_DISTINCT_ETC] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ROWID_VIEW_HAS_DISTINCT_ETC] = -1; SQLSTATE[-OB_ROWID_VIEW_HAS_DISTINCT_ETC] = "HY000"; STR_ERROR[-OB_ROWID_VIEW_HAS_DISTINCT_ETC] = @@ -11208,6 +13555,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ROWID_VIEW_HAS_DISTINCT_ETC] = "ORA-01446: cannot select ROWID from, or sample, a view with DISTINCT, GROUP BY, etc"; ERROR_NAME[-OB_ERR_AT_LEAST_ONE_COLUMN_NOT_VIRTUAL] = "OB_ERR_AT_LEAST_ONE_COLUMN_NOT_VIRTUAL"; + ERROR_CAUSE[-OB_ERR_AT_LEAST_ONE_COLUMN_NOT_VIRTUAL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_AT_LEAST_ONE_COLUMN_NOT_VIRTUAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_AT_LEAST_ONE_COLUMN_NOT_VIRTUAL] = -1; SQLSTATE[-OB_ERR_AT_LEAST_ONE_COLUMN_NOT_VIRTUAL] = "HY000"; STR_ERROR[-OB_ERR_AT_LEAST_ONE_COLUMN_NOT_VIRTUAL] = "table must have at least 1 column that is not virtual"; @@ -11218,6 +13567,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_AT_LEAST_ONE_COLUMN_NOT_VIRTUAL] = "ORA-54037: table must have at least 1 column that is not virtual"; ERROR_NAME[-OB_ERR_ONLY_PURE_FUNC_CANBE_INDEXED] = "OB_ERR_ONLY_PURE_FUNC_CANBE_INDEXED"; + ERROR_CAUSE[-OB_ERR_ONLY_PURE_FUNC_CANBE_INDEXED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ONLY_PURE_FUNC_CANBE_INDEXED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ONLY_PURE_FUNC_CANBE_INDEXED] = -1; SQLSTATE[-OB_ERR_ONLY_PURE_FUNC_CANBE_INDEXED] = "HY000"; STR_ERROR[-OB_ERR_ONLY_PURE_FUNC_CANBE_INDEXED] = "only pure functions can be indexed"; @@ -11227,6 +13578,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ONLY_PURE_FUNC_CANBE_INDEXED] = "ORA-01743: only pure functions can be indexed"; ERROR_NAME[-OB_ERR_ONLY_PURE_FUNC_CANBE_VIRTUAL_COLUMN_EXPRESSION] = "OB_ERR_ONLY_PURE_FUNC_CANBE_VIRTUAL_COLUMN_EXPRESSION"; + ERROR_CAUSE[-OB_ERR_ONLY_PURE_FUNC_CANBE_VIRTUAL_COLUMN_EXPRESSION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ONLY_PURE_FUNC_CANBE_VIRTUAL_COLUMN_EXPRESSION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ONLY_PURE_FUNC_CANBE_VIRTUAL_COLUMN_EXPRESSION] = -1; SQLSTATE[-OB_ERR_ONLY_PURE_FUNC_CANBE_VIRTUAL_COLUMN_EXPRESSION] = "HY000"; STR_ERROR[-OB_ERR_ONLY_PURE_FUNC_CANBE_VIRTUAL_COLUMN_EXPRESSION] = @@ -11239,6 +13592,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ONLY_PURE_FUNC_CANBE_VIRTUAL_COLUMN_EXPRESSION] = "ORA-54002: only pure functions can be specified in a virtual column expression"; ERROR_NAME[-OB_ERR_UPDATE_OPERATION_ON_VIRTUAL_COLUMNS] = "OB_ERR_UPDATE_OPERATION_ON_VIRTUAL_COLUMNS"; + ERROR_CAUSE[-OB_ERR_UPDATE_OPERATION_ON_VIRTUAL_COLUMNS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UPDATE_OPERATION_ON_VIRTUAL_COLUMNS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UPDATE_OPERATION_ON_VIRTUAL_COLUMNS] = -1; SQLSTATE[-OB_ERR_UPDATE_OPERATION_ON_VIRTUAL_COLUMNS] = "HY000"; STR_ERROR[-OB_ERR_UPDATE_OPERATION_ON_VIRTUAL_COLUMNS] = "UPDATE operation disallowed on virtual columns"; @@ -11249,6 +13604,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UPDATE_OPERATION_ON_VIRTUAL_COLUMNS] = "ORA-54017: UPDATE operation disallowed on virtual columns"; ERROR_NAME[-OB_ERR_INVALID_COLUMN_EXPRESSION] = "OB_ERR_INVALID_COLUMN_EXPRESSION"; + ERROR_CAUSE[-OB_ERR_INVALID_COLUMN_EXPRESSION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_COLUMN_EXPRESSION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_COLUMN_EXPRESSION] = -1; SQLSTATE[-OB_ERR_INVALID_COLUMN_EXPRESSION] = "HY000"; STR_ERROR[-OB_ERR_INVALID_COLUMN_EXPRESSION] = "Invalid column expression was specified"; @@ -11257,6 +13614,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INVALID_COLUMN_EXPRESSION] = "ORA-54016: Invalid column expression was specified"; ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_COLUMN_EXPRESSION] = "ORA-54016: Invalid column expression was specified"; ERROR_NAME[-OB_ERR_IDENTITY_COLUMN_COUNT_EXCE_LIMIT] = "OB_ERR_IDENTITY_COLUMN_COUNT_EXCE_LIMIT"; + ERROR_CAUSE[-OB_ERR_IDENTITY_COLUMN_COUNT_EXCE_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_IDENTITY_COLUMN_COUNT_EXCE_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_IDENTITY_COLUMN_COUNT_EXCE_LIMIT] = -1; SQLSTATE[-OB_ERR_IDENTITY_COLUMN_COUNT_EXCE_LIMIT] = "HY000"; STR_ERROR[-OB_ERR_IDENTITY_COLUMN_COUNT_EXCE_LIMIT] = "table can have only one identity column"; @@ -11267,6 +13626,8 @@ static struct ObStrErrorInit { "ORA-30669: table can have only one identity column"; ERROR_NAME[-OB_ERR_INVALID_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = "OB_ERR_INVALID_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN"; + ERROR_CAUSE[-OB_ERR_INVALID_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = -1; SQLSTATE[-OB_ERR_INVALID_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_INVALID_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = @@ -11280,6 +13641,8 @@ static struct ObStrErrorInit { "ORA-30670: invalid NOT NULL constraint specified on an identity column"; ERROR_NAME[-OB_ERR_CANNOT_MODIFY_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = "OB_ERR_CANNOT_MODIFY_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN"; + ERROR_CAUSE[-OB_ERR_CANNOT_MODIFY_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CANNOT_MODIFY_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CANNOT_MODIFY_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = -1; SQLSTATE[-OB_ERR_CANNOT_MODIFY_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_CANNOT_MODIFY_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = @@ -11293,6 +13656,8 @@ static struct ObStrErrorInit { "ORA-30671: cannot modify NOT NULL constraint on an identity column"; ERROR_NAME[-OB_ERR_CANNOT_DROP_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = "OB_ERR_CANNOT_DROP_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN"; + ERROR_CAUSE[-OB_ERR_CANNOT_DROP_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CANNOT_DROP_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CANNOT_DROP_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = -1; SQLSTATE[-OB_ERR_CANNOT_DROP_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_CANNOT_DROP_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = @@ -11305,6 +13670,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CANNOT_DROP_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN] = "ORA-30672: cannot drop NOT NULL constraint on an identity column"; ERROR_NAME[-OB_ERR_COLUMN_MODIFY_TO_IDENTITY_COLUMN] = "OB_ERR_COLUMN_MODIFY_TO_IDENTITY_COLUMN"; + ERROR_CAUSE[-OB_ERR_COLUMN_MODIFY_TO_IDENTITY_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_COLUMN_MODIFY_TO_IDENTITY_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_COLUMN_MODIFY_TO_IDENTITY_COLUMN] = -1; SQLSTATE[-OB_ERR_COLUMN_MODIFY_TO_IDENTITY_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_COLUMN_MODIFY_TO_IDENTITY_COLUMN] = "column to be modified is not an identity column"; @@ -11315,6 +13682,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_COLUMN_MODIFY_TO_IDENTITY_COLUMN] = "ORA-30673: column to be modified is not an identity column"; ERROR_NAME[-OB_ERR_IDENTITY_COLUMN_CANNOT_HAVE_DEFAULT_VALUE] = "OB_ERR_IDENTITY_COLUMN_CANNOT_HAVE_DEFAULT_VALUE"; + ERROR_CAUSE[-OB_ERR_IDENTITY_COLUMN_CANNOT_HAVE_DEFAULT_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_IDENTITY_COLUMN_CANNOT_HAVE_DEFAULT_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_IDENTITY_COLUMN_CANNOT_HAVE_DEFAULT_VALUE] = -1; SQLSTATE[-OB_ERR_IDENTITY_COLUMN_CANNOT_HAVE_DEFAULT_VALUE] = "HY000"; STR_ERROR[-OB_ERR_IDENTITY_COLUMN_CANNOT_HAVE_DEFAULT_VALUE] = "identity column cannot have a default value"; @@ -11325,6 +13694,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_IDENTITY_COLUMN_CANNOT_HAVE_DEFAULT_VALUE] = "ORA-30674: identity column cannot have a default value"; ERROR_NAME[-OB_ERR_IDENTITY_COLUMN_MUST_BE_NUMERIC_TYPE] = "OB_ERR_IDENTITY_COLUMN_MUST_BE_NUMERIC_TYPE"; + ERROR_CAUSE[-OB_ERR_IDENTITY_COLUMN_MUST_BE_NUMERIC_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_IDENTITY_COLUMN_MUST_BE_NUMERIC_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_IDENTITY_COLUMN_MUST_BE_NUMERIC_TYPE] = -1; SQLSTATE[-OB_ERR_IDENTITY_COLUMN_MUST_BE_NUMERIC_TYPE] = "HY000"; STR_ERROR[-OB_ERR_IDENTITY_COLUMN_MUST_BE_NUMERIC_TYPE] = "identity column must be a numeric type"; @@ -11336,6 +13707,8 @@ static struct ObStrErrorInit { "ORA-30675: identity column must be a numeric type"; ERROR_NAME[-OB_ERR_PREBUILT_TABLE_MANAGED_CANNOT_BE_IDENTITY_COLUMN] = "OB_ERR_PREBUILT_TABLE_MANAGED_CANNOT_BE_IDENTITY_COLUMN"; + ERROR_CAUSE[-OB_ERR_PREBUILT_TABLE_MANAGED_CANNOT_BE_IDENTITY_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_PREBUILT_TABLE_MANAGED_CANNOT_BE_IDENTITY_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_PREBUILT_TABLE_MANAGED_CANNOT_BE_IDENTITY_COLUMN] = -1; SQLSTATE[-OB_ERR_PREBUILT_TABLE_MANAGED_CANNOT_BE_IDENTITY_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_PREBUILT_TABLE_MANAGED_CANNOT_BE_IDENTITY_COLUMN] = @@ -11348,6 +13721,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_PREBUILT_TABLE_MANAGED_CANNOT_BE_IDENTITY_COLUMN] = "ORA-32792: prebuilt table managed column cannot be an identity column"; ERROR_NAME[-OB_ERR_CANNOT_ALTER_SYSTEM_GENERATED_SEQUENCE] = "OB_ERR_CANNOT_ALTER_SYSTEM_GENERATED_SEQUENCE"; + ERROR_CAUSE[-OB_ERR_CANNOT_ALTER_SYSTEM_GENERATED_SEQUENCE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CANNOT_ALTER_SYSTEM_GENERATED_SEQUENCE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CANNOT_ALTER_SYSTEM_GENERATED_SEQUENCE] = -1; SQLSTATE[-OB_ERR_CANNOT_ALTER_SYSTEM_GENERATED_SEQUENCE] = "HY000"; STR_ERROR[-OB_ERR_CANNOT_ALTER_SYSTEM_GENERATED_SEQUENCE] = "cannot alter a system-generated sequence"; @@ -11358,6 +13733,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CANNOT_ALTER_SYSTEM_GENERATED_SEQUENCE] = "ORA-32793: cannot alter a system-generated sequence"; ERROR_NAME[-OB_ERR_CANNOT_DROP_SYSTEM_GENERATED_SEQUENCE] = "OB_ERR_CANNOT_DROP_SYSTEM_GENERATED_SEQUENCE"; + ERROR_CAUSE[-OB_ERR_CANNOT_DROP_SYSTEM_GENERATED_SEQUENCE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CANNOT_DROP_SYSTEM_GENERATED_SEQUENCE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CANNOT_DROP_SYSTEM_GENERATED_SEQUENCE] = -1; SQLSTATE[-OB_ERR_CANNOT_DROP_SYSTEM_GENERATED_SEQUENCE] = "HY000"; STR_ERROR[-OB_ERR_CANNOT_DROP_SYSTEM_GENERATED_SEQUENCE] = "cannot drop a system-generated sequence"; @@ -11369,6 +13746,8 @@ static struct ObStrErrorInit { "ORA-32794: cannot drop a system-generated sequence"; ERROR_NAME[-OB_ERR_INSERT_INTO_GENERATED_ALWAYS_IDENTITY_COLUMN] = "OB_ERR_INSERT_INTO_GENERATED_ALWAYS_IDENTITY_COLUMN"; + ERROR_CAUSE[-OB_ERR_INSERT_INTO_GENERATED_ALWAYS_IDENTITY_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INSERT_INTO_GENERATED_ALWAYS_IDENTITY_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INSERT_INTO_GENERATED_ALWAYS_IDENTITY_COLUMN] = -1; SQLSTATE[-OB_ERR_INSERT_INTO_GENERATED_ALWAYS_IDENTITY_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_INSERT_INTO_GENERATED_ALWAYS_IDENTITY_COLUMN] = @@ -11381,6 +13760,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INSERT_INTO_GENERATED_ALWAYS_IDENTITY_COLUMN] = "ORA-32795: cannot insert into a generated always identity column"; ERROR_NAME[-OB_ERR_UPDATE_GENERATED_ALWAYS_IDENTITY_COLUMN] = "OB_ERR_UPDATE_GENERATED_ALWAYS_IDENTITY_COLUMN"; + ERROR_CAUSE[-OB_ERR_UPDATE_GENERATED_ALWAYS_IDENTITY_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UPDATE_GENERATED_ALWAYS_IDENTITY_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UPDATE_GENERATED_ALWAYS_IDENTITY_COLUMN] = -1; SQLSTATE[-OB_ERR_UPDATE_GENERATED_ALWAYS_IDENTITY_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_UPDATE_GENERATED_ALWAYS_IDENTITY_COLUMN] = "cannot update a generated always identity column"; @@ -11393,6 +13774,9 @@ static struct ObStrErrorInit { "ORA-32796: cannot update a generated always identity column"; ERROR_NAME[-OB_ERR_IDENTITY_COLUMN_SEQUENCE_MISMATCH_ALTER_TABLE_EXCHANGE_PARTITION] = "OB_ERR_IDENTITY_COLUMN_SEQUENCE_MISMATCH_ALTER_TABLE_EXCHANGE_PARTITION"; + ERROR_CAUSE[-OB_ERR_IDENTITY_COLUMN_SEQUENCE_MISMATCH_ALTER_TABLE_EXCHANGE_PARTITION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_IDENTITY_COLUMN_SEQUENCE_MISMATCH_ALTER_TABLE_EXCHANGE_PARTITION] = + "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_IDENTITY_COLUMN_SEQUENCE_MISMATCH_ALTER_TABLE_EXCHANGE_PARTITION] = -1; SQLSTATE[-OB_ERR_IDENTITY_COLUMN_SEQUENCE_MISMATCH_ALTER_TABLE_EXCHANGE_PARTITION] = "HY000"; STR_ERROR[-OB_ERR_IDENTITY_COLUMN_SEQUENCE_MISMATCH_ALTER_TABLE_EXCHANGE_PARTITION] = @@ -11405,6 +13789,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_IDENTITY_COLUMN_SEQUENCE_MISMATCH_ALTER_TABLE_EXCHANGE_PARTITION] = "ORA-32797: identity column sequence mismatch in ALTER TABLE EXCHANGE PARTITION"; ERROR_NAME[-OB_ERR_CANNOT_RENAME_SYSTEM_GENERATED_SEQUENCE] = "OB_ERR_CANNOT_RENAME_SYSTEM_GENERATED_SEQUENCE"; + ERROR_CAUSE[-OB_ERR_CANNOT_RENAME_SYSTEM_GENERATED_SEQUENCE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CANNOT_RENAME_SYSTEM_GENERATED_SEQUENCE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CANNOT_RENAME_SYSTEM_GENERATED_SEQUENCE] = -1; SQLSTATE[-OB_ERR_CANNOT_RENAME_SYSTEM_GENERATED_SEQUENCE] = "HY000"; STR_ERROR[-OB_ERR_CANNOT_RENAME_SYSTEM_GENERATED_SEQUENCE] = "cannot rename a system-generated sequence"; @@ -11415,6 +13801,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CANNOT_RENAME_SYSTEM_GENERATED_SEQUENCE] = "ORA-32798: cannot rename a system-generated sequence"; ERROR_NAME[-OB_ERR_REVOKE_BY_COLUMN] = "OB_ERR_REVOKE_BY_COLUMN"; + ERROR_CAUSE[-OB_ERR_REVOKE_BY_COLUMN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_REVOKE_BY_COLUMN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_REVOKE_BY_COLUMN] = -1; SQLSTATE[-OB_ERR_REVOKE_BY_COLUMN] = "HY000"; STR_ERROR[-OB_ERR_REVOKE_BY_COLUMN] = "UPDATE/REFERENCES may only be REVOKEd from the whole table, not by column"; @@ -11426,6 +13814,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_REVOKE_BY_COLUMN] = "ORA-01750: UPDATE/REFERENCES may only be REVOKEd from the whole table, not by column"; ERROR_NAME[-OB_ERR_TYPE_BODY_NOT_EXIST] = "OB_ERR_TYPE_BODY_NOT_EXIST"; + ERROR_CAUSE[-OB_ERR_TYPE_BODY_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TYPE_BODY_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TYPE_BODY_NOT_EXIST] = -1; SQLSTATE[-OB_ERR_TYPE_BODY_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_TYPE_BODY_NOT_EXIST] = "not executed, type body does not exist"; @@ -11434,6 +13824,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_TYPE_BODY_NOT_EXIST] = "ORA-04067: not executed, type body does not exist"; ORACLE_STR_USER_ERROR[-OB_ERR_TYPE_BODY_NOT_EXIST] = "ORA-04067: not executed, type body '%.*s' does not exist"; ERROR_NAME[-OB_ERR_INVALID_ARGUMENT_FOR_WIDTH_BUCKET] = "OB_ERR_INVALID_ARGUMENT_FOR_WIDTH_BUCKET"; + ERROR_CAUSE[-OB_ERR_INVALID_ARGUMENT_FOR_WIDTH_BUCKET] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_ARGUMENT_FOR_WIDTH_BUCKET] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_ARGUMENT_FOR_WIDTH_BUCKET] = -1; SQLSTATE[-OB_ERR_INVALID_ARGUMENT_FOR_WIDTH_BUCKET] = "HY000"; STR_ERROR[-OB_ERR_INVALID_ARGUMENT_FOR_WIDTH_BUCKET] = "The argument of WIDTH_BUCKET function is NULL or invalid."; @@ -11445,6 +13837,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_ARGUMENT_FOR_WIDTH_BUCKET] = "ORA-30494: The argument [%s] of WIDTH_BUCKET function is NULL or invalid."; ERROR_NAME[-OB_ERR_CBY_NO_MEMORY] = "OB_ERR_CBY_NO_MEMORY"; + ERROR_CAUSE[-OB_ERR_CBY_NO_MEMORY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CBY_NO_MEMORY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CBY_NO_MEMORY] = -1; SQLSTATE[-OB_ERR_CBY_NO_MEMORY] = "HY000"; STR_ERROR[-OB_ERR_CBY_NO_MEMORY] = "Not enough memory for CONNECT BY operation"; @@ -11453,6 +13847,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_CBY_NO_MEMORY] = "ORA-30009: Not enough memory for CONNECT BY operation"; ORACLE_STR_USER_ERROR[-OB_ERR_CBY_NO_MEMORY] = "ORA-30009: Not enough memory for CONNECT BY operation"; ERROR_NAME[-OB_ERR_ILLEGAL_PARAM_FOR_CBY_PATH] = "OB_ERR_ILLEGAL_PARAM_FOR_CBY_PATH"; + ERROR_CAUSE[-OB_ERR_ILLEGAL_PARAM_FOR_CBY_PATH] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ILLEGAL_PARAM_FOR_CBY_PATH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ILLEGAL_PARAM_FOR_CBY_PATH] = -1; SQLSTATE[-OB_ERR_ILLEGAL_PARAM_FOR_CBY_PATH] = "HY000"; STR_ERROR[-OB_ERR_ILLEGAL_PARAM_FOR_CBY_PATH] = "illegal parameter in SYS_CONNECT_BY_PATH function"; @@ -11463,6 +13859,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ILLEGAL_PARAM_FOR_CBY_PATH] = "ORA-30003: illegal parameter in SYS_CONNECT_BY_PATH function"; ERROR_NAME[-OB_ERR_HOST_UNKNOWN] = "OB_ERR_HOST_UNKNOWN"; + ERROR_CAUSE[-OB_ERR_HOST_UNKNOWN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_HOST_UNKNOWN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_HOST_UNKNOWN] = -1; SQLSTATE[-OB_ERR_HOST_UNKNOWN] = "HY000"; STR_ERROR[-OB_ERR_HOST_UNKNOWN] = "host unknown"; @@ -11471,6 +13869,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_HOST_UNKNOWN] = "ORA-29257: host unknown"; ORACLE_STR_USER_ERROR[-OB_ERR_HOST_UNKNOWN] = "ORA-29257: host %.*s unknown"; ERROR_NAME[-OB_ERR_WINDOW_NAME_IS_NOT_DEFINE] = "OB_ERR_WINDOW_NAME_IS_NOT_DEFINE"; + ERROR_CAUSE[-OB_ERR_WINDOW_NAME_IS_NOT_DEFINE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_WINDOW_NAME_IS_NOT_DEFINE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_WINDOW_NAME_IS_NOT_DEFINE] = -1; SQLSTATE[-OB_ERR_WINDOW_NAME_IS_NOT_DEFINE] = "HY000"; STR_ERROR[-OB_ERR_WINDOW_NAME_IS_NOT_DEFINE] = "Window name is not defined."; @@ -11481,6 +13881,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_WINDOW_NAME_IS_NOT_DEFINE] = "ORA-00600: internal error code, arguments: -5929, Window name '%.*s' is not defined."; ERROR_NAME[-OB_ERR_OPEN_CURSORS_EXCEEDED] = "OB_ERR_OPEN_CURSORS_EXCEEDED"; + ERROR_CAUSE[-OB_ERR_OPEN_CURSORS_EXCEEDED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OPEN_CURSORS_EXCEEDED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OPEN_CURSORS_EXCEEDED] = -1; SQLSTATE[-OB_ERR_OPEN_CURSORS_EXCEEDED] = "HY000"; STR_ERROR[-OB_ERR_OPEN_CURSORS_EXCEEDED] = "maximum open cursors exceeded"; @@ -11489,6 +13891,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_OPEN_CURSORS_EXCEEDED] = "ORA-01000: maximum open cursors exceeded"; ORACLE_STR_USER_ERROR[-OB_ERR_OPEN_CURSORS_EXCEEDED] = "ORA-01000: maximum open cursors exceeded"; ERROR_NAME[-OB_ERR_ARG_INVALID] = "OB_ERR_ARG_INVALID"; + ERROR_CAUSE[-OB_ERR_ARG_INVALID] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ARG_INVALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ARG_INVALID] = -1; SQLSTATE[-OB_ERR_ARG_INVALID] = "HY000"; STR_ERROR[-OB_ERR_ARG_INVALID] = "argument is null, invalid, or out of range"; @@ -11497,6 +13901,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_ARG_INVALID] = "ORA-21560: argument %.*s is null, invalid, or out of range"; ORACLE_STR_USER_ERROR[-OB_ERR_ARG_INVALID] = "ORA-21560: argument %.*s is null, invalid, or out of range"; ERROR_NAME[-OB_ERR_ILL_NAME_STRING] = "OB_ERR_ILL_NAME_STRING"; + ERROR_CAUSE[-OB_ERR_ILL_NAME_STRING] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ILL_NAME_STRING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ILL_NAME_STRING] = -1; SQLSTATE[-OB_ERR_ILL_NAME_STRING] = "HY000"; STR_ERROR[-OB_ERR_ILL_NAME_STRING] = "unexpected name string"; @@ -11513,6 +13919,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_INCORRECT_VALUE_FOR_FUNCTION] = "ORA-00600: internal error code, arguments: -5936, Incorrect value for function"; ORACLE_STR_USER_ERROR[-OB_ERR_INCORRECT_VALUE_FOR_FUNCTION] = "ORA-00600: internal error code, arguments: -5936, Incorrect %.*s value: '%.*s' for function %.*s"; ERROR_NAME[-OB_TRANSACTION_SET_VIOLATION] = "OB_TRANSACTION_SET_VIOLATION"; + ERROR_CAUSE[-OB_TRANSACTION_SET_VIOLATION] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANSACTION_SET_VIOLATION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANSACTION_SET_VIOLATION] = -1; SQLSTATE[-OB_TRANSACTION_SET_VIOLATION] = "25000"; STR_ERROR[-OB_TRANSACTION_SET_VIOLATION] = "Transaction set changed during the execution"; @@ -11523,6 +13931,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANSACTION_SET_VIOLATION] = "ORA-00600: internal error code, arguments: -6001, Transaction set changed during the execution"; ERROR_NAME[-OB_TRANS_ROLLBACKED] = "OB_TRANS_ROLLBACKED"; + ERROR_CAUSE[-OB_TRANS_ROLLBACKED] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_ROLLBACKED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_ROLLBACKED] = -1; SQLSTATE[-OB_TRANS_ROLLBACKED] = "40000"; STR_ERROR[-OB_TRANS_ROLLBACKED] = "Transaction rollbacked"; @@ -11531,6 +13941,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TRANS_ROLLBACKED] = "ORA-24761: transaction rolled back"; ORACLE_STR_USER_ERROR[-OB_TRANS_ROLLBACKED] = "ORA-24761: transaction rolled back"; ERROR_NAME[-OB_ERR_EXCLUSIVE_LOCK_CONFLICT] = "OB_ERR_EXCLUSIVE_LOCK_CONFLICT"; + ERROR_CAUSE[-OB_ERR_EXCLUSIVE_LOCK_CONFLICT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_EXCLUSIVE_LOCK_CONFLICT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_EXCLUSIVE_LOCK_CONFLICT] = ER_LOCK_WAIT_TIMEOUT; SQLSTATE[-OB_ERR_EXCLUSIVE_LOCK_CONFLICT] = "HY000"; STR_ERROR[-OB_ERR_EXCLUSIVE_LOCK_CONFLICT] = "Lock wait timeout exceeded; try restarting transaction"; @@ -11540,6 +13952,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_EXCLUSIVE_LOCK_CONFLICT] = "ORA-30006: resource busy; acquire with WAIT timeout expired"; ERROR_NAME[-OB_ERR_SHARED_LOCK_CONFLICT] = "OB_ERR_SHARED_LOCK_CONFLICT"; + ERROR_CAUSE[-OB_ERR_SHARED_LOCK_CONFLICT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SHARED_LOCK_CONFLICT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SHARED_LOCK_CONFLICT] = 4012; SQLSTATE[-OB_ERR_SHARED_LOCK_CONFLICT] = "HY000"; STR_ERROR[-OB_ERR_SHARED_LOCK_CONFLICT] = "Statement is timeout"; @@ -11549,6 +13963,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_SHARED_LOCK_CONFLICT] = "ORA-02049: timeout: distributed transaction waiting for lock"; ERROR_NAME[-OB_TRY_LOCK_ROW_CONFLICT] = "OB_TRY_LOCK_ROW_CONFLICT"; + ERROR_CAUSE[-OB_TRY_LOCK_ROW_CONFLICT] = "Internal Error"; + ERROR_SOLUTION[-OB_TRY_LOCK_ROW_CONFLICT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRY_LOCK_ROW_CONFLICT] = -1; SQLSTATE[-OB_TRY_LOCK_ROW_CONFLICT] = "HY000"; STR_ERROR[-OB_TRY_LOCK_ROW_CONFLICT] = "Try lock row conflict"; @@ -11559,6 +13975,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRY_LOCK_ROW_CONFLICT] = "ORA-00600: internal error code, arguments: -6005, Try lock row conflict"; ERROR_NAME[-OB_ERR_EXCLUSIVE_LOCK_CONFLICT_NOWAIT] = "OB_ERR_EXCLUSIVE_LOCK_CONFLICT_NOWAIT"; + ERROR_CAUSE[-OB_ERR_EXCLUSIVE_LOCK_CONFLICT_NOWAIT] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_EXCLUSIVE_LOCK_CONFLICT_NOWAIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_EXCLUSIVE_LOCK_CONFLICT_NOWAIT] = ER_LOCK_WAIT_TIMEOUT; SQLSTATE[-OB_ERR_EXCLUSIVE_LOCK_CONFLICT_NOWAIT] = "HY000"; STR_ERROR[-OB_ERR_EXCLUSIVE_LOCK_CONFLICT_NOWAIT] = "Lock wait timeout exceeded; try restarting transaction"; @@ -11569,6 +13987,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_EXCLUSIVE_LOCK_CONFLICT_NOWAIT] = "ORA-00054: resource busy and acquire with NOWAIT specified or timeout expired"; ERROR_NAME[-OB_CLOCK_OUT_OF_ORDER] = "OB_CLOCK_OUT_OF_ORDER"; + ERROR_CAUSE[-OB_CLOCK_OUT_OF_ORDER] = "Internal Error"; + ERROR_SOLUTION[-OB_CLOCK_OUT_OF_ORDER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CLOCK_OUT_OF_ORDER] = -1; SQLSTATE[-OB_CLOCK_OUT_OF_ORDER] = "25000"; STR_ERROR[-OB_CLOCK_OUT_OF_ORDER] = "Clock out of order"; @@ -11578,6 +13998,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CLOCK_OUT_OF_ORDER] = "ORA-00600: internal error code, arguments: -6201, Clock out of order"; ERROR_NAME[-OB_MASK_SET_NO_NODE] = "OB_MASK_SET_NO_NODE"; + ERROR_CAUSE[-OB_MASK_SET_NO_NODE] = "Internal Error"; + ERROR_SOLUTION[-OB_MASK_SET_NO_NODE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_MASK_SET_NO_NODE] = -1; SQLSTATE[-OB_MASK_SET_NO_NODE] = "25000"; STR_ERROR[-OB_MASK_SET_NO_NODE] = "Mask set has no node"; @@ -11587,6 +14009,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_MASK_SET_NO_NODE] = "ORA-00600: internal error code, arguments: -6203, Mask set has no node"; ERROR_NAME[-OB_TRANS_HAS_DECIDED] = "OB_TRANS_HAS_DECIDED"; + ERROR_CAUSE[-OB_TRANS_HAS_DECIDED] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_HAS_DECIDED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_HAS_DECIDED] = -1; SQLSTATE[-OB_TRANS_HAS_DECIDED] = "HY000"; STR_ERROR[-OB_TRANS_HAS_DECIDED] = "Transaction has been decided"; @@ -11597,6 +14021,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_HAS_DECIDED] = "ORA-00600: internal error code, arguments: -6204, Transaction has been decided"; ERROR_NAME[-OB_TRANS_INVALID_STATE] = "OB_TRANS_INVALID_STATE"; + ERROR_CAUSE[-OB_TRANS_INVALID_STATE] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_INVALID_STATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_INVALID_STATE] = -1; SQLSTATE[-OB_TRANS_INVALID_STATE] = "HY000"; STR_ERROR[-OB_TRANS_INVALID_STATE] = "Transaction state invalid"; @@ -11607,6 +14033,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_INVALID_STATE] = "ORA-00600: internal error code, arguments: -6205, Transaction state invalid"; ERROR_NAME[-OB_TRANS_STATE_NOT_CHANGE] = "OB_TRANS_STATE_NOT_CHANGE"; + ERROR_CAUSE[-OB_TRANS_STATE_NOT_CHANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_STATE_NOT_CHANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_STATE_NOT_CHANGE] = -1; SQLSTATE[-OB_TRANS_STATE_NOT_CHANGE] = "HY000"; STR_ERROR[-OB_TRANS_STATE_NOT_CHANGE] = "Transaction state not changed"; @@ -11617,6 +14045,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_STATE_NOT_CHANGE] = "ORA-00600: internal error code, arguments: -6206, Transaction state not changed"; ERROR_NAME[-OB_TRANS_PROTOCOL_ERROR] = "OB_TRANS_PROTOCOL_ERROR"; + ERROR_CAUSE[-OB_TRANS_PROTOCOL_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_PROTOCOL_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_PROTOCOL_ERROR] = -1; SQLSTATE[-OB_TRANS_PROTOCOL_ERROR] = "HY000"; STR_ERROR[-OB_TRANS_PROTOCOL_ERROR] = "Transaction protocol error"; @@ -11627,6 +14057,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_PROTOCOL_ERROR] = "ORA-00600: internal error code, arguments: -6207, Transaction protocol error"; ERROR_NAME[-OB_TRANS_INVALID_MESSAGE] = "OB_TRANS_INVALID_MESSAGE"; + ERROR_CAUSE[-OB_TRANS_INVALID_MESSAGE] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_INVALID_MESSAGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_INVALID_MESSAGE] = -1; SQLSTATE[-OB_TRANS_INVALID_MESSAGE] = "HY000"; STR_ERROR[-OB_TRANS_INVALID_MESSAGE] = "Transaction message invalid"; @@ -11637,6 +14069,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_INVALID_MESSAGE] = "ORA-00600: internal error code, arguments: -6208, Transaction message invalid"; ERROR_NAME[-OB_TRANS_INVALID_MESSAGE_TYPE] = "OB_TRANS_INVALID_MESSAGE_TYPE"; + ERROR_CAUSE[-OB_TRANS_INVALID_MESSAGE_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_INVALID_MESSAGE_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_INVALID_MESSAGE_TYPE] = -1; SQLSTATE[-OB_TRANS_INVALID_MESSAGE_TYPE] = "HY000"; STR_ERROR[-OB_TRANS_INVALID_MESSAGE_TYPE] = "Transaction message type invalid"; @@ -11647,6 +14081,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_INVALID_MESSAGE_TYPE] = "ORA-00600: internal error code, arguments: -6209, Transaction message type invalid"; ERROR_NAME[-OB_TRANS_TIMEOUT] = "OB_TRANS_TIMEOUT"; + ERROR_CAUSE[-OB_TRANS_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_TIMEOUT] = 4012; SQLSTATE[-OB_TRANS_TIMEOUT] = "25000"; STR_ERROR[-OB_TRANS_TIMEOUT] = "Transaction is timeout"; @@ -11656,6 +14092,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_TIMEOUT] = "ORA-00600: internal error code, arguments: -6210, Transaction is timeout"; ERROR_NAME[-OB_TRANS_KILLED] = "OB_TRANS_KILLED"; + ERROR_CAUSE[-OB_TRANS_KILLED] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_KILLED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_KILLED] = 6002; SQLSTATE[-OB_TRANS_KILLED] = "25000"; STR_ERROR[-OB_TRANS_KILLED] = "Transaction is killed"; @@ -11664,6 +14102,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TRANS_KILLED] = "ORA-24761: transaction rolled back: transaction is killed"; ORACLE_STR_USER_ERROR[-OB_TRANS_KILLED] = "ORA-24761: transaction rolled back: transaction is killed"; ERROR_NAME[-OB_TRANS_STMT_TIMEOUT] = "OB_TRANS_STMT_TIMEOUT"; + ERROR_CAUSE[-OB_TRANS_STMT_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_STMT_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_STMT_TIMEOUT] = 4012; SQLSTATE[-OB_TRANS_STMT_TIMEOUT] = "25000"; STR_ERROR[-OB_TRANS_STMT_TIMEOUT] = "Statement is timeout"; @@ -11673,6 +14113,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_STMT_TIMEOUT] = "ORA-00600: internal error code, arguments: -6212, Statement is timeout"; ERROR_NAME[-OB_TRANS_CTX_NOT_EXIST] = "OB_TRANS_CTX_NOT_EXIST"; + ERROR_CAUSE[-OB_TRANS_CTX_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_CTX_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_CTX_NOT_EXIST] = 6002; SQLSTATE[-OB_TRANS_CTX_NOT_EXIST] = "HY000"; STR_ERROR[-OB_TRANS_CTX_NOT_EXIST] = "Transaction context does not exist"; @@ -11683,6 +14125,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_CTX_NOT_EXIST] = "ORA-24761: transaction rolled back: transaction context does not exist"; ERROR_NAME[-OB_PARTITION_IS_FROZEN] = "OB_PARTITION_IS_FROZEN"; + ERROR_CAUSE[-OB_PARTITION_IS_FROZEN] = "Internal Error"; + ERROR_SOLUTION[-OB_PARTITION_IS_FROZEN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PARTITION_IS_FROZEN] = 6002; SQLSTATE[-OB_PARTITION_IS_FROZEN] = "25000"; STR_ERROR[-OB_PARTITION_IS_FROZEN] = "Partition is frozen"; @@ -11691,6 +14135,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_PARTITION_IS_FROZEN] = "ORA-24761: transaction rolled back: partition is frozen"; ORACLE_STR_USER_ERROR[-OB_PARTITION_IS_FROZEN] = "ORA-24761: transaction rolled back: partition is frozen"; ERROR_NAME[-OB_PARTITION_IS_NOT_FROZEN] = "OB_PARTITION_IS_NOT_FROZEN"; + ERROR_CAUSE[-OB_PARTITION_IS_NOT_FROZEN] = "Internal Error"; + ERROR_SOLUTION[-OB_PARTITION_IS_NOT_FROZEN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PARTITION_IS_NOT_FROZEN] = -1; SQLSTATE[-OB_PARTITION_IS_NOT_FROZEN] = "HY000"; STR_ERROR[-OB_PARTITION_IS_NOT_FROZEN] = "Partition is not frozen"; @@ -11701,6 +14147,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PARTITION_IS_NOT_FROZEN] = "ORA-00600: internal error code, arguments: -6215, Partition is not frozen"; ERROR_NAME[-OB_TRANS_INVALID_LOG_TYPE] = "OB_TRANS_INVALID_LOG_TYPE"; + ERROR_CAUSE[-OB_TRANS_INVALID_LOG_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_INVALID_LOG_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_INVALID_LOG_TYPE] = -1; SQLSTATE[-OB_TRANS_INVALID_LOG_TYPE] = "HY000"; STR_ERROR[-OB_TRANS_INVALID_LOG_TYPE] = "Transaction invalid log type"; @@ -11711,6 +14159,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_INVALID_LOG_TYPE] = "ORA-00600: internal error code, arguments: -6219, Transaction invalid log type"; ERROR_NAME[-OB_TRANS_SQL_SEQUENCE_ILLEGAL] = "OB_TRANS_SQL_SEQUENCE_ILLEGAL"; + ERROR_CAUSE[-OB_TRANS_SQL_SEQUENCE_ILLEGAL] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_SQL_SEQUENCE_ILLEGAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_SQL_SEQUENCE_ILLEGAL] = -1; SQLSTATE[-OB_TRANS_SQL_SEQUENCE_ILLEGAL] = "HY000"; STR_ERROR[-OB_TRANS_SQL_SEQUENCE_ILLEGAL] = "SQL sequence illegal"; @@ -11721,6 +14171,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_SQL_SEQUENCE_ILLEGAL] = "ORA-00600: internal error code, arguments: -6220, SQL sequence illegal"; ERROR_NAME[-OB_TRANS_CANNOT_BE_KILLED] = "OB_TRANS_CANNOT_BE_KILLED"; + ERROR_CAUSE[-OB_TRANS_CANNOT_BE_KILLED] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_CANNOT_BE_KILLED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_CANNOT_BE_KILLED] = -1; SQLSTATE[-OB_TRANS_CANNOT_BE_KILLED] = "HY000"; STR_ERROR[-OB_TRANS_CANNOT_BE_KILLED] = "Transaction context cannot be killed"; @@ -11731,6 +14183,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_CANNOT_BE_KILLED] = "ORA-00600: internal error code, arguments: -6221, Transaction context cannot be killed"; ERROR_NAME[-OB_TRANS_STATE_UNKNOWN] = "OB_TRANS_STATE_UNKNOWN"; + ERROR_CAUSE[-OB_TRANS_STATE_UNKNOWN] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_STATE_UNKNOWN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_STATE_UNKNOWN] = -1; SQLSTATE[-OB_TRANS_STATE_UNKNOWN] = "HY000"; STR_ERROR[-OB_TRANS_STATE_UNKNOWN] = "Transaction state unknown"; @@ -11739,6 +14193,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TRANS_STATE_UNKNOWN] = "ORA-25405: transaction status unknown"; ORACLE_STR_USER_ERROR[-OB_TRANS_STATE_UNKNOWN] = "ORA-25405: transaction status unknown"; ERROR_NAME[-OB_TRANS_IS_EXITING] = "OB_TRANS_IS_EXITING"; + ERROR_CAUSE[-OB_TRANS_IS_EXITING] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_IS_EXITING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_IS_EXITING] = 6002; SQLSTATE[-OB_TRANS_IS_EXITING] = "25000"; STR_ERROR[-OB_TRANS_IS_EXITING] = "Transaction exiting"; @@ -11747,6 +14203,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TRANS_IS_EXITING] = "ORA-24761: transaction rolled back: Transaction exiting"; ORACLE_STR_USER_ERROR[-OB_TRANS_IS_EXITING] = "ORA-24761: transaction rolled back: Transaction exiting"; ERROR_NAME[-OB_TRANS_NEED_ROLLBACK] = "OB_TRANS_NEED_ROLLBACK"; + ERROR_CAUSE[-OB_TRANS_NEED_ROLLBACK] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_NEED_ROLLBACK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_NEED_ROLLBACK] = 6002; SQLSTATE[-OB_TRANS_NEED_ROLLBACK] = "25000"; STR_ERROR[-OB_TRANS_NEED_ROLLBACK] = "transaction needs rollback"; @@ -11755,6 +14213,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TRANS_NEED_ROLLBACK] = "ORA-24761: transaction rolled back: transaction needs rollback"; ORACLE_STR_USER_ERROR[-OB_TRANS_NEED_ROLLBACK] = "ORA-24761: transaction rolled back: transaction needs rollback"; ERROR_NAME[-OB_TRANS_UNKNOWN] = "OB_TRANS_UNKNOWN"; + ERROR_CAUSE[-OB_TRANS_UNKNOWN] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_UNKNOWN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_UNKNOWN] = 4012; SQLSTATE[-OB_TRANS_UNKNOWN] = "25000"; STR_ERROR[-OB_TRANS_UNKNOWN] = "Transaction result is unknown"; @@ -11765,6 +14225,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_UNKNOWN] = "ORA-00600: internal error code, arguments: -6225, Transaction result is unknown"; ERROR_NAME[-OB_ERR_READ_ONLY_TRANSACTION] = "OB_ERR_READ_ONLY_TRANSACTION"; + ERROR_CAUSE[-OB_ERR_READ_ONLY_TRANSACTION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_READ_ONLY_TRANSACTION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_READ_ONLY_TRANSACTION] = ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION; SQLSTATE[-OB_ERR_READ_ONLY_TRANSACTION] = "25006"; STR_ERROR[-OB_ERR_READ_ONLY_TRANSACTION] = "Cannot execute statement in a READ ONLY transaction"; @@ -11775,6 +14237,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_READ_ONLY_TRANSACTION] = "ORA-00600: internal error code, arguments: -6226, Cannot execute statement in a READ ONLY transaction"; ERROR_NAME[-OB_PARTITION_IS_NOT_STOPPED] = "OB_PARTITION_IS_NOT_STOPPED"; + ERROR_CAUSE[-OB_PARTITION_IS_NOT_STOPPED] = "Internal Error"; + ERROR_SOLUTION[-OB_PARTITION_IS_NOT_STOPPED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PARTITION_IS_NOT_STOPPED] = -1; SQLSTATE[-OB_PARTITION_IS_NOT_STOPPED] = "HY000"; STR_ERROR[-OB_PARTITION_IS_NOT_STOPPED] = "Partition is not stopped"; @@ -11785,6 +14249,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PARTITION_IS_NOT_STOPPED] = "ORA-00600: internal error code, arguments: -6227, Partition is not stopped"; ERROR_NAME[-OB_PARTITION_IS_STOPPED] = "OB_PARTITION_IS_STOPPED"; + ERROR_CAUSE[-OB_PARTITION_IS_STOPPED] = "Internal Error"; + ERROR_SOLUTION[-OB_PARTITION_IS_STOPPED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PARTITION_IS_STOPPED] = -1; SQLSTATE[-OB_PARTITION_IS_STOPPED] = "HY000"; STR_ERROR[-OB_PARTITION_IS_STOPPED] = "Partition has been stopped"; @@ -11795,6 +14261,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PARTITION_IS_STOPPED] = "ORA-00600: internal error code, arguments: -6228, Partition has been stopped"; ERROR_NAME[-OB_PARTITION_IS_BLOCKED] = "OB_PARTITION_IS_BLOCKED"; + ERROR_CAUSE[-OB_PARTITION_IS_BLOCKED] = "Internal Error"; + ERROR_SOLUTION[-OB_PARTITION_IS_BLOCKED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PARTITION_IS_BLOCKED] = -1; SQLSTATE[-OB_PARTITION_IS_BLOCKED] = "HY000"; STR_ERROR[-OB_PARTITION_IS_BLOCKED] = "Partition has been blocked"; @@ -11805,6 +14273,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PARTITION_IS_BLOCKED] = "ORA-00600: internal error code, arguments: -6229, Partition has been blocked"; ERROR_NAME[-OB_TRANS_RPC_TIMEOUT] = "OB_TRANS_RPC_TIMEOUT"; + ERROR_CAUSE[-OB_TRANS_RPC_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_RPC_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_RPC_TIMEOUT] = 4012; SQLSTATE[-OB_TRANS_RPC_TIMEOUT] = "25000"; STR_ERROR[-OB_TRANS_RPC_TIMEOUT] = "transaction rpc timeout"; @@ -11815,6 +14285,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_RPC_TIMEOUT] = "ORA-00600: internal error code, arguments: -6230, transaction rpc timeout"; ERROR_NAME[-OB_REPLICA_NOT_READABLE] = "OB_REPLICA_NOT_READABLE"; + ERROR_CAUSE[-OB_REPLICA_NOT_READABLE] = "Internal Error"; + ERROR_SOLUTION[-OB_REPLICA_NOT_READABLE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_REPLICA_NOT_READABLE] = -1; SQLSTATE[-OB_REPLICA_NOT_READABLE] = "HY000"; STR_ERROR[-OB_REPLICA_NOT_READABLE] = "replica is not readable"; @@ -11825,6 +14297,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_REPLICA_NOT_READABLE] = "ORA-00600: internal error code, arguments: -6231, replica is not readable"; ERROR_NAME[-OB_PARTITION_IS_SPLITTING] = "OB_PARTITION_IS_SPLITTING"; + ERROR_CAUSE[-OB_PARTITION_IS_SPLITTING] = "Internal Error"; + ERROR_SOLUTION[-OB_PARTITION_IS_SPLITTING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PARTITION_IS_SPLITTING] = -1; SQLSTATE[-OB_PARTITION_IS_SPLITTING] = "HY000"; STR_ERROR[-OB_PARTITION_IS_SPLITTING] = "Partition is splitting"; @@ -11835,6 +14309,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PARTITION_IS_SPLITTING] = "ORA-00600: internal error code, arguments: -6232, Partition is splitting"; ERROR_NAME[-OB_TRANS_COMMITED] = "OB_TRANS_COMMITED"; + ERROR_CAUSE[-OB_TRANS_COMMITED] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_COMMITED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_COMMITED] = -1; SQLSTATE[-OB_TRANS_COMMITED] = "HY000"; STR_ERROR[-OB_TRANS_COMMITED] = "Transaction has been commited"; @@ -11845,6 +14321,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_COMMITED] = "ORA-00600: internal error code, arguments: -6233, Transaction has been commited"; ERROR_NAME[-OB_TRANS_CTX_COUNT_REACH_LIMIT] = "OB_TRANS_CTX_COUNT_REACH_LIMIT"; + ERROR_CAUSE[-OB_TRANS_CTX_COUNT_REACH_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_CTX_COUNT_REACH_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_CTX_COUNT_REACH_LIMIT] = 6002; SQLSTATE[-OB_TRANS_CTX_COUNT_REACH_LIMIT] = "25000"; STR_ERROR[-OB_TRANS_CTX_COUNT_REACH_LIMIT] = "transaction context count reach limit"; @@ -11855,6 +14333,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_CTX_COUNT_REACH_LIMIT] = "ORA-24761: transaction rolled back: transaction context count reach limit"; ERROR_NAME[-OB_TRANS_CANNOT_SERIALIZE] = "OB_TRANS_CANNOT_SERIALIZE"; + ERROR_CAUSE[-OB_TRANS_CANNOT_SERIALIZE] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_CANNOT_SERIALIZE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_CANNOT_SERIALIZE] = -1; SQLSTATE[-OB_TRANS_CANNOT_SERIALIZE] = "25000"; STR_ERROR[-OB_TRANS_CANNOT_SERIALIZE] = "can't serialize access for this transaction"; @@ -11863,6 +14343,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TRANS_CANNOT_SERIALIZE] = "ORA-08177: can't serialize access for this transaction"; ORACLE_STR_USER_ERROR[-OB_TRANS_CANNOT_SERIALIZE] = "ORA-08177: can't serialize access for this transaction"; ERROR_NAME[-OB_TRANS_WEAK_READ_VERSION_NOT_READY] = "OB_TRANS_WEAK_READ_VERSION_NOT_READY"; + ERROR_CAUSE[-OB_TRANS_WEAK_READ_VERSION_NOT_READY] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_WEAK_READ_VERSION_NOT_READY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_WEAK_READ_VERSION_NOT_READY] = -1; SQLSTATE[-OB_TRANS_WEAK_READ_VERSION_NOT_READY] = "HY000"; STR_ERROR[-OB_TRANS_WEAK_READ_VERSION_NOT_READY] = "transaction weak read version is not ready"; @@ -11873,6 +14355,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_WEAK_READ_VERSION_NOT_READY] = "ORA-00600: internal error code, arguments: -6236, transaction weak read version is not ready"; ERROR_NAME[-OB_GTS_STANDBY_IS_INVALID] = "OB_GTS_STANDBY_IS_INVALID"; + ERROR_CAUSE[-OB_GTS_STANDBY_IS_INVALID] = "Internal Error"; + ERROR_SOLUTION[-OB_GTS_STANDBY_IS_INVALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_GTS_STANDBY_IS_INVALID] = -1; SQLSTATE[-OB_GTS_STANDBY_IS_INVALID] = "HY000"; STR_ERROR[-OB_GTS_STANDBY_IS_INVALID] = "gts standby is invalid"; @@ -11883,6 +14367,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_GTS_STANDBY_IS_INVALID] = "ORA-00600: internal error code, arguments: -6237, gts standby is invalid"; ERROR_NAME[-OB_GTS_UPDATE_FAILED] = "OB_GTS_UPDATE_FAILED"; + ERROR_CAUSE[-OB_GTS_UPDATE_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_GTS_UPDATE_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_GTS_UPDATE_FAILED] = -1; SQLSTATE[-OB_GTS_UPDATE_FAILED] = "HY000"; STR_ERROR[-OB_GTS_UPDATE_FAILED] = "gts update failed"; @@ -11892,6 +14378,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_GTS_UPDATE_FAILED] = "ORA-00600: internal error code, arguments: -6238, gts update failed"; ERROR_NAME[-OB_GTS_IS_NOT_SERVING] = "OB_GTS_IS_NOT_SERVING"; + ERROR_CAUSE[-OB_GTS_IS_NOT_SERVING] = "Internal Error"; + ERROR_SOLUTION[-OB_GTS_IS_NOT_SERVING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_GTS_IS_NOT_SERVING] = -1; SQLSTATE[-OB_GTS_IS_NOT_SERVING] = "HY000"; STR_ERROR[-OB_GTS_IS_NOT_SERVING] = "gts is not serving"; @@ -11901,6 +14389,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_GTS_IS_NOT_SERVING] = "ORA-00600: internal error code, arguments: -6239, gts is not serving"; ERROR_NAME[-OB_PG_PARTITION_NOT_EXIST] = "OB_PG_PARTITION_NOT_EXIST"; + ERROR_CAUSE[-OB_PG_PARTITION_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_PG_PARTITION_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PG_PARTITION_NOT_EXIST] = -1; SQLSTATE[-OB_PG_PARTITION_NOT_EXIST] = "HY000"; STR_ERROR[-OB_PG_PARTITION_NOT_EXIST] = "pg partition not exist"; @@ -11911,6 +14401,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PG_PARTITION_NOT_EXIST] = "ORA-00600: internal error code, arguments: -6240, pg partition not exist"; ERROR_NAME[-OB_TRANS_STMT_NEED_RETRY] = "OB_TRANS_STMT_NEED_RETRY"; + ERROR_CAUSE[-OB_TRANS_STMT_NEED_RETRY] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_STMT_NEED_RETRY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_STMT_NEED_RETRY] = -1; SQLSTATE[-OB_TRANS_STMT_NEED_RETRY] = "HY000"; STR_ERROR[-OB_TRANS_STMT_NEED_RETRY] = "transaction statement need retry"; @@ -11921,6 +14413,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_STMT_NEED_RETRY] = "ORA-00600: internal error code, arguments: -6241, transaction statement need retry"; ERROR_NAME[-OB_SAVEPOINT_NOT_EXIST] = "OB_SAVEPOINT_NOT_EXIST"; + ERROR_CAUSE[-OB_SAVEPOINT_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_SAVEPOINT_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SAVEPOINT_NOT_EXIST] = ER_SP_DOES_NOT_EXIST; SQLSTATE[-OB_SAVEPOINT_NOT_EXIST] = "42000"; STR_ERROR[-OB_SAVEPOINT_NOT_EXIST] = "savepoint does not exist"; @@ -11929,6 +14423,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_SAVEPOINT_NOT_EXIST] = "ORA-01086: savepoint does not exist"; ORACLE_STR_USER_ERROR[-OB_SAVEPOINT_NOT_EXIST] = "ORA-01086: savepoint does not exist"; ERROR_NAME[-OB_TRANS_WAIT_SCHEMA_REFRESH] = "OB_TRANS_WAIT_SCHEMA_REFRESH"; + ERROR_CAUSE[-OB_TRANS_WAIT_SCHEMA_REFRESH] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_WAIT_SCHEMA_REFRESH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_WAIT_SCHEMA_REFRESH] = -1; SQLSTATE[-OB_TRANS_WAIT_SCHEMA_REFRESH] = "HY000"; STR_ERROR[-OB_TRANS_WAIT_SCHEMA_REFRESH] = "local schema is not new enough, replaying logs of user table from " @@ -11943,6 +14439,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -6243, local schema is not new enough, replaying logs of user " "table from standby cluster needs to wait for schema refreshing "; ERROR_NAME[-OB_TRANS_OUT_OF_THRESHOLD] = "OB_TRANS_OUT_OF_THRESHOLD"; + ERROR_CAUSE[-OB_TRANS_OUT_OF_THRESHOLD] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_OUT_OF_THRESHOLD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_OUT_OF_THRESHOLD] = -1; SQLSTATE[-OB_TRANS_OUT_OF_THRESHOLD] = "HY000"; STR_ERROR[-OB_TRANS_OUT_OF_THRESHOLD] = "out of transaction threshold"; @@ -11953,6 +14451,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_OUT_OF_THRESHOLD] = "ORA-00600: internal error code, arguments: -6244, out of transaction threshold"; ERROR_NAME[-OB_TRANS_XA_NOTA] = "OB_TRANS_XA_NOTA"; + ERROR_CAUSE[-OB_TRANS_XA_NOTA] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_XA_NOTA] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_XA_NOTA] = ER_XAER_NOTA; SQLSTATE[-OB_TRANS_XA_NOTA] = "XAE04"; STR_ERROR[-OB_TRANS_XA_NOTA] = "Unknown XID"; @@ -11961,6 +14461,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TRANS_XA_NOTA] = "ORA-00600: internal error code, arguments: -6245, Unknown XID"; ORACLE_STR_USER_ERROR[-OB_TRANS_XA_NOTA] = "ORA-00600: internal error code, arguments: -6245, Unknown XID"; ERROR_NAME[-OB_TRANS_XA_RMFAIL] = "OB_TRANS_XA_RMFAIL"; + ERROR_CAUSE[-OB_TRANS_XA_RMFAIL] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_XA_RMFAIL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_XA_RMFAIL] = ER_XAER_RMFAIL; SQLSTATE[-OB_TRANS_XA_RMFAIL] = "XAE07"; STR_ERROR[-OB_TRANS_XA_RMFAIL] = "The command cannot be executed when global transaction is in this state"; @@ -11971,6 +14473,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_XA_RMFAIL] = "ORA-00600: internal error code, arguments: -6246, The command cannot " "be executed when global transaction is in the %s state"; ERROR_NAME[-OB_TRANS_XA_DUPID] = "OB_TRANS_XA_DUPID"; + ERROR_CAUSE[-OB_TRANS_XA_DUPID] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_XA_DUPID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_XA_DUPID] = ER_XAER_DUPID; SQLSTATE[-OB_TRANS_XA_DUPID] = "XAE08"; STR_ERROR[-OB_TRANS_XA_DUPID] = "The XID already exists"; @@ -11980,6 +14484,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_XA_DUPID] = "ORA-00600: internal error code, arguments: -6247, The XID already exists"; ERROR_NAME[-OB_TRANS_XA_OUTSIDE] = "OB_TRANS_XA_OUTSIDE"; + ERROR_CAUSE[-OB_TRANS_XA_OUTSIDE] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_XA_OUTSIDE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_XA_OUTSIDE] = ER_XAER_OUTSIDE; SQLSTATE[-OB_TRANS_XA_OUTSIDE] = "XAE09"; STR_ERROR[-OB_TRANS_XA_OUTSIDE] = "Some work is done outside global transaction"; @@ -11990,6 +14496,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_XA_OUTSIDE] = "ORA-00600: internal error code, arguments: -6248, Some work is done outside global transaction"; ERROR_NAME[-OB_TRANS_XA_INVAL] = "OB_TRANS_XA_INVAL"; + ERROR_CAUSE[-OB_TRANS_XA_INVAL] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_XA_INVAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_XA_INVAL] = ER_XAER_INVAL; SQLSTATE[-OB_TRANS_XA_INVAL] = "XAE05"; STR_ERROR[-OB_TRANS_XA_INVAL] = "Invalid arguments were given"; @@ -12000,6 +14508,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_XA_INVAL] = "ORA-00600: internal error code, arguments: -6249, Invalid arguments were given"; ERROR_NAME[-OB_TRANS_XA_RMERR] = "OB_TRANS_XA_RMERR"; + ERROR_CAUSE[-OB_TRANS_XA_RMERR] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_XA_RMERR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_XA_RMERR] = ER_XAER_RMERR; SQLSTATE[-OB_TRANS_XA_RMERR] = "XAE03"; STR_ERROR[-OB_TRANS_XA_RMERR] = "Resource manager error occurred in the transaction branch"; @@ -12010,6 +14520,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_XA_RMERR] = "ORA-00600: internal error code, arguments: -6250, Resource manager error occurred in the transaction branch"; ERROR_NAME[-OB_TRANS_XA_PROTO] = "OB_TRANS_XA_PROTO"; + ERROR_CAUSE[-OB_TRANS_XA_PROTO] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_XA_PROTO] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_XA_PROTO] = -1; SQLSTATE[-OB_TRANS_XA_PROTO] = "HY000"; STR_ERROR[-OB_TRANS_XA_PROTO] = "Routine invoked in an improper context"; @@ -12020,6 +14532,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_XA_PROTO] = "ORA-00600: internal error code, arguments: -6251, Routine invoked in an improper context"; ERROR_NAME[-OB_TRANS_XA_RBROLLBACK] = "OB_TRANS_XA_RBROLLBACK"; + ERROR_CAUSE[-OB_TRANS_XA_RBROLLBACK] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_XA_RBROLLBACK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_XA_RBROLLBACK] = ER_XA_RBROLLBACK; SQLSTATE[-OB_TRANS_XA_RBROLLBACK] = "XA100"; STR_ERROR[-OB_TRANS_XA_RBROLLBACK] = "Rollback was caused by an unspecified reason"; @@ -12030,6 +14544,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_XA_RBROLLBACK] = "ORA-00600: internal error code, arguments: -6252, Rollback was caused by an unspecified reason"; ERROR_NAME[-OB_TRANS_XA_RBTIMEOUT] = "OB_TRANS_XA_RBTIMEOUT"; + ERROR_CAUSE[-OB_TRANS_XA_RBTIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_XA_RBTIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_XA_RBTIMEOUT] = ER_XA_RBTIMEOUT; SQLSTATE[-OB_TRANS_XA_RBTIMEOUT] = "XA106"; STR_ERROR[-OB_TRANS_XA_RBTIMEOUT] = "Transaction branch took long"; @@ -12040,6 +14556,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_XA_RBTIMEOUT] = "ORA-00600: internal error code, arguments: -6253, Transaction branch took long"; ERROR_NAME[-OB_TRANS_XA_RDONLY] = "OB_TRANS_XA_RDONLY"; + ERROR_CAUSE[-OB_TRANS_XA_RDONLY] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_XA_RDONLY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_XA_RDONLY] = -1; SQLSTATE[-OB_TRANS_XA_RDONLY] = "HY000"; STR_ERROR[-OB_TRANS_XA_RDONLY] = "Transaction was read-only and has been committed"; @@ -12050,6 +14568,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_XA_RDONLY] = "ORA-00600: internal error code, arguments: -6254, Transaction was read-only and has been committed"; ERROR_NAME[-OB_TRANS_XA_RETRY] = "OB_TRANS_XA_RETRY"; + ERROR_CAUSE[-OB_TRANS_XA_RETRY] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_XA_RETRY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_XA_RETRY] = -1; SQLSTATE[-OB_TRANS_XA_RETRY] = "HY000"; STR_ERROR[-OB_TRANS_XA_RETRY] = "Routine returned with no effect and may be re-issued"; @@ -12060,6 +14580,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_XA_RETRY] = "ORA-00600: internal error code, arguments: -6255, Routine returned with no effect and may be re-issued"; ERROR_NAME[-OB_ERR_ROW_NOT_LOCKED] = "OB_ERR_ROW_NOT_LOCKED"; + ERROR_CAUSE[-OB_ERR_ROW_NOT_LOCKED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ROW_NOT_LOCKED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ROW_NOT_LOCKED] = -1; SQLSTATE[-OB_ERR_ROW_NOT_LOCKED] = "HY000"; STR_ERROR[-OB_ERR_ROW_NOT_LOCKED] = "Row has not been locked"; @@ -12070,6 +14592,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_ROW_NOT_LOCKED] = "ORA-00600: internal error code, arguments: -6256, Row has not been locked"; ERROR_NAME[-OB_EMPTY_PG] = "OB_EMPTY_PG"; + ERROR_CAUSE[-OB_EMPTY_PG] = "Internal Error"; + ERROR_SOLUTION[-OB_EMPTY_PG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_EMPTY_PG] = -1; SQLSTATE[-OB_EMPTY_PG] = "HY000"; STR_ERROR[-OB_EMPTY_PG] = "Empty partition group"; @@ -12078,6 +14602,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_EMPTY_PG] = "ORA-00600: internal error code, arguments: -6257, Empty partition group"; ORACLE_STR_USER_ERROR[-OB_EMPTY_PG] = "ORA-00600: internal error code, arguments: -6257, Empty partition group"; ERROR_NAME[-OB_TRANS_XA_ERR_COMMIT] = "OB_TRANS_XA_ERR_COMMIT"; + ERROR_CAUSE[-OB_TRANS_XA_ERR_COMMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_XA_ERR_COMMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_XA_ERR_COMMIT] = ER_XAER_RMFAIL; SQLSTATE[-OB_TRANS_XA_ERR_COMMIT] = "XAE07"; STR_ERROR[-OB_TRANS_XA_ERR_COMMIT] = @@ -12088,6 +14614,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TRANS_XA_ERR_COMMIT] = "ORA-02089: COMMIT is not allowed in a subordinate session"; ORACLE_STR_USER_ERROR[-OB_TRANS_XA_ERR_COMMIT] = "ORA-02089: COMMIT is not allowed in a subordinate session"; ERROR_NAME[-OB_ERR_RESTORE_POINT_EXIST] = "OB_ERR_RESTORE_POINT_EXIST"; + ERROR_CAUSE[-OB_ERR_RESTORE_POINT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_RESTORE_POINT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_RESTORE_POINT_EXIST] = -1; SQLSTATE[-OB_ERR_RESTORE_POINT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_RESTORE_POINT_EXIST] = "Restore point %s already exists"; @@ -12096,6 +14624,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_RESTORE_POINT_EXIST] = "ORA-38778: Restore point %s already exists"; ORACLE_STR_USER_ERROR[-OB_ERR_RESTORE_POINT_EXIST] = "ORA-38778: Restore point %s already exists"; ERROR_NAME[-OB_ERR_RESTORE_POINT_NOT_EXIST] = "OB_ERR_RESTORE_POINT_NOT_EXIST"; + ERROR_CAUSE[-OB_ERR_RESTORE_POINT_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_RESTORE_POINT_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_RESTORE_POINT_NOT_EXIST] = -1; SQLSTATE[-OB_ERR_RESTORE_POINT_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_RESTORE_POINT_NOT_EXIST] = "Restore point %s does not exist"; @@ -12104,6 +14634,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_RESTORE_POINT_NOT_EXIST] = "ORA-38780: Restore point %s does not exists"; ORACLE_STR_USER_ERROR[-OB_ERR_RESTORE_POINT_NOT_EXIST] = "ORA-38780: Restore point %s does not exists"; ERROR_NAME[-OB_ERR_BACKUP_POINT_EXIST] = "OB_ERR_BACKUP_POINT_EXIST"; + ERROR_CAUSE[-OB_ERR_BACKUP_POINT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_BACKUP_POINT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_BACKUP_POINT_EXIST] = -1; SQLSTATE[-OB_ERR_BACKUP_POINT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_BACKUP_POINT_EXIST] = "Backup point %s already exists"; @@ -12112,6 +14644,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_BACKUP_POINT_EXIST] = "ORA-38778: Restore point %s already exists"; ORACLE_STR_USER_ERROR[-OB_ERR_BACKUP_POINT_EXIST] = "ORA-38778: Restore point %s already exists"; ERROR_NAME[-OB_ERR_BACKUP_POINT_NOT_EXIST] = "OB_ERR_BACKUP_POINT_NOT_EXIST"; + ERROR_CAUSE[-OB_ERR_BACKUP_POINT_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_BACKUP_POINT_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_BACKUP_POINT_NOT_EXIST] = -1; SQLSTATE[-OB_ERR_BACKUP_POINT_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_BACKUP_POINT_NOT_EXIST] = "Backup point %s does not exist"; @@ -12120,6 +14654,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_BACKUP_POINT_NOT_EXIST] = "ORA-38780: Restore point %s does not exists"; ORACLE_STR_USER_ERROR[-OB_ERR_BACKUP_POINT_NOT_EXIST] = "ORA-38780: Restore point %s does not exists"; ERROR_NAME[-OB_ERR_RESTORE_POINT_TOO_MANY] = "OB_ERR_RESTORE_POINT_TOO_MANY"; + ERROR_CAUSE[-OB_ERR_RESTORE_POINT_TOO_MANY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_RESTORE_POINT_TOO_MANY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_RESTORE_POINT_TOO_MANY] = -1; SQLSTATE[-OB_ERR_RESTORE_POINT_TOO_MANY] = "HY000"; STR_ERROR[-OB_ERR_RESTORE_POINT_TOO_MANY] = "cannot create restore point - too many restore points"; @@ -12130,6 +14666,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_RESTORE_POINT_TOO_MANY] = "ORA-38779: cannot create restore point - too many restore points"; ERROR_NAME[-OB_TRANS_XA_BRANCH_FAIL] = "OB_TRANS_XA_BRANCH_FAIL"; + ERROR_CAUSE[-OB_TRANS_XA_BRANCH_FAIL] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_XA_BRANCH_FAIL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_XA_BRANCH_FAIL] = -1; SQLSTATE[-OB_TRANS_XA_BRANCH_FAIL] = "HY000"; STR_ERROR[-OB_TRANS_XA_BRANCH_FAIL] = "another session or branch in same transaction failed or finalized"; @@ -12140,6 +14678,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_XA_BRANCH_FAIL] = "ORA-02051: another session or branch in same transaction failed or finalized"; ERROR_NAME[-OB_LOG_ID_NOT_FOUND] = "OB_LOG_ID_NOT_FOUND"; + ERROR_CAUSE[-OB_LOG_ID_NOT_FOUND] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_ID_NOT_FOUND] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_ID_NOT_FOUND] = -1; SQLSTATE[-OB_LOG_ID_NOT_FOUND] = "HY000"; STR_ERROR[-OB_LOG_ID_NOT_FOUND] = "log id not found"; @@ -12148,6 +14688,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_LOG_ID_NOT_FOUND] = "ORA-00600: internal error code, arguments: -6301, log id not found"; ORACLE_STR_USER_ERROR[-OB_LOG_ID_NOT_FOUND] = "ORA-00600: internal error code, arguments: -6301, log id not found"; ERROR_NAME[-OB_LSR_THREAD_STOPPED] = "OB_LSR_THREAD_STOPPED"; + ERROR_CAUSE[-OB_LSR_THREAD_STOPPED] = "Internal Error"; + ERROR_SOLUTION[-OB_LSR_THREAD_STOPPED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LSR_THREAD_STOPPED] = -1; SQLSTATE[-OB_LSR_THREAD_STOPPED] = "HY000"; STR_ERROR[-OB_LSR_THREAD_STOPPED] = "log scan runnable thread stop"; @@ -12158,6 +14700,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LSR_THREAD_STOPPED] = "ORA-00600: internal error code, arguments: -6302, log scan runnable thread stop"; ERROR_NAME[-OB_NO_LOG] = "OB_NO_LOG"; + ERROR_CAUSE[-OB_NO_LOG] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_LOG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_LOG] = -1; SQLSTATE[-OB_NO_LOG] = "HY000"; STR_ERROR[-OB_NO_LOG] = "no log ever scanned"; @@ -12166,6 +14710,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_NO_LOG] = "ORA-00600: internal error code, arguments: -6303, no log ever scanned"; ORACLE_STR_USER_ERROR[-OB_NO_LOG] = "ORA-00600: internal error code, arguments: -6303, no log ever scanned"; ERROR_NAME[-OB_LOG_ID_RANGE_ERROR] = "OB_LOG_ID_RANGE_ERROR"; + ERROR_CAUSE[-OB_LOG_ID_RANGE_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_ID_RANGE_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_ID_RANGE_ERROR] = -1; SQLSTATE[-OB_LOG_ID_RANGE_ERROR] = "HY000"; STR_ERROR[-OB_LOG_ID_RANGE_ERROR] = "log id range error"; @@ -12175,6 +14721,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LOG_ID_RANGE_ERROR] = "ORA-00600: internal error code, arguments: -6304, log id range error"; ERROR_NAME[-OB_LOG_ITER_ENOUGH] = "OB_LOG_ITER_ENOUGH"; + ERROR_CAUSE[-OB_LOG_ITER_ENOUGH] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_ITER_ENOUGH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_ITER_ENOUGH] = -1; SQLSTATE[-OB_LOG_ITER_ENOUGH] = "HY000"; STR_ERROR[-OB_LOG_ITER_ENOUGH] = "iter scans enough files"; @@ -12184,6 +14732,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LOG_ITER_ENOUGH] = "ORA-00600: internal error code, arguments: -6305, iter scans enough files"; ERROR_NAME[-OB_CLOG_INVALID_ACK] = "OB_CLOG_INVALID_ACK"; + ERROR_CAUSE[-OB_CLOG_INVALID_ACK] = "Internal Error"; + ERROR_SOLUTION[-OB_CLOG_INVALID_ACK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CLOG_INVALID_ACK] = -1; SQLSTATE[-OB_CLOG_INVALID_ACK] = "HY000"; STR_ERROR[-OB_CLOG_INVALID_ACK] = "invalid ack msg"; @@ -12192,6 +14742,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_CLOG_INVALID_ACK] = "ORA-00600: internal error code, arguments: -6306, invalid ack msg"; ORACLE_STR_USER_ERROR[-OB_CLOG_INVALID_ACK] = "ORA-00600: internal error code, arguments: -6306, invalid ack msg"; ERROR_NAME[-OB_CLOG_CACHE_INVALID] = "OB_CLOG_CACHE_INVALID"; + ERROR_CAUSE[-OB_CLOG_CACHE_INVALID] = "Internal Error"; + ERROR_SOLUTION[-OB_CLOG_CACHE_INVALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CLOG_CACHE_INVALID] = -1; SQLSTATE[-OB_CLOG_CACHE_INVALID] = "HY000"; STR_ERROR[-OB_CLOG_CACHE_INVALID] = "clog cache invalid"; @@ -12201,6 +14753,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CLOG_CACHE_INVALID] = "ORA-00600: internal error code, arguments: -6307, clog cache invalid"; ERROR_NAME[-OB_EXT_HANDLE_UNFINISH] = "OB_EXT_HANDLE_UNFINISH"; + ERROR_CAUSE[-OB_EXT_HANDLE_UNFINISH] = "Internal Error"; + ERROR_SOLUTION[-OB_EXT_HANDLE_UNFINISH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_EXT_HANDLE_UNFINISH] = -1; SQLSTATE[-OB_EXT_HANDLE_UNFINISH] = "HY000"; STR_ERROR[-OB_EXT_HANDLE_UNFINISH] = "external executor handle do not finish"; @@ -12211,6 +14765,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_EXT_HANDLE_UNFINISH] = "ORA-00600: internal error code, arguments: -6308, external executor handle do not finish"; ERROR_NAME[-OB_CURSOR_NOT_EXIST] = "OB_CURSOR_NOT_EXIST"; + ERROR_CAUSE[-OB_CURSOR_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_CURSOR_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CURSOR_NOT_EXIST] = -1; SQLSTATE[-OB_CURSOR_NOT_EXIST] = "HY000"; STR_ERROR[-OB_CURSOR_NOT_EXIST] = "cursor not exist"; @@ -12219,6 +14775,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_CURSOR_NOT_EXIST] = "ORA-00600: internal error code, arguments: -6309, cursor not exist"; ORACLE_STR_USER_ERROR[-OB_CURSOR_NOT_EXIST] = "ORA-00600: internal error code, arguments: -6309, cursor not exist"; ERROR_NAME[-OB_STREAM_NOT_EXIST] = "OB_STREAM_NOT_EXIST"; + ERROR_CAUSE[-OB_STREAM_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_STREAM_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_STREAM_NOT_EXIST] = -1; SQLSTATE[-OB_STREAM_NOT_EXIST] = "HY000"; STR_ERROR[-OB_STREAM_NOT_EXIST] = "stream not exist"; @@ -12227,6 +14785,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_STREAM_NOT_EXIST] = "ORA-00600: internal error code, arguments: -6310, stream not exist"; ORACLE_STR_USER_ERROR[-OB_STREAM_NOT_EXIST] = "ORA-00600: internal error code, arguments: -6310, stream not exist"; ERROR_NAME[-OB_STREAM_BUSY] = "OB_STREAM_BUSY"; + ERROR_CAUSE[-OB_STREAM_BUSY] = "Internal Error"; + ERROR_SOLUTION[-OB_STREAM_BUSY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_STREAM_BUSY] = -1; SQLSTATE[-OB_STREAM_BUSY] = "HY000"; STR_ERROR[-OB_STREAM_BUSY] = "stream busy"; @@ -12235,6 +14795,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_STREAM_BUSY] = "ORA-00600: internal error code, arguments: -6311, stream busy"; ORACLE_STR_USER_ERROR[-OB_STREAM_BUSY] = "ORA-00600: internal error code, arguments: -6311, stream busy"; ERROR_NAME[-OB_FILE_RECYCLED] = "OB_FILE_RECYCLED"; + ERROR_CAUSE[-OB_FILE_RECYCLED] = "Internal Error"; + ERROR_SOLUTION[-OB_FILE_RECYCLED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_FILE_RECYCLED] = -1; SQLSTATE[-OB_FILE_RECYCLED] = "HY000"; STR_ERROR[-OB_FILE_RECYCLED] = "file recycled"; @@ -12243,6 +14805,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_FILE_RECYCLED] = "ORA-00600: internal error code, arguments: -6312, file recycled"; ORACLE_STR_USER_ERROR[-OB_FILE_RECYCLED] = "ORA-00600: internal error code, arguments: -6312, file recycled"; ERROR_NAME[-OB_REPLAY_EAGAIN_TOO_MUCH_TIME] = "OB_REPLAY_EAGAIN_TOO_MUCH_TIME"; + ERROR_CAUSE[-OB_REPLAY_EAGAIN_TOO_MUCH_TIME] = "Internal Error"; + ERROR_SOLUTION[-OB_REPLAY_EAGAIN_TOO_MUCH_TIME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_REPLAY_EAGAIN_TOO_MUCH_TIME] = -1; SQLSTATE[-OB_REPLAY_EAGAIN_TOO_MUCH_TIME] = "HY000"; STR_ERROR[-OB_REPLAY_EAGAIN_TOO_MUCH_TIME] = "replay eagain cost too much time"; @@ -12253,6 +14817,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_REPLAY_EAGAIN_TOO_MUCH_TIME] = "ORA-00600: internal error code, arguments: -6313, replay eagain cost too much time"; ERROR_NAME[-OB_MEMBER_CHANGE_FAILED] = "OB_MEMBER_CHANGE_FAILED"; + ERROR_CAUSE[-OB_MEMBER_CHANGE_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_MEMBER_CHANGE_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_MEMBER_CHANGE_FAILED] = -1; SQLSTATE[-OB_MEMBER_CHANGE_FAILED] = "HY000"; STR_ERROR[-OB_MEMBER_CHANGE_FAILED] = "member change log sync failed"; @@ -12263,6 +14829,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_MEMBER_CHANGE_FAILED] = "ORA-00600: internal error code, arguments: -6314, member change log sync failed"; ERROR_NAME[-OB_NO_NEED_BATCH_CTX] = "OB_NO_NEED_BATCH_CTX"; + ERROR_CAUSE[-OB_NO_NEED_BATCH_CTX] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_NEED_BATCH_CTX] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_NEED_BATCH_CTX] = -1; SQLSTATE[-OB_NO_NEED_BATCH_CTX] = "HY000"; STR_ERROR[-OB_NO_NEED_BATCH_CTX] = "no need batch ctx"; @@ -12272,6 +14840,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NO_NEED_BATCH_CTX] = "ORA-00600: internal error code, arguments: -6315, no need batch ctx"; ERROR_NAME[-OB_TOO_LARGE_LOG_ID] = "OB_TOO_LARGE_LOG_ID"; + ERROR_CAUSE[-OB_TOO_LARGE_LOG_ID] = "Internal Error"; + ERROR_SOLUTION[-OB_TOO_LARGE_LOG_ID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TOO_LARGE_LOG_ID] = -1; SQLSTATE[-OB_TOO_LARGE_LOG_ID] = "HY000"; STR_ERROR[-OB_TOO_LARGE_LOG_ID] = "too large log id"; @@ -12280,6 +14850,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_TOO_LARGE_LOG_ID] = "ORA-00600: internal error code, arguments: -6316, too large log id"; ORACLE_STR_USER_ERROR[-OB_TOO_LARGE_LOG_ID] = "ORA-00600: internal error code, arguments: -6316, too large log id"; ERROR_NAME[-OB_ALLOC_LOG_ID_NEED_RETRY] = "OB_ALLOC_LOG_ID_NEED_RETRY"; + ERROR_CAUSE[-OB_ALLOC_LOG_ID_NEED_RETRY] = "Internal Error"; + ERROR_SOLUTION[-OB_ALLOC_LOG_ID_NEED_RETRY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ALLOC_LOG_ID_NEED_RETRY] = -1; SQLSTATE[-OB_ALLOC_LOG_ID_NEED_RETRY] = "HY000"; STR_ERROR[-OB_ALLOC_LOG_ID_NEED_RETRY] = "alloc log id need retry"; @@ -12290,6 +14862,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ALLOC_LOG_ID_NEED_RETRY] = "ORA-00600: internal error code, arguments: -6317, alloc log id need retry"; ERROR_NAME[-OB_TRANS_ONE_PC_NOT_ALLOWED] = "OB_TRANS_ONE_PC_NOT_ALLOWED"; + ERROR_CAUSE[-OB_TRANS_ONE_PC_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANS_ONE_PC_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANS_ONE_PC_NOT_ALLOWED] = -1; SQLSTATE[-OB_TRANS_ONE_PC_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_TRANS_ONE_PC_NOT_ALLOWED] = "transaction one pc not allowed"; @@ -12300,6 +14874,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANS_ONE_PC_NOT_ALLOWED] = "ORA-00600: internal error code, arguments: -6318, transaction one pc not allowed"; ERROR_NAME[-OB_LOG_NEED_REBUILD] = "OB_LOG_NEED_REBUILD"; + ERROR_CAUSE[-OB_LOG_NEED_REBUILD] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_NEED_REBUILD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_NEED_REBUILD] = -1; SQLSTATE[-OB_LOG_NEED_REBUILD] = "HY000"; STR_ERROR[-OB_LOG_NEED_REBUILD] = "need rebuild"; @@ -12308,6 +14884,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_LOG_NEED_REBUILD] = "ORA-00600: internal error code, arguments: -6319, need rebuild"; ORACLE_STR_USER_ERROR[-OB_LOG_NEED_REBUILD] = "ORA-00600: internal error code, arguments: -6319, need rebuild"; ERROR_NAME[-OB_TOO_MANY_LOG_TASK] = "OB_TOO_MANY_LOG_TASK"; + ERROR_CAUSE[-OB_TOO_MANY_LOG_TASK] = "Internal Error"; + ERROR_SOLUTION[-OB_TOO_MANY_LOG_TASK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TOO_MANY_LOG_TASK] = -1; SQLSTATE[-OB_TOO_MANY_LOG_TASK] = "HY000"; STR_ERROR[-OB_TOO_MANY_LOG_TASK] = "too many log tasks"; @@ -12317,6 +14895,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TOO_MANY_LOG_TASK] = "ORA-00600: internal error code, arguments: -6320, too many log tasks"; ERROR_NAME[-OB_INVALID_BATCH_SIZE] = "OB_INVALID_BATCH_SIZE"; + ERROR_CAUSE[-OB_INVALID_BATCH_SIZE] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_BATCH_SIZE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_BATCH_SIZE] = -1; SQLSTATE[-OB_INVALID_BATCH_SIZE] = "HY000"; STR_ERROR[-OB_INVALID_BATCH_SIZE] = "ob invalid batch size"; @@ -12327,6 +14907,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_BATCH_SIZE] = "ORA-00600: internal error code, arguments: -6321, ob invalid batch size"; ERROR_NAME[-OB_CLOG_SLIDE_TIMEOUT] = "OB_CLOG_SLIDE_TIMEOUT"; + ERROR_CAUSE[-OB_CLOG_SLIDE_TIMEOUT] = "Internal Error"; + ERROR_SOLUTION[-OB_CLOG_SLIDE_TIMEOUT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CLOG_SLIDE_TIMEOUT] = -1; SQLSTATE[-OB_CLOG_SLIDE_TIMEOUT] = "HY000"; STR_ERROR[-OB_CLOG_SLIDE_TIMEOUT] = "ob clog slide timeout"; @@ -12337,6 +14919,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CLOG_SLIDE_TIMEOUT] = "ORA-00600: internal error code, arguments: -6322, ob clog slide timeout"; ERROR_NAME[-OB_ELECTION_WARN_LOGBUF_FULL] = "OB_ELECTION_WARN_LOGBUF_FULL"; + ERROR_CAUSE[-OB_ELECTION_WARN_LOGBUF_FULL] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_LOGBUF_FULL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_LOGBUF_FULL] = -1; SQLSTATE[-OB_ELECTION_WARN_LOGBUF_FULL] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_LOGBUF_FULL] = "The log buffer is full"; @@ -12347,6 +14931,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_LOGBUF_FULL] = "ORA-00600: internal error code, arguments: -7000, The log buffer is full"; ERROR_NAME[-OB_ELECTION_WARN_LOGBUF_EMPTY] = "OB_ELECTION_WARN_LOGBUF_EMPTY"; + ERROR_CAUSE[-OB_ELECTION_WARN_LOGBUF_EMPTY] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_LOGBUF_EMPTY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_LOGBUF_EMPTY] = -1; SQLSTATE[-OB_ELECTION_WARN_LOGBUF_EMPTY] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_LOGBUF_EMPTY] = "The log buffer is empty"; @@ -12357,6 +14943,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_LOGBUF_EMPTY] = "ORA-00600: internal error code, arguments: -7001, The log buffer is empty"; ERROR_NAME[-OB_ELECTION_WARN_NOT_RUNNING] = "OB_ELECTION_WARN_NOT_RUNNING"; + ERROR_CAUSE[-OB_ELECTION_WARN_NOT_RUNNING] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_NOT_RUNNING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_NOT_RUNNING] = -1; SQLSTATE[-OB_ELECTION_WARN_NOT_RUNNING] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_NOT_RUNNING] = "The object is not running"; @@ -12367,6 +14955,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_NOT_RUNNING] = "ORA-00600: internal error code, arguments: -7002, The object is not running"; ERROR_NAME[-OB_ELECTION_WARN_IS_RUNNING] = "OB_ELECTION_WARN_IS_RUNNING"; + ERROR_CAUSE[-OB_ELECTION_WARN_IS_RUNNING] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_IS_RUNNING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_IS_RUNNING] = -1; SQLSTATE[-OB_ELECTION_WARN_IS_RUNNING] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_IS_RUNNING] = "The object is running"; @@ -12377,6 +14967,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_IS_RUNNING] = "ORA-00600: internal error code, arguments: -7003, The object is running"; ERROR_NAME[-OB_ELECTION_WARN_NOT_REACH_MAJORITY] = "OB_ELECTION_WARN_NOT_REACH_MAJORITY"; + ERROR_CAUSE[-OB_ELECTION_WARN_NOT_REACH_MAJORITY] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_NOT_REACH_MAJORITY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_NOT_REACH_MAJORITY] = -1; SQLSTATE[-OB_ELECTION_WARN_NOT_REACH_MAJORITY] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_NOT_REACH_MAJORITY] = "Election does not reach majority"; @@ -12387,6 +14979,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_NOT_REACH_MAJORITY] = "ORA-00600: internal error code, arguments: -7004, Election does not reach majority"; ERROR_NAME[-OB_ELECTION_WARN_INVALID_SERVER] = "OB_ELECTION_WARN_INVALID_SERVER"; + ERROR_CAUSE[-OB_ELECTION_WARN_INVALID_SERVER] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_INVALID_SERVER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_INVALID_SERVER] = -1; SQLSTATE[-OB_ELECTION_WARN_INVALID_SERVER] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_INVALID_SERVER] = "The server is not valid"; @@ -12397,6 +14991,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_INVALID_SERVER] = "ORA-00600: internal error code, arguments: -7005, The server is not valid"; ERROR_NAME[-OB_ELECTION_WARN_INVALID_LEADER] = "OB_ELECTION_WARN_INVALID_LEADER"; + ERROR_CAUSE[-OB_ELECTION_WARN_INVALID_LEADER] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_INVALID_LEADER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_INVALID_LEADER] = -1; SQLSTATE[-OB_ELECTION_WARN_INVALID_LEADER] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_INVALID_LEADER] = "The leader is not valid"; @@ -12407,6 +15003,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_INVALID_LEADER] = "ORA-00600: internal error code, arguments: -7006, The leader is not valid"; ERROR_NAME[-OB_ELECTION_WARN_LEADER_LEASE_EXPIRED] = "OB_ELECTION_WARN_LEADER_LEASE_EXPIRED"; + ERROR_CAUSE[-OB_ELECTION_WARN_LEADER_LEASE_EXPIRED] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_LEADER_LEASE_EXPIRED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_LEADER_LEASE_EXPIRED] = -1; SQLSTATE[-OB_ELECTION_WARN_LEADER_LEASE_EXPIRED] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_LEADER_LEASE_EXPIRED] = "The leader lease is expired"; @@ -12417,6 +15015,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_LEADER_LEASE_EXPIRED] = "ORA-00600: internal error code, arguments: -7007, The leader lease is expired"; ERROR_NAME[-OB_ELECTION_WARN_INVALID_MESSAGE] = "OB_ELECTION_WARN_INVALID_MESSAGE"; + ERROR_CAUSE[-OB_ELECTION_WARN_INVALID_MESSAGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_INVALID_MESSAGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_INVALID_MESSAGE] = -1; SQLSTATE[-OB_ELECTION_WARN_INVALID_MESSAGE] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_INVALID_MESSAGE] = "The message is not valid"; @@ -12427,6 +15027,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_INVALID_MESSAGE] = "ORA-00600: internal error code, arguments: -7010, The message is not valid"; ERROR_NAME[-OB_ELECTION_WARN_MESSAGE_NOT_INTIME] = "OB_ELECTION_WARN_MESSAGE_NOT_INTIME"; + ERROR_CAUSE[-OB_ELECTION_WARN_MESSAGE_NOT_INTIME] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_MESSAGE_NOT_INTIME] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_MESSAGE_NOT_INTIME] = -1; SQLSTATE[-OB_ELECTION_WARN_MESSAGE_NOT_INTIME] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_MESSAGE_NOT_INTIME] = "The message is not intime"; @@ -12437,6 +15039,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_MESSAGE_NOT_INTIME] = "ORA-00600: internal error code, arguments: -7011, The message is not intime"; ERROR_NAME[-OB_ELECTION_WARN_NOT_CANDIDATE] = "OB_ELECTION_WARN_NOT_CANDIDATE"; + ERROR_CAUSE[-OB_ELECTION_WARN_NOT_CANDIDATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_NOT_CANDIDATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_NOT_CANDIDATE] = -1; SQLSTATE[-OB_ELECTION_WARN_NOT_CANDIDATE] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_NOT_CANDIDATE] = "The server is not candidate"; @@ -12447,6 +15051,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_NOT_CANDIDATE] = "ORA-00600: internal error code, arguments: -7012, The server is not candidate"; ERROR_NAME[-OB_ELECTION_WARN_NOT_CANDIDATE_OR_VOTER] = "OB_ELECTION_WARN_NOT_CANDIDATE_OR_VOTER"; + ERROR_CAUSE[-OB_ELECTION_WARN_NOT_CANDIDATE_OR_VOTER] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_NOT_CANDIDATE_OR_VOTER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_NOT_CANDIDATE_OR_VOTER] = -1; SQLSTATE[-OB_ELECTION_WARN_NOT_CANDIDATE_OR_VOTER] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_NOT_CANDIDATE_OR_VOTER] = "The server is not candidate or voter"; @@ -12457,6 +15063,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_NOT_CANDIDATE_OR_VOTER] = "ORA-00600: internal error code, arguments: -7013, The server is not candidate or voter"; ERROR_NAME[-OB_ELECTION_WARN_PROTOCOL_ERROR] = "OB_ELECTION_WARN_PROTOCOL_ERROR"; + ERROR_CAUSE[-OB_ELECTION_WARN_PROTOCOL_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_PROTOCOL_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_PROTOCOL_ERROR] = -1; SQLSTATE[-OB_ELECTION_WARN_PROTOCOL_ERROR] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_PROTOCOL_ERROR] = "Election protocol error"; @@ -12467,6 +15075,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_PROTOCOL_ERROR] = "ORA-00600: internal error code, arguments: -7014, Election protocol error"; ERROR_NAME[-OB_ELECTION_WARN_RUNTIME_OUT_OF_RANGE] = "OB_ELECTION_WARN_RUNTIME_OUT_OF_RANGE"; + ERROR_CAUSE[-OB_ELECTION_WARN_RUNTIME_OUT_OF_RANGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_RUNTIME_OUT_OF_RANGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_RUNTIME_OUT_OF_RANGE] = -1; SQLSTATE[-OB_ELECTION_WARN_RUNTIME_OUT_OF_RANGE] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_RUNTIME_OUT_OF_RANGE] = "The task run time out of range"; @@ -12477,6 +15087,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_RUNTIME_OUT_OF_RANGE] = "ORA-00600: internal error code, arguments: -7015, The task run time out of range"; ERROR_NAME[-OB_ELECTION_WARN_LAST_OPERATION_NOT_DONE] = "OB_ELECTION_WARN_LAST_OPERATION_NOT_DONE"; + ERROR_CAUSE[-OB_ELECTION_WARN_LAST_OPERATION_NOT_DONE] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_LAST_OPERATION_NOT_DONE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_LAST_OPERATION_NOT_DONE] = -1; SQLSTATE[-OB_ELECTION_WARN_LAST_OPERATION_NOT_DONE] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_LAST_OPERATION_NOT_DONE] = "Last operation has not done"; @@ -12487,6 +15099,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_LAST_OPERATION_NOT_DONE] = "ORA-00600: internal error code, arguments: -7021, Last operation has not done"; ERROR_NAME[-OB_ELECTION_WARN_CURRENT_SERVER_NOT_LEADER] = "OB_ELECTION_WARN_CURRENT_SERVER_NOT_LEADER"; + ERROR_CAUSE[-OB_ELECTION_WARN_CURRENT_SERVER_NOT_LEADER] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_CURRENT_SERVER_NOT_LEADER] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_CURRENT_SERVER_NOT_LEADER] = -1; SQLSTATE[-OB_ELECTION_WARN_CURRENT_SERVER_NOT_LEADER] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_CURRENT_SERVER_NOT_LEADER] = "Current server is not leader"; @@ -12497,6 +15111,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_CURRENT_SERVER_NOT_LEADER] = "ORA-00600: internal error code, arguments: -7022, Current server is not leader"; ERROR_NAME[-OB_ELECTION_WARN_NO_PREPARE_MESSAGE] = "OB_ELECTION_WARN_NO_PREPARE_MESSAGE"; + ERROR_CAUSE[-OB_ELECTION_WARN_NO_PREPARE_MESSAGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_NO_PREPARE_MESSAGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_NO_PREPARE_MESSAGE] = -1; SQLSTATE[-OB_ELECTION_WARN_NO_PREPARE_MESSAGE] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_NO_PREPARE_MESSAGE] = "There is not prepare message"; @@ -12507,6 +15123,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_NO_PREPARE_MESSAGE] = "ORA-00600: internal error code, arguments: -7024, There is not prepare message"; ERROR_NAME[-OB_ELECTION_ERROR_MULTI_PREPARE_MESSAGE] = "OB_ELECTION_ERROR_MULTI_PREPARE_MESSAGE"; + ERROR_CAUSE[-OB_ELECTION_ERROR_MULTI_PREPARE_MESSAGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_ERROR_MULTI_PREPARE_MESSAGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_ERROR_MULTI_PREPARE_MESSAGE] = -1; SQLSTATE[-OB_ELECTION_ERROR_MULTI_PREPARE_MESSAGE] = "HY000"; STR_ERROR[-OB_ELECTION_ERROR_MULTI_PREPARE_MESSAGE] = "There is more than one prepare message"; @@ -12517,6 +15135,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_ERROR_MULTI_PREPARE_MESSAGE] = "ORA-00600: internal error code, arguments: -7025, There is more than one prepare message"; ERROR_NAME[-OB_ELECTION_NOT_EXIST] = "OB_ELECTION_NOT_EXIST"; + ERROR_CAUSE[-OB_ELECTION_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_NOT_EXIST] = -1; SQLSTATE[-OB_ELECTION_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ELECTION_NOT_EXIST] = "Election does not exist"; @@ -12527,6 +15147,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_NOT_EXIST] = "ORA-00600: internal error code, arguments: -7026, Election does not exist"; ERROR_NAME[-OB_ELECTION_MGR_IS_RUNNING] = "OB_ELECTION_MGR_IS_RUNNING"; + ERROR_CAUSE[-OB_ELECTION_MGR_IS_RUNNING] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_MGR_IS_RUNNING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_MGR_IS_RUNNING] = -1; SQLSTATE[-OB_ELECTION_MGR_IS_RUNNING] = "HY000"; STR_ERROR[-OB_ELECTION_MGR_IS_RUNNING] = "Election manager is running"; @@ -12537,6 +15159,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_MGR_IS_RUNNING] = "ORA-00600: internal error code, arguments: -7027, Election manager is running"; ERROR_NAME[-OB_ELECTION_WARN_NO_MAJORITY_PREPARE_MESSAGE] = "OB_ELECTION_WARN_NO_MAJORITY_PREPARE_MESSAGE"; + ERROR_CAUSE[-OB_ELECTION_WARN_NO_MAJORITY_PREPARE_MESSAGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_NO_MAJORITY_PREPARE_MESSAGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_NO_MAJORITY_PREPARE_MESSAGE] = -1; SQLSTATE[-OB_ELECTION_WARN_NO_MAJORITY_PREPARE_MESSAGE] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_NO_MAJORITY_PREPARE_MESSAGE] = "Election msg pool not have majority prepare message"; @@ -12548,6 +15172,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_NO_MAJORITY_PREPARE_MESSAGE] = "ORA-00600: internal error code, arguments: -7029, Election msg pool not have majority prepare message"; ERROR_NAME[-OB_ELECTION_ASYNC_LOG_WARN_INIT] = "OB_ELECTION_ASYNC_LOG_WARN_INIT"; + ERROR_CAUSE[-OB_ELECTION_ASYNC_LOG_WARN_INIT] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_ASYNC_LOG_WARN_INIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_ASYNC_LOG_WARN_INIT] = -1; SQLSTATE[-OB_ELECTION_ASYNC_LOG_WARN_INIT] = "HY000"; STR_ERROR[-OB_ELECTION_ASYNC_LOG_WARN_INIT] = "Election async log init error"; @@ -12558,6 +15184,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_ASYNC_LOG_WARN_INIT] = "ORA-00600: internal error code, arguments: -7030, Election async log init error"; ERROR_NAME[-OB_ELECTION_WAIT_LEADER_MESSAGE] = "OB_ELECTION_WAIT_LEADER_MESSAGE"; + ERROR_CAUSE[-OB_ELECTION_WAIT_LEADER_MESSAGE] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WAIT_LEADER_MESSAGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WAIT_LEADER_MESSAGE] = -1; SQLSTATE[-OB_ELECTION_WAIT_LEADER_MESSAGE] = "HY000"; STR_ERROR[-OB_ELECTION_WAIT_LEADER_MESSAGE] = "Election waiting leader message"; @@ -12568,6 +15196,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WAIT_LEADER_MESSAGE] = "ORA-00600: internal error code, arguments: -7031, Election waiting leader message"; ERROR_NAME[-OB_ELECTION_GROUP_NOT_EXIST] = "OB_ELECTION_GROUP_NOT_EXIST"; + ERROR_CAUSE[-OB_ELECTION_GROUP_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_GROUP_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_GROUP_NOT_EXIST] = -1; SQLSTATE[-OB_ELECTION_GROUP_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ELECTION_GROUP_NOT_EXIST] = "Election group not exist"; @@ -12578,6 +15208,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_GROUP_NOT_EXIST] = "ORA-00600: internal error code, arguments: -7032, Election group not exist"; ERROR_NAME[-OB_UNEXPECT_EG_VERSION] = "OB_UNEXPECT_EG_VERSION"; + ERROR_CAUSE[-OB_UNEXPECT_EG_VERSION] = "Internal Error"; + ERROR_SOLUTION[-OB_UNEXPECT_EG_VERSION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_UNEXPECT_EG_VERSION] = -1; SQLSTATE[-OB_UNEXPECT_EG_VERSION] = "HY000"; STR_ERROR[-OB_UNEXPECT_EG_VERSION] = "unexpected eg_version"; @@ -12588,6 +15220,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_UNEXPECT_EG_VERSION] = "ORA-00600: internal error code, arguments: -7033, unexpected eg_version"; ERROR_NAME[-OB_ELECTION_GROUP_MGR_IS_RUNNING] = "OB_ELECTION_GROUP_MGR_IS_RUNNING"; + ERROR_CAUSE[-OB_ELECTION_GROUP_MGR_IS_RUNNING] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_GROUP_MGR_IS_RUNNING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_GROUP_MGR_IS_RUNNING] = -1; SQLSTATE[-OB_ELECTION_GROUP_MGR_IS_RUNNING] = "HY000"; STR_ERROR[-OB_ELECTION_GROUP_MGR_IS_RUNNING] = "election_group_mgr is running"; @@ -12598,6 +15232,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_GROUP_MGR_IS_RUNNING] = "ORA-00600: internal error code, arguments: -7034, election_group_mgr is running"; ERROR_NAME[-OB_ELECTION_MGR_NOT_RUNNING] = "OB_ELECTION_MGR_NOT_RUNNING"; + ERROR_CAUSE[-OB_ELECTION_MGR_NOT_RUNNING] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_MGR_NOT_RUNNING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_MGR_NOT_RUNNING] = -1; SQLSTATE[-OB_ELECTION_MGR_NOT_RUNNING] = "HY000"; STR_ERROR[-OB_ELECTION_MGR_NOT_RUNNING] = "Election manager is not running"; @@ -12608,6 +15244,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_MGR_NOT_RUNNING] = "ORA-00600: internal error code, arguments: -7035, Election manager is not running"; ERROR_NAME[-OB_ELECTION_ERROR_VOTE_MSG_CONFLICT] = "OB_ELECTION_ERROR_VOTE_MSG_CONFLICT"; + ERROR_CAUSE[-OB_ELECTION_ERROR_VOTE_MSG_CONFLICT] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_ERROR_VOTE_MSG_CONFLICT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_ERROR_VOTE_MSG_CONFLICT] = -1; SQLSTATE[-OB_ELECTION_ERROR_VOTE_MSG_CONFLICT] = "HY000"; STR_ERROR[-OB_ELECTION_ERROR_VOTE_MSG_CONFLICT] = "Receive change leader msg and vote msg with same T1 timestamp"; @@ -12621,6 +15259,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -7036, Receive change leader msg and vote msg with same T1 " "timestamp"; ERROR_NAME[-OB_ELECTION_ERROR_DUPLICATED_MSG] = "OB_ELECTION_ERROR_DUPLICATED_MSG"; + ERROR_CAUSE[-OB_ELECTION_ERROR_DUPLICATED_MSG] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_ERROR_DUPLICATED_MSG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_ERROR_DUPLICATED_MSG] = -1; SQLSTATE[-OB_ELECTION_ERROR_DUPLICATED_MSG] = "HY000"; STR_ERROR[-OB_ELECTION_ERROR_DUPLICATED_MSG] = "Receive duplicated prepare/vote msg with same T1 timestamp"; @@ -12631,6 +15271,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_ERROR_DUPLICATED_MSG] = "ORA-00600: internal error code, arguments: -7037, Receive duplicated prepare/vote msg with same T1 timestamp"; ERROR_NAME[-OB_ELECTION_WARN_T1_NOT_MATCH] = "OB_ELECTION_WARN_T1_NOT_MATCH"; + ERROR_CAUSE[-OB_ELECTION_WARN_T1_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_ELECTION_WARN_T1_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ELECTION_WARN_T1_NOT_MATCH] = -1; SQLSTATE[-OB_ELECTION_WARN_T1_NOT_MATCH] = "HY000"; STR_ERROR[-OB_ELECTION_WARN_T1_NOT_MATCH] = "T1 timestamp is not match"; @@ -12641,6 +15283,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ELECTION_WARN_T1_NOT_MATCH] = "ORA-00600: internal error code, arguments: -7038, T1 timestamp is not match"; ERROR_NAME[-OB_TRANSFER_TASK_COMPLETED] = "OB_TRANSFER_TASK_COMPLETED"; + ERROR_CAUSE[-OB_TRANSFER_TASK_COMPLETED] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANSFER_TASK_COMPLETED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANSFER_TASK_COMPLETED] = -1; SQLSTATE[-OB_TRANSFER_TASK_COMPLETED] = "HY000"; STR_ERROR[-OB_TRANSFER_TASK_COMPLETED] = "transfer task completed"; @@ -12651,6 +15295,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANSFER_TASK_COMPLETED] = "ORA-00600: internal error code, arguments: -7100, transfer task completed"; ERROR_NAME[-OB_TOO_MANY_TRANSFER_TASK] = "OB_TOO_MANY_TRANSFER_TASK"; + ERROR_CAUSE[-OB_TOO_MANY_TRANSFER_TASK] = "Internal Error"; + ERROR_SOLUTION[-OB_TOO_MANY_TRANSFER_TASK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TOO_MANY_TRANSFER_TASK] = -1; SQLSTATE[-OB_TOO_MANY_TRANSFER_TASK] = "HY000"; STR_ERROR[-OB_TOO_MANY_TRANSFER_TASK] = "too many transfer tasks"; @@ -12661,6 +15307,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TOO_MANY_TRANSFER_TASK] = "ORA-00600: internal error code, arguments: -7101, too many transfer tasks"; ERROR_NAME[-OB_TRANSFER_TASK_EXIST] = "OB_TRANSFER_TASK_EXIST"; + ERROR_CAUSE[-OB_TRANSFER_TASK_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANSFER_TASK_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANSFER_TASK_EXIST] = -1; SQLSTATE[-OB_TRANSFER_TASK_EXIST] = "HY000"; STR_ERROR[-OB_TRANSFER_TASK_EXIST] = "transfer task exist"; @@ -12670,6 +15318,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANSFER_TASK_EXIST] = "ORA-00600: internal error code, arguments: -7102, transfer task exist"; ERROR_NAME[-OB_TRANSFER_TASK_NOT_EXIST] = "OB_TRANSFER_TASK_NOT_EXIST"; + ERROR_CAUSE[-OB_TRANSFER_TASK_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANSFER_TASK_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANSFER_TASK_NOT_EXIST] = -1; SQLSTATE[-OB_TRANSFER_TASK_NOT_EXIST] = "HY000"; STR_ERROR[-OB_TRANSFER_TASK_NOT_EXIST] = "transfer task not exist"; @@ -12680,6 +15330,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANSFER_TASK_NOT_EXIST] = "ORA-00600: internal error code, arguments: -7103, transfer task not exist"; ERROR_NAME[-OB_NOT_ALLOW_TO_REMOVE] = "OB_NOT_ALLOW_TO_REMOVE"; + ERROR_CAUSE[-OB_NOT_ALLOW_TO_REMOVE] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_ALLOW_TO_REMOVE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_ALLOW_TO_REMOVE] = -1; SQLSTATE[-OB_NOT_ALLOW_TO_REMOVE] = "HY000"; STR_ERROR[-OB_NOT_ALLOW_TO_REMOVE] = "not allow to remove"; @@ -12689,6 +15341,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NOT_ALLOW_TO_REMOVE] = "ORA-00600: internal error code, arguments: -7104, not allow to remove"; ERROR_NAME[-OB_RG_NOT_MATCH] = "OB_RG_NOT_MATCH"; + ERROR_CAUSE[-OB_RG_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_RG_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RG_NOT_MATCH] = -1; SQLSTATE[-OB_RG_NOT_MATCH] = "HY000"; STR_ERROR[-OB_RG_NOT_MATCH] = "replication group not match"; @@ -12699,6 +15353,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RG_NOT_MATCH] = "ORA-00600: internal error code, arguments: -7105, replication group not match"; ERROR_NAME[-OB_TRANSFER_TASK_ABORTED] = "OB_TRANSFER_TASK_ABORTED"; + ERROR_CAUSE[-OB_TRANSFER_TASK_ABORTED] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANSFER_TASK_ABORTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANSFER_TASK_ABORTED] = -1; SQLSTATE[-OB_TRANSFER_TASK_ABORTED] = "HY000"; STR_ERROR[-OB_TRANSFER_TASK_ABORTED] = "transfer task aborted"; @@ -12709,6 +15365,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANSFER_TASK_ABORTED] = "ORA-00600: internal error code, arguments: -7106, transfer task aborted"; ERROR_NAME[-OB_TRANSFER_INVALID_MESSAGE] = "OB_TRANSFER_INVALID_MESSAGE"; + ERROR_CAUSE[-OB_TRANSFER_INVALID_MESSAGE] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANSFER_INVALID_MESSAGE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANSFER_INVALID_MESSAGE] = -1; SQLSTATE[-OB_TRANSFER_INVALID_MESSAGE] = "HY000"; STR_ERROR[-OB_TRANSFER_INVALID_MESSAGE] = "transfer invalid message"; @@ -12719,6 +15377,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANSFER_INVALID_MESSAGE] = "ORA-00600: internal error code, arguments: -7107, transfer invalid message"; ERROR_NAME[-OB_TRANSFER_CTX_TS_NOT_MATCH] = "OB_TRANSFER_CTX_TS_NOT_MATCH"; + ERROR_CAUSE[-OB_TRANSFER_CTX_TS_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_TRANSFER_CTX_TS_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_TRANSFER_CTX_TS_NOT_MATCH] = -1; SQLSTATE[-OB_TRANSFER_CTX_TS_NOT_MATCH] = "HY000"; STR_ERROR[-OB_TRANSFER_CTX_TS_NOT_MATCH] = "transfer ctx_ts not match"; @@ -12729,6 +15389,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_TRANSFER_CTX_TS_NOT_MATCH] = "ORA-00600: internal error code, arguments: -7108, transfer ctx_ts not match"; ERROR_NAME[-OB_SERVER_IS_INIT] = "OB_SERVER_IS_INIT"; + ERROR_CAUSE[-OB_SERVER_IS_INIT] = "Internal Error"; + ERROR_SOLUTION[-OB_SERVER_IS_INIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SERVER_IS_INIT] = -1; SQLSTATE[-OB_SERVER_IS_INIT] = "08004"; STR_ERROR[-OB_SERVER_IS_INIT] = "Server is initializing"; @@ -12738,6 +15400,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SERVER_IS_INIT] = "ORA-00600: internal error code, arguments: -8001, Server is initializing"; ERROR_NAME[-OB_SERVER_IS_STOPPING] = "OB_SERVER_IS_STOPPING"; + ERROR_CAUSE[-OB_SERVER_IS_STOPPING] = "Internal Error"; + ERROR_SOLUTION[-OB_SERVER_IS_STOPPING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SERVER_IS_STOPPING] = -1; SQLSTATE[-OB_SERVER_IS_STOPPING] = "08004"; STR_ERROR[-OB_SERVER_IS_STOPPING] = "Server is stopping"; @@ -12747,6 +15411,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SERVER_IS_STOPPING] = "ORA-00600: internal error code, arguments: -8002, Server is stopping"; ERROR_NAME[-OB_PACKET_CHECKSUM_ERROR] = "OB_PACKET_CHECKSUM_ERROR"; + ERROR_CAUSE[-OB_PACKET_CHECKSUM_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_PACKET_CHECKSUM_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PACKET_CHECKSUM_ERROR] = -1; SQLSTATE[-OB_PACKET_CHECKSUM_ERROR] = "08004"; STR_ERROR[-OB_PACKET_CHECKSUM_ERROR] = "Packet checksum error"; @@ -12757,6 +15423,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PACKET_CHECKSUM_ERROR] = "ORA-00600: internal error code, arguments: -8003, Packet checksum error"; ERROR_NAME[-OB_PACKET_CLUSTER_ID_NOT_MATCH] = "OB_PACKET_CLUSTER_ID_NOT_MATCH"; + ERROR_CAUSE[-OB_PACKET_CLUSTER_ID_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_PACKET_CLUSTER_ID_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PACKET_CLUSTER_ID_NOT_MATCH] = -1; SQLSTATE[-OB_PACKET_CLUSTER_ID_NOT_MATCH] = "08004"; STR_ERROR[-OB_PACKET_CLUSTER_ID_NOT_MATCH] = "Packet cluster_id not match"; @@ -12767,6 +15435,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PACKET_CLUSTER_ID_NOT_MATCH] = "ORA-00600: internal error code, arguments: -8004, Packet cluster_id not match"; ERROR_NAME[-OB_URI_ERROR] = "OB_URI_ERROR"; + ERROR_CAUSE[-OB_URI_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_URI_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_URI_ERROR] = -1; SQLSTATE[-OB_URI_ERROR] = "HY000"; STR_ERROR[-OB_URI_ERROR] = "URI error"; @@ -12775,6 +15445,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_URI_ERROR] = "ORA-00600: internal error code, arguments: -9001, URI error"; ORACLE_STR_USER_ERROR[-OB_URI_ERROR] = "ORA-00600: internal error code, arguments: -9001, URI error"; ERROR_NAME[-OB_FINAL_MD5_ERROR] = "OB_FINAL_MD5_ERROR"; + ERROR_CAUSE[-OB_FINAL_MD5_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_FINAL_MD5_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_FINAL_MD5_ERROR] = -1; SQLSTATE[-OB_FINAL_MD5_ERROR] = "HY000"; STR_ERROR[-OB_FINAL_MD5_ERROR] = "OSS file MD5 error"; @@ -12783,6 +15455,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_FINAL_MD5_ERROR] = "ORA-00600: internal error code, arguments: -9002, OSS file MD5 error"; ORACLE_STR_USER_ERROR[-OB_FINAL_MD5_ERROR] = "ORA-00600: internal error code, arguments: -9002, OSS file MD5 error"; ERROR_NAME[-OB_OSS_ERROR] = "OB_OSS_ERROR"; + ERROR_CAUSE[-OB_OSS_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_OSS_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OSS_ERROR] = -1; SQLSTATE[-OB_OSS_ERROR] = "HY000"; STR_ERROR[-OB_OSS_ERROR] = "OSS error"; @@ -12791,6 +15465,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_OSS_ERROR] = "ORA-00600: internal error code, arguments: -9003, OSS error"; ORACLE_STR_USER_ERROR[-OB_OSS_ERROR] = "ORA-00600: internal error code, arguments: -9003, OSS error"; ERROR_NAME[-OB_INIT_MD5_ERROR] = "OB_INIT_MD5_ERROR"; + ERROR_CAUSE[-OB_INIT_MD5_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_INIT_MD5_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INIT_MD5_ERROR] = -1; SQLSTATE[-OB_INIT_MD5_ERROR] = "HY000"; STR_ERROR[-OB_INIT_MD5_ERROR] = "Init MD5 fail"; @@ -12799,6 +15475,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_INIT_MD5_ERROR] = "ORA-00600: internal error code, arguments: -9004, Init MD5 fail"; ORACLE_STR_USER_ERROR[-OB_INIT_MD5_ERROR] = "ORA-00600: internal error code, arguments: -9004, Init MD5 fail"; ERROR_NAME[-OB_OUT_OF_ELEMENT] = "OB_OUT_OF_ELEMENT"; + ERROR_CAUSE[-OB_OUT_OF_ELEMENT] = "Internal Error"; + ERROR_SOLUTION[-OB_OUT_OF_ELEMENT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OUT_OF_ELEMENT] = -1; SQLSTATE[-OB_OUT_OF_ELEMENT] = "HY000"; STR_ERROR[-OB_OUT_OF_ELEMENT] = "Out of element"; @@ -12807,6 +15485,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_OUT_OF_ELEMENT] = "ORA-00600: internal error code, arguments: -9005, Out of element"; ORACLE_STR_USER_ERROR[-OB_OUT_OF_ELEMENT] = "ORA-00600: internal error code, arguments: -9005, Out of element"; ERROR_NAME[-OB_UPDATE_MD5_ERROR] = "OB_UPDATE_MD5_ERROR"; + ERROR_CAUSE[-OB_UPDATE_MD5_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_UPDATE_MD5_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_UPDATE_MD5_ERROR] = -1; SQLSTATE[-OB_UPDATE_MD5_ERROR] = "HY000"; STR_ERROR[-OB_UPDATE_MD5_ERROR] = "Update MD5 fail"; @@ -12815,6 +15495,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_UPDATE_MD5_ERROR] = "ORA-00600: internal error code, arguments: -9006, Update MD5 fail"; ORACLE_STR_USER_ERROR[-OB_UPDATE_MD5_ERROR] = "ORA-00600: internal error code, arguments: -9006, Update MD5 fail"; ERROR_NAME[-OB_FILE_LENGTH_INVALID] = "OB_FILE_LENGTH_INVALID"; + ERROR_CAUSE[-OB_FILE_LENGTH_INVALID] = "Internal Error"; + ERROR_SOLUTION[-OB_FILE_LENGTH_INVALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_FILE_LENGTH_INVALID] = -1; SQLSTATE[-OB_FILE_LENGTH_INVALID] = "HY000"; STR_ERROR[-OB_FILE_LENGTH_INVALID] = "Invalid OSS file length"; @@ -12825,6 +15507,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_FILE_LENGTH_INVALID] = "ORA-00600: internal error code, arguments: -9007, Invalid OSS file length"; ERROR_NAME[-OB_NOT_READ_ALL_DATA] = "OB_NOT_READ_ALL_DATA"; + ERROR_CAUSE[-OB_NOT_READ_ALL_DATA] = "Internal Error"; + ERROR_SOLUTION[-OB_NOT_READ_ALL_DATA] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NOT_READ_ALL_DATA] = -1; SQLSTATE[-OB_NOT_READ_ALL_DATA] = "HY000"; STR_ERROR[-OB_NOT_READ_ALL_DATA] = "Read all data fail"; @@ -12834,6 +15518,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NOT_READ_ALL_DATA] = "ORA-00600: internal error code, arguments: -9008, Read all data fail"; ERROR_NAME[-OB_BUILD_MD5_ERROR] = "OB_BUILD_MD5_ERROR"; + ERROR_CAUSE[-OB_BUILD_MD5_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_BUILD_MD5_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BUILD_MD5_ERROR] = -1; SQLSTATE[-OB_BUILD_MD5_ERROR] = "HY000"; STR_ERROR[-OB_BUILD_MD5_ERROR] = "Build MD5 fail"; @@ -12842,6 +15528,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_BUILD_MD5_ERROR] = "ORA-00600: internal error code, arguments: -9009, Build MD5 fail"; ORACLE_STR_USER_ERROR[-OB_BUILD_MD5_ERROR] = "ORA-00600: internal error code, arguments: -9009, Build MD5 fail"; ERROR_NAME[-OB_MD5_NOT_MATCH] = "OB_MD5_NOT_MATCH"; + ERROR_CAUSE[-OB_MD5_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_MD5_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_MD5_NOT_MATCH] = -1; SQLSTATE[-OB_MD5_NOT_MATCH] = "HY000"; STR_ERROR[-OB_MD5_NOT_MATCH] = "OSS file MD5 not match"; @@ -12851,6 +15539,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_MD5_NOT_MATCH] = "ORA-00600: internal error code, arguments: -9010, OSS file MD5 not match"; ERROR_NAME[-OB_BACKUP_FILE_NOT_EXIST] = "OB_BACKUP_FILE_NOT_EXIST"; + ERROR_CAUSE[-OB_BACKUP_FILE_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_BACKUP_FILE_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BACKUP_FILE_NOT_EXIST] = -1; SQLSTATE[-OB_BACKUP_FILE_NOT_EXIST] = "HY000"; STR_ERROR[-OB_BACKUP_FILE_NOT_EXIST] = "cannot find backup file"; @@ -12861,6 +15551,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_BACKUP_FILE_NOT_EXIST] = "ORA-00600: internal error code, arguments: -9011, cannot find backup file"; ERROR_NAME[-OB_OSS_DATA_VERSION_NOT_MATCHED] = "OB_OSS_DATA_VERSION_NOT_MATCHED"; + ERROR_CAUSE[-OB_OSS_DATA_VERSION_NOT_MATCHED] = "Internal Error"; + ERROR_SOLUTION[-OB_OSS_DATA_VERSION_NOT_MATCHED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OSS_DATA_VERSION_NOT_MATCHED] = -1; SQLSTATE[-OB_OSS_DATA_VERSION_NOT_MATCHED] = "HY000"; STR_ERROR[-OB_OSS_DATA_VERSION_NOT_MATCHED] = "Can not get data version from timestamp"; @@ -12871,6 +15563,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_OSS_DATA_VERSION_NOT_MATCHED] = "ORA-00600: internal error code, arguments: -9012, Can not get data version from timestamp"; ERROR_NAME[-OB_OSS_WRITE_ERROR] = "OB_OSS_WRITE_ERROR"; + ERROR_CAUSE[-OB_OSS_WRITE_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_OSS_WRITE_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_OSS_WRITE_ERROR] = -1; SQLSTATE[-OB_OSS_WRITE_ERROR] = "HY000"; STR_ERROR[-OB_OSS_WRITE_ERROR] = "Write OSS file error"; @@ -12880,6 +15574,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_OSS_WRITE_ERROR] = "ORA-00600: internal error code, arguments: -9013, Write OSS file error"; ERROR_NAME[-OB_RESTORE_IN_PROGRESS] = "OB_RESTORE_IN_PROGRESS"; + ERROR_CAUSE[-OB_RESTORE_IN_PROGRESS] = "Internal Error"; + ERROR_SOLUTION[-OB_RESTORE_IN_PROGRESS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RESTORE_IN_PROGRESS] = -1; SQLSTATE[-OB_RESTORE_IN_PROGRESS] = "HY000"; STR_ERROR[-OB_RESTORE_IN_PROGRESS] = "Another restore is in progress"; @@ -12890,6 +15586,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RESTORE_IN_PROGRESS] = "ORA-00600: internal error code, arguments: -9014, Another restore is in progress"; ERROR_NAME[-OB_AGENT_INITING_BACKUP_COUNT_ERROR] = "OB_AGENT_INITING_BACKUP_COUNT_ERROR"; + ERROR_CAUSE[-OB_AGENT_INITING_BACKUP_COUNT_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_AGENT_INITING_BACKUP_COUNT_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_AGENT_INITING_BACKUP_COUNT_ERROR] = -1; SQLSTATE[-OB_AGENT_INITING_BACKUP_COUNT_ERROR] = "HY000"; STR_ERROR[-OB_AGENT_INITING_BACKUP_COUNT_ERROR] = "agent initing backup count error"; @@ -12900,6 +15598,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_AGENT_INITING_BACKUP_COUNT_ERROR] = "ORA-00600: internal error code, arguments: -9015, agent initing backup count error"; ERROR_NAME[-OB_CLUSTER_NAME_NOT_EQUAL] = "OB_CLUSTER_NAME_NOT_EQUAL"; + ERROR_CAUSE[-OB_CLUSTER_NAME_NOT_EQUAL] = "Internal Error"; + ERROR_SOLUTION[-OB_CLUSTER_NAME_NOT_EQUAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CLUSTER_NAME_NOT_EQUAL] = -1; SQLSTATE[-OB_CLUSTER_NAME_NOT_EQUAL] = "HY000"; STR_ERROR[-OB_CLUSTER_NAME_NOT_EQUAL] = "ob cluster name not equal"; @@ -12910,6 +15610,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CLUSTER_NAME_NOT_EQUAL] = "ORA-00600: internal error code, arguments: -9016, ob cluster name not equal"; ERROR_NAME[-OB_RS_LIST_INVAILD] = "OB_RS_LIST_INVAILD"; + ERROR_CAUSE[-OB_RS_LIST_INVAILD] = "Internal Error"; + ERROR_SOLUTION[-OB_RS_LIST_INVAILD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RS_LIST_INVAILD] = -1; SQLSTATE[-OB_RS_LIST_INVAILD] = "HY000"; STR_ERROR[-OB_RS_LIST_INVAILD] = "rs list invalid"; @@ -12918,6 +15620,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_RS_LIST_INVAILD] = "ORA-00600: internal error code, arguments: -9017, rs list invalid"; ORACLE_STR_USER_ERROR[-OB_RS_LIST_INVAILD] = "ORA-00600: internal error code, arguments: -9017, rs list invalid"; ERROR_NAME[-OB_AGENT_HAS_FAILED_TASK] = "OB_AGENT_HAS_FAILED_TASK"; + ERROR_CAUSE[-OB_AGENT_HAS_FAILED_TASK] = "Internal Error"; + ERROR_SOLUTION[-OB_AGENT_HAS_FAILED_TASK] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_AGENT_HAS_FAILED_TASK] = -1; SQLSTATE[-OB_AGENT_HAS_FAILED_TASK] = "HY000"; STR_ERROR[-OB_AGENT_HAS_FAILED_TASK] = "agent has failed task"; @@ -12928,6 +15632,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_AGENT_HAS_FAILED_TASK] = "ORA-00600: internal error code, arguments: -9018, agent has failed task"; ERROR_NAME[-OB_RESTORE_PARTITION_IS_COMPELETE] = "OB_RESTORE_PARTITION_IS_COMPELETE"; + ERROR_CAUSE[-OB_RESTORE_PARTITION_IS_COMPELETE] = "Internal Error"; + ERROR_SOLUTION[-OB_RESTORE_PARTITION_IS_COMPELETE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RESTORE_PARTITION_IS_COMPELETE] = -1; SQLSTATE[-OB_RESTORE_PARTITION_IS_COMPELETE] = "HY000"; STR_ERROR[-OB_RESTORE_PARTITION_IS_COMPELETE] = "restore partition is compelete"; @@ -12938,6 +15644,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RESTORE_PARTITION_IS_COMPELETE] = "ORA-00600: internal error code, arguments: -9019, restore partition is compelete"; ERROR_NAME[-OB_RESTORE_PARTITION_TWICE] = "OB_RESTORE_PARTITION_TWICE"; + ERROR_CAUSE[-OB_RESTORE_PARTITION_TWICE] = "Internal Error"; + ERROR_SOLUTION[-OB_RESTORE_PARTITION_TWICE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RESTORE_PARTITION_TWICE] = -1; SQLSTATE[-OB_RESTORE_PARTITION_TWICE] = "HY000"; STR_ERROR[-OB_RESTORE_PARTITION_TWICE] = "restore partition twice"; @@ -12948,6 +15656,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RESTORE_PARTITION_TWICE] = "ORA-00600: internal error code, arguments: -9020, restore partition twice"; ERROR_NAME[-OB_STOP_DROP_SCHEMA] = "OB_STOP_DROP_SCHEMA"; + ERROR_CAUSE[-OB_STOP_DROP_SCHEMA] = "Internal Error"; + ERROR_SOLUTION[-OB_STOP_DROP_SCHEMA] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_STOP_DROP_SCHEMA] = -1; SQLSTATE[-OB_STOP_DROP_SCHEMA] = "HY000"; STR_ERROR[-OB_STOP_DROP_SCHEMA] = "physical backup switch is on"; @@ -12958,6 +15668,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_STOP_DROP_SCHEMA] = "ORA-00600: internal error code, arguments: -9022, physical backup switch is on"; ERROR_NAME[-OB_CANNOT_START_LOG_ARCHIVE_BACKUP] = "OB_CANNOT_START_LOG_ARCHIVE_BACKUP"; + ERROR_CAUSE[-OB_CANNOT_START_LOG_ARCHIVE_BACKUP] = "Internal Error"; + ERROR_SOLUTION[-OB_CANNOT_START_LOG_ARCHIVE_BACKUP] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANNOT_START_LOG_ARCHIVE_BACKUP] = -1; SQLSTATE[-OB_CANNOT_START_LOG_ARCHIVE_BACKUP] = "HY000"; STR_ERROR[-OB_CANNOT_START_LOG_ARCHIVE_BACKUP] = "cannot start log archive backup"; @@ -12968,6 +15680,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CANNOT_START_LOG_ARCHIVE_BACKUP] = "ORA-00600: internal error code, arguments: -9023, cannot start log archive backup"; ERROR_NAME[-OB_ALREADY_NO_LOG_ARCHIVE_BACKUP] = "OB_ALREADY_NO_LOG_ARCHIVE_BACKUP"; + ERROR_CAUSE[-OB_ALREADY_NO_LOG_ARCHIVE_BACKUP] = "Internal Error"; + ERROR_SOLUTION[-OB_ALREADY_NO_LOG_ARCHIVE_BACKUP] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ALREADY_NO_LOG_ARCHIVE_BACKUP] = -1; SQLSTATE[-OB_ALREADY_NO_LOG_ARCHIVE_BACKUP] = "HY000"; STR_ERROR[-OB_ALREADY_NO_LOG_ARCHIVE_BACKUP] = "log archive backup is already disabled"; @@ -12978,6 +15692,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ALREADY_NO_LOG_ARCHIVE_BACKUP] = "ORA-00600: internal error code, arguments: -9024, log archive backup is already disabled"; ERROR_NAME[-OB_LOG_ARCHIVE_BACKUP_INFO_NOT_EXIST] = "OB_LOG_ARCHIVE_BACKUP_INFO_NOT_EXIST"; + ERROR_CAUSE[-OB_LOG_ARCHIVE_BACKUP_INFO_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_ARCHIVE_BACKUP_INFO_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_ARCHIVE_BACKUP_INFO_NOT_EXIST] = -1; SQLSTATE[-OB_LOG_ARCHIVE_BACKUP_INFO_NOT_EXIST] = "HY000"; STR_ERROR[-OB_LOG_ARCHIVE_BACKUP_INFO_NOT_EXIST] = "log archive backup info not exists"; @@ -12988,6 +15704,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LOG_ARCHIVE_BACKUP_INFO_NOT_EXIST] = "ORA-00600: internal error code, arguments: -9025, log archive backup info not exists"; ERROR_NAME[-OB_INVALID_BACKUP_DEST] = "OB_INVALID_BACKUP_DEST"; + ERROR_CAUSE[-OB_INVALID_BACKUP_DEST] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_BACKUP_DEST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_BACKUP_DEST] = -1; SQLSTATE[-OB_INVALID_BACKUP_DEST] = "HY000"; STR_ERROR[-OB_INVALID_BACKUP_DEST] = "backup destination is not valid"; @@ -12998,6 +15716,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_BACKUP_DEST] = "ORA-00600: internal error code, arguments: -9026, backup destination is not valid"; ERROR_NAME[-OB_LOG_ARCHIVE_INTERRUPTED] = "OB_LOG_ARCHIVE_INTERRUPTED"; + ERROR_CAUSE[-OB_LOG_ARCHIVE_INTERRUPTED] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_ARCHIVE_INTERRUPTED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_ARCHIVE_INTERRUPTED] = -1; SQLSTATE[-OB_LOG_ARCHIVE_INTERRUPTED] = "HY000"; STR_ERROR[-OB_LOG_ARCHIVE_INTERRUPTED] = "ob log archive interrupted"; @@ -13008,6 +15728,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LOG_ARCHIVE_INTERRUPTED] = "ORA-00600: internal error code, arguments: -9027, ob log archive interrupted"; ERROR_NAME[-OB_LOG_ARCHIVE_STAT_NOT_MATCH] = "OB_LOG_ARCHIVE_STAT_NOT_MATCH"; + ERROR_CAUSE[-OB_LOG_ARCHIVE_STAT_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_ARCHIVE_STAT_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_ARCHIVE_STAT_NOT_MATCH] = -1; SQLSTATE[-OB_LOG_ARCHIVE_STAT_NOT_MATCH] = "HY000"; STR_ERROR[-OB_LOG_ARCHIVE_STAT_NOT_MATCH] = "ob log archive stat not match"; @@ -13018,6 +15740,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LOG_ARCHIVE_STAT_NOT_MATCH] = "ORA-00600: internal error code, arguments: -9028, ob log archive stat not match"; ERROR_NAME[-OB_LOG_ARCHIVE_NOT_RUNNING] = "OB_LOG_ARCHIVE_NOT_RUNNING"; + ERROR_CAUSE[-OB_LOG_ARCHIVE_NOT_RUNNING] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_ARCHIVE_NOT_RUNNING] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_ARCHIVE_NOT_RUNNING] = -1; SQLSTATE[-OB_LOG_ARCHIVE_NOT_RUNNING] = "HY000"; STR_ERROR[-OB_LOG_ARCHIVE_NOT_RUNNING] = "log archive is not running"; @@ -13028,6 +15752,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LOG_ARCHIVE_NOT_RUNNING] = "ORA-00600: internal error code, arguments: -9029, log archive is not running"; ERROR_NAME[-OB_LOG_ARCHIVE_INVALID_ROUND] = "OB_LOG_ARCHIVE_INVALID_ROUND"; + ERROR_CAUSE[-OB_LOG_ARCHIVE_INVALID_ROUND] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_ARCHIVE_INVALID_ROUND] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_ARCHIVE_INVALID_ROUND] = -1; SQLSTATE[-OB_LOG_ARCHIVE_INVALID_ROUND] = "HY000"; STR_ERROR[-OB_LOG_ARCHIVE_INVALID_ROUND] = "log archive invalid round"; @@ -13038,6 +15764,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LOG_ARCHIVE_INVALID_ROUND] = "ORA-00600: internal error code, arguments: -9030, log archive invalid round"; ERROR_NAME[-OB_REPLICA_CANNOT_BACKUP] = "OB_REPLICA_CANNOT_BACKUP"; + ERROR_CAUSE[-OB_REPLICA_CANNOT_BACKUP] = "Internal Error"; + ERROR_SOLUTION[-OB_REPLICA_CANNOT_BACKUP] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_REPLICA_CANNOT_BACKUP] = -1; SQLSTATE[-OB_REPLICA_CANNOT_BACKUP] = "HY000"; STR_ERROR[-OB_REPLICA_CANNOT_BACKUP] = "Cannot backup ob replica"; @@ -13048,6 +15776,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_REPLICA_CANNOT_BACKUP] = "ORA-00600: internal error code, arguments: -9031, Cannot backup ob replica"; ERROR_NAME[-OB_BACKUP_INFO_NOT_EXIST] = "OB_BACKUP_INFO_NOT_EXIST"; + ERROR_CAUSE[-OB_BACKUP_INFO_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_BACKUP_INFO_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BACKUP_INFO_NOT_EXIST] = -1; SQLSTATE[-OB_BACKUP_INFO_NOT_EXIST] = "HY000"; STR_ERROR[-OB_BACKUP_INFO_NOT_EXIST] = "backup info not exists"; @@ -13058,6 +15788,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_BACKUP_INFO_NOT_EXIST] = "ORA-00600: internal error code, arguments: -9032, backup info not exists"; ERROR_NAME[-OB_BACKUP_INFO_NOT_MATCH] = "OB_BACKUP_INFO_NOT_MATCH"; + ERROR_CAUSE[-OB_BACKUP_INFO_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_BACKUP_INFO_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BACKUP_INFO_NOT_MATCH] = -1; SQLSTATE[-OB_BACKUP_INFO_NOT_MATCH] = "HY000"; STR_ERROR[-OB_BACKUP_INFO_NOT_MATCH] = @@ -13072,6 +15804,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -9033, Backup meta info stored in system dictionary does not match " "with current system status"; ERROR_NAME[-OB_LOG_ARCHIVE_ALREADY_STOPPED] = "OB_LOG_ARCHIVE_ALREADY_STOPPED"; + ERROR_CAUSE[-OB_LOG_ARCHIVE_ALREADY_STOPPED] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_ARCHIVE_ALREADY_STOPPED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_ARCHIVE_ALREADY_STOPPED] = -1; SQLSTATE[-OB_LOG_ARCHIVE_ALREADY_STOPPED] = "HY000"; STR_ERROR[-OB_LOG_ARCHIVE_ALREADY_STOPPED] = "log archive already stopped"; @@ -13082,6 +15816,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LOG_ARCHIVE_ALREADY_STOPPED] = "ORA-00600: internal error code, arguments: -9034, log archive already stopped"; ERROR_NAME[-OB_RESTORE_INDEX_FAILED] = "OB_RESTORE_INDEX_FAILED"; + ERROR_CAUSE[-OB_RESTORE_INDEX_FAILED] = "Internal Error"; + ERROR_SOLUTION[-OB_RESTORE_INDEX_FAILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_RESTORE_INDEX_FAILED] = -1; SQLSTATE[-OB_RESTORE_INDEX_FAILED] = "HY000"; STR_ERROR[-OB_RESTORE_INDEX_FAILED] = "restore index failed"; @@ -13092,6 +15828,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_RESTORE_INDEX_FAILED] = "ORA-00600: internal error code, arguments: -9035, restore index failed"; ERROR_NAME[-OB_BACKUP_IN_PROGRESS] = "OB_BACKUP_IN_PROGRESS"; + ERROR_CAUSE[-OB_BACKUP_IN_PROGRESS] = "Internal Error"; + ERROR_SOLUTION[-OB_BACKUP_IN_PROGRESS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BACKUP_IN_PROGRESS] = -1; SQLSTATE[-OB_BACKUP_IN_PROGRESS] = "HY000"; STR_ERROR[-OB_BACKUP_IN_PROGRESS] = "Backup is in progress"; @@ -13102,6 +15840,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_BACKUP_IN_PROGRESS] = "ORA-00600: internal error code, arguments: -9036, Backup is in progress"; ERROR_NAME[-OB_INVALID_LOG_ARCHIVE_STATUS] = "OB_INVALID_LOG_ARCHIVE_STATUS"; + ERROR_CAUSE[-OB_INVALID_LOG_ARCHIVE_STATUS] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_LOG_ARCHIVE_STATUS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_LOG_ARCHIVE_STATUS] = -1; SQLSTATE[-OB_INVALID_LOG_ARCHIVE_STATUS] = "HY000"; STR_ERROR[-OB_INVALID_LOG_ARCHIVE_STATUS] = "log archive status is not valid"; @@ -13112,6 +15852,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_LOG_ARCHIVE_STATUS] = "ORA-00600: internal error code, arguments: -9037, log archive status is not valid"; ERROR_NAME[-OB_CANNOT_ADD_REPLICA_DURING_SET_MEMBER_LIST] = "OB_CANNOT_ADD_REPLICA_DURING_SET_MEMBER_LIST"; + ERROR_CAUSE[-OB_CANNOT_ADD_REPLICA_DURING_SET_MEMBER_LIST] = "Internal Error"; + ERROR_SOLUTION[-OB_CANNOT_ADD_REPLICA_DURING_SET_MEMBER_LIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANNOT_ADD_REPLICA_DURING_SET_MEMBER_LIST] = -1; SQLSTATE[-OB_CANNOT_ADD_REPLICA_DURING_SET_MEMBER_LIST] = "HY000"; STR_ERROR[-OB_CANNOT_ADD_REPLICA_DURING_SET_MEMBER_LIST] = "Cannot add replica during set member list in restore"; @@ -13123,6 +15865,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CANNOT_ADD_REPLICA_DURING_SET_MEMBER_LIST] = "ORA-00600: internal error code, arguments: -9038, Cannot add replica during set member list in restore"; ERROR_NAME[-OB_LOG_ARCHIVE_LEADER_CHANGED] = "OB_LOG_ARCHIVE_LEADER_CHANGED"; + ERROR_CAUSE[-OB_LOG_ARCHIVE_LEADER_CHANGED] = "Internal Error"; + ERROR_SOLUTION[-OB_LOG_ARCHIVE_LEADER_CHANGED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_LOG_ARCHIVE_LEADER_CHANGED] = -1; SQLSTATE[-OB_LOG_ARCHIVE_LEADER_CHANGED] = "HY000"; STR_ERROR[-OB_LOG_ARCHIVE_LEADER_CHANGED] = "pg log archive leader changed"; @@ -13133,6 +15877,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_LOG_ARCHIVE_LEADER_CHANGED] = "ORA-00600: internal error code, arguments: -9039, pg log archive leader changed"; ERROR_NAME[-OB_BACKUP_CAN_NOT_START] = "OB_BACKUP_CAN_NOT_START"; + ERROR_CAUSE[-OB_BACKUP_CAN_NOT_START] = "Internal Error"; + ERROR_SOLUTION[-OB_BACKUP_CAN_NOT_START] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BACKUP_CAN_NOT_START] = -1; SQLSTATE[-OB_BACKUP_CAN_NOT_START] = "HY000"; STR_ERROR[-OB_BACKUP_CAN_NOT_START] = "backup can not start"; @@ -13143,6 +15889,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_BACKUP_CAN_NOT_START] = "ORA-00600: internal error code, arguments: -9040, backup can not start, because %s"; ERROR_NAME[-OB_CANCEL_BACKUP_NOT_ALLOWED] = "OB_CANCEL_BACKUP_NOT_ALLOWED"; + ERROR_CAUSE[-OB_CANCEL_BACKUP_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_CANCEL_BACKUP_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANCEL_BACKUP_NOT_ALLOWED] = -1; SQLSTATE[-OB_CANCEL_BACKUP_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_CANCEL_BACKUP_NOT_ALLOWED] = "cancel backup do not allow"; @@ -13153,6 +15901,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CANCEL_BACKUP_NOT_ALLOWED] = "ORA-00600: internal error code, arguments: -9041, cancel backup do not allow"; ERROR_NAME[-OB_BACKUP_DATA_VERSION_GAP_OVER_LIMIT] = "OB_BACKUP_DATA_VERSION_GAP_OVER_LIMIT"; + ERROR_CAUSE[-OB_BACKUP_DATA_VERSION_GAP_OVER_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_BACKUP_DATA_VERSION_GAP_OVER_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BACKUP_DATA_VERSION_GAP_OVER_LIMIT] = -1; SQLSTATE[-OB_BACKUP_DATA_VERSION_GAP_OVER_LIMIT] = "HY000"; STR_ERROR[-OB_BACKUP_DATA_VERSION_GAP_OVER_LIMIT] = "backup data version gap over limit"; @@ -13163,6 +15913,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_BACKUP_DATA_VERSION_GAP_OVER_LIMIT] = "ORA-00600: internal error code, arguments: -9042, backup data version gap over limit"; ERROR_NAME[-OB_PG_LOG_ARCHIVE_STATUS_NOT_INIT] = "OB_PG_LOG_ARCHIVE_STATUS_NOT_INIT"; + ERROR_CAUSE[-OB_PG_LOG_ARCHIVE_STATUS_NOT_INIT] = "Internal Error"; + ERROR_SOLUTION[-OB_PG_LOG_ARCHIVE_STATUS_NOT_INIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_PG_LOG_ARCHIVE_STATUS_NOT_INIT] = -1; SQLSTATE[-OB_PG_LOG_ARCHIVE_STATUS_NOT_INIT] = "HY000"; STR_ERROR[-OB_PG_LOG_ARCHIVE_STATUS_NOT_INIT] = "pg log archive status is still invalid"; @@ -13173,6 +15925,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_PG_LOG_ARCHIVE_STATUS_NOT_INIT] = "ORA-00600: internal error code, arguments: -9043, pg log archive status is still invalid"; ERROR_NAME[-OB_BACKUP_DELETE_DATA_IN_PROGRESS] = "OB_BACKUP_DELETE_DATA_IN_PROGRESS"; + ERROR_CAUSE[-OB_BACKUP_DELETE_DATA_IN_PROGRESS] = "Internal Error"; + ERROR_SOLUTION[-OB_BACKUP_DELETE_DATA_IN_PROGRESS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BACKUP_DELETE_DATA_IN_PROGRESS] = -1; SQLSTATE[-OB_BACKUP_DELETE_DATA_IN_PROGRESS] = "HY000"; STR_ERROR[-OB_BACKUP_DELETE_DATA_IN_PROGRESS] = "delete backup data is in progress"; @@ -13183,6 +15937,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_BACKUP_DELETE_DATA_IN_PROGRESS] = "ORA-00600: internal error code, arguments: -9044, delete backup data is in progress"; ERROR_NAME[-OB_BACKUP_DELETE_BACKUP_SET_NOT_ALLOWED] = "OB_BACKUP_DELETE_BACKUP_SET_NOT_ALLOWED"; + ERROR_CAUSE[-OB_BACKUP_DELETE_BACKUP_SET_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_BACKUP_DELETE_BACKUP_SET_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BACKUP_DELETE_BACKUP_SET_NOT_ALLOWED] = -1; SQLSTATE[-OB_BACKUP_DELETE_BACKUP_SET_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_BACKUP_DELETE_BACKUP_SET_NOT_ALLOWED] = "delete backup set do not allow"; @@ -13193,6 +15949,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_BACKUP_DELETE_BACKUP_SET_NOT_ALLOWED] = "ORA-00600: internal error code, arguments: -9045, delete backup set do not allow"; ERROR_NAME[-OB_INVALID_BACKUP_SET_ID] = "OB_INVALID_BACKUP_SET_ID"; + ERROR_CAUSE[-OB_INVALID_BACKUP_SET_ID] = "Internal Error"; + ERROR_SOLUTION[-OB_INVALID_BACKUP_SET_ID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_INVALID_BACKUP_SET_ID] = -1; SQLSTATE[-OB_INVALID_BACKUP_SET_ID] = "HY000"; STR_ERROR[-OB_INVALID_BACKUP_SET_ID] = "backup set id is not valid"; @@ -13203,6 +15961,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_INVALID_BACKUP_SET_ID] = "ORA-00600: internal error code, arguments: -9046, backup set id is not valid"; ERROR_NAME[-OB_BACKUP_INVALID_PASSWORD] = "OB_BACKUP_INVALID_PASSWORD"; + ERROR_CAUSE[-OB_BACKUP_INVALID_PASSWORD] = "Internal Error"; + ERROR_SOLUTION[-OB_BACKUP_INVALID_PASSWORD] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BACKUP_INVALID_PASSWORD] = -1; SQLSTATE[-OB_BACKUP_INVALID_PASSWORD] = "HY000"; STR_ERROR[-OB_BACKUP_INVALID_PASSWORD] = "invalid password for backup"; @@ -13213,6 +15973,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_BACKUP_INVALID_PASSWORD] = "ORA-00600: internal error code, arguments: -9047, invalid password for backup"; ERROR_NAME[-OB_ISOLATED_BACKUP_SET] = "OB_ISOLATED_BACKUP_SET"; + ERROR_CAUSE[-OB_ISOLATED_BACKUP_SET] = "Internal Error"; + ERROR_SOLUTION[-OB_ISOLATED_BACKUP_SET] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ISOLATED_BACKUP_SET] = -1; SQLSTATE[-OB_ISOLATED_BACKUP_SET] = "HY000"; STR_ERROR[-OB_ISOLATED_BACKUP_SET] = "backup set is isolated by two log archive round"; @@ -13223,6 +15985,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ISOLATED_BACKUP_SET] = "ORA-00600: internal error code, arguments: -9048, backup set is isolated by two log archive round"; ERROR_NAME[-OB_CANNOT_CANCEL_STOPPED_BACKUP] = "OB_CANNOT_CANCEL_STOPPED_BACKUP"; + ERROR_CAUSE[-OB_CANNOT_CANCEL_STOPPED_BACKUP] = "Internal Error"; + ERROR_SOLUTION[-OB_CANNOT_CANCEL_STOPPED_BACKUP] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANNOT_CANCEL_STOPPED_BACKUP] = -1; SQLSTATE[-OB_CANNOT_CANCEL_STOPPED_BACKUP] = "HY000"; STR_ERROR[-OB_CANNOT_CANCEL_STOPPED_BACKUP] = "backup status is stopped, can not cancel"; @@ -13233,6 +15997,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CANNOT_CANCEL_STOPPED_BACKUP] = "ORA-00600: internal error code, arguments: -9049, backup status is stopped, can not cancel"; ERROR_NAME[-OB_BACKUP_BACKUP_CAN_NOT_START] = "OB_BACKUP_BACKUP_CAN_NOT_START"; + ERROR_CAUSE[-OB_BACKUP_BACKUP_CAN_NOT_START] = "Internal Error"; + ERROR_SOLUTION[-OB_BACKUP_BACKUP_CAN_NOT_START] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BACKUP_BACKUP_CAN_NOT_START] = -1; SQLSTATE[-OB_BACKUP_BACKUP_CAN_NOT_START] = "HY000"; STR_ERROR[-OB_BACKUP_BACKUP_CAN_NOT_START] = "no backup data to be backuped up"; @@ -13243,6 +16009,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_BACKUP_BACKUP_CAN_NOT_START] = "ORA-00600: internal error code, arguments: -9050, no backup data to be backuped up"; ERROR_NAME[-OB_BACKUP_MOUNT_FILE_NOT_VALID] = "OB_BACKUP_MOUNT_FILE_NOT_VALID"; + ERROR_CAUSE[-OB_BACKUP_MOUNT_FILE_NOT_VALID] = "Internal Error"; + ERROR_SOLUTION[-OB_BACKUP_MOUNT_FILE_NOT_VALID] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BACKUP_MOUNT_FILE_NOT_VALID] = -1; SQLSTATE[-OB_BACKUP_MOUNT_FILE_NOT_VALID] = "HY000"; STR_ERROR[-OB_BACKUP_MOUNT_FILE_NOT_VALID] = "backup mount file is not valid"; @@ -13253,6 +16021,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_BACKUP_MOUNT_FILE_NOT_VALID] = "ORA-00600: internal error code, arguments: -9051, backup mount file is not valid"; ERROR_NAME[-OB_BACKUP_CLEAN_INFO_NOT_MATCH] = "OB_BACKUP_CLEAN_INFO_NOT_MATCH"; + ERROR_CAUSE[-OB_BACKUP_CLEAN_INFO_NOT_MATCH] = "Internal Error"; + ERROR_SOLUTION[-OB_BACKUP_CLEAN_INFO_NOT_MATCH] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BACKUP_CLEAN_INFO_NOT_MATCH] = -1; SQLSTATE[-OB_BACKUP_CLEAN_INFO_NOT_MATCH] = "HY000"; STR_ERROR[-OB_BACKUP_CLEAN_INFO_NOT_MATCH] = "backup clean info not match"; @@ -13263,6 +16033,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_BACKUP_CLEAN_INFO_NOT_MATCH] = "ORA-00600: internal error code, arguments: -9052, backup clean info not match"; ERROR_NAME[-OB_CANCEL_DELETE_BACKUP_NOT_ALLOWED] = "OB_CANCEL_DELETE_BACKUP_NOT_ALLOWED"; + ERROR_CAUSE[-OB_CANCEL_DELETE_BACKUP_NOT_ALLOWED] = "Internal Error"; + ERROR_SOLUTION[-OB_CANCEL_DELETE_BACKUP_NOT_ALLOWED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CANCEL_DELETE_BACKUP_NOT_ALLOWED] = -1; SQLSTATE[-OB_CANCEL_DELETE_BACKUP_NOT_ALLOWED] = "HY000"; STR_ERROR[-OB_CANCEL_DELETE_BACKUP_NOT_ALLOWED] = "cancel delete backup do not allow"; @@ -13273,6 +16045,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CANCEL_DELETE_BACKUP_NOT_ALLOWED] = "ORA-00600: internal error code, arguments: -9053, cancel delete backup do not allow"; ERROR_NAME[-OB_BACKUP_CLEAN_INFO_NOT_EXIST] = "OB_BACKUP_CLEAN_INFO_NOT_EXIST"; + ERROR_CAUSE[-OB_BACKUP_CLEAN_INFO_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_BACKUP_CLEAN_INFO_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_BACKUP_CLEAN_INFO_NOT_EXIST] = -1; SQLSTATE[-OB_BACKUP_CLEAN_INFO_NOT_EXIST] = "HY000"; STR_ERROR[-OB_BACKUP_CLEAN_INFO_NOT_EXIST] = "backup clean info not exists"; @@ -13282,7 +16056,36 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -9054, backup clean info not exists"; ORACLE_STR_USER_ERROR[-OB_BACKUP_CLEAN_INFO_NOT_EXIST] = "ORA-00600: internal error code, arguments: -9054, backup clean info not exists"; + ERROR_NAME[-OB_ERR_DROP_TRUNCATE_PARTITION_REBUILD_INDEX] = "OB_ERR_DROP_TRUNCATE_PARTITION_REBUILD_INDEX"; + ERROR_CAUSE[-OB_ERR_DROP_TRUNCATE_PARTITION_REBUILD_INDEX] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DROP_TRUNCATE_PARTITION_REBUILD_INDEX] = "Contact OceanBase Support"; + MYSQL_ERRNO[-OB_ERR_DROP_TRUNCATE_PARTITION_REBUILD_INDEX] = -1; + SQLSTATE[-OB_ERR_DROP_TRUNCATE_PARTITION_REBUILD_INDEX] = "HY000"; + STR_ERROR[-OB_ERR_DROP_TRUNCATE_PARTITION_REBUILD_INDEX] = + "rebuild global index failed when drop/truncate partitions"; + STR_USER_ERROR[-OB_ERR_DROP_TRUNCATE_PARTITION_REBUILD_INDEX] = + "rebuild global index:'%.*s' failed when drop/truncate partitions"; + ORACLE_ERRNO[-OB_ERR_DROP_TRUNCATE_PARTITION_REBUILD_INDEX] = 600; + ORACLE_STR_ERROR[-OB_ERR_DROP_TRUNCATE_PARTITION_REBUILD_INDEX] = + "ORA-00600: internal error code, arguments: -9055, rebuild global index failed when drop/truncate partitions"; + ORACLE_STR_USER_ERROR[-OB_ERR_DROP_TRUNCATE_PARTITION_REBUILD_INDEX] = + "ORA-00600: internal error code, arguments: -9055, rebuild global index:'%.*s' failed when drop/truncate " + "partitions"; + ERROR_NAME[-OB_ERR_ATLER_TABLE_ILLEGAL_FK] = "OB_ERR_ATLER_TABLE_ILLEGAL_FK"; + ERROR_CAUSE[-OB_ERR_ATLER_TABLE_ILLEGAL_FK] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ATLER_TABLE_ILLEGAL_FK] = "Contact OceanBase Support"; + MYSQL_ERRNO[-OB_ERR_ATLER_TABLE_ILLEGAL_FK] = -1; + SQLSTATE[-OB_ERR_ATLER_TABLE_ILLEGAL_FK] = "HY000"; + STR_ERROR[-OB_ERR_ATLER_TABLE_ILLEGAL_FK] = "unique/primary keys in table referenced by enabled foreign keys"; + STR_USER_ERROR[-OB_ERR_ATLER_TABLE_ILLEGAL_FK] = "unique/primary keys in table referenced by enabled foreign keys"; + ORACLE_ERRNO[-OB_ERR_ATLER_TABLE_ILLEGAL_FK] = 02266; + ORACLE_STR_ERROR[-OB_ERR_ATLER_TABLE_ILLEGAL_FK] = + "ORA-02266: unique/primary keys in table referenced by enabled foreign keys"; + ORACLE_STR_USER_ERROR[-OB_ERR_ATLER_TABLE_ILLEGAL_FK] = + "ORA-02266: unique/primary keys in table referenced by enabled foreign keys"; ERROR_NAME[-OB_IO_LIMIT] = "OB_IO_LIMIT"; + ERROR_CAUSE[-OB_IO_LIMIT] = "Internal Error"; + ERROR_SOLUTION[-OB_IO_LIMIT] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_IO_LIMIT] = -1; SQLSTATE[-OB_IO_LIMIT] = "HY000"; STR_ERROR[-OB_IO_LIMIT] = "IO limit"; @@ -13291,6 +16094,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_IO_LIMIT] = "ORA-00600: internal error code, arguments: -9061, IO limit"; ORACLE_STR_USER_ERROR[-OB_IO_LIMIT] = "ORA-00600: internal error code, arguments: -9061, IO limit"; ERROR_NAME[-OB_NO_SUCH_FILE_OR_DIRECTORY] = "OB_NO_SUCH_FILE_OR_DIRECTORY"; + ERROR_CAUSE[-OB_NO_SUCH_FILE_OR_DIRECTORY] = "Internal Error"; + ERROR_SOLUTION[-OB_NO_SUCH_FILE_OR_DIRECTORY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_NO_SUCH_FILE_OR_DIRECTORY] = -1; SQLSTATE[-OB_NO_SUCH_FILE_OR_DIRECTORY] = "HY000"; STR_ERROR[-OB_NO_SUCH_FILE_OR_DIRECTORY] = "no such file or directory"; @@ -13301,6 +16106,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_NO_SUCH_FILE_OR_DIRECTORY] = "ORA-00600: internal error code, arguments: -9100, no such file or directory"; ERROR_NAME[-OB_FILE_OR_DIRECTORY_EXIST] = "OB_FILE_OR_DIRECTORY_EXIST"; + ERROR_CAUSE[-OB_FILE_OR_DIRECTORY_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_FILE_OR_DIRECTORY_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_FILE_OR_DIRECTORY_EXIST] = -1; SQLSTATE[-OB_FILE_OR_DIRECTORY_EXIST] = "HY000"; STR_ERROR[-OB_FILE_OR_DIRECTORY_EXIST] = "file or directory already exist"; @@ -13312,6 +16119,8 @@ static struct ObStrErrorInit { "ORA-00600: internal error code, arguments: -9101, file or directory already exist"; ERROR_NAME[-OB_ERR_DUPLICATE_HAVING_CLAUSE_IN_TABLE_EXPRESSION] = "OB_ERR_DUPLICATE_HAVING_CLAUSE_IN_TABLE_EXPRESSION"; + ERROR_CAUSE[-OB_ERR_DUPLICATE_HAVING_CLAUSE_IN_TABLE_EXPRESSION] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DUPLICATE_HAVING_CLAUSE_IN_TABLE_EXPRESSION] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DUPLICATE_HAVING_CLAUSE_IN_TABLE_EXPRESSION] = -1; SQLSTATE[-OB_ERR_DUPLICATE_HAVING_CLAUSE_IN_TABLE_EXPRESSION] = "HY000"; STR_ERROR[-OB_ERR_DUPLICATE_HAVING_CLAUSE_IN_TABLE_EXPRESSION] = "Duplicate having-clause in table expression"; @@ -13322,6 +16131,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DUPLICATE_HAVING_CLAUSE_IN_TABLE_EXPRESSION] = "PLS-00119: Duplicate having-clause in table expression"; ERROR_NAME[-OB_ERR_INOUT_PARAM_PLACEMENT_NOT_PROPERLY] = "OB_ERR_INOUT_PARAM_PLACEMENT_NOT_PROPERLY"; + ERROR_CAUSE[-OB_ERR_INOUT_PARAM_PLACEMENT_NOT_PROPERLY] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INOUT_PARAM_PLACEMENT_NOT_PROPERLY] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INOUT_PARAM_PLACEMENT_NOT_PROPERLY] = -1; SQLSTATE[-OB_ERR_INOUT_PARAM_PLACEMENT_NOT_PROPERLY] = "HY000"; STR_ERROR[-OB_ERR_INOUT_PARAM_PLACEMENT_NOT_PROPERLY] = "OUT and IN/OUT modes cannot be used in this context"; @@ -13332,6 +16143,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INOUT_PARAM_PLACEMENT_NOT_PROPERLY] = "PLS-00254: OUT and IN/OUT modes cannot be used in this context"; ERROR_NAME[-OB_ERR_OBJECT_NOT_FOUND] = "OB_ERR_OBJECT_NOT_FOUND"; + ERROR_CAUSE[-OB_ERR_OBJECT_NOT_FOUND] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_OBJECT_NOT_FOUND] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_OBJECT_NOT_FOUND] = -1; SQLSTATE[-OB_ERR_OBJECT_NOT_FOUND] = "HY000"; STR_ERROR[-OB_ERR_OBJECT_NOT_FOUND] = "object not found"; @@ -13341,6 +16154,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_OBJECT_NOT_FOUND] = "ORA-31603: object '%.*s' of type %.*s not found in schema '%.*s'"; ERROR_NAME[-OB_ERR_INVALID_INPUT_VALUE] = "OB_ERR_INVALID_INPUT_VALUE"; + ERROR_CAUSE[-OB_ERR_INVALID_INPUT_VALUE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INVALID_INPUT_VALUE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INVALID_INPUT_VALUE] = -1; SQLSTATE[-OB_ERR_INVALID_INPUT_VALUE] = "HY000"; STR_ERROR[-OB_ERR_INVALID_INPUT_VALUE] = "invalid input value"; @@ -13350,6 +16165,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INVALID_INPUT_VALUE] = "ORA-31600: invalid input value %.*s for parameter %.*s in function %.*s"; ERROR_NAME[-OB_ERR_GOTO_BRANCH_ILLEGAL] = "OB_ERR_GOTO_BRANCH_ILLEGAL"; + ERROR_CAUSE[-OB_ERR_GOTO_BRANCH_ILLEGAL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_GOTO_BRANCH_ILLEGAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_GOTO_BRANCH_ILLEGAL] = ER_SP_LILABEL_MISMATCH; SQLSTATE[-OB_ERR_GOTO_BRANCH_ILLEGAL] = "42000"; STR_ERROR[-OB_ERR_GOTO_BRANCH_ILLEGAL] = "no matching label: %.*s"; @@ -13360,6 +16177,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_GOTO_BRANCH_ILLEGAL] = "PLS-00375: illegal GOTO statement; this GOTO cannot branch to label '%.*s'"; ERROR_NAME[-OB_ERR_ONLY_SCHEMA_LEVEL_ALLOW] = "OB_ERR_ONLY_SCHEMA_LEVEL_ALLOW"; + ERROR_CAUSE[-OB_ERR_ONLY_SCHEMA_LEVEL_ALLOW] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_ONLY_SCHEMA_LEVEL_ALLOW] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_ONLY_SCHEMA_LEVEL_ALLOW] = -1; SQLSTATE[-OB_ERR_ONLY_SCHEMA_LEVEL_ALLOW] = "HY000"; STR_ERROR[-OB_ERR_ONLY_SCHEMA_LEVEL_ALLOW] = "Only schema-level programs allow AUTHID or DEFAULT COLLATION clause"; @@ -13369,6 +16188,8 @@ static struct ObStrErrorInit { "PLS-00157: Only schema-level programs allow AUTHID or DEFAULT COLLATION clause"; ORACLE_STR_USER_ERROR[-OB_ERR_ONLY_SCHEMA_LEVEL_ALLOW] = "PLS-00157: Only schema-level programs allow %s"; ERROR_NAME[-OB_ERR_DECL_MORE_THAN_ONCE] = "OB_ERR_DECL_MORE_THAN_ONCE"; + ERROR_CAUSE[-OB_ERR_DECL_MORE_THAN_ONCE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DECL_MORE_THAN_ONCE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DECL_MORE_THAN_ONCE] = -1; SQLSTATE[-OB_ERR_DECL_MORE_THAN_ONCE] = "HY000"; STR_ERROR[-OB_ERR_DECL_MORE_THAN_ONCE] = "at most one declaration for identifier is permitted"; @@ -13377,6 +16198,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_DECL_MORE_THAN_ONCE] = "PLS-00371: at most one declaration for identifier is permitted"; ORACLE_STR_USER_ERROR[-OB_ERR_DECL_MORE_THAN_ONCE] = "PLS-00371: at most one declaration for '%.*s' is permitted"; ERROR_NAME[-OB_ERR_DUPLICATE_FILED] = "OB_ERR_DUPLICATE_FILED"; + ERROR_CAUSE[-OB_ERR_DUPLICATE_FILED] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_DUPLICATE_FILED] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_DUPLICATE_FILED] = -1; SQLSTATE[-OB_ERR_DUPLICATE_FILED] = "HY000"; STR_ERROR[-OB_ERR_DUPLICATE_FILED] = "duplicate fields in RECORD,TABLE or argument list are not permitted"; @@ -13387,6 +16210,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_DUPLICATE_FILED] = "PLS-00410: duplicate fields in RECORD,TABLE or argument list are not permitted"; ERROR_NAME[-OB_ERR_AUTONOMOUS_TRANSACTION_ILLEGAL] = "OB_ERR_AUTONOMOUS_TRANSACTION_ILLEGAL"; + ERROR_CAUSE[-OB_ERR_AUTONOMOUS_TRANSACTION_ILLEGAL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_AUTONOMOUS_TRANSACTION_ILLEGAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_AUTONOMOUS_TRANSACTION_ILLEGAL] = -1; SQLSTATE[-OB_ERR_AUTONOMOUS_TRANSACTION_ILLEGAL] = "HY000"; STR_ERROR[-OB_ERR_AUTONOMOUS_TRANSACTION_ILLEGAL] = "Pragma AUTONOMOUS_TRANSACTION cannot be specified here"; @@ -13397,6 +16222,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_AUTONOMOUS_TRANSACTION_ILLEGAL] = "PLS-00710: Pragma AUTONOMOUS_TRANSACTION cannot be specified here"; ERROR_NAME[-OB_ERR_EXIT_CONTINUE_ILLEGAL] = "OB_ERR_EXIT_CONTINUE_ILLEGAL"; + ERROR_CAUSE[-OB_ERR_EXIT_CONTINUE_ILLEGAL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_EXIT_CONTINUE_ILLEGAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_EXIT_CONTINUE_ILLEGAL] = -1; SQLSTATE[-OB_ERR_EXIT_CONTINUE_ILLEGAL] = "HY000"; STR_ERROR[-OB_ERR_EXIT_CONTINUE_ILLEGAL] = "illegal EXIT/CONTINUE statement; it must appear inside a loop"; @@ -13407,6 +16234,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_EXIT_CONTINUE_ILLEGAL] = "PLS-00376: illegal EXIT/CONTINUE statement; it must appear inside a loop"; ERROR_NAME[-OB_ERR_LABEL_ILLEGAL] = "OB_ERR_LABEL_ILLEGAL"; + ERROR_CAUSE[-OB_ERR_LABEL_ILLEGAL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_LABEL_ILLEGAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_LABEL_ILLEGAL] = -1; SQLSTATE[-OB_ERR_LABEL_ILLEGAL] = "HY000"; STR_ERROR[-OB_ERR_LABEL_ILLEGAL] = "EXIT/CONTINUE label must label a LOOP statement"; @@ -13415,6 +16244,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_LABEL_ILLEGAL] = "PLS-00373: EXIT/CONTINUE label must label a LOOP statement"; ORACLE_STR_USER_ERROR[-OB_ERR_LABEL_ILLEGAL] = "PLS-00373: EXIT/CONTINUE label '%.*s' must label a LOOP statement"; ERROR_NAME[-OB_ERR_CURSOR_LEFT_ASSIGN] = "OB_ERR_CURSOR_LEFT_ASSIGN"; + ERROR_CAUSE[-OB_ERR_CURSOR_LEFT_ASSIGN] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CURSOR_LEFT_ASSIGN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CURSOR_LEFT_ASSIGN] = -1; SQLSTATE[-OB_ERR_CURSOR_LEFT_ASSIGN] = "HY000"; STR_ERROR[-OB_ERR_CURSOR_LEFT_ASSIGN] = @@ -13427,6 +16258,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CURSOR_LEFT_ASSIGN] = "PLS-00321: expression '%.*s' is inappropriate as the left hand side of anassignment statement"; ERROR_NAME[-OB_ERR_INIT_NOTNULL_ILLEGAL] = "OB_ERR_INIT_NOTNULL_ILLEGAL"; + ERROR_CAUSE[-OB_ERR_INIT_NOTNULL_ILLEGAL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INIT_NOTNULL_ILLEGAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INIT_NOTNULL_ILLEGAL] = -1; SQLSTATE[-OB_ERR_INIT_NOTNULL_ILLEGAL] = "HY000"; STR_ERROR[-OB_ERR_INIT_NOTNULL_ILLEGAL] = "a variable declared NOT NULL must have an initialization assignment"; @@ -13438,6 +16271,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INIT_NOTNULL_ILLEGAL] = "PLS-00218: a variable declared NOT NULL must have an initialization assignment"; ERROR_NAME[-OB_ERR_INIT_CONST_ILLEGAL] = "OB_ERR_INIT_CONST_ILLEGAL"; + ERROR_CAUSE[-OB_ERR_INIT_CONST_ILLEGAL] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_INIT_CONST_ILLEGAL] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_INIT_CONST_ILLEGAL] = -1; SQLSTATE[-OB_ERR_INIT_CONST_ILLEGAL] = "HY000"; STR_ERROR[-OB_ERR_INIT_CONST_ILLEGAL] = "Constant declarations should contain initialization assignments"; @@ -13448,6 +16283,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_INIT_CONST_ILLEGAL] = "PLS-00322: Constant declarations should contain initialization assignments"; ERROR_NAME[-OB_ERR_CURSOR_VAR_IN_PKG] = "OB_ERR_CURSOR_VAR_IN_PKG"; + ERROR_CAUSE[-OB_ERR_CURSOR_VAR_IN_PKG] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_CURSOR_VAR_IN_PKG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_CURSOR_VAR_IN_PKG] = -1; SQLSTATE[-OB_ERR_CURSOR_VAR_IN_PKG] = "HY000"; STR_ERROR[-OB_ERR_CURSOR_VAR_IN_PKG] = "Cursor Variables cannot be declared as part of a package"; @@ -13457,6 +16294,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_CURSOR_VAR_IN_PKG] = "PLS-00994: Cursor Variables cannot be declared as part of a package"; ERROR_NAME[-OB_ERR_LIMIT_CLAUSE] = "OB_ERR_LIMIT_CLAUSE"; + ERROR_CAUSE[-OB_ERR_LIMIT_CLAUSE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_LIMIT_CLAUSE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_LIMIT_CLAUSE] = -1; SQLSTATE[-OB_ERR_LIMIT_CLAUSE] = "HY000"; STR_ERROR[-OB_ERR_LIMIT_CLAUSE] = "value in LIMIT clause: \'%.*s\' use is invalid"; @@ -13465,6 +16304,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_LIMIT_CLAUSE] = "PLS-00438: value in LIMIT clause: \'%.*s\' use is invalid"; ORACLE_STR_USER_ERROR[-OB_ERR_LIMIT_CLAUSE] = "PLS-00438: value in LIMIT clause: \'%.*s\' use is invalid"; ERROR_NAME[-OB_ERR_EXPRESSION_WRONG_TYPE] = "OB_ERR_EXPRESSION_WRONG_TYPE"; + ERROR_CAUSE[-OB_ERR_EXPRESSION_WRONG_TYPE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_EXPRESSION_WRONG_TYPE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_EXPRESSION_WRONG_TYPE] = -1; SQLSTATE[-OB_ERR_EXPRESSION_WRONG_TYPE] = "HY000"; STR_ERROR[-OB_ERR_EXPRESSION_WRONG_TYPE] = "expression is of wrong type"; @@ -13473,6 +16314,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_EXPRESSION_WRONG_TYPE] = "PLS-00382: expression is of wrong type"; ORACLE_STR_USER_ERROR[-OB_ERR_EXPRESSION_WRONG_TYPE] = "PLS-00382: expression is of wrong type"; ERROR_NAME[-OB_ERR_TYPE_SPEC_NOT_EXIST] = "OB_ERR_TYPE_SPEC_NOT_EXIST"; + ERROR_CAUSE[-OB_ERR_TYPE_SPEC_NOT_EXIST] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TYPE_SPEC_NOT_EXIST] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TYPE_SPEC_NOT_EXIST] = -1; SQLSTATE[-OB_ERR_TYPE_SPEC_NOT_EXIST] = "HY000"; STR_ERROR[-OB_ERR_TYPE_SPEC_NOT_EXIST] = "cannot compile type body without its specification"; @@ -13482,6 +16325,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TYPE_SPEC_NOT_EXIST] = "PLS-00304: cannot compile body of '%.*s' without its specification"; ERROR_NAME[-OB_ERR_TYPE_SPEC_NO_ROUTINE] = "OB_ERR_TYPE_SPEC_NO_ROUTINE"; + ERROR_CAUSE[-OB_ERR_TYPE_SPEC_NO_ROUTINE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TYPE_SPEC_NO_ROUTINE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TYPE_SPEC_NO_ROUTINE] = -1; SQLSTATE[-OB_ERR_TYPE_SPEC_NO_ROUTINE] = "HY000"; STR_ERROR[-OB_ERR_TYPE_SPEC_NO_ROUTINE] = @@ -13494,6 +16339,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_TYPE_SPEC_NO_ROUTINE] = "PLS-00539: subprogram '%.*s' is declared in an object type " "body and must be defined in the object type specification"; ERROR_NAME[-OB_ERR_TYPE_BODY_NO_ROUTINE] = "OB_ERR_TYPE_BODY_NO_ROUTINE"; + ERROR_CAUSE[-OB_ERR_TYPE_BODY_NO_ROUTINE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_TYPE_BODY_NO_ROUTINE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_TYPE_BODY_NO_ROUTINE] = -1; SQLSTATE[-OB_ERR_TYPE_BODY_NO_ROUTINE] = "HY000"; STR_ERROR[-OB_ERR_TYPE_BODY_NO_ROUTINE] = @@ -13507,6 +16354,8 @@ static struct ObStrErrorInit { "PLS-00538: subprogram or cursor '%.*s' is declared in an object type specification and must be defined in the " "object type body"; ERROR_NAME[-OB_ERR_IDENTIFIER_TOO_LONG] = "OB_ERR_IDENTIFIER_TOO_LONG"; + ERROR_CAUSE[-OB_ERR_IDENTIFIER_TOO_LONG] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_IDENTIFIER_TOO_LONG] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_IDENTIFIER_TOO_LONG] = -1; SQLSTATE[-OB_ERR_IDENTIFIER_TOO_LONG] = "HY000"; STR_ERROR[-OB_ERR_IDENTIFIER_TOO_LONG] = "identifier '%.*s' too long"; @@ -13515,6 +16364,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_IDENTIFIER_TOO_LONG] = "PLS-00114: identifier '%.*s' too long"; ORACLE_STR_USER_ERROR[-OB_ERR_IDENTIFIER_TOO_LONG] = "PLS-00114: identifier '%.*s' too long"; ERROR_NAME[-OB_SP_RAISE_APPLICATION_ERROR] = "OB_SP_RAISE_APPLICATION_ERROR"; + ERROR_CAUSE[-OB_SP_RAISE_APPLICATION_ERROR] = "Internal Error"; + ERROR_SOLUTION[-OB_SP_RAISE_APPLICATION_ERROR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SP_RAISE_APPLICATION_ERROR] = -1; SQLSTATE[-OB_SP_RAISE_APPLICATION_ERROR] = "HY000"; STR_ERROR[-OB_SP_RAISE_APPLICATION_ERROR] = @@ -13525,6 +16376,8 @@ static struct ObStrErrorInit { "ORA-20000: The stored procedure 'raise_application_error' was called which causes this error to be generated"; ORACLE_STR_USER_ERROR[-OB_SP_RAISE_APPLICATION_ERROR] = "ORA%06ld: %.*s"; ERROR_NAME[-OB_SP_RAISE_APPLICATION_ERROR_NUM] = "OB_SP_RAISE_APPLICATION_ERROR_NUM"; + ERROR_CAUSE[-OB_SP_RAISE_APPLICATION_ERROR_NUM] = "Internal Error"; + ERROR_SOLUTION[-OB_SP_RAISE_APPLICATION_ERROR_NUM] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_SP_RAISE_APPLICATION_ERROR_NUM] = -1; SQLSTATE[-OB_SP_RAISE_APPLICATION_ERROR_NUM] = "HY000"; STR_ERROR[-OB_SP_RAISE_APPLICATION_ERROR_NUM] = @@ -13537,6 +16390,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_SP_RAISE_APPLICATION_ERROR_NUM] = "ORA-21000: error number argument to raise_application_error of '%d' is out of range"; ERROR_NAME[-OB_CLOB_ONLY_SUPPORT_WITH_MULTIBYTE_FUN] = "OB_CLOB_ONLY_SUPPORT_WITH_MULTIBYTE_FUN"; + ERROR_CAUSE[-OB_CLOB_ONLY_SUPPORT_WITH_MULTIBYTE_FUN] = "Internal Error"; + ERROR_SOLUTION[-OB_CLOB_ONLY_SUPPORT_WITH_MULTIBYTE_FUN] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_CLOB_ONLY_SUPPORT_WITH_MULTIBYTE_FUN] = -1; SQLSTATE[-OB_CLOB_ONLY_SUPPORT_WITH_MULTIBYTE_FUN] = "HY000"; STR_ERROR[-OB_CLOB_ONLY_SUPPORT_WITH_MULTIBYTE_FUN] = "CLOB or NCLOB in multibyte character set not supported"; @@ -13547,6 +16402,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_CLOB_ONLY_SUPPORT_WITH_MULTIBYTE_FUN] = "ORA-22998: CLOB or NCLOB in multibyte character set not supported"; ERROR_NAME[-OB_ERR_UPDATE_TWICE] = "OB_ERR_UPDATE_TWICE"; + ERROR_CAUSE[-OB_ERR_UPDATE_TWICE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UPDATE_TWICE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UPDATE_TWICE] = -1; SQLSTATE[-OB_ERR_UPDATE_TWICE] = "HY000"; STR_ERROR[-OB_ERR_UPDATE_TWICE] = "unable to get a stable set of rows in the source tables"; @@ -13555,6 +16412,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_UPDATE_TWICE] = "ORA-30926: unable to get a stable set of rows in the source tables"; ORACLE_STR_USER_ERROR[-OB_ERR_UPDATE_TWICE] = "ORA-30926: unable to get a stable set of rows in the source tables"; ERROR_NAME[-OB_ERR_FLASHBACK_QUERY_WITH_UPDATE] = "OB_ERR_FLASHBACK_QUERY_WITH_UPDATE"; + ERROR_CAUSE[-OB_ERR_FLASHBACK_QUERY_WITH_UPDATE] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_FLASHBACK_QUERY_WITH_UPDATE] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_FLASHBACK_QUERY_WITH_UPDATE] = -1; SQLSTATE[-OB_ERR_FLASHBACK_QUERY_WITH_UPDATE] = "HY000"; STR_ERROR[-OB_ERR_FLASHBACK_QUERY_WITH_UPDATE] = "snapshot expression not allowed here"; @@ -13563,6 +16422,8 @@ static struct ObStrErrorInit { ORACLE_STR_ERROR[-OB_ERR_FLASHBACK_QUERY_WITH_UPDATE] = "ORA-08187: snapshot expression not allowed here"; ORACLE_STR_USER_ERROR[-OB_ERR_FLASHBACK_QUERY_WITH_UPDATE] = "ORA-08187: snapshot expression not allowed here"; ERROR_NAME[-OB_ERR_UPDATE_ON_EXPR] = "OB_ERR_UPDATE_ON_EXPR"; + ERROR_CAUSE[-OB_ERR_UPDATE_ON_EXPR] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_UPDATE_ON_EXPR] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_UPDATE_ON_EXPR] = -1; SQLSTATE[-OB_ERR_UPDATE_ON_EXPR] = "HY000"; STR_ERROR[-OB_ERR_UPDATE_ON_EXPR] = "Columns referenced in the ON Clause cannot be updated"; @@ -13572,6 +16433,8 @@ static struct ObStrErrorInit { ORACLE_STR_USER_ERROR[-OB_ERR_UPDATE_ON_EXPR] = "ORA-38104: Columns referenced in the ON Clause cannot be updated:'%.*s'.'%.*s'"; ERROR_NAME[-OB_ERR_SPECIFIED_ROW_NO_LONGER_EXISTS] = "OB_ERR_SPECIFIED_ROW_NO_LONGER_EXISTS"; + ERROR_CAUSE[-OB_ERR_SPECIFIED_ROW_NO_LONGER_EXISTS] = "Internal Error"; + ERROR_SOLUTION[-OB_ERR_SPECIFIED_ROW_NO_LONGER_EXISTS] = "Contact OceanBase Support"; MYSQL_ERRNO[-OB_ERR_SPECIFIED_ROW_NO_LONGER_EXISTS] = -1; SQLSTATE[-OB_ERR_SPECIFIED_ROW_NO_LONGER_EXISTS] = "HY000"; STR_ERROR[-OB_ERR_SPECIFIED_ROW_NO_LONGER_EXISTS] = "specified row no longer exists"; @@ -13597,6 +16460,32 @@ const char* ob_error_name(const int err) } return ret; } +const char* ob_error_cause(const int err) +{ + const char* ret = "Internal Error"; + if (OB_UNLIKELY(0 == err)) { + ret = "Not an Error"; + } else if (OB_LIKELY(0 > err && err > -OB_MAX_ERROR_CODE)) { + ret = ERROR_CAUSE[-err]; + if (OB_UNLIKELY(NULL == ret || '\0' == ret[0])) { + ret = "Internal Error"; + } + } + return ret; +} +const char* ob_error_solution(const int err) +{ + const char* ret = "Contact OceanBase Support"; + if (OB_UNLIKELY(0 == err)) { + ret = "Contact OceanBase Support"; + } else if (OB_LIKELY(0 > err && err > -OB_MAX_ERROR_CODE)) { + ret = ERROR_SOLUTION[-err]; + if (OB_UNLIKELY(NULL == ret || '\0' == ret[0])) { + ret = "Contact OceanBase Support"; + } + } + return ret; +} const char* ob_strerror(const int err) { diff --git a/src/share/ob_errno.def b/src/share/ob_errno.def index 08b456525..98955d9dd 100644 --- a/src/share/ob_errno.def +++ b/src/share/ob_errno.def @@ -20,6 +20,8 @@ // //C0: int OB_MAX_ERROR_CODE -----> ob errno //C1: char *ERROR_NAME[OB_MAX_ERROR_CODE]; -----> store ob errno name +//C2: char *ERROR_CAUSE[OB_MAX_ERROR_CODE]; -----> store ob errno cause +//C3: char *ERROR_SOLUTION[OB_MAX_ERROR_CODE]; -----> store ob errno solution //M1: int MYSQL_ERRNO[OB_MAX_ERROR_CODE]; -----> store mysql errno //M2: char *SQLSTATE[OB_MAX_ERROR_CODE]; -----> store mysql errstate //M3: char *STR_ERROR[OB_MAX_ERROR_CODE]; -----> store mysql errmsg without parameter @@ -36,6 +38,13 @@ //DEFINE_PLS_ERROR(C1, C0, M1, M2, M3, R1, R3) <==> DEFINE_ORACLE_ERROR_EXT(C1, C0, M1, M2, M3, M3, R1, PLS, R3, R3) //DEFINE_PLS_ERROR_EXT(C1, C0, M1, M2, M3, M4, R1, R3, R4) <==> DEFINE_ORACLE_ERROR_EXT(C1, C0, M1, M2, M3, M4, R1, PLS, R3, R4) // +//DEFINE_ERROR(C1, C0, M1, M2, M3, C2, C3) <==> DEFINE_ORACLE_ERROR_EXT(C1, C0, M1, M2, M3, M3, -600, M2, M3, M3, C2, C3) +//DEFINE_ERROR_EXT(C1, C0, M1, M2, M3, M4, C2, C3) <==> DEFINE_ORACLE_ERROR_EXT(C1, C0, M1, M2, M3, M4, -600, M2, M3, M4, C2, C3) +//DEFINE_ORACLE_ERROR(C1, C0, M1, M2, M3, R1, R3, C2, C3) <==> DEFINE_ORACLE_ERROR_EXT(C1, C0, M1, M2, M3, M3, R1, ORA, R3, R3, C2, C3) +//DEFINE_ORACLE_ERROR_EXT(C1, C0, M1, M2, M3, M4, R1, R3, R4, C2, C3) <==> DEFINE_ORACLE_ERROR_EXT(C1, C0, M1, M2, M3, M4, R1, ORA, R3, R4, C2, C3) +//DEFINE_PLS_ERROR(C1, C0, M1, M2, M3, R1, R3, C2, C3) <==> DEFINE_ORACLE_ERROR_EXT(C1, C0, M1, M2, M3, M3, R1, PLS, R3, R3, C2, C3) +//DEFINE_PLS_ERROR_EXT(C1, C0, M1, M2, M3, M4, R1, R3, R4, C2, C3) <==> DEFINE_ORACLE_ERROR_EXT(C1, C0, M1, M2, M3, M4, R1, PLS, R3, R4, C2, C3) +// //DEFINE_ERROR(C1, C0, M1, M2, M3) // M1 = (M1 == -1 ? C0 : M1) // M4 = M3 @@ -824,7 +833,7 @@ DEFINE_ORACLE_ERROR(OB_EER_NULL_IN_VALUES_LESS_THAN, -5285, ER_NULL_IN_VALUES_LE DEFINE_ERROR(OB_ERR_PARTITION_CONST_DOMAIN_ERROR, -5286, ER_PARTITION_CONST_DOMAIN_ERROR, "HY000", "Partition constant is out of partition function domain"); DEFINE_ERROR(OB_ERR_TOO_MANY_PARTITION_FUNC_FIELDS, -5287, ER_TOO_MANY_PARTITION_FUNC_FIELDS_ERROR, "HY000", "Too many fields in \'list of partition fields\'"); DEFINE_ERROR_EXT(OB_ERR_BAD_FT_COLUMN, -5288, ER_BAD_FT_COLUMN, "HY000", "Column cannot be part of FULLTEXT index", "Column '%.*s' cannot be part of FULLTEXT index"); -DEFINE_ERROR_EXT(OB_ERR_KEY_DOES_NOT_EXISTS, -5289, ER_KEY_DOES_NOT_EXITS, "42000", "key does not exist in table", "Key '%.*s' doesn't exist in table '%.*s'"); +DEFINE_ERROR_EXT(OB_ERR_KEY_DOES_NOT_EXISTS, -5289, ER_KEY_DOES_NOT_EXISTS, "42000", "key does not exist in table", "Key '%.*s' doesn't exist in table '%.*s'"); DEFINE_ERROR_EXT(OB_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN, -5290, ER_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN, "HY000", "non-default value for generated column is not allowed", "The value specified for generated column '%.*s' in table '%.*s' is not allowed"); DEFINE_ERROR(OB_ERR_BAD_CTXCAT_COLUMN, -5291, -1, "HY000", "The CTXCAT column must be contiguous in the index column list"); DEFINE_ERROR_EXT(OB_ERR_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN, -5292, ER_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN, "HY000", "not supported for generated columns", "'%s' is not supported for generated columns."); @@ -1199,7 +1208,7 @@ DEFINE_ORACLE_ERROR(OB_ERR_REGEXP_EPAREN, -5813, -1, "HY000", "unmatched parenth DEFINE_ORACLE_ERROR(OB_ERR_REGEXP_ESUBREG, -5814, -1, "HY000", "invalid back reference in regular expression", 12727, "invalid back reference in regular expression"); DEFINE_ORACLE_ERROR(OB_ERR_REGEXP_ERANGE, -5815, -1, "HY000", "invalid range in regular expression", 12728, "invalid range in regular expression"); DEFINE_ORACLE_ERROR(OB_ERR_REGEXP_ECTYPE, -5816, -1, "HY000", "invalid character class in regular expression", 12729, "invalid character class in regular expression"); -DEFINE_ERROR(OB_ERR_REGEXP_ECOLLATE, -5817, -1, "HY000", "invalid collation class in regular expression", 12731, "invalid collation class in regular expression"); +DEFINE_ORACLE_ERROR(OB_ERR_REGEXP_ECOLLATE, -5817, -1, "HY000", "invalid collation class in regular expression", 12731, "invalid collation class in regular expression"); DEFINE_ERROR(OB_ERR_REGEXP_EBRACE, -5818, -1, "HY000", "braces {} not balanced in in regular expression"); DEFINE_ERROR(OB_ERR_REGEXP_BADBR, -5819, -1, "HY000", "invalid repetition count(s) in regular expression"); DEFINE_ERROR(OB_ERR_REGEXP_BADRPT, -5820, -1, "HY000", "The regular expression was too complex and current library can't be parsed"); diff --git a/src/share/ob_errno.h b/src/share/ob_errno.h index e109ced4a..8bc0da2ae 100644 --- a/src/share/ob_errno.h +++ b/src/share/ob_errno.h @@ -10,6 +10,8 @@ * See the Mulan PubL v2 for more details. */ +// DO NOT EDIT. This file is automatically generated from `ob_errno.def'. + #ifndef OCEANBASE_LIB_OB_ERRNO_H_ #define OCEANBASE_LIB_OB_ERRNO_H_ #include @@ -4679,8 +4681,7 @@ constexpr int OB_ERR_INVALID_DATE_MSG_FMT_V2 = -4219; #define OB_ERR_REGEXP_ESUBREG__ORA_USER_ERROR_MSG "ORA-12727: invalid back reference in regular expression" #define OB_ERR_REGEXP_ERANGE__ORA_USER_ERROR_MSG "ORA-12728: invalid range in regular expression" #define OB_ERR_REGEXP_ECTYPE__ORA_USER_ERROR_MSG "ORA-12729: invalid character class in regular expression" -#define OB_ERR_REGEXP_ECOLLATE__ORA_USER_ERROR_MSG \ - "ORA-00600: internal error code, arguments: -5817, invalid collation class in regular expression" +#define OB_ERR_REGEXP_ECOLLATE__ORA_USER_ERROR_MSG "ORA-12731: invalid collation class in regular expression" #define OB_ERR_REGEXP_EBRACE__ORA_USER_ERROR_MSG \ "ORA-00600: internal error code, arguments: -5818, braces {} not balanced in in regular expression" #define OB_ERR_REGEXP_BADBR__ORA_USER_ERROR_MSG \ @@ -5243,6 +5244,9 @@ constexpr int OB_ERR_INVALID_DATE_MSG_FMT_V2 = -4219; "ORA-01861: Incorrect datetime value for column '%.*s' at row %ld" const char* ob_error_name(const int oberr); +const char* ob_error_cause(const int oberr); +const char* ob_error_solution(const int oberr); + int ob_mysql_errno(const int oberr); int ob_mysql_errno_with_check(const int oberr); const char* ob_sqlstate(const int oberr); diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt new file mode 100644 index 000000000..e27d0f2b6 --- /dev/null +++ b/tools/CMakeLists.txt @@ -0,0 +1 @@ +add_subdirectory(ob_error) \ No newline at end of file diff --git a/tools/ob_error/CMakeLists.txt b/tools/ob_error/CMakeLists.txt new file mode 100644 index 000000000..130b119d8 --- /dev/null +++ b/tools/ob_error/CMakeLists.txt @@ -0,0 +1 @@ +add_subdirectory(src) \ No newline at end of file diff --git a/tools/ob_error/README.md b/tools/ob_error/README.md new file mode 100644 index 000000000..3f0e545c3 --- /dev/null +++ b/tools/ob_error/README.md @@ -0,0 +1,166 @@ +# What is ob_error + +ob_error is the error tool of OceanBase. + +An error tool can return the information, reason and solution corresponding to the error code which entered by the user. + +It saves the trouble of looking up documents. + +## How to build + +### debug mode + +```shell +bash build.sh debug --init +cd build_debug +make ob_error +cp tools/ob_error/src/ob_error /usr/local/bin +``` + +`ob_error` will generated in `DEBUG_BUILD_DIR/tools/ob_error/src/ob_error` by default. + +### release mode + +```shell +bash build.sh release --init +cd build_release +make ob_error +cp tools/ob_error/src/ob_error /usr/local/bin +``` + +`ob_error` will generated in `RELEASE_BUILD_DIR/tools/ob_error/src/ob_error` by default. + +### RPM packges + +NOTE: this is not support now. + +```shell +bash build.sh rpm --init && cd build_rpm && make -j16 rpm +rpm2cpio oceanbase-ce-3.1.0-1.alios7.x86_64.rpm | cpio -idmv ./home/admin/oceanbase/bin/ob_error +cp home/admin/oceanbase/bin/ob_error /usr/local/bin +``` + +`ob_error` will included in `oceanbase-ce-3.1.0-1.alios7.x86_64.rpm`. +Because you just need `ob_error`, you can use `rpm2cpio` to do it. + +## How to use + +You can search error message by only enter the error code. + +Then you will get the error message corresponding to OS, Oracle and MySQL modes, and OceanBase own error (if any exists). + +such as: + +```shell +$ob_error 4001 + +OceanBase: + OceanBase Error Code: OB_OBJ_TYPE_ERROR(-4001) + Message: Object type error + Cause: Internal Error + Solution: Contact OceanBase Support + +Oracle: + Oracle Error Code: ORA-04001 + Message: sequence parameter must be an integer + Related OceanBase Error Code: + OB_ERR_SEQ_OPTION_MUST_BE_INTEGER(-4317) +``` + +Also, you can search error message of specific mode by adding a prefix (we called facility). + +When the facility is `my`, if the error code is not an error which exists in MySQL, you will get the OceanBase error info(if it exists). Otherwise, you will get the error info of MySQL mode. + +such as: + +```shell +$ob_error my 4000 + +OceanBase: + OceanBase Error Code: OB_ERROR(-4000) + Message: Common error + Cause: Internal Error + Solution: Contact OceanBase Support + +$ob_error my 1210 + +MySQL: + MySQL Error Code: 1210 (HY000) + Message: Invalid argument + Message: Miss argument + Message: Incorrect arguments to ESCAPE + Related OceanBase Error Code: + OB_INVALID_ARGUMENT(-4002) + OB_MISS_ARGUMENT(-4277) + INCORRECT_ARGUMENTS_TO_ESCAPE(-5832) +``` + +When the facility is `ora` or `pls`, you will get the error info of Oracle mode(if it exists). +such as: + +```shell +$ob_error ora 51 + +Oracle: + Oracle Error Code: ORA-00051 + Message: timeout occurred while waiting for a resource + Related OceanBase Error Code: + OB_ERR_TIMEOUT_ON_RESOURCE(-5848) +``` + +Further more, there is an exceptional case. If you use the `-a` option, you will get the OceanBase own error info and the error info of Oracle mode (if any exists). + +such as: + +```shell +$ob_error ora 600 -a 5727 + +OceanBase: + OceanBase Error Code: OB_ERR_PROXY_REROUTE(-5727) + Message: SQL request should be rerouted + Cause: Internal Error + Solution: Contact OceanBase Support + +Oracle: + Oracle Error Code: ORA-00600 + Message: internal error code, arguments: -5727, SQL request should be rerouted + Related OceanBase Error Code: + OB_ERR_PROXY_REROUTE(-5727) +``` + +Note: `-a` option is designed to find `ORA-00600` error which has an `arguments` (those Oracle internal error). + +You can find more test example in [expect_result](test/expect_result.result). + +Further more, you can get the complete user manual by `--help` option. + +```shell +ob_error --help +``` + +## How to add error cause/solution + +*This part is for developers.* + +For example: + +The ob error `4000` in `src/oberror_errno.def` defined as + +```shell +DEFINE_ERROR(OB_ERROR, -4000, -1, "HY000", "Common error"); +``` + +If you want to add the cause and solution info, you can change the define as + +```shell +DEFINE_ERROR(OB_ERROR, -4000, -1, "HY000", "Common error", "CAUSE", "SOLUTION"); +``` + +And then regenerate the `src/lib/oberror_errno.h`、`src/oberror_errno.h` and `src/oberror_errno.cpp` by + +```shell +cd src/share +./gen_errno.pl +``` + +Finally back to `BUILD_DIR` to remake `ob_error`. diff --git a/tools/ob_error/src/CMakeLists.txt b/tools/ob_error/src/CMakeLists.txt new file mode 100644 index 000000000..1823a4473 --- /dev/null +++ b/tools/ob_error/src/CMakeLists.txt @@ -0,0 +1,13 @@ +include_directories( + ${CMAKE_SOURCE_DIR}/src + ${DEP_DIR}/include + ${CMAKE_SOURCE_DIR}/deps/oblib/src +) +add_definitions(-D__ERROR_CODE_PARSER_) +set(SRC_LIST ob_error.cpp os_errno.cpp ${CMAKE_SOURCE_DIR}/src/share/ob_errno.cpp) + +add_executable(ob_error ${SRC_LIST}) + +add_library(oberror SHARED ${SRC_LIST}) + +# message(STATUS "DIR = " ${CMAKE_SOURCE_DIR}) \ No newline at end of file diff --git a/tools/ob_error/src/gen_os_errno.pl b/tools/ob_error/src/gen_os_errno.pl new file mode 100755 index 000000000..dffc23818 --- /dev/null +++ b/tools/ob_error/src/gen_os_errno.pl @@ -0,0 +1,172 @@ +#!/usr/bin/env perl +# 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. + +use strict; +use warnings; +open my $fh, '<', "os_errno.def"; +my %os_map; +my $error_count=0; + +while(<$fh>) { + if (/^DEFINE_OS_ERROR\(([^,]+),\s*([^,]*),\s*([^,]*),\s*("[^,]*")/) { + ++$error_count; + #print "\"$1\", $1, $2\n"; + $os_map{$1} = [$2, $3, "$1", $4]; + } +} + +print "total error code: $error_count\n"; +print "please wait for writing files ...\n"; +# check duplicate error number +my %dedup; +for my $oberr (keys % os_map) { + my $errno = $os_map{$oberr}->[0]; + if (defined $dedup{$errno}) + { + print "Error: error code($errno) is duplicated for $oberr and $dedup{$errno}\n"; + exit 1; + } else { + $dedup{$errno} = $oberr; + } +} + +# sort +my @os_pairs = map {[$_, $os_map{$_}->[0] ]} keys %os_map; +my @os_sorted = sort {$b->[1] <=> $a->[1]} @os_pairs; +my @os_errors = map {$_->[0]} @os_sorted; + +# generate os_errno.h +open my $fh_header_os, '>', "os_errno.h"; +print $fh_header_os '/** + * 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. + */ + +// DO NOT EDIT. This file is automatically generated from `ob_errno.def\'. +#ifndef OBERROR_OS_ERRNO_H +#define OBERROR_OS_ERRNO_H + +// linux +#include + +namespace oceanbase { +namespace common { + +// The length of the second dimension, in order to solve the conflict of multiple identical error codes +constexpr int OS_MAX_SAME_ERROR_COUNT = 2; + +constexpr int OS_MAX_ERROR_CODE = 135; +'; + for my $oserr (@os_errors) { + print $fh_header_os "constexpr int $oserr = $os_map{$oserr}->[0];\n"; + } +print $fh_header_os ' +const char* str_os_error_name(const int err); +const char* str_os_error_msg(const int err); +int os_errno(const int err); +} // end namespace common +} // end namespace oceanbase + +#endif /* OBERROR_OS_ERRNO_H */ +'; + +# generate os_errno.cpp +open my $fh_cpp_os, '>', "os_errno.cpp"; +print $fh_cpp_os '/** + * 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. + */ + +// DO NOT EDIT. This file is automatically generated from `ob_errno.def\'. + +#include "os_errno.h" +#include +#include +using namespace oceanbase::common; + +static const char *OS_ERRNO_NAME[OS_MAX_ERROR_CODE]; +static const char *OS_ERRNO_MSG[OS_MAX_ERROR_CODE]; +static int OS_ERRNO[OS_MAX_ERROR_CODE]; + +static struct OSStrErrorInit +{ + OSStrErrorInit() { + memset(OS_ERRNO_NAME, 0, sizeof(OS_ERRNO_NAME)); + memset(OS_ERRNO_MSG, 0, sizeof(OS_ERRNO_MSG)); + memset(OS_ERRNO, 0, sizeof(OS_ERRNO)); + +'; + for my $oserr (@os_errors) { + if (0 > $os_map{$oserr}->[0]) { + print $fh_cpp_os " OS_ERRNO_NAME[-$oserr] = \"$os_map{$oserr}->[2]\";\n"; + print $fh_cpp_os " OS_ERRNO_MSG[-$oserr] = $os_map{$oserr}->[3];\n"; + print $fh_cpp_os " OS_ERRNO[-$oserr] = $os_map{$oserr}->[1];\n"; + } + } + print $fh_cpp_os ' + } +} local_init; + +namespace oceanbase { +namespace common { +const char *str_os_error_name(const int err) +{ + const char *ret = "Unknown error"; + if (0 == err) { + ret = "OB_SUCCESS"; + } else if (0 > err && err > -OS_MAX_ERROR_CODE) { + ret = OS_ERRNO_NAME[-err]; + if (NULL == ret || \'\0\' == ret[0]) + { + ret = "Unknown Error"; + } + } + return ret; +} +const char *str_os_error_msg(const int err) +{ + const char *ret = NULL; + if (0 == err) { + ret = NULL; + } else if (0 > err && err > -OS_MAX_ERROR_CODE) { + ret = OS_ERRNO_MSG[-err]; + if (NULL == ret || \'\0\' == ret[0]) + { + ret = NULL; + } + } + return ret; +} +int os_errno(const int err) +{ + int ret = -1; + if (0 >= err && err > -OS_MAX_ERROR_CODE) { + ret = OS_ERRNO[-err]; + } + return ret; +} +} // end namespace common +} // end namespace oceanbase + '; diff --git a/tools/ob_error/src/ob_error.cpp b/tools/ob_error/src/ob_error.cpp new file mode 100644 index 000000000..897a500a9 --- /dev/null +++ b/tools/ob_error/src/ob_error.cpp @@ -0,0 +1,784 @@ +/** + * 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. + */ + +#include "ob_error.h" +#include +#include + +ObErrorInfoMgr::ObErrorInfoMgr() + : os_error_count_(0), + mysql_error_count_(0), + oracle_error_count_(0), + ob_error_count_(0) +{} + +ObErrorInfoMgr::~ObErrorInfoMgr() +{ + for (int i = 0; i < os_error_count_; i++) { + os_error_[i].free_space(); + } + for (int i = 0; i < mysql_error_count_; i++) { + mysql_error_[i].free_space(); + } + for (int i = 0; i < oracle_error_count_; i++) { + oracle_error_[i].free_space(); + } + for (int i = 0; i < ob_error_count_; i++) { + ob_error_[i].free_space(); + } +} + +bool ObErrorInfoMgr::insert_os_error(const char* name, const char* msg, int error_code) +{ + bool bret = false; + if (OS_MAX_SAME_ERROR_COUNT <= os_error_count_) { + ERROR_PRINT("error: ObErrorInfoMgr os_error_[] is full.\n"); + } else if (nullptr == name) { + ERROR_PRINT("error: name is nullptr.\n"); + } else if (nullptr == msg) { + ERROR_PRINT("error: msg is nullptr.\n"); + } else { + os_error_[os_error_count_].error_name_ = strdup(name); + os_error_[os_error_count_].error_msg_ = strdup(msg); + os_error_[os_error_count_].error_code_ = error_code; + os_error_count_++; + bret = true; + } + return bret; +} +void ObErrorInfoMgr::print_os_error() +{ + for (int i = 0; i < os_error_count_; i++) { + printf("\n\tLinux Error Code: %s(%d)\n\tMessage: %s\n", + os_error_[i].error_name_, + os_error_[i].error_code_, + os_error_[i].error_msg_); + } +} + +bool ObErrorInfoMgr::insert_mysql_error(const char* name, const char* msg, int mysql_errno, const char* sqlstate, + const char* cause, const char* solution, int ob_error) +{ + bool bret = false; + if (OB_MAX_SAME_ERROR_COUNT <= mysql_error_count_) { + ERROR_PRINT("error: ObErrorInfoMgr mysql_error_[] is full.\n"); + } else if (nullptr == name) { + ERROR_PRINT("error: name is nullptr.\n"); + } else if (nullptr == msg) { + ERROR_PRINT("error: msg is nullptr.\n"); + } else if (nullptr == sqlstate) { + ERROR_PRINT("error: sqlstate is nullptr.\n"); + } else if (nullptr == cause) { + ERROR_PRINT("error: cause is nullptr.\n"); + } else if (nullptr == solution) { + ERROR_PRINT("error: solution is nullptr.\n"); + } else { + mysql_error_[mysql_error_count_].error_name_ = strdup(name); + mysql_error_[mysql_error_count_].error_msg_ = strdup(msg); + mysql_error_[mysql_error_count_].mysql_errno_ = mysql_errno; + mysql_error_[mysql_error_count_].sqlstate_ = strdup(sqlstate); + mysql_error_[mysql_error_count_].cause_ = strdup(cause); + mysql_error_[mysql_error_count_].solution_ = strdup(solution); + mysql_error_[mysql_error_count_].ob_error_ = ob_error; + mysql_error_count_++; + bret = true; + } + return bret; +} +void ObErrorInfoMgr::print_mysql_error() +{ + for (int i = 0; i < mysql_error_count_; i++) { + if (0 == i) { + printf("\n\tMySQL Error Code: %d (%s)\n", mysql_error_[i].mysql_errno_, mysql_error_[i].sqlstate_); + printf("\tMessage: %s\n", mysql_error_[i].error_msg_); + } else if (0 != strcmp(mysql_error_[i].error_msg_, mysql_error_[i - 1].error_msg_)) { + printf("\tMessage: %s\n", mysql_error_[i].error_msg_); + } + } + printf("\tRelated OceanBase Error Code:\n"); + for (int i = 0; i < mysql_error_count_; i++) { + printf("\t\t%s(%d)\n", mysql_error_[i].error_name_, -mysql_error_[i].ob_error_); + } +} + +bool ObErrorInfoMgr::insert_oracle_error(const char* name, const char* msg, const char* cause, const char* solution, + Fac facility, int error_code, int ob_error) +{ + bool bret = false; + if (OB_MAX_SAME_ERROR_COUNT <= oracle_error_count_) { + ERROR_PRINT("error: ObErrorInfoMgr oracle_error_[] is full.\n"); + } else if (nullptr == name) { + ERROR_PRINT("error: name is nullptr.\n"); + } else if (nullptr == msg) { + ERROR_PRINT("error: msg is nullptr.\n"); + } else if (nullptr == cause) { + ERROR_PRINT("error: cause is nullptr.\n"); + } else if (nullptr == solution) { + ERROR_PRINT("error: solution is nullptr.\n"); + } else if (MY <= facility) { + ERROR_PRINT("error: facility is not a Oracle facility.\n"); + } else { + oracle_error_[oracle_error_count_].error_name_ = strdup(name); + oracle_error_[oracle_error_count_].error_msg_ = strdup(msg); + oracle_error_[oracle_error_count_].cause_ = strdup(cause); + oracle_error_[oracle_error_count_].solution_ = strdup(solution); + oracle_error_[oracle_error_count_].facility_ = facility; + oracle_error_[oracle_error_count_].error_code_ = error_code; + oracle_error_[oracle_error_count_].ob_error_ = ob_error; + oracle_error_count_++; + bret = true; + } + return bret; +} +void ObErrorInfoMgr::print_oracle_error() +{ + for (int i = 0; i < oracle_error_count_; i++) { + if (0 == i) { + printf( + "\n\tOracle Error Code: %s-%05d\n", facility_str[oracle_error_[i].facility_], oracle_error_[i].error_code_); + printf("\tMessage: %s\n", oracle_error_[i].error_msg_); + } else if (0 != strcmp(oracle_error_[i].error_msg_, oracle_error_[i - 1].error_msg_)) { + printf("\tMessage: %s\n", oracle_error_[i].error_msg_); + } + } + printf("\tRelated OceanBase Error Code:\n"); + for (int i = 0; i < oracle_error_count_; i++) { + printf("\t\t%s(%d)\n", oracle_error_[i].error_name_, -oracle_error_[i].ob_error_); + } +} + +bool ObErrorInfoMgr::insert_ob_error( + const char* name, const char* msg, const char* cause, const char* solution, int error_code) +{ + bool bret = false; + if (OB_MAX_SAME_ERROR_COUNT <= ob_error_count_) { + ERROR_PRINT("error: ObErrorInfoMgr ob_error_[] is full.\n"); + } else if (nullptr == name) { + ERROR_PRINT("error: name is nullptr.\n"); + } else if (nullptr == msg) { + ERROR_PRINT("error: msg is nullptr.\n"); + } else if (nullptr == cause) { + ERROR_PRINT("error: cause is nullptr.\n"); + } else if (nullptr == solution) { + ERROR_PRINT("error: solution is nullptr.\n"); + } else { + ob_error_[ob_error_count_].error_name_ = strdup(name); + ob_error_[ob_error_count_].error_msg_ = strdup(msg); + ob_error_[ob_error_count_].cause_ = strdup(cause); + ob_error_[ob_error_count_].solution_ = strdup(solution); + ob_error_[ob_error_count_].error_code_ = error_code; + ob_error_count_++; + bret = true; + } + return bret; +} +void ObErrorInfoMgr::print_ob_error() +{ + for (int i = 0; i < ob_error_count_; i++) { + printf("\n\tOceanBase Error Code: %s(%d)\n\tMessage: %s\n\tCause: %s\n\tSolution: %s\n", + ob_error_[i].error_name_, + -ob_error_[i].error_code_, + ob_error_[i].error_msg_, + ob_error_[i].cause_, + ob_error_[i].solution_); + } +} +////////////////////////////////////////////////////////////// +static void print_help() +{ + printf("This is the ob_error tool. Usage:\n\n" + " ob_error [option]\n" + " ob_error [facility] error_code [-a ARGUMENT]\n" + " ob_error [facility] error_code [--argument ARGUMENT]\n" + "Get the error information, reasons and possible solutions.\n\n" + "Query an error:\n\n" + " ob_error error_code\n\n" + "Query an error in MySQL mode:\n\n" + " ob_error MY error_code\n\n" + "Query an error in ORACLE mode:\n\n" + " ob_error facility error_code\n" + " ob_error facility error_code -a ARGUMENT\n" + " ob_error facility error_code --argument ARGUMENT\n\n" + "ARGUMENT: \n\n" + " Positive number OceanBase error_code in ORA-00600 error output.\n\n" + "facility:\n\n" + " MY MySQL mode.\n" + " ORA ORACLE mode. Error from database.\n" + " PLS ORACLE mode. Error from the stored procedure.\n\n" + "Normal options:\n\n" + " --help, -h Print this message and then exit.\n" + " --version, -V Print version information and then exit.\n\n"); +} + +static void print_version() +{ + printf("OceanBase ob_error %.1f\n", OB_ERROR_VERSION); +} + +static void print_not_found(Fac facility, int error_code, int argument) +{ + if (MY > facility) { // oracle mode + if (-1 == argument) { + printf("\n\tError Code %s-%05d not found.\n", facility_str[facility], error_code); + } else { + printf("\n\tError Code %s-%05d arguments: -%d not found.\n", facility_str[facility], error_code, argument); + } + } else { + printf("\n\tError Code %d not found.\n", error_code); + } +} + +bool print_error_info(Fac facility, int error_code, int argument) +{ + bool bret = false; + ObErrorInfoMgr mgr; + if (MY > facility) { + if (-1 != argument) { + bret = add_ob_info(argument, &mgr); + if (mgr.is_ob_error_exist()) { + printf("\nOceanBase:"); + mgr.print_ob_error(); + } else if (!bret) { + printf("\nOceanBase:"); + print_not_found(NONE, argument, -1); + } + } + bool oracle_bret = add_oracle_info(facility, error_code, argument, &mgr); + if (mgr.is_oracle_error_exist()) { + printf("\nOracle:"); + mgr.print_oracle_error(); + } else if (!oracle_bret) { + printf("\nOracle:"); + print_not_found(facility, error_code, argument); + } + bret = true; + } else if (MY == facility) { + bret = add_mysql_info(error_code, &mgr); + if (mgr.is_mysql_error_exist()) { + printf("\nMySQL:"); + mgr.print_mysql_error(); + } else if (!bret) { + bret = add_ob_info(error_code, &mgr); + if (mgr.is_ob_error_exist()) { + printf("\nOceanBase:"); + mgr.print_ob_error(); + } else if (!bret) { + printf("\nMySQL:"); + print_not_found(NONE, error_code, argument); + bret = true; + } + } + } else { + bret |= add_os_info(error_code, &mgr); + if (mgr.is_os_error_exist()) { + printf("\nOperating System:"); + mgr.print_os_error(); + } + bret |= add_ob_info(error_code, &mgr); + if (mgr.is_ob_error_exist()) { + printf("\nOceanBase:"); + mgr.print_ob_error(); + } + bret |= add_mysql_info(error_code, &mgr); + if (mgr.is_mysql_error_exist()) { + printf("\nMySQL:"); + mgr.print_mysql_error(); + } + bret |= add_oracle_info(facility, error_code, argument, &mgr); + if (mgr.is_oracle_error_exist()) { + printf("\nOracle:"); + mgr.print_oracle_error(); + } + if (!bret) { + printf("\nOceanBase:"); + print_not_found(NONE, error_code, -1); + bret = true; + } + } + return bret; +} +bool add_os_info(int error_code, ObErrorInfoMgr* mgr) +{ + bool bret = false; + if (nullptr == mgr) { + ERROR_PRINT("ObErrorInfoMgr *mgr is null.\n"); + bret = true; + } else if (0 == error_code) { + bret = true; + } else if (0 < error_code && OS_MAX_ERROR_CODE > error_code) { + int ob_error = 0; + int info_count = 0; + for (int i = 0; i < OS_MAX_SAME_ERROR_COUNT; i++) { + if (-1 == g_os_error[error_code][i]) { + break; + } else { + ob_error = g_os_error[error_code][i]; + const char* error_msg = str_os_error_msg(-ob_error); + if (nullptr != error_msg) { + const char* error_name = str_os_error_name(-ob_error); + if (mgr->insert_os_error(error_name + strlen("OS_"), error_msg, error_code)) { + info_count++; + } + } + } + } + bret = (0 != info_count); + } + return bret; +} + +bool add_ob_info(int error_code, ObErrorInfoMgr* mgr) +{ + bool bret = false; + if (nullptr == mgr) { + ERROR_PRINT("ObErrorInfoMgr *mgr is null.\n"); + bret = true; + } else if (0 <= error_code && OB_MAX_ERROR_CODE > error_code) { + if (0 == error_code) { + const char* error_msg = "It is not an error."; + const char* error_name = ob_error_name(-error_code); + const char* error_cause = ob_error_cause(-error_code); + const char* error_solution = ob_error_solution(-error_code); + if (mgr->insert_ob_error(error_name, error_msg, error_cause, error_solution, error_code)) { + bret = true; + } + } else if (-1 == g_mysql_error[error_code][0]) { + const char* error_usr_msg = ob_errpkt_str_user_error(-error_code, false); + if (nullptr != error_usr_msg) { + const char* error_msg = ob_errpkt_strerror(-error_code, false); + const char* error_name = ob_error_name(-error_code); + const char* error_cause = ob_error_cause(-error_code); + const char* error_solution = ob_error_solution(-error_code); + if (mgr->insert_ob_error(error_name, error_msg, error_cause, error_solution, error_code)) { + bret = true; + } + } + } + } + return bret; +} + +static bool add_error_info(int error_code, Fac facility, int g_error[][OB_MAX_SAME_ERROR_COUNT], ObErrorInfoMgr* mgr) +{ + bool bret = false; + int ob_error = 0; + int info_count = 0; + if (nullptr == mgr) { + ERROR_PRINT("ObErrorInfoMgr *mgr is null.\n"); + bret = true; + } else if (0 <= error_code) { + for (int i = 0; i < OB_MAX_SAME_ERROR_COUNT; i++) { + if (-1 == g_error[error_code][i]) { + break; + } else { + ob_error = g_error[error_code][i]; + const char* error_usr_msg = ob_errpkt_str_user_error(-ob_error, MY > facility); + if (nullptr != error_usr_msg) { + const char* error_msg = ob_errpkt_strerror(-ob_error, MY > facility); + const char* error_name = ob_error_name(-ob_error); + const char* error_cause = ob_error_cause(-ob_error); + const char* error_solution = ob_error_solution(-ob_error); + if (MY > facility) { + if (mgr->insert_oracle_error(error_name, + error_msg + ORACLE_MSG_PREFIX, + error_cause, + error_solution, + facility, + error_code, + ob_error)) { + info_count++; + } + } else { + const char* sqlstate = ob_sqlstate(-ob_error); + if (mgr->insert_mysql_error( + error_name, error_msg, error_code, sqlstate, error_cause, error_solution, ob_error)) { + info_count++; + } + } + } + } + } + bret = (0 != info_count); + } + return bret; +} + +bool add_mysql_info(int error_code, ObErrorInfoMgr* mgr) +{ + bool bret = false; + if (nullptr == mgr) { + ERROR_PRINT("ObErrorInfoMgr *mgr is null.\n"); + bret = true; + } else if (0 <= error_code && OB_MAX_ERROR_CODE > error_code) { + if (-1 != g_mysql_error[error_code][0]) { + // map is not emtpy which means MySQL error exists + bret = add_error_info(error_code, MY, g_mysql_error, mgr); + } + } + return bret; +} + +bool add_oracle_info(Fac oracle_facility, int error_code, int argument, ObErrorInfoMgr* mgr) +{ + bool bret = false; + if (nullptr == mgr) { + ERROR_PRINT("ObErrorInfoMgr *mgr is null.\n"); + bret = true; + } else if (0 <= error_code && ORACLE_MAX_ERROR_CODE > error_code) { + int info_count = 0; + int ob_error = -1; + // Before being called, ensure that argument cannot be set when nullptr == oracle_facility + if (NONE == oracle_facility) { + // Handle the case where error is ORA-error_code + bret |= add_error_info(error_code, ORA, g_oracle_ora, mgr); + // Handle the case where error is PLS-error_code + bret |= add_error_info(error_code, PLS, g_oracle_pls, mgr); + } else { + if (ORA == oracle_facility) { + if (ORACLE_SPECIAL_ERROR_CODE == error_code) { + // 600 is a special error code. + // If there is no '-a ARG' parameter, the original possible error of ora-00600 will be output + if (-1 == argument) { + bret = add_error_info(error_code, ORA, g_oracle_ora, mgr); + } else { + ob_error = argument; + const char* error_usr_msg = ob_errpkt_str_user_error(-ob_error, true); + if (nullptr != error_usr_msg) { + // verify that the error is ora-00600 + if (-OB_ERR_PROXY_REROUTE == ob_errpkt_errno(-ob_error, true) || + ORACLE_SPECIAL_ERROR_CODE == ob_errpkt_errno(-ob_error, true)) { + const char* error_msg = ob_errpkt_strerror(-ob_error, true); + const char* error_name = ob_error_name(-ob_error); + const char* error_cause = ob_error_cause(-ob_error); + const char* error_solution = ob_error_solution(-ob_error); + if (mgr->insert_oracle_error(error_name, + error_msg + ORACLE_MSG_PREFIX, + error_cause, + error_solution, + ORA, + error_code, + ob_error)) { + bret = true; + } + } + } + } + } else { + // '-a ARG' parameter only supports ora-00600 error + if (-1 != argument) { + printf("error: '-a ARG' is unsupport in this scene\n" + "Use 'ob_error ora 600 -a=ARG'.\n" + "Use 'ob_error --help' for help.\n"); + bret = true; + } else { + bret = add_error_info(error_code, ORA, g_oracle_ora, mgr); + } + } + } else if (PLS == oracle_facility) { + // '-a ARG' parameter only supports ora-00600 error + if (-1 != argument) { + printf("error: '-a ARG' is unsupport in this scene\n" + "Use 'ob_error ora 600 -a ARG'.\n" + "Use 'ob_error --help' for help.\n"); + bret = true; + } else { + bret = add_error_info(error_code, PLS, g_oracle_pls, mgr); + } + } + } + } + return bret; +} + +// prevent the atoi parse "123abc" +void parse_error_code(const char* argv, int& error_code) +{ + int len = 0; + int code = 0; + if (nullptr != argv) { + len = strlen(argv); + for (int i = 0; i < len; i++) { + if (argv[i] <= '9' && argv[i] >= '0') { + int tmp_code = code * 10 + (argv[i] - '0'); + if (code > tmp_code) { // overflow + code = -1; + break; + } else { + code = tmp_code; + } + } else { + code = -1; + break; + } + } + error_code = code; + } +} + +void parse_facility(const char* argv, Fac& facility) +{ + if (nullptr != argv) { + if (0 == strcasecmp(argv, facility_str[ORA])) { + facility = ORA; + } else if (0 == strcasecmp(argv, facility_str[PLS])) { + facility = PLS; + } else if (0 == strcasecmp(argv, facility_str[MY])) { + facility = MY; + } + } +} + +bool parse_param(int args, char* argv[]) +{ + bool bret = false; + Fac facility = NONE; + int error_code = -1; + int argument = -1; + + if (1 < args && 5 >= args) { + parse_facility(argv[1], facility); + if (NONE == facility) { + parse_error_code(argv[1], error_code); + } else if (2 < args) { + parse_error_code(argv[2], error_code); + } + + extern char* optarg; + extern int opterr; + + opterr = 0; // getpot_long will not print error messages + int option_index = 0; + static struct option long_options[] = { + {"help", 0, 0, 'h'}, {"version", 0, 0, 'V'}, {"argument", 1, 0, 'a'}, {0, 0, 0, 0}}; + + int c = getopt_long(args, argv, ":hVa:", long_options, &option_index); + if (-1 != c) { + switch (c) { + case 'h': { + print_help(); + bret = true; + break; + } + case 'V': { + print_version(); + bret = true; + break; + } + case 'a': { + if (ORA == facility && ORACLE_SPECIAL_ERROR_CODE == error_code) { + parse_error_code(optarg, argument); + if (-1 == argument) { + printf("error: '-a ARG': ARG should be a number\n" + "Use 'ob_error --help' for help.\n"); + bret = true; + } + } else { + printf("error: '-a ARG' is unsupport in this scene\n" + "Use 'ob_error ora 600 -a ARG'.\n" + "Use 'ob_error --help' for help.\n"); + bret = true; + } + break; + } + case ':': { + printf("error: '-a' missing parameter\n" + "Use 'ob_error --help' for help.\n"); + bret = true; + break; + } + default: { + printf("error: parameters invalid\n" + "Use 'ob_error --help' for help.\n"); + bret = true; + break; + } + } + } + + if (!bret) { + if (-1 == error_code) { + printf("error: 'facility' invalid or 'error_code' may overflow or not be a positive number\n" + "Use 'ob_error --help' for help.\n"); + bret = true; + } else { + bret = print_error_info(facility, error_code, argument); + } + } + } + + return bret; +} + +static bool insert_oracle_error_slot_ora(int err_map[][OB_MAX_SAME_ERROR_COUNT], int error_code, int ob_error) +{ + bool bret = true; + int k = 0; + if (0 > error_code || ORACLE_MAX_ERROR_CODE < error_code) { + ERROR_PRINT("error: error_code invalid.\n"); + bret = false; + } else { + for (k = 0; k < OB_MAX_SAME_ERROR_COUNT; k++) { + if (-1 == err_map[error_code][k]) { + if (ORACLE_SPECIAL_ERROR_CODE == error_code) { + // Compatible error for ORA-00600 + if (OB_AUTOINC_SERVICE_BUSY == -ob_error || OB_ROWID_TYPE_MISMATCH == -ob_error || + OB_ROWID_NUM_MISMATCH == -ob_error) { + err_map[error_code][k] = ob_error; + } + } else { + err_map[error_code][k] = ob_error; + } + break; + } + } + if (OB_MAX_SAME_ERROR_COUNT <= k) { + bret = false; + } + } + return bret; +} +static bool insert_oracle_error_slot_pls(int err_map[][OB_MAX_SAME_ERROR_COUNT], int error_code, int ob_error) +{ + bool bret = true; + int k = 0; + if (0 > error_code || ORACLE_MAX_ERROR_CODE < error_code) { + ERROR_PRINT("error: error_code invalid.\n"); + bret = false; + } else { + for (k = 0; k < OB_MAX_SAME_ERROR_COUNT; k++) { + if (-1 == err_map[error_code][k]) { + err_map[error_code][k] = ob_error; + break; + } + } + if (OB_MAX_SAME_ERROR_COUNT <= k) { + bret = false; + } + } + return bret; +} +static bool insert_mysql_error_slot(int err_map[][OB_MAX_SAME_ERROR_COUNT], int error_code, int ob_error) +{ + bool bret = true; + int k = 0; + if (0 > error_code || OB_MAX_ERROR_CODE < error_code) { + ERROR_PRINT("error: error_code invalid.\n"); + bret = false; + } else { + for (k = 0; k < OB_MAX_SAME_ERROR_COUNT; k++) { + if (-1 == err_map[error_code][k]) { + err_map[error_code][k] = ob_error; + break; + } + } + if (OB_MAX_SAME_ERROR_COUNT <= k) { + bret = false; + } + } + return bret; +} +static bool insert_os_error_slot(int err_map[][OS_MAX_SAME_ERROR_COUNT], int error_code, int ob_error) +{ + bool bret = true; + int k = 0; + if (0 > error_code || OS_MAX_ERROR_CODE < error_code) { + ERROR_PRINT("error: error_code invalid.\n"); + bret = false; + } else { + for (k = 0; k < OS_MAX_SAME_ERROR_COUNT; k++) { + if (-1 == err_map[error_code][k]) { + err_map[error_code][k] = ob_error; + break; + } + } + if (OS_MAX_SAME_ERROR_COUNT <= k) { + bret = false; + } + } + return bret; +} +static bool ob_init_error_to_oberror(int ora_err[][OB_MAX_SAME_ERROR_COUNT], int pls_err[][OB_MAX_SAME_ERROR_COUNT], + int mysql_err[][OB_MAX_SAME_ERROR_COUNT], int os_err[][OS_MAX_SAME_ERROR_COUNT]) +{ + bool bret = true; + int error_code = -1; + int k = 0; + // init os_err map + for (int i = 0; i < OS_MAX_ERROR_CODE; i++) { + error_code = os_errno(-i); + if (-1 != error_code && 0 != error_code) { + if (!insert_os_error_slot(os_err, error_code, i)) { + bret = false; + ERROR_PRINT("error: OS_MAX_SAME_ERROR_COUNT is not enough for OS Error %d(OB Error %d)\n", error_code, i); + } + } + } + // init mysql_err/ora_err/pls_err map + for (int i = 0; i < OB_MAX_ERROR_CODE; i++) { + // init mysql_err map + error_code = ob_mysql_errno(-i); + if (-1 != error_code && 0 != error_code) { + if (0 > error_code) + error_code = -error_code; + if (!insert_mysql_error_slot(mysql_err, error_code, i)) { + ERROR_PRINT("error: OB_MAX_SAME_ERROR_COUNT is not enough for Error %d(OB Error %d)\n", error_code, i); + bret = false; + } + } + // init ora_err/pls_err map + const char* error_usr_msg = ob_oracle_str_user_error(-i); + error_code = ob_oracle_errno(-i); + if (-1 != error_code && NULL != error_usr_msg) { + if (0 > error_code) + error_code = -error_code; + if (0 == strncmp(error_usr_msg, facility_str[ORA], strlen(facility_str[ORA]))) { + if (!insert_oracle_error_slot_ora(ora_err, error_code, i)) { + ERROR_PRINT("error: OB_MAX_SAME_ERROR_COUNT is not enough for ORA-%05d(OB Error %d)\n", error_code, i); + bret = false; + } + } else if (0 == strncmp(error_usr_msg, facility_str[PLS], strlen(facility_str[PLS]))) { + if (!insert_oracle_error_slot_pls(pls_err, error_code, i)) { + ERROR_PRINT("error: OB_MAX_SAME_ERROR_COUNT is not enough for PLS-%05d(OB Error %d)\n", error_code, i); + bret = false; + } + } + } + } + return bret; +} + +bool init_global_info() +{ + memset(g_oracle_ora, -1, sizeof(g_oracle_ora)); + memset(g_oracle_pls, -1, sizeof(g_oracle_pls)); + memset(g_mysql_error, -1, sizeof(g_mysql_error)); + memset(g_os_error, -1, sizeof(g_os_error)); + + return ob_init_error_to_oberror(g_oracle_ora, g_oracle_pls, g_mysql_error, g_os_error); +} + +int main(int args, char* argv[]) +{ + if (!init_global_info()) { + printf("\nerror: ob_error init failed.\n"); + } else if (1 < args) { + if (!parse_param(args, argv)) { + printf("error: parameters invalid\n" + "Use 'ob_error --help' for help.\n"); + } + } else { + printf("error: missing parameter\n" + "Use 'ob_error --help' for help.\n"); + } + + return 0; +} \ No newline at end of file diff --git a/tools/ob_error/src/ob_error.h b/tools/ob_error/src/ob_error.h new file mode 100644 index 000000000..e10d1cdc7 --- /dev/null +++ b/tools/ob_error/src/ob_error.h @@ -0,0 +1,256 @@ +/** + * 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. + */ + +#ifndef OBERROR_ERROR_H +#define OBERROR_ERROR_H + +#include "share/ob_errno.h" +#include "os_errno.h" +#include +#include +using namespace oceanbase::common; + +// code error print define +#define ERROR_PRINT(fmt, ...) printf("%s[%d]-<%s>: " #fmt, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__) + +enum Fac { + ORA, // oracle mode // ora + PLS, // oracle mode // pls + MY, // mysql mode + NONE +}; + +struct OSErrorInfo { +public: + OSErrorInfo() : error_name_(nullptr), error_msg_(nullptr), error_code_(-1) + {} + virtual ~OSErrorInfo() + {} + void free_space() + { + if (nullptr != error_name_) { + free(error_name_); + error_name_ = nullptr; + } + if (nullptr != error_msg_) { + free(error_msg_); + error_msg_ = nullptr; + } + } + + char* error_name_; + char* error_msg_; + int error_code_; +}; + +struct MySQLErrorInfo { +public: + MySQLErrorInfo() + : error_name_(nullptr), + error_msg_(nullptr), + mysql_errno_(-1), + sqlstate_(nullptr), + cause_(nullptr), + solution_(nullptr), + ob_error_(-1) + {} + virtual ~MySQLErrorInfo() + {} + void free_space() + { + if (nullptr != error_name_) { + free(error_name_); + error_name_ = nullptr; + } + if (nullptr != error_msg_) { + free(error_msg_); + error_msg_ = nullptr; + } + if (nullptr != sqlstate_) { + free(sqlstate_); + sqlstate_ = nullptr; + } + if (nullptr != cause_) { + free(cause_); + cause_ = nullptr; + } + if (nullptr != solution_) { + free(solution_); + solution_ = nullptr; + } + } + + char* error_name_; + char* error_msg_; + int mysql_errno_; + char* sqlstate_; + char* cause_; + char* solution_; + int ob_error_; +}; + +struct OracleErrorInfo { +public: + OracleErrorInfo() + : error_name_(nullptr), + error_msg_(nullptr), + cause_(nullptr), + solution_(nullptr), + facility_(NONE), + error_code_(-1), + ob_error_(-1) + {} + virtual ~OracleErrorInfo() + {} + void free_space() + { + if (nullptr != error_name_) { + free(error_name_); + error_name_ = nullptr; + } + if (nullptr != error_msg_) { + free(error_msg_); + error_msg_ = nullptr; + } + if (nullptr != cause_) { + free(cause_); + cause_ = nullptr; + } + if (nullptr != solution_) { + free(solution_); + solution_ = nullptr; + } + } + + char* error_name_; + char* error_msg_; + char* cause_; + char* solution_; + Fac facility_; + int error_code_; + int ob_error_; +}; + +struct OBErrorInfo { +public: + OBErrorInfo() : error_name_(nullptr), error_msg_(nullptr), cause_(nullptr), solution_(nullptr), error_code_(-1) + {} + virtual ~OBErrorInfo() + {} + void free_space() + { + if (nullptr != error_name_) { + free(error_name_); + error_name_ = nullptr; + } + if (nullptr != error_msg_) { + free(error_msg_); + error_msg_ = nullptr; + } + if (nullptr != cause_) { + free(cause_); + cause_ = nullptr; + } + if (nullptr != solution_) { + free(solution_); + solution_ = nullptr; + } + } + + char* error_name_; + char* error_msg_; + char* cause_; + char* solution_; + int error_code_; +}; + +// The length of the second dimension, in order to solve the conflict of multiple identical error codes +constexpr int OB_MAX_SAME_ERROR_COUNT = 10; +constexpr int ORACLE_SPECIAL_ERROR_CODE = 600; +constexpr int ORACLE_MAX_ERROR_CODE = 65535; +constexpr int ORACLE_MSG_PREFIX = 11; // strlen("ORA-00000: ") +constexpr float OB_ERROR_VERSION = 1.0; + +static const char* facility_str[NONE] = {"ORA", "PLS", "MY"}; + +class ObErrorInfoMgr { +public: + ObErrorInfoMgr(); + virtual ~ObErrorInfoMgr(); + + bool insert_os_error(const char* name, const char* msg, int error_code); + void print_os_error(); + bool is_os_error_exist() + { + return 0 < os_error_count_; + } + + bool insert_mysql_error(const char* name, const char* msg, int mysql_errno, const char* sqlstate, const char* cause, + const char* solution, int ob_error); + void print_mysql_error(); + bool is_mysql_error_exist() + { + return 0 < mysql_error_count_; + } + + bool insert_oracle_error(const char* name, const char* msg, const char* cause, const char* solution, Fac facility, + int error_code, int ob_error); + void print_oracle_error(); + bool is_oracle_error_exist() + { + return 0 < oracle_error_count_; + } + + bool insert_ob_error(const char* name, const char* msg, const char* cause, const char* solution, int error_code); + void print_ob_error(); + bool is_ob_error_exist() + { + return 0 < ob_error_count_; + } + +private: + int os_error_count_; + OSErrorInfo os_error_[OS_MAX_SAME_ERROR_COUNT]; + int mysql_error_count_; + MySQLErrorInfo mysql_error_[OB_MAX_SAME_ERROR_COUNT]; + int oracle_error_count_; + OracleErrorInfo oracle_error_[OB_MAX_SAME_ERROR_COUNT]; + int ob_error_count_; + OBErrorInfo ob_error_[OB_MAX_SAME_ERROR_COUNT]; +}; + +// oracle error code -> ob error map // Maximum number of identical error codes is OB_MAX_SAME_ERROR_COUNT +static int g_oracle_ora[ORACLE_MAX_ERROR_CODE][OB_MAX_SAME_ERROR_COUNT]; +static int g_oracle_pls[ORACLE_MAX_ERROR_CODE][OB_MAX_SAME_ERROR_COUNT]; +// mysql error code -> ob error map // Maximum number of identical error codes is OB_MAX_SAME_ERROR_COUNT +static int g_mysql_error[OB_MAX_ERROR_CODE][OB_MAX_SAME_ERROR_COUNT]; +// os error code -> ob error map // Maximum number of identical error codes is OS_MAX_SAME_ERROR_COUNT +static int g_os_error[OS_MAX_ERROR_CODE][OS_MAX_SAME_ERROR_COUNT]; + +// adder +bool add_os_info(int error_code, ObErrorInfoMgr* mgr); +bool add_ob_info(int error_code, ObErrorInfoMgr* mgr); +bool add_oracle_info(Fac oracle_facility, int error_code, int argument, ObErrorInfoMgr* mgr); +bool add_mysql_info(int error_code, ObErrorInfoMgr* mgr); + +// parser +void parse_error_code(const char* argv, int& error_code); +void parse_facility(const char* argv, Fac& facility); +bool parse_param(int args, char* argv[]); + +// printer +bool print_error_info(Fac facility, int error_code, int argument); + +// init +bool init_global_info(); + +#endif /* OBERROR_ERROR_H */ diff --git a/tools/ob_error/src/os_errno.cpp b/tools/ob_error/src/os_errno.cpp new file mode 100644 index 000000000..21f077551 --- /dev/null +++ b/tools/ob_error/src/os_errno.cpp @@ -0,0 +1,464 @@ +/** + * 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. + */ + +// DO NOT EDIT. This file is automatically generated from `ob_errno.def'. + +#include "os_errno.h" +#include +#include +using namespace oceanbase::common; + +static const char* OS_ERRNO_NAME[OS_MAX_ERROR_CODE]; +static const char* OS_ERRNO_MSG[OS_MAX_ERROR_CODE]; +static int OS_ERRNO[OS_MAX_ERROR_CODE]; + +static struct OSStrErrorInit { + OSStrErrorInit() + { + memset(OS_ERRNO_NAME, 0, sizeof(OS_ERRNO_NAME)); + memset(OS_ERRNO_MSG, 0, sizeof(OS_ERRNO_MSG)); + memset(OS_ERRNO, 0, sizeof(OS_ERRNO)); + + OS_ERRNO_NAME[-OS_ENOENT] = "OS_ENOENT"; + OS_ERRNO_MSG[-OS_ENOENT] = "No such file or directory"; + OS_ERRNO[-OS_ENOENT] = 2; + OS_ERRNO_NAME[-OS_ESRCH] = "OS_ESRCH"; + OS_ERRNO_MSG[-OS_ESRCH] = "No such process"; + OS_ERRNO[-OS_ESRCH] = 3; + OS_ERRNO_NAME[-OS_EINTR] = "OS_EINTR"; + OS_ERRNO_MSG[-OS_EINTR] = "Interrupted system call"; + OS_ERRNO[-OS_EINTR] = 4; + OS_ERRNO_NAME[-OS_EIO] = "OS_EIO"; + OS_ERRNO_MSG[-OS_EIO] = "I/O error"; + OS_ERRNO[-OS_EIO] = 5; + OS_ERRNO_NAME[-OS_ENXIO] = "OS_ENXIO"; + OS_ERRNO_MSG[-OS_ENXIO] = "No such device or address"; + OS_ERRNO[-OS_ENXIO] = 6; + OS_ERRNO_NAME[-OS_E2BIG] = "OS_E2BIG"; + OS_ERRNO_MSG[-OS_E2BIG] = "Argument list too long"; + OS_ERRNO[-OS_E2BIG] = 7; + OS_ERRNO_NAME[-OS_ENOEXEC] = "OS_ENOEXEC"; + OS_ERRNO_MSG[-OS_ENOEXEC] = "Exec format error"; + OS_ERRNO[-OS_ENOEXEC] = 8; + OS_ERRNO_NAME[-OS_EBADF] = "OS_EBADF"; + OS_ERRNO_MSG[-OS_EBADF] = "Bad file number"; + OS_ERRNO[-OS_EBADF] = 9; + OS_ERRNO_NAME[-OS_ECHILD] = "OS_ECHILD"; + OS_ERRNO_MSG[-OS_ECHILD] = "No child processes"; + OS_ERRNO[-OS_ECHILD] = 10; + OS_ERRNO_NAME[-OS_EAGAIN] = "OS_EAGAIN"; + OS_ERRNO_MSG[-OS_EAGAIN] = "Try again"; + OS_ERRNO[-OS_EAGAIN] = 11; + OS_ERRNO_NAME[-OS_ENOMEM] = "OS_ENOMEM"; + OS_ERRNO_MSG[-OS_ENOMEM] = "Out of memory"; + OS_ERRNO[-OS_ENOMEM] = 12; + OS_ERRNO_NAME[-OS_EACCES] = "OS_EACCES"; + OS_ERRNO_MSG[-OS_EACCES] = "Permission denied"; + OS_ERRNO[-OS_EACCES] = 13; + OS_ERRNO_NAME[-OS_EFAULT] = "OS_EFAULT"; + OS_ERRNO_MSG[-OS_EFAULT] = "Bad address"; + OS_ERRNO[-OS_EFAULT] = 14; + OS_ERRNO_NAME[-OS_ENOTBLK] = "OS_ENOTBLK"; + OS_ERRNO_MSG[-OS_ENOTBLK] = "Block device required"; + OS_ERRNO[-OS_ENOTBLK] = 15; + OS_ERRNO_NAME[-OS_EBUSY] = "OS_EBUSY"; + OS_ERRNO_MSG[-OS_EBUSY] = "Device or resource busy"; + OS_ERRNO[-OS_EBUSY] = 16; + OS_ERRNO_NAME[-OS_EEXIST] = "OS_EEXIST"; + OS_ERRNO_MSG[-OS_EEXIST] = "File exists"; + OS_ERRNO[-OS_EEXIST] = 17; + OS_ERRNO_NAME[-OS_EXDEV] = "OS_EXDEV"; + OS_ERRNO_MSG[-OS_EXDEV] = "Cross-device link"; + OS_ERRNO[-OS_EXDEV] = 18; + OS_ERRNO_NAME[-OS_ENODEV] = "OS_ENODEV"; + OS_ERRNO_MSG[-OS_ENODEV] = "No such device"; + OS_ERRNO[-OS_ENODEV] = 19; + OS_ERRNO_NAME[-OS_ENOTDIR] = "OS_ENOTDIR"; + OS_ERRNO_MSG[-OS_ENOTDIR] = "Not a directory"; + OS_ERRNO[-OS_ENOTDIR] = 20; + OS_ERRNO_NAME[-OS_EISDIR] = "OS_EISDIR"; + OS_ERRNO_MSG[-OS_EISDIR] = "Is a directory"; + OS_ERRNO[-OS_EISDIR] = 21; + OS_ERRNO_NAME[-OS_EINVAL] = "OS_EINVAL"; + OS_ERRNO_MSG[-OS_EINVAL] = "Invalid argument"; + OS_ERRNO[-OS_EINVAL] = 22; + OS_ERRNO_NAME[-OS_ENFILE] = "OS_ENFILE"; + OS_ERRNO_MSG[-OS_ENFILE] = "File table overflow"; + OS_ERRNO[-OS_ENFILE] = 23; + OS_ERRNO_NAME[-OS_EMFILE] = "OS_EMFILE"; + OS_ERRNO_MSG[-OS_EMFILE] = "Too many open files"; + OS_ERRNO[-OS_EMFILE] = 24; + OS_ERRNO_NAME[-OS_ENOTTY] = "OS_ENOTTY"; + OS_ERRNO_MSG[-OS_ENOTTY] = "Not a typewriter"; + OS_ERRNO[-OS_ENOTTY] = 25; + OS_ERRNO_NAME[-OS_ETXTBSY] = "OS_ETXTBSY"; + OS_ERRNO_MSG[-OS_ETXTBSY] = "Text file busy"; + OS_ERRNO[-OS_ETXTBSY] = 26; + OS_ERRNO_NAME[-OS_EFBIG] = "OS_EFBIG"; + OS_ERRNO_MSG[-OS_EFBIG] = "File too large"; + OS_ERRNO[-OS_EFBIG] = 27; + OS_ERRNO_NAME[-OS_ENOSPC] = "OS_ENOSPC"; + OS_ERRNO_MSG[-OS_ENOSPC] = "No space left on device"; + OS_ERRNO[-OS_ENOSPC] = 28; + OS_ERRNO_NAME[-OS_ESPIPE] = "OS_ESPIPE"; + OS_ERRNO_MSG[-OS_ESPIPE] = "Illegal seek"; + OS_ERRNO[-OS_ESPIPE] = 29; + OS_ERRNO_NAME[-OS_EROFS] = "OS_EROFS"; + OS_ERRNO_MSG[-OS_EROFS] = "Read-only file system"; + OS_ERRNO[-OS_EROFS] = 30; + OS_ERRNO_NAME[-OS_EMLINK] = "OS_EMLINK"; + OS_ERRNO_MSG[-OS_EMLINK] = "Too many links"; + OS_ERRNO[-OS_EMLINK] = 31; + OS_ERRNO_NAME[-OS_EPIPE] = "OS_EPIPE"; + OS_ERRNO_MSG[-OS_EPIPE] = "Broken pipe"; + OS_ERRNO[-OS_EPIPE] = 32; + OS_ERRNO_NAME[-OS_EDOM] = "OS_EDOM"; + OS_ERRNO_MSG[-OS_EDOM] = "Math argument out of domain of func"; + OS_ERRNO[-OS_EDOM] = 33; + OS_ERRNO_NAME[-OS_ERANGE] = "OS_ERANGE"; + OS_ERRNO_MSG[-OS_ERANGE] = "Math result not representable"; + OS_ERRNO[-OS_ERANGE] = 34; + OS_ERRNO_NAME[-OS_EDEADLK] = "OS_EDEADLK"; + OS_ERRNO_MSG[-OS_EDEADLK] = "Resource deadlock would occur"; + OS_ERRNO[-OS_EDEADLK] = 35; + OS_ERRNO_NAME[-OS_ENAMETOOLONG] = "OS_ENAMETOOLONG"; + OS_ERRNO_MSG[-OS_ENAMETOOLONG] = "File name too long"; + OS_ERRNO[-OS_ENAMETOOLONG] = 36; + OS_ERRNO_NAME[-OS_ENOLCK] = "OS_ENOLCK"; + OS_ERRNO_MSG[-OS_ENOLCK] = "No record locks available"; + OS_ERRNO[-OS_ENOLCK] = 37; + OS_ERRNO_NAME[-OS_ENOSYS] = "OS_ENOSYS"; + OS_ERRNO_MSG[-OS_ENOSYS] = "Function not implemented"; + OS_ERRNO[-OS_ENOSYS] = 38; + OS_ERRNO_NAME[-OS_ENOTEMPTY] = "OS_ENOTEMPTY"; + OS_ERRNO_MSG[-OS_ENOTEMPTY] = "Directory not empty"; + OS_ERRNO[-OS_ENOTEMPTY] = 39; + OS_ERRNO_NAME[-OS_ELOOP] = "OS_ELOOP"; + OS_ERRNO_MSG[-OS_ELOOP] = "Too many symbolic links encountered"; + OS_ERRNO[-OS_ELOOP] = 40; + OS_ERRNO_NAME[-OS_EWOULDBLOCK] = "OS_EWOULDBLOCK"; + OS_ERRNO_MSG[-OS_EWOULDBLOCK] = "Operation would block"; + OS_ERRNO[-OS_EWOULDBLOCK] = 11; + OS_ERRNO_NAME[-OS_ENOMSG] = "OS_ENOMSG"; + OS_ERRNO_MSG[-OS_ENOMSG] = "No message of desired type"; + OS_ERRNO[-OS_ENOMSG] = 42; + OS_ERRNO_NAME[-OS_EIDRM] = "OS_EIDRM"; + OS_ERRNO_MSG[-OS_EIDRM] = "Identifier removed"; + OS_ERRNO[-OS_EIDRM] = 43; + OS_ERRNO_NAME[-OS_ECHRNG] = "OS_ECHRNG"; + OS_ERRNO_MSG[-OS_ECHRNG] = "Channel number out of range"; + OS_ERRNO[-OS_ECHRNG] = 44; + OS_ERRNO_NAME[-OS_EL2NSYNC] = "OS_EL2NSYNC"; + OS_ERRNO_MSG[-OS_EL2NSYNC] = "Level 2 not synchronized"; + OS_ERRNO[-OS_EL2NSYNC] = 45; + OS_ERRNO_NAME[-OS_EL3HLT] = "OS_EL3HLT"; + OS_ERRNO_MSG[-OS_EL3HLT] = "Level 3 halted"; + OS_ERRNO[-OS_EL3HLT] = 46; + OS_ERRNO_NAME[-OS_EL3RST] = "OS_EL3RST"; + OS_ERRNO_MSG[-OS_EL3RST] = "Level 3 reset"; + OS_ERRNO[-OS_EL3RST] = 47; + OS_ERRNO_NAME[-OS_ELNRNG] = "OS_ELNRNG"; + OS_ERRNO_MSG[-OS_ELNRNG] = "Link number out of range"; + OS_ERRNO[-OS_ELNRNG] = 48; + OS_ERRNO_NAME[-OS_EUNATCH] = "OS_EUNATCH"; + OS_ERRNO_MSG[-OS_EUNATCH] = "Protocol driver not attached"; + OS_ERRNO[-OS_EUNATCH] = 49; + OS_ERRNO_NAME[-OS_ENOCSI] = "OS_ENOCSI"; + OS_ERRNO_MSG[-OS_ENOCSI] = "No CSI structure available"; + OS_ERRNO[-OS_ENOCSI] = 50; + OS_ERRNO_NAME[-OS_EL2HLT] = "OS_EL2HLT"; + OS_ERRNO_MSG[-OS_EL2HLT] = "Level 2 halted"; + OS_ERRNO[-OS_EL2HLT] = 51; + OS_ERRNO_NAME[-OS_EBADE] = "OS_EBADE"; + OS_ERRNO_MSG[-OS_EBADE] = "Invalid exchange"; + OS_ERRNO[-OS_EBADE] = 52; + OS_ERRNO_NAME[-OS_EBADR] = "OS_EBADR"; + OS_ERRNO_MSG[-OS_EBADR] = "Invalid request descriptor"; + OS_ERRNO[-OS_EBADR] = 53; + OS_ERRNO_NAME[-OS_EXFULL] = "OS_EXFULL"; + OS_ERRNO_MSG[-OS_EXFULL] = "Exchange full"; + OS_ERRNO[-OS_EXFULL] = 54; + OS_ERRNO_NAME[-OS_ENOANO] = "OS_ENOANO"; + OS_ERRNO_MSG[-OS_ENOANO] = "No anode"; + OS_ERRNO[-OS_ENOANO] = 55; + OS_ERRNO_NAME[-OS_EBADRQC] = "OS_EBADRQC"; + OS_ERRNO_MSG[-OS_EBADRQC] = "Invalid request code"; + OS_ERRNO[-OS_EBADRQC] = 56; + OS_ERRNO_NAME[-OS_EBADSLT] = "OS_EBADSLT"; + OS_ERRNO_MSG[-OS_EBADSLT] = "Invalid slot"; + OS_ERRNO[-OS_EBADSLT] = 57; + OS_ERRNO_NAME[-OS_EBFONT] = "OS_EBFONT"; + OS_ERRNO_MSG[-OS_EBFONT] = "Bad font file format"; + OS_ERRNO[-OS_EBFONT] = 59; + OS_ERRNO_NAME[-OS_ENOSTR] = "OS_ENOSTR"; + OS_ERRNO_MSG[-OS_ENOSTR] = "Device not a stream"; + OS_ERRNO[-OS_ENOSTR] = 60; + OS_ERRNO_NAME[-OS_ENODATA] = "OS_ENODATA"; + OS_ERRNO_MSG[-OS_ENODATA] = "No data available"; + OS_ERRNO[-OS_ENODATA] = 61; + OS_ERRNO_NAME[-OS_ETIME] = "OS_ETIME"; + OS_ERRNO_MSG[-OS_ETIME] = "Timer expired"; + OS_ERRNO[-OS_ETIME] = 62; + OS_ERRNO_NAME[-OS_ENOSR] = "OS_ENOSR"; + OS_ERRNO_MSG[-OS_ENOSR] = "OOut of streams resources"; + OS_ERRNO[-OS_ENOSR] = 63; + OS_ERRNO_NAME[-OS_ENONET] = "OS_ENONET"; + OS_ERRNO_MSG[-OS_ENONET] = "Machine is not on the network"; + OS_ERRNO[-OS_ENONET] = 64; + OS_ERRNO_NAME[-OS_ENOPKG] = "OS_ENOPKG"; + OS_ERRNO_MSG[-OS_ENOPKG] = "Package not installed"; + OS_ERRNO[-OS_ENOPKG] = 65; + OS_ERRNO_NAME[-OS_EREMOTE] = "OS_EREMOTE"; + OS_ERRNO_MSG[-OS_EREMOTE] = "Object is remote"; + OS_ERRNO[-OS_EREMOTE] = 66; + OS_ERRNO_NAME[-OS_ENOLINK] = "OS_ENOLINK"; + OS_ERRNO_MSG[-OS_ENOLINK] = "Link has been severed"; + OS_ERRNO[-OS_ENOLINK] = 67; + OS_ERRNO_NAME[-OS_EADV] = "OS_EADV"; + OS_ERRNO_MSG[-OS_EADV] = "Advertise error"; + OS_ERRNO[-OS_EADV] = 68; + OS_ERRNO_NAME[-OS_ESRMNT] = "OS_ESRMNT"; + OS_ERRNO_MSG[-OS_ESRMNT] = "Srmount error"; + OS_ERRNO[-OS_ESRMNT] = 69; + OS_ERRNO_NAME[-OS_ECOMM] = "OS_ECOMM"; + OS_ERRNO_MSG[-OS_ECOMM] = "Communication error on send"; + OS_ERRNO[-OS_ECOMM] = 70; + OS_ERRNO_NAME[-OS_EPROTO] = "OS_EPROTO"; + OS_ERRNO_MSG[-OS_EPROTO] = "Protocol error"; + OS_ERRNO[-OS_EPROTO] = 71; + OS_ERRNO_NAME[-OS_EMULTIHOP] = "OS_EMULTIHOP"; + OS_ERRNO_MSG[-OS_EMULTIHOP] = "Multihop attempted"; + OS_ERRNO[-OS_EMULTIHOP] = 72; + OS_ERRNO_NAME[-OS_EDOTDOT] = "OS_EDOTDOT"; + OS_ERRNO_MSG[-OS_EDOTDOT] = "RFS specific error"; + OS_ERRNO[-OS_EDOTDOT] = 73; + OS_ERRNO_NAME[-OS_EBADMSG] = "OS_EBADMSG"; + OS_ERRNO_MSG[-OS_EBADMSG] = "Not a data message"; + OS_ERRNO[-OS_EBADMSG] = 74; + OS_ERRNO_NAME[-OS_EOVERFLOW] = "OS_EOVERFLOW"; + OS_ERRNO_MSG[-OS_EOVERFLOW] = "Value too large for defined data type"; + OS_ERRNO[-OS_EOVERFLOW] = 75; + OS_ERRNO_NAME[-OS_ENOTUNIQ] = "OS_ENOTUNIQ"; + OS_ERRNO_MSG[-OS_ENOTUNIQ] = "Name not unique on network"; + OS_ERRNO[-OS_ENOTUNIQ] = 76; + OS_ERRNO_NAME[-OS_EBADFD] = "OS_EBADFD"; + OS_ERRNO_MSG[-OS_EBADFD] = "File descriptor in bad state"; + OS_ERRNO[-OS_EBADFD] = 77; + OS_ERRNO_NAME[-OS_EREMCHG] = "OS_EREMCHG"; + OS_ERRNO_MSG[-OS_EREMCHG] = "Remote address changed"; + OS_ERRNO[-OS_EREMCHG] = 78; + OS_ERRNO_NAME[-OS_ELIBACC] = "OS_ELIBACC"; + OS_ERRNO_MSG[-OS_ELIBACC] = "Can not access a needed shared library"; + OS_ERRNO[-OS_ELIBACC] = 79; + OS_ERRNO_NAME[-OS_ELIBBAD] = "OS_ELIBBAD"; + OS_ERRNO_MSG[-OS_ELIBBAD] = "Accessing a corrupted shared library"; + OS_ERRNO[-OS_ELIBBAD] = 80; + OS_ERRNO_NAME[-OS_ELIBSCN] = "OS_ELIBSCN"; + OS_ERRNO_MSG[-OS_ELIBSCN] = ".lib section in a.out corrupted"; + OS_ERRNO[-OS_ELIBSCN] = 81; + OS_ERRNO_NAME[-OS_ELIBMAX] = "OS_ELIBMAX"; + OS_ERRNO_MSG[-OS_ELIBMAX] = "Attempting to link in too many shared libraries"; + OS_ERRNO[-OS_ELIBMAX] = 82; + OS_ERRNO_NAME[-OS_ELIBEXEC] = "OS_ELIBEXEC"; + OS_ERRNO_MSG[-OS_ELIBEXEC] = "Cannot exec a shared library directly"; + OS_ERRNO[-OS_ELIBEXEC] = 83; + OS_ERRNO_NAME[-OS_EILSEQ] = "OS_EILSEQ"; + OS_ERRNO_MSG[-OS_EILSEQ] = "Illegal byte sequence"; + OS_ERRNO[-OS_EILSEQ] = 84; + OS_ERRNO_NAME[-OS_ERESTART] = "OS_ERESTART"; + OS_ERRNO_MSG[-OS_ERESTART] = "Interrupted system call should be restarted"; + OS_ERRNO[-OS_ERESTART] = 85; + OS_ERRNO_NAME[-OS_ESTRPIPE] = "OS_ESTRPIPE"; + OS_ERRNO_MSG[-OS_ESTRPIPE] = "Streams pipe error"; + OS_ERRNO[-OS_ESTRPIPE] = 86; + OS_ERRNO_NAME[-OS_EUSERS] = "OS_EUSERS"; + OS_ERRNO_MSG[-OS_EUSERS] = "Too many users"; + OS_ERRNO[-OS_EUSERS] = 87; + OS_ERRNO_NAME[-OS_ENOTSOCK] = "OS_ENOTSOCK"; + OS_ERRNO_MSG[-OS_ENOTSOCK] = "Socket operation on non-socket"; + OS_ERRNO[-OS_ENOTSOCK] = 88; + OS_ERRNO_NAME[-OS_EDESTADDRREQ] = "OS_EDESTADDRREQ"; + OS_ERRNO_MSG[-OS_EDESTADDRREQ] = "Destination address required"; + OS_ERRNO[-OS_EDESTADDRREQ] = 89; + OS_ERRNO_NAME[-OS_EMSGSIZE] = "OS_EMSGSIZE"; + OS_ERRNO_MSG[-OS_EMSGSIZE] = "Message too long"; + OS_ERRNO[-OS_EMSGSIZE] = 90; + OS_ERRNO_NAME[-OS_EPROTOTYPE] = "OS_EPROTOTYPE"; + OS_ERRNO_MSG[-OS_EPROTOTYPE] = "Protocol wrong type for socket"; + OS_ERRNO[-OS_EPROTOTYPE] = 91; + OS_ERRNO_NAME[-OS_ENOPROTOOPT] = "OS_ENOPROTOOPT"; + OS_ERRNO_MSG[-OS_ENOPROTOOPT] = "Protocol not available"; + OS_ERRNO[-OS_ENOPROTOOPT] = 92; + OS_ERRNO_NAME[-OS_EPROTONOSUPPORT] = "OS_EPROTONOSUPPORT"; + OS_ERRNO_MSG[-OS_EPROTONOSUPPORT] = "Protocol not supported"; + OS_ERRNO[-OS_EPROTONOSUPPORT] = 93; + OS_ERRNO_NAME[-OS_ESOCKTNOSUPPORT] = "OS_ESOCKTNOSUPPORT"; + OS_ERRNO_MSG[-OS_ESOCKTNOSUPPORT] = "Socket type not supported"; + OS_ERRNO[-OS_ESOCKTNOSUPPORT] = 94; + OS_ERRNO_NAME[-OS_EOPNOTSUPP] = "OS_EOPNOTSUPP"; + OS_ERRNO_MSG[-OS_EOPNOTSUPP] = "Operation not supported on transport endpoint"; + OS_ERRNO[-OS_EOPNOTSUPP] = 95; + OS_ERRNO_NAME[-OS_EPFNOSUPPORT] = "OS_EPFNOSUPPORT"; + OS_ERRNO_MSG[-OS_EPFNOSUPPORT] = "Protocol family not supported"; + OS_ERRNO[-OS_EPFNOSUPPORT] = 96; + OS_ERRNO_NAME[-OS_EAFNOSUPPORT] = "OS_EAFNOSUPPORT"; + OS_ERRNO_MSG[-OS_EAFNOSUPPORT] = "Address family not supported by protocol"; + OS_ERRNO[-OS_EAFNOSUPPORT] = 97; + OS_ERRNO_NAME[-OS_EADDRINUSE] = "OS_EADDRINUSE"; + OS_ERRNO_MSG[-OS_EADDRINUSE] = "Address already in use"; + OS_ERRNO[-OS_EADDRINUSE] = 98; + OS_ERRNO_NAME[-OS_EADDRNOTAVAIL] = "OS_EADDRNOTAVAIL"; + OS_ERRNO_MSG[-OS_EADDRNOTAVAIL] = "Cannot assign requested address"; + OS_ERRNO[-OS_EADDRNOTAVAIL] = 99; + OS_ERRNO_NAME[-OS_ENETDOWN] = "OS_ENETDOWN"; + OS_ERRNO_MSG[-OS_ENETDOWN] = "Network is down"; + OS_ERRNO[-OS_ENETDOWN] = 100; + OS_ERRNO_NAME[-OS_ENETUNREACH] = "OS_ENETUNREACH"; + OS_ERRNO_MSG[-OS_ENETUNREACH] = "Network is unreachable"; + OS_ERRNO[-OS_ENETUNREACH] = 101; + OS_ERRNO_NAME[-OS_ENETRESET] = "OS_ENETRESET"; + OS_ERRNO_MSG[-OS_ENETRESET] = "Network dropped connection because of reset"; + OS_ERRNO[-OS_ENETRESET] = 102; + OS_ERRNO_NAME[-OS_ECONNABORTED] = "OS_ECONNABORTED"; + OS_ERRNO_MSG[-OS_ECONNABORTED] = "Software caused connection abort"; + OS_ERRNO[-OS_ECONNABORTED] = 103; + OS_ERRNO_NAME[-OS_ECONNRESET] = "OS_ECONNRESET"; + OS_ERRNO_MSG[-OS_ECONNRESET] = "Connection reset by peer"; + OS_ERRNO[-OS_ECONNRESET] = 104; + OS_ERRNO_NAME[-OS_ENOBUFS] = "OS_ENOBUFS"; + OS_ERRNO_MSG[-OS_ENOBUFS] = "No buffer space available"; + OS_ERRNO[-OS_ENOBUFS] = 105; + OS_ERRNO_NAME[-OS_EISCONN] = "OS_EISCONN"; + OS_ERRNO_MSG[-OS_EISCONN] = "Transport endpoint is already connected"; + OS_ERRNO[-OS_EISCONN] = 106; + OS_ERRNO_NAME[-OS_ENOTCONN] = "OS_ENOTCONN"; + OS_ERRNO_MSG[-OS_ENOTCONN] = "Transport endpoint is not connected"; + OS_ERRNO[-OS_ENOTCONN] = 107; + OS_ERRNO_NAME[-OS_ESHUTDOWN] = "OS_ESHUTDOWN"; + OS_ERRNO_MSG[-OS_ESHUTDOWN] = "Cannot send after transport endpoint shutdown"; + OS_ERRNO[-OS_ESHUTDOWN] = 108; + OS_ERRNO_NAME[-OS_ETOOMANYREFS] = "OS_ETOOMANYREFS"; + OS_ERRNO_MSG[-OS_ETOOMANYREFS] = "Too many references: cannot splice"; + OS_ERRNO[-OS_ETOOMANYREFS] = 109; + OS_ERRNO_NAME[-OS_ETIMEDOUT] = "OS_ETIMEDOUT"; + OS_ERRNO_MSG[-OS_ETIMEDOUT] = "Connection timed out"; + OS_ERRNO[-OS_ETIMEDOUT] = 110; + OS_ERRNO_NAME[-OS_ECONNREFUSED] = "OS_ECONNREFUSED"; + OS_ERRNO_MSG[-OS_ECONNREFUSED] = "Connection refused"; + OS_ERRNO[-OS_ECONNREFUSED] = 111; + OS_ERRNO_NAME[-OS_EHOSTDOWN] = "OS_EHOSTDOWN"; + OS_ERRNO_MSG[-OS_EHOSTDOWN] = "Host is down"; + OS_ERRNO[-OS_EHOSTDOWN] = 112; + OS_ERRNO_NAME[-OS_EHOSTUNREACH] = "OS_EHOSTUNREACH"; + OS_ERRNO_MSG[-OS_EHOSTUNREACH] = "No route to host"; + OS_ERRNO[-OS_EHOSTUNREACH] = 113; + OS_ERRNO_NAME[-OS_EALREADY] = "OS_EALREADY"; + OS_ERRNO_MSG[-OS_EALREADY] = "Operation already in progress"; + OS_ERRNO[-OS_EALREADY] = 114; + OS_ERRNO_NAME[-OS_EINPROGRESS] = "OS_EINPROGRESS"; + OS_ERRNO_MSG[-OS_EINPROGRESS] = "Operation now in progress"; + OS_ERRNO[-OS_EINPROGRESS] = 115; + OS_ERRNO_NAME[-OS_ESTALE] = "OS_ESTALE"; + OS_ERRNO_MSG[-OS_ESTALE] = "Stale file handle"; + OS_ERRNO[-OS_ESTALE] = 116; + OS_ERRNO_NAME[-OS_EUCLEAN] = "OS_EUCLEAN"; + OS_ERRNO_MSG[-OS_EUCLEAN] = "Structure needs cleaning"; + OS_ERRNO[-OS_EUCLEAN] = 117; + OS_ERRNO_NAME[-OS_ENOTNAM] = "OS_ENOTNAM"; + OS_ERRNO_MSG[-OS_ENOTNAM] = "Not a XENIX named type file"; + OS_ERRNO[-OS_ENOTNAM] = 118; + OS_ERRNO_NAME[-OS_ENAVAIL] = "OS_ENAVAIL"; + OS_ERRNO_MSG[-OS_ENAVAIL] = "No XENIX semaphores available"; + OS_ERRNO[-OS_ENAVAIL] = 119; + OS_ERRNO_NAME[-OS_EISNAM] = "OS_EISNAM"; + OS_ERRNO_MSG[-OS_EISNAM] = "Is a named type file"; + OS_ERRNO[-OS_EISNAM] = 120; + OS_ERRNO_NAME[-OS_EREMOTEIO] = "OS_EREMOTEIO"; + OS_ERRNO_MSG[-OS_EREMOTEIO] = "Remote I/O error"; + OS_ERRNO[-OS_EREMOTEIO] = 121; + OS_ERRNO_NAME[-OS_EDQUOT] = "OS_EDQUOT"; + OS_ERRNO_MSG[-OS_EDQUOT] = "Quota exceeded"; + OS_ERRNO[-OS_EDQUOT] = 122; + OS_ERRNO_NAME[-OS_ENOMEDIUM] = "OS_ENOMEDIUM"; + OS_ERRNO_MSG[-OS_ENOMEDIUM] = "No medium found"; + OS_ERRNO[-OS_ENOMEDIUM] = 123; + OS_ERRNO_NAME[-OS_EMEDIUMTYPE] = "OS_EMEDIUMTYPE"; + OS_ERRNO_MSG[-OS_EMEDIUMTYPE] = "Wrong medium type"; + OS_ERRNO[-OS_EMEDIUMTYPE] = 124; + OS_ERRNO_NAME[-OS_ECANCELED] = "OS_ECANCELED"; + OS_ERRNO_MSG[-OS_ECANCELED] = "Operation Canceled"; + OS_ERRNO[-OS_ECANCELED] = 125; + OS_ERRNO_NAME[-OS_ENOKEY] = "OS_ENOKEY"; + OS_ERRNO_MSG[-OS_ENOKEY] = "Required key not available"; + OS_ERRNO[-OS_ENOKEY] = 126; + OS_ERRNO_NAME[-OS_EKEYEXPIRED] = "OS_EKEYEXPIRED"; + OS_ERRNO_MSG[-OS_EKEYEXPIRED] = "Key has expired"; + OS_ERRNO[-OS_EKEYEXPIRED] = 127; + OS_ERRNO_NAME[-OS_EKEYREVOKED] = "OS_EKEYREVOKED"; + OS_ERRNO_MSG[-OS_EKEYREVOKED] = "Key has been revoked"; + OS_ERRNO[-OS_EKEYREVOKED] = 128; + OS_ERRNO_NAME[-OS_EKEYREJECTED] = "OS_EKEYREJECTED"; + OS_ERRNO_MSG[-OS_EKEYREJECTED] = "Key was rejected by service"; + OS_ERRNO[-OS_EKEYREJECTED] = 129; + OS_ERRNO_NAME[-OS_EOWNERDEAD] = "OS_EOWNERDEAD"; + OS_ERRNO_MSG[-OS_EOWNERDEAD] = "Owner died"; + OS_ERRNO[-OS_EOWNERDEAD] = 130; + OS_ERRNO_NAME[-OS_ENOTRECOVERABLE] = "OS_ENOTRECOVERABLE"; + OS_ERRNO_MSG[-OS_ENOTRECOVERABLE] = "State not recoverable"; + OS_ERRNO[-OS_ENOTRECOVERABLE] = 131; + OS_ERRNO_NAME[-OS_ERFKILL] = "OS_ERFKILL"; + OS_ERRNO_MSG[-OS_ERFKILL] = "Operation not possible due to RF-kill"; + OS_ERRNO[-OS_ERFKILL] = 132; + OS_ERRNO_NAME[-OS_EHWPOISON] = "OS_EHWPOISON"; + OS_ERRNO_MSG[-OS_EHWPOISON] = "Memory page has hardware error"; + OS_ERRNO[-OS_EHWPOISON] = 133; + } +} local_init; + +namespace oceanbase { +namespace common { +const char* str_os_error_name(const int err) +{ + const char* ret = "Unknown error"; + if (0 == err) { + ret = "OB_SUCCESS"; + } else if (0 > err && err > -OS_MAX_ERROR_CODE) { + ret = OS_ERRNO_NAME[-err]; + if (NULL == ret || '\0' == ret[0]) { + ret = "Unknown Error"; + } + } + return ret; +} +const char* str_os_error_msg(const int err) +{ + const char* ret = NULL; + if (0 == err) { + ret = NULL; + } else if (0 > err && err > -OS_MAX_ERROR_CODE) { + ret = OS_ERRNO_MSG[-err]; + if (NULL == ret || '\0' == ret[0]) { + ret = NULL; + } + } + return ret; +} +int os_errno(const int err) +{ + int ret = -1; + if (0 >= err && err > -OS_MAX_ERROR_CODE) { + ret = OS_ERRNO[-err]; + } + return ret; +} +} // end namespace common +} // end namespace oceanbase diff --git a/tools/ob_error/src/os_errno.def b/tools/ob_error/src/os_errno.def new file mode 100644 index 000000000..55d9a1f06 --- /dev/null +++ b/tools/ob_error/src/os_errno.def @@ -0,0 +1,139 @@ +//here is os errno. +//C0: int OS_MAX_ERROR_CODE -----> ob errno +//C1: char *OS_ERROR_NAME[OS_MAX_ERROR_CODE] -----> store os errno name +//C2: int OS_ERRNO[OS_MAX_ERROR_CODE]; -----> store os errno +//C3: char *OS_ERROR_MSG[OS_MAX_ERROR_CODE]; -----> store os errno msg + +//DEFINE_OS_ERROR(C1, C0, C2, C3) +DEFINE_OS_ERROR(OS_EPERM, -1, 1 "Operation not permitted"); +DEFINE_OS_ERROR(OS_ENOENT, -2, 2, "No such file or directory"); +DEFINE_OS_ERROR(OS_ESRCH, -3, 3, "No such process"); +DEFINE_OS_ERROR(OS_EINTR, -4, 4, "Interrupted system call"); +DEFINE_OS_ERROR(OS_EIO, -5, 5, "I/O error"); +DEFINE_OS_ERROR(OS_ENXIO, -6, 6, "No such device or address"); +DEFINE_OS_ERROR(OS_E2BIG, -7, 7, "Argument list too long"); +DEFINE_OS_ERROR(OS_ENOEXEC, -8, 8, "Exec format error"); +DEFINE_OS_ERROR(OS_EBADF, -9, 9, "Bad file number"); +DEFINE_OS_ERROR(OS_ECHILD, -10, 10, "No child processes"); +DEFINE_OS_ERROR(OS_EAGAIN, -11, 11, "Try again"); +DEFINE_OS_ERROR(OS_ENOMEM, -12, 12, "Out of memory"); +DEFINE_OS_ERROR(OS_EACCES, -13, 13, "Permission denied"); +DEFINE_OS_ERROR(OS_EFAULT, -14, 14, "Bad address"); +DEFINE_OS_ERROR(OS_ENOTBLK, -15, 15, "Block device required"); +DEFINE_OS_ERROR(OS_EBUSY, -16, 16, "Device or resource busy"); +DEFINE_OS_ERROR(OS_EEXIST, -17, 17, "File exists"); +DEFINE_OS_ERROR(OS_EXDEV, -18, 18, "Cross-device link"); +DEFINE_OS_ERROR(OS_ENODEV, -19, 19, "No such device"); +DEFINE_OS_ERROR(OS_ENOTDIR, -20, 20, "Not a directory"); +DEFINE_OS_ERROR(OS_EISDIR, -21, 21, "Is a directory"); +DEFINE_OS_ERROR(OS_EINVAL, -22, 22, "Invalid argument"); +DEFINE_OS_ERROR(OS_ENFILE, -23, 23, "File table overflow"); +DEFINE_OS_ERROR(OS_EMFILE, -24, 24, "Too many open files"); +DEFINE_OS_ERROR(OS_ENOTTY, -25, 25, "Not a typewriter"); +DEFINE_OS_ERROR(OS_ETXTBSY, -26, 26, "Text file busy"); +DEFINE_OS_ERROR(OS_EFBIG, -27, 27, "File too large"); +DEFINE_OS_ERROR(OS_ENOSPC, -28, 28, "No space left on device"); +DEFINE_OS_ERROR(OS_ESPIPE, -29, 29, "Illegal seek"); +DEFINE_OS_ERROR(OS_EROFS, -30, 30, "Read-only file system"); +DEFINE_OS_ERROR(OS_EMLINK, -31, 31, "Too many links"); +DEFINE_OS_ERROR(OS_EPIPE, -32, 32, "Broken pipe"); +DEFINE_OS_ERROR(OS_EDOM, -33, 33, "Math argument out of domain of func"); +DEFINE_OS_ERROR(OS_ERANGE, -34, 34, "Math result not representable"); +DEFINE_OS_ERROR(OS_EDEADLK, -35, 35, "Resource deadlock would occur"); +DEFINE_OS_ERROR(OS_ENAMETOOLONG, -36, 36, "File name too long"); +DEFINE_OS_ERROR(OS_ENOLCK, -37, 37, "No record locks available"); +DEFINE_OS_ERROR(OS_ENOSYS, -38, 38, "Function not implemented"); +DEFINE_OS_ERROR(OS_ENOTEMPTY, -39, 39, "Directory not empty"); +DEFINE_OS_ERROR(OS_ELOOP, -40, 40, "Too many symbolic links encountered"); +DEFINE_OS_ERROR(OS_EWOULDBLOCK, -41, 11, "Operation would block"); +DEFINE_OS_ERROR(OS_ENOMSG, -42, 42, "No message of desired type"); +DEFINE_OS_ERROR(OS_EIDRM, -43, 43, "Identifier removed"); +DEFINE_OS_ERROR(OS_ECHRNG, -44, 44, "Channel number out of range"); +DEFINE_OS_ERROR(OS_EL2NSYNC, -45, 45, "Level 2 not synchronized"); +DEFINE_OS_ERROR(OS_EL3HLT, -46, 46, "Level 3 halted"); +DEFINE_OS_ERROR(OS_EL3RST, -47, 47, "Level 3 reset"); +DEFINE_OS_ERROR(OS_ELNRNG, -48, 48, "Link number out of range"); +DEFINE_OS_ERROR(OS_EUNATCH, -49, 49, "Protocol driver not attached"); +DEFINE_OS_ERROR(OS_ENOCSI, -50, 50, "No CSI structure available"); +DEFINE_OS_ERROR(OS_EL2HLT, -51, 51, "Level 2 halted"); +DEFINE_OS_ERROR(OS_EBADE, -52, 52, "Invalid exchange"); +DEFINE_OS_ERROR(OS_EBADR, -53, 53, "Invalid request descriptor"); +DEFINE_OS_ERROR(OS_EXFULL, -54, 54, "Exchange full"); +DEFINE_OS_ERROR(OS_ENOANO, -55, 55, "No anode"); +DEFINE_OS_ERROR(OS_EBADRQC, -56, 56, "Invalid request code"); +DEFINE_OS_ERROR(OS_EBADSLT, -57, 57, "Invalid slot"); +DEFINE_OS_ERROR(OS_EBFONT, -59, 59, "Bad font file format"); +DEFINE_OS_ERROR(OS_ENOSTR, -60, 60, "Device not a stream"); +DEFINE_OS_ERROR(OS_ENODATA, -61, 61, "No data available"); +DEFINE_OS_ERROR(OS_ETIME, -62, 62, "Timer expired"); +DEFINE_OS_ERROR(OS_ENOSR, -63, 63, "OOut of streams resources"); +DEFINE_OS_ERROR(OS_ENONET, -64, 64, "Machine is not on the network"); +DEFINE_OS_ERROR(OS_ENOPKG, -65, 65, "Package not installed"); +DEFINE_OS_ERROR(OS_EREMOTE, -66, 66, "Object is remote"); +DEFINE_OS_ERROR(OS_ENOLINK, -67, 67, "Link has been severed"); +DEFINE_OS_ERROR(OS_EADV, -68, 68, "Advertise error"); +DEFINE_OS_ERROR(OS_ESRMNT, -69, 69, "Srmount error"); +DEFINE_OS_ERROR(OS_ECOMM, -70, 70, "Communication error on send"); +DEFINE_OS_ERROR(OS_EPROTO, -71, 71, "Protocol error"); +DEFINE_OS_ERROR(OS_EMULTIHOP, -72, 72, "Multihop attempted"); +DEFINE_OS_ERROR(OS_EDOTDOT, -73, 73, "RFS specific error"); +DEFINE_OS_ERROR(OS_EBADMSG, -74, 74, "Not a data message"); +DEFINE_OS_ERROR(OS_EOVERFLOW, -75, 75, "Value too large for defined data type"); +DEFINE_OS_ERROR(OS_ENOTUNIQ, -76, 76, "Name not unique on network"); +DEFINE_OS_ERROR(OS_EBADFD, -77, 77, "File descriptor in bad state"); +DEFINE_OS_ERROR(OS_EREMCHG, -78, 78, "Remote address changed"); +DEFINE_OS_ERROR(OS_ELIBACC, -79, 79, "Can not access a needed shared library"); +DEFINE_OS_ERROR(OS_ELIBBAD, -80, 80, "Accessing a corrupted shared library"); +DEFINE_OS_ERROR(OS_ELIBSCN, -81, 81, ".lib section in a.out corrupted"); +DEFINE_OS_ERROR(OS_ELIBMAX, -82, 82, "Attempting to link in too many shared libraries"); +DEFINE_OS_ERROR(OS_ELIBEXEC, -83, 83, "Cannot exec a shared library directly"); +DEFINE_OS_ERROR(OS_EILSEQ, -84, 84, "Illegal byte sequence"); +DEFINE_OS_ERROR(OS_ERESTART, -85, 85, "Interrupted system call should be restarted"); +DEFINE_OS_ERROR(OS_ESTRPIPE, -86, 86, "Streams pipe error"); +DEFINE_OS_ERROR(OS_EUSERS, -87, 87, "Too many users"); +DEFINE_OS_ERROR(OS_ENOTSOCK, -88, 88, "Socket operation on non-socket"); +DEFINE_OS_ERROR(OS_EDESTADDRREQ, -89, 89, "Destination address required"); +DEFINE_OS_ERROR(OS_EMSGSIZE, -90, 90, "Message too long"); +DEFINE_OS_ERROR(OS_EPROTOTYPE, -91, 91, "Protocol wrong type for socket"); +DEFINE_OS_ERROR(OS_ENOPROTOOPT, -92, 92, "Protocol not available"); +DEFINE_OS_ERROR(OS_EPROTONOSUPPORT, -93, 93, "Protocol not supported"); +DEFINE_OS_ERROR(OS_ESOCKTNOSUPPORT, -94, 94, "Socket type not supported"); +DEFINE_OS_ERROR(OS_EOPNOTSUPP, -95, 95, "Operation not supported on transport endpoint"); +DEFINE_OS_ERROR(OS_EPFNOSUPPORT, -96, 96, "Protocol family not supported"); +DEFINE_OS_ERROR(OS_EAFNOSUPPORT, -97, 97, "Address family not supported by protocol"); +DEFINE_OS_ERROR(OS_EADDRINUSE, -98, 98, "Address already in use"); +DEFINE_OS_ERROR(OS_EADDRNOTAVAIL, -99, 99, "Cannot assign requested address"); +DEFINE_OS_ERROR(OS_ENETDOWN, -100, 100, "Network is down"); +DEFINE_OS_ERROR(OS_ENETUNREACH, -101, 101, "Network is unreachable"); +DEFINE_OS_ERROR(OS_ENETRESET, -102, 102, "Network dropped connection because of reset"); +DEFINE_OS_ERROR(OS_ECONNABORTED, -103, 103, "Software caused connection abort"); +DEFINE_OS_ERROR(OS_ECONNRESET, -104, 104, "Connection reset by peer"); +DEFINE_OS_ERROR(OS_ENOBUFS, -105, 105, "No buffer space available"); +DEFINE_OS_ERROR(OS_EISCONN, -106, 106, "Transport endpoint is already connected"); +DEFINE_OS_ERROR(OS_ENOTCONN, -107, 107, "Transport endpoint is not connected"); +DEFINE_OS_ERROR(OS_ESHUTDOWN, -108, 108, "Cannot send after transport endpoint shutdown"); +DEFINE_OS_ERROR(OS_ETOOMANYREFS, -109, 109, "Too many references: cannot splice"); +DEFINE_OS_ERROR(OS_ETIMEDOUT, -110, 110, "Connection timed out"); +DEFINE_OS_ERROR(OS_ECONNREFUSED, -111, 111, "Connection refused"); +DEFINE_OS_ERROR(OS_EHOSTDOWN, -112, 112, "Host is down"); +DEFINE_OS_ERROR(OS_EHOSTUNREACH, -113, 113, "No route to host"); +DEFINE_OS_ERROR(OS_EALREADY, -114, 114, "Operation already in progress"); +DEFINE_OS_ERROR(OS_EINPROGRESS, -115, 115, "Operation now in progress"); +DEFINE_OS_ERROR(OS_ESTALE, -116, 116, "Stale file handle"); +DEFINE_OS_ERROR(OS_EUCLEAN, -117, 117, "Structure needs cleaning"); +DEFINE_OS_ERROR(OS_ENOTNAM, -118, 118, "Not a XENIX named type file"); +DEFINE_OS_ERROR(OS_ENAVAIL, -119, 119, "No XENIX semaphores available"); +DEFINE_OS_ERROR(OS_EISNAM, -120, 120, "Is a named type file"); +DEFINE_OS_ERROR(OS_EREMOTEIO, -121, 121, "Remote I/O error"); +DEFINE_OS_ERROR(OS_EDQUOT, -122, 122, "Quota exceeded"); +DEFINE_OS_ERROR(OS_ENOMEDIUM, -123, 123, "No medium found"); +DEFINE_OS_ERROR(OS_EMEDIUMTYPE, -124, 124, "Wrong medium type"); +DEFINE_OS_ERROR(OS_ECANCELED, -125, 125, "Operation Canceled"); +DEFINE_OS_ERROR(OS_ENOKEY, -126, 126, "Required key not available"); +DEFINE_OS_ERROR(OS_EKEYEXPIRED, -127, 127, "Key has expired"); +DEFINE_OS_ERROR(OS_EKEYREVOKED, -128, 128, "Key has been revoked"); +DEFINE_OS_ERROR(OS_EKEYREJECTED, -129, 129, "Key was rejected by service"); +DEFINE_OS_ERROR(OS_EOWNERDEAD, -130, 130, "Owner died"); +DEFINE_OS_ERROR(OS_ENOTRECOVERABLE, -131, 131, "State not recoverable"); +DEFINE_OS_ERROR(OS_ERFKILL, -132, 132, "Operation not possible due to RF-kill"); +DEFINE_OS_ERROR(OS_EHWPOISON, -133, 133, "Memory page has hardware error"); \ No newline at end of file diff --git a/tools/ob_error/src/os_errno.h b/tools/ob_error/src/os_errno.h new file mode 100644 index 000000000..4d377233e --- /dev/null +++ b/tools/ob_error/src/os_errno.h @@ -0,0 +1,165 @@ +/** + * 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. + */ + +// DO NOT EDIT. This file is automatically generated from `ob_errno.def'. +#ifndef OBERROR_OS_ERRNO_H +#define OBERROR_OS_ERRNO_H + +// linux +#include + +namespace oceanbase { +namespace common { + +// The length of the second dimension, in order to solve the conflict of multiple identical error codes +constexpr int OS_MAX_SAME_ERROR_COUNT = 2; + +constexpr int OS_MAX_ERROR_CODE = 135; +constexpr int OS_ENOENT = -2; +constexpr int OS_ESRCH = -3; +constexpr int OS_EINTR = -4; +constexpr int OS_EIO = -5; +constexpr int OS_ENXIO = -6; +constexpr int OS_E2BIG = -7; +constexpr int OS_ENOEXEC = -8; +constexpr int OS_EBADF = -9; +constexpr int OS_ECHILD = -10; +constexpr int OS_EAGAIN = -11; +constexpr int OS_ENOMEM = -12; +constexpr int OS_EACCES = -13; +constexpr int OS_EFAULT = -14; +constexpr int OS_ENOTBLK = -15; +constexpr int OS_EBUSY = -16; +constexpr int OS_EEXIST = -17; +constexpr int OS_EXDEV = -18; +constexpr int OS_ENODEV = -19; +constexpr int OS_ENOTDIR = -20; +constexpr int OS_EISDIR = -21; +constexpr int OS_EINVAL = -22; +constexpr int OS_ENFILE = -23; +constexpr int OS_EMFILE = -24; +constexpr int OS_ENOTTY = -25; +constexpr int OS_ETXTBSY = -26; +constexpr int OS_EFBIG = -27; +constexpr int OS_ENOSPC = -28; +constexpr int OS_ESPIPE = -29; +constexpr int OS_EROFS = -30; +constexpr int OS_EMLINK = -31; +constexpr int OS_EPIPE = -32; +constexpr int OS_EDOM = -33; +constexpr int OS_ERANGE = -34; +constexpr int OS_EDEADLK = -35; +constexpr int OS_ENAMETOOLONG = -36; +constexpr int OS_ENOLCK = -37; +constexpr int OS_ENOSYS = -38; +constexpr int OS_ENOTEMPTY = -39; +constexpr int OS_ELOOP = -40; +constexpr int OS_EWOULDBLOCK = -41; +constexpr int OS_ENOMSG = -42; +constexpr int OS_EIDRM = -43; +constexpr int OS_ECHRNG = -44; +constexpr int OS_EL2NSYNC = -45; +constexpr int OS_EL3HLT = -46; +constexpr int OS_EL3RST = -47; +constexpr int OS_ELNRNG = -48; +constexpr int OS_EUNATCH = -49; +constexpr int OS_ENOCSI = -50; +constexpr int OS_EL2HLT = -51; +constexpr int OS_EBADE = -52; +constexpr int OS_EBADR = -53; +constexpr int OS_EXFULL = -54; +constexpr int OS_ENOANO = -55; +constexpr int OS_EBADRQC = -56; +constexpr int OS_EBADSLT = -57; +constexpr int OS_EBFONT = -59; +constexpr int OS_ENOSTR = -60; +constexpr int OS_ENODATA = -61; +constexpr int OS_ETIME = -62; +constexpr int OS_ENOSR = -63; +constexpr int OS_ENONET = -64; +constexpr int OS_ENOPKG = -65; +constexpr int OS_EREMOTE = -66; +constexpr int OS_ENOLINK = -67; +constexpr int OS_EADV = -68; +constexpr int OS_ESRMNT = -69; +constexpr int OS_ECOMM = -70; +constexpr int OS_EPROTO = -71; +constexpr int OS_EMULTIHOP = -72; +constexpr int OS_EDOTDOT = -73; +constexpr int OS_EBADMSG = -74; +constexpr int OS_EOVERFLOW = -75; +constexpr int OS_ENOTUNIQ = -76; +constexpr int OS_EBADFD = -77; +constexpr int OS_EREMCHG = -78; +constexpr int OS_ELIBACC = -79; +constexpr int OS_ELIBBAD = -80; +constexpr int OS_ELIBSCN = -81; +constexpr int OS_ELIBMAX = -82; +constexpr int OS_ELIBEXEC = -83; +constexpr int OS_EILSEQ = -84; +constexpr int OS_ERESTART = -85; +constexpr int OS_ESTRPIPE = -86; +constexpr int OS_EUSERS = -87; +constexpr int OS_ENOTSOCK = -88; +constexpr int OS_EDESTADDRREQ = -89; +constexpr int OS_EMSGSIZE = -90; +constexpr int OS_EPROTOTYPE = -91; +constexpr int OS_ENOPROTOOPT = -92; +constexpr int OS_EPROTONOSUPPORT = -93; +constexpr int OS_ESOCKTNOSUPPORT = -94; +constexpr int OS_EOPNOTSUPP = -95; +constexpr int OS_EPFNOSUPPORT = -96; +constexpr int OS_EAFNOSUPPORT = -97; +constexpr int OS_EADDRINUSE = -98; +constexpr int OS_EADDRNOTAVAIL = -99; +constexpr int OS_ENETDOWN = -100; +constexpr int OS_ENETUNREACH = -101; +constexpr int OS_ENETRESET = -102; +constexpr int OS_ECONNABORTED = -103; +constexpr int OS_ECONNRESET = -104; +constexpr int OS_ENOBUFS = -105; +constexpr int OS_EISCONN = -106; +constexpr int OS_ENOTCONN = -107; +constexpr int OS_ESHUTDOWN = -108; +constexpr int OS_ETOOMANYREFS = -109; +constexpr int OS_ETIMEDOUT = -110; +constexpr int OS_ECONNREFUSED = -111; +constexpr int OS_EHOSTDOWN = -112; +constexpr int OS_EHOSTUNREACH = -113; +constexpr int OS_EALREADY = -114; +constexpr int OS_EINPROGRESS = -115; +constexpr int OS_ESTALE = -116; +constexpr int OS_EUCLEAN = -117; +constexpr int OS_ENOTNAM = -118; +constexpr int OS_ENAVAIL = -119; +constexpr int OS_EISNAM = -120; +constexpr int OS_EREMOTEIO = -121; +constexpr int OS_EDQUOT = -122; +constexpr int OS_ENOMEDIUM = -123; +constexpr int OS_EMEDIUMTYPE = -124; +constexpr int OS_ECANCELED = -125; +constexpr int OS_ENOKEY = -126; +constexpr int OS_EKEYEXPIRED = -127; +constexpr int OS_EKEYREVOKED = -128; +constexpr int OS_EKEYREJECTED = -129; +constexpr int OS_EOWNERDEAD = -130; +constexpr int OS_ENOTRECOVERABLE = -131; +constexpr int OS_ERFKILL = -132; +constexpr int OS_EHWPOISON = -133; + +const char* str_os_error_name(const int err); +const char* str_os_error_msg(const int err); +int os_errno(const int err); +} // end namespace common +} // end namespace oceanbase + +#endif /* OBERROR_OS_ERRNO_H */ diff --git a/tools/ob_error/test/expect_result.result b/tools/ob_error/test/expect_result.result new file mode 100644 index 000000000..ade34a4a1 --- /dev/null +++ b/tools/ob_error/test/expect_result.result @@ -0,0 +1,221 @@ +$ob_error 1 + +Oracle: + Oracle Error Code: ORA-00001 + Message: unique constraint violated + Related OceanBase Error Code: + OB_ERR_PRIMARY_KEY_DUPLICATE(-5024) + OB_ER_DUPLICATED_VALUE_IN_TYPE(-5334) + OB_ERR_CONSTRAINT_DUPLICATE(-5562) + OB_ERR_DUP_KEY(-5595) +$ob_error 13 + +Operating System: + Linux Error Code: EACCES(13) + Message: Permission denied +$ob_error 200 + +OceanBase: + Error Code 200 not found. +$ob_error 600 + +Oracle: + Oracle Error Code: ORA-00600 + Message: auto increment service busy + Message: rowid type mismatch + Related OceanBase Error Code: + OB_AUTOINC_SERVICE_BUSY(-5794) + OB_ROWID_TYPE_MISMATCH(-5870) + OB_ROWID_NUM_MISMATCH(-5871) +$ob_error 1017 + +MySQL: + MySQL Error Code: 1017 (HY000) + Message: File not exist + Related OceanBase Error Code: + OB_FILE_NOT_EXIST(-4027) + +Oracle: + Oracle Error Code: ORA-01017 + Message: invalid username/password; logon deniedd + Related OceanBase Error Code: + OB_ERR_LOGIN_DENIED(-5845) +$ob_error 5858 + +OceanBase: + OceanBase Error Code: OB_ERR_CONFLICTING_DECLARATIONS(-5858) + Message: Conflicting declarations + Cause: Internal Error + Solution: Contact OceanBase Support +$ob_error 4001 + +OceanBase: + OceanBase Error Code: OB_OBJ_TYPE_ERROR(-4001) + Message: Object type error + Cause: Internal Error + Solution: Contact OceanBase Support + +Oracle: + Oracle Error Code: ORA-04001 + Message: sequence parameter must be an integer + Related OceanBase Error Code: + OB_ERR_SEQ_OPTION_MUST_BE_INTEGER(-4317) +$ob_error 20000 + +OceanBase: + OceanBase Error Code: OB_SP_RAISE_APPLICATION_ERROR(-20000) + Message: The stored procedure 'raise_application_error' was called which causes this error to be generated + Cause: Internal Error + Solution: Contact OceanBase Support + +Oracle: + Oracle Error Code: ORA-20000 + Message: The stored procedure 'raise_application_error' was called which causes this error to be generated + Related OceanBase Error Code: + OB_SP_RAISE_APPLICATION_ERROR(-20000) +$ob_error 24761 + +Oracle: + Oracle Error Code: ORA-24761 + Message: transaction rolled back + Message: transaction rolled back: transaction is killed + Message: transaction rolled back: transaction context does not exist + Message: transaction rolled back: partition is frozen + Message: transaction rolled back: Transaction exiting + Message: transaction rolled back: transaction needs rollback + Message: transaction rolled back: transaction context count reach limit + Related OceanBase Error Code: + OB_TRANS_ROLLBACKED(-6002) + OB_TRANS_KILLED(-6211) + OB_TRANS_CTX_NOT_EXIST(-6213) + OB_PARTITION_IS_FROZEN(-6214) + OB_TRANS_IS_EXITING(-6223) + OB_TRANS_NEED_ROLLBACK(-6224) + OB_TRANS_CTX_COUNT_REACH_LIMIT(-6234) +$ob_error 5727 + +OceanBase: + OceanBase Error Code: OB_ERR_PROXY_REROUTE(-5727) + Message: SQL request should be rerouted + Cause: Internal Error + Solution: Contact OceanBase Support +$ob_error 5133 + +MySQL: + MySQL Error Code: 5133 (42000) + Message: No such grant defined + Related OceanBase Error Code: + OB_ERR_CANNOT_REVOKE_PRIVILEGES_YOU_DID_NOT_GRANT(-5362) +$ob_error 1210 + +MySQL: + MySQL Error Code: 1210 (HY000) + Message: Invalid argument + Message: Miss argument + Message: Incorrect arguments to ESCAPE + Related OceanBase Error Code: + OB_INVALID_ARGUMENT(-4002) + OB_MISS_ARGUMENT(-4277) + INCORRECT_ARGUMENTS_TO_ESCAPE(-5832) +$ob_error 700 -a 1000 +error: '-a ARG' is unsupport in this scene +Use 'ob_error ora 600 -a ARG'. +Use 'ob_error --help' for help. +$ob_error my 6000 + +MySQL: + Error Code 6000 not found. +$ob_error my 4000 + +OceanBase: + OceanBase Error Code: OB_ERROR(-4000) + Message: Common error + Cause: Internal Error + Solution: Contact OceanBase Support +$ob_error my 5133 + +MySQL: + MySQL Error Code: 5133 (42000) + Message: No such grant defined + Related OceanBase Error Code: + OB_ERR_CANNOT_REVOKE_PRIVILEGES_YOU_DID_NOT_GRANT(-5362) +$ob_error my 1210 + +MySQL: + MySQL Error Code: 1210 (HY000) + Message: Invalid argument + Message: Miss argument + Message: Incorrect arguments to ESCAPE + Related OceanBase Error Code: + OB_INVALID_ARGUMENT(-4002) + OB_MISS_ARGUMENT(-4277) + INCORRECT_ARGUMENTS_TO_ESCAPE(-5832) +$ob_error ora 00051 + +Oracle: + Oracle Error Code: ORA-00051 + Message: timeout occurred while waiting for a resource + Related OceanBase Error Code: + OB_ERR_TIMEOUT_ON_RESOURCE(-5848) +$ob_error ora 900 + +Oracle: + Oracle Error Code: ORA-00900 + Message: invalid SQL statement + Message: You have an error in your SQL syntax; check the manual that corresponds to your OceanBase version for the right syntax to use + Related OceanBase Error Code: + OB_ERR_PARSE_SQL(-5001) + OB_ERR_PARSER_SYNTAX(-5006) +$ob_error ora 600 -a 5858 + +OceanBase: + OceanBase Error Code: OB_ERR_CONFLICTING_DECLARATIONS(-5858) + Message: Conflicting declarations + Cause: Internal Error + Solution: Contact OceanBase Support + +Oracle: + Oracle Error Code: ORA-00600 + Message: internal error code, arguments: -5858, Conflicting declarations + Related OceanBase Error Code: + OB_ERR_CONFLICTING_DECLARATIONS(-5858) +$ob_error ora 600 -a 5727 + +OceanBase: + OceanBase Error Code: OB_ERR_PROXY_REROUTE(-5727) + Message: SQL request should be rerouted + Cause: Internal Error + Solution: Contact OceanBase Support + +Oracle: + Oracle Error Code: ORA-00600 + Message: internal error code, arguments: -5727, SQL request should be rerouted + Related OceanBase Error Code: + OB_ERR_PROXY_REROUTE(-5727) +$ob_error -a 100 ora 600 +error: '-a ARG' is unsupport in this scene +Use 'ob_error ora 600 -a ARG'. +Use 'ob_error --help' for help. +$ob_error ora -a 100 600 +error: '-a ARG' is unsupport in this scene +Use 'ob_error ora 600 -a ARG'. +Use 'ob_error --help' for help. +$ob_error ora 600 -a 100 + +OceanBase: + Error Code 100 not found. + +Oracle: + Error Code ORA-00600 arguments: -100 not found. +$ob_error pls 100 + +Oracle: + Error Code PLS-00100 not found. +$ob_error pls 201 + +Oracle: + Oracle Error Code: PLS-00201 + Message: identifier must be declared + Related OceanBase Error Code: + OB_ERR_SP_UNDECLARED_VAR(-5543) + OB_ERR_SP_LILABEL_MISMATCH(-5546) diff --git a/tools/ob_error/test/ob_error_test.test b/tools/ob_error/test/ob_error_test.test new file mode 100644 index 000000000..ea764f871 --- /dev/null +++ b/tools/ob_error/test/ob_error_test.test @@ -0,0 +1,26 @@ +ob_error 1 +ob_error 13 +ob_error 200 +ob_error 600 +ob_error 1017 +ob_error 5858 +ob_error 4001 +ob_error 20000 +ob_error 24761 +ob_error 5727 +ob_error 5133 +ob_error 1210 +ob_error 700 -a 1000 +ob_error my 6000 +ob_error my 4000 +ob_error my 5133 +ob_error my 1210 +ob_error ora 00051 +ob_error ora 900 +ob_error ora 600 -a 5858 +ob_error ora 600 -a 5727 +ob_error -a 100 ora 600 +ob_error ora -a 100 600 +ob_error ora 600 -a 100 +ob_error pls 100 +ob_error pls 201 diff --git a/tools/ob_error/test/test.sh b/tools/ob_error/test/test.sh new file mode 100755 index 000000000..a1e10be31 --- /dev/null +++ b/tools/ob_error/test/test.sh @@ -0,0 +1,21 @@ +#!/bin/bash + +CURRENT_DIR="$(cd $(dirname $0); pwd)" +test_file=${CURRENT_DIR}/ob_error_test.test +test_result_file=${CURRENT_DIR}/expect_result.result +result_file=${CURRENT_DIR}/test.result + +rm -f $result_file + +while read line +do + echo "$"$line >> $result_file + eval $line >> $result_file +done < $test_file + +if cmp -s $result_file $test_result_file +then + echo "test finish. success." +else + echo "test finish. failed." +fi diff --git a/unittest/CMakeLists.txt b/unittest/CMakeLists.txt index 7c5c748cf..6bf97f6ae 100644 --- a/unittest/CMakeLists.txt +++ b/unittest/CMakeLists.txt @@ -28,3 +28,4 @@ add_subdirectory(election) add_subdirectory(observer) add_subdirectory(share) add_subdirectory(rootserver) +add_subdirectory(tools) diff --git a/unittest/tools/CMakeLists.txt b/unittest/tools/CMakeLists.txt new file mode 100644 index 000000000..e27d0f2b6 --- /dev/null +++ b/unittest/tools/CMakeLists.txt @@ -0,0 +1 @@ +add_subdirectory(ob_error) \ No newline at end of file diff --git a/unittest/tools/ob_error/CMakeLists.txt b/unittest/tools/ob_error/CMakeLists.txt new file mode 100644 index 000000000..46b4ef287 --- /dev/null +++ b/unittest/tools/ob_error/CMakeLists.txt @@ -0,0 +1,6 @@ +add_executable(test_ob_error test_ob_error.cpp) +add_test(test_ob_error test_ob_error) +target_link_libraries(test_ob_error PRIVATE oberror ${DEP_DIR}/lib/libgtest.a ${DEP_DIR}/lib/libgmock.a -lpthread) +target_include_directories(test_ob_error + PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_SOURCE_DIR}/unittest ${CMAKE_SOURCE_DIR}/deps/oblib/unittest ${DEP_DIR}/include + ${CMAKE_SOURCE_DIR} ${CMAKE_SOURCE_DIR}/src ${CMAKE_SOURCE_DIR}/deps/oblib/src) \ No newline at end of file diff --git a/unittest/tools/ob_error/test_ob_error.cpp b/unittest/tools/ob_error/test_ob_error.cpp new file mode 100644 index 000000000..4f40157c9 --- /dev/null +++ b/unittest/tools/ob_error/test_ob_error.cpp @@ -0,0 +1,127 @@ +/** + * 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. + */ + +#include "tools/ob_error/src/ob_error.h" + +#include "gtest/gtest.h" + +using namespace oceanbase::common; +namespace oceanbase { +namespace unittest { +class TestObError : public ::testing::Test { +public: + virtual void SetUp() + {} + virtual void TearDown() + {} +}; + +TEST_F(TestObError, test_mgr) +{ + ObErrorInfoMgr mgr; + + EXPECT_FALSE(mgr.insert_os_error(nullptr, "abc", 1)); + EXPECT_FALSE(mgr.insert_os_error("abc", nullptr, 1)); + EXPECT_FALSE(mgr.insert_mysql_error(nullptr, "abc", 1, "abc", "abc", "abc", 1)); + EXPECT_FALSE(mgr.insert_mysql_error("abc", nullptr, 1, "abc", "abc", "abc", 1)); + EXPECT_FALSE(mgr.insert_mysql_error("abc", "abc", 1, nullptr, "abc", "abc", 1)); + EXPECT_FALSE(mgr.insert_mysql_error("abc", "abc", 1, "abc", nullptr, "abc", 1)); + EXPECT_FALSE(mgr.insert_mysql_error("abc", "abc", 1, "abc", "abc", nullptr, 1)); + EXPECT_FALSE(mgr.insert_oracle_error(nullptr, "abc", "abc", "abc", ORA, 1, 1)); + EXPECT_FALSE(mgr.insert_oracle_error("abc", nullptr, "abc", "abc", ORA, 1, 1)); + EXPECT_FALSE(mgr.insert_oracle_error("abc", "abc", nullptr, "abc", ORA, 1, 1)); + EXPECT_FALSE(mgr.insert_oracle_error("abc", "abc", "abc", nullptr, ORA, 1, 1)); + EXPECT_FALSE(mgr.insert_oracle_error("abc", "abc", "abc", "abc", NONE, 1, 1)); + EXPECT_FALSE(mgr.insert_ob_error(nullptr, "abc", "abc", "abc", 1)); + EXPECT_FALSE(mgr.insert_ob_error("abc", nullptr, "abc", "abc", 1)); + EXPECT_FALSE(mgr.insert_ob_error("abc", "abc", nullptr, "abc", 1)); + EXPECT_FALSE(mgr.insert_ob_error("abc", "abc", "abc", nullptr, 1)); +} + +TEST_F(TestObError, test_adder) +{ + ObErrorInfoMgr mgr; + EXPECT_TRUE(init_global_info()); + // test_add_os_info + EXPECT_FALSE(add_os_info(-1, &mgr)); + EXPECT_FALSE(add_os_info(OS_MAX_ERROR_CODE, &mgr)); + + EXPECT_TRUE(add_os_info(1, nullptr)); + EXPECT_TRUE(add_os_info(100, &mgr)); + EXPECT_TRUE(add_os_info(0, &mgr)); + + // test_add_oracle_info + EXPECT_FALSE(add_oracle_info(NONE, -1, -1, &mgr)); + EXPECT_FALSE(add_oracle_info(ORA, 100, -1, &mgr)); + EXPECT_FALSE(add_oracle_info(PLS, 100, -1, &mgr)); + EXPECT_FALSE(add_oracle_info(ORA, 600, 3000, &mgr)); + EXPECT_FALSE(add_oracle_info(MY, 600, 3000, &mgr)); + EXPECT_FALSE(add_oracle_info(NONE, 100, -1, &mgr)); + + EXPECT_TRUE(add_oracle_info(ORA, 600, -1, nullptr)); + EXPECT_TRUE(add_oracle_info(ORA, 600, -1, &mgr)); + EXPECT_TRUE(add_oracle_info(ORA, 600, 4000, &mgr)); + EXPECT_TRUE(add_oracle_info(ORA, 100, 4000, &mgr)); + EXPECT_TRUE(add_oracle_info(PLS, 100, 4000, &mgr)); + EXPECT_TRUE(add_oracle_info(NONE, 600, 3000, &mgr)); + + // test_add_mysql_info + EXPECT_FALSE(add_mysql_info(-1, &mgr)); + EXPECT_FALSE(add_mysql_info(OB_MAX_ERROR_CODE, &mgr)); + EXPECT_FALSE(add_mysql_info(1000, &mgr)); + EXPECT_FALSE(add_mysql_info(6300, &mgr)); + + EXPECT_TRUE(add_mysql_info(1017, &mgr)); + + // test_add_ob_info + EXPECT_FALSE(add_ob_info(-1, &mgr)); + EXPECT_FALSE(add_ob_info(OB_MAX_ERROR_CODE, &mgr)); + EXPECT_FALSE(add_ob_info(1000, &mgr)); + EXPECT_FALSE(add_ob_info(6500, &mgr)); + + EXPECT_TRUE(add_ob_info(4100, &mgr)); +} + +TEST_F(TestObError, test_parser) +{ + // test_parse_error_code + int error_code = -1; + parse_error_code("abc123", error_code); + EXPECT_EQ(-1, error_code); + parse_error_code(nullptr, error_code); + EXPECT_EQ(-1, error_code); + parse_error_code("9999999999999", error_code); // overflow + EXPECT_EQ(-1, error_code); + parse_error_code("123", error_code); + EXPECT_EQ(123, error_code); + + // test_parse_facility + Fac facility = NONE; + parse_facility("ABC", facility); + EXPECT_EQ(NONE, facility); + + facility = NONE; + parse_facility("ORa", facility); + EXPECT_EQ(ORA, facility); + + facility = NONE; + parse_facility("mY", facility); + EXPECT_EQ(MY, facility); +} +} // end namespace unittest +} // end namespace oceanbase + +int main(int argc, char** argv) +{ + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} \ No newline at end of file