ob_errno.def

// Total number of errors is not greater than 10000
// [-1, -4000] is reserved for MySQL compatibility purpose. MySQL has error code from 1000-3000 and the client side uses error code from 2000-3000. 1-1000 is reserved
// General Error [-4000, -4500)
// RootServer Error [-4500, -5000)
// Transaction Error [-6000, -7000)
// Election Error [-7000, -7100)
// Fatal Error [-8000, -9000)
// backup [-9000, -9500)
// pl [-9500, -10000)
////////////////////////////////////////////////////////////////
//error code -1~-999 are reserved
//error code -1000~-1999 are reserved for mysql server error, see mysql_errno.h
//error code -2001~-3000 are reserved for mysql client error, see http://dev.mysql.com/doc/refman/5.1/en/error-messages-client.html
//error code -4000~-65535 are reserved for ob error
//
//oracle error https://docs.oracle.com/en/database/oracle/oracle-database/18/errmg/ORA-00910.html
//
//we have ob errno, mysql errno, oracle errno. ob errno used in source code, mysql/oracle errno used in error packet encoding.
//developer only use ob errno in source code, and specify the mapping relation between ob errno and mysql/oracle errnor in this file.
//
//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
//M4: char *STR_USER_ERROR[OB_MAX_ERROR_CODE];        -----> store mysql errmsg with parameter
//R1: int ORACLE_ERRNO[OB_MAX_ERROR_CODE];            -----> store oracle errno
//R2: char *ORACLE_SQLSTATE[OB_MAX_ERROR_CODE];       -----> store oracle errstate
//R3: char *ORACLE_STR_ERROR[OB_MAX_ERROR_CODE];      -----> store oracle errno without parameter
//R4: char *ORACLE_STR_USER_ERROR[OB_MAX_ERROR_CODE]; -----> store oracle errno with parameter
//
//DEFINE_ERROR(C1, C0, M1, M2, M3)                            <==>   DEFINE_ORACLE_ERROR_EXT(C1, C0, M1, M2, M3, M3, -600, M2, M3, M3)
//DEFINE_ERROR_EXT(C1, C0, M1, M2, M3, M4)                    <==>   DEFINE_ORACLE_ERROR_EXT(C1, C0, M1, M2, M3, M4, -600, M2, M3, M4)
//DEFINE_ORACLE_ERROR(C1, C0, M1, M2, M3, R1, R3)             <==>   DEFINE_ORACLE_ERROR_EXT(C1, C0, M1, M2, M3, M3, R1, ORA, R3, R3)
//DEFINE_ORACLE_ERROR_EXT(C1, C0, M1, M2, M3, M4, R1, R3, R4) <==>   DEFINE_ORACLE_ERROR_EXT(C1, C0, M1, M2, M3, M4, R1, ORA, R3, R4)
//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
//   R1 = -600
//   R2 = ORA
//   R3 = internal error code, arguments: M3
//   R4 = internal error code, arguments: M3
//
//DEFINE_ERROR_EXT(C1, C0, M1, M2, M3, M4)
//   M1 = (M1 == -1 ? C0 : M1)
//   R1 = -600
//   R2 = ORA
//   R3 = internal error code, arguments: M3
//   R4 = internal error code, arguments: M4
//
//DEFINE_ORACLE_ERROR(C1, C0, M1, M2, M3, R1, R3)
//   M1 = (M1 == -1 ? C0 : M1)
//   M4 = M3
//   R4 = R3
//   R2 = ORA
//
//DEFINE_ORACLE_ERROR_EXT(C1, C0, M1, M2, M3, M4, R1, R3, R4)
//   M1 = (M1 == -1 ? C0 : M1)
//   R2 = ORA
//
//DEFINE_PLS_ERROR(C1, C0, M1, M2, M3, R1, R3)
//   M1 = (M1 == -1 ? C0 : M1)
//   M4 = M3
//   R2 = PLS
//   R4 = R3
//
//DEFINE_PLS_ERROR_EXT(C1, C0, M1, M2, M3, M4, R1, R3, R4)
//   M1 = (M1 == -1 ? C0 : M1)
//   R2 = PLS
//
//only add the definition of errno msg with parameter, in order to be compatible with the old code
//errno of c1 is equal to errno of c0. you should use it like below
//DEFINE_OTHER_MSG_FMT(C1, C0, M4, R4)
//
//DEFINE_OTHER_MSG_FMT(OB_ERR_DATA_TOO_LONG_MSG_FMT_V2, OB_ERR_DATA_TOO_LONG, "Data too long for column '%.*s' at row %ld", "value too large for column %.*s (actual: %ld, maximum: %ld)")
//
////////////////////////////////////////////////////////////////

DEFINE_ERROR(OB_SUCCESS, 0, 0, "00000", "Success");

////////////////////////////////////////////////////////////////
//error code for common -4000 ---- -4500
////////////////////////////////////////////////////////////////
DEFINE_ERROR(OB_ERROR, -4000, -1, "HY000", "Common error");
DEFINE_ERROR(OB_OBJ_TYPE_ERROR, -4001, -1, "HY004", "Object type error");
DEFINE_ERROR_EXT(OB_INVALID_ARGUMENT, -4002, ER_WRONG_ARGUMENTS, "HY000", "Invalid argument", "Incorrect arguments to %s");
DEFINE_ERROR(OB_ARRAY_OUT_OF_RANGE, -4003, -1, "42000", "Array index out of range");
DEFINE_ERROR(OB_SERVER_LISTEN_ERROR, -4004, -1, "08S01", "Failed to listen to the port");
DEFINE_ERROR(OB_INIT_TWICE, -4005, -1, "HY000", "The object is initialized twice");
DEFINE_ERROR(OB_NOT_INIT, -4006, -1, "HY000", "The object is not initialized");
DEFINE_ERROR_EXT(OB_NOT_SUPPORTED, -4007, ER_NOT_SUPPORTED_YET, "0A000", "Not supported feature or function", "%s not supported");
DEFINE_ERROR(OB_ITER_END, -4008, -1, "HY000", "End of iteration");
DEFINE_ERROR(OB_IO_ERROR, -4009, -1, "58030", "IO error");
DEFINE_ERROR(OB_ERROR_FUNC_VERSION, -4010, -1, "HY000", "Wrong RPC command version");
DEFINE_ERROR(OB_PACKET_NOT_SENT, -4011, -1, "HY000", "Can not send packet");
DEFINE_ERROR(OB_TIMEOUT, -4012, -1, "HY000", "Timeout");
DEFINE_ERROR(OB_ALLOCATE_MEMORY_FAILED, -4013, -1, "HY001", "No memory or reach tenant memory limit");
DEFINE_ERROR(OB_INNER_STAT_ERROR, -4014, -1, "HY000", "Inner state error");
DEFINE_ERROR(OB_ERR_SYS, -4015, -1, "HY000", "System error");
DEFINE_ERROR_EXT(OB_ERR_UNEXPECTED, -4016, -1, "HY000", "Internal error", "%s");
DEFINE_ERROR_EXT(OB_ENTRY_EXIST, -4017, -1, "HY000", "Entry already exist", "%s");
DEFINE_ERROR_EXT(OB_ENTRY_NOT_EXIST, -4018, -1, "HY000", "Entry not exist", "%s");
DEFINE_ERROR(OB_SIZE_OVERFLOW, -4019, -1, "HY000", "Size overflow");
DEFINE_ERROR(OB_REF_NUM_NOT_ZERO, -4020, -1, "HY000", "Reference count is not zero");
DEFINE_ERROR(OB_CONFLICT_VALUE, -4021, -1, "HY000", "Conflict value");
DEFINE_ERROR(OB_ITEM_NOT_SETTED, -4022, -1, "HY000", "Item not set");
DEFINE_ERROR(OB_EAGAIN, -4023, -1, "HY000", "Try again");
DEFINE_ERROR(OB_BUF_NOT_ENOUGH, -4024, -1, "HY000", "Buffer not enough");
DEFINE_ERROR(OB_PARTIAL_FAILED, -4025, -1, "HY000", "Partial failed");
DEFINE_ORACLE_ERROR(OB_READ_NOTHING, -4026, -1, "02000", "Nothing to read", 1403, "no data found");
DEFINE_ERROR(OB_FILE_NOT_EXIST, -4027, ER_FILE_NOT_FOUND, "HY000", "File not exist");
DEFINE_ERROR(OB_DISCONTINUOUS_LOG, -4028, -1, "HY000", "Log entry not continuous");
DEFINE_ERROR(OB_SCHEMA_ERROR, -4029, -1, "HY000", "Schema error");
DEFINE_ERROR(OB_TENANT_OUT_OF_MEM, -4030, -1, "HY000", "Over tenant memory limits");
DEFINE_ERROR(OB_UNKNOWN_OBJ, -4031, -1, "HY004", "Unknown object");
DEFINE_ERROR(OB_NO_MONITOR_DATA, -4032, -1, "02000", "No monitor data");
DEFINE_ERROR(OB_SERIALIZE_ERROR, -4033, -1, "HY000", "Serialize error");
DEFINE_ERROR(OB_DESERIALIZE_ERROR, -4034, -1, "HY000", "Deserialize error");
DEFINE_ERROR(OB_AIO_TIMEOUT, -4035, -1, "HY000", "Asynchronous IO error");
DEFINE_ERROR(OB_NEED_RETRY, -4036, -1, "HY000", "Need retry");
DEFINE_ERROR(OB_TOO_MANY_SSTABLE, -4037, -1, "HY000", "Too many sstable");
DEFINE_ERROR(OB_NOT_MASTER, -4038, -1, "HY000", "The observer or zone is not the master");
DEFINE_ERROR(OB_KILLED_BY_THROTTLING, -4039, -1, "HY000", "Request has killed by sql throttle");
DEFINE_ERROR(OB_DECRYPT_FAILED, -4041, -1, "HY000", "Decrypt error");
DEFINE_ORACLE_ERROR_EXT(OB_USER_NOT_EXIST, -4042, ER_PASSWORD_NO_MATCH, "42000", "Can not find any matching row in the user table", "Can not find any matching row in the user table'%.*s'", 1918, "user does not exist", "user '%.*s' does not exist");

DEFINE_ERROR_EXT(OB_PASSWORD_WRONG, -4043, ER_ACCESS_DENIED_ERROR, "42000", "Access denied for user", "Access denied for user '%.*s'@'%.*s' (using password: %s)");
DEFINE_ERROR(OB_SKEY_VERSION_WRONG, -4044, -1, "HY000", "Wrong skey version");
DEFINE_ERROR(OB_NOT_REGISTERED, -4048, -1, "HY000", "Not registered");
DEFINE_ERROR(OB_WAITQUEUE_TIMEOUT, -4049, 4012, "HY000", "Task timeout and not executed");
DEFINE_ERROR(OB_NOT_THE_OBJECT, -4050, -1, "HY000", "Not the object");
DEFINE_ERROR(OB_ALREADY_REGISTERED, -4051, -1, "HY000", "Already registered");
DEFINE_ERROR(OB_LAST_LOG_RUINNED, -4052, -1, "HY000", "Corrupted log entry");
DEFINE_ERROR(OB_NO_CS_SELECTED, -4053, -1, "HY000", "No ChunkServer selected");
DEFINE_ERROR(OB_NO_TABLETS_CREATED, -4054, -1, "HY000", "No tablets created");
DEFINE_ERROR(OB_INVALID_ERROR, -4055, -1, "HY000", "Invalid entry");
DEFINE_ERROR(OB_DECIMAL_OVERFLOW_WARN, -4057, -1, "HY000", "Decimal overflow warning");
DEFINE_ERROR(OB_DECIMAL_UNLEGAL_ERROR, -4058, -1, "HY000", "Decimal overflow error");
DEFINE_ERROR(OB_OBJ_DIVIDE_ERROR, -4060, -1, "HY000", "Divide error");
DEFINE_ERROR(OB_NOT_A_DECIMAL, -4061, -1, "HY000", "Not a decimal");
DEFINE_ERROR(OB_DECIMAL_PRECISION_NOT_EQUAL, -4062, -1, "HY104", "Decimal precision error");
DEFINE_ERROR(OB_EMPTY_RANGE, -4063, -1, "HY000", "Empty range");
DEFINE_ERROR(OB_SESSION_KILLED, -4064, -1, "HY000", "Session killed");
DEFINE_ERROR(OB_LOG_NOT_SYNC, -4065, -1, "HY000", "Log not sync");
DEFINE_ERROR(OB_DIR_NOT_EXIST, -4066, ER_CANT_READ_DIR, "HY000", "Directory not exist");
DEFINE_ERROR(OB_SESSION_NOT_FOUND, -4067, 4012, "HY000", "RPC session not found");
DEFINE_ERROR(OB_INVALID_LOG, -4068, -1, "HY000", "Invalid log");
DEFINE_ERROR(OB_INVALID_DATA, -4070, -1, "HY000", "Invalid data");
DEFINE_ERROR(OB_ALREADY_DONE, -4071, -1, "HY000", "Already done");
DEFINE_ERROR(OB_CANCELED, -4072, -1, "HY000", "Operation canceled");
DEFINE_ERROR(OB_LOG_SRC_CHANGED, -4073, -1, "HY000", "Log source changed");
DEFINE_ERROR(OB_LOG_NOT_ALIGN, -4074, -1, "HY000", "Log not aligned");
DEFINE_ERROR(OB_LOG_MISSING, -4075, -1, "HY000", "Log entry missed");
DEFINE_ERROR(OB_NEED_WAIT, -4076, -1, "HY000", "Need wait");
DEFINE_ERROR(OB_NOT_IMPLEMENT, -4077, -1, "0A000", "Not implemented feature");
DEFINE_ERROR(OB_DIVISION_BY_ZERO, -4078, ER_DIVISION_BY_ZERO, "42000", "Divided by zero");
DEFINE_ERROR(OB_EXCEED_MEM_LIMIT, -4080, -1, "HY013", "exceed memory limit");
DEFINE_ERROR(OB_RESULT_UNKNOWN, -4081, -1, "HY000", "Unknown result");
DEFINE_ERROR(OB_NO_RESULT, -4084, -1, "02000", "No result");
DEFINE_ERROR(OB_QUEUE_OVERFLOW, -4085, -1, "HY000", "Queue overflow");
DEFINE_ERROR(OB_LOG_ID_RANGE_NOT_CONTINUOUS, -4090, -1, "HY000", "Table log_id range no continuous");
DEFINE_ERROR(OB_TERM_LAGGED, -4097, -1, "HY000", "Term lagged");
DEFINE_ERROR(OB_TERM_NOT_MATCH, -4098, -1, "HY000", "Term not match");
DEFINE_ERROR(OB_START_LOG_CURSOR_INVALID, -4099, -1, "HY000", "Invalid log cursor");
DEFINE_ERROR(OB_LOCK_NOT_MATCH, -4100, -1, "HY000", "Lock not match");
DEFINE_ORACLE_ERROR(OB_DEAD_LOCK, -4101, ER_LOCK_DEADLOCK, "HY000", "Deadlock", 60, "deadlock detected while waiting for resource");
DEFINE_ERROR(OB_PARTIAL_LOG, -4102, -1, "HY000", "Incomplete log entry");
DEFINE_ERROR(OB_CHECKSUM_ERROR, -4103, -1, "42000", "Data checksum error");
DEFINE_ERROR(OB_INIT_FAIL, -4104, -1, "HY000", "Initialize error");
DEFINE_ERROR(OB_ROWKEY_ORDER_ERROR, -4105, -1, "HY000", "Rowkey order error");
DEFINE_ERROR(OB_NOT_ENOUGH_STORE, -4106, -1, "HY000", "not enough commitlog store");
DEFINE_ERROR(OB_BLOCK_SWITCHED, -4107, -1, "HY000", "block switched when fill commitlog");
DEFINE_ERROR(OB_PHYSIC_CHECKSUM_ERROR, -4108, -1, "42000", "Physic data checksum error");
DEFINE_ERROR(OB_STATE_NOT_MATCH, -4109, -1, "HY000", "Server state or role not the same as expected");
DEFINE_ERROR(OB_READ_ZERO_LOG, -4110, -1, "HY000", "Read zero log");
DEFINE_ERROR(OB_BLOCK_NEED_FREEZE, -4111, -1, "HY000", "block need freeze");
DEFINE_ERROR(OB_BLOCK_FROZEN, -4112, -1, "HY000", "block frozen");
DEFINE_ERROR(OB_IN_FATAL_STATE, -4113, -1, "HY000", "In FATAL state");
DEFINE_ERROR(OB_IN_STOP_STATE, -4114, -1, "08S01", "In STOP state");
DEFINE_ERROR(OB_UPS_MASTER_EXISTS, -4115, -1, "HY000", "Master UpdateServer already exists");
DEFINE_ERROR(OB_LOG_NOT_CLEAR, -4116, -1, "42000", "Log not clear");
DEFINE_ERROR(OB_FILE_ALREADY_EXIST, -4117, ER_FILE_EXISTS_ERROR, "58000", "File already exist");
DEFINE_ERROR(OB_UNKNOWN_PACKET, -4118, ER_UNKNOWN_COM_ERROR, "HY001", "Unknown packet");
DEFINE_ERROR(OB_RPC_PACKET_TOO_LONG, -4119, -1, "08000", "RPC packet to send too long");
DEFINE_ERROR(OB_LOG_TOO_LARGE, -4120, -1, "HY000", "Log too large");
DEFINE_ERROR(OB_RPC_SEND_ERROR, -4121, 4012, "HY000", "RPC send error");
DEFINE_ERROR(OB_RPC_POST_ERROR, -4122, 4012, "HY000", "RPC post error");
DEFINE_ERROR(OB_LIBEASY_ERROR, -4123, -1, "08000", "Libeasy error");
DEFINE_ERROR(OB_CONNECT_ERROR, -4124, -1, "HY000", "Connect error");
DEFINE_ERROR(OB_NOT_FREE, -4125, -1, "HY000", "Not free");
DEFINE_ERROR(OB_INIT_SQL_CONTEXT_ERROR, -4126, -1, "HY000", "Init SQL context error");
DEFINE_ERROR(OB_SKIP_INVALID_ROW, -4127, -1, "42000", "Skip invalid row");
DEFINE_ERROR(OB_RPC_PACKET_INVALID, -4128, -1, "HY000", "RPC packet is invalid");
DEFINE_ERROR(OB_NO_TABLET, -4133, -1, "HY000", "No tablets");
DEFINE_ORACLE_ERROR(OB_SNAPSHOT_DISCARDED, -4138, -1, "HY000", "Request to read too old versioned data", 1555, "snapshot too old");
DEFINE_ERROR(OB_DATA_NOT_UPTODATE, -4139, -1, "HY000", "State is stale");
DEFINE_ERROR(OB_ROW_MODIFIED, -4142, -1, "HY000", "Row modified");
DEFINE_ERROR(OB_VERSION_NOT_MATCH, -4143, -1, "42000", "Version not match");
DEFINE_ERROR(OB_BAD_ADDRESS, -4144, -1, "42000", "Bad address");
DEFINE_ERROR(OB_ENQUEUE_FAILED, -4146, -1, "HY000", "Enqueue error");
DEFINE_ERROR_EXT(OB_INVALID_CONFIG, -4147, -1, "HY000", "Invalid config", "%s");
DEFINE_ERROR(OB_STMT_EXPIRED, -4149, -1, "HY000", "Expired statement");
DEFINE_ERROR(OB_ERR_MIN_VALUE, -4150, -1, "42000", "Min value");
DEFINE_ERROR(OB_ERR_MAX_VALUE, -4151, -1, "42000", "Max value");
DEFINE_ERROR_EXT(OB_ERR_NULL_VALUE, -4152, -1, "42000", "Null value", "%s");
DEFINE_ERROR(OB_RESOURCE_OUT, -4153, ER_OUT_OF_RESOURCES, "53000", "Out of resource");
DEFINE_ERROR(OB_ERR_SQL_CLIENT, -4154, -1, "HY000", "Internal SQL client error");
DEFINE_ERROR(OB_META_TABLE_WITHOUT_USE_TABLE, -4155, -1, "HY000", "Meta table without use table");
DEFINE_ERROR(OB_DISCARD_PACKET, -4156, -1, "HY000", "Discard packet");
DEFINE_ORACLE_ERROR_EXT(OB_OPERATE_OVERFLOW, -4157, ER_DATA_OUT_OF_RANGE, "22003", "value is out of range", "%s value is out of range in '%s'", 25137, "Data value out of range", "Data value %s out of range in '%s'");
DEFINE_ORACLE_ERROR_EXT(OB_INVALID_DATE_FORMAT, -4158, ER_TRUNCATED_WRONG_VALUE, "22007", "Incorrect value", "%s=%d must between %d and %d", 1821, "date format not recognized", "date format not recognized, %s=%d must between %d and %d");
DEFINE_ERROR(OB_POOL_REGISTERED_FAILED, -4159, -1, "HY000", "register pool failed");
DEFINE_ERROR(OB_POOL_UNREGISTERED_FAILED, -4160, -1, "HY000", "unregister pool failed");
DEFINE_ERROR(OB_INVALID_ARGUMENT_NUM, -4161, -1, "42000", "Invalid argument num");
DEFINE_ERROR(OB_LEASE_NOT_ENOUGH, -4162, -1, "HY000", "reserved lease not enough");
DEFINE_ERROR(OB_LEASE_NOT_MATCH, -4163, -1, "HY000", "ups lease not match with rs");
DEFINE_ERROR(OB_UPS_SWITCH_NOT_HAPPEN, -4164, -1, "HY000", "ups switch not happen");
DEFINE_ERROR(OB_EMPTY_RESULT, -4165, -1, "HY000", "Empty result");
DEFINE_ERROR(OB_CACHE_NOT_HIT, -4166, -1, "HY000", "Cache not hit");
DEFINE_ERROR(OB_NESTED_LOOP_NOT_SUPPORT, -4167, -1, "HY000", "Nested loop not support");
DEFINE_ERROR(OB_LOG_INVALID_MOD_ID, -4168, -1, "HY000", "Invalid log module id");
DEFINE_ERROR_EXT(OB_LOG_MODULE_UNKNOWN, -4169, -1, "HY000", "Unknown module name", "Unknown module name. Invalid Setting:'%.*s'. Syntax:parMod.subMod:level, parMod.subMod:level");
DEFINE_ERROR_EXT(OB_LOG_LEVEL_INVALID, -4170, -1, "HY000", "Invalid level", "Invalid level. Invalid setting:'%.*s'. Syntax:parMod.subMod:level, parMod.subMod:level");
DEFINE_ERROR_EXT(OB_LOG_PARSER_SYNTAX_ERR, -4171, -1, "HY000", "Syntax to set log_level error", "Syntax to set log_level error. Invalid setting:'%.*s'. Syntax:parMod.subMod:level, parMod.subMod:level");
DEFINE_ERROR(OB_INDEX_OUT_OF_RANGE, -4172, -1, "HY000", "Index out of range");
DEFINE_ERROR(OB_INT_UNDERFLOW, -4173, -1, "HY000", "Int underflow");
DEFINE_ERROR_EXT(OB_UNKNOWN_CONNECTION, -4174, ER_NO_SUCH_THREAD, "HY000", "Unknown thread id", "Unknown thread id: %lu");
DEFINE_ERROR(OB_ERROR_OUT_OF_RANGE, -4175, -1, "42000", "Out of range");
DEFINE_ERROR(OB_CACHE_SHRINK_FAILED, -4176, -1, "HY001", "shrink cache failed, no available cache");
DEFINE_ERROR(OB_OLD_SCHEMA_VERSION, -4177, -1, "42000", "Schema version too old");
DEFINE_ERROR(OB_RELEASE_SCHEMA_ERROR, -4178, -1, "HY000", "Release schema error");
DEFINE_ERROR_EXT(OB_OP_NOT_ALLOW, -4179, -1, "HY000", "Operation not allowed now", "%s not allowed");
DEFINE_ERROR(OB_NO_EMPTY_ENTRY, -4180, -1, "HY000", "No empty entry");
DEFINE_ERROR(OB_ERR_ALREADY_EXISTS, -4181, -1, "42S01", "Already exist");
DEFINE_ERROR(OB_SEARCH_NOT_FOUND, -4182, -1, "HY000", "Value not found");
DEFINE_ERROR(OB_BEYOND_THE_RANGE, -4183, -1, "HY000", "Key out of range");
DEFINE_ERROR(OB_CS_OUTOF_DISK_SPACE, -4184, -1, "53100", "ChunkServer out of disk space");
DEFINE_ERROR(OB_COLUMN_GROUP_NOT_FOUND, -4185, -1, "HY000", "Column group not found");
DEFINE_ERROR(OB_CS_COMPRESS_LIB_ERROR, -4186, -1, "HY000", "ChunkServer failed to get compress library");
DEFINE_ERROR(OB_ITEM_NOT_MATCH, -4187, -1, "HY000", "Item not match");
DEFINE_ERROR(OB_SCHEDULER_TASK_CNT_MISMATCH, -4188, -1, "HY000", "Running task cnt and unfinished task cnt not consistent");
DEFINE_ERROR(OB_INVALID_MACRO_BLOCK_TYPE, -4189, -1, "HY000", "the macro block type does not exist");
DEFINE_ORACLE_ERROR(OB_INVALID_DATE_FORMAT_END, -4190, ER_TRUNCATED_WRONG_VALUE, "22007", "Incorrect value", 1830, "date format picture ends before converting entire input string");
DEFINE_ERROR(OB_PG_IS_REMOVED, -4191, -1, "HY000", "partition group is removed");
DEFINE_ERROR_EXT(OB_HASH_EXIST, -4200, -1, "HY000", "hash map/set entry exist", "%s");
DEFINE_ERROR_EXT(OB_HASH_NOT_EXIST, -4201, -1, "HY000", "hash map/set entry not exist", "%s");
DEFINE_ERROR(OB_HASH_GET_TIMEOUT, -4204, -1, "HY000", "hash map/set get timeout");
DEFINE_ERROR(OB_HASH_PLACEMENT_RETRY, -4205, -1, "HY000", "hash map/set retry");
DEFINE_ERROR(OB_HASH_FULL, -4206, -1, "HY000", "hash map/set full");
DEFINE_ERROR(OB_PACKET_PROCESSED, -4207, -1, "HY000", "packet processed");
DEFINE_ERROR(OB_WAIT_NEXT_TIMEOUT, -4208, -1, "HY000", "wait next packet timeout");
DEFINE_ERROR(OB_LEADER_NOT_EXIST, -4209, -1, "HY000", "partition has not leader");
DEFINE_ERROR(OB_PREPARE_MAJOR_FREEZE_FAILED, -4210, -1, "HY000", "prepare major freeze failed");
DEFINE_ERROR(OB_COMMIT_MAJOR_FREEZE_FAILED, -4211, -1, "HY000", "commit major freeze failed");
DEFINE_ERROR(OB_ABORT_MAJOR_FREEZE_FAILED, -4212, -1, "HY000", "abort major freeze failed");
DEFINE_ERROR(OB_MAJOR_FREEZE_NOT_FINISHED, -4213, -1, "HY000", "last major freeze not finish");
DEFINE_ERROR(OB_PARTITION_NOT_LEADER, -4214, -1, "HY000", "partition is not leader partition");
DEFINE_ERROR(OB_WAIT_MAJOR_FREEZE_RESPONSE_TIMEOUT, -4215, -1, "HY000", "wait major freeze response timeout");
DEFINE_ERROR(OB_CURL_ERROR, -4216, -1, "HY000", "curl error");
DEFINE_ERROR_EXT(OB_MAJOR_FREEZE_NOT_ALLOW, -4217, -1, "HY000", "Major freeze not allowed now", "%s");
DEFINE_ERROR(OB_PREPARE_FREEZE_FAILED, -4218, -1, "HY000", "prepare freeze failed");
DEFINE_ORACLE_ERROR_EXT(OB_INVALID_DATE_VALUE, -4219, ER_TRUNCATED_WRONG_VALUE, "22007", "Incorrect value", "Incorrect datetime value: '%s' for column '%s'", 1861, "literal does not match format string", "literal does not match format string: '%s' for column '%s'");
DEFINE_OTHER_MSG_FMT(OB_ERR_INVALID_DATE_MSG_FMT_V2, OB_INVALID_DATE_VALUE, "Incorrect datetime value for column '%.*s' at row %ld", "Incorrect datetime value for column '%.*s' at row %ld")
DEFINE_ERROR(OB_INACTIVE_SQL_CLIENT, -4220, -1, "HY000", "Inactive sql client, only read allowed");
DEFINE_ERROR(OB_INACTIVE_RPC_PROXY, -4221, -1, "HY000", "Inactive rpc proxy, can not send RPC request");
DEFINE_ERROR(OB_INTERVAL_WITH_MONTH, -4222, -1, "42000", "Interval with year or month can not be converted to microseconds");
DEFINE_ERROR(OB_TOO_MANY_DATETIME_PARTS, -4223, -1, "42000", "Interval has too many datetime parts");
DEFINE_ORACLE_ERROR_EXT(OB_DATA_OUT_OF_RANGE, -4224, ER_WARN_DATA_OUT_OF_RANGE, "22003", "Out of range value for column", "Out of range value for column '%.*s' at row %ld", 1438, "value larger than specified precision allowed for this column", "value larger than specified precision allowed for this column '%.*s' at row %ld");
DEFINE_ERROR(OB_PARTITION_NOT_EXIST, -4225, -1, "HY000", "Partition entry not exists");
DEFINE_ERROR_EXT(OB_ERR_TRUNCATED_WRONG_VALUE_FOR_FIELD, -4226, ER_TRUNCATED_WRONG_VALUE_FOR_FIELD, "HY000", "Incorrect integer value", "Incorrect integer value: '%.*s'");
DEFINE_ERROR_EXT(OB_ERR_NO_DEFAULT_FOR_FIELD, -4227, ER_NO_DEFAULT_FOR_FIELD, "HY000", "Field doesn't have a default value", "Field \'%s\' doesn't have a default value");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_FIELD_SPECIFIED_TWICE, -4228, ER_FIELD_SPECIFIED_TWICE, "42000", "Column specified twice", "Column \'%s\' specified twice", 957, "duplicate column name", "duplicate column name \'%s\'");
DEFINE_ERROR_EXT(OB_ERR_TOO_LONG_TABLE_COMMENT, -4229, ER_TOO_LONG_TABLE_COMMENT, "HY000", "Comment for table is too long", "Comment for table is too long (max = %ld)");
DEFINE_ERROR_EXT(OB_ERR_TOO_LONG_FIELD_COMMENT, -4230, ER_TOO_LONG_FIELD_COMMENT, "HY000", "Comment for field is too long", "Comment for field is too long (max = %ld)");
DEFINE_ERROR_EXT(OB_ERR_TOO_LONG_INDEX_COMMENT, -4231, ER_TOO_LONG_INDEX_COMMENT, "HY000", "Comment for index is too long", "Comment for index is too long (max = %ld)");
DEFINE_ERROR(OB_NOT_FOLLOWER, -4232, -1, "HY000", "The observer or zone is not a follower");
DEFINE_ERROR(OB_ERR_OUT_OF_LOWER_BOUND, -4233, -1, "HY000", "smaller than container lower bound");
DEFINE_ERROR(OB_ERR_OUT_OF_UPPER_BOUND, -4234, -1, "HY000", "bigger than container upper bound");
DEFINE_ORACLE_ERROR_EXT(OB_BAD_NULL_ERROR, -4235, ER_BAD_NULL_ERROR, "23000", "Column cannot be null", "Column '%.*s' cannot be null", 1400, "cannot insert NULL", "cannot insert NULL into '(%.*s)'");
DEFINE_ERROR(OB_OBCONFIG_RETURN_ERROR, -4236, -1, "HY000", "ObConfig return error code");
DEFINE_ERROR(OB_OBCONFIG_APPNAME_MISMATCH, -4237, -1, "HY000", "Appname mismatch with obconfig result");
DEFINE_ERROR(OB_ERR_VIEW_SELECT_DERIVED, -4238, ER_VIEW_SELECT_DERIVED, "HY000", "View's SELECT contains a subquery in the FROM clause");
DEFINE_ERROR(OB_CANT_MJ_PATH, -4239, -1, "HY000", "Can not use merge-join to join the tables without join conditions");
DEFINE_ERROR(OB_ERR_NO_JOIN_ORDER_GENERATED, -4240, -1, "HY000", "No join order generated");
DEFINE_ERROR(OB_ERR_NO_PATH_GENERATED, -4241, -1, "HY000", "No join path generated");
DEFINE_ERROR(OB_ERR_WAIT_REMOTE_SCHEMA_REFRESH, -4242, -1, "HY000", "Schema error");
DEFINE_ERROR(OB_FILE_NOT_OPENED, -4243, -1, "HY000", "file not opened");
DEFINE_ERROR(OB_TIMER_TASK_HAS_SCHEDULED, -4244, -1, "HY000", "Timer task has been scheduled");
DEFINE_ERROR(OB_TIMER_TASK_HAS_NOT_SCHEDULED, -4245, -1, "HY000", "Timer task has not been scheduled");
DEFINE_ERROR(OB_PARSE_DEBUG_SYNC_ERROR, -4246, -1, "HY000", "parse debug sync string error");
DEFINE_ERROR(OB_UNKNOWN_DEBUG_SYNC_POINT, -4247, -1, "HY000", "unknown debug sync point");
DEFINE_ERROR(OB_ERR_INTERRUPTED, -4248, -1, "HY000", "task is interrupted while running");
DEFINE_ERROR_EXT(OB_ERR_DATA_TRUNCATED, -4249, WARN_DATA_TRUNCATED, "01000", "Data truncated for argument", "Data truncated for column '%.*s' at row %ld");
// used by modules in partition service only, and not returned to client
DEFINE_ERROR(OB_NOT_RUNNING, -4250, -1, "HY000", "module is not running");
DEFINE_ERROR(OB_INVALID_PARTITION, -4251, -1, "HY000", "partition not valid");
DEFINE_ERROR(OB_ERR_TIMEOUT_TRUNCATED, -4252, WARN_DATA_TRUNCATED, "01000", "Timeout value truncated to 102 years");
DEFINE_ERROR_EXT(OB_ERR_TOO_LONG_TENANT_COMMENT, -4253, -1, "HY000", "Comment for tenant is too long", "Comment for tenant is too long (max = %ld)");
DEFINE_ERROR(OB_ERR_NET_PACKET_TOO_LARGE, -4254, ER_NET_PACKET_TOO_LARGE, "08S01", "Got a packet bigger than \'max_allowed_packet\' bytes");
DEFINE_ERROR(OB_TRACE_DESC_NOT_EXIST, -4255, -1, "HY000", "trace log title or key not exist describle");
DEFINE_ERROR_EXT(OB_ERR_NO_DEFAULT, -4256, ER_NO_DEFAULT, "42000", "Variable doesn't have a default value", "Variable '%.*s' doesn't have a default value");
DEFINE_ERROR(OB_ERR_COMPRESS_DECOMPRESS_DATA, -4257, -1, "HY000", "compress data or decompress data failed");
DEFINE_ERROR_EXT(OB_ERR_INCORRECT_STRING_VALUE, -4258, ER_TRUNCATED_WRONG_VALUE_FOR_FIELD, "HY000", "Incorrect string value", "Incorrect string value for column '%.*s' at row %ld");
DEFINE_ERROR_EXT(OB_ERR_DISTRIBUTED_NOT_SUPPORTED, -4259, ER_NOT_SUPPORTED_YET, "0A000", "Not supported feature or function", "%s not supported");
DEFINE_ERROR(OB_IS_CHANGING_LEADER, -4260, -1, "HY000", "the partition is changing leader");
DEFINE_ERROR(OB_DATETIME_FUNCTION_OVERFLOW, -4261, ER_DATETIME_FUNCTION_OVERFLOW, "22008", "Datetime overflow");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_DOUBLE_TRUNCATED, -4262, ER_TRUNCATED_WRONG_VALUE, "01000", "Truncated incorrect DOUBLE value", "Truncated incorrect DOUBLE value: '%.*s'", 1722, "invalid number", "invalid number: '%.*s'");
DEFINE_ERROR_EXT(OB_MINOR_FREEZE_NOT_ALLOW, -4263, -1, "HY000", "Minor freeze not allowed now", "%s");
DEFINE_ERROR(OB_LOG_OUTOF_DISK_SPACE, -4264, -1, "HY000", "Log out of disk space");
DEFINE_ERROR(OB_RPC_CONNECT_ERROR, -4265, -1, "HY000", "Rpc connect error");
DEFINE_ERROR(OB_MINOR_MERGE_NOT_ALLOW, -4266, -1, "HY000", "minor merge not allow");
DEFINE_ERROR(OB_CACHE_INVALID, -4267, -1, "HY000", "Cache invalid");
DEFINE_ERROR(OB_REACH_SERVER_DATA_COPY_IN_CONCURRENCY_LIMIT, -4268, -1, "HY000", "reach server data copy in concurrency");
DEFINE_ERROR(OB_WORKING_PARTITION_EXIST, -4269, -1, "HY000", "Working partition entry already exists");
DEFINE_ERROR(OB_WORKING_PARTITION_NOT_EXIST, -4270, -1, "HY000", "Working partition entry does not exists");
DEFINE_ERROR(OB_LIBEASY_REACH_MEM_LIMIT, -4271, -1, "HY000", "LIBEASY reach memory limit");
DEFINE_ERROR_EXT(OB_MISS_ARGUMENT, -4272, ER_WRONG_ARGUMENTS, "HY000", "Miss argument", "Miss argument for %s");
DEFINE_ERROR(OB_CACHE_FREE_BLOCK_NOT_ENOUGH, -4273, -1, "HY000", "free memblock in cache is not enough");
DEFINE_ERROR(OB_SYNC_WASH_MB_TIMEOUT, -4274, -1, "HY000", "sync wash memblock timeout");
DEFINE_ERROR(OB_NOT_ALLOW_MIGRATE_IN, -4275, -1, "HY000", "not allow migrate in");
DEFINE_ERROR(OB_SCHEDULER_TASK_CNT_MISTACH, -4276, -1, "HY000", "Scheduler task cnt does not match")
DEFINE_ERROR_EXT(OB_MISS_ARGUMENT, -4277, ER_WRONG_ARGUMENTS, "HY000", "Miss argument", "Miss argument for %s");
DEFINE_ERROR(OB_LAST_LOG_NOT_COMPLETE, -4278, -1, "HY000", "last log is not complete");
DEFINE_ERROR(OB_TABLE_IS_DELETED, -4279, -1, "HY000", "table is deleted");
DEFINE_ERROR(OB_VERSION_RANGE_NOT_CONTINUES, -4280, -1, "HY000", "version range not continues");
DEFINE_ERROR(OB_INVALID_IO_BUFFER, -4281, -1, "HY000", "io buffer is invalid");
DEFINE_ERROR(OB_PARTITION_IS_REMOVED, -4282, -1, "HY000", "partition is removed");
DEFINE_ERROR(OB_GTS_NOT_READY, -4283, -1, "HY000", "gts is not ready");
DEFINE_ERROR(OB_MAJOR_SSTABLE_NOT_EXIST, -4284, -1, "HY000", "major sstable not exist");
DEFINE_ERROR(OB_VERSION_RANGE_DISCARDED, -4285, -1, "HY000", "Request to read too old version range data");
DEFINE_ERROR(OB_MAJOR_SSTABLE_HAS_MERGED, -4286, -1, "HY000", "major sstable may has been merged");
DEFINE_ERROR(OB_MINOR_SSTABLE_RANGE_CROSS, -4287, -1, "HY000", "minor sstable version range cross");
DEFINE_ERROR(OB_MEMTABLE_CANNOT_MINOR_MERGE, -4288, -1, "HY000", "memtable cannot minor merge");
DEFINE_ERROR(OB_TASK_EXIST, -4289, -1, "HY000", "task exist");
DEFINE_ERROR(OB_ALLOCATE_DISK_SPACE_FAILED, -4290, -1, "HY000", "cannot allocate disk space");
DEFINE_ERROR_EXT(OB_CANT_FIND_UDF, -4291, ER_CANT_FIND_UDF, "HY000", "Can't load function", "Can not load function %s");
DEFINE_ERROR_EXT(OB_CANT_INITIALIZE_UDF, -4292, ER_CANT_INITIALIZE_UDF, "HY000", "Can't initialize function", "Can not initialize function '%.*s'");
DEFINE_ERROR(OB_UDF_NO_PATHS, -4293, ER_UDF_NO_PATHS, "HY000", "No paths allowed for shared library");
DEFINE_ERROR_EXT(OB_UDF_EXISTS, -4294, ER_UDF_EXISTS, "HY000", "Function already exists", "Function %.*s already exists");
DEFINE_ERROR_EXT(OB_CANT_OPEN_LIBRARY, -4295, ER_CANT_OPEN_LIBRARY, "HY000", "Can't open shared library", "Can not open shared library '%.*s'");
DEFINE_ERROR_EXT(OB_CANT_FIND_DL_ENTRY, -4296, ER_CANT_FIND_DL_ENTRY, "HY000", "Can't find symbol", "Can't find symbol %.*s in library");
DEFINE_ERROR(OB_OBJECT_NAME_EXIST, -4297, -1, "HY000", "name is already used by an existing object");
DEFINE_ORACLE_ERROR_EXT(OB_OBJECT_NAME_NOT_EXIST, -4298, -1, "HY000", "object does not exist", "%s does not exist", 2289, "object does not exist", "%s does not exist");
DEFINE_ERROR_EXT(OB_ERR_DUP_ARGUMENT, -4299, ER_DUP_ARGUMENT, "HY000", "Option used twice in statement", "Option '%s' used twice in statement");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_SEQUENCE_NAME, -4300,-1, "HY000", "invalid sequence name", 2277, "invalid sequence name");
DEFINE_ORACLE_ERROR(OB_ERR_DUP_MAXVALUE_SPEC, -4301,-1, "HY000", "duplicate MAXVALUE/NOMAXVALUE specifications", 2278, "duplicate MAXVALUE/NOMAXVALUE specifications");
DEFINE_ORACLE_ERROR(OB_ERR_DUP_MINVALUE_SPEC, -4302,-1, "HY000", "duplicate MINVALUE/NOMINVALUE specifications", 2279, "duplicate MINVALUE/NOMINVALUE specifications");
DEFINE_ORACLE_ERROR(OB_ERR_DUP_CYCLE_SPEC, -4303,-1, "HY000", "duplicate CYCLE/NOCYCLE specifications", 2280, "duplicate CYCLE/NOCYCLE specifications");
DEFINE_ORACLE_ERROR(OB_ERR_DUP_CACHE_SPEC, -4304,-1, "HY000", "duplicate CACHE/NOCACHE specifications", 2281, "duplicate CACHE/NOCACHE specifications");
DEFINE_ORACLE_ERROR(OB_ERR_DUP_ORDER_SPEC, -4305,-1, "HY000", "duplicate ORDER/NOORDER specifications", 2282, "duplicate ORDER/NOORDER specifications");
DEFINE_ORACLE_ERROR(OB_ERR_CONFL_MAXVALUE_SPEC, -4306,-1, "HY000", "conflicting MAXVALUE/NOMAXVALUE specifications", 2278, "conflicting MAXVALUE/NOMAXVALUE specifications");
DEFINE_ORACLE_ERROR(OB_ERR_CONFL_MINVALUE_SPEC, -4307,-1, "HY000", "conflicting MINVALUE/NOMINVALUE specifications", 2279, "conflicting MINVALUE/NOMINVALUE specifications");
DEFINE_ORACLE_ERROR(OB_ERR_CONFL_CYCLE_SPEC, -4308,-1, "HY000", "conflicting CYCLE/NOCYCLE specifications", 2280, "conflicting CYCLE/NOCYCLE specifications");
DEFINE_ORACLE_ERROR(OB_ERR_CONFL_CACHE_SPEC, -4309,-1, "HY000", "conflicting CACHE/NOCACHE specifications", 2281, "conflicting CACHE/NOCACHE specifications");
DEFINE_ORACLE_ERROR(OB_ERR_CONFL_ORDER_SPEC, -4310,-1, "HY000", "conflicting ORDER/NOORDER specifications", 2282, "conflicting ORDER/NOORDER specifications");
DEFINE_ORACLE_ERROR(OB_ERR_ALTER_START_SEQ_NUMBER_NOT_ALLOWED, -4311,-1, "HY000", "cannot alter starting sequence number", 2283, "cannot alter starting sequence number");
DEFINE_ORACLE_ERROR(OB_ERR_DUP_INCREMENT_BY_SPEC, -4312,-1, "HY000", "duplicate INCREMENT BY specifications", 2284, "duplicate INCREMENT BY specifications",);
DEFINE_ORACLE_ERROR(OB_ERR_DUP_START_WITH_SPEC, -4313,-1, "HY000", "duplicate START WITH specifications", 2285, "duplicate START WITH specifications",);
DEFINE_ORACLE_ERROR(OB_ERR_REQUIRE_ALTER_SEQ_OPTION, -4314,-1, "HY000", "no options specified for ALTER SEQUENCE", 2286, "no options specified for ALTER SEQUENCE");
DEFINE_ORACLE_ERROR(OB_ERR_SEQ_NOT_ALLOWED_HERE, -4315,-1, "HY000", "sequence number not allowed here", 2287, "sequence number not allowed here");
DEFINE_ORACLE_ERROR(OB_ERR_SEQ_NOT_EXIST, -4316,-1, "HY000", "sequence does not exist", 2289, "sequence does not exist");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_SEQ_OPTION_MUST_BE_INTEGER, -4317,-1, "HY000","sequence parameter must be an integer", "sequence parameter %s must be an integer", 4001, "sequence parameter must be an integer","sequence parameter %s must be an integer");
DEFINE_ORACLE_ERROR(OB_ERR_SEQ_INCREMENT_CAN_NOT_BE_ZERO, -4318,-1, "HY000", "INCREMENT must be a nonzero integer", 4002, "INCREMENT must be a nonzero integer");
DEFINE_ORACLE_ERROR(OB_ERR_SEQ_OPTION_EXCEED_RANGE, -4319,-1, "HY000", "sequence parameter exceeds maximum size allowed", 4003, "sequence parameter exceeds maximum size allowed");
DEFINE_ORACLE_ERROR(OB_ERR_MINVALUE_LARGER_THAN_MAXVALUE, -4320,-1, "HY000", "MINVALUE must be less than MAXVALUE", 4004, "MINVALUE must be less than MAXVALUE");
DEFINE_ORACLE_ERROR(OB_ERR_SEQ_INCREMENT_TOO_LARGE, -4321,-1, "HY000", "INCREMENT must be less than MAXVALUE minus MINVALUE", 4005, "INCREMENT must be less than MAXVALUE minus MINVALUE");
DEFINE_ORACLE_ERROR(OB_ERR_START_WITH_LESS_THAN_MINVALUE, -4322,-1, "HY000", "START WITH cannot be less than MINVALUE", 4006, "START WITH cannot be less than MINVALUE");
DEFINE_ORACLE_ERROR(OB_ERR_MINVALUE_EXCEED_CURRVAL, -4323,-1, "HY000", "MINVALUE cannot be made to exceed the current value", 4007, "MINVALUE cannot be made to exceed the current value");
DEFINE_ORACLE_ERROR(OB_ERR_START_WITH_EXCEED_MAXVALUE, -4324,-1, "HY000", "START WITH cannot be more than MAXVALUE", 4008, "START WITH cannot be more than MAXVALUE");
DEFINE_ORACLE_ERROR(OB_ERR_MAXVALUE_EXCEED_CURRVAL, -4325,-1, "HY000", "MAXVALUE cannot be made to be less than the current value", 4009, "MAXVALUE cannot be made to be less than the current value");
DEFINE_ORACLE_ERROR(OB_ERR_SEQ_CACHE_TOO_SMALL, -4326,-1, "HY000", "the number of values to CACHE must be greater than 1", 4010, "the number of values to CACHE must be greater than 1");
DEFINE_ORACLE_ERROR(OB_ERR_SEQ_OPTION_OUT_OF_RANGE, -4327,-1, "HY000", "sequence option value out of range", 4011, "sequence option value out of range");
DEFINE_ORACLE_ERROR(OB_ERR_SEQ_CACHE_TOO_LARGE, -4328,-1, "HY000", "number to CACHE must be less than one cycle", 4013, "number to CACHE must be less than one cycle");
DEFINE_ORACLE_ERROR(OB_ERR_SEQ_REQUIRE_MINVALUE, -4329,-1, "HY000", "descending sequences that CYCLE must specify MINVALUE", 4014, "descending sequences that CYCLE must specify MINVALUE");
DEFINE_ORACLE_ERROR(OB_ERR_SEQ_REQUIRE_MAXVALUE, -4330,-1, "HY000", "ascending sequences that CYCLE must specify MAXVALUE", 4015, "ascending sequences that CYCLE must specify MAXVALUE");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_SEQ_NO_LONGER_EXIST, -4331,-1, "HY000", "sequence no longer exists", "sequence %s no longer exists", 4015, "sequence no longer exists", "sequence %s no longer exists");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_SEQ_VALUE_EXCEED_LIMIT, -4332, -1, "HY000", "sequence exceeds limit and cannot be instantiated", "sequence exceeds %s and cannot be instantiated", 8004, "sequence exceeds limit and cannot be instantiated", "sequence exceeds %s and cannot be instantiated");
DEFINE_ORACLE_ERROR(OB_ERR_DIVISOR_IS_ZERO, -4333,-1, "HY000", "divisor is equal to zero", 1476, "divisor is equal to zero");
DEFINE_ERROR(OB_ERR_AES_IV_LENGTH, -4336, ER_AES_INVALID_IV, "HY000", "The initialization vector supplied to aes_encrypt is too short. Must be at least 16 bytes long");
DEFINE_ERROR(OB_STORE_DIR_ERROR, -4337, -1, "HY000", "store directory structure error");
DEFINE_ERROR(OB_OPEN_TWICE, -4338, -1, "HY000", "open twice");
DEFINE_ERROR(OB_RAID_SUPER_BLOCK_NOT_MATCH, -4339, -1, "HY000", "raid super block not match");
DEFINE_ERROR(OB_NOT_OPEN, -4340, -1, "HY000", "not opened");
DEFINE_ERROR(OB_NOT_IN_SERVICE, -4341, -1, "HY000", "target module is not in service");
DEFINE_ERROR(OB_RAID_DISK_NOT_NORMAL, -4342, -1, "HY000", "raid disk not in normal status");
DEFINE_ERROR(OB_TENANT_SCHEMA_NOT_FULL, -4343, -1, "HY000", "tenant schema is not full");
DEFINE_ORACLE_ERROR(OB_INVALID_QUERY_TIMESTAMP, -4344, -1, "HY000", "invalid timestamp", 8186, "invalid timestamp");
DEFINE_ERROR(OB_DIR_NOT_EMPTY, -4345, -1, "HY000", "dir not empty");
DEFINE_ERROR(OB_SCHEMA_NOT_UPTODATE, -4346, -1, "HY000", "schema is not up to date for read");
DEFINE_ORACLE_ERROR_EXT(OB_ROLE_NOT_EXIST, -4347, -1, "HY000", "role does not exist", "role '%.*s' does not exist", 1919, "role does not exist", "role '%.*s' does not exist");
DEFINE_ORACLE_ERROR_EXT(OB_ROLE_EXIST, -4348, -1, "HY000", "role exists", "role '%.*s' exists", 1921, "role name conflicts with another user or role name", "role name '%.*s' conflicts with another user or role name");
DEFINE_ORACLE_ERROR(OB_PRIV_DUP, -4349, -1, "HY000", "duplicate privilege listed", 1711, "duplicate privilege listed");
DEFINE_ERROR(OB_KEYSTORE_EXIST, -4350, -1, "HY000", "the keystore already exists and each tenant can only have at most one");
DEFINE_ERROR(OB_KEYSTORE_NOT_EXIST, -4351, -1, "HY000", "the keystore is not exist");
DEFINE_ERROR(OB_KEYSTORE_WRONG_PASSWORD, -4352, -1, "HY000", "the password is wrong for keystore");
DEFINE_ORACLE_ERROR_EXT(OB_TABLESPACE_EXIST, -4353, -1, "HY000", "tablespace already exists", "tablespace '%.*s' already exists", 1543, "tablespace already exists", "tablespace '%.*s' already exists");
DEFINE_ORACLE_ERROR_EXT(OB_TABLESPACE_NOT_EXIST, -4354, -1, "HY000", "tablespace does not exist", "tablespace '%.*s' does not exist", 959, "tablespace does not exist", "tablespace '%.*s' does not exist");
DEFINE_ERROR(OB_TABLESPACE_DELETE_NOT_EMPTY, -4355, -1, "HY000", "cannot delete a tablespace which is not empty");
DEFINE_ORACLE_ERROR(OB_FLOAT_PRECISION_OUT_RANGE, -4356, -1, "HY000", "floating point precision is out of range (1 to 126)", 1724, "floating point precision is out of range (1 to 126)");
DEFINE_ORACLE_ERROR(OB_NUMERIC_PRECISION_OUT_RANGE, -4357, -1, "HY000", "numeric precision specifier is out of range (1 to 38)", 1727, "numeric precision specifier is out of range (1 to 38)");
DEFINE_ORACLE_ERROR(OB_NUMERIC_SCALE_OUT_RANGE, -4358, -1, "HY000", "numeric scale specifier is out of range (-84 to 127)", 1728, "numeric scale specifier is out of range (-84 to 127)");
DEFINE_ERROR(OB_KEYSTORE_NOT_OPEN, -4359, -1, "HY000", "the keystore is not open");
DEFINE_ERROR(OB_KEYSTORE_OPEN_NO_MASTER_KEY, -4360, -1, "HY000", "the keystore opened with dont have a master key");
DEFINE_ERROR(OB_SLOG_REACH_MAX_CONCURRENCY, -4361, -1, "HY000", "slog active transaction entries reach maximum");
DEFINE_ERROR(OB_ERR_NOT_VALID_PASSWORD, -4365, ER_NOT_VALID_PASSWORD, "HY000", "Your password does not satisfy the current policy requirements");
DEFINE_ORACLE_ERROR(OB_ERR_MUST_CHANGE_PASSWORD, -4366, ER_MUST_CHANGE_PASSWORD, "HY000", "You must reset your password using ALTER USER statement before executing this statement", 28001, "the password has expired");
DEFINE_ERROR(OB_OVERSIZE_NEED_RETRY, -4367, ER_OVERSIZE_NEED_RETRY, "HY000", "The data more than 64M(rpc limit), split into smaller task and retry");
DEFINE_ERROR(OB_OBCONFIG_CLUSTER_NOT_EXIST, -4368, -1, "HY000", "cluster not exists", "cluster %s not exist");
DEFINE_ORACLE_ERROR(OB_ERR_VALUE_LARGER_THAN_ALLOWED, -4374, -1, "HY000", "value larger than specified precision allowed for this column", 1438, "value larger than specified precision allowed for this column");
DEFINE_ERROR(OB_DISK_ERROR, -4375, -1, "HY000", "observer has disk error");
DEFINE_ORACLE_ERROR(OB_UNIMPLEMENTED_FEATURE, -4376, -1, "HY000", "unimplemented feature", 3001, "unimplemented feature");

////////////////////////////////////////////////////////////////
//error code for root server & server management -4500 ---- -5000
////////////////////////////////////////////////////////////////
DEFINE_ERROR(OB_IMPORT_NOT_IN_SERVER, -4505, -1, "HY000", "Import not in service");
DEFINE_ERROR(OB_CONVERT_ERROR, -4507, -1, "42000", "Convert error");
DEFINE_ERROR(OB_BYPASS_TIMEOUT, -4510, -1, "HY000", "Bypass timeout");
DEFINE_ERROR(OB_RS_STATE_NOT_ALLOW, -4512, -1, "HY000", "RootServer state error");
DEFINE_ERROR(OB_NO_REPLICA_VALID, -4515, -1, "HY000", "No replica is valid");
DEFINE_ERROR(OB_NO_NEED_UPDATE, -4517, -1, "HY000", "No need to update");
DEFINE_ERROR(OB_CACHE_TIMEOUT, -4518, -1, "HY000", "Cache timeout");
DEFINE_ERROR(OB_ITER_STOP, -4519, -1, "HY000", "Iteration was stopped");
DEFINE_ERROR(OB_ZONE_ALREADY_MASTER, -4523, -1, "HY000", "The zone is the master already");
DEFINE_ERROR(OB_IP_PORT_IS_NOT_SLAVE_ZONE, -4524, -1, "HY000", "Not slave zone");
DEFINE_ERROR(OB_ZONE_IS_NOT_SLAVE, -4525, -1, "HY000", "Not slave zone");
DEFINE_ERROR(OB_ZONE_IS_NOT_MASTER, -4526, -1, "HY000", "Not master zone");
DEFINE_ERROR(OB_CONFIG_NOT_SYNC, -4527, -1, "F0000", "Configuration not sync");
DEFINE_ERROR(OB_IP_PORT_IS_NOT_ZONE, -4528, -1, "42000", "Not a zone address");
DEFINE_ERROR(OB_MASTER_ZONE_NOT_EXIST, -4529, -1, "HY000", "Master zone not exist");
DEFINE_ERROR_EXT(OB_ZONE_INFO_NOT_EXIST, -4530, -1, "HY000", "Zone info not exist", "Zone info \'%s\' not exist");
DEFINE_ERROR(OB_GET_ZONE_MASTER_UPS_FAILED, -4531, -1, "HY000", "Failed to get master UpdateServer");
DEFINE_ERROR(OB_MULTIPLE_MASTER_ZONES_EXIST, -4532, -1, "HY000", "Multiple master zones");
DEFINE_ERROR(OB_INDEXING_ZONE_INVALID, -4533, -1, "HY000", "indexing zone is not exist anymore or not active");
DEFINE_ERROR(OB_ROOT_TABLE_RANGE_NOT_EXIST, -4537, -1, "HY000", "Tablet range not exist");
DEFINE_ERROR(OB_ROOT_MIGRATE_CONCURRENCY_FULL, -4538, -1, "HY000", "Migrate concurrency full");
DEFINE_ERROR(OB_ROOT_MIGRATE_INFO_NOT_FOUND, -4539, -1, "HY000", "Migrate info not found");
DEFINE_ERROR(OB_NOT_DATA_LOAD_TABLE, -4540, -1, "HY000", "No data to load");
DEFINE_ERROR(OB_DATA_LOAD_TABLE_DUPLICATED, -4541, -1, "HY000", "Duplicated table data to load");
DEFINE_ERROR(OB_ROOT_TABLE_ID_EXIST, -4542, -1, "HY000", "Table ID exist");
DEFINE_ERROR(OB_INDEX_TIMEOUT, -4543, -1, "HY000", "Building index timeout");
DEFINE_ERROR(OB_ROOT_NOT_INTEGRATED, -4544, -1, "42000", "Root not integrated");
DEFINE_ERROR(OB_INDEX_INELIGIBLE, -4545, -1, "HY000", "index data not unique");
DEFINE_ERROR(OB_REBALANCE_EXEC_TIMEOUT, -4546, -1, "HY000", "execute replication or migration task timeout");
DEFINE_ERROR(OB_MERGE_NOT_STARTED, -4547, -1, "HY000", "global merge not started");
DEFINE_ERROR(OB_MERGE_ALREADY_STARTED, -4548, -1, "HY000", "merge already started");
DEFINE_ERROR(OB_ROOTSERVICE_EXIST, -4549, -1, "HY000", "rootservice already exist");
DEFINE_ERROR(OB_RS_SHUTDOWN, -4550, -1, "HY000", "rootservice is shutdown");
DEFINE_ERROR(OB_SERVER_MIGRATE_IN_DENIED, -4551, -1, "HY000", "server migrate in denied");
DEFINE_ERROR(OB_REBALANCE_TASK_CANT_EXEC, -4552, -1, "HY000", "rebalance task can not executing now");
DEFINE_ERROR(OB_PARTITION_CNT_REACH_ROOTSERVER_LIMIT, -4553, -1, "HY000", "rootserver can not hold more partition");
DEFINE_ERROR(OB_REBALANCE_TASK_NOT_IN_PROGRESS, -4554, -1, "HY000", "rebalance task not in progress on observer");
DEFINE_ERROR(OB_DATA_SOURCE_NOT_EXIST, -4600, -1, "HY000", "Data source not exist");
DEFINE_ERROR(OB_DATA_SOURCE_TABLE_NOT_EXIST, -4601, -1, "HY000", "Data source table not exist");
DEFINE_ERROR(OB_DATA_SOURCE_RANGE_NOT_EXIST, -4602, -1, "HY000", "Data source range not exist");
DEFINE_ERROR(OB_DATA_SOURCE_DATA_NOT_EXIST, -4603, -1, "HY000", "Data source data not exist");
DEFINE_ERROR(OB_DATA_SOURCE_SYS_ERROR, -4604, -1, "HY000", "Data source sys error");
DEFINE_ERROR(OB_DATA_SOURCE_TIMEOUT, -4605, -1, "HY000", "Data source timeout");
DEFINE_ERROR(OB_DATA_SOURCE_CONCURRENCY_FULL, -4606, -1, "53000", "Data source concurrency full");
DEFINE_ERROR(OB_DATA_SOURCE_WRONG_URI_FORMAT, -4607, -1, "42000", "Data source wrong URI format");

DEFINE_ERROR(OB_SSTABLE_VERSION_UNEQUAL, -4608, -1, "42000", "SSTable version not equal");
DEFINE_ERROR(OB_UPS_RENEW_LEASE_NOT_ALLOWED, -4609, -1, "HY000", "ups should not renew its lease");
DEFINE_ERROR(OB_UPS_COUNT_OVER_LIMIT, -4610, -1, "HY000", "ups count over limit");
DEFINE_ERROR(OB_NO_UPS_MAJORITY, -4611, -1, "HY000", "ups not form a majority");
DEFINE_ERROR(OB_INDEX_COUNT_REACH_THE_LIMIT, -4613, -1, "HY000", "created index tables count has reach the limit:128");
DEFINE_ERROR(OB_TASK_EXPIRED, -4614, -1, "HY000", "task expired");
DEFINE_ERROR(OB_TABLEGROUP_NOT_EMPTY, -4615, -1, "HY000", "tablegroup is not empty");
DEFINE_ERROR(OB_INVALID_SERVER_STATUS, -4620, -1, "HY000", "server status is not valid");
DEFINE_ERROR(OB_WAIT_ELEC_LEADER_TIMEOUT, -4621, -1, "HY000", "wait elect partition leader timeout");
DEFINE_ERROR(OB_WAIT_ALL_RS_ONLINE_TIMEOUT, -4622, -1, "HY000", "wait all rs online timeout");
DEFINE_ERROR(OB_ALL_REPLICAS_ON_MERGE_ZONE, -4623, -1, "HY000", "all replicas of partition group are on zones to merge");
DEFINE_ERROR_EXT(OB_MACHINE_RESOURCE_NOT_ENOUGH, -4624, -1, "HY000", "machine resource is not enough to hold a new unit", " machine resource \'%s\' is not enough to hold a new unit");
DEFINE_ERROR(OB_NOT_SERVER_CAN_HOLD_SOFTLY, -4625, -1, "HY000", "not server can hole the unit and not over soft limit");
DEFINE_ERROR_EXT(OB_RESOURCE_POOL_ALREADY_GRANTED, -4626, -1, "HY000", "resource pool has already been granted to a tenant", "resource pool \'%s\' has already been granted to a tenant");
DEFINE_ERROR(OB_SERVER_ALREADY_DELETED, -4628, -1, "HY000", "server has already been deleted");
DEFINE_ERROR(OB_SERVER_NOT_DELETING, -4629, -1, "HY000", "server is not in deleting status");
DEFINE_ERROR(OB_SERVER_NOT_IN_WHITE_LIST, -4630, -1, "HY000", "server not in server white list");
DEFINE_ERROR(OB_SERVER_ZONE_NOT_MATCH, -4631, -1, "HY000", "server zone not match");
DEFINE_ERROR(OB_OVER_ZONE_NUM_LIMIT, -4632, -1, "HY000", "zone num has reach max zone num");
DEFINE_ERROR(OB_ZONE_STATUS_NOT_MATCH, -4633, -1, "HY000", "zone status not match");
DEFINE_ERROR_EXT(OB_RESOURCE_UNIT_IS_REFERENCED, -4634, -1, "HY000", "resource unit is referenced by resource pool", "resource unit \'%s\' is referenced by some resource pool");
DEFINE_ERROR(OB_DIFFERENT_PRIMARY_ZONE, -4636, -1, "HY000", "table schema primary zone different with other table in sampe tablegroup");
DEFINE_ERROR(OB_SERVER_NOT_ACTIVE, -4637, -1, "HY000", "server is not active");
DEFINE_ERROR(OB_RS_NOT_MASTER, -4638, -1, "HY000", "The RootServer is not the master");
DEFINE_ERROR(OB_CANDIDATE_LIST_ERROR, -4639, -1, "HY000", "The candidate list is invalid");
DEFINE_ERROR(OB_PARTITION_ZONE_DUPLICATED, -4640, -1, "HY000", "The chosen partition servers belong to same zone.");
DEFINE_ERROR_EXT(OB_ZONE_DUPLICATED, -4641, -1, "HY000", "Duplicated zone in zone list", "Duplicated zone \'%s\' in zone list %s");
DEFINE_ERROR(OB_NOT_ALL_ZONE_ACTIVE, -4642, -1, "HY000", "Not all zone in zone list are active");
DEFINE_ERROR_EXT(OB_PRIMARY_ZONE_NOT_IN_ZONE_LIST, -4643, -1, "HY000", "primary zone not in zone list", "primary zone \'%s\' not in zone list %s");
DEFINE_ERROR(OB_REPLICA_NUM_NOT_MATCH, -4644, -1, "HY000", "replica num not same with zone count");
DEFINE_ERROR_EXT(OB_ZONE_LIST_POOL_LIST_NOT_MATCH, -4645, -1, "HY000", "zone list not a subset of  resource pool list", "zone list %s not a subset of resource pool zone list %s");
DEFINE_ERROR_EXT(OB_INVALID_TENANT_NAME, -4646, -1, "HY000", "tenant name is too long", "tenant name \'%s\' over max_tenant_name_length %ld");
DEFINE_ERROR(OB_EMPTY_RESOURCE_POOL_LIST, -4647, -1, "HY000", "resource pool list is empty");
DEFINE_ERROR_EXT(OB_RESOURCE_UNIT_NOT_EXIST, -4648, -1, "HY000", "resource unit not exist", "resource unit \'%s\' not exist");
DEFINE_ERROR_EXT(OB_RESOURCE_UNIT_EXIST, -4649, -1, "HY000", "resource unit already exist", "resource unit \'%s\' already exist");
DEFINE_ERROR_EXT(OB_RESOURCE_POOL_NOT_EXIST, -4650, -1, "HY000", "resource pool not exist", "resource pool \'%s\' not exist");
DEFINE_ERROR_EXT(OB_RESOURCE_POOL_EXIST, -4651, -1, "HY000", "resource pool already exist", "resource pool \'%s\' exist");
DEFINE_ERROR(OB_WAIT_LEADER_SWITCH_TIMEOUT, -4652, -1, "HY000", "wait leader switch timeout");
DEFINE_ERROR(OB_LOCATION_NOT_EXIST, -4653, -1, "HY000", "location not exist");
DEFINE_ERROR(OB_LOCATION_LEADER_NOT_EXIST, -4654, -1, "HY000", "location leader not exist");
DEFINE_ERROR(OB_ZONE_NOT_ACTIVE, -4655, -1, "HY000", "zone not active");
DEFINE_ERROR(OB_UNIT_NUM_OVER_SERVER_COUNT, -4656, -1, "HY000", "resource pool unit num is bigger than zone server count");
DEFINE_ERROR_EXT(OB_POOL_SERVER_INTERSECT, -4657, -1, "HY000", "resource pool list unit server intersect", "resource pool list %s unit servers intersect");
DEFINE_ERROR_EXT(OB_NOT_SINGLE_RESOURCE_POOL, -4658, -1, "HY000", "create tenant only support single resource pool now", "create tenant only support single resource pool now, but pool list is %s");
DEFINE_ERROR_EXT(OB_INVALID_RESOURCE_UNIT, -4659, -1, "HY000", "invalid resource unit", "invalid resource unit, %s\'s min value is %s");
DEFINE_ERROR_EXT(OB_STOP_SERVER_IN_MULTIPLE_ZONES, -4660, -1, "HY000", "Can not stop server in multiple zones", "%s");
DEFINE_ERROR(OB_SESSION_ENTRY_EXIST, -4661, -1, "HY000", "Session already exist");
DEFINE_ERROR_EXT(OB_GOT_SIGNAL_ABORTING, -4662, ER_GOT_SIGNAL, "01000", "Got signal. Aborting!", "%s: Got signal %d. Aborting!");
DEFINE_ERROR(OB_SERVER_NOT_ALIVE, -4663, -1, "HY000", "server is not alive");
DEFINE_ERROR(OB_GET_LOCATION_TIME_OUT, -4664, 4012, "HY000", "Timeout");
DEFINE_ERROR(OB_UNIT_IS_MIGRATING, -4665, -1, "HY000", "Unit is migrating, can not migrate again");
DEFINE_ERROR_EXT(OB_CLUSTER_NO_MATCH, -4666, -1, "HY000", "cluster name does not match", "cluster name does not match to \'%s\'");
DEFINE_ERROR(OB_CHECK_ZONE_MERGE_ORDER, -4667, -1, "HY000", "Please check new zone in zone_merge_order. You can show parameters like 'zone_merge_order'");
DEFINE_ERROR_EXT(OB_ERR_ZONE_NOT_EMPTY, -4668, -1, "HY000", "zone not empty", "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.");
DEFINE_ERROR(OB_DIFFERENT_LOCALITY, -4669, -1, "HY000", "locality not match, check it");
DEFINE_ERROR(OB_EMPTY_LOCALITY, -4670, -1, "HY000", "locality is empty")
DEFINE_ERROR(OB_FULL_REPLICA_NUM_NOT_ENOUGH, -4671, -1, "HY000", "full replica num not enough")
DEFINE_ERROR(OB_REPLICA_NUM_NOT_ENOUGH, -4672, -1, "HY000", "replica num not enough")
DEFINE_ERROR(OB_DATA_SOURCE_NOT_VALID, -4673, -1, "HY000", "Data source not valid");
DEFINE_ERROR(OB_RUN_JOB_NOT_SUCCESS, -4674, -1, "HY000", "run job not success yet");
DEFINE_ERROR(OB_NO_NEED_REBUILD, -4675, -1, "HY000", "no need to rebuild");
DEFINE_ERROR(OB_NEED_REMOVE_UNNEED_TABLE, -4676, -1, "HY000", "need remove unneed table");
DEFINE_ERROR(OB_NO_NEED_MERGE, -4677, -1, "HY000", "no need to merge");
DEFINE_ERROR_EXT(OB_CONFLICT_OPTION, -4678, -1, "HY000", "conflicting specifications", "conflicting %.*s specifications");
DEFINE_ERROR_EXT(OB_DUPLICATE_OPTION, -4679, -1, "HY000", "duplicate specifications", "duplicate %.*s specifications");
DEFINE_ERROR_EXT(OB_INVALID_OPTION, -4680, -1, "HY000", "invalid specifications", "%s");
DEFINE_ERROR_EXT(OB_RPC_NEED_RECONNECT, -4681, -1, "HY000", "rpc need reconnect", "%s");
DEFINE_ERROR(OB_CANNOT_COPY_MAJOR_SSTABLE, -4682, -1, "HY000", "cannot copy major sstable now");
DEFINE_ERROR(OB_SRC_DO_NOT_ALLOWED_MIGRATE, -4683, -1, "HY000", "src do not allowed migrate");
DEFINE_ERROR(OB_TOO_MANY_TENANT_PARTITIONS_ERROR, -4684, -1, "HY000", "Too many partitions were defined for this tenant");
DEFINE_ERROR(OB_ACTIVE_MEMTBALE_NOT_EXSIT, -4685, -1, "HY000", "active memtable not exist");
DEFINE_ERROR(OB_USE_DUP_FOLLOW_AFTER_DML, -4686, -1, "HY000", "Should use leader replica for duplicate table after DML operator");
DEFINE_ERROR(OB_NO_DISK_NEED_REBUILD, -4687, -1, "HY000", "no disk need rebuild");
DEFINE_ORACLE_ERROR(OB_STANDBY_WEAK_READ_ONLY, -4688, -1, "HY000", "standby cluster support weak read only", 16003, "standby cluster support weak read only");
DEFINE_ERROR(OB_INVALD_WEB_SERVICE_CONTENT, -4689, -1, "HY000", "web service content not valid");
DEFINE_ERROR(OB_PRIMARY_CLUSTER_EXIST, -4690, -1, "HY000", "other primary cluster already exist, can not start as primary");
DEFINE_ERROR(OB_ARRAY_BINDING_SWITCH_ITERATOR, -4691, -1, "HY000", "array binding needs to switch iterator");
DEFINE_ERROR(OB_ERR_STANDBY_CLUSTER_NOT_EMPTY, -4692, -1, "HY000", "standby cluster not empty");
DEFINE_ERROR(OB_NOT_PRIMARY_CLUSTER, -4693, -1, "HY000", "not primary cluster");
DEFINE_ERROR(OB_ERR_CHECK_DROP_COLUMN_FAILED, -4694, -1, "HY000", "check drop column failed");
DEFINE_ERROR(OB_NOT_STANDBY_CLUSTER, -4695, -1, "HY000", "not standby cluster");
DEFINE_ERROR(OB_CLUSTER_VERSION_NOT_COMPATIBLE, -4696, -1, "HY000", "cluster version not compatible");
DEFINE_ERROR(OB_WAIT_TRANS_TABLE_MERGE_TIMEOUT, -4697, -1, "HY000", "wait trans table merge finish timeout");
DEFINE_ERROR(OB_SKIP_RENEW_LOCATION_BY_RPC, -4698, -1, "HY000", "skip renew location by rpc");
DEFINE_ERROR(OB_RENEW_LOCATION_BY_RPC_FAILED, -4699, -1, "HY000", "renew location by rpc failed");
DEFINE_ERROR(OB_CLUSTER_ID_NO_MATCH, -4700, -1, "HY000", "cluster id does not match");
DEFINE_ORACLE_ERROR(OB_ERR_PARAM_INVALID, -4701, -1, "HY000", "parameter cannot be modified because specified value is invalid", 2097, "parameter cannot be modified because specified value is invalid");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_RES_OBJ_ALREADY_EXIST, -4702, -1, "HY000", "resource object already exists", "%s %.*s already exists", 29357, "resource object already exists", "%s %.*s already exists");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_RES_PLAN_NOT_EXIST, -4703, -1, "HY000", "resource plan does not exist", "resource plan %.*s does not exist", 29358, "resource plan does not exist", "resource plan %.*s does not exist");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_PERCENTAGE_OUT_OF_RANGE, -4704, -1, "HY000", "value is outside valid range of 0 to 100", "value %ld for %s is outside valid range of 0 to 100", 29361, "value is outside valid range of 0 to 100", "value %ld for %s is outside valid range of 0 to 100");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_PLAN_DIRECTIVE_NOT_EXIST, -4705, -1, "HY000", "plan directive does not exist", "plan directive %.*s, %.*s does not exist", 29362, "plan directive does not exist", "plan directive %.*s, %.*s does not exist");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_PLAN_DIRECTIVE_ALREADY_EXIST, -4706, -1, "HY000", "plan directive already exists", "plan directive %.*s, %.*s already exists", 29364, "plan directive already exists", "plan directive %.*s, %.*s already exists");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_INVALID_PLAN_DIRECTIVE_NAME, -4707, -1, "HY000", "plan directive name not supported.", "plan directive name '%.*s' not supported." , 29366, "plan directive name not supported.", "plan directive name '%.*s' not supported.");
DEFINE_ERROR_EXT(OB_FAILOVER_NOT_ALLOW, -4708, -1, "HY000", "Failover is not allowed", "%s");
DEFINE_ERROR_EXT(OB_ADD_CLUSTER_NOT_ALLOWED, -4709, -1, "HY000", "Add cluster not allowed.", "Add cluster not allowed. Actions: %s");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_CONSUMER_GROUP_NOT_EXIST, -4710, -1, "HY000", "consumer group does not exist", "consumer group %.*s does not exist", 29368, "consumer group does not exist", "consumer group %.*s does not exist");
DEFINE_ERROR_EXT(OB_CLUSTER_NOT_ACCESSIBLE, -4711, -1, "HY000", "cluster is not accessible", "cluster is not accessible, cluster_id: %ld");
DEFINE_ERROR_EXT(OB_TENANT_RESOURCE_UNIT_EXIST, -4712, -1, "HY000", "tenant already has resource unit configured", "tenant already has resource unit configured, tenant_id: %ld, observer: \'%s\'");
DEFINE_ERROR_EXT(OB_ERR_DROP_TRUNCATE_PARTITION_REBUILD_INDEX, -4713, -1, "HY000", "rebuild global index failed when drop/truncate partitions", "rebuild global index:'%.*s' failed when drop/truncate partitions");
DEFINE_ORACLE_ERROR(OB_ERR_ATLER_TABLE_ILLEGAL_FK, -4714, -1, "HY000", "unique/primary keys in table referenced by enabled foreign keys", 02266, "unique/primary keys in table referenced by enabled foreign keys");
DEFINE_ORACLE_ERROR(OB_ERR_NO_RESOURCE_MANAGER_PRIVILEGE, -4715, -1, "HY000", "insufficient Resource Manager privileges", 56713, "insufficient Resource Manager privileges");
DEFINE_ORACLE_ERROR(OB_ERR_RES_MGR_PLAN_NOT_EXIST, -4718, -1, "HY000", "specified resource manager plan does not exist in the data dictionary", 7452, "specified resource manager plan does not exist in the data dictionary");

////////////////////////////////////////////////////////////////
// SQL & Schema specific error code, -5000 ~ -6000
////////////////////////////////////////////////////////////////
DEFINE_ERROR(OB_ERR_PARSER_INIT, -5000, ER_PARSE_ERROR, "0B000", "Failed to init SQL parser");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_PARSE_SQL, -5001, ER_PARSE_ERROR, "42000", "Parse error", "%s near \'%.*s\' at line %d", 900, "invalid SQL statement", "%s near \'%.*s\' at line %d");
DEFINE_ERROR(OB_ERR_RESOLVE_SQL, -5002, -1, "HY000", "Resolve error");
DEFINE_ERROR(OB_ERR_GEN_PLAN, -5003, -1, "HY000", "Generate plan error");
DEFINE_ORACLE_ERROR(OB_ERR_PARSER_SYNTAX, -5006, ER_SYNTAX_ERROR, "42000", "You have an error in your SQL syntax; check the manual that corresponds to your OceanBase version for the right syntax to use", 900, "You have an error in your SQL syntax; check the manual that corresponds to your OceanBase version for the right syntax to use");
DEFINE_ERROR(OB_ERR_COLUMN_SIZE, -5007, ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT, "21000", "The used SELECT statements have a different number of columns");
// @TODO: will be replaced by OB_NON_UNIQ_ERROR
DEFINE_ERROR_EXT(OB_ERR_COLUMN_DUPLICATE, -5008, ER_DUP_FIELDNAME, "42S21", "Duplicate column name", "Duplicate column name '%.*s'");
DEFINE_ERROR(OB_ERR_OPERATOR_UNKNOWN, -5010, -1, "21000", "Unknown operator");
DEFINE_ERROR(OB_ERR_STAR_DUPLICATE, -5011, -1, "42000", "Duplicated star");
DEFINE_ERROR_EXT(OB_ERR_ILLEGAL_ID, -5012, -1, "HY000", "Illegal ID", "%s");
DEFINE_ERROR(OB_ERR_ILLEGAL_VALUE, -5014, -1, "HY000", "Illegal value");
DEFINE_ERROR(OB_ERR_COLUMN_AMBIGUOUS, -5015, ER_AMBIGUOUS_FIELD_TERM, "42000", "Ambiguous column");
DEFINE_ERROR(OB_ERR_LOGICAL_PLAN_FAILD, -5016, -1, "HY000", "Generate logical plan error");
DEFINE_ERROR(OB_ERR_SCHEMA_UNSET, -5017, -1, "HY000", "Schema not set");
DEFINE_ERROR(OB_ERR_ILLEGAL_NAME, -5018, -1, "42000", "Illegal name");
DEFINE_ERROR_EXT(OB_ERR_TABLE_EXIST, -5020, ER_TABLE_EXISTS_ERROR, "42S01", "Table already exists", "Table '%.*s' already exists");
DEFINE_ORACLE_ERROR_EXT(OB_TABLE_NOT_EXIST, -5019, ER_NO_SUCH_TABLE, "42S02", "Table doesn\'t exist", "Table \'%s.%s\' doesn\'t exist", 942, "table or view does not exist", "table or view \'%s.%s\' does not exist");
DEFINE_ERROR(OB_ERR_EXPR_UNKNOWN, -5022, -1, "42000", "Unknown expression");
DEFINE_ERROR_EXT(OB_ERR_ILLEGAL_TYPE, -5023, -1, "S1004", "Illegal type", "unsupport MySQL type %d. Maybe you should use java.sql.Timestamp instead of java.util.Date.");
DEFINE_ERROR_EXT(OB_ERR_KEY_NAME_DUPLICATE, -5025, ER_DUP_KEYNAME, "42000", "Duplicated key name", "Duplicate key name \'%.*s\'");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_PRIMARY_KEY_DUPLICATE, -5024, ER_DUP_ENTRY, "23000", "Duplicated primary key", "Duplicate entry \'%s\' for key \'%.*s\'", 1, "unique constraint violated", "unique constraint \'%s\' for key \'%.*s\' violated");
DEFINE_ERROR(OB_ERR_CREATETIME_DUPLICATE, -5026, -1, "42000", "Duplicated createtime");
DEFINE_ERROR(OB_ERR_MODIFYTIME_DUPLICATE, -5027, -1, "42000", "Duplicated modifytime");
DEFINE_ERROR(OB_ERR_ILLEGAL_INDEX, -5028, ER_NO_SUCH_INDEX, "42S12", "Illegal index");
DEFINE_ERROR(OB_ERR_INVALID_SCHEMA, -5029, -1, "HY000", "Invalid schema");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_INSERT_NULL_ROWKEY, -5030, ER_PRIMARY_CANT_HAVE_NULL, "42000", "Insert null rowkey", "Insert null into %.*s", 1400, "cannot insert NULL into", "cannot insert NULL into (%.*s)");
DEFINE_ERROR(OB_ERR_COLUMN_NOT_FOUND, -5031, -1, "HY000", "Column not found");
DEFINE_ERROR(OB_ERR_DELETE_NULL_ROWKEY, -5032, -1, "23000", "Delete null rowkey");
DEFINE_ERROR(OB_ERR_USER_EMPTY, -5034, -1, "01007", "No user");
DEFINE_ERROR(OB_ERR_USER_NOT_EXIST, -5035, ER_NO_SUCH_USER, "01007", "User not exist");
DEFINE_ERROR_EXT(OB_ERR_NO_PRIVILEGE, -5036, ER_SPECIFIC_ACCESS_DENIED_ERROR, "42501", "Access denied", "Access denied; you need (at least one of) the %s privilege(s) for this operation");
DEFINE_ERROR(OB_ERR_NO_AVAILABLE_PRIVILEGE_ENTRY, -5037, -1, "HY000", "No privilege entry");
DEFINE_ERROR(OB_ERR_WRONG_PASSWORD, -5038, ER_PASSWORD_NO_MATCH, "42000", "Incorrect password");
DEFINE_ERROR(OB_ERR_USER_IS_LOCKED, -5039, ER_ACCOUNT_HAS_BEEN_LOCKED, "HY000", "User locked");
DEFINE_ERROR(OB_ERR_UPDATE_ROWKEY_COLUMN, -5040, -1, "42000", "Can not update rowkey column");
DEFINE_ERROR(OB_ERR_UPDATE_JOIN_COLUMN, -5041, -1, "42000", "Can not update join column");
DEFINE_ERROR_EXT(OB_ERR_INVALID_COLUMN_NUM, -5042, ER_OPERAND_COLUMNS, "21000", "Invalid column number", "Operand should contain %ld column(s)");
DEFINE_ERROR_EXT(OB_ERR_PREPARE_STMT_NOT_FOUND, -5043, ER_UNKNOWN_STMT_HANDLER, "HY007", "Unknown prepared statement", "statement not prepared, stmt_id=%u");
DEFINE_ERROR_EXT(OB_ERR_SYS_VARIABLE_UNKNOWN, -5044, ER_UNKNOWN_SYSTEM_VARIABLE, "HY000", "Unknown system variable", "Unknown system variable '%.*s'");
DEFINE_ERROR(OB_ERR_OLDER_PRIVILEGE_VERSION, -5046, -1, "HY000", "Older privilege version");
DEFINE_ERROR_EXT(OB_ERR_LACK_OF_ROWKEY_COL, -5047, ER_REQUIRES_PRIMARY_KEY, "42000", "No rowkey column specified", "Primary key column(s) not specified in the WHERE clause");
DEFINE_ORACLE_ERROR(OB_ERR_USER_EXIST, -5050, -1, "42710", "User exists", 1920, "user name conflicts with another user or role name");
DEFINE_ERROR(OB_ERR_PASSWORD_EMPTY, -5051, -1, "HY000", "Empty password");
DEFINE_ERROR(OB_ERR_GRANT_PRIVILEGES_TO_CREATE_TABLE, -5052, -1, "42000", "Failed to grant privelege");
DEFINE_ERROR_EXT(OB_ERR_WRONG_DYNAMIC_PARAM, -5053, -1, "HY093", "Wrong dynamic parameters", "Incorrect arguments number to EXECUTE, need %ld arguments but give %ld");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_PARAM_SIZE, -5054, ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, "42000", "Incorrect parameter count", "Incorrect parameter count in the call to native function '%.*s'", 909, "invalid number of arguments", "invalid number of arguments in the call to native function '%.*s'");
DEFINE_ERROR_EXT(OB_ERR_FUNCTION_UNKNOWN, -5055, ER_SP_DOES_NOT_EXIST, "42000", "FUNCTION does not exist", "FUNCTION %.*s does not exist");
DEFINE_ERROR(OB_ERR_CREAT_MODIFY_TIME_COLUMN, -5056, -1, "23000", "CreateTime or ModifyTime column cannot be modified");
DEFINE_ERROR(OB_ERR_MODIFY_PRIMARY_KEY, -5057, -1, "23000", "Primary key cannot be modified");
DEFINE_ERROR(OB_ERR_PARAM_DUPLICATE, -5058, -1, "42000", "Duplicated parameters");
DEFINE_ERROR(OB_ERR_TOO_MANY_SESSIONS, -5059, ER_TOO_MANY_USER_CONNECTIONS, "42000", "Too many sessions");
DEFINE_ERROR(OB_ERR_TOO_MANY_PS, -5061, -1, "54023", "Too many prepared statements");
DEFINE_ERROR(OB_ERR_HINT_UNKNOWN, -5063, -1, "42000", "Unknown hint");
DEFINE_ERROR(OB_ERR_WHEN_UNSATISFIED, -5064, -1, "23000", "When condition not satisfied");
DEFINE_ERROR(OB_ERR_QUERY_INTERRUPTED, -5065, ER_QUERY_INTERRUPTED, "70100", "Query execution was interrupted");
DEFINE_ORACLE_ERROR(OB_ERR_SESSION_INTERRUPTED, -5066, -1, "HY000", "Session interrupted", 1092, "OceanBase instance terminated. Disconnection forced");
DEFINE_ERROR(OB_ERR_UNKNOWN_SESSION_ID, -5067, -1, "HY000", "Unknown session ID");
DEFINE_ERROR(OB_ERR_PROTOCOL_NOT_RECOGNIZE, -5068, -1, "HY000", "Incorrect protocol");
DEFINE_ERROR(OB_ERR_WRITE_AUTH_ERROR, -5069, -1, "HY000", "Write auth packet error");
DEFINE_ERROR(OB_ERR_PARSE_JOIN_INFO, -5070, -1, "42000", "Wrong join info")
DEFINE_ERROR(OB_ERR_ALTER_INDEX_COLUMN, -5071, -1, "42000", "Cannot alter index column");
DEFINE_ERROR(OB_ERR_MODIFY_INDEX_TABLE, -5072, -1, "42000", "Cannot modify index table");
DEFINE_ERROR(OB_ERR_INDEX_UNAVAILABLE, -5073, ER_NO_SUCH_INDEX, "42000", "Index unavailable");
DEFINE_ERROR(OB_ERR_NOP_VALUE, -5074, -1, "23000", "NOP cannot be used here");
DEFINE_ERROR(OB_ERR_PS_TOO_MANY_PARAM, -5080, ER_PS_MANY_PARAM, "54000", "Prepared statement contains too many placeholders");
DEFINE_ERROR(OB_ERR_READ_ONLY, -5081, -1, "25000", "The server is read only now");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_INVALID_TYPE_FOR_OP, -5083, -1, "22000", "Invalid data type for the operation", "invalid obj type for type promotion: left_type=%s right_type=%s", 932, "inconsistent datatypes", "inconsistent datatypes: left_type=%s right_type=%s");
DEFINE_ERROR(OB_ERR_CAST_VARCHAR_TO_BOOL, -5084, -1, "22000", "Can not cast varchar value to bool type");
DEFINE_ORACLE_ERROR(OB_ERR_CAST_VARCHAR_TO_NUMBER, -5085, -1, "22000", "Not a number Can not cast varchar value to number type", 1722, "invalid number");
DEFINE_ERROR(OB_ERR_CAST_VARCHAR_TO_TIME, -5086, -1, "22000", "Not timestamp Can not cast varchar value to timestamp type");
DEFINE_ERROR(OB_ERR_CAST_NUMBER_OVERFLOW, -5087, -1, "22000", "Result value was out of range when cast to number");
DEFINE_ORACLE_ERROR_EXT(OB_INTEGER_PRECISION_OVERFLOW, -5088, ER_WARN_DATA_OUT_OF_RANGE, "22003", "Result value was out of range when casting varchar to number", "value larger than specified precision(%ld,%ld) allowed for this column", 1426, "numeric overflow", "numeric overflow, value larger than specified precision(%ld,%ld) allowed for this column");
DEFINE_ORACLE_ERROR_EXT(OB_DECIMAL_PRECISION_OVERFLOW, -5089, ER_WARN_DATA_OUT_OF_RANGE, "22003", "Result value was out of range when casting varchar to number", "value(%s) larger than specified precision(%ld,%ld) allowed for this column", 1426, "numeric overflow", "numeric overflow, value(%s) larger than specified precision(%ld,%ld) allowed for this column");
DEFINE_ERROR(OB_SCHEMA_NUMBER_PRECISION_OVERFLOW, -5090, -1, "22000", "Precision was out of range");
DEFINE_ERROR(OB_SCHEMA_NUMBER_SCALE_OVERFLOW, -5091, -1, "22000", "Scale value was out of range");
DEFINE_ERROR(OB_ERR_INDEX_UNKNOWN, -5092, -1, "42000", "Unknown index");
DEFINE_ORACLE_ERROR(OB_NUMERIC_OVERFLOW, -5093, ER_WARN_DATA_OUT_OF_RANGE, "22003", "Result value was out of range when casting varchar to number", 1426, "numeric overflow");
DEFINE_ERROR(OB_ERR_TOO_MANY_JOIN_TABLES, -5094, -1, "HY000", "too many joined tables");
DEFINE_ERROR_EXT(OB_ERR_VARCHAR_TOO_LONG, -5098, -1, "22001", "Varchar value is too long for the column", "Data too long(%d>%ld) for column '%s'");
DEFINE_ERROR(OB_ERR_SYS_CONFIG_UNKNOWN, -5099, -1, "42000", "System config unknown");
DEFINE_ERROR_EXT(OB_ERR_LOCAL_VARIABLE, -5100, ER_LOCAL_VARIABLE, "HY000", "Local variable", "Variable \'%.*s\' is a SESSION variable and can't be used with SET GLOBAL");
DEFINE_ERROR_EXT(OB_ERR_GLOBAL_VARIABLE, -5101, ER_GLOBAL_VARIABLE, "HY000", "Global variable", "Variable \'%.*s\' is a GLOBAL variable and should be set with SET GLOBAL");
DEFINE_ERROR_EXT(OB_ERR_VARIABLE_IS_READONLY, -5102, ER_VARIABLE_IS_READONLY, "HY000", "variable is read only", "%.*s variable '%.*s' is read-only. Use SET %.*s to assign the value");
DEFINE_ERROR_EXT(OB_ERR_INCORRECT_GLOBAL_LOCAL_VAR, -5103, ER_INCORRECT_GLOBAL_LOCAL_VAR, "HY000", "incorrect global or local variable", "Variable '%.*s' is a %.*s variable");
DEFINE_ERROR_EXT(OB_ERR_EXPIRE_INFO_TOO_LONG, -5104, -1, "42000", "Expire expression too long", "length(%d) of expire_info is larger than the max allowed(%ld)");
DEFINE_ERROR_EXT(OB_ERR_EXPIRE_COND_TOO_LONG, -5105, -1, "42000", "Expire condition too long", "total length(%ld) of expire_info and its expression is larger than the max allowed(%ld)");
DEFINE_ERROR_EXT(OB_INVALID_ARGUMENT_FOR_EXTRACT, -5106, -1, "42000", "Invalid argument for extract()", "EXTRACT() expected timestamp or a string as date argument");
DEFINE_ERROR_EXT(OB_INVALID_ARGUMENT_FOR_IS, -5107, -1, "42000", "Invalid argument for IS operator", "Invalid operand type for IS operator, lval=%s");
DEFINE_ERROR_EXT(OB_INVALID_ARGUMENT_FOR_LENGTH, -5108, -1, "42000", "Invalid argument for length()", "function LENGTH() expected a varchar argument");
DEFINE_ERROR_EXT(OB_INVALID_ARGUMENT_FOR_SUBSTR, -5109, -1, "42000", "Invalid argument for substr()", "invalid input format. ret=%d text=%s start=%s length=%s");
DEFINE_ERROR_EXT(OB_INVALID_ARGUMENT_FOR_TIME_TO_USEC, -5110, -1, "42000", "Invalid argument for time_to_usec()", "TIME_TO_USEC() expected timestamp or a string as date argument");
DEFINE_ERROR_EXT(OB_INVALID_ARGUMENT_FOR_USEC_TO_TIME, -5111, -1, "42000", "Invalid argument for usec_to_time()", "USEC_TO_TIME expected a interger number as usec argument");
DEFINE_ERROR_EXT(OB_ERR_USER_VARIABLE_UNKNOWN, -5112, -1, "42P01", "Unknown user variable", "Variable %.*s does not exists");
DEFINE_ERROR_EXT(OB_ILLEGAL_USAGE_OF_MERGING_FROZEN_TIME, -5113, -1, "42000", "Illegal usage of merging_frozen_time()", "MERGING_FROZEN_TIME() system function only be used in daily merging.");
DEFINE_ORACLE_ERROR_EXT(OB_INVALID_NUMERIC, -5114, -1, "42000", "Invalid numeric", "Invalid numeric char '%c'", 1722, "invalid number", "invalid number char '%c'");
DEFINE_ERROR(OB_ERR_REGEXP_ERROR, -5115, ER_REGEXP_ERROR, "42000", "Got error 'empty (sub)expression' from regexp");
DEFINE_ERROR(OB_SQL_LOG_OP_SETCHILD_OVERFLOW, -5116, -1, "HY000", "Logical operator child index overflow");
DEFINE_ERROR(OB_SQL_EXPLAIN_FAILED, -5117, -1, "HY000", "fail to explain plan");
DEFINE_ERROR(OB_SQL_OPT_COPY_OP_FAILED, -5118, -1, "HY000", "fail to copy logical operator");
DEFINE_ERROR(OB_SQL_OPT_GEN_PLAN_FALIED, -5119, -1, "HY000", "fail to generate plan");;
DEFINE_ERROR(OB_SQL_OPT_CREATE_RAWEXPR_FAILED, -5120, -1,  "HY000", "fail to create raw expr");
DEFINE_ERROR(OB_SQL_OPT_JOIN_ORDER_FAILED, -5121, -1,  "HY000", "fail to generate join order");
DEFINE_ERROR(OB_SQL_OPT_ERROR, -5122, -1,  "HY000", "optimizer general error");
DEFINE_ERROR(OB_SQL_RESOLVER_NO_MEMORY, -5130, -1, "HY000", "sql resolver no memory");
DEFINE_ERROR(OB_SQL_DML_ONLY, -5131, -1, "HY000", "plan cache support dml only");
DEFINE_ERROR(OB_ERR_NO_GRANT, -5133, -1, "42000", "No such grant defined");
DEFINE_ERROR(OB_ERR_NO_DB_SELECTED, -5134, ER_NO_DB_ERROR, "3D000", "No database selected");
DEFINE_ERROR(OB_SQL_PC_OVERFLOW, -5135, -1, "HY000", "plan cache is overflow");
DEFINE_ERROR(OB_SQL_PC_PLAN_DUPLICATE, -5136, -1, "HY000", "plan exists in plan cache already");
DEFINE_ERROR(OB_SQL_PC_PLAN_EXPIRE, -5137, -1, "HY000", "plan is expired");
DEFINE_ERROR(OB_SQL_PC_NOT_EXIST, -5138, -1, "HY000", "no plan exist");
DEFINE_ERROR(OB_SQL_PARAMS_LIMIT, -5139, -1, "HY000", "too many params, plan cache not support" );
DEFINE_ERROR(OB_SQL_PC_PLAN_SIZE_LIMIT, -5140, -1, "HY000", "plan is too big to add to plan cache");
DEFINE_ERROR_EXT(OB_ERR_UNKNOWN_CHARSET, -5142, ER_UNKNOWN_CHARACTER_SET, "42000", "Unknown character set", "Unknown character set: '%.*s'");
DEFINE_ERROR_EXT(OB_ERR_UNKNOWN_COLLATION, -5143, ER_UNKNOWN_COLLATION, "HY000", "Unknown collation", "Unknown collation: '%.*s'");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_COLLATION_MISMATCH, -5144, ER_COLLATION_CHARSET_MISMATCH, "42000", "The collation is not valid for the character set", "COLLATION '%.*s' is not valid for CHARACTER SET '%.*s'", 12704, "character set mismatch", "COLLATION '%.*s' is not valid for CHARACTER SET '%.*s'");
DEFINE_ERROR_EXT(OB_ERR_WRONG_VALUE_FOR_VAR, -5145, ER_WRONG_VALUE_FOR_VAR, "42000", "Variable can't be set to the value", "Variable \'%.*s\' can't be set to the value of \'%.*s\'");
DEFINE_ORACLE_ERROR_EXT(OB_UNKNOWN_PARTITION, -5146, ER_UNKNOWN_PARTITION, "HY000", "Unknown partition", "Unkown partition '%.*s' in table '%.*s'", 2149, "Specified partition does not exist", "Specified partition does not exist '%.*s' in table '%.*s'");
DEFINE_ERROR(OB_PARTITION_NOT_MATCH, -5147, ER_ROW_DOES_NOT_MATCH_GIVEN_PARTITION_SET, "HY000", "Found a row not matching the given partition set");
DEFINE_ERROR(OB_ER_PASSWD_LENGTH, -5148, -1, "HY000", " Password hash should be a 40-digit hexadecimal number");
DEFINE_ERROR(OB_ERR_INSERT_INNER_JOIN_COLUMN, -5149, -1, "07000", "Insert inner join column error");
DEFINE_ERROR(OB_TENANT_NOT_IN_SERVER, -5150, -1, "HY000", "Tenant not in this server");
DEFINE_ERROR(OB_TABLEGROUP_NOT_EXIST, -5151, -1, "42P01", "tablegroup not exist");
DEFINE_ORACLE_ERROR(OB_SUBQUERY_TOO_MANY_ROW, -5153, ER_SUBQUERY_NO_1_ROW, "21000", "Subquery returns more than 1 row", 1427, "single-row subquery returns more than one row");
DEFINE_ERROR_EXT(OB_ERR_BAD_DATABASE, -5154, ER_BAD_DB_ERROR, "42000", "Unknown database", "Unknown database '%.*s'");
DEFINE_ERROR_EXT(OB_CANNOT_USER, -5155, ER_CANNOT_USER, "HY000", "User operation failed", "Operation %.*s failed for %.*s");
DEFINE_ERROR_EXT(OB_TENANT_EXIST, -5156, -1, "HY000", "tenant already exist", "tenant \'%s\' already exist");
DEFINE_ERROR_EXT(OB_TENANT_NOT_EXIST, -5157, -1, "HY000", "Unknown tenant", "Unknown tenant '%.*s'");
DEFINE_ERROR_EXT(OB_DATABASE_EXIST, -5158, ER_DB_CREATE_EXISTS, "HY000", "Can't create database;database exists", "Can't create database '%.*s'; database exists");
DEFINE_ERROR(OB_TABLEGROUP_EXIST, -5159, -1, "HY000", "tablegroup already exist");
DEFINE_ERROR(OB_ERR_INVALID_TENANT_NAME, -5160, -1, "HY000", "invalid tenant name specified in connection string");
DEFINE_ERROR(OB_EMPTY_TENANT, -5161, -1, "HY000", "tenant is empty");
DEFINE_ERROR_EXT(OB_WRONG_DB_NAME, -5162, ER_WRONG_DB_NAME, "42000", "Incorrect database name", "Incorrect database name '%.*s'");
DEFINE_ORACLE_ERROR_EXT(OB_WRONG_TABLE_NAME, -5163, ER_WRONG_TABLE_NAME, "42000", "Incorrect table name", "Incorrect table name '%.*s'", 903, "invalid table name", "invalid table name '%.*s'");
DEFINE_ORACLE_ERROR_EXT(OB_WRONG_COLUMN_NAME, -5164, ER_WRONG_COLUMN_NAME, "42000", "Incorrect column name", "Incorrect column name '%.*s'", 904, "invalid identifier", "invalid identifier '%.*s'");
DEFINE_ERROR_EXT(OB_ERR_COLUMN_SPEC, -5165, ER_WRONG_FIELD_SPEC, "42000", "Incorrect column specifier", "Incorrect column specifier for column '%.*s'");
DEFINE_ERROR_EXT(OB_ERR_DB_DROP_EXISTS, -5166, ER_DB_DROP_EXISTS, "HY000", "Can't drop database;database doesn't exist", "Can't drop database '%.*s'; database doesn't exist");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_DATA_TOO_LONG, -5167, ER_DATA_TOO_LONG, "22001", "Data too long for column", "Data too long for column '%.*s' at row %ld", 12899, "value too large for column", "value too large for column '%.*s' at row %ld");
DEFINE_OTHER_MSG_FMT(OB_ERR_DATA_TOO_LONG_MSG_FMT_V2, OB_ERR_DATA_TOO_LONG, "Data too long for column '%.*s' at row %ld", "value too large for column %.*s (actual: %ld, maximum: %ld)")
DEFINE_ERROR_EXT(OB_ERR_WRONG_VALUE_COUNT_ON_ROW, -5168, ER_WRONG_VALUE_COUNT_ON_ROW, "21S01", "column count does not match value count", "column count does not match value count at row '%d'");
DEFINE_ERROR(OB_ERR_CREATE_USER_WITH_GRANT, -5169, ER_CANT_CREATE_USER_WITH_GRANT, "42000", "You are not allowed to create a user with GRANT");
DEFINE_ERROR_EXT(OB_ERR_NO_DB_PRIVILEGE, -5170, ER_DBACCESS_DENIED_ERROR, "42000", "Access denied for user to database", "Access denied for user '%.*s'@'%.*s' to database '%.*s'");
DEFINE_ERROR_EXT(OB_ERR_NO_TABLE_PRIVILEGE, -5171, ER_TABLEACCESS_DENIED_ERROR, "42000", "Command denied to user for table", "%.*s command denied to user '%.*s'@'%.*s' for table '%.*s'");
DEFINE_ERROR_EXT(OB_INVALID_ON_UPDATE, -5172, ER_INVALID_ON_UPDATE, "HY000", "Invalid ON UPDATE clause", "Invalid ON UPDATE clause for \'%s\' column");
DEFINE_ERROR_EXT(OB_INVALID_DEFAULT, -5173, ER_INVALID_DEFAULT, "42000", "Invalid default value", "Invalid default value for \'%.*s\'");
DEFINE_ERROR_EXT(OB_ERR_UPDATE_TABLE_USED, -5174, ER_UPDATE_TABLE_USED, "HY000", "Update table used", "You can\'t specify target table \'%s\' for update in FROM clause");
DEFINE_ERROR_EXT(OB_ERR_COULUMN_VALUE_NOT_MATCH, -5175, ER_WRONG_VALUE_COUNT_ON_ROW, "21S01", "Column count doesn\'t match value count", "Column count doesn\'t match value count at row %ld");
DEFINE_ERROR(OB_ERR_INVALID_GROUP_FUNC_USE, -5176, ER_INVALID_GROUP_FUNC_USE, "HY000", "Invalid use of group function");
DEFINE_ERROR(OB_CANT_AGGREGATE_2COLLATIONS, -5177, ER_CANT_AGGREGATE_2COLLATIONS, "HY000", "Illegal mix of collations");
DEFINE_ERROR_EXT(OB_ERR_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD, -5178, ER_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD, "HY000", "Field is of a not allowed type for this type of partitioning", "Field \'%.*s\' is of a not allowed type for this type of partitioning");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_TOO_LONG_IDENT, -5179, ER_TOO_LONG_IDENT, "42000", "Identifier name is too long", "Identifier name \'%.*s\' is too long", 972, "identifier is too long", "identifier \'%.*s\' is too long");
DEFINE_ERROR_EXT(OB_ERR_WRONG_TYPE_FOR_VAR, -5180, ER_WRONG_TYPE_FOR_VAR, "42000", "Incorrect argument type to variable", "Incorrect argument type to variable '%.*s'");
DEFINE_ERROR_EXT(OB_WRONG_USER_NAME_LENGTH, -5181, ER_WRONG_STRING_LENGTH, "HY000", "String is too long for user_name (should be no longer than 16)", "String '%.*s' is too long for user name (should be no longer than 16)");
DEFINE_ERROR(OB_ERR_PRIV_USAGE, -5182, ER_WRONG_USAGE, "HY000", "Incorrect usage of DB GRANT and GLOBAL PRIVILEGES");
DEFINE_ERROR(OB_ILLEGAL_GRANT_FOR_TABLE, -5183, ER_ILLEGAL_GRANT_FOR_TABLE, "42000", "Illegal GRANT/REVOKE command; please consult the manual to see which privileges can be used");
DEFINE_ERROR(OB_ERR_REACH_AUTOINC_MAX, -5184, ER_AUTOINC_READ_FAILED, "HY000", "Failed to read auto-increment value from storage engine");
DEFINE_ERROR(OB_ERR_NO_TABLES_USED, -5185, ER_NO_TABLES_USED, "HY000", "No tables used");
DEFINE_ERROR(OB_CANT_REMOVE_ALL_FIELDS, -5187, ER_CANT_REMOVE_ALL_FIELDS, "42000", "You can't delete all columns with ALTER TABLE; use DROP TABLE instead");
DEFINE_ERROR(OB_TOO_MANY_PARTITIONS_ERROR, -5188, ER_TOO_MANY_PARTITIONS_ERROR, "HY000", "Too many partitions (including subpartitions) were defined", "Too many partitions (including subpartitions) were defined")
DEFINE_ERROR(OB_NO_PARTS_ERROR, -5189, ER_NO_PARTS_ERROR, "HY000", "Number of partitions = 0 is not an allowed value", "Number of partitions = 0 is not an allowed value");
DEFINE_ERROR(OB_WRONG_SUB_KEY, -5190, ER_WRONG_SUB_KEY, "HY000", "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");
DEFINE_ERROR_EXT(OB_KEY_PART_0, -5191, ER_KEY_PART_0, "HY000", "Key part length cannot be 0", "Key part \'%.*s\' length cannot be 0");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_UNKNOWN_TIME_ZONE, -5192, ER_UNKNOWN_TIME_ZONE, "HY000", "Unknown or incorrect time zone", "Unknown or incorrect time zone: \'%.*s\'", 1882, "timezone region string not found", "timezone region \'%.*s\' not found");
DEFINE_ERROR(OB_ERR_WRONG_AUTO_KEY, -5193, ER_WRONG_AUTO_KEY, "42000", "Incorrect table definition; there can be only one auto column");
DEFINE_ERROR_EXT(OB_ERR_TOO_MANY_KEYS, -5194, ER_TOO_MANY_KEYS, "42000","Too many keys specified", "Too many keys specified; max %ld keys allowed");
DEFINE_ERROR_EXT(OB_ERR_TOO_MANY_ROWKEY_COLUMNS, -5195, ER_TOO_MANY_KEY_PARTS, "42000","Too many key parts specified", "Too many key parts specified; max %ld parts allowed");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_TOO_LONG_KEY_LENGTH, -5196, ER_TOO_LONG_KEY, "42000", "Specified key was too long", "Specified key was too long; max key length is %ld bytes", 1450, "maximum key length exceeded", "maximum key length (%ld) exceeded");
DEFINE_ERROR(OB_ERR_TOO_MANY_COLUMNS, -5197, ER_TOO_MANY_FIELDS, "42000", "Too many columns");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_TOO_LONG_COLUMN_LENGTH, -5198, ER_TOO_BIG_FIELDLENGTH, "42000", "Column length too big", "Column length too big for column '%s' (max = %d)", 910, "specified length too long for its datatype", "specified length too long for column '%s' (max = %d byte)");
DEFINE_ERROR(OB_ERR_TOO_BIG_ROWSIZE, -5199, ER_TOO_BIG_ROWSIZE, "42000", "Row size too large");
DEFINE_ERROR_EXT(OB_ERR_UNKNOWN_TABLE, -5200, ER_UNKNOWN_TABLE, "42S02", "Unknown table", "Unknown table '%.*s' in %.*s");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_BAD_TABLE, -5201, ER_BAD_TABLE_ERROR, "42S02", "Unknown table", "Unknown table '%.*s'", 942, "table or view does not exist", "table or view '%.*s' does not exist");
DEFINE_ERROR_EXT(OB_ERR_TOO_BIG_SCALE, -5202, ER_TOO_BIG_SCALE, "42000", "Too big scale specified for column", "Too big scale %d specified for column '%s'. Maximum is %ld.");
DEFINE_ERROR_EXT(OB_ERR_TOO_BIG_PRECISION, -5203, ER_TOO_BIG_PRECISION, "42000", "Too big precision specified for column", "Too big precision %d specified for column '%s'. Maximum is %ld.");
DEFINE_ERROR_EXT(OB_ERR_M_BIGGER_THAN_D, -5204, ER_M_BIGGER_THAN_D, "42000", "precision must be >= scale", "For float(M,D), double(M,D) or decimal(M,D), M must be >= D (column '%s').");
DEFINE_ERROR_EXT(OB_ERR_TOO_BIG_DISPLAYWIDTH, -5205, ER_TOO_BIG_DISPLAYWIDTH, "42000", "Display width out of range for column", "Display width out of range for column '%s' (max = %ld)");
DEFINE_ERROR_EXT(OB_WRONG_GROUP_FIELD, -5206, ER_WRONG_GROUP_FIELD, "42000", "Can't group on column", "Can't group on '%.*s'");
DEFINE_ORACLE_ERROR_EXT(OB_NON_UNIQ_ERROR, -5207, ER_NON_UNIQ_ERROR, "23000", "Column is ambiguous", "Column '%.*s' in %.*s is ambiguous", 918, "Column is ambiguous", "column '%.*s' in %.*s ambiguously defined");
DEFINE_ERROR_EXT(OB_ERR_NONUNIQ_TABLE, -5208, ER_NONUNIQ_TABLE, "42000", "Not unique table/alias", "Not unique table/alias: \'%.*s\'");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_CANT_DROP_FIELD_OR_KEY, -5209, ER_CANT_DROP_FIELD_OR_KEY, "42000", "Can't DROP Column; check that column/key exists", "Can't DROP '%.*s'; check that column/key exists", 1418, "specified index does not exist", "specified index '%.*s' does not exist");
DEFINE_ERROR(OB_ERR_MULTIPLE_PRI_KEY, -5210, ER_MULTIPLE_PRI_KEY, "42000", "Multiple primary key defined");
DEFINE_ERROR_EXT(OB_ERR_KEY_COLUMN_DOES_NOT_EXITS, -5211, ER_KEY_COLUMN_DOES_NOT_EXITS, "42000", "Key column doesn't exist in table", "Key column '%.*s' doesn't exist in table");
DEFINE_ERROR_EXT(OB_ERR_AUTO_PARTITION_KEY, -5212, -1, "42000", "auto-increment column should not be part of partition key", "auto-increment column '%.*s' should not be part of partition key");
DEFINE_ERROR_EXT(OB_ERR_CANT_USE_OPTION_HERE, -5213, ER_CANT_USE_OPTION_HERE, "42000", "Incorrect usage/placement", "Incorrect usage/placement of '%s'");
DEFINE_ERROR_EXT(OB_ERR_WRONG_OBJECT, -5214, ER_WRONG_OBJECT, "HY000", "Wrong object", "\'%s.%s\' is not %s");
DEFINE_ERROR_EXT(OB_ERR_ON_RENAME, -5215, ER_ERROR_ON_RENAME, "HY000", "Error on rename table", "Error on rename of \'%s.%s\' to \'%s.%s\'");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_WRONG_KEY_COLUMN, -5216, ER_WRONG_KEY_COLUMN, "42000", "The used storage engine can't index column", "The used storage engine can't index column '%.*s'", 2329, "column of datatype string cannot be unique or a primary key", "column '%.*s' of datatype string cannot be unique or a primary key");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_BAD_FIELD_ERROR, -5217, ER_BAD_FIELD_ERROR, "42S22", "Unknown column", "Unknown column '%.*s' in '%.*s'", 904, "invalid identifier", "invalid identifier '%.*s' in '%.*s'");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_WRONG_FIELD_WITH_GROUP, -5218, ER_WRONG_FIELD_WITH_GROUP, "42000", "column is not in GROUP BY", "\'%.*s\' is not in GROUP BY", 979, "not a GROUP BY expression", "\'%.*s\' not a GROUP BY expression");
DEFINE_ORACLE_ERROR(OB_ERR_CANT_CHANGE_TX_CHARACTERISTICS, -5219, ER_CANT_CHANGE_TX_CHARACTERISTICS, "25001", "Transaction characteristics can't be changed while a transaction is in progress", 1453, "SET TRANSACTION must be first statement of transaction");
DEFINE_ERROR(OB_ERR_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION, -5220, ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION, "25006", "Cannot execute statement in a READ ONLY transaction.");
DEFINE_ERROR(OB_ERR_MIX_OF_GROUP_FUNC_AND_FIELDS, -5221, ER_MIX_OF_GROUP_FUNC_AND_FIELDS, "42000", "Mixing of GROUP columns (MIN(),MAX(),COUNT(),...) with no GROUP columns is illegal if there is no GROUP BY clause");
DEFINE_ERROR_EXT(OB_ERR_TRUNCATED_WRONG_VALUE, -5222, ER_TRUNCATED_WRONG_VALUE, "22007", "Incorrect value", "Truncated incorrect %.*s value: '%.*s'");
DEFINE_ERROR(OB_ERR_WRONG_IDENT_NAME, -5223, -1, "42000", "wrong ident name");
DEFINE_ERROR_EXT(OB_WRONG_NAME_FOR_INDEX, -5224, ER_WRONG_NAME_FOR_INDEX, "42000", "Incorrect index name", "Incorrect index name '%.*s'");
DEFINE_ERROR_EXT(OB_ILLEGAL_REFERENCE, -5225, ER_ILLEGAL_REFERENCE, "42S22", "Reference not supported (reference to group function)", "Reference '%.*s' not supported (reference to group function)")
DEFINE_ERROR(OB_REACH_MEMORY_LIMIT, -5226, -1, "42000", "plan cache memory used reach the high water mark.");
DEFINE_ERROR(OB_ERR_PASSWORD_FORMAT, -5227, ER_PASSWORD_FORMAT, "42000", "The password hash doesn't have the expected format. Check if the correct password algorithm is being used with the PASSWORD() function.");
DEFINE_ERROR_EXT(OB_ERR_NON_UPDATABLE_TABLE, -5228, ER_NON_UPDATABLE_TABLE, "HY000", "The target table is not updatable", "The target table %.*s of the %.*s is not updatable");
DEFINE_ERROR_EXT(OB_ERR_WARN_DATA_OUT_OF_RANGE, -5229, ER_WARN_DATA_OUT_OF_RANGE, "22003", "Out of range value for column", "Out of range value for column '%.*s' at row %ld")
DEFINE_ERROR(OB_ERR_WRONG_EXPR_IN_PARTITION_FUNC_ERROR, -5230, ER_WRONG_EXPR_IN_PARTITION_FUNC_ERROR, "HY000", "Constant or random or timezone-dependent expressions in (sub)partitioning function are not allowed");
DEFINE_ERROR_EXT(OB_ERR_VIEW_INVALID, -5231, ER_VIEW_INVALID, "42S22", "view invalid", "View \'%.*s.%.*s\' references invalid table(s) or column(s) or function(s) or definer/invoker of view lack rights to use them");
DEFINE_ERROR(OB_ERR_OPTION_PREVENTS_STATEMENT, -5233, ER_OPTION_PREVENTS_STATEMENT, "HY000", "The MySQL server is running with the --read-only option so it cannot execute this statement");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_DB_READ_ONLY, -5234, -1, "HY000", "The database is read only so it cannot execute this statement", "The database \'%.*s\' is read only so it cannot execute this statement", 16000, "database open for read-only access", "database \'%.*s\' open for read-only access");
DEFINE_ERROR_EXT(OB_ERR_TABLE_READ_ONLY, -5235, -1, "HY000", "The table is read only so it cannot execute this statement", "The table \'%.*s.%.*s\' is read only so it cannot execute this statement");
DEFINE_ERROR(OB_ERR_LOCK_OR_ACTIVE_TRANSACTION, -5236, ER_LOCK_OR_ACTIVE_TRANSACTION, "HY000", "Can't execute the given command because you have active locked tables or an active transaction");
DEFINE_ERROR_EXT(OB_ERR_SAME_NAME_PARTITION_FIELD, -5237, ER_SAME_NAME_PARTITION_FIELD, "HY000", "Duplicate partition field name", "Duplicate partition field name '%.*s'")
DEFINE_ERROR_EXT(OB_ERR_TABLENAME_NOT_ALLOWED_HERE, -5238, ER_TABLENAME_NOT_ALLOWED_HERE, "42000", "Table from one of the SELECTs cannot be used in global ORDER clause", "Table \'%.*s\' from one of the SELECTs cannot be used in global ORDER clause");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_VIEW_RECURSIVE, -5239, ER_VIEW_RECURSIVE, "42S02", "view contains recursion", "\'%.*s.%.*s\' contains view recursion", 1731, "circular view definition encountered", "view '%.*s.%.*s' encounters circular definition");
DEFINE_ERROR(OB_ERR_QUALIFIER, -5240, -1, "HY000", "Column part of USING clause cannot have qualifier");
DEFINE_ERROR_EXT(OB_ERR_WRONG_VALUE, -5241, ER_WRONG_VALUE, "HY000", "Incorrect value", "Incorrect %s value: '%s'");
DEFINE_ERROR(OB_ERR_VIEW_WRONG_LIST, -5242, ER_VIEW_WRONG_LIST,  "HY000", "View's SELECT and view's field list have different column counts");
DEFINE_ERROR(OB_SYS_VARS_MAYBE_DIFF_VERSION, -5243, -1,  "HY000", "system variables' version maybe different");
DEFINE_ERROR(OB_ERR_AUTO_INCREMENT_CONFLICT, -5244, ER_AUTO_INCREMENT_CONFLICT, "HY000", "Auto-increment value in UPDATE conflicts with internally generated values");
DEFINE_ERROR_EXT(OB_ERR_TASK_SKIPPED, -5245, -1, "HY000", "some tasks are skipped", "some tasks are skipped, skipped server addr is '%s', the orginal error code is %d");
DEFINE_ERROR_EXT(OB_ERR_NAME_BECOMES_EMPTY, -5246, ER_NAME_BECOMES_EMPTY, "HY000", "Name has become ''", "Name \'%.*s\' has become ''");
DEFINE_ERROR_EXT(OB_ERR_REMOVED_SPACES, -5247, ER_REMOVED_SPACES, "HY000", "Leading spaces are removed from name ", "Leading spaces are removed from name \'%.*s\'");
DEFINE_ERROR_EXT(OB_WARN_ADD_AUTOINCREMENT_COLUMN, -5248, -1, "HY000", "Alter table add auto_increment column is dangerous", "Alter table add auto_increment column is dangerous, table_name=\'%.*s\', column_name=\'%s\'");
DEFINE_ERROR_EXT(OB_WARN_CHAMGE_NULL_ATTRIBUTE, -5249, -1, "HY000", "Alter table change nullable column to not nullable is dangerous", "Alter table change nullable column to not nullable is dangerous, table_name=\'%.*s\', column_name=\'%.*s\'");
DEFINE_ERROR_EXT(OB_ERR_INVALID_CHARACTER_STRING, -5250, ER_INVALID_CHARACTER_STRING, "HY000", "Invalid character string", "Invalid %.*s character string: \'%.*s\'");
DEFINE_ERROR_EXT(OB_ERR_KILL_DENIED, -5251, ER_KILL_DENIED_ERROR, "HY000", "You are not owner of thread", "You are not owner of thread %lu");
DEFINE_ERROR_EXT(OB_ERR_COLUMN_DEFINITION_AMBIGUOUS, -5252, -1, "HY000", "Column definition is ambiguous. Column has both NULL and NOT NULL attributes", "Column \'%.*s\' definition is ambiguous. Column has both NULL and NOT NULL attributes");
DEFINE_ERROR(OB_ERR_EMPTY_QUERY, -5253, ER_EMPTY_QUERY, "42000", "Query was empty");
DEFINE_ERROR_EXT(OB_ERR_CUT_VALUE_GROUP_CONCAT, -5254, ER_CUT_VALUE_GROUP_CONCAT, "42000", "Row was cut by GROUP_CONCAT()", "Row %ld was cut by GROUP_CONCAT()");
DEFINE_ERROR(OB_ERR_FIELD_NOT_FOUND_PART, -5255, ER_FIELD_NOT_FOUND_PART_ERROR, "HY000", "Field in list of fields for partition function not found in table");
DEFINE_ERROR(OB_ERR_PRIMARY_CANT_HAVE_NULL, -5256, ER_PRIMARY_CANT_HAVE_NULL, "42000", "All parts of a PRIMARY KEY must be NOT NULL; if you need NULL in a key, use UNIQUE instead");
DEFINE_ERROR(OB_ERR_PARTITION_FUNC_NOT_ALLOWED_ERROR, -5257, ER_PARTITION_FUNC_NOT_ALLOWED_ERROR, "HY000", "The PARTITION function returns the wrong type");
DEFINE_ERROR(OB_ERR_INVALID_BLOCK_SIZE, -5258, -1, "HY000", "Invalid block size, block size should between 1024 and 1048576");
DEFINE_ERROR_EXT(OB_ERR_UNKNOWN_STORAGE_ENGINE, -5259, ER_UNKNOWN_STORAGE_ENGINE, "42000", "Unknown storage engine", "Unknown storage engine \'%.*s\'");
DEFINE_ERROR_EXT(OB_ERR_TENANT_IS_LOCKED, -5260, -1, "HY000", "Tenant is locked", "Tenant \'%.*s\' is locked");
DEFINE_ERROR_EXT(OB_EER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF, -5261, ER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF, "HY000", "A UNIQUE INDEX/PRIMARY KEY must include all columns in the table's partitioning function", "A %s must include all columns in the table's partitioning function";
DEFINE_ERROR(OB_ERR_PARTITION_FUNCTION_IS_NOT_ALLOWED, -5262, ER_PARTITION_FUNCTION_IS_NOT_ALLOWED, "HY000", "This partition function is not allowed");
DEFINE_ERROR_EXT(OB_ERR_AGGREGATE_ORDER_FOR_UNION, -5263, ER_AGGREGATE_ORDER_FOR_UNION, "HY000", "aggregate order for union", "Expression #%d of ORDER BY contains aggregate function and applies to a UNION");
DEFINE_ERROR_EXT(OB_ERR_OUTLINE_EXIST, -5264, -1, "HY000", "Outline exists", "Outline '%.*s' already exists");
DEFINE_ERROR_EXT(OB_OUTLINE_NOT_EXIST, -5265, -1, "HY000", "Outline not exists", "Outline \'%.*s.%.*s\' doesn\'t exist");
DEFINE_ERROR_EXT(OB_WARN_OPTION_BELOW_LIMIT, -5266, WARN_OPTION_BELOW_LIMIT, "HY000", "The value should be no less than the limit", "The value of \'%s\' should be no less than the value of \'%s\'");
DEFINE_ERROR_EXT(OB_INVALID_OUTLINE, -5267, -1, "HY000", "invalid outline", "invalid outline ,error info:%s");
DEFINE_ERROR_EXT(OB_REACH_MAX_CONCURRENT_NUM, -5268, -1, "HY000", "SQL reach max concurrent num", "SQL reach max concurrent num %ld");
DEFINE_ERROR(OB_ERR_OPERATION_ON_RECYCLE_OBJECT, -5269, -1, "HY000", "can not perform DDL/DML over objects in Recycle Bin");
DEFINE_ERROR(OB_ERR_OBJECT_NOT_IN_RECYCLEBIN, -5270, -1, "HY000", "object not in RECYCLE BIN");
DEFINE_ERROR(OB_ERR_CON_COUNT_ERROR, -5271, ER_CON_COUNT_ERROR, "08004", "Too many connections");
DEFINE_ERROR_EXT(OB_ERR_OUTLINE_CONTENT_EXIST, -5272, -1, "HY000", "Outline content already exists when added", "Outline content '%.*s' of outline '%.*s' already exists when added");
DEFINE_ERROR_EXT(OB_ERR_OUTLINE_MAX_CONCURRENT_EXIST, -5273, -1, "HY000", "Max concurrent already exists when added", "Max concurrent in outline '%.*s' already exists when added");
DEFINE_ERROR_EXT(OB_ERR_VALUES_IS_NOT_INT_TYPE_ERROR, -5274, ER_VALUES_IS_NOT_INT_TYPE_ERROR, "HY000", "VALUES value for partition must have type INT", "VALUES value for partition \'%.*s\' must have type INT");
DEFINE_ORACLE_ERROR(OB_ERR_WRONG_TYPE_COLUMN_VALUE_ERROR, -5275, ER_WRONG_TYPE_COLUMN_VALUE_ERROR, "HY000", "Partition column values of incorrect type", 14019, "partition bound element must be one of: string, datetime or interval literal, number, or MAXVALUE");
DEFINE_ERROR(OB_ERR_PARTITION_COLUMN_LIST_ERROR, -5276, ER_PARTITION_COLUMN_LIST_ERROR, "HY000", "Inconsistency in usage of column lists for partitioning");
DEFINE_ERROR(OB_ERR_TOO_MANY_VALUES_ERROR, -5277, ER_TOO_MANY_VALUES_ERROR, "HY000", "Cannot have more than one value for this type of RANGE partitioning");
DEFINE_ERROR(OB_ERR_PARTITION_VALUE_ERROR, -5278, -1, "HY000", "This partition value with incorrect charset type");
DEFINE_ERROR(OB_ERR_PARTITION_INTERVAL_ERROR, -5279, -1, "HY000", "Partition interval must have type INT");
DEFINE_ERROR_EXT(OB_ERR_SAME_NAME_PARTITION, -5280, ER_SAME_NAME_PARTITION, "HY000", "Duplicate partition name", "Duplicate partition name \'%.*s\'");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_RANGE_NOT_INCREASING_ERROR, -5281, ER_RANGE_NOT_INCREASING_ERROR, "HY000", "VALUES LESS THAN value must be strictly increasing for each partition", "VALUES LESS THAN value must be strictly increasing for each partition%.*s", 14037, "partition bound is too high", "partition bound of partition '%.*s' is too high");
DEFINE_ERROR(OB_ERR_PARSE_PARTITION_RANGE, -5282, ER_PARSE_ERROR, "42000", "Wrong number of partitions defined, mismatch with previous setting");
DEFINE_ERROR(OB_ERR_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF, -5283, ER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF, "HY000", "A PRIMARY KEY must include all columns in the table\'s partitioning function");
DEFINE_ORACLE_ERROR(OB_NO_PARTITION_FOR_GIVEN_VALUE, -5284, ER_NO_PARTITION_FOR_GIVEN_VALUE, "HY000", "Table has no partition for value", 14400, "inserted partition key does not map to any partition");
DEFINE_ORACLE_ERROR(OB_EER_NULL_IN_VALUES_LESS_THAN, -5285, ER_NULL_IN_VALUES_LESS_THAN, "HY000", "Not allowed to use NULL value in VALUES LESS THAN", 14019, "partition bound element must be one of: datetime or interval literal, number, or MAXVALUE");
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_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.");
DEFINE_ERROR_EXT(OB_ERR_DEPENDENT_BY_GENERATED_COLUMN, -5293, ER_DEPENDENT_BY_GENERATED_COLUMN, "HY000", "Column has a generated column dependency", "Column '%.*s' has a generated column dependency");
DEFINE_ORACLE_ERROR(OB_ERR_TOO_MANY_ROWS, -5294, ER_TOO_MANY_ROWS, "42000", "Result consisted of more than one row", 1422, "exact fetch returns more than requested number of rows");
DEFINE_ERROR(OB_WRONG_FIELD_TERMINATORS, -5295, ER_WRONG_FIELD_TERMINATORS, "42000", "Field separator argument is not what is expected; check the manual");
DEFINE_ERROR(OB_NO_READABLE_REPLICA, -5296, -1, "42000", "there has no readable replica");
DEFINE_ERROR(OB_ERR_UNEXPECTED_TZ_TRANSITION, -5297, -1, "HY000", "unexpected time zone info transition");
DEFINE_ERROR_EXT(OB_ERR_SYNONYM_EXIST, -5298, -1, "HY000", "synonym exists", "synonym '%.*s' already exists");
DEFINE_ERROR_EXT(OB_SYNONYM_NOT_EXIST, -5299, -1, "HY000", "synonym not exists", "synonym \'%.*s.%.*s\' doesn\'t exist");
DEFINE_ORACLE_ERROR(OB_ERR_MISS_ORDER_BY_EXPR, -5300, -1, "HY000", "missing ORDER BY expression in the window specification", 30485, "missing ORDER BY expression in the window specification");
DEFINE_ERROR(OB_ERR_NOT_CONST_EXPR, -5301, -1, "HY000", "The argument of the window function should be a constant for a partition", "The argument of the window function should be a constant for a partition");
DEFINE_ERROR(OB_ERR_PARTITION_MGMT_ON_NONPARTITIONED, -5302, ER_PARTITION_MGMT_ON_NONPARTITIONED, "HY000", "Partition management on a not partitioned table is not possible");
DEFINE_ERROR_EXT(OB_ERR_DROP_PARTITION_NON_EXISTENT, -5303, ER_DROP_PARTITION_NON_EXISTENT, "HY000", "Error in list of partitions", "Error in list of partitions to %s");
DEFINE_ERROR(OB_ERR_PARTITION_MGMT_ON_TWOPART_TABLE, -5304, -1, "HY000", "Partition management on a two-part table is not possible");
DEFINE_ERROR_EXT(OB_ERR_ONLY_ON_RANGE_LIST_PARTITION, -5305, ER_ONLY_ON_RANGE_LIST_PARTITION, "HY000", "can only be used on RANGE/LIST partitions", "%s PARTITION can only be used on RANGE/LIST partitions");
DEFINE_ERROR(OB_ERR_DROP_LAST_PARTITION, -5306, ER_DROP_LAST_PARTITION, "HY000", "Cannot remove all partitions, use DROP TABLE instead");
DEFINE_ERROR(OB_ERR_SCHEDULER_THREAD_NOT_ENOUGH, -5307, -1, "HY000", "Scheduler thread number is not enough");
DEFINE_ERROR(OB_ERR_IGNORE_USER_HOST_NAME, -5308, -1, "HY000", "Ignore the host name");
DEFINE_ERROR(OB_IGNORE_SQL_IN_RESTORE, -5309, -1, "HY000", "Ignore sql in restore process");
DEFINE_ERROR(OB_ERR_TEMPORARY_TABLE_WITH_PARTITION, -5310, ER_PARTITION_NO_TEMPORARY, "HY000", "Cannot create temporary table with partitions");
DEFINE_ERROR_EXT(OB_ERR_INVALID_COLUMN_ID, -5311, -1, "HY000", "Invalid column id", "Invalid column id for %.*s");
DEFINE_ERROR_EXT(OB_SYNC_DDL_DUPLICATE, -5312, -1, "HY000", "Duplicated ddl id", "Duplicated ddl id '%.*s'");
DEFINE_ERROR_EXT(OB_SYNC_DDL_ERROR, -5313, -1, "HY000", "Failed to sync ddl", "Failed to sync ddl '%.*s'");
DEFINE_ORACLE_ERROR(OB_ERR_ROW_IS_REFERENCED, -5314, ER_ROW_IS_REFERENCED_2, "23000", "Cannot delete or update a parent row: a foreign key constraint fails", 2292, "integrity constraint violated - child record found");
DEFINE_ORACLE_ERROR(OB_ERR_NO_REFERENCED_ROW, -5315, ER_NO_REFERENCED_ROW_2, "23000", "Cannot add or update a child row: a foreign key constraint fails", 2291, "integrity constraint violated - parent key not found");
DEFINE_ERROR_EXT(OB_ERR_FUNC_RESULT_TOO_LARGE, -5316, ER_WARN_ALLOWED_PACKET_OVERFLOWED, "HY000", "Result of function was larger than max_allowed_packet - truncated", "Result of %s() was larger than max_allowed_packet (%d) - truncated");
DEFINE_ERROR(OB_ERR_CANNOT_ADD_FOREIGN, -5317, ER_CANNOT_ADD_FOREIGN, "HY000", "Cannot add foreign key constraint");
DEFINE_ERROR(OB_ERR_WRONG_FK_DEF, -5318, ER_WRONG_FK_DEF, "42000", "Incorrect foreign key definition: Key reference and table reference don't match");
DEFINE_ERROR_EXT(OB_ERR_INVALID_CHILD_COLUMN_LENGTH_FK, -5319, -1, "HY000", "Invalid child column length", "Child column \'%.*s\' data length cannot be less than parent column \'%.*s\' data length");
DEFINE_ERROR_EXT(OB_ERR_ALTER_COLUMN_FK, -5320, -1, "HY000", "Cannot alter foreign key column", "\'%.*s\': used in a foreign key constraint");
DEFINE_ERROR(OB_ERR_CONNECT_BY_REQUIRED, -5321, -1, "HY000", "CONNECT BY clause required in this query block");
DEFINE_ERROR(OB_ERR_INVALID_PSEUDO_COLUMN_PLACE, -5322, -1, "HY000", "Specified pseudocolumn, operator or function not allowed here");
DEFINE_ERROR(OB_ERR_NOCYCLE_REQUIRED, -5323, -1, "HY000", "NOCYCLE keyword is required with CONNECT_BY_ISCYCLE pseudocolumn");
DEFINE_ERROR(OB_ERR_CONNECT_BY_LOOP, -5324, -1, "HY000", "CONNECT BY loop in user data");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_SIBLINGS, -5325, -1, "HY000", "ORDER SIBLINGS BY clause not allowed here", 30929, "ORDER SIBLINGS BY clause not allowed here");
DEFINE_ERROR(OB_ERR_INVALID_SEPARATOR, -5326, -1, "HY000", "when using SYS_CONNECT_BY_PATH function, cannot have separator as part of column value");
DEFINE_ERROR(OB_ERR_INVALID_SYNONYM_NAME, -5327, -1, "HY000", "Database can not be specified in public synonym");
DEFINE_ERROR(OB_ERR_LOOP_OF_SYNONYM, -5328, -1, "HY000", "Looping chain of synonyms");
DEFINE_ERROR(OB_ERR_SYNONYM_SAME_AS_OBJECT, -5329, -1, "HY000", "Cannot create a synonym with same name as object");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_SYNONYM_TRANSLATION_INVALID, -5330, -1, "HY000", "Synonym translation is no longer valid", "Synonym %s translation is no longer valid", 980, "synonym translation is no longer valid", "synonym %s translation is no longer valid");
DEFINE_ORACLE_ERROR(OB_ERR_EXIST_OBJECT, -5331, -1, "HY000", "name is already used by an existing object", 955, "name is already used by an existing object");
DEFINE_ERROR_EXT(OB_ERR_ILLEGAL_VALUE_FOR_TYPE, -5332, ER_ILLEGAL_VALUE_FOR_TYPE, "22007", "Illegal value found during parsing", "Illegal %s '%.*s' value found during parsing");
DEFINE_ERROR_EXT(OB_ER_TOO_LONG_SET_ENUM_VALUE, -5333, ER_TOO_LONG_SET_ENUM_VALUE, "HY000", "Too long enumeration/set value for column.", "Too long enumeration/set value for column %.*s.");
DEFINE_ORACLE_ERROR_EXT(OB_ER_DUPLICATED_VALUE_IN_TYPE, -5334, ER_DUPLICATED_VALUE_IN_TYPE, "HY000", "Column has duplicated value", "Column '%.*s' has duplicated value '%.*s' in %s ", 1, "unique constraint violated", "unique constraint violated, column '%.*s' with value '%.*s' in %s");
DEFINE_ERROR_EXT(OB_ER_TOO_BIG_ENUM, -5335, ER_TOO_BIG_ENUM, "HY000", "Too many enumeration values for column", "Too many enumeration values for column %.*s");
DEFINE_ERROR_EXT(OB_ERR_TOO_BIG_SET, -5336, ER_TOO_BIG_SET, "HY000", "Too many strings for column", "Too many strings for column %.*s and SET");
DEFINE_ERROR(OB_ERR_WRONG_ROWID, -5337, -1, "HY000", "rowid is wrong");
DEFINE_ERROR(OB_ERR_INVALID_WINDOW_FUNCTION_PLACE, -5338, -1, "HY000", "Window Function not allowed here");
DEFINE_ERROR(OB_ERR_PARSE_PARTITION_LIST, -5339, -1, "HY000", "Fail to parse list partition");
DEFINE_ERROR(OB_ERR_MULTIPLE_DEF_CONST_IN_LIST_PART, -5340, ER_MULTIPLE_DEF_CONST_IN_LIST_PART_ERROR, "HY000", "Multiple definition of same constant in list partitioning");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_TIMEZONE_REGION_ID, -5341, -1, "HY000", "timezone region ID is invalid", 1881, "timezone region ID is invalid");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_HEX_NUMBER, -5342, -1, "HY000", "invalid hex number", 1465, "invalid hex number");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_WRONG_FUNC_ARGUMENTS_TYPE, -5343, -1, "42000", "wrong number or types of arguments in function", "wrong number or types of arguments in call to '%.*s'", 6553, "wrong number or types of arguments in function", "wrong number or types of arguments in call to '%.*s'");
DEFINE_ERROR_EXT(OB_ERR_MULTI_UPDATE_KEY_CONFLICT, -5344, ER_MULTI_UPDATE_KEY_CONFLICT, "HY000", "Primary key/index key/partition key update is not allowed", "Primary key/index key/partition key update is not allowed since the table is updated both as '%.*s' and '%.*s'");
DEFINE_ORACLE_ERROR(OB_ERR_INSUFFICIENT_PX_WORKER, -5345, -1, "HY000", "insufficient parallel query worker available", 12827, "insufficient parallel query worker available");
DEFINE_ORACLE_ERROR(OB_ERR_FOR_UPDATE_EXPR_NOT_ALLOWED, -5346, -1, "HY000", "FOR UPDATE of this query expression is not allowed", 1786, "FOR UPDATE of this query expression is not allowed");
DEFINE_ORACLE_ERROR(OB_ERR_WIN_FUNC_ARG_NOT_IN_PARTITION_BY, -5347, -1, "HY000", "argument should be a function of expressions in PARTITION BY", 30488, "argument should be a function of expressions in PARTITION BY");
DEFINE_ORACLE_ERROR(OB_ERR_TOO_LONG_STRING_IN_CONCAT, -5348, -1, "HY000", "result of string concatenation is too long", 1489, "result of string concatenation is too long");
DEFINE_ORACLE_ERROR(OB_ERR_WRONG_TIMESTAMP_LTZ_COLUMN_VALUE_ERROR, -5349, ER_WRONG_TYPE_COLUMN_VALUE_ERROR, "HY000", "Partition column values of incorrect type", 30078, "partition bound must be TIME/TIMESTAMP WITH TIME ZONE literals");
DEFINE_ORACLE_ERROR(OB_ERR_UPD_CAUSE_PART_CHANGE, -5350, -1, "HY000", "updating partition key column would cause a partition change", 14402, "updating partition key column would cause a partition change");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_TYPE_FOR_ARGUMENT, -5351, -1, "HY000", "invalid type given for an argument", 30175, "invalid type given for an argument");
DEFINE_ORACLE_ERROR(OB_ERR_FIELD_NOT_FOUND_IN_DATETIME_OR_INTERVAL, -5352, -1, "HY000", "specified field not found in datetime or interval", 1878, "specified field not found in datetime or interval");
DEFINE_ORACLE_ERROR(OB_ERR_ADD_PART_BOUN_NOT_INC, -5353, ER_RANGE_NOT_INCREASING_ERROR, "HY000", "VALUES LESS THAN value must be strictly increasing for each partition", 14074, "partition bound must collate higher than that of the last partition");
DEFINE_ORACLE_ERROR(OB_ERR_DATA_TOO_LONG_IN_PART_CHECK,-5354, ER_DATA_TOO_LONG, "22001", "Data too long for column", 14036, "partition bound value too large for column");
DEFINE_ORACLE_ERROR(OB_ERR_WRONG_TYPE_COLUMN_VALUE_V2_ERROR, -5355, ER_WRONG_TYPE_COLUMN_VALUE_ERROR, "HY000", "Partition column values of incorrect type", 14308, "partition bound element must be one of: string, datetime or interval literal, number, or NULL");
DEFINE_ERROR(OB_CANT_AGGREGATE_3COLLATIONS, -5356, ER_CANT_AGGREGATE_3COLLATIONS, "HY000", "Illegal mix of collations");
DEFINE_ERROR(OB_CANT_AGGREGATE_NCOLLATIONS, -5357, ER_CANT_AGGREGATE_NCOLLATIONS, "HY000", "Illegal mix of collations");

DEFINE_ORACLE_ERROR(OB_ERR_NO_SYS_PRIVILEGE, -5360, -1, "HY000", "insufficient privileges", 1031, "insufficient privileges");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_NO_LOGIN_PRIVILEGE, -5361, -1, "HY000", "user lacks CREATE SESSION privilege logon denied", "user %.*s lacks CREATE SESSION privilege; logon denied", 1045, "user lacks CREATE SESSION privilege; logon denied", "user %.*s lacks CREATE SESSION privilege; logon denied");
DEFINE_ORACLE_ERROR(OB_ERR_CANNOT_REVOKE_PRIVILEGES_YOU_DID_NOT_GRANT, -5362, OB_ERR_NO_GRANT, "42000", "No such grant defined", 1927, "cannot REVOKE privileges you did not grant");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_SYSTEM_PRIVILEGES_NOT_GRANTED_TO, -5363, -1, "HY000", "system privileges not granted to", "system privileges not granted to '%.*s'", 1952, "system privileges not granted to", "system privileges not granted to '%.*s'");
DEFINE_ORACLE_ERROR(OB_ERR_ONLY_SELECT_AND_ALTER_PRIVILEGES_ARE_VALID_FOR_SEQUENCES, -5364, -1, "HY000", "only SELECT and ALTER privileges are valid for sequences", 2205, "only SELECT and ALTER privileges are valid for sequences");
DEFINE_ORACLE_ERROR(OB_ERR_EXECUTE_PRIVILEGE_NOT_ALLOWED_FOR_TABLES, -5365, -1, "HY000", "EXECUTE privilege not allowed for tables", 2224, "EXECUTE privilege not allowed for tables");
DEFINE_ORACLE_ERROR(OB_ERR_ONLY_EXECUTE_AND_DEBUG_PRIVILEGES_ARE_VALID_FOR_PROCEDURES, -5366, -1, "HY000", "only EXECUTE and DEBUG privileges are valid for procedures", 2225, "only EXECUTE and DEBUG privileges are valid for procedures");
DEFINE_ORACLE_ERROR(OB_ERR_ONLY_EXECUTE_DEBUG_AND_UNDER_PRIVILEGES_ARE_VALID_FOR_TYPES, -5367, -1, "HY000", "only EXECUTE, DEBUG, and UNDER privileges are valid for types", 2305, "only EXECUTE, DEBUG, and UNDER privileges are valid for types");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_ADMIN_OPTION_NOT_GRANTED_FOR_ROLE, -5368, -1, "HY000", "ADMIN option not granted for role", "ADMIN option not granted for role '%.*s'", 1932, "ADMIN option not granted for role", "ADMIN option not granted for role '%.*s'");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_USER_OR_ROLE_DOES_NOT_EXIST, -5369, -1, "HY000", "user or role does not exist", "user or role '%.*s' does not exist", 1917, "user or role does not exist", "user or role '%.*s' does not exist");
DEFINE_ORACLE_ERROR(OB_ERR_MISSING_ON_KEYWORD, -5370, -1, "HY000", "missing ON keyword", 969, "missing ON keyword");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_NO_GRANT_OPTION, -5371, -1, "HY000", "grant option does not exists", "grant option does not exist for '%.*s.%.*s'", 1720, "grant option does not exist", "grant option does not exist for '%.*s.%.*s'");
DEFINE_ORACLE_ERROR(OB_ERR_ALTER_INDEX_AND_EXECUTE_NOT_ALLOWED_FOR_VIEWS, -5372, -1, "HY000", "ALTER, INDEX and EXECUTE not allowed for views", 2204, "ALTER, INDEX and EXECUTE not allowed for views");
DEFINE_ORACLE_ERROR(OB_ERR_CIRCULAR_ROLE_GRANT_DETECTED, -5373, -1, "HY000", "circular role grant detected", 1934, "circular role grant detected");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_PRIVILEGE_ON_DIRECTORIES, -5374, -1, "HY000", "invalid privilege on directories", 22928, "invalid privilege on directories");
DEFINE_ORACLE_ERROR(OB_ERR_DIRECTORY_ACCESS_DENIED, -5375, -1, "HY000", "directory access denied", 29289, "directory access denied");
DEFINE_ORACLE_ERROR(OB_ERR_MISSING_OR_INVALID_ROLE_NAME, -5376, -1, "HY000", "missing or invalid role name", 1937, "missing or invalid role name");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_ROLE_NOT_GRANTED_OR_DOES_NOT_EXIST, -5377, -1, "HY000", "role not granted or does not exist", "role '%.*s' not granted or does not exist", 1924, "role not granted or does not exist", "role '%.*s' not granted or does not exist");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_DEFAULT_ROLE_NOT_GRANTED_TO_USER, -5378, -1, "HY000", "DEFAULT ROLE not granted to user", "DEFAULT ROLE '%.*s' not granted to user", 1955, "DEFAULT ROLE not granted to user", "DEFAULT ROLE '%.*s' not granted to user");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_ROLE_NOT_GRANTED_TO, -5379, -1, "HY000", "ROLE not granted to", "ROLE '%.*s' not granted to '%.*s'", 1951, "ROLE not granted to", "ROLE '%.*s' not granted to '%.*s'");
DEFINE_ORACLE_ERROR(OB_ERR_CANNOT_GRANT_TO_A_ROLE_WITH_GRANT_OPTION, -5380, -1, "HY000", "cannot GRANT to a role WITH GRANT OPTION", 1926, "cannot GRANT to a role WITH GRANT OPTION");
DEFINE_ORACLE_ERROR(OB_ERR_DUPLICATE_USERNAME_IN_LIST, -5381, -1, "HY000", "duplicate username in list", 1700, "duplicate username in list");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_CANNOT_GRANT_STRING_TO_A_ROLE, -5382, -1, "HY000", "cannot grant string to a role", "cannot grant %.*s to a role", 1931, "cannot grant string to a role", "cannot grant %.*s to a role");
DEFINE_ORACLE_ERROR(OB_ERR_CASCADE_CONSTRAINTS_MUST_BE_SPECIFIED_TO_PERFORM_THIS_REVOKE, -5383, -1, "HY000", "CASCADE CONSTRAINTS must be specified to perform this revoke", 1981, "CASCADE CONSTRAINTS must be specified to perform this revoke");
DEFINE_ORACLE_ERROR(OB_ERR_YOU_MAY_NOT_REVOKE_PRIVILEGES_FROM_YOURSELF, -5384, -1, "HY000", "you may not GRANT/REVOKE privileges to/from yourself", 1749, "you may not GRANT/REVOKE privileges to/from yourself");

DEFINE_ERROR_EXT(OB_ERR_SP_ALREADY_EXISTS, -5541, ER_SP_ALREADY_EXISTS, "42000", "procedure/function already exists", "%s %.*s already exists");
DEFINE_ERROR_EXT(OB_ERR_SP_DOES_NOT_EXIST, -5542, ER_SP_DOES_NOT_EXIST, "42000", "procedure/function does not exist", "%s %.*s.%.*s does not exist");
DEFINE_PLS_ERROR_EXT(OB_ERR_SP_UNDECLARED_VAR, -5543, ER_SP_UNDECLARED_VAR, "42000", "Undeclared variable", "Undeclared variable: %.*s", 201, "identifier must be declared", "identifier '%.*s' must be declared");
DEFINE_ERROR_EXT(OB_ERR_SP_UNDECLARED_TYPE, -5544, ER_SP_UNDECLARED_VAR, "42000", "Undeclared type", "Undeclared type: %.*s");
DEFINE_ERROR_EXT(OB_ERR_SP_COND_MISMATCH, -5545, ER_SP_COND_MISMATCH, "42000", "Undefined CONDITION", "Undefined CONDITION: %.*s");
DEFINE_PLS_ERROR_EXT(OB_ERR_SP_LILABEL_MISMATCH, -5546, ER_SP_LILABEL_MISMATCH, "42000", "no matching label", "no matching label: %.*s", 201, "identifier must be declared", "identifier '%.*s' must be declared");
DEFINE_ERROR_EXT(OB_ERR_SP_CURSOR_MISMATCH, -5547, ER_SP_CURSOR_MISMATCH, "42000", "Undefined CURSOR", "Undefined CURSOR: %.*s");
DEFINE_ERROR_EXT(OB_ERR_SP_DUP_PARAM, -5548, ER_SP_DUP_PARAM, "42000", "Duplicate parameter", "Duplicate parameter: %.*s");
DEFINE_ERROR_EXT(OB_ERR_SP_DUP_VAR, -5549, ER_SP_DUP_VAR, "42000", "Duplicate variable", "Duplicate variable: %.*s");
DEFINE_ERROR_EXT(OB_ERR_SP_DUP_TYPE, -5550, ER_SP_DUP_PARAM, "42000", "Duplicate type", "Duplicate type: %.*s");
DEFINE_ERROR_EXT(OB_ERR_SP_DUP_CONDITION, -5551, ER_SP_DUP_COND, "42000", "Duplicate condition", "Duplicate condition: %.*s");
DEFINE_ERROR_EXT(OB_ERR_SP_DUP_LABEL, -5552, ER_SP_DUP_PARAM, "42000", "Duplicate label", "Duplicate label: %.*s");
DEFINE_ERROR_EXT(OB_ERR_SP_DUP_CURSOR, -5553, ER_SP_DUP_CURS, "42000", "Duplicate cursor", "Duplicate cursor: %.*s");
DEFINE_ERROR(OB_ERR_SP_INVALID_FETCH_ARG, -5554, ER_SP_WRONG_NO_OF_FETCH_ARGS, "HY000", "Incorrect number of FETCH variables");
DEFINE_ERROR_EXT(OB_ERR_SP_WRONG_ARG_NUM, -5555, ER_SP_WRONG_NO_OF_ARGS, "42000", "Incorrect number of arguments", "Incorrect number of arguments for %s %s; expected %u, got %u");
DEFINE_ERROR_EXT(OB_ERR_SP_UNHANDLED_EXCEPTION, -5556, ER_SIGNAL_EXCEPTION, "HY000", "Unhandled exception has occurred in PL", "Unhandled user-defined exception condition");
DEFINE_ERROR(OB_ERR_SP_BAD_CONDITION_TYPE, -5557, ER_SIGNAL_BAD_CONDITION_TYPE, "HY000", "SIGNAL/RESIGNAL can only use a CONDITION defined with SQLSTATE");
DEFINE_ERROR_EXT(OB_ERR_PACKAGE_ALREADY_EXISTS, -5558, -1, "42000", "package already exists", "%s \'%.*s.%.*s\' already exists");
DEFINE_ERROR_EXT(OB_ERR_PACKAGE_DOSE_NOT_EXIST, -5559, -1, "42000", "package does not exist", "%s \'%.*s.%.*s\' does not exist");
DEFINE_ERROR(OB_EER_UNKNOWN_STMT_HANDLER, -5560, ER_UNKNOWN_STMT_HANDLER, "HY000", "Unknown prepared statement handle");
DEFINE_ERROR(OB_ERR_INVALID_WINDOW_FUNC_USE, -5561, -1, "HY000", "Invalid use of window function");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_CONSTRAINT_DUPLICATE, -5562, -1, "HY000", "Duplicate constraint name", "Duplicate constraint name '%.*s'", 1, "unique constraint violated", "unique constraint (%.*s) violated");
DEFINE_ERROR(OB_ERR_CONTRAINT_NOT_FOUND, -5563, -1, "HY000", "Constraint not found");
DEFINE_ERROR_EXT(OB_ERR_ALTER_TABLE_ALTER_DUPLICATED_INDEX, -5564, -1, "HY000", "Duplicate alter index operations", "Duplicate alter index operations on column \'%.*s\'");
DEFINE_ERROR(OB_EER_INVALID_ARGUMENT_FOR_LOGARITHM, -5565, ER_INVALID_ARGUMENT_FOR_LOGARITHM, "2201E", "Invalid argument for logarithm");
DEFINE_ERROR(OB_ERR_REORGANIZE_OUTSIDE_RANGE, -5566, ER_REORG_OUTSIDE_RANGE, "HY000", "Reorganize of range partitions cannot change total ranges except for last partition where it can extend the range");
DEFINE_ERROR_EXT(OB_ER_SP_RECURSION_LIMIT, -5567, ER_SP_RECURSION_LIMIT, "HY000", "Recursive limit was exceeded", "Recursive limit %ld (as set by the max_sp_recursion_depth variable) was exceeded for routine");
DEFINE_ERROR(OB_ER_UNSUPPORTED_PS, -5568, ER_UNSUPPORTED_PS, "HY000", "This command is not supported in the prepared statement protocol yet");
DEFINE_ERROR_EXT(OB_ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG, -5569, ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG, "0A000", "stmt is not allowed in stored function", "%s is not allowed in stored function");
DEFINE_ERROR(OB_ER_SP_NO_RECURSION, -5570, ER_SP_NO_RECURSION, "HY000", "Recursive stored functions are not allowed.");
DEFINE_ERROR(OB_ER_SP_CASE_NOT_FOUND, -5571, ER_SP_CASE_NOT_FOUND, "20000", "Case not found for CASE statement");
DEFINE_ERROR(OB_ERR_INVALID_SPLIT_COUNT, -5572, -1, "HY000", "a partition may be split into exactly two new partitions");
DEFINE_ERROR(OB_ERR_INVALID_SPLIT_GRAMMAR, -5573, -1, "HY000", "this physical attribute may not be specified for a table partition");
DEFINE_ORACLE_ERROR(OB_ERR_MISS_VALUES, -5574, -1, "HY000", "missing VALUES keyword", 926, "missing VALUES keyword");
DEFINE_ERROR(OB_ERR_MISS_AT_VALUES, -5575, -1, "HY000", "missing AT or VALUES keyword");
DEFINE_ERROR(OB_ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, -5576, ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, "HY000", "Explicit or implicit commit is not allowed in stored function.");
DEFINE_ERROR(OB_PC_GET_LOCATION_ERROR, -5577, -1, "HY000", "Plan cache get location failed");
DEFINE_ERROR(OB_PC_LOCK_CONFLICT, -5578, -1, "HY000", "Plan cache lock conflict");
DEFINE_ERROR(OB_ER_SP_NO_RETSET, -5579, ER_SP_NO_RETSET, "0A000", "Not allowed to return a result set in pl function");
DEFINE_ERROR_EXT(OB_ER_SP_NORETURNEND, -5580, ER_SP_NORETURNEND, "2F005", "FUNCTION ended without RETURN", "FUNCTION %s ended without RETURN");
DEFINE_ERROR(OB_ERR_SP_DUP_HANDLER, -5581, ER_SP_DUP_HANDLER, "42000", "Duplicate handler declared in the same block");
DEFINE_ERROR(OB_ER_SP_NO_RECURSIVE_CREATE, -5582, ER_SP_NO_RECURSIVE_CREATE, "2F003", "Can\'t create a routine from within another routine");
DEFINE_PLS_ERROR(OB_ER_SP_BADRETURN, -5583, ER_SP_BADRETURN, "42000", "RETURN is only allowed in a FUNCTION", 372, "In a procedure, RETURN statement cannot contain an expression");
DEFINE_ERROR(OB_ER_SP_BAD_CURSOR_SELECT, -5584, ER_SP_BAD_CURSOR_SELECT, "42000", "Cursor SELECT must not have INTO");
DEFINE_ERROR_EXT(OB_ER_SP_BAD_SQLSTATE, -5585, ER_SP_BAD_SQLSTATE, "42000", "Bad SQLSTATE", "Bad SQLSTATE: \'%.*s\'");
DEFINE_ERROR(OB_ER_SP_VARCOND_AFTER_CURSHNDLR, -5586, ER_SP_VARCOND_AFTER_CURSHNDLR, "42000", "Variable or condition declaration after cursor or handler declaration");
DEFINE_ERROR(OB_ER_SP_CURSOR_AFTER_HANDLER, -5587, ER_SP_CURSOR_AFTER_HANDLER, "42000", "Cursor declaration after handler declaration");
DEFINE_ERROR_EXT(OB_ER_SP_WRONG_NAME, -5588, ER_SP_WRONG_NAME, "42000", "Incorrect routine name", "Incorrect routine name \'%.*s\'");
DEFINE_ERROR(OB_ER_SP_CURSOR_ALREADY_OPEN, -5589, ER_SP_CURSOR_ALREADY_OPEN, "24000", "Cursor is already open");
DEFINE_ERROR(OB_ER_SP_CURSOR_NOT_OPEN, -5590, ER_SP_CURSOR_NOT_OPEN, "24000", "Cursor is not open");
DEFINE_ERROR(OB_ER_SP_CANT_SET_AUTOCOMMIT, -5591, ER_SP_CANT_SET_AUTOCOMMIT, "HY000", "Not allowed to set autocommit from a stored function");
DEFINE_ERROR_EXT(OB_ER_SP_NOT_VAR_ARG, -5592, ER_SP_NOT_VAR_ARG, "42000", "OUT or INOUT argument for routine is not a variable", "OUT or INOUT argument %d for routine %.*s is not a variable");
DEFINE_ERROR_EXT(OB_ER_SP_LILABEL_MISMATCH, -5593, ER_SP_LILABEL_MISMATCH, "42000", "with no matching label", "%s with no matching label: %s");
DEFINE_ERROR_EXT(OB_ERR_TRUNCATE_ILLEGAL_FK, -5594, ER_TRUNCATE_ILLEGAL_FK, "42000", "Cannot truncate a table referenced in a foreign key constraint", "Cannot truncate a table referenced in a foreign key constraint %.*s");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_DUP_KEY, -5595, ER_DUP_KEY, "23000", "Can't write; duplicate key in table", "Can't write; duplicate key in table \'%.*s\'", 1, "unique constraint violated", "unique constraint (%.*s) violated");
DEFINE_ERROR(OB_ER_INVALID_USE_OF_NULL, -5596, ER_INVALID_USE_OF_NULL, "22004", "Invalid use of NULL value");
DEFINE_ERROR(OB_ERR_SPLIT_LIST_LESS_VALUE, -5597, -1, "HY000", "last resulting partition cannot contain bounds");
DEFINE_ERROR(OB_ERR_ADD_PARTITION_TO_DEFAULT_LIST, -5598, -1, "HY000", "cannot add partition when DEFAULT partition exists");
DEFINE_ERROR(OB_ERR_SPLIT_INTO_ONE_PARTITION, -5599, -1, "HY000", "cannot split partition into one partition, use rename instead");
DEFINE_ERROR_EXT(OB_ERR_NO_TENANT_PRIVILEGE, -5600, -1, "HY000", "can not create user in sys tenant", "can not create user %s in sys tenant, name %.*s");
DEFINE_ERROR(OB_ERR_INVALID_PERCENTAGE, -5601, -1, "HY000", "Percentage should between 1 and 99");
DEFINE_ERROR(OB_ERR_COLLECT_HISTOGRAM, -5602, -1, "HY000", "Should collect histogram after major freeze");
DEFINE_ERROR(OB_ER_TEMP_TABLE_IN_USE, -5603, -1, "0A000", "Attempt to create, alter or drop an index on temporary table already in use");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_NLS_PARAMETER_STRING, -5604, -1, "HY000", "invalid NLS parameter string used in SQL function", 12702, "invalid NLS parameter string used in SQL function");
DEFINE_ORACLE_ERROR(OB_ERR_DATETIME_INTERVAL_PRECISION_OUT_OF_RANGE, -5605, -1, "HY000", "datetime/interval precision is out of range", 30088, "datetime/interval precision is out of range");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_NUMBER_FORMAT_MODEL, -5606, -1, "42000", "Invalid number format model", 1481, "invalid number format model");
DEFINE_ORACLE_ERROR(OB_ERR_CMD_NOT_PROPERLY_ENDED, -5607, -1, "HY000", "SQL command not properly ended", 933, "SQL command not properly ended");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_NUMBER_FORMAT_MODEL, -5608, -1, "42000", "invalid number format model", 1481, "invalid number format model");
DEFINE_ERROR(OB_WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED, -5609, ER_WRONG_FIELD_TERMINATORS, "HY000", "Non-ASCII separator arguments are not fully supported");
DEFINE_ERROR(OB_WARN_AMBIGUOUS_FIELD_TERM, -5610, ER_WRONG_FIELD_TERMINATORS, "HY000", "First character of the FIELDS TERMINATED string is ambiguous; please use non-optional and non-empty FIELDS ENCLOSED BY");
DEFINE_ERROR_EXT(OB_WARN_TOO_FEW_RECORDS, -5611, ER_WARN_TOO_FEW_RECORDS, "01000", "Row doesn't contain data for all columns", "Row %ld doesn't contain data for all columns");
DEFINE_ERROR_EXT(OB_WARN_TOO_MANY_RECORDS, -5612, ER_WARN_TOO_MANY_RECORDS, "01000", "Row was truncated; it contained more data than there were input columns", "Row %ld was truncated; it contained more data than there were input columns");
DEFINE_ORACLE_ERROR(OB_ERR_TOO_MANY_VALUES, -5613, -1, "HY000", "too many values", 913, "too many values");
DEFINE_ORACLE_ERROR(OB_ERR_NOT_ENOUGH_VALUES, -5614, -1, "HY000", "not enough values", 947, "not enough values");
DEFINE_ORACLE_ERROR(OB_ERR_MORE_THAN_ONE_ROW, -5615, -1, "HY000", "single-row subquery returns more than one row", 1427, "single-row subquery returns more than one row");
DEFINE_ORACLE_ERROR(OB_ERR_NOT_SUBQUERY, -5616, -1, "HY000", "UPDATE ... SET expression must be a subquery", 1767, "UPDATE ... SET expression must be a subquery");
DEFINE_ORACLE_ERROR(OB_INAPPROPRIATE_INTO, -5617, -1, "HY000", "inappropriate INTO", 1744, "inappropriate INTO");
DEFINE_ORACLE_ERROR(OB_ERR_TABLE_IS_REFERENCED, -5618, ER_ROW_IS_REFERENCED, "23000", "Cannot delete or update a parent row: a foreign key constraint fails", 2292, "integrity constraint violated - child record found");
DEFINE_ORACLE_ERROR(OB_ERR_QUALIFIER_EXISTS_FOR_USING_COLUMN, -5619, -1, "HY000", "Column part of using clause can not have qualifier", 25154, "Column part of using clause can not have qualifier");
DEFINE_ORACLE_ERROR(OB_ERR_OUTER_JOIN_NESTED, -5620, -1, "HY000", "two tables cannot be outer-joined to each other", 1416, "two tables cannot be outer-joined to each other");
DEFINE_ORACLE_ERROR(OB_ERR_MULTI_OUTER_JOIN_TABLE, -5621, -1, "HY000", "a predicate may reference only one outer-joined table", 1468, "a predicate may reference only one outer-joined table");
DEFINE_ORACLE_ERROR(OB_ERR_OUTER_JOIN_ON_CORRELATION_COLUMN, -5622, -1, "HY000", "an outer join cannot be specified on a correlation column", 1705, "an outer join cannot be specified on a correlation column");
DEFINE_ORACLE_ERROR(OB_ERR_OUTER_JOIN_AMBIGUOUS, -5623, -1, "HY000", "outer join operator (+) not allowed in operand of OR or IN", 1719, "outer join operator (+) not allowed in operand of OR or IN");
DEFINE_ORACLE_ERROR(OB_ERR_OUTER_JOIN_WITH_SUBQUERY, -5624, -1, "HY000", "a column may not be outer-joined to a subquery", 1799, "a column may not be outer-joined to a subquery");
DEFINE_ORACLE_ERROR(OB_ERR_OUTER_JOIN_WITH_ANSI_JOIN, -5625, -1, "HY000", "old style outer join (+) cannot be used with ANSI joins", 25156, "old style outer join (+) cannot be used with ANSI joins");
DEFINE_ORACLE_ERROR(OB_ERR_OUTER_JOIN_NOT_ALLOWED, -5626, -1, "HY000", "outer join operator (+) is not allowed here", 30563, "outer join operator (+) is not allowed here");
DEFINE_ERROR(OB_SCHEMA_EAGAIN, -5627, -1, "HY000", "Schema try again");
DEFINE_ORACLE_ERROR(OB_ERR_ZERO_LEN_COL, -5628, -1, "HY000", "zero-length columns are not allowed", 1723, "zero-length columns are not allowed");
DEFINE_ORACLE_ERROR(OB_ERR_YEAR_CONFLICTS_WITH_JULIAN_DATE, -5629, -1, "HY000", "year conflicts with Julian date", 1831, "year conflicts with Julian date");
DEFINE_ORACLE_ERROR(OB_ERR_DAY_OF_YEAR_CONFLICTS_WITH_JULIAN_DATE, -5630, -1, "HY000", "day of year conflicts with Julian date", 1832, "day of year conflicts with Julian date");
DEFINE_ORACLE_ERROR(OB_ERR_MONTH_CONFLICTS_WITH_JULIAN_DATE, -5631, -1, "HY000", "month conflicts with Julian date", 1833, "month conflicts with Julian date");
DEFINE_ORACLE_ERROR(OB_ERR_DAY_OF_MONTH_CONFLICTS_WITH_JULIAN_DATE, -5632, -1, "HY000", "day of month conflicts with Julian date", 1834, "day of month conflicts with Julian date");
DEFINE_ORACLE_ERROR(OB_ERR_DAY_OF_WEEK_CONFLICTS_WITH_JULIAN_DATE, -5633, -1, "HY000", "day of week conflicts with Julian date", 1835, "day of week conflicts with Julian date");
DEFINE_ORACLE_ERROR(OB_ERR_HOUR_CONFLICTS_WITH_SECONDS_IN_DAY, -5634, -1, "HY000", "hour conflicts with seconds in day", 1836, "hour conflicts with seconds in day");
DEFINE_ORACLE_ERROR(OB_ERR_MINUTES_OF_HOUR_CONFLICTS_WITH_SECONDS_IN_DAY, -5635, -1, "HY000", "minutes of hour conflicts with seconds in day", 1837, "minutes of hour conflicts with seconds in day");
DEFINE_ORACLE_ERROR(OB_ERR_SECONDS_OF_MINUTE_CONFLICTS_WITH_SECONDS_IN_DAY, -5636, -1, "HY000", "seconds of minute conflicts with seconds in day", 1838, "seconds of minute conflicts with seconds in day");
DEFINE_ORACLE_ERROR(OB_ERR_DATE_NOT_VALID_FOR_MONTH_SPECIFIED, -5637, -1, "HY000", "date not valid for month specified", 1839, "date not valid for month specified");
DEFINE_ORACLE_ERROR(OB_ERR_INPUT_VALUE_NOT_LONG_ENOUGH, -5638, -1, "HY000", "input value not long enough for date format", 1840, "input value not long enough for date format");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_YEAR_VALUE, -5639, -1, "HY000", "(full) year must be between -4713 and +9999, and not be 0", 1841, "(full) year must be between -4713 and +9999, and not be 0");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_QUARTER_VALUE, -5640, -1, "HY000", "quarter must be between 1 and 4", 1842, "quarter must be between 1 and 4");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_MONTH, -5641, -1, "HY000", "not a valid month", 1843, "not a valid month");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_DAY_OF_THE_WEEK, -5642, -1, "HY000", "not a valid day of the week", 1846, "not a valid day of the week");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_DAY_OF_YEAR_VALUE, -5643, -1, "HY000", "day of year must be between 1 and 365 (366 for leap year)", 1848, "day of year must be between 1 and 365 (366 for leap year)");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_HOUR12_VALUE, -5644, -1, "HY000", "hour must be between 1 and 12", 1849, "hour must be between 1 and 12");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_HOUR24_VALUE, -5645, -1, "HY000", "hour must be between 0 and 23", 1850, "hour must be between 0 and 23");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_MINUTES_VALUE, -5646, -1, "HY000", "minutes must be between 0 and 59", 1851, "minutes must be between 0 and 59");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_SECONDS_VALUE, -5647, -1, "HY000", "seconds must be between 0 and 59", 1852, "seconds must be between 0 and 59");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_SECONDS_IN_DAY_VALUE, -5648, -1, "HY000", "seconds in day must be between 0 and 86399", 1853, "seconds in day must be between 0 and 86399");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_JULIAN_DATE_VALUE, -5649, -1, "HY000", "julian date must be between 1 and 5373484", 1854, "julian date must be between 1 and 5373484");
DEFINE_ORACLE_ERROR(OB_ERR_AM_OR_PM_REQUIRED, -5650, -1, "HY000", "AM/A.M. or PM/P.M. required", 1855, "AM/A.M. or PM/P.M. required");
DEFINE_ORACLE_ERROR(OB_ERR_BC_OR_AD_REQUIRED, -5651, -1, "HY000", "BC/B.C. or AD/A.D. required", 1856, "BC/B.C. or AD/A.D. required");
DEFINE_ORACLE_ERROR(OB_ERR_FORMAT_CODE_APPEARS_TWICE, -5652, -1, "HY000", "format code appears twice", 1810, "format code appears twice");
DEFINE_ORACLE_ERROR(OB_ERR_DAY_OF_WEEK_SPECIFIED_MORE_THAN_ONCE, -5653, -1, "HY000", "day of week may only be specified once", 1817, "day of week may only be specified once");
DEFINE_ORACLE_ERROR(OB_ERR_SIGNED_YEAR_PRECLUDES_USE_OF_BC_AD, -5654, -1, "HY000", "signed year precludes use of BC/AD", 1819, "signed year precludes use of BC/AD");
DEFINE_ORACLE_ERROR(OB_ERR_JULIAN_DATE_PRECLUDES_USE_OF_DAY_OF_YEAR, -5655, -1, "HY000", "Julian date precludes use of day of year", 1811, "Julian date precludes use of day of year");
DEFINE_ORACLE_ERROR(OB_ERR_YEAR_MAY_ONLY_BE_SPECIFIED_ONCE, -5656, -1, "HY000", "year may only be specified once", 1812, "year may only be specified once");
DEFINE_ORACLE_ERROR(OB_ERR_HOUR_MAY_ONLY_BE_SPECIFIED_ONCE, -5657, -1, "HY000", "hour may only be specified once", 1813, "hour may only be specified once");
DEFINE_ORACLE_ERROR(OB_ERR_AM_PM_CONFLICTS_WITH_USE_OF_AM_DOT_PM_DOT, -5658, -1, "HY000", "AM/PM conflicts with use of A.M./P.M.", 1814, "AM/PM conflicts with use of A.M./P.M.");
DEFINE_ORACLE_ERROR(OB_ERR_BC_AD_CONFLICT_WITH_USE_OF_BC_DOT_AD_DOT, -5659, -1, "HY000", "BC/AD conflicts with use of B.C./A.D.", 1815, "BC/AD conflicts with use of B.C./A.D.");
DEFINE_ORACLE_ERROR(OB_ERR_MONTH_MAY_ONLY_BE_SPECIFIED_ONCE, -5660, -1, "HY000", "month may only be specified once", 1816, "month may only be specified once");
DEFINE_ORACLE_ERROR(OB_ERR_DAY_OF_WEEK_MAY_ONLY_BE_SPECIFIED_ONCE, -5661, -1, "HY000", "day of week may only be specified once", 1817, "day of week may only be specified once");
DEFINE_ORACLE_ERROR(OB_ERR_FORMAT_CODE_CANNOT_APPEAR, -5662, -1, "HY000", "format code cannot appear in date input format", 1820, "format code cannot appear in date input format");
DEFINE_ORACLE_ERROR(OB_ERR_NON_NUMERIC_CHARACTER_VALUE, -5663, -1, "HY000", "a non-numeric character was found where a numeric was expected", 1858, "a non-numeric character was found where a numeric was expected");
DEFINE_ORACLE_ERROR(OB_INVALID_MERIDIAN_INDICATOR_USE, -5664, -1, "HY000", "'HH24' precludes use of meridian indicator", 1818, "'HH24' precludes use of meridian indicator");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_CHAR_FOLLOWING_ESCAPE_CHAR, -5665, -1, "HY000", "missing or illegal character following the escape character", 1424, "missing or illegal character following the escape character");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_ESCAPE_CHAR_LENGTH, -5666, -1, "HY000", "escape character must be character string of length 1", 1425, "escape character must be character string of length 1");
DEFINE_ORACLE_ERROR(OB_ERR_DAY_OF_MONTH_RANGE, -5667, -1, "HY000", "day of month must be between 1 and last day of month", 1847, "day of month must be between 1 and last day of month");
DEFINE_ORACLE_ERROR(OB_ERR_NOT_SELECTED_EXPR, -5668, -1, "HY000", "not a SELECTed expression", 1791, "not a SELECTed expression");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_YEAR_VALUE, -5670, -1, "HY000", "(full) year must be between -4713 and +9999, and not be 0", 1841, "(full) year must be between -4713 and +9999, and not be 0");
DEFINE_ORACLE_ERROR(OB_ERR_UK_PK_DUPLICATE, -5671, -1, "HY000", "such unique or primary key already exists in the table", 2261, "such unique or primary key already exists in the table");
DEFINE_ORACLE_ERROR(OB_ERR_COLUMN_LIST_ALREADY_INDEXED, -5672, -1, "HY000", "such column list already indexed", 1408, "such column list already indexed");
DEFINE_ERROR(OB_ERR_BUSHY_TREE_NOT_SUPPORTED, -5673, -1, "HY000", "PX does not support processing a bushy tree");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_ARGUMENT_OUT_OF_RANGE, -5674, -1, "HY000", "argument is out of range", "argument '%ld' is out of range", 1428, "argument is out of range", "argument '%ld' is out of range");
DEFINE_ORACLE_ERROR(OB_ERR_ORDER_BY_ITEM_NOT_IN_SELECT_LIST, -5675, -1, "HY000", "ORDER BY item must be the number of a SELECT-list expression", 1785, "ORDER BY item must be the number of a SELECT-list expression");
DEFINE_ORACLE_ERROR(OB_ERR_INTERVAL_INVALID, -5676, -1, "HY000", "the interval is invalid", 1867, "the interval is invalid");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_NUMERIC_OR_VALUE_ERROR, -5677, -1, "HY000", "PL/SQL: numeric or value error", "PL/SQL: numeric or value error: %.*s", 6502, "PL/SQL: numeric or value error", "PL/SQL: numeric or value error: %.*s");
DEFINE_ORACLE_ERROR(OB_ERR_CONSTRAINT_NAME_DUPLICATE, -5678, -1, "HY000", "name already used by an existing constraint", 2264, "name already used by an existing constraint");
DEFINE_ORACLE_ERROR(OB_ERR_ONLY_HAVE_INVISIBLE_COL_IN_TABLE, -5679, -1, "HY000", "table must have at least one column that is not invisible", 54039, "table must have at least one column that is not invisible");
DEFINE_ORACLE_ERROR(OB_ERR_INVISIBLE_COL_ON_UNSUPPORTED_TABLE_TYPE, -5680, -1, "HY000", "Invisible column is not supported on this type of table.", 54042, "Invisible column is not supported on this type of table.");
DEFINE_ORACLE_ERROR(OB_ERR_MODIFY_COL_VISIBILITY_COMBINED_WITH_OTHER_OPTION, -5681, -1, "HY000", "Column visibility modifications cannot be combined with any other modified column DDL option.", 54046, "Column visibility modifications cannot be combined with any other modified column DDL option.");
DEFINE_ORACLE_ERROR(OB_ERR_MODIFY_COL_VISIBILITY_BY_SYS_USER, -5682, -1, "HY000", "The visibility of a column from a table owned by a SYS user cannot be changed.", 54053, "The visibility of a column from a table owned by a SYS user cannot be changed.");
DEFINE_ORACLE_ERROR(OB_ERR_TOO_MANY_ARGS_FOR_FUN, -5683, -1, "HY000", "too many arguments for function", 939, "too many arguments for function");
DEFINE_ERROR(OB_PX_SQL_NEED_RETRY, -5684, -1, "HY000", "PX sql need retry");
DEFINE_ERROR_EXT(OB_TENANT_HAS_BEEN_DROPPED, -5685, -1, "HY000", "tenant has been dropped", "Tenant '%.*s' has been dropped");
DEFINE_ORACLE_ERROR(OB_ERR_EXTRACT_FIELD_INVALID, -5686, -1, "HY000", "invalid extract field for extract source", 30076, "invalid extract field for extract source");
DEFINE_ERROR_EXT(OB_ERR_PACKAGE_COMPILE_ERROR, -5687, -1, "42000", "package compile error", "%s \'%.*s.%.*s\' compile error");
DEFINE_ERROR(OB_ERR_SP_EMPTY_BLOCK, -5688, -1, "42000", "Empty block prohibited in Oracle");
DEFINE_ERROR(OB_ARRAY_BINDING_ROLLBACK, -5689, -1, "HY000", "array binding need rollback");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_SUBQUERY_USE, -5690, -1, "HY000", "subquery not allowed here", 2251, "subquery not allowed here");
DEFINE_ORACLE_ERROR(OB_ERR_DATE_OR_SYS_VAR_CANNOT_IN_CHECK_CST, -5691, -1, "HY000", "date or system variable wrongly specified in CHECK constraint", 2436, "date or system variable wrongly specified in CHECK constraint");
DEFINE_ORACLE_ERROR(OB_ERR_NONEXISTENT_CONSTRAINT, -5692, -1, "HY000", "Cannot drop constraint  - nonexistent constraint", 2443, "Cannot drop constraint  - nonexistent constraint");
DEFINE_ORACLE_ERROR(OB_ERR_CHECK_CONSTRAINT_VIOLATED, -5693, -1, "HY000", "check constraint violated", 2290, "check constraint violated");
DEFINE_ORACLE_ERROR(OB_ERR_GROUP_FUNC_NOT_ALLOWED, -5694, -1, "HY000", "group function is not allowed here", 934, "group function is not allowed here");
DEFINE_ORACLE_ERROR(OB_ERR_POLICY_STRING_NOT_FOUND, -5695, -1, "HY000", "policy string not found", 12416, "policy string not found");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_LABEL_STRING, -5696, -1, "HY000", "invalid label string", 12401, "invalid label string");
DEFINE_ORACLE_ERROR(OB_ERR_UNDEFINED_COMPARTMENT_STRING_FOR_POLICY_STRING, -5697, -1, "HY000", "undefined compartment string for policy string", 12462, "undefined compartment string for policy string");
DEFINE_ORACLE_ERROR(OB_ERR_UNDEFINED_LEVEL_STRING_FOR_POLICY_STRING, -5698, -1, "HY000", "undefined level string for policy string", 12461, "undefined level string for policy string");
DEFINE_ORACLE_ERROR(OB_ERR_UNDEFINED_GROUP_STRING_FOR_POLICY_STRING, -5699, -1, "HY000", "undefined group string for policy string", 12463, "undefined group string for policy string");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_LBAC_ERROR, -5700, -1, "HY000", "LBAC error", "LBAC error: %s", 12432, "LBAC error", "LBAC error: %s");
DEFINE_ORACLE_ERROR(OB_ERR_POLICY_ROLE_ALREADY_EXISTS_FOR_POLICY_STRING, -5701, -1, "HY000", "policy role already exists for policy string", 12447, "policy role already exists for policy string");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_NULL_OR_INVALID_USER_LABEL, -5702, -1, "HY000", "NULL or invalid user label", "NULL or invalid user label: %s", 12470, "NULL or invalid user label", "NULL or invalid user label: %s");
DEFINE_ERROR(OB_ERR_ADD_INDEX, -5703, -1, "HY000", "Add index failed");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_PROFILE_STRING_DOES_NOT_EXIST, -5704, -1, "HY000", "profile string does not exist", "profile %.*s does not exist", 2380, "profile string does not exist", "profile %.*s does not exist");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_INVALID_RESOURCE_LIMIT, -5705, -1, "HY000", "invalid resource limit", "invalid resource limit %s", 2377, "invalid resource limit", "invalid resource limit %s");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_PROFILE_STRING_ALREADY_EXISTS, -5706, -1, "HY000", "profile string already exists", "profile %.*s already exists", 2379, "profile string already exists", "profile %.*s already exists");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_PROFILE_STRING_HAS_USERS_ASSIGNED, -5707, -1, "HY000", "profile string has users assigned, cannot drop without CASCADE", "profile %.*s has users assigned, cannot drop without CASCADE", 2382, "profile string has users assigned, cannot drop without CASCADE", "profile %.*s has users assigned, cannot drop without CASCADE");
DEFINE_ORACLE_ERROR(OB_ERR_THE_LEADING_PRECISION_OF_THE_INTERVAL_IS_TOO_SMALL, -5708, -1, "HY000", "the leading precision of the interval is too small", 1873, "the leading precision of the interval is too small");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_TIME_ZONE_HOUR, -5709, -1, "HY000", "time zone hour must be between -12 and 14", 1874, "time zone hour must be between -15 and 15");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_TIME_ZONE_MINUTE, -5710, -1, "HY000", "time zone minute must be between -59 and 59", 1875, "time zone minute must be between -59 and 59");
DEFINE_ORACLE_ERROR(OB_ERR_NOT_A_VALID_TIME_ZONE, -5711, -1, "HY000", "not a valid time zone", 1857, "not a valid time zone");
DEFINE_ORACLE_ERROR(OB_ERR_DATE_FORMAT_IS_TOO_LONG_FOR_INTERNAL_BUFFER, -5712, -1, "HY000", "date format is too long for internal buffer", 1801, "date format is too long for internal buffer");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_ADD_CHECK_CONSTRAINT_VIOLATED, -5713, -1, "HY000", "cannot validate - check constraint violated", "cannot validate (%.*s.%.*s) - check constraint violated", 2293, "cannot validate - check constraint violated", "cannot validate (%.*s.%.*s) - check constraint violated");
DEFINE_ORACLE_ERROR(OB_ERR_ILLEGAL_VIEW_UPDATE, -5714, -1, "HY000", "data manipulation operation not legal on this view", 1732, "data manipulation operation not legal on this view");
DEFINE_ORACLE_ERROR(OB_ERR_VIRTUAL_COL_NOT_ALLOWED, -5715, -1, "HY000", "virtual column not allowed here", 1733, "virtual column not allowed here");
DEFINE_ORACLE_ERROR(OB_ERR_O_VIEW_MULTIUPDATE, -5716, -1, "HY000", "cannot modify more than one base table through a join view", 1776, "cannot modify more than one base table through a join view");
DEFINE_ERROR_EXT(OB_ERR_NON_INSERTABLE_TABLE, -5717, ER_NON_INSERTABLE_TABLE, "HY000", "The target table is not insertable", "The target table %.*s of the INSERT is not insertable-into");
DEFINE_ERROR_EXT(OB_ERR_VIEW_MULTIUPDATE, -5718, ER_VIEW_MULTIUPDATE, "HY000", "Can not modify more than one base table through a join view", "Can not modify more than one base table through a join view '%.*s.%.*s'");
DEFINE_ERROR_EXT(OB_ERR_NONUPDATEABLE_COLUMN, -5719, ER_NONUPDATEABLE_COLUMN, "HY000", "Column is not updatable", "Column '%.*s' is not updatable");
DEFINE_ERROR_EXT(OB_ERR_VIEW_DELETE_MERGE_VIEW, -5720, ER_VIEW_DELETE_MERGE_VIEW, "HY000", "Can not delete from join view", "Can not delete from join view '%.*s.%.*s'");
DEFINE_ORACLE_ERROR(OB_ERR_O_DELETE_VIEW_NON_KEY_PRESERVED, -5721, -1, "HY000", "cannot delete from view without exactly one key-preserved table", 1752, "cannot delete from view without exactly one key-preserved table");
DEFINE_ORACLE_ERROR(OB_ERR_O_UPDATE_VIEW_NON_KEY_PRESERVED, -5722, -1, "HY000", "cannot modify a column which maps to a non key-preserved table", 1779, "cannot modify a column which maps to a non key-preserved table");
DEFINE_ORACLE_ERROR(OB_ERR_MODIFY_READ_ONLY_VIEW, -5723, -1, "HY000", "cannot perform a DML operation on a read-only view", 42399, "cannot perform a DML operation on a read-only view");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_INITRANS_VALUE, -5724, -1, "HY000", "invalid INITRANS option value", 2207, "invalid INITRANS option value");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_MAXTRANS_VALUE, -5725, -1, "HY000", "invalid MAXTRANS option value", 2209, "invalid MAXTRANS option value");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_PCTFREE_OR_PCTUSED_VALUE, -5726, -1, "HY000", "invalid value for PCTFREE or PCTUSED", 2211, "invalid value for PCTFREE or PCTUSED");
DEFINE_ERROR(OB_ERR_PROXY_REROUTE, -5727, -1, "HY000", "SQL request should be rerouted");
DEFINE_ORACLE_ERROR(OB_ERR_ILLEGAL_ARGUMENT_FOR_FUNCTION, -5728, -1, "HY000", "illegal argument for function", 1760, "illegal argument for function");
DEFINE_ORACLE_ERROR(OB_ERR_OPERATOR_CANNOT_BE_USED_WITH_LIST, -5729, -1, "HY000", "this operator cannot be used with lists", 1796, "this operator cannot be used with lists");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_SAMPLING_RANGE, -5730, -1, "HY000", "SAMPLE percentage must be in the range [0.000001,100)", 30562, "SAMPLE percentage must be in the range [0.000001,100)");
DEFINE_ORACLE_ERROR(OB_ERR_SPECIFY_DATABASE_NOT_ALLOWED, -5731, -1, "HY000", "specifying owner's name of the table is not allowed", 1765, "specifying owner's name of the table is not allowed");
// OB_ERR_NOT_ENOUGH_ARGS_FOR_FUN changed to -5774
//DEFINE_ORACLE_ERROR(OB_ERR_NOT_ENOUGH_ARGS_FOR_FUN, -5732, -1, "HY000", "not enough arguments for function", 938, "not enough arguments for function");
DEFINE_ORACLE_ERROR(OB_ERR_STMT_TRIGGER_WITH_WHEN_CLAUSE, -5732, -1, "HY000", "stmt trigger with when clause", 4077, "stmt trigger with when clause");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_TRIGGER_NOT_EXIST, -5733, -1, "HY000", "trigger does not exist", "trigger '%.*s' does not exist", 4080, "trigger not exist", "trigger '%.*s' does not exist");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_TRIGGER_ALREADY_EXIST, -5734, -1, "HY000", "trigger already exist", "trigger '%.*s' already exist", 4081, "trigger already exist", "trigger '%.*s' already exist");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_TRIGGER_EXIST_ON_OTHER_TABLE, -5735, -1, "HY000", "trigger already exists on another table, cannot replace it", "trigger '%.*s' already exists on another table, cannot replace it", 4095, "trigger already exists on another table, cannot replace it", "trigger '%.*s' already exists on another table, cannot replace it");
DEFINE_ORACLE_ERROR(OB_ERR_SIGNALED_IN_PARALLEL_QUERY_SERVER, -5736, -1, "HY000", "error signaled in parallel query server", 12801, "error signaled in parallel query server");

////////////////////////////////////////////////////////////////
// !!! subquery factoring (CTE, with clause) error code
////////////////////////////////////////////////////////////////
DEFINE_ORACLE_ERROR(OB_ERR_CTE_ILLEGAL_QUERY_NAME, -5737, -1, "HY000", "illegal reference of a query name in WITH clause", 32031, "illegal reference of a query name in WITH clause");
DEFINE_ORACLE_ERROR(OB_ERR_CTE_UNSUPPORTED_COLUMN_ALIASING, -5738, -1, "HY000", "unsupported column aliasing", 32033, "unsupported column aliasing");
DEFINE_ORACLE_ERROR(OB_ERR_UNSUPPORTED_USE_OF_CTE, -5739, -1, "HY000", "unsupported use of WITH clause", 32034, "unsupported use of WITH clause");
DEFINE_ORACLE_ERROR(OB_ERR_CTE_COLUMN_NUMBER_NOT_MATCH, -5740, -1, "HY000", "number of WITH clause column names does not match number of elements in select list", 32038, "number of WITH clause column names does not match number of elements in select list");
DEFINE_ORACLE_ERROR(OB_ERR_NEED_COLUMN_ALIAS_LIST_IN_RECURSIVE_CTE, -5741, -1, "HY000", "recursive WITH clause must have column alias list", 32039, "recursive WITH clause must have column alias list");
DEFINE_ORACLE_ERROR(OB_ERR_NEED_UNION_ALL_IN_RECURSIVE_CTE, -5742, -1, "HY000", "recursive WITH clause must use a UNION ALL operation", 32040, "recursive WITH clause must use a UNION ALL operation");
DEFINE_ORACLE_ERROR(OB_ERR_NEED_ONLY_TWO_BRANCH_IN_RECURSIVE_CTE, -5743, -1, "HY000", "UNION ALL operation in recursive WITH clause must have only two branches", 32041, "UNION ALL operation in recursive WITH clause must have only two branches");
DEFINE_ORACLE_ERROR(OB_ERR_NEED_REFERENCE_ITSELF_DIRECTLY_IN_RECURSIVE_CTE, -5744, -1, "HY000", "recursive WITH clause must reference itself directly in one of the UNION ALL branches", 32042, "recursive WITH clause must reference itself directly in one of the UNION ALL branches");
DEFINE_ORACLE_ERROR(OB_ERR_NEED_INIT_BRANCH_IN_RECURSIVE_CTE, -5745, -1, "HY000", "recursive WITH clause needs an initialization branch", 32043, "recursive WITH clause needs an initialization branch");
DEFINE_ORACLE_ERROR(OB_ERR_CYCLE_FOUND_IN_RECURSIVE_CTE, -5746, -1, "HY000", "cycle detected while executing recursive WITH query", 32044, "cycle detected while executing recursive WITH query");
DEFINE_ORACLE_ERROR(OB_ERR_CTE_REACH_MAX_LEVEL_RECURSION, -5747, -1, "HY000", "maximum level of recursion reached while executing recursive WITH query", 32045, "maximum level of recursion reached while executing recursive WITH query");
DEFINE_ORACLE_ERROR(OB_ERR_CTE_ILLEGAL_SEARCH_PSEUDO_NAME, -5748, -1, "HY000", "sequence column name for SEARCH clause must not be part of the column alias list", 32046, "sequence column name for SEARCH clause must not be part of the column alias list");
DEFINE_ORACLE_ERROR(OB_ERR_CTE_ILLEGAL_CYCLE_NON_CYCLE_VALUE, -5749, -1, "HY000", "cycle mark value and non-cycle mark value must be one byte character string values", 32047, "cycle mark value and non-cycle mark value must be one byte character string values");
DEFINE_ORACLE_ERROR(OB_ERR_CTE_ILLEGAL_CYCLE_PSEUDO_NAME, -5750, -1, "HY000", "cycle mark column name for CYCLE clause must not be part of the column alias list", 32048, "cycle mark column name for CYCLE clause must not be part of the column alias list");
DEFINE_ORACLE_ERROR(OB_ERR_CTE_COLUMN_ALIAS_DUPLICATE, -5751, -1, "HY000", "duplicate name found in column alias list for WITH clause", 32049, "duplicate name found in column alias list for WITH clause");
DEFINE_ORACLE_ERROR(OB_ERR_CTE_ILLEGAL_SEARCH_CYCLE_CLAUSE, -5752, -1, "HY000", "SEARCH and CYCLE clauses can only be specified for recursive WITH clause elements", 32480, "SEARCH and CYCLE clauses can only be specified for recursive WITH clause elements");
DEFINE_ORACLE_ERROR(OB_ERR_CTE_DUPLICATE_CYCLE_NON_CYCLE_VALUE, -5753, -1, "HY000", "cycle value for CYCLE clause must be different from the non-cycle value", 32481, "cycle value for CYCLE clause must be different from the non-cycle value");
DEFINE_ORACLE_ERROR(OB_ERR_CTE_DUPLICATE_SEQ_NAME_CYCLE_COLUMN, -5754, -1, "HY000", "sequence column for SEARCH clause must be different from the cycle mark column for CYCLE clause", 32482, "sequence column for SEARCH clause must be different from the cycle mark column for CYCLE clause");
DEFINE_ORACLE_ERROR(OB_ERR_CTE_DUPLICATE_NAME_IN_SEARCH_CLAUSE, -5755, -1, "HY000", "duplicate name found in sort specification list for SEARCH clause of WITH clause", 32483, "duplicate name found in sort specification list for SEARCH clause of WITH clause");
DEFINE_ORACLE_ERROR(OB_ERR_CTE_DUPLICATE_NAME_IN_CYCLE_CLAUSE, -5756, -1, "HY000", "duplicate name found in cycle column list for CYCLE clause of WITH clause", 32484, "duplicate name found in cycle column list for CYCLE clause of WITH clause");
DEFINE_ORACLE_ERROR(OB_ERR_CTE_ILLEGAL_COLUMN_IN_CYCLE_CLAUSE, -5757, -1, "HY000", "element in cycle column list of CYCLE clause must appear in the column alias list of the WITH clause element", 32485, "element in cycle column list of CYCLE clause must appear in the column alias list of the WITH clause element");
DEFINE_ORACLE_ERROR(OB_ERR_CTE_ILLEGAL_RECURSIVE_BRANCH, -5758, -1, "HY000", "unsupported operation in recursive branch of recursive WITH clause", 32486, "unsupported operation in recursive branch of recursive WITH clause");
DEFINE_ORACLE_ERROR(OB_ERR_ILLEGAL_JOIN_IN_RECURSIVE_CTE, -5759, -1, "HY000", "unsupported join in recursive WITH query", 32487, "unsupported join in recursive WITH query");
DEFINE_ORACLE_ERROR(OB_ERR_CTE_NEED_COLUMN_ALIAS_LIST, -5760, -1, "HY000", "WITH clause element did not have a column alias list", 32488, "WITH clause element did not have a column alias list");
DEFINE_ORACLE_ERROR(OB_ERR_CTE_ILLEGAL_COLUMN_IN_SERACH_CALUSE, -5761, -1, "HY000", "element in sort specification list of SEARCH clause did not appear in the column alias list of the WITH clause element", 32489, "element in sort specification list of SEARCH clause did not appear in the column alias list of the WITH clause element");
DEFINE_ORACLE_ERROR(OB_ERR_CTE_RECURSIVE_QUERY_NAME_REFERENCED_MORE_THAN_ONCE, -5762, -1, "HY000", "recursive query name referenced more than once in recursive branch of recursive WITH clause element", 32490, "recursive query name referenced more than once in recursive branch of recursive WITH clause element");

////////////////////////////////////////////////////////////////
// !!! subquery factoring (connect by) error code
////////////////////////////////////////////////////////////////
DEFINE_ORACLE_ERROR(OB_ERR_CBY_PSEUDO_COLUMN_NOT_ALLOWED, -5763, -1, "HY000", "Specified pseudo column or operator not allowed here", 976, "Specified pseudo column or operator not allowed here");
DEFINE_ORACLE_ERROR(OB_ERR_CBY_LOOP, -5764, -1, "HY000", "CONNECT BY loop in user data", 1436, "CONNECT BY loop in user data");
DEFINE_ORACLE_ERROR(OB_ERR_CBY_JOIN_NOT_ALLOWED, -5765, -1, "HY000", "cannot have join with CONNECT BY", 1437, "cannot have join with CONNECT BY");
DEFINE_ORACLE_ERROR(OB_ERR_CBY_CONNECT_BY_REQUIRED, -5766, -1, "HY000", "CONNECT BY clause required in this query block", 1788, "CONNECT BY clause required in this query block");
DEFINE_ORACLE_ERROR(OB_ERR_CBY_CONNECT_BY_PATH_NOT_ALLOWED,-5768, -1, "HY000", "SYS_CONNECT_BY_PATH function is not allowed here", 30002, "SYS_CONNECT_BY_PATH function is not allowed here");
DEFINE_ORACLE_ERROR(OB_ERR_CBY_CONNECT_BY_PATH_ILLEGAL_PARAM, -5769, -1, "HY000", "illegal parameter in SYS_CONNECT_BY_PATH function", 30003, "illegal parameter in SYS_CONNECT_BY_PATH function");
DEFINE_ORACLE_ERROR(OB_ERR_CBY_CONNECT_BY_PATH_INVALID_SEPARATOR, -5770, -1, "HY000", "A column value contained the string that the SYS_CONNECT_BY_PATH function was to use to separate column values", 30004, "A column value contained the string that the SYS_CONNECT_BY_PATH function was to use to separate column values.");
DEFINE_ORACLE_ERROR(OB_ERR_CBY_CONNECT_BY_ROOT_ILLEGAL_USED, -5771, -1, "HY000", "CONNECT BY ROOT operator is not supported in the START WITH or in the CONNECT BY condition", 30007, "CONNECT BY ROOT operator is not supported in the START WITH or in the CONNECT BY condition");
DEFINE_ORACLE_ERROR(OB_ERR_CBY_OREDER_SIBLINGS_BY_NOT_ALLOWED, -5772, -1, "HY000", "ORDER SIBLINGS BY clause not allowed here", 30929, "ORDER SIBLINGS BY clause not allowed here");
DEFINE_ORACLE_ERROR(OB_ERR_CBY_NOCYCLE_REQUIRED, -5773, -1, "HY000", "NOCYCLE keyword is required with CONNECT_BY_ISCYCLE pseudo column", 30930, "NOCYCLE keyword is required with CONNECT_BY_ISCYCLE pseudo column");
DEFINE_ORACLE_ERROR(OB_ERR_NOT_ENOUGH_ARGS_FOR_FUN, -5774, -1, "HY000", "not enough arguments for function", 938, "not enough arguments for function");
DEFINE_ORACLE_ERROR(OB_ERR_PREPARE_STMT_CHECKSUM, -5777, -1, "HY000", "Prepare statement checksum error", 603, "Oracle Server session terminated by fatal error");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_ENABLE_NONEXISTENT_CONSTRAINT, -5778, -1, "HY000", "cannot enable constraint - no such constraint", "cannot enable constraint (%.*s) - no such constraint", 2430, "cannot enable constraint - no such constraint", "cannot enable constraint (%.*s) - no such constraint");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_DISABLE_NONEXISTENT_CONSTRAINT, -5779, -1, "HY000", "cannot disable constraint - no such constraint", "cannot disable constraint (%.*s) - no such constraint", 2431, "cannot disable constraint - no such constraint", "cannot disable constraint (%.*s) - no such constraint");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_DOWNGRADE_DOP, -5780, -1, "HY000", "PX DOP downgrade", "PX DOP downgrade from %ld to %ld", 0, "PX DOP downgrade", "PX DOP downgrade from %ld to %ld");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_DOWNGRADE_PARALLEL_MAX_SERVERS, -5781, -1, "HY000", "parallel_max_servers downgrade due to insufficent cpu resource", "parallel_max_servers downgrade due to insufficent cpu resource from %ld to %ld", 0, "parallel_max_servers downgrade due to insufficent cpu resource", "parallel_max_servers downgrade due to insufficent cpu resource from %ld to %ld");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_ORPHANED_CHILD_RECORD_EXISTS, -5785, -1, "HY000", "cannot validate - parent keys not found", "cannot validate (%.*s.%.*s) - parent keys not found", 2298, "cannot validate - parent keys not found", "cannot validate (%.*s.%.*s) - parent keys not found");
DEFINE_ORACLE_ERROR(OB_ERR_COL_CHECK_CST_REFER_ANOTHER_COL, -5786, -1, "HY000", "Column check constraint cannot reference other columns", 2438, "Column check constraint cannot reference other columns");
DEFINE_ERROR(OB_BATCHED_MULTI_STMT_ROLLBACK, -5787, -1, "HY000", "batched multi statement execution needs rollback");
DEFINE_ORACLE_ERROR(OB_ERR_FOR_UPDATE_SELECT_VIEW_CANNOT, -5788, -1, "HY000", "cannot select FOR UPDATE from view with DISTINCT, GROUP BY, etc.", 2014, "cannot select FOR UPDATE from view with DISTINCT, GROUP BY, etc.");
DEFINE_ORACLE_ERROR(OB_ERR_POLICY_WITH_CHECK_OPTION_VIOLATION, -5789, -1, "HY000", "policy with check option violation", 28115, "policy with check option violation");
DEFINE_ORACLE_ERROR(OB_ERR_POLICY_ALREADY_APPLIED_TO_TABLE, -5790, -1, "HY000", "policy already applied to table", 12444, "policy already applied to table");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_MUTATING_TABLE_OPERATION, -5791, -1, "HY000", "table is mutating, trigger/function may not see it", "table '%.*s'.'%.*s' is mutating, trigger/function may not see it", 4091, "table is mutating, trigger/function may not see it", "table '%.*s'.'%.*s' is mutating, trigger/function may not see it");
DEFINE_ORACLE_ERROR(OB_ERR_MODIFY_OR_DROP_MULTI_COLUMN_CONSTRAINT, -5792, -1, "HY000", "column is referenced in a multi-column constraint", 12991, "column is referenced in a multi-column constraint");
DEFINE_ORACLE_ERROR(OB_ERR_DROP_PARENT_KEY_COLUMN, -5793, -1, "HY000", "cannot drop parent key column", 12992, "cannot drop parent key column");
DEFINE_ORACLE_ERROR(OB_AUTOINC_SERVICE_BUSY, -5794, -1, "HY000", "auto increment service busy", 600, "auto increment service busy");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_CONSTRAINT_CONSTRAINT_DISABLE_VALIDATE, -5795, -1, "HY000", "No insert/update/delete on table with constraint disabled and validated", "No insert/update/delete on table with constraint (%.*s.%.*s) disabled and validated", 25128, "No insert/update/delete on table with constraint disabled and validated", "No insert/update/delete on table with constraint (%.*s.%.*s) disabled and validated");
DEFINE_ORACLE_ERROR(OB_ERR_AUTONOMOUS_TRANSACTION_ROLLBACK, -5796, -1, "HY000", "active autonomous transaction detected and rolled back", 6519, "active autonomous transaction detected and rolled back");
DEFINE_ORACLE_ERROR(OB_ORDERBY_CLAUSE_NOT_ALLOWED, -5797, -1, "HY000", "ORDER BY not allowed here", 30487, "ORDER BY not allowed here");
DEFINE_ORACLE_ERROR(OB_DISTINCT_NOT_ALLOWED, -5798, -1, "HY000", "DISTINCT not allowed here", 30482, "DISTINCT not allowed here");
DEFINE_ERROR(OB_ERR_ASSIGN_USER_VARIABLE_NOT_ALLOWED, -5799, -1, "HY000", "assign user variable with := only allowed in select filed list and as root expression");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_MODIFY_NONEXISTENT_CONSTRAINT, -5800, -1, "HY000", "cannot modify constraint - no such constraint", "cannot modify constraint (%.*s) - no such constraint", 25129, "cannot modify constraint - no such constraint", "cannot modify constraint (%.*s) - no such constraint");
DEFINE_ERROR(OB_ERR_SP_EXCEPTION_HANDLE_ILLEGAL, -5801, -1, "HY000", "implementation restriction: exception handler in nested transaction is illegal");
DEFINE_ORACLE_ERROR(OB_INVALID_ROWID, -5802, -1, "HY000", "invalid ROWID", 1410, "invalid ROWID");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_INVALID_INSERT_COLUMN, -5803, -1, "HY000", "Invalid column in the INSERT VALUES Clause", "Invalid column in the INSERT VALUES Clause:'%.*s'.'%.*s'", 38101, "Invalid column in the INSERT VALUES Clause", "Invalid column in the INSERT VALUES Clause:'%.*s'.'%.*s'");
DEFINE_ORACLE_ERROR_EXT(OB_INCORRECT_USE_OF_OPERATOR, -5804, -1, "HY000", "incorrect use of operator", "incorrect use of the ['%.*s'] operator", 13207, "incorrect use of operator", "incorrect use of the ['%.*s'] operator");
DEFINE_ORACLE_ERROR(OB_ERR_NON_CONST_EXPR_IS_NOT_ALLOWED_FOR_PIVOT_UNPIVOT_VALUES, -5805, -1, "HY000", "non-constant expression is not allowed for pivot|unpivot values", 56901, "non-constant expression is not allowed for pivot|unpivot values");
DEFINE_ORACLE_ERROR(OB_ERR_EXPECT_AGGREGATE_FUNCTION_INSIDE_PIVOT_OPERATION, -5806, -1, "HY000", "expect aggregate function inside pivot operation", 56902, "expect aggregate function inside pivot operation");
DEFINE_ORACLE_ERROR(OB_ERR_EXP_NEED_SAME_DATATYPE, -5807, -1, "HY000", "expression must have same datatype as corresponding expression", 1790, "expression must have same datatype as corresponding expression");
DEFINE_ORACLE_ERROR(OB_ERR_CHARACTER_SET_MISMATCH, -5808, -1, "HY000", "character set mismatch", 12704, "character set mismatch");
DEFINE_ERROR(OB_ERR_REGEXP_NOMATCH, -5809, -1, "HY000", "regular expression failed to match");
DEFINE_ERROR(OB_ERR_REGEXP_BADPAT, -5810, -1, "HY000", "invalid regular expression (reg version 0.8)");
DEFINE_ERROR(OB_ERR_REGEXP_EESCAPE, -5811, -1, "HY000", "invalid escape \\ sequence in regular expression");
DEFINE_ORACLE_ERROR(OB_ERR_REGEXP_EBRACK, -5812, -1, "HY000", "unmatched bracket in regular expression", 12726, "unmatched bracket in regular expression");
DEFINE_ORACLE_ERROR(OB_ERR_REGEXP_EPAREN, -5813, -1, "HY000", "unmatched parentheses in regular expression", 12725, "unmatched parentheses in regular expression");
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_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");
DEFINE_ERROR(OB_ERR_REGEXP_ASSERT, -5821, -1, "HY000", "regular expression internal error");
DEFINE_ERROR(OB_ERR_REGEXP_INVARG, -5822, -1, "HY000", "invalid argument in regular expression");
DEFINE_ERROR(OB_ERR_REGEXP_MIXED, -5823, -1, "HY000", "character widths of regex and string differ in regular expression");
DEFINE_ERROR(OB_ERR_REGEXP_BADOPT, -5824, -1, "HY000", "invalid embedded option in regular expression");
DEFINE_ERROR(OB_ERR_REGEXP_ETOOBIG, -5825, -1, "HY000", "nfa has too many states in regular expression, may be the regular expression too long");
DEFINE_ERROR(OB_NOT_SUPPORTED_ROWID_TYPE, -5826, -1, "HY000", "ROWID for tables without primary key is not implemented");
DEFINE_ERROR(OB_ERR_PARALLEL_DDL_CONFLICT, -5827, -1, "HY000", "the definition of relative objects have been modified, please check and retry");
DEFINE_ORACLE_ERROR(OB_ERR_SUBSCRIPT_BEYOND_COUNT, -5828, -1, "HY000", "Subscript beyond count", 6533, "Subscript beyond count");
DEFINE_ORACLE_ERROR(OB_ERR_NOT_PARTITIONED, -5829, -1, "HY000", "PARTITION () clause on non partitioned table", 14501, "object is not partitioned");
DEFINE_ORACLE_ERROR(OB_UNKNOWN_SUBPARTITION, -5830, -1, "HY000", "Unknown subpartition", 14251, "Specified subpartition does not exist");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_SQL_ROW_LIMITING, -5831, -1, "HY000", "Invalid SQL ROW LIMITING expression was specified.", 62550, "Invalid SQL ROW LIMITING expression was specified.");
DEFINE_ERROR(INCORRECT_ARGUMENTS_TO_ESCAPE, -5832, -1210, "HY000", "Incorrect arguments to ESCAPE");
DEFINE_ERROR(STATIC_ENG_NOT_IMPLEMENT, -5833, -1,  "HY000", "not implemented in SQL static typing engine, will try the old engine automatically");
DEFINE_ORACLE_ERROR(OB_OBJ_ALREADY_EXIST, -5834, -1, "HY000", "name is already used by an existing object", 955, "name is already used by an existing object");
DEFINE_ORACLE_ERROR(OB_DBLINK_NOT_EXIST_TO_ACCESS, -5835, -1, "HY000", "connection description for remote database not found", 2019, "connection description for remote database not found");
DEFINE_ORACLE_ERROR(OB_DBLINK_NOT_EXIST_TO_DROP, -5836, -1, "HY000", "database link not found", 2024, "database link not found");
DEFINE_ORACLE_ERROR(OB_ERR_ACCESS_INTO_NULL, -5837, -1, "HY000", "Reference to uninitialized composite", 6530, "Reference to uninitialized composite");
DEFINE_ORACLE_ERROR(OB_ERR_COLLECION_NULL, -5838, -1, "HY000", "Reference to uninitialized collection", 6531, "Reference to uninitialized collection");
DEFINE_ORACLE_ERROR(OB_ERR_NO_DATA_NEEDED, -5839, -1, "HY000", "no more rows needed", 6548, "no more rows needed");
DEFINE_ORACLE_ERROR(OB_ERR_PROGRAM_ERROR, -5840, -1, "HY000", "PL/SQL: program error", 6501, "PL/SQL: program error");
DEFINE_ORACLE_ERROR(OB_ERR_ROWTYPE_MISMATCH, -5841, -1, "HY000", "PL/SQL: Return types of Result Set variables or query do not match", 6504, "PL/SQL: Return types of Result Set variables or query do not match");
DEFINE_ORACLE_ERROR(OB_ERR_STORAGE_ERROR, -5842, -1, "HY000", "PL/SQL: storage error", 6500, "PL/SQL: storage error");
DEFINE_ORACLE_ERROR(OB_ERR_SUBSCRIPT_OUTSIDE_LIMIT, -5843, -1, "HY000", "Subscript outside of limit", 6532, "Subscript outside of limit");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_CURSOR, -5844, -1, "HY000", "invalid cursor", 1001, "invalid cursor");
DEFINE_ORACLE_ERROR(OB_ERR_LOGIN_DENIED, -5845, -1, "HY000", "invalid username/password; logon denied", 1017, "invalid username/password; logon deniedd");
DEFINE_ORACLE_ERROR(OB_ERR_NOT_LOGGED_ON, -5846, -1, "HY000", "not logged on", 1012, "not logged on");
DEFINE_ORACLE_ERROR(OB_ERR_SELF_IS_NULL, -5847, -1, "HY000", "method dispatch on NULL SELF argument is disallowed", 30625, "method dispatch on NULL SELF argument is disallowed");
DEFINE_ORACLE_ERROR(OB_ERR_TIMEOUT_ON_RESOURCE, -5848, -1, "HY000", "timeout occurred while waiting for a resource", 51, "timeout occurred while waiting for a resource");
DEFINE_ORACLE_ERROR(OB_COLUMN_CANT_CHANGE_TO_NOT_NULL, -5849, -1, "HY000", "column to be modified to NOT NULL is already NOT NULL", 1442, "column to be modified to NOT NULL is already NOT NULL");
DEFINE_ORACLE_ERROR(OB_COLUMN_CANT_CHANGE_TO_NULLALE, -5850, -1, "HY000", "column to be modified to NULL cannot be modified to NULL", 1451, "column to be modified to NULL cannot be modified to NULL");
DEFINE_ORACLE_ERROR_EXT(OB_ENABLE_NOT_NULL_CONSTRAINT_VIOLATED, -5851, -1, "HY000", "cannot enable - null values found", "cannot enable (%.*s.%.*s) - null values found", 2296, "cannot enable - null values found", "cannot enable (%.*s.%.*s) - null values found");
DEFINE_ORACLE_ERROR(OB_ERR_ARGUMENT_SHOULD_CONSTANT, -5852, -1, "HY000", "Argument should be a constant.", 30496, "Argument should be a constant.");
DEFINE_ORACLE_ERROR(OB_ERR_NOT_A_SINGLE_GROUP_FUNCTION, -5853, -1, "HY000", "not a single-group group function", 937, "not a single-group group function");
DEFINE_ORACLE_ERROR(OB_ERR_ZERO_LENGTH_IDENTIFIER, -5854, -1, "HY000", "illegal zero-length identifier", 1741, "illegal zero-length identifier");
DEFINE_ORACLE_ERROR(OB_ERR_PARAM_VALUE_INVALID, -5855, -1, "HY000", "parameter cannot be modified because specified value is invalid", 2097, "parameter cannot be modified because specified value is invalid");
DEFINE_ORACLE_ERROR(OB_ERR_DBMS_SQL_CURSOR_NOT_EXIST, -5856, -1, "HY000", "DBMS_SQL access denied", 29471, "DBMS_SQL access denied");
DEFINE_ORACLE_ERROR(OB_ERR_DBMS_SQL_NOT_ALL_VAR_BIND, -5857, -1, "HY000", "not all variables bound", 1008, "not all variables bound");
DEFINE_ERROR_EXT(OB_ERR_CONFLICTING_DECLARATIONS, -5858, ER_CONFLICTING_DECLARATIONS, "42000", "Conflicting declarations", "Conflicting declarations: '%s' and '%s'");
DEFINE_ORACLE_ERROR(OB_ERR_DROP_COL_REFERENCED_MULTI_COLS_CONSTRAINT, -5859, -1, "HY000", "column is referenced in a multi-column constraint", 12991, "column is referenced in a multi-column constraint");
DEFINE_ORACLE_ERROR(OB_ERR_MODIFY_COL_DATATYEP_REFERENCED_CONSTRAINT, -5860, -1, "HY000", "cannot modify column datatype with current constraint(s)", 1463, "cannot modify column datatype with current constraint(s)");
DEFINE_ORACLE_ERROR(OB_ERR_PERCENTILE_VALUE_INVALID, -5861, -1, "HY000", "The percentile value should be a number between 0 and 1.", 30493, "The percentile value should be a number between 0 and 1.");
DEFINE_ORACLE_ERROR(OB_ERR_ARGUMENT_SHOULD_NUMERIC_DATE_DATETIME_TYPE, -5862, -1, "HY000", "The argument should be of numeric or date/datetime type.", 30495, "The argument should be of numeric or date/datetime type.");
DEFINE_ORACLE_ERROR(OB_ERR_ALTER_TABLE_RENAME_WITH_OPTION, -5863, -1, "HY000", "ALTER TABLE|INDEX RENAME may not be combined with other operations", 14047, "ALTER TABLE|INDEX RENAME may not be combined with other operations");
DEFINE_ORACLE_ERROR(OB_ERR_ONLY_SIMPLE_COLUMN_NAME_ALLOWED, -5864, -1, "HY000", "only simple column names allowed here.", 1748, "only simple column names allowed here.");
DEFINE_ERROR_EXT(OB_ERR_SAFE_UPDATE_MODE_NEED_WHERE_OR_LIMIT, -5865, ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE, "HY000", "You are using safe update mode and you tried to update a table without a WHERE that uses a KEY column", "You are using safe update mode and you tried to update a table without a WHERE that uses a KEY column");
DEFINE_ORACLE_ERROR(OB_ERR_SPECIFIY_PARTITION_DESCRIPTION, -5866, -1, "HY000", "cannot specify <(sub)partition-description> clause in CREATE TABLE or CREATE INDEX", 14170, "cannot specify <(sub)partition-description> clause in CREATE TABLE or CREATE INDEX");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_SAME_NAME_SUBPARTITION, -5867, -1, "HY000", "Duplicate partition name", "Duplicate partition name %.*s", 14159, "duplicate subpartition name", "duplicate subpartition name %.*s");
DEFINE_ERROR(OB_ERR_UPDATE_ORDER_BY, -5868, -1, "HY000", "Incorrect usage of UPDATE and ORDER BY");
DEFINE_ERROR(OB_ERR_UPDATE_LIMIT, -5869, -1, "HY000", "Incorrect usage of UPDATE and LIMIT");
DEFINE_ORACLE_ERROR_EXT(OB_ROWID_TYPE_MISMATCH, -5870, -1, "HY000", "rowid type mismatch", "rowid type mismatch, expect %.*s, got %.*s", 600, "rowid type mismatch", "rowid type mismatch, expect %s, got %s");
DEFINE_ORACLE_ERROR_EXT(OB_ROWID_NUM_MISMATCH, -5871, -1, "HY000", "rowid num mismatch", "rowid num mismatch, expect %ld, actual %ld", 600, "rowid type mismatch", "rowid type mismatch, expect %ld, actual %ld");
DEFINE_ORACLE_ERROR_EXT(OB_NO_COLUMN_ALIAS, -5872, -1, "HY000", "must name this expression with a column alias", "must name %.*s with a column alias", 998, "must name this expression with a column alias", "must name %.*s with a column alias");
DEFINE_ORACLE_ERROR(OB_ERR_NUMERIC_NOT_MATCH_FORMAT_LENGTH, -5873, -1, "HY000", "the numeric value does not match the length of the format item", 1862, "the numeric value does not match the length of the format item");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_DATATYPE, -5874, -1, "HY000", "invalid datatype", 902, "invalid datatype");
DEFINE_ORACLE_ERROR(OB_ERR_NOT_COMPOSITE_PARTITION, -5875, -1, "HY000", "table is not partitioned by composite partition method", 14253, "table is not partitioned by composite partition method");
DEFINE_ORACLE_ERROR(OB_ERR_SUBPARTITION_NOT_EXPECT_VALUES_IN, -5876, -1, "HY000", "VALUES IN (<value list>) cannot be used for Range subpartitioned tables", 14214, "VALUES (<value list>) cannot be used for Range subpartitioned tables");
DEFINE_ORACLE_ERROR(OB_ERR_SUBPARTITION_EXPECT_VALUES_IN, -5877, -1, "HY000", "VALUES IN (<value list>) clause expected", 14217, "VALUES (<value list>) clause expected");
DEFINE_ORACLE_ERROR(OB_ERR_PARTITION_NOT_EXPECT_VALUES_LESS_THAN, -5878, -1, "HY000", "VALUES LESS THAN or AT clause cannot be used with List partitioned tables", 14310, "VALUES LESS THAN or AT clause cannot be used with List partitioned tables");
DEFINE_ORACLE_ERROR(OB_ERR_PARTITION_EXPECT_VALUES_LESS_THAN, -5879, -1, "HY000", "Expecting VALUES LESS THAN or AT clause", 14311, "Expecting VALUES LESS THAN or AT clause");
DEFINE_ORACLE_ERROR(OB_ERR_PROGRAM_UNIT_NOT_EXIST, -5880, -1, "HY000", "Procedure, function, package, or package body does not exist", 4042, "procedure, function, package, or package body does not exist");
DEFINE_ERROR(OB_ERR_INVALID_RESTORE_POINT_NAME, -5881, -1, "HY000", "invalid restore point name specified in connection string");
DEFINE_ORACLE_ERROR(OB_ERR_INPUT_TIME_TYPE, -5882, -1, "HY000", "invalid time limit specified", 14312, "invalid time limit specified");
DEFINE_ORACLE_ERROR(OB_ERR_IN_ARRAY_DML, -5883, -1, "HY000", "error(s) in array DML", 24381, "error(s) in array DML");
DEFINE_ERROR_EXT(OB_ERR_TRIGGER_COMPILE_ERROR, -5884, -1, "42000", "trigger compile error", "%s \'%.*s.%.*s\' compile error");
DEFINE_ORACLE_ERROR(OB_ERR_MISSING_OR_INVALID_PASSWORD, -5887, -1, "HY000", "missing or invalid password(s)", 988, "missing or invalid password(s)");
DEFINE_ORACLE_ERROR(OB_ERR_NO_MATCHING_UK_PK_FOR_COL_LIST, -5889, -1, "HY000", "no matching unique or primary key for this column-list", 2270, "no matching unique or primary key for this column-list");
DEFINE_ORACLE_ERROR(OB_ERR_DUP_FK_IN_TABLE, -5890, -1, "HY000", "duplicate referential constraint specifications", 2774, "duplicate referential constraint specifications");
DEFINE_ORACLE_ERROR(OB_ERR_DUP_FK_EXISTS, -5891, -1, "HY000", "such a referential constraint already exists in the table", 2775, "such a referential constraint already exists in the table");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_VIRTUAL_COLUMN_TYPE, -5893, -1, "HY000", "specified data type is not supported for a virtual column", 54003, "specified data type is not supported for a virtual column");
DEFINE_ORACLE_ERROR(OB_ERR_REFERENCED_TABLE_HAS_NO_PK, -5894, -1, "HY000", "referenced table does not have a primary key", 2268, "referenced table does not have a primary key");
DEFINE_ORACLE_ERROR(OB_ERR_MODIFY_PART_COLUMN_TYPE, -5895, -1, "HY000", "data type or length of a table partitioning column may not be changed", 14060, "data type or length of a table partitioning column may not be changed");
DEFINE_ORACLE_ERROR(OB_ERR_MODIFY_SUBPART_COLUMN_TYPE, -5896, -1, "HY000", "data type or length of a table subpartitioning column may not be changed", 14265, "data type or length of a table subpartitioning column may not be changed");
DEFINE_ORACLE_ERROR(OB_ERR_DECREASE_COLUMN_LENGTH, -5897, -1, "HY000", "cannot decrease column length because some value is too big", 1441, "cannot decrease column length because some value is too big");
DEFINE_ORACLE_ERROR(OB_ERR_DATETIME_INTERVAL_INTERNAL_ERROR, -5898, -1, "HY000", "Datetime/Interval internal error", 1891, "Datetime/Interval internal error");
DEFINE_ORACLE_ERROR(OB_ERR_REMOTE_PART_ILLEGAL, -5899, -1, "HY000", "partition extended table name cannot refer to a remote object", 14100, "partition extended table name cannot refer to a remote object");

DEFINE_ORACLE_ERROR(OB_ERR_A_VIEW_NOT_APPROPRIATE_HERE, -5901, -1, "HY000", "a view is not appropriate here", 1702, "a view is not appropriate here");
DEFINE_ORACLE_ERROR(OB_ROWID_VIEW_NO_KEY_PRESERVED, -5902, -1, "HY000", "cannot select ROWID from, or sample, a join view without a key-preserved table", 1445, "cannot select ROWID from, or sample, a join view without a key-preserved table");
DEFINE_ORACLE_ERROR(OB_ROWID_VIEW_HAS_DISTINCT_ETC, -5903, -1, "HY000", "cannot select ROWID from, or sample, a view with DISTINCT, GROUP BY, etc", 1446, "cannot select ROWID from, or sample, a view with DISTINCT, GROUP BY, etc");
DEFINE_ORACLE_ERROR(OB_ERR_AT_LEAST_ONE_COLUMN_NOT_VIRTUAL, -5904, -1, "HY000", "table must have at least 1 column that is not virtual", 54037, "table must have at least 1 column that is not virtual");
DEFINE_ORACLE_ERROR(OB_ERR_ONLY_PURE_FUNC_CANBE_INDEXED, -5905, -1, "HY000", "only pure functions can be indexed", 1743, "only pure functions can be indexed");
DEFINE_ORACLE_ERROR(OB_ERR_ONLY_PURE_FUNC_CANBE_VIRTUAL_COLUMN_EXPRESSION, -5906, -1, "HY000", "Expression of generated column contains a disallowed function", 54002, "only pure functions can be specified in a virtual column expression");
DEFINE_ORACLE_ERROR(OB_ERR_UPDATE_OPERATION_ON_VIRTUAL_COLUMNS, -5907, -1, "HY000", "UPDATE operation disallowed on virtual columns", 54017, "UPDATE operation disallowed on virtual columns");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_COLUMN_EXPRESSION, -5908, -1, "HY000", "Invalid column expression was specified", 54016, "Invalid column expression was specified");
DEFINE_ORACLE_ERROR(OB_ERR_IDENTITY_COLUMN_COUNT_EXCE_LIMIT, -5909, -1, "HY000", "table can have only one identity column", 30669, "table can have only one identity column");
DEFINE_ORACLE_ERROR(OB_ERR_INVALID_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN, -5910, -1, "HY000", "invalid NOT NULL constraint specified on an identity column", 30670, "invalid NOT NULL constraint specified on an identity column");
DEFINE_ORACLE_ERROR(OB_ERR_CANNOT_MODIFY_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN, -5911, -1, "HY000", "cannot modify NOT NULL constraint on an identity column", 30671, "cannot modify NOT NULL constraint on an identity column");
DEFINE_ORACLE_ERROR(OB_ERR_CANNOT_DROP_NOT_NULL_CONSTRAINT_ON_IDENTITY_COLUMN, -5912, -1, "HY000", "cannot drop NOT NULL constraint on an identity column", 30672, "cannot drop NOT NULL constraint on an identity column");
DEFINE_ORACLE_ERROR(OB_ERR_COLUMN_MODIFY_TO_IDENTITY_COLUMN, -5913, -1, "HY000", "column to be modified is not an identity column", 30673, "column to be modified is not an identity column");
DEFINE_ORACLE_ERROR(OB_ERR_IDENTITY_COLUMN_CANNOT_HAVE_DEFAULT_VALUE, -5914, -1, "HY000", "identity column cannot have a default value", 30674, "identity column cannot have a default value");
DEFINE_ORACLE_ERROR(OB_ERR_IDENTITY_COLUMN_MUST_BE_NUMERIC_TYPE, -5915, -1, "HY000", "identity column must be a numeric type", 30675, "identity column must be a numeric type");
DEFINE_ORACLE_ERROR(OB_ERR_PREBUILT_TABLE_MANAGED_CANNOT_BE_IDENTITY_COLUMN, -5916, -1, "HY000", "prebuilt table managed column cannot be an identity column", 32792, "prebuilt table managed column cannot be an identity column");
DEFINE_ORACLE_ERROR(OB_ERR_CANNOT_ALTER_SYSTEM_GENERATED_SEQUENCE, -5917, -1, "HY000", "cannot alter a system-generated sequence", 32793, "cannot alter a system-generated sequence");
DEFINE_ORACLE_ERROR(OB_ERR_CANNOT_DROP_SYSTEM_GENERATED_SEQUENCE, -5918, -1, "HY000", "cannot drop a system-generated sequence", 32794, "cannot drop a system-generated sequence");
DEFINE_ORACLE_ERROR(OB_ERR_INSERT_INTO_GENERATED_ALWAYS_IDENTITY_COLUMN, -5919, -1, "HY000", "cannot insert into a generated always identity column", 32795, "cannot insert into a generated always identity column");
DEFINE_ORACLE_ERROR(OB_ERR_UPDATE_GENERATED_ALWAYS_IDENTITY_COLUMN, -5920, -1, "HY000", "cannot update a generated always identity column", 32796, "cannot update a generated always identity column");
DEFINE_ORACLE_ERROR(OB_ERR_IDENTITY_COLUMN_SEQUENCE_MISMATCH_ALTER_TABLE_EXCHANGE_PARTITION, -5921, -1, "HY000", "identity column sequence mismatch in ALTER TABLE EXCHANGE PARTITION", 32797, "identity column sequence mismatch in ALTER TABLE EXCHANGE PARTITION");
DEFINE_ORACLE_ERROR(OB_ERR_CANNOT_RENAME_SYSTEM_GENERATED_SEQUENCE, -5922, -1, "HY000", "cannot rename a system-generated sequence", 32798, "cannot rename a system-generated sequence");
DEFINE_ORACLE_ERROR(OB_ERR_REVOKE_BY_COLUMN, -5923, -1, "HY000", "UPDATE/REFERENCES may only be REVOKEd from the whole table, not by column", 1750, "UPDATE/REFERENCES may only be REVOKEd from the whole table, not by column");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_TYPE_BODY_NOT_EXIST, -5924, -1, "HY000", "not executed, type body does not exist", "not executed, type body '%.*s' does not exist", 4067, "not executed, type body does not exist", "not executed, type body '%.*s' does not exist");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_INVALID_ARGUMENT_FOR_WIDTH_BUCKET, -5925, -1, "HY000", "The argument of WIDTH_BUCKET function is NULL or invalid.", "The argument [%s] of WIDTH_BUCKET function is NULL or invalid.", 30494, "The argument of WIDTH_BUCKET function is NULL or invalid.", "The argument [%s] of WIDTH_BUCKET function is NULL or invalid.");
DEFINE_ORACLE_ERROR(OB_ERR_CBY_NO_MEMORY, -5926, -1, "HY000", "Not enough memory for CONNECT BY operation", 30009, "Not enough memory for CONNECT BY operation");
DEFINE_ORACLE_ERROR(OB_ERR_ILLEGAL_PARAM_FOR_CBY_PATH, -5927, -1, "HY000", "illegal parameter in SYS_CONNECT_BY_PATH function", 30003, "illegal parameter in SYS_CONNECT_BY_PATH function");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_HOST_UNKNOWN, -5928, -1, "HY000", "host unknown", "host %.*s unknown", 29257, "host unknown", "host %.*s unknown");
DEFINE_ERROR_EXT(OB_ERR_WINDOW_NAME_IS_NOT_DEFINE, -5929, -1, "HY000", "Window name is not defined.", "Window name '%.*s' is not defined.");
DEFINE_ORACLE_ERROR(OB_ERR_OPEN_CURSORS_EXCEEDED, -5930, -1, "HY000", "maximum open cursors exceeded", 1000, "maximum open cursors exceeded");
DEFINE_ORACLE_ERROR(OB_ERR_ARG_INVALID, -5931, -1, "HY000", "argument is null, invalid, or out of range", 21560, "argument %.*s is null, invalid, or out of range");
DEFINE_ORACLE_ERROR(OB_ERR_ILL_NAME_STRING, -5932, -1, "HY000", "unexpected name string", 21560, "unexpected name string '%.*s'");
DEFINE_ERROR_EXT(OB_ERR_CTE_NEED_QUERY_BLOCKS, -5976, -1, "HY000", "Recursive Common Table Expression should have one or more non-recursive query blocks followed by one or more recursive ones", "Recursive Common Table Expression should have one or more non-recursive query blocks followed by one or more recursive ones: %s");
DEFINE_ERROR_EXT(OB_ERR_INCORRECT_VALUE_FOR_FUNCTION, -5936, ER_WRONG_VALUE_FOR_TYPE, "HY000", "Incorrect value for function", "Incorrect %.*s value: '%.*s' for function %.*s");
DEFINE_ERROR_EXT(OB_ERR_USER_EXCEED_RESOURCE, -5967, 1226, "42000", "User has exceeded the resource", "User '%.*s' has exceeded the '%s' resource (current value: %lu)");

////////////////////////////////////////////////////////////////
//error code for transaction, mvcc and commitlog -6001 ---- -7000
////////////////////////////////////////////////////////////////

DEFINE_ERROR(OB_TRANSACTION_SET_VIOLATION, -6001, -1, "25000", "Transaction set changed during the execution");
DEFINE_ORACLE_ERROR_EXT(OB_TRANS_ROLLBACKED, -6002, -1, "40000", "Transaction rollbacked", "transaction is rolled back", 24761, "transaction rolled back", "transaction rolled back");
DEFINE_ORACLE_ERROR(OB_ERR_EXCLUSIVE_LOCK_CONFLICT, -6003, ER_LOCK_WAIT_TIMEOUT, "HY000", "Lock wait timeout exceeded; try restarting transaction", 30006, "resource busy; acquire with WAIT timeout expired");
DEFINE_ORACLE_ERROR(OB_ERR_SHARED_LOCK_CONFLICT, -6004, 4012, "HY000", "Statement is timeout", 2049, "timeout: distributed transaction waiting for lock");
DEFINE_ERROR(OB_TRY_LOCK_ROW_CONFLICT, -6005, -1, "HY000", "Try lock row conflict");
DEFINE_ORACLE_ERROR(OB_ERR_EXCLUSIVE_LOCK_CONFLICT_NOWAIT, -6006, ER_LOCK_WAIT_TIMEOUT, "HY000", "Lock wait timeout exceeded; try restarting transaction", 54, "resource busy and acquire with NOWAIT specified or timeout expired");
DEFINE_ERROR(OB_CLOCK_OUT_OF_ORDER, -6201, -1, "25000", "Clock out of order");
DEFINE_ERROR(OB_MASK_SET_NO_NODE, -6203, -1, "25000", "Mask set has no node");
DEFINE_ERROR(OB_TRANS_HAS_DECIDED, -6204, -1, "HY000", "Transaction has been decided");
DEFINE_ERROR(OB_TRANS_INVALID_STATE, -6205, -1, "HY000", "Transaction state invalid");
DEFINE_ERROR(OB_TRANS_STATE_NOT_CHANGE, -6206, -1, "HY000", "Transaction state not changed");
DEFINE_ERROR(OB_TRANS_PROTOCOL_ERROR, -6207, -1, "HY000", "Transaction protocol error");
DEFINE_ERROR(OB_TRANS_INVALID_MESSAGE, -6208, -1, "HY000", "Transaction message invalid");
DEFINE_ERROR(OB_TRANS_INVALID_MESSAGE_TYPE, -6209, -1, "HY000", "Transaction message type invalid");
DEFINE_ERROR(OB_TRANS_TIMEOUT, -6210, 4012, "25000", "Transaction is timeout");
DEFINE_ORACLE_ERROR(OB_TRANS_KILLED, -6211, 6002, "25000", "Transaction is killed", 24761, "transaction rolled back: transaction is killed");
DEFINE_ERROR(OB_TRANS_STMT_TIMEOUT, -6212, 4012, "25000", "Statement is timeout");
DEFINE_ORACLE_ERROR(OB_TRANS_CTX_NOT_EXIST, -6213, 6002, "HY000", "Transaction context does not exist", 24761, "transaction rolled back: transaction context does not exist");
DEFINE_ORACLE_ERROR(OB_PARTITION_IS_FROZEN, -6214, 6002, "25000", "Partition is frozen", 24761, "transaction rolled back: partition is frozen");
DEFINE_ERROR(OB_PARTITION_IS_NOT_FROZEN, -6215, -1, "HY000", "Partition is not frozen");
DEFINE_ERROR(OB_TRANS_INVALID_LOG_TYPE, -6219, -1, "HY000", "Transaction invalid log type");
DEFINE_ERROR(OB_TRANS_SQL_SEQUENCE_ILLEGAL, -6220, -1, "HY000", "SQL sequence illegal");
DEFINE_ERROR(OB_TRANS_CANNOT_BE_KILLED, -6221, -1, "HY000", "Transaction context cannot be killed");
DEFINE_ORACLE_ERROR(OB_TRANS_STATE_UNKNOWN, -6222, -1, "HY000", "Transaction state unknown", 25405, "transaction status unknown");
DEFINE_ORACLE_ERROR(OB_TRANS_IS_EXITING, -6223, 6002, "25000", "Transaction exiting", 24761, "transaction rolled back: Transaction exiting");
DEFINE_ORACLE_ERROR(OB_TRANS_NEED_ROLLBACK, -6224, 6002, "25000", "transaction needs rollback", 24761, "transaction rolled back: transaction needs rollback");
DEFINE_ERROR(OB_TRANS_UNKNOWN, -6225, 4012, "25000", "Transaction result is unknown");
DEFINE_ERROR(OB_ERR_READ_ONLY_TRANSACTION, -6226, ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION, "25006", "Cannot execute statement in a READ ONLY transaction");
DEFINE_ERROR(OB_PARTITION_IS_NOT_STOPPED, -6227, -1, "HY000", "Partition is not stopped");
DEFINE_ERROR(OB_PARTITION_IS_STOPPED, -6228, -1, "HY000", "Partition has been stopped");
DEFINE_ERROR(OB_PARTITION_IS_BLOCKED, -6229, -1, "HY000", "Partition has been blocked");
DEFINE_ERROR(OB_TRANS_RPC_TIMEOUT, -6230, 4012, "25000", "transaction rpc timeout");
DEFINE_ERROR(OB_REPLICA_NOT_READABLE, -6231, -1, "HY000", "replica is not readable");
DEFINE_ERROR(OB_PARTITION_IS_SPLITTING, -6232, -1, "HY000", "Partition is splitting");
DEFINE_ERROR(OB_TRANS_COMMITED, -6233, -1, "HY000", "Transaction has been commited");
DEFINE_ORACLE_ERROR(OB_TRANS_CTX_COUNT_REACH_LIMIT, -6234, 6002, "25000", "transaction context count reach limit", 24761, "transaction rolled back: transaction context count reach limit");
DEFINE_ORACLE_ERROR(OB_TRANS_CANNOT_SERIALIZE, -6235, -1, "25000", "can't serialize access for this transaction", 8177, "can't serialize access for this transaction");
DEFINE_ERROR(OB_TRANS_WEAK_READ_VERSION_NOT_READY, -6236, -1, "HY000", "transaction weak read version is not ready");
DEFINE_ERROR(OB_GTS_STANDBY_IS_INVALID, -6237, -1, "HY000", "gts standby is invalid");
DEFINE_ERROR(OB_GTS_UPDATE_FAILED, -6238, -1, "HY000", "gts update failed");
DEFINE_ERROR(OB_GTS_IS_NOT_SERVING, -6239, -1, "HY000", "gts is not serving");
DEFINE_ERROR(OB_PG_PARTITION_NOT_EXIST, -6240, -1, "HY000", "pg partition not exist");
DEFINE_ERROR(OB_TRANS_STMT_NEED_RETRY, -6241, -1, "HY000", "transaction statement need retry");
DEFINE_ORACLE_ERROR(OB_SAVEPOINT_NOT_EXIST, -6242, ER_SP_DOES_NOT_EXIST, "42000", "savepoint does not exist", 1086, "savepoint does not exist");
DEFINE_ERROR(OB_TRANS_WAIT_SCHEMA_REFRESH, -6243, -1, "HY000", "local schema is not new enough, replaying logs of user table from standby cluster needs to wait for schema refreshing ");
DEFINE_ERROR(OB_TRANS_OUT_OF_THRESHOLD, -6244, -1, "HY000", "out of transaction threshold");
DEFINE_ERROR(OB_TRANS_XA_NOTA, -6245, ER_XAER_NOTA, "XAE04", "Unknown XID");
DEFINE_ERROR_EXT(OB_TRANS_XA_RMFAIL, -6246, ER_XAER_RMFAIL, "XAE07", "The command cannot be executed when global transaction is in this state", "The command cannot be executed when global transaction is in the %s state");
DEFINE_ERROR(OB_TRANS_XA_DUPID, -6247, ER_XAER_DUPID, "XAE08", "The XID already exists", "The XID already exists");
DEFINE_ERROR(OB_TRANS_XA_OUTSIDE, -6248, ER_XAER_OUTSIDE, "XAE09", "Some work is done outside global transaction", "Some work is done outside global transaction");
DEFINE_ERROR(OB_TRANS_XA_INVAL, -6249, ER_XAER_INVAL, "XAE05", "Invalid arguments were given", "XAER_INVAL: Invalid arguments (or unsupported command)");
DEFINE_ERROR(OB_TRANS_XA_RMERR, -6250, ER_XAER_RMERR, "XAE03", "Resource manager error occurred in the transaction branch", "XAER_RMERR: Fatal error occurred in the transaction branch - check your data for consistency");
DEFINE_ERROR(OB_TRANS_XA_PROTO, -6251, -1, "HY000", "Routine invoked in an improper context", "Routine invoked in an improper context");
DEFINE_ERROR(OB_TRANS_XA_RBROLLBACK, -6252, ER_XA_RBROLLBACK, "XA100", "Rollback was caused by an unspecified reason", "XA_RBROLLBACK: Transaction branch was rolled back");
DEFINE_ERROR(OB_TRANS_XA_RBTIMEOUT, -6253, ER_XA_RBTIMEOUT, "XA106", "Transaction branch took long", "XA_RBTIMEOUT: Transaction branch was rolled back: took too long");
DEFINE_ERROR(OB_TRANS_XA_RDONLY, -6254, -1, "HY000", "Transaction was read-only and has been committed", "Transaction was read-only and has been committed");
DEFINE_ERROR(OB_TRANS_XA_RETRY, -6255, -1, "HY000", "Routine returned with no effect and may be re-issued", "The resource manager is not able to commit the transaction branch at this time. Please retry later");
DEFINE_ERROR(OB_ERR_ROW_NOT_LOCKED, -6256, -1, "HY000", "Row has not been locked");
DEFINE_ERROR(OB_EMPTY_PG, -6257, -1, "HY000", "Empty partition group");
DEFINE_ORACLE_ERROR_EXT(OB_TRANS_XA_ERR_COMMIT, -6258, ER_XAER_RMFAIL, "XAE07", "RMFAIL: The command cannot be executed when global transaction is in this state", "RMFAIL: The command cannot be executed when global transaction is in the %s state", 2089, "COMMIT is not allowed in a subordinate session", "COMMIT is not allowed in a subordinate session");
DEFINE_ORACLE_ERROR(OB_ERR_RESTORE_POINT_EXIST, -6259, -1, "HY000", "Restore point %s already exists", 38778, "Restore point %s already exists");
DEFINE_ORACLE_ERROR(OB_ERR_RESTORE_POINT_NOT_EXIST, -6260, -1, "HY000", "Restore point %s does not exist", 38780, "Restore point %s does not exists");
DEFINE_ORACLE_ERROR(OB_ERR_BACKUP_POINT_EXIST, -6261, -1, "HY000", "Backup point %s already exists", 38778, "Restore point %s already exists");
DEFINE_ORACLE_ERROR(OB_ERR_BACKUP_POINT_NOT_EXIST, -6262, -1, "HY000", "Backup point %s does not exist", 38780, "Restore point %s does not exists");
DEFINE_ORACLE_ERROR(OB_ERR_RESTORE_POINT_TOO_MANY, -6263, -1, "HY000", "cannot create restore point - too many restore points", 38779, "cannot create restore point - too many restore points");
DEFINE_ORACLE_ERROR(OB_TRANS_XA_BRANCH_FAIL, -6264, -1, "HY000", "another session or branch in same transaction failed or finalized", 2051, "another session or branch in same transaction failed or finalized");

// for clog
DEFINE_ERROR(OB_LOG_ID_NOT_FOUND, -6301, -1, "HY000", "log id not found");
DEFINE_ERROR(OB_LSR_THREAD_STOPPED, -6302, -1, "HY000", "log scan runnable thread stop");
DEFINE_ERROR(OB_NO_LOG, -6303, -1, "HY000", "no log ever scanned");
DEFINE_ERROR(OB_LOG_ID_RANGE_ERROR, -6304, -1, "HY000", "log id range error");
DEFINE_ERROR(OB_LOG_ITER_ENOUGH, -6305, -1, "HY000", "iter scans enough files");
DEFINE_ERROR(OB_CLOG_INVALID_ACK, -6306, -1, "HY000", "invalid ack msg");
DEFINE_ERROR(OB_CLOG_CACHE_INVALID, -6307, -1, "HY000", "clog cache invalid");
DEFINE_ERROR(OB_EXT_HANDLE_UNFINISH, -6308, -1, "HY000", "external executor handle do not finish");
DEFINE_ERROR(OB_CURSOR_NOT_EXIST, -6309, -1, "HY000", "cursor not exist");
DEFINE_ERROR(OB_STREAM_NOT_EXIST, -6310, -1, "HY000", "stream not exist");
DEFINE_ERROR(OB_STREAM_BUSY, -6311, -1, "HY000", "stream busy");
DEFINE_ERROR(OB_FILE_RECYCLED, -6312, -1, "HY000", "file recycled");
DEFINE_ERROR(OB_REPLAY_EAGAIN_TOO_MUCH_TIME, -6313, -1, "HY000", "replay eagain cost too much time");
DEFINE_ERROR(OB_MEMBER_CHANGE_FAILED, -6314, -1, "HY000", "member change log sync failed");
DEFINE_ERROR(OB_NO_NEED_BATCH_CTX, -6315, -1, "HY000", "no need batch ctx");
DEFINE_ERROR(OB_TOO_LARGE_LOG_ID, -6316, -1, "HY000", "too large log id");
DEFINE_ERROR(OB_ALLOC_LOG_ID_NEED_RETRY, -6317, -1, "HY000", "alloc log id need retry");
DEFINE_ERROR(OB_TRANS_ONE_PC_NOT_ALLOWED, -6318, -1, "HY000", "transaction one pc not allowed");
DEFINE_ERROR(OB_LOG_NEED_REBUILD, -6319, -1, "HY000", "need rebuild");
DEFINE_ERROR(OB_TOO_MANY_LOG_TASK, -6320, -1, "HY000", "too many log tasks");
DEFINE_ERROR(OB_INVALID_BATCH_SIZE, -6321, -1, "HY000", "ob invalid batch size");
DEFINE_ERROR(OB_CLOG_SLIDE_TIMEOUT, -6322, -1, "HY000", "ob clog slide timeout");

////////////////////////////////////////////////////////////////
//error code for election -7000 ---- -7100
////////////////////////////////////////////////////////////////
DEFINE_ERROR(OB_ELECTION_WARN_LOGBUF_FULL, -7000, -1, "HY000", "The log buffer is full");
DEFINE_ERROR(OB_ELECTION_WARN_LOGBUF_EMPTY, -7001, -1, "HY000", "The log buffer is empty");
DEFINE_ERROR(OB_ELECTION_WARN_NOT_RUNNING, -7002, -1, "HY000", "The object is not running");
DEFINE_ERROR(OB_ELECTION_WARN_IS_RUNNING, -7003, -1, "HY000", "The object is running");
DEFINE_ERROR(OB_ELECTION_WARN_NOT_REACH_MAJORITY, -7004, -1, "HY000", "Election does not reach majority");
DEFINE_ERROR(OB_ELECTION_WARN_INVALID_SERVER, -7005, -1, "HY000", "The server is not valid");
DEFINE_ERROR(OB_ELECTION_WARN_INVALID_LEADER, -7006, -1, "HY000", "The leader is not valid");
DEFINE_ERROR(OB_ELECTION_WARN_LEADER_LEASE_EXPIRED, -7007, -1, "HY000", "The leader lease is expired");
DEFINE_ERROR(OB_ELECTION_WARN_INVALID_MESSAGE, -7010, -1, "HY000", "The message is not valid");
DEFINE_ERROR(OB_ELECTION_WARN_MESSAGE_NOT_INTIME, -7011, -1, "HY000", "The message is not intime");
DEFINE_ERROR(OB_ELECTION_WARN_NOT_CANDIDATE, -7012, -1, "HY000", "The server is not candidate");
DEFINE_ERROR(OB_ELECTION_WARN_NOT_CANDIDATE_OR_VOTER, -7013, -1, "HY000", "The server is not candidate or voter");
DEFINE_ERROR(OB_ELECTION_WARN_PROTOCOL_ERROR, -7014, -1, "HY000", "Election protocol error");
DEFINE_ERROR(OB_ELECTION_WARN_RUNTIME_OUT_OF_RANGE, -7015, -1, "HY000", "The task run time out of range");
DEFINE_ERROR(OB_ELECTION_WARN_LAST_OPERATION_NOT_DONE, -7021, -1, "HY000", "Last operation has not done");
DEFINE_ERROR(OB_ELECTION_WARN_CURRENT_SERVER_NOT_LEADER, -7022, -1, "HY000", "Current server is not leader");
DEFINE_ERROR(OB_ELECTION_WARN_NO_PREPARE_MESSAGE, -7024, -1, "HY000", "There is not prepare message");
DEFINE_ERROR(OB_ELECTION_ERROR_MULTI_PREPARE_MESSAGE, -7025, -1, "HY000", "There is more than one prepare message");
DEFINE_ERROR(OB_ELECTION_NOT_EXIST, -7026, -1, "HY000", "Election does not exist");
DEFINE_ERROR(OB_ELECTION_MGR_IS_RUNNING, -7027, -1, "HY000", "Election manager is running");
DEFINE_ERROR(OB_ELECTION_WARN_NO_MAJORITY_PREPARE_MESSAGE, -7029, -1, "HY000", "Election msg pool not have majority prepare message");
DEFINE_ERROR(OB_ELECTION_ASYNC_LOG_WARN_INIT, -7030, -1, "HY000", "Election async log init error");
DEFINE_ERROR(OB_ELECTION_WAIT_LEADER_MESSAGE, -7031, -1, "HY000", "Election waiting leader message");
DEFINE_ERROR(OB_ELECTION_GROUP_NOT_EXIST, -7032, -1, "HY000", "Election group not exist");
DEFINE_ERROR(OB_UNEXPECT_EG_VERSION, -7033, -1, "HY000", "unexpected eg_version");
DEFINE_ERROR(OB_ELECTION_GROUP_MGR_IS_RUNNING, -7034, -1, "HY000", "election_group_mgr is running");
DEFINE_ERROR(OB_ELECTION_MGR_NOT_RUNNING, -7035, -1, "HY000", "Election manager is not running");
DEFINE_ERROR(OB_ELECTION_ERROR_VOTE_MSG_CONFLICT, -7036, -1, "HY000", "Receive change leader msg and vote msg with same T1 timestamp");
DEFINE_ERROR(OB_ELECTION_ERROR_DUPLICATED_MSG, -7037, -1, "HY000", "Receive duplicated prepare/vote msg with same T1 timestamp");
DEFINE_ERROR(OB_ELECTION_WARN_T1_NOT_MATCH, -7038, -1, "HY000", "T1 timestamp is not match");

////////////////////////////////////////////////////////////////
//error code for replication group -7100 ---- -7200
////////////////////////////////////////////////////////////////
DEFINE_ERROR(OB_TRANSFER_TASK_COMPLETED, -7100, -1, "HY000", "transfer task completed");
DEFINE_ERROR(OB_TOO_MANY_TRANSFER_TASK, -7101, -1, "HY000", "too many transfer tasks");
DEFINE_ERROR(OB_TRANSFER_TASK_EXIST, -7102, -1, "HY000", "transfer task exist");
DEFINE_ERROR(OB_TRANSFER_TASK_NOT_EXIST, -7103, -1, "HY000", "transfer task not exist");
DEFINE_ERROR(OB_NOT_ALLOW_TO_REMOVE, -7104, -1, "HY000", "not allow to remove");
DEFINE_ERROR(OB_RG_NOT_MATCH, -7105, -1, "HY000", "replication group not match");
DEFINE_ERROR(OB_TRANSFER_TASK_ABORTED, -7106, -1, "HY000", "transfer task aborted");
DEFINE_ERROR(OB_TRANSFER_INVALID_MESSAGE, -7107, -1, "HY000", "transfer invalid message");
DEFINE_ERROR(OB_TRANSFER_CTX_TS_NOT_MATCH, -7108, -1, "HY000", "transfer ctx_ts not match");

////////////////////////////////////////////////////////////////
// !!! Fatal errors and the client should close the connection, -8000 ~ -8999
////////////////////////////////////////////////////////////////
DEFINE_ERROR(OB_SERVER_IS_INIT, -8001, -1, "08004", "Server is initializing");
DEFINE_ERROR(OB_SERVER_IS_STOPPING, -8002, -1, "08004", "Server is stopping");
DEFINE_ERROR(OB_PACKET_CHECKSUM_ERROR, -8003, -1, "08004", "Packet checksum error");
DEFINE_ERROR(OB_PACKET_CLUSTER_ID_NOT_MATCH, -8004, -1, "08004", "Packet cluster_id not match");

////////////////////////////////////////////////////////////////
// backup and restore error codes
////////////////////////////////////////////////////////////////
DEFINE_ERROR(OB_URI_ERROR, -9001, -1, "HY000", "URI error");
DEFINE_ERROR(OB_FINAL_MD5_ERROR, -9002, -1, "HY000", "OSS file MD5 error");
DEFINE_ERROR(OB_OSS_ERROR, -9003, -1, "HY000", "OSS error");
DEFINE_ERROR(OB_INIT_MD5_ERROR, -9004, -1, "HY000", "Init MD5 fail");
DEFINE_ERROR(OB_OUT_OF_ELEMENT, -9005, -1, "HY000", "Out of element");
DEFINE_ERROR(OB_UPDATE_MD5_ERROR, -9006, -1, "HY000", "Update MD5 fail");
DEFINE_ERROR(OB_FILE_LENGTH_INVALID, -9007, -1, "HY000", "Invalid OSS file length");
DEFINE_ERROR(OB_NOT_READ_ALL_DATA, -9008, -1, "HY000", "Read all data fail");
DEFINE_ERROR(OB_BUILD_MD5_ERROR, -9009, -1, "HY000", "Build MD5 fail");
DEFINE_ERROR(OB_MD5_NOT_MATCH, -9010, -1, "HY000", "OSS file MD5 not match");
DEFINE_ERROR(OB_BACKUP_FILE_NOT_EXIST, -9011, -1, "HY000", "cannot find backup file");
DEFINE_ERROR(OB_OSS_DATA_VERSION_NOT_MATCHED, -9012, -1, "HY000", "Can not get data version from timestamp");
DEFINE_ERROR(OB_OSS_WRITE_ERROR, -9013, -1, "HY000", "Write OSS file error");
DEFINE_ERROR(OB_RESTORE_IN_PROGRESS, -9014, -1, "HY000", "Another restore is in progress");
DEFINE_ERROR(OB_AGENT_INITING_BACKUP_COUNT_ERROR, -9015, -1, "HY000", "agent initing backup count error");
DEFINE_ERROR(OB_CLUSTER_NAME_NOT_EQUAL, -9016, -1, "HY000", "ob cluster name not equal");
DEFINE_ERROR(OB_RS_LIST_INVAILD, -9017, -1, "HY000", "rs list invalid");
DEFINE_ERROR(OB_AGENT_HAS_FAILED_TASK, -9018, -1, "HY000", "agent has failed task");
DEFINE_ERROR(OB_RESTORE_PARTITION_IS_COMPELETE, -9019, -1, "HY000", "restore partition is compelete");
DEFINE_ERROR(OB_RESTORE_PARTITION_TWICE, -9020, -1, "HY000", "restore partition twice");
DEFINE_ERROR(OB_STOP_DROP_SCHEMA, -9022, -1, "HY000", "physical backup switch is on");
DEFINE_ERROR(OB_CANNOT_START_LOG_ARCHIVE_BACKUP, -9023, -1, "HY000", "cannot start log archive backup");
DEFINE_ERROR(OB_ALREADY_NO_LOG_ARCHIVE_BACKUP, -9024, -1, "HY000", "log archive backup is already disabled");
DEFINE_ERROR(OB_LOG_ARCHIVE_BACKUP_INFO_NOT_EXIST, -9025, -1, "HY000", "log archive backup info not exists");
DEFINE_ERROR(OB_INVALID_BACKUP_DEST, -9026, -1, "HY000", "backup destination is not valid");
DEFINE_ERROR(OB_LOG_ARCHIVE_INTERRUPTED, -9027, -1, "HY000", "ob log archive interrupted");
DEFINE_ERROR(OB_LOG_ARCHIVE_STAT_NOT_MATCH, -9028, -1, "HY000", "ob log archive stat not match");
DEFINE_ERROR(OB_LOG_ARCHIVE_NOT_RUNNING, -9029, -1, "HY000", "log archive is not running");
DEFINE_ERROR(OB_LOG_ARCHIVE_INVALID_ROUND, -9030, -1, "HY000", "log archive invalid round");
DEFINE_ERROR(OB_REPLICA_CANNOT_BACKUP, -9031, -1, "HY000", "Cannot backup ob replica");
DEFINE_ERROR(OB_BACKUP_INFO_NOT_EXIST, -9032, -1, "HY000", "backup info not exists");
DEFINE_ERROR(OB_BACKUP_INFO_NOT_MATCH, -9033, -1, "HY000", "Backup meta info stored in system dictionary does not match with current system status");
DEFINE_ERROR(OB_LOG_ARCHIVE_ALREADY_STOPPED, -9034, -1, "HY000", "log archive already stopped");
DEFINE_ERROR(OB_RESTORE_INDEX_FAILED, -9035, -1, "HY000", "restore index failed");
DEFINE_ERROR(OB_BACKUP_IN_PROGRESS, -9036, -1, "HY000", "Backup is in progress");
DEFINE_ERROR(OB_INVALID_LOG_ARCHIVE_STATUS, -9037, -1, "HY000", "log archive status is not valid");
DEFINE_ERROR(OB_CANNOT_ADD_REPLICA_DURING_SET_MEMBER_LIST, -9038, -1, "HY000", "Cannot add replica during set member list in restore");
DEFINE_ERROR(OB_LOG_ARCHIVE_LEADER_CHANGED, -9039, -1, "HY000", "pg log archive leader changed");
DEFINE_ERROR_EXT(OB_BACKUP_CAN_NOT_START, -9040, -1, "HY000", "backup can not start", "backup can not start, because %s");
DEFINE_ERROR(OB_CANCEL_BACKUP_NOT_ALLOWED, -9041, -1, "HY000", "cancel backup do not allow");
DEFINE_ERROR(OB_BACKUP_DATA_VERSION_GAP_OVER_LIMIT, -9042, -1, "HY000", "backup data version gap over limit");
DEFINE_ERROR(OB_PG_LOG_ARCHIVE_STATUS_NOT_INIT, -9043, -1, "HY000", "pg log archive status is still invalid");
DEFINE_ERROR(OB_BACKUP_DELETE_DATA_IN_PROGRESS, -9044, -1, "HY000", "delete backup data is in progress");
DEFINE_ERROR(OB_BACKUP_DELETE_BACKUP_SET_NOT_ALLOWED, -9045, -1, "HY000", "delete backup set do not allow");
DEFINE_ERROR(OB_INVALID_BACKUP_SET_ID, -9046, -1, "HY000", "backup set id is not valid");
DEFINE_ERROR(OB_BACKUP_INVALID_PASSWORD, -9047, -1, "HY000", "invalid password for backup");
DEFINE_ERROR(OB_ISOLATED_BACKUP_SET, -9048, -1, "HY000", "backup set is isolated by two log archive round");
DEFINE_ERROR(OB_CANNOT_CANCEL_STOPPED_BACKUP, -9049, -1, "HY000", "backup status is stopped, can not cancel");
DEFINE_ERROR(OB_BACKUP_BACKUP_CAN_NOT_START, -9050, -1, "HY000", "no backup data to be backuped up");
DEFINE_ERROR(OB_BACKUP_MOUNT_FILE_NOT_VALID, -9051, -1, "HY000", "backup mount file is not valid");
DEFINE_ERROR(OB_BACKUP_CLEAN_INFO_NOT_MATCH, -9052, -1, "HY000", "backup clean info not match");
DEFINE_ERROR(OB_CANCEL_DELETE_BACKUP_NOT_ALLOWED, -9053, -1, "HY000", "cancel delete backup do not allow");
DEFINE_ERROR(OB_BACKUP_CLEAN_INFO_NOT_EXIST, -9054, -1, "HY000", "backup clean info not exists");
DEFINE_ERROR_EXT(OB_CANNOT_SET_BACKUP_REGION, -9057, -1, "HY000", "can not set backup region", "can not set backup region, because %s");
DEFINE_ERROR_EXT(OB_CANNOT_SET_BACKUP_ZONE, -9058, -1, "HY000", "can not set backup zone", "can not set backup zone, because %s");
DEFINE_ERROR(OB_BACKUP_BACKUP_REACH_MAX_BACKUP_TIMES, -9059, -1, "HY000", "backup backup has reached max backup times");
DEFINE_ERROR_DEP(OB_COS_ERROR, -9060, -1, "HY000", "COS error");
DEFINE_ERROR_DEP(OB_IO_LIMIT, -9061, -1, "HY000", "IO limit");
DEFINE_ERROR(OB_BACKUP_BACKUP_REACH_COPY_LIMIT, -9062, -1, "HY000", "reach backup backup copy limit");
DEFINE_ERROR(OB_BACKUP_IO_PROHIBITED, -9063, -1, "HY000", "backup io is prohibited");
DEFINE_ERROR(OB_ARCHIVE_LOG_NOT_CONTINUES_WITH_DATA, -9064, -1, "HY000", "the archive log and backup data are not continuous");

////////////////////////////////////////////////////////////////
//error code for STORAGE3.0 -9100 ~
////////////////////////////////////////////////////////////////
DEFINE_ERROR(OB_NO_SUCH_FILE_OR_DIRECTORY, -9100, -1, "HY000", "no such file or directory");
DEFINE_ERROR(OB_FILE_OR_DIRECTORY_EXIST, -9101, -1, "HY000", "file or directory already exist");


////////////////////////////////////////////////////////////////
//error code for PL/SQL  -9500 ~ -10000
//!!! -20000/-21000/-32491 shoud not in here. but we can not remove it now because of compat. ONLY PL SQL ERROR PUT HERE!!!
////////////////////////////////////////////////////////////////
DEFINE_ORACLE_ERROR_V2_EXT(OB_SP_RAISE_APPLICATION_ERROR, -20000, -1, "HY000", "The stored procedure 'raise_application_error' was called which causes this error to be generated", "-%05ld: %.*s", 20000, "ORA-20000: The stored procedure 'raise_application_error' was called which causes this error to be generated", "ORA%06ld: %.*s");
DEFINE_ORACLE_ERROR_EXT(OB_SP_RAISE_APPLICATION_ERROR_NUM, -21000, -1, "HY000", "error number argument to raise_application_error of stringstring is out of range", "error number argument to raise_application_error of '%d' is out of range", 21000, "error number argument to raise_application_error of stringstring is out of range", "error number argument to raise_application_error of '%d' is out of range");
DEFINE_ORACLE_ERROR(OB_ERR_FLASHBACK_QUERY_WITH_UPDATE, -32491, -1, "HY000", "snapshot expression not allowed here", 8187, "snapshot expression not allowed here");

DEFINE_PLS_ERROR(OB_ERR_DUPLICATE_HAVING_CLAUSE_IN_TABLE_EXPRESSION, -9501, -1, "HY000", "Duplicate having-clause in table expression", 119, "Duplicate having-clause in table expression");
DEFINE_PLS_ERROR(OB_ERR_INOUT_PARAM_PLACEMENT_NOT_PROPERLY, -9502, -1, "HY000", "OUT and IN/OUT modes cannot be used in this context", 254, "OUT and IN/OUT modes cannot be used in this context");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_OBJECT_NOT_FOUND, -9503, -1, "HY000", "object not found", "object '%.*s' of type %.*s not found in schema '%.*s'", 31603, "object not found", "object '%.*s' of type %.*s not found in schema '%.*s'");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_INVALID_INPUT_VALUE, -9504, -1, "HY000", "invalid input value", "invalid input value %.*s for parameter %.*s in function %.*s", 31600, "invalid input value", "invalid input value %.*s for parameter %.*s in function %.*s");
DEFINE_PLS_ERROR(OB_ERR_GOTO_BRANCH_ILLEGAL, -9505, ER_SP_LILABEL_MISMATCH, "42000", "no matching label: %.*s", 375, "illegal GOTO statement; this GOTO cannot branch to label '%.*s'");
DEFINE_PLS_ERROR_EXT(OB_ERR_ONLY_SCHEMA_LEVEL_ALLOW, -9506, -1, "HY000", "Only schema-level programs allow AUTHID or DEFAULT COLLATION clause", "Only schema-level programs allow %s", 157, "Only schema-level programs allow AUTHID or DEFAULT COLLATION clause", "Only schema-level programs allow %s");
DEFINE_PLS_ERROR_EXT(OB_ERR_DECL_MORE_THAN_ONCE, -9507, -1, "HY000", "at most one declaration for identifier is permitted", "at most one declaration for '%.*s' is permitted", 371, "at most one declaration for identifier is permitted", "at most one declaration for '%.*s' is permitted");
DEFINE_PLS_ERROR(OB_ERR_DUPLICATE_FILED, -9508, -1, "HY000", "duplicate fields in RECORD,TABLE or argument list are not permitted", 410, "duplicate fields in RECORD,TABLE or argument list are not permitted");
DEFINE_PLS_ERROR(OB_ERR_AUTONOMOUS_TRANSACTION_ILLEGAL, -9509, -1, "HY000", "Pragma AUTONOMOUS_TRANSACTION cannot be specified here", 710, "Pragma AUTONOMOUS_TRANSACTION cannot be specified here");
DEFINE_PLS_ERROR(OB_ERR_EXIT_CONTINUE_ILLEGAL, -9510, -1, "HY000", "illegal EXIT/CONTINUE statement; it must appear inside a loop", 376, "illegal EXIT/CONTINUE statement; it must appear inside a loop");
DEFINE_PLS_ERROR_EXT(OB_ERR_LABEL_ILLEGAL, -9512, -1, "HY000", "EXIT/CONTINUE label must label a LOOP statement", "EXIT/CONTINUE label '%.*s' must label a LOOP statement", 373, "EXIT/CONTINUE label must label a LOOP statement", "EXIT/CONTINUE label '%.*s' must label a LOOP statement");
DEFINE_PLS_ERROR(OB_ERR_CURSOR_LEFT_ASSIGN, -9513, -1, "HY000", "expression '%.*s' is inappropriate as the left hand side of an assignment statement", 321, "expression '%.*s' is inappropriate as the left hand side of anassignment statement");
DEFINE_PLS_ERROR(OB_ERR_INIT_NOTNULL_ILLEGAL, -9514, -1, "HY000", "a variable declared NOT NULL must have an initialization assignment", 218, "a variable declared NOT NULL must have an initialization assignment");
DEFINE_PLS_ERROR(OB_ERR_INIT_CONST_ILLEGAL, -9515, -1, "HY000", "Constant declarations should contain initialization assignments", 322, "Constant declarations should contain initialization assignments");
DEFINE_PLS_ERROR(OB_ERR_CURSOR_VAR_IN_PKG, -9516, -1, "HY000", "Cursor Variables cannot be declared as part of a package", 994, "Cursor Variables cannot be declared as part of a package");
DEFINE_PLS_ERROR(OB_ERR_LIMIT_CLAUSE, -9518, -1, "HY000", "value in LIMIT clause: \'%.*s\' use is invalid", 438, "value in LIMIT clause: \'%.*s\' use is invalid");
DEFINE_PLS_ERROR(OB_ERR_EXPRESSION_WRONG_TYPE, -9519, -1, "HY000", "expression is of wrong type", 382, "expression is of wrong type");
DEFINE_PLS_ERROR_EXT(OB_ERR_TYPE_SPEC_NOT_EXIST, -9520, -1, "HY000", "cannot compile type body without its specification", "cannot compile body of '%.*s' without its specification", 304, "cannot compile type body without its specification", "cannot compile body of '%.*s' without its specification");
DEFINE_PLS_ERROR_EXT(OB_ERR_TYPE_SPEC_NO_ROUTINE, -9521, -1, "HY000", "subprogram is declared in an object type body and must be defined in the object type specification", "subprogram '%.*s' is declared in an object type body and must be defined in the object type specification", 539, "subprogram is declared in an object type body and must be defined in the object type specification", "subprogram '%.*s' is declared in an object type body and must be defined in the object type specification");
DEFINE_PLS_ERROR_EXT(OB_ERR_TYPE_BODY_NO_ROUTINE, -9522, -1, "HY000", "subprogram or cursor is declared in an object type specification and must be defined in the object type body", "subprogram or cursor '%.*s' is declared in an object type specification and must be defined in the object type body", 538, "subprogram or cursor is declared in an object type specification and must be defined in the object type body", "subprogram or cursor '%.*s' is declared in an object type specification and must be defined in the object type body");
DEFINE_PLS_ERROR(OB_ERR_IDENTIFIER_TOO_LONG, -9523, -1, "HY000", "identifier '%.*s' too long", 114, "identifier '%.*s' too long");

////////////////////////////////////////////////////////////////
// !!! text/blob || clob/blob erro code
// for compat we cant not remove this errno!!!!
////////////////////////////////////////////////////////////////
DEFINE_ORACLE_ERROR(OB_CLOB_ONLY_SUPPORT_WITH_MULTIBYTE_FUN, -22998, -1, "HY000", "CLOB or NCLOB in multibyte character set not supported", 22998, "CLOB or NCLOB in multibyte character set not supported");
DEFINE_ORACLE_ERROR_EXT(OB_ERR_UPDATE_ON_EXPR, -38104, -1, "HY000", "Columns referenced in the ON Clause cannot be updated", "Columns referenced in the ON Clause cannot be updated:'%.*s'.'%.*s'", 38104, "Columns referenced in the ON Clause cannot be updated", "Columns referenced in the ON Clause cannot be updated:'%.*s'.'%.*s'");
DEFINE_ORACLE_ERROR(OB_ERR_UPDATE_TWICE, -30926, -1, "HY000", "unable to get a stable set of rows in the source tables", 30926, "unable to get a stable set of rows in the source tables");
DEFINE_ORACLE_ERROR(OB_ERR_SPECIFIED_ROW_NO_LONGER_EXISTS, -38105, -1, "HY000", "specified row no longer exists", 8006, "specified row no longer exists");